qfai 1.7.6 → 1.7.7

package/dist/cli/index.mjs

@@ -465,6 +465,15 @@ function normalizeUiux(raw, configPath, issues) {
       );
     }
   }
+  if (raw.phase1ReleaseDate !== void 0) {
+    if (typeof raw.phase1ReleaseDate === "string" && !isNaN(new Date(raw.phase1ReleaseDate).getTime())) {
+      result.phase1ReleaseDate = raw.phase1ReleaseDate;
+    } else {
+      issues.push(
+        configIssue(configPath, "uiux.phase1ReleaseDate \u306F\u6709\u52B9\u306A\u65E5\u4ED8\u6587\u5B57\u5217\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;
@@ -489,6 +498,12 @@ function normalizeUiux(raw, configPath, issues) {
       result.audit = audit;
     }
   }
+  if (raw.migration !== void 0) {
+    const migration = normalizeUiuxMigration(raw.migration, configPath, issues);
+    if (migration) {
+      result.migration = migration;
+    }
+  }
   return Object.keys(result).length > 0 ? result : void 0;
 }
 function normalizeUiuxAudit(raw, configPath, issues) {
@@ -548,6 +563,23 @@ function normalizeUiuxAudit(raw, configPath, issues) {
   }
   return Object.keys(result).length > 0 ? result : void 0;
 }
+function normalizeUiuxMigration(raw, configPath, issues) {
+  if (!isRecord(raw)) {
+    issues.push(configIssue(configPath, "uiux.migration \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.strict !== void 0) {
+    if (typeof raw.strict === "boolean") {
+      result.strict = raw.strict;
+    } else {
+      issues.push(
+        configIssue(configPath, "uiux.migration.strict \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 normalizeRenderEvidence(raw, configPath, issues) {
   if (!isRecord(raw)) {
     issues.push(
@@ -1684,8 +1716,8 @@ import { readFile as readFile5 } from "fs/promises";
 import path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function resolveToolVersion() {
-  if ("1.7.6".length > 0) {
-    return "1.7.6";
+  if ("1.7.7".length > 0) {
+    return "1.7.7";
   }
   try {
     const packagePath = resolvePackageJsonPath();
@@ -3428,8 +3460,8 @@ function buildCopilotInstructions() {
 }
 
 // src/cli/commands/prototyping.ts
-import { mkdir as mkdir4, readFile as readFile9, writeFile as writeFile3 } from "fs/promises";
-import path17 from "path";
+import { mkdir as mkdir4, readFile as readFile11, writeFile as writeFile3 } from "fs/promises";
+import path20 from "path";
 
 // src/core/prototyping/uiFidelityAutogen.ts
 import { readFile as readFile8 } from "fs/promises";
@@ -4068,256 +4100,715 @@ var RUNTIME_HEAVY_CHECKS = [
 ];
 var FULL_HARNESS_OBLIGATIONS = [...STATIC_OBLIGATIONS, ...RUNTIME_HEAVY_CHECKS];
 
-// src/cli/commands/prototyping.ts
-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) {
-      error(
-        `prototyping: --autogen-only \u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u3059\u304C --autogen-ui-fidelity / ${ENV_AUTOGEN}=1 \u304C\u3042\u308A\u307E\u305B\u3093\u3002`
-      );
-      return 2;
-    }
-    info(
-      `prototyping: --autogen-ui-fidelity or ${ENV_AUTOGEN}=1 \u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002\u4F55\u3082\u5B9F\u884C\u3057\u307E\u305B\u3093\u3002`
-    );
-    const evidencePath2 = resolveEvidencePath(options.root, options.evidenceOut);
-    const toolVersion2 = await resolveToolVersion();
-    let existingEvidence2 = {};
-    try {
-      const raw = await readFile9(evidencePath2, "utf-8");
-      const parsed = JSON.parse(raw);
-      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-        existingEvidence2 = parsed;
-      }
-    } catch {
-    }
-    const skippedEvidence = emitUiFidelity({
-      evidence: existingEvidence2,
-      toolVersion: toolVersion2,
-      command: "qfai prototyping",
-      baseUrl: "",
-      status: "skipped",
-      reason: "autogen not enabled (--autogen-ui-fidelity or env not set)"
-    });
-    const renderBundle2 = await maybeWriteRenderBundle(
-      toolVersion2,
-      "qfai prototyping --render-evidence",
-      renderOptions,
-      false
-    );
-    await writeEvidence(
-      evidencePath2,
-      applyRenderEvidence(
-        skippedEvidence,
-        await resolveAttachedRenderEvidence(renderBundle2, renderOptions, false)
-      )
-    );
-    return 0;
-  }
-  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 evidencePath = resolveEvidencePath(options.root, options.evidenceOut);
-  info(`prototyping: autogen uiFidelity \u3092\u5B9F\u884C\u3057\u307E\u3059 (baseUrl=${baseUrl})`);
-  let existingEvidence = {};
+// src/core/prototyping/discussionReader.ts
+import { readFile as readFile9 } from "fs/promises";
+import path17 from "path";
+import { parse as parseYaml3 } from "yaml";
+var VALID_MODES = /* @__PURE__ */ new Set(["low-cost", "standard", "full-harness"]);
+var SIDECAR_FILENAME = "prototyping.yaml";
+async function readDiscussionRecommendation(discussionPackDir) {
+  const filePath = path17.join(discussionPackDir, SIDECAR_FILENAME);
+  let raw;
   try {
-    const raw = await readFile9(evidencePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      existingEvidence = parsed;
-    }
+    raw = await readFile9(filePath, "utf-8");
   } catch {
+    return { recommended_mode: null, rationale: null };
   }
-  const routeHints = extractRouteHintsFromEvidence(existingEvidence);
-  let result;
+  let doc;
   try {
-    result = await autogenerateUiFidelity(options.root, config, baseUrl, routeHints);
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    warn(`prototyping: autogen failed - ${reason}`);
-    const failedEvidence = emitUiFidelity({
-      evidence: existingEvidence,
-      toolVersion,
-      command: "qfai prototyping --autogen-ui-fidelity",
-      baseUrl,
-      status: "failed",
-      reason
-    });
-    const renderBundle2 = await maybeWriteRenderBundle(
-      toolVersion,
-      "qfai prototyping --render-evidence",
-      renderOptions,
-      true
-    );
-    await writeEvidence(
-      evidencePath,
-      applyRenderEvidence(
-        failedEvidence,
-        await resolveAttachedRenderEvidence(renderBundle2, renderOptions, true)
-      )
-    );
-    info(`prototyping: wrote evidence with status=failed to ${evidencePath}`);
-    return options.autogenOnly ? 1 : 0;
-  }
-  const hasScreens = result.screens.length > 0;
-  const allRoutesFailed = result.crawled.every((r) => r.status === "failed");
-  if (!hasScreens || allRoutesFailed) {
-    const uiContractsPath = path17.join(resolvePath(options.root, config, "contractsDir"), "ui");
-    const reason = !hasScreens ? `no screens found in ${uiContractsPath}` : "all route crawls failed";
-    warn(`prototyping: autogen produced no usable data - ${reason}`);
-    const failedEvidence = emitUiFidelity({
-      evidence: existingEvidence,
-      toolVersion,
-      command: "qfai prototyping --autogen-ui-fidelity",
-      baseUrl,
-      status: "failed",
-      crawled: result.crawled,
-      reason
-    });
-    const renderBundle2 = await maybeWriteRenderBundle(
-      toolVersion,
-      "qfai prototyping --render-evidence",
-      renderOptions,
-      true
-    );
-    await writeEvidence(
-      evidencePath,
-      applyRenderEvidence(
-        failedEvidence,
-        await resolveAttachedRenderEvidence(renderBundle2, renderOptions, true)
-      )
-    );
-    info(`prototyping: wrote evidence with status=failed to ${evidencePath}`);
-    return options.autogenOnly ? 1 : 0;
-  }
-  const successEvidence = emitUiFidelity({
-    evidence: existingEvidence,
-    toolVersion,
-    command: "qfai prototyping --autogen-ui-fidelity",
-    baseUrl,
-    status: "success",
-    screens: result.screens,
-    crawled: result.crawled
-  });
-  const renderBundle = await maybeWriteRenderBundle(
-    toolVersion,
-    "qfai prototyping --render-evidence",
-    renderOptions,
-    true
-  );
-  await writeEvidence(
-    evidencePath,
-    applyRenderEvidence(
-      successEvidence,
-      await resolveAttachedRenderEvidence(renderBundle, renderOptions, true)
-    )
-  );
-  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";
-  info(
-    `prototyping: autogen success - ${result.screens.length} screens, routes ok=${routeOkCount} fail=${routeFailCount}, avg coverage=${avgCoverage}`
-  );
-  info(`prototyping: wrote evidence to ${evidencePath}`);
-  return 0;
-}
-function resolveBaseUrl(options) {
-  if (options.baseUrl) {
-    return options.baseUrl;
-  }
-  const envUrl = process.env.QFAI_PROTOTYPE_BASE_URL;
-  if (envUrl && envUrl.trim().length > 0) {
-    return envUrl.trim();
+    doc = parseYaml3(raw);
+  } catch {
+    return { recommended_mode: null, rationale: null };
   }
-  return null;
-}
-function resolveEvidencePath(root, explicit) {
-  if (explicit) {
-    return path17.isAbsolute(explicit) ? explicit : path17.resolve(root, explicit);
+  if (!doc || typeof doc !== "object" || Array.isArray(doc)) {
+    return { recommended_mode: null, rationale: null };
   }
-  return path17.resolve(root, DEFAULT_EVIDENCE_PATH);
-}
-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 record2 = doc;
+  const prototyping = record2.prototyping;
+  if (!prototyping || typeof prototyping !== "object" || Array.isArray(prototyping)) {
+    return { recommended_mode: null, rationale: null };
   }
-  const renderBundle = await buildRenderBundle(toolVersion, command, options, autogenEnabled);
-  await writeRenderBundle(renderBundle.path, renderBundle.bundle);
-  return renderBundle;
+  const section = prototyping;
+  const rawMode = typeof section.recommended_mode === "string" ? section.recommended_mode.trim() : null;
+  const rationale = typeof section.rationale === "string" ? section.rationale.trim() : null;
+  const recommended_mode = rawMode && VALID_MODES.has(rawMode) ? rawMode : null;
+  return { recommended_mode, rationale };
 }
-function applyRenderEvidence(evidence, renderEvidence) {
-  if (!renderEvidence) {
-    return evidence;
+
+// src/core/prototyping/precedenceResolver.ts
+var VALID_MODES2 = /* @__PURE__ */ new Set([
+  "default",
+  "standard",
+  "low-cost",
+  "full-harness"
+]);
+function isPrototypingMode(value) {
+  return VALID_MODES2.has(value);
+}
+var SYSTEM_DEFAULT_MODE = "standard";
+function resolvePrecedence(input) {
+  const { cliMode, discussion } = input;
+  const rawRecommended = discussion?.recommended_mode ?? null;
+  const recommended_mode = rawRecommended && isPrototypingMode(rawRecommended) ? rawRecommended : null;
+  if (cliMode) {
+    return {
+      effective_mode: cliMode,
+      mode_source: "cli-override",
+      recommended_mode,
+      rationale: "CLI override"
+    };
   }
-  return {
-    ...evidence,
-    renderEvidence
-  };
-}
-async function resolveAttachedRenderEvidence(renderBundle, options, autogenEnabled) {
-  if (!options.renderEvidence) {
-    return void 0;
+  if (recommended_mode) {
+    return {
+      effective_mode: recommended_mode,
+      mode_source: "discussion-recommendation",
+      recommended_mode,
+      rationale: discussion?.rationale ?? "discussion recommendation"
+    };
   }
-  return renderBundle?.renderEvidence ?? await buildRenderEvidenceRecord(
-    options,
-    autogenEnabled,
-    resolveRenderOutPath(options.root, options.renderOut)
-  );
-}
-async function buildRenderBundle(toolVersion, command, options, autogenEnabled) {
-  const outPath = resolveRenderOutPath(options.root, options.renderOut);
-  const renderEvidence = await buildRenderEvidenceRecord(options, autogenEnabled, outPath);
   return {
-    path: outPath,
-    bundle: {
-      meta: {
-        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        toolVersion,
-        commands: [command]
-      },
-      renderEvidence
-    },
-    renderEvidence
+    effective_mode: SYSTEM_DEFAULT_MODE,
+    mode_source: "default",
+    recommended_mode: null,
+    rationale: "system default"
   };
 }
-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;
+
+// src/core/prototyping/modeLogger.ts
+var EVIDENCE_EXPECTATIONS = {
+  "low-cost": "L1/L2",
+  standard: "L2/L3",
+  "full-harness": "L3/L4/L5"
+};
+function formatModeLog(resolution) {
   return {
-    ...options,
-    renderEvidence: options.renderEvidence || configRenderEvidence?.enabled === true,
-    renderViewports: mergedViewports,
-    renderFailOpen: options.renderFailOpen ?? configRenderEvidence?.failOpen === true,
-    ...renderOut ? { renderOut } : {},
-    ...baseUrl ? { baseUrl } : {}
+    mode_source: resolution.mode_source,
+    recommended_mode: resolution.recommended_mode,
+    effective_mode: resolution.effective_mode,
+    rationale: resolution.rationale,
+    evidence_expectations: EVIDENCE_EXPECTATIONS[resolution.effective_mode] ?? "L2/L3"
   };
 }
-function resolveRenderOutPath(root, explicit) {
-  if (explicit) {
-    return path17.isAbsolute(explicit) ? explicit : path17.resolve(root, explicit);
-  }
-  return path17.resolve(root, ".qfai/evidence/render.json");
-}
-async function buildRenderEvidenceRecord(options, autogenEnabled, outputPath) {
-  const viewports = normalizeRenderViewports(options.renderViewports);
+
+// src/core/discussionPack.ts
+import { readFile as readFile10, stat as stat2 } from "fs/promises";
+import path19 from "path";
+
+// src/core/packLocator.ts
+import { readdir as readdir5 } from "fs/promises";
+import path18 from "path";
+var PACK_RULES = {
+  discussion: {
+    prefix: "discussion",
+    legacyPattern: /^discussion-\d{4}$/i,
+    parkedLegacyPattern: /^discussion-legacy-[a-z0-9][a-z0-9-]*$/i
+  }
+};
+var PACK_TIMESTAMP_RE = /^\d{17}$/;
+function parsePackTimestamp(kind, name) {
+  const rule = PACK_RULES[kind];
+  const prefix = `${rule.prefix}-`;
+  if (!name.startsWith(prefix)) {
+    return null;
+  }
+  const suffix = name.slice(prefix.length);
+  if (!PACK_TIMESTAMP_RE.test(suffix)) {
+    return null;
+  }
+  return suffix;
+}
+function validatePackName(kind, name) {
+  const rule = PACK_RULES[kind];
+  const normalizedPrefix = `${rule.prefix}-`;
+  const isPrefixed = name.toLowerCase().startsWith(normalizedPrefix);
+  const timestamp = parsePackTimestamp(kind, name);
+  const isCanonical = timestamp !== null;
+  const isLegacy = !isCanonical && rule.legacyPattern.test(name);
+  const isParkedLegacy = !isCanonical && rule.parkedLegacyPattern.test(name);
+  const isDangerous = isPrefixed && !isCanonical && !isLegacy && !isParkedLegacy;
+  const status = isCanonical ? "canonical" : isLegacy ? "legacy" : isDangerous ? "dangerous" : "other";
+  return {
+    kind,
+    name,
+    status,
+    isCanonical,
+    isLegacy,
+    isDangerous,
+    isPrefixed,
+    timestamp
+  };
+}
+async function findPacks(rootDir, kind) {
+  try {
+    const entries = await readdir5(rootDir, { withFileTypes: true });
+    const packs = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const validation = validatePackName(kind, entry.name);
+      if (validation.status === "other") {
+        continue;
+      }
+      packs.push({
+        kind,
+        rootDir,
+        path: path18.join(rootDir, entry.name),
+        name: entry.name,
+        status: validation.status,
+        isCanonical: validation.isCanonical,
+        isLegacy: validation.isLegacy,
+        isDangerous: validation.isDangerous,
+        timestamp: validation.timestamp
+      });
+    }
+    return packs.sort((left, right) => left.name.localeCompare(right.name));
+  } catch {
+    return [];
+  }
+}
+function latestPack(packs) {
+  let latest = null;
+  for (const candidate of packs) {
+    if (!candidate.isCanonical || !candidate.timestamp) {
+      continue;
+    }
+    if (!latest || isTimestampGreater(candidate.timestamp, latest.timestamp)) {
+      latest = candidate;
+    }
+  }
+  return latest;
+}
+async function findLatestPack(rootDir, kind) {
+  const packs = await findPacks(rootDir, kind);
+  return latestPack(packs);
+}
+function isTimestampGreater(left, right) {
+  if (!right) {
+    return true;
+  }
+  return BigInt(left) > BigInt(right);
+}
+
+// src/core/discussionPack.ts
+var REQUIRED_DISCUSSION_PACK_FILES = [
+  "01_Context.md",
+  "02_Inception-Deck.md",
+  "03_Story-Workshop.md",
+  "04_Sources.md",
+  "05_Scope.md",
+  "06_REQ.md",
+  "07_NFR.md",
+  "08_Glossary.md",
+  "09_Constraints.md",
+  "10_Policy.md",
+  "11_OQ-Register.md",
+  "12_OQ-Resolution-Log.md",
+  "13_Deferred.md",
+  "14_Review-Request.md",
+  "99_delta.md"
+];
+var PLACEHOLDER_LINE_RE = /^(?:[-*]\s*)?(?:tbd|todo|none|n\/a|placeholder|\(placeholder\)|to be defined|to be updated|<[^>]+>)\.?$/i;
+async function inspectLatestDiscussionPack(discussionRoot) {
+  const packs = await findPacks(discussionRoot, "discussion");
+  const legacyPackNames = packs.filter((pack) => pack.isLegacy).map((pack) => pack.name).sort((left, right) => left.localeCompare(right));
+  const dangerousPackNames = packs.filter((pack) => pack.isDangerous).map((pack) => pack.name).sort((left, right) => left.localeCompare(right));
+  const latest = latestPack(packs);
+  const latestPackDir = latest?.path ?? null;
+  const latestPackName = latest?.name ?? null;
+  if (!latestPackDir) {
+    return {
+      discussionRoot,
+      latestPackDir: null,
+      latestPackName,
+      legacyPackNames,
+      dangerousPackNames,
+      missingFiles: [...REQUIRED_DISCUSSION_PACK_FILES],
+      incompleteFiles: [],
+      blockingOqIds: [],
+      deferredWithoutDetails: []
+    };
+  }
+  const missingFiles = [];
+  const incompleteFiles = [];
+  let blockingOqIds = [];
+  let deferredWithoutDetails = [];
+  for (const fileName of REQUIRED_DISCUSSION_PACK_FILES) {
+    const target = path19.join(latestPackDir, fileName);
+    const content = await readSafe(target);
+    if (content === null) {
+      missingFiles.push(fileName);
+      continue;
+    }
+    if (isDiscussionPackFileIncomplete(content)) {
+      incompleteFiles.push(fileName);
+    }
+    if (fileName === "11_OQ-Register.md") {
+      blockingOqIds = extractBlockingOqIds(content);
+    }
+  }
+  const oqRegisterContent = await readSafe(path19.join(latestPackDir, "11_OQ-Register.md"));
+  const deferredContent = await readSafe(path19.join(latestPackDir, "13_Deferred.md"));
+  if (oqRegisterContent !== null && deferredContent !== null) {
+    deferredWithoutDetails = extractDeferredWithoutDetails(oqRegisterContent, deferredContent);
+  }
+  return {
+    discussionRoot,
+    latestPackDir,
+    latestPackName,
+    legacyPackNames,
+    dangerousPackNames,
+    missingFiles,
+    incompleteFiles,
+    blockingOqIds,
+    deferredWithoutDetails
+  };
+}
+async function findLatestDiscussionPackDir(discussionRoot) {
+  const packs = await findPacks(discussionRoot, "discussion");
+  return latestPack(packs)?.path ?? null;
+}
+function isDiscussionPackFileIncomplete(text) {
+  const normalized = text.replace(/\r\n/g, "\n").trim();
+  if (normalized.length < 100) {
+    return true;
+  }
+  const contentLines = normalized.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).filter((line) => !line.startsWith("#")).filter((line) => !/^\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)*\|?$/.test(line));
+  if (contentLines.length === 0) {
+    return true;
+  }
+  if (contentLines.every((line) => isPlaceholderLine(line))) {
+    return true;
+  }
+  return false;
+}
+function isPlaceholderLine(line) {
+  const plain = line.replace(/[`*_~]/g, "").replace(/\|/g, " ").replace(/\s+/g, " ").trim();
+  return PLACEHOLDER_LINE_RE.test(plain);
+}
+function extractBlockingOqIds(text) {
+  const lines = text.replace(/\r\n/g, "\n").split("\n");
+  const oqStates = /* @__PURE__ */ new Map();
+  let currentId = null;
+  for (const line of lines) {
+    const idMatch = /\b(OQ-\d+)\b/i.exec(line);
+    if (idMatch?.[1]) {
+      currentId = idMatch[1].toUpperCase();
+    }
+    if (currentId !== null) {
+      const state = oqStates.get(currentId) ?? { disposition: null };
+      const disposition = /^\s*-\s*Disposition\s*:\s*([^\s#]+)/i.exec(line)?.[1] ?? null;
+      if (disposition) {
+        state.disposition = disposition.toLowerCase();
+      }
+      oqStates.set(currentId, state);
+    }
+    if (line.trim().startsWith("|")) {
+      const cells = parseTableCells(line);
+      for (const cell of cells) {
+        const oqMatch = /\b(OQ-\d+)\b/i.exec(cell);
+        if (oqMatch?.[1]) {
+          currentId = oqMatch[1].toUpperCase();
+          const existingState = oqStates.get(currentId) ?? { disposition: null };
+          oqStates.set(currentId, existingState);
+        }
+      }
+    }
+  }
+  const tableOqs = extractOqTableRows(text);
+  for (const row of tableOqs) {
+    if (row.id && row.disposition) {
+      const existing = oqStates.get(row.id) ?? { disposition: null };
+      existing.disposition = row.disposition;
+      oqStates.set(row.id, existing);
+    }
+  }
+  const blocking = Array.from(oqStates.entries()).filter(([, state]) => state.disposition === "open").map(([id]) => id).sort((left, right) => left.localeCompare(right));
+  return blocking;
+}
+function extractOqTableRows(text) {
+  const lines = text.replace(/\r\n/g, "\n").split("\n");
+  const results = [];
+  let headerIndex = -1;
+  let oqIdCol = -1;
+  let dispositionCol = -1;
+  for (let i = 0; i < lines.length - 1; i++) {
+    const line = lines[i] ?? "";
+    if (!line.includes("|")) continue;
+    const cells = parseTableCells(line);
+    const normalizedCells = cells.map((c) => c.toLowerCase().replace(/[^a-z0-9-]/g, ""));
+    oqIdCol = normalizedCells.findIndex((c) => c === "oq-id" || c === "oqid");
+    dispositionCol = normalizedCells.findIndex((c) => c === "disposition");
+    if (oqIdCol >= 0 && dispositionCol >= 0) {
+      const sepLine = lines[i + 1] ?? "";
+      const sepCells = parseTableCells(sepLine);
+      if (sepCells.length === cells.length && sepCells.every((c) => /^:?-{3,}:?$/.test(c.trim()))) {
+        headerIndex = i;
+        break;
+      }
+    }
+  }
+  if (headerIndex < 0) return results;
+  for (let i = headerIndex + 2; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (!line.trim().startsWith("|")) break;
+    const cells = parseTableCells(line);
+    const oqIdRaw = cells[oqIdCol] ?? "";
+    const dispositionRaw = cells[dispositionCol] ?? "";
+    const oqMatch = /\b(OQ-\d+)\b/i.exec(oqIdRaw);
+    if (oqMatch?.[1]) {
+      results.push({
+        id: oqMatch[1].toUpperCase(),
+        disposition: dispositionRaw.trim().toLowerCase()
+      });
+    }
+  }
+  return results;
+}
+function extractDeferredWithoutDetails(oqRegisterText, deferredText) {
+  const registerRows = extractOqTableRows(oqRegisterText);
+  const deferredIds = registerRows.filter((row) => row.disposition === "deferred").map((row) => row.id);
+  if (deferredIds.length === 0) return [];
+  const deferredDetailSet = extractAllOqIds(deferredText);
+  return deferredIds.filter((id) => !deferredDetailSet.has(id));
+}
+function extractAllOqIds(text) {
+  const ids = /* @__PURE__ */ new Set();
+  const re = /\b(OQ-\d+)\b/gi;
+  let match;
+  while ((match = re.exec(text)) !== null) {
+    if (match[1]) {
+      ids.add(match[1].toUpperCase());
+    }
+  }
+  return ids;
+}
+function parseTableCells(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("|")) return [];
+  const normalized = trimmed.replace(/^\|/, "").replace(/\|$/, "");
+  return normalized.split("|").map((cell) => cell.trim());
+}
+async function readSafe(filePath) {
+  try {
+    const stats = await stat2(filePath);
+    if (!stats.isFile()) {
+      return null;
+    }
+    return await readFile10(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+// src/cli/commands/prototyping.ts
+var ENV_AUTOGEN = "QFAI_PROTOTYPE_FIDELITY_AUTOGEN";
+var DEFAULT_EVIDENCE_PATH = ".qfai/evidence/prototyping.json";
+async function runPrototyping(options) {
+  if (options.modeInvalid) {
+    error(
+      `QFAI-PROTO-010: invalid mode "${options.modeInvalid}". Valid modes: low-cost, standard, full-harness`
+    );
+    return 1;
+  }
+  const { config } = await loadConfig(options.root);
+  const discussionDir = path20.join(options.root, config.paths.discussionDir);
+  const packDir = await findLatestDiscussionPackDir(discussionDir);
+  const recommendation = packDir ? await readDiscussionRecommendation(packDir) : null;
+  const modeResolution = resolvePrecedence({
+    cliMode: options.mode ?? null,
+    discussion: recommendation
+  });
+  const modeLog = formatModeLog(modeResolution);
+  info(`prototyping: mode resolution \u2014 ${JSON.stringify(modeLog)}`);
+  if (modeResolution.effective_mode === "full-harness") {
+    info(
+      "prototyping: full-harness mode requires /qfai-prototyping-full-harness. Exiting without starting loop."
+    );
+    return 0;
+  }
+  if (modeResolution.effective_mode === "low-cost") {
+    info("prototyping: low-cost mode \u2014 skipping runtime evidence (static obligations only).");
+    const evidencePath2 = resolveEvidencePath(options.root, options.evidenceOut);
+    const toolVersion2 = await resolveToolVersion();
+    let existingEvidence2 = {};
+    try {
+      const raw = await readFile11(evidencePath2, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        existingEvidence2 = parsed;
+      }
+    } catch {
+    }
+    const skippedEvidence = emitUiFidelity({
+      evidence: existingEvidence2,
+      toolVersion: toolVersion2,
+      command: "qfai prototyping",
+      baseUrl: "",
+      status: "skipped",
+      reason: "low-cost mode: runtime evidence skipped"
+    });
+    const renderOptions2 = mergeRenderOptions(options, config.uiux?.renderEvidence);
+    const renderBundle2 = await maybeWriteRenderBundle(
+      toolVersion2,
+      "qfai prototyping --render-evidence",
+      renderOptions2,
+      false
+    );
+    await writeEvidence(
+      evidencePath2,
+      applyRenderEvidence(
+        skippedEvidence,
+        await resolveAttachedRenderEvidence(renderBundle2, renderOptions2, false)
+      )
+    );
+    return 0;
+  }
+  const renderOptions = mergeRenderOptions(options, config.uiux?.renderEvidence);
+  const autogenEnabled = options.autogenUiFidelity || process.env[ENV_AUTOGEN] === "1";
+  if (!autogenEnabled) {
+    if (options.autogenOnly) {
+      error(
+        `prototyping: --autogen-only \u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u3059\u304C --autogen-ui-fidelity / ${ENV_AUTOGEN}=1 \u304C\u3042\u308A\u307E\u305B\u3093\u3002`
+      );
+      return 2;
+    }
+    info(
+      `prototyping: --autogen-ui-fidelity or ${ENV_AUTOGEN}=1 \u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002\u4F55\u3082\u5B9F\u884C\u3057\u307E\u305B\u3093\u3002`
+    );
+    const evidencePath2 = resolveEvidencePath(options.root, options.evidenceOut);
+    const toolVersion2 = await resolveToolVersion();
+    let existingEvidence2 = {};
+    try {
+      const raw = await readFile11(evidencePath2, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        existingEvidence2 = parsed;
+      }
+    } catch {
+    }
+    const skippedEvidence = emitUiFidelity({
+      evidence: existingEvidence2,
+      toolVersion: toolVersion2,
+      command: "qfai prototyping",
+      baseUrl: "",
+      status: "skipped",
+      reason: "autogen not enabled (--autogen-ui-fidelity or env not set)"
+    });
+    const renderBundle2 = await maybeWriteRenderBundle(
+      toolVersion2,
+      "qfai prototyping --render-evidence",
+      renderOptions,
+      false
+    );
+    await writeEvidence(
+      evidencePath2,
+      applyRenderEvidence(
+        skippedEvidence,
+        await resolveAttachedRenderEvidence(renderBundle2, renderOptions, false)
+      )
+    );
+    return 0;
+  }
+  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 evidencePath = resolveEvidencePath(options.root, options.evidenceOut);
+  info(`prototyping: autogen uiFidelity \u3092\u5B9F\u884C\u3057\u307E\u3059 (baseUrl=${baseUrl})`);
+  let existingEvidence = {};
+  try {
+    const raw = await readFile11(evidencePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      existingEvidence = parsed;
+    }
+  } catch {
+  }
+  const routeHints = extractRouteHintsFromEvidence(existingEvidence);
+  let result;
+  try {
+    result = await autogenerateUiFidelity(options.root, config, baseUrl, routeHints);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    warn(`prototyping: autogen failed - ${reason}`);
+    const failedEvidence = emitUiFidelity({
+      evidence: existingEvidence,
+      toolVersion,
+      command: "qfai prototyping --autogen-ui-fidelity",
+      baseUrl,
+      status: "failed",
+      reason
+    });
+    const renderBundle2 = await maybeWriteRenderBundle(
+      toolVersion,
+      "qfai prototyping --render-evidence",
+      renderOptions,
+      true
+    );
+    await writeEvidence(
+      evidencePath,
+      applyRenderEvidence(
+        failedEvidence,
+        await resolveAttachedRenderEvidence(renderBundle2, renderOptions, true)
+      )
+    );
+    info(`prototyping: wrote evidence with status=failed to ${evidencePath}`);
+    return options.autogenOnly ? 1 : 0;
+  }
+  const hasScreens = result.screens.length > 0;
+  const allRoutesFailed = result.crawled.every((r) => r.status === "failed");
+  if (!hasScreens || allRoutesFailed) {
+    const uiContractsPath = path20.join(resolvePath(options.root, config, "contractsDir"), "ui");
+    const reason = !hasScreens ? `no screens found in ${uiContractsPath}` : "all route crawls failed";
+    warn(`prototyping: autogen produced no usable data - ${reason}`);
+    const failedEvidence = emitUiFidelity({
+      evidence: existingEvidence,
+      toolVersion,
+      command: "qfai prototyping --autogen-ui-fidelity",
+      baseUrl,
+      status: "failed",
+      crawled: result.crawled,
+      reason
+    });
+    const renderBundle2 = await maybeWriteRenderBundle(
+      toolVersion,
+      "qfai prototyping --render-evidence",
+      renderOptions,
+      true
+    );
+    await writeEvidence(
+      evidencePath,
+      applyRenderEvidence(
+        failedEvidence,
+        await resolveAttachedRenderEvidence(renderBundle2, renderOptions, true)
+      )
+    );
+    info(`prototyping: wrote evidence with status=failed to ${evidencePath}`);
+    return options.autogenOnly ? 1 : 0;
+  }
+  const successEvidence = emitUiFidelity({
+    evidence: existingEvidence,
+    toolVersion,
+    command: "qfai prototyping --autogen-ui-fidelity",
+    baseUrl,
+    status: "success",
+    screens: result.screens,
+    crawled: result.crawled
+  });
+  const renderBundle = await maybeWriteRenderBundle(
+    toolVersion,
+    "qfai prototyping --render-evidence",
+    renderOptions,
+    true
+  );
+  await writeEvidence(
+    evidencePath,
+    applyRenderEvidence(
+      successEvidence,
+      await resolveAttachedRenderEvidence(renderBundle, renderOptions, true)
+    )
+  );
+  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";
+  info(
+    `prototyping: autogen success - ${result.screens.length} screens, routes ok=${routeOkCount} fail=${routeFailCount}, avg coverage=${avgCoverage}`
+  );
+  info(`prototyping: wrote evidence to ${evidencePath}`);
+  return 0;
+}
+function resolveBaseUrl(options) {
+  if (options.baseUrl) {
+    return options.baseUrl;
+  }
+  const envUrl = process.env.QFAI_PROTOTYPE_BASE_URL;
+  if (envUrl && envUrl.trim().length > 0) {
+    return envUrl.trim();
+  }
+  return null;
+}
+function resolveEvidencePath(root, explicit) {
+  if (explicit) {
+    return path20.isAbsolute(explicit) ? explicit : path20.resolve(root, explicit);
+  }
+  return path20.resolve(root, DEFAULT_EVIDENCE_PATH);
+}
+async function writeEvidence(filePath, evidence) {
+  await mkdir4(path20.dirname(filePath), { recursive: true });
+  await writeFile3(filePath, JSON.stringify(evidence, null, 2) + "\n", "utf-8");
+}
+async function writeRenderBundle(filePath, bundle) {
+  await mkdir4(path20.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 = await buildRenderBundle(toolVersion, command, options, autogenEnabled);
+  await writeRenderBundle(renderBundle.path, renderBundle.bundle);
+  return renderBundle;
+}
+function applyRenderEvidence(evidence, renderEvidence) {
+  if (!renderEvidence) {
+    return evidence;
+  }
+  return {
+    ...evidence,
+    renderEvidence
+  };
+}
+async function resolveAttachedRenderEvidence(renderBundle, options, autogenEnabled) {
+  if (!options.renderEvidence) {
+    return void 0;
+  }
+  return renderBundle?.renderEvidence ?? await buildRenderEvidenceRecord(
+    options,
+    autogenEnabled,
+    resolveRenderOutPath(options.root, options.renderOut)
+  );
+}
+async function buildRenderBundle(toolVersion, command, options, autogenEnabled) {
+  const outPath = resolveRenderOutPath(options.root, options.renderOut);
+  const renderEvidence = await buildRenderEvidenceRecord(options, autogenEnabled, outPath);
+  return {
+    path: outPath,
+    bundle: {
+      meta: {
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        toolVersion,
+        commands: [command]
+      },
+      renderEvidence
+    },
+    renderEvidence
+  };
+}
+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,
+    renderFailOpen: options.renderFailOpen ?? configRenderEvidence?.failOpen === true,
+    ...renderOut ? { renderOut } : {},
+    ...baseUrl ? { baseUrl } : {}
+  };
+}
+function resolveRenderOutPath(root, explicit) {
+  if (explicit) {
+    return path20.isAbsolute(explicit) ? explicit : path20.resolve(root, explicit);
+  }
+  return path20.resolve(root, ".qfai/evidence/render.json");
+}
+async function buildRenderEvidenceRecord(options, autogenEnabled, outputPath) {
+  const viewports = normalizeRenderViewports(options.renderViewports);
   if (!autogenEnabled) {
     return {
       status: "skipped",
@@ -4401,8 +4892,8 @@ function extractRouteHintsFromEvidence(evidence) {
 }
 
 // src/cli/commands/report.ts
-import { mkdir as mkdir8, readFile as readFile45, writeFile as writeFile7 } from "fs/promises";
-import path61 from "path";
+import { mkdir as mkdir8, readFile as readFile46, writeFile as writeFile7 } from "fs/promises";
+import path64 from "path";
 
 // src/core/normalize.ts
 function normalizeIssuePaths(root, issues) {
@@ -4497,17 +4988,17 @@ async function createPhaseGuardResult(phase, blockedIssue) {
 }
 
 // src/core/report.ts
-import { readFile as readFile43 } from "fs/promises";
-import path59 from "path";
+import { readFile as readFile44 } from "fs/promises";
+import path62 from "path";
 
 // src/core/contractIndex.ts
-import { readFile as readFile10 } from "fs/promises";
-import path18 from "path";
+import { readFile as readFile12 } from "fs/promises";
+import path21 from "path";
 async function buildContractIndex(root, config) {
   const contractsRoot = resolvePath(root, config, "contractsDir");
-  const uiRoot = path18.join(contractsRoot, "ui");
-  const apiRoot = path18.join(contractsRoot, "api");
-  const dbRoot = path18.join(contractsRoot, "db");
+  const uiRoot = path21.join(contractsRoot, "ui");
+  const apiRoot = path21.join(contractsRoot, "api");
+  const dbRoot = path21.join(contractsRoot, "db");
   const [uiFiles, themaFiles, apiFiles, dbFiles] = await Promise.all([
     collectUiContractFiles(uiRoot),
     collectThemaContractFiles(),
@@ -4527,7 +5018,7 @@ async function buildContractIndex(root, config) {
 }
 async function indexContractFiles(files, index) {
   for (const file of files) {
-    const text = await readFile10(file, "utf-8");
+    const text = await readFile12(file, "utf-8");
     extractDeclaredContractIds(text).forEach((id) => {
       record(index, id, file);
     });
@@ -4920,7 +5411,7 @@ function parseSpec(md, file) {
 }
 
 // src/core/deltaV1.ts
-import { parse as parseYaml3 } from "yaml";
+import { parse as parseYaml4 } from "yaml";
 var REQUIRED_DELTA_META_KEYS = [
   "id",
   "date",
@@ -5075,7 +5566,7 @@ function parseYamlMeta(block) {
     return { value: null, error: null };
   }
   try {
-    const parsed = parseYaml3(sanitizeMetaYaml(block));
+    const parsed = parseYaml4(sanitizeMetaYaml(block));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return {
         value: null,
@@ -5109,7 +5600,7 @@ function parseVerificationPlan(body) {
     return { planHeadingLine: planHeading.line, parseError: null, items: [] };
   }
   try {
-    const parsed = parseYaml3(yamlSource);
+    const parsed = parseYaml4(yamlSource);
     if (!Array.isArray(parsed)) {
       return {
         planHeadingLine: planHeading.line,
@@ -5196,9 +5687,9 @@ function asTagArray(value) {
 }
 
 // src/core/waivers.ts
-import { access as access9, readFile as readFile12 } from "fs/promises";
-import path19 from "path";
-import { parse as parseYaml4 } from "yaml";
+import { access as access9, readFile as readFile14 } from "fs/promises";
+import path22 from "path";
+import { parse as parseYaml5 } from "yaml";
 
 // src/core/regex.ts
 function escapeRegExp(value) {
@@ -5206,7 +5697,7 @@ function escapeRegExp(value) {
 }
 
 // src/core/validators/utils.ts
-import { access as access8, readFile as readFile11 } from "fs/promises";
+import { access as access8, readFile as readFile13 } from "fs/promises";
 function issue(code, message, severity, file, rule, refs, category = "compatibility", suggested_action, details) {
   const issue2 = {
     code,
@@ -5239,9 +5730,9 @@ async function exists8(filePath) {
     return false;
   }
 }
-async function readSafe(filePath) {
+async function readSafe2(filePath) {
   try {
-    return await readFile11(filePath, "utf-8");
+    return await readFile13(filePath, "utf-8");
   } catch {
     return "";
   }
@@ -5329,12 +5820,12 @@ function cloneGlobal(pattern) {
 }
 
 // src/core/waivers.ts
-var WAIVER_FILE = path19.join(".qfai", "waivers.yml");
-var UNSUPPORTED_WAIVER_FILE = path19.join(".qfai", "waivers.yaml");
+var WAIVER_FILE = path22.join(".qfai", "waivers.yml");
+var UNSUPPORTED_WAIVER_FILE = path22.join(".qfai", "waivers.yaml");
 var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 var RULE_ID_RE = /^[A-Z]+-\d{3}$/;
 async function applyWaivers(root, findings) {
-  const resolvedRoot = path19.resolve(root);
+  const resolvedRoot = path22.resolve(root);
   const ruleSeverityIndex = buildRuleSeverityIndex(findings);
   const loaded = await loadWaivers(resolvedRoot, ruleSeverityIndex);
   const applied = applyWaiversToFindings(resolvedRoot, findings, loaded.applicableWaivers);
@@ -5347,8 +5838,8 @@ async function applyWaivers(root, findings) {
   };
 }
 async function loadWaivers(root, ruleSeverityIndex) {
-  const waiverPath = path19.join(root, WAIVER_FILE);
-  const unsupportedPath = path19.join(root, UNSUPPORTED_WAIVER_FILE);
+  const waiverPath = path22.join(root, WAIVER_FILE);
+  const unsupportedPath = path22.join(root, UNSUPPORTED_WAIVER_FILE);
   const validationIssues = [];
   if (await exists9(unsupportedPath)) {
     validationIssues.push(
@@ -5372,7 +5863,7 @@ async function loadWaivers(root, ruleSeverityIndex) {
   }
   let rawText;
   try {
-    rawText = await readFile12(waiverPath, "utf-8");
+    rawText = await readFile14(waiverPath, "utf-8");
   } catch (error2) {
     validationIssues.push(
       issue(
@@ -5393,7 +5884,7 @@ async function loadWaivers(root, ruleSeverityIndex) {
   }
   let parsed;
   try {
-    parsed = parseYaml4(rawText);
+    parsed = parseYaml5(rawText);
   } catch (error2) {
     validationIssues.push(
       issue(
@@ -6065,8 +6556,8 @@ var STATIC_RULE_SEVERITY = {
 };
 
 // src/core/validators/contracts.ts
-import { readFile as readFile13 } from "fs/promises";
-import path20 from "path";
+import { readFile as readFile15 } from "fs/promises";
+import path23 from "path";
 var SQL_DANGEROUS_PATTERNS = [
   { pattern: /\bDROP\s+TABLE\b/i, label: "DROP TABLE" },
   { pattern: /\bDROP\s+DATABASE\b/i, label: "DROP DATABASE" },
@@ -6079,9 +6570,9 @@ var SQL_DANGEROUS_PATTERNS = [
 async function validateContracts(root, config) {
   const issues = [];
   const contractsRoot = resolvePath(root, config, "contractsDir");
-  const uiRoot = path20.join(contractsRoot, "ui");
-  const apiRoot = path20.join(contractsRoot, "api");
-  const dbRoot = path20.join(contractsRoot, "db");
+  const uiRoot = path23.join(contractsRoot, "ui");
+  const apiRoot = path23.join(contractsRoot, "api");
+  const dbRoot = path23.join(contractsRoot, "db");
   const [uiFiles, apiFiles, dbFiles] = await Promise.all([
     collectUiContractFiles(uiRoot),
     collectApiContractFiles(apiRoot),
@@ -6135,7 +6626,7 @@ async function validateContracts(root, config) {
 }
 async function validateContractFile(file, kind) {
   const issues = [];
-  const text = await readFile13(file, "utf-8");
+  const text = await readFile15(file, "utf-8");
   const declaredIds = extractDeclaredContractIds(text);
   issues.push(...validateDeclaredContractIds(declaredIds, file, kind));
   if (kind === "DB") {
@@ -6256,121 +6747,23 @@ function formatError5(error2) {
 }
 
 // src/core/validators/discussMermaid.ts
-import { readFile as readFile14 } from "fs/promises";
-import path22 from "path";
-
-// src/core/packLocator.ts
-import { readdir as readdir5 } from "fs/promises";
-import path21 from "path";
-var PACK_RULES = {
-  discussion: {
-    prefix: "discussion",
-    legacyPattern: /^discussion-\d{4}$/i,
-    parkedLegacyPattern: /^discussion-legacy-[a-z0-9][a-z0-9-]*$/i
-  }
-};
-var PACK_TIMESTAMP_RE = /^\d{17}$/;
-function parsePackTimestamp(kind, name) {
-  const rule = PACK_RULES[kind];
-  const prefix = `${rule.prefix}-`;
-  if (!name.startsWith(prefix)) {
-    return null;
-  }
-  const suffix = name.slice(prefix.length);
-  if (!PACK_TIMESTAMP_RE.test(suffix)) {
-    return null;
-  }
-  return suffix;
-}
-function validatePackName(kind, name) {
-  const rule = PACK_RULES[kind];
-  const normalizedPrefix = `${rule.prefix}-`;
-  const isPrefixed = name.toLowerCase().startsWith(normalizedPrefix);
-  const timestamp = parsePackTimestamp(kind, name);
-  const isCanonical = timestamp !== null;
-  const isLegacy = !isCanonical && rule.legacyPattern.test(name);
-  const isParkedLegacy = !isCanonical && rule.parkedLegacyPattern.test(name);
-  const isDangerous = isPrefixed && !isCanonical && !isLegacy && !isParkedLegacy;
-  const status = isCanonical ? "canonical" : isLegacy ? "legacy" : isDangerous ? "dangerous" : "other";
-  return {
-    kind,
-    name,
-    status,
-    isCanonical,
-    isLegacy,
-    isDangerous,
-    isPrefixed,
-    timestamp
-  };
-}
-async function findPacks(rootDir, kind) {
-  try {
-    const entries = await readdir5(rootDir, { withFileTypes: true });
-    const packs = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory()) {
-        continue;
-      }
-      const validation = validatePackName(kind, entry.name);
-      if (validation.status === "other") {
-        continue;
-      }
-      packs.push({
-        kind,
-        rootDir,
-        path: path21.join(rootDir, entry.name),
-        name: entry.name,
-        status: validation.status,
-        isCanonical: validation.isCanonical,
-        isLegacy: validation.isLegacy,
-        isDangerous: validation.isDangerous,
-        timestamp: validation.timestamp
-      });
-    }
-    return packs.sort((left, right) => left.name.localeCompare(right.name));
-  } catch {
-    return [];
-  }
-}
-function latestPack(packs) {
-  let latest = null;
-  for (const candidate of packs) {
-    if (!candidate.isCanonical || !candidate.timestamp) {
-      continue;
-    }
-    if (!latest || isTimestampGreater(candidate.timestamp, latest.timestamp)) {
-      latest = candidate;
-    }
-  }
-  return latest;
-}
-async function findLatestPack(rootDir, kind) {
-  const packs = await findPacks(rootDir, kind);
-  return latestPack(packs);
-}
-function isTimestampGreater(left, right) {
-  if (!right) {
-    return true;
-  }
-  return BigInt(left) > BigInt(right);
-}
-
-// src/core/validators/discussMermaid.ts
+import { readFile as readFile16 } from "fs/promises";
+import path24 from "path";
 var DISCUSSION_PACK_FLOW_FILE = "03_Story-Workshop.md";
 var MERMAID_START_RE = /^\s*(`{3,}|~{3,})\s*mermaid\b/i;
 var FLOW_OR_SEQUENCE_RE = /\b(?:sequenceDiagram|flowchart)\b/;
 async function validateDiscussionMermaid(root) {
-  const discussionRootDir = path22.join(root, ".qfai", "discussion");
+  const discussionRootDir = path24.join(root, ".qfai", "discussion");
   const discussionPackMarkdownFiles = await collectFiles(discussionRootDir, {
     extensions: [".md"]
   });
   const discussionPackFiles = [];
   for (const file of discussionPackMarkdownFiles) {
-    const fileName = path22.basename(file);
+    const fileName = path24.basename(file);
     if (fileName !== DISCUSSION_PACK_FLOW_FILE) {
       continue;
     }
-    const discussionDirName = path22.basename(path22.dirname(file));
+    const discussionDirName = path24.basename(path24.dirname(file));
     const nameValidation = validatePackName("discussion", discussionDirName);
     if (nameValidation.isCanonical) {
       discussionPackFiles.push({ file, kind: "current" });
@@ -6400,7 +6793,7 @@ async function validateDiscussionMermaid(root) {
     );
   }
   for (const { file } of discussionPackFiles) {
-    const text = await readFile14(file, "utf-8");
+    const text = await readFile16(file, "utf-8");
     if (containsMermaidFlowDiagram(text)) {
       continue;
     }
@@ -6450,17 +6843,17 @@ function containsMermaidFlowDiagram(text) {
 }
 
 // src/core/validators/assistantAssets.ts
-import { access as access10, readFile as readFile15 } from "fs/promises";
-import path23 from "path";
+import { access as access10, readFile as readFile17 } from "fs/promises";
+import path25 from "path";
 var DRIFT_PROTOCOL_MARKER = "[DRIFT-PROTOCOL:MANDATORY]";
 var REVIEWER_GATE_HEADING_PATTERN = /^###\s+Reviewer Gate\b.*$/im;
 var ANY_MARKDOWN_HEADING_PATTERN = /^\s*#{1,6}\s+/m;
 async function validateAssistantAssets(root, config) {
   const skillsDir = resolvePath(root, config, "skillsDir");
-  const assistantDir = path23.dirname(skillsDir);
-  const skillsLocalDir = path23.join(path23.dirname(skillsDir), `${path23.basename(skillsDir)}.local`);
-  const driftProtocolPath = path23.join(assistantDir, "instructions", "drift-protocol.md");
-  const testLayersPath = path23.join(assistantDir, "steering", "test-layers.md");
+  const assistantDir = path25.dirname(skillsDir);
+  const skillsLocalDir = path25.join(path25.dirname(skillsDir), `${path25.basename(skillsDir)}.local`);
+  const driftProtocolPath = path25.join(assistantDir, "instructions", "drift-protocol.md");
+  const testLayersPath = path25.join(assistantDir, "steering", "test-layers.md");
   const issues = [];
   if (!await exists10(driftProtocolPath)) {
     issues.push(
@@ -6486,7 +6879,7 @@ async function validateAssistantAssets(root, config) {
   }
   const skillFiles = await collectSkillFiles([skillsDir, skillsLocalDir]);
   for (const skillFile of skillFiles) {
-    const content = await readFile15(skillFile, "utf-8");
+    const content = await readFile17(skillFile, "utf-8");
     if (!content.includes(DRIFT_PROTOCOL_MARKER)) {
       issues.push(
         issue(
@@ -6528,7 +6921,7 @@ async function validateAssistantAssets(root, config) {
 }
 async function collectSkillFiles(dirs) {
   const files = await Promise.all(dirs.map((dir) => collectFiles(dir)));
-  return files.flat().filter((filePath) => path23.basename(filePath) === "SKILL.md").sort((a, b) => a.localeCompare(b));
+  return files.flat().filter((filePath) => path25.basename(filePath) === "SKILL.md").sort((a, b) => a.localeCompare(b));
 }
 function extractReviewerGateSection(content) {
   const headingMatch = REVIEWER_GATE_HEADING_PATTERN.exec(content);
@@ -6600,8 +6993,8 @@ async function validateSkillsIntegrity(root, config) {
 }
 
 // src/core/validators/ids.ts
-import { readFile as readFile16 } from "fs/promises";
-import path24 from "path";
+import { readFile as readFile18 } from "fs/promises";
+import path26 from "path";
 var SC_TAG_RE2 = /^SC-\d{4}-\d{4}$/;
 var AC_ID_RE2 = /\bAC-[A-Za-z0-9_-]+\b/g;
 var CASE_ID_RE = /\b(?:CASE|TC)-[A-Za-z0-9_-]+\b/g;
@@ -6657,7 +7050,7 @@ async function validateDefinedIds(root, config) {
   return issues;
 }
 async function collectLayeredSharedCapabilityIds(file, out) {
-  const text = await readSafe2(file);
+  const text = await readSafe3(file);
   if (!text) {
     return;
   }
@@ -6670,7 +7063,7 @@ async function collectLayeredSharedCapabilityIds(file, out) {
   }
 }
 async function collectLayeredDefinitionIds(file, definitionRe, out) {
-  const text = await readSafe2(file);
+  const text = await readSafe3(file);
   if (!text) {
     return;
   }
@@ -6684,7 +7077,7 @@ async function collectLayeredDefinitionIds(file, definitionRe, out) {
 }
 async function collectCaseCatalogueDefinitionIds(files, out) {
   for (const file of files) {
-    const text = await readSafe2(file);
+    const text = await readSafe3(file);
     if (!text) {
       continue;
     }
@@ -6696,7 +7089,7 @@ async function collectCaseCatalogueDefinitionIds(files, out) {
 }
 async function collectSpecDefinitionIds(files, out) {
   for (const file of files) {
-    const text = await readSafe2(file);
+    const text = await readSafe3(file);
     if (!text) {
       continue;
     }
@@ -6715,16 +7108,16 @@ async function collectSpecDefinitionIds(files, out) {
     }
   }
 }
-async function readSafe2(file) {
+async function readSafe3(file) {
   try {
-    return await readFile16(file, "utf-8");
+    return await readFile18(file, "utf-8");
   } catch {
     return "";
   }
 }
 async function collectScenarioDefinitionIds(files, out) {
   for (const file of files) {
-    const text = await readSafe2(file);
+    const text = await readSafe3(file);
     if (!text) {
       continue;
     }
@@ -6748,23 +7141,23 @@ function recordId(out, id, file) {
 }
 function formatFileList(files, root) {
   return files.map((file) => {
-    const relative = path24.relative(root, file);
+    const relative = path26.relative(root, file);
     return relative.length > 0 ? relative : file;
   }).join(", ");
 }
 
 // src/core/validators/reviewArtifacts.ts
-import { readFile as readFile17, readdir as readdir6, stat as stat2 } from "fs/promises";
-import path25 from "path";
+import { readFile as readFile19, readdir as readdir6, stat as stat3 } from "fs/promises";
+import path27 from "path";
 var REVIEW_PACK_DIR_RE = /^review-(\d{17})$/i;
 var REVIEWER_FILE_RE = /^R\d+_.+\.md$/i;
 var ALLOWED_TARGET_KINDS = /* @__PURE__ */ new Set(["spec", "discussion"]);
 var ALLOWED_ROSTER_STATUS = /* @__PURE__ */ new Set(["PASS", "FAIL", "NA"]);
 var ALLOWED_OVERALL_STATUS = /* @__PURE__ */ new Set(["PASS", "FAIL"]);
 async function validateReviewArtifacts(root) {
-  const reviewRoot = path25.join(root, ".qfai", "review");
+  const reviewRoot = path27.join(root, ".qfai", "review");
   const issues = [];
-  const gitignorePath = path25.join(reviewRoot, ".gitignore");
+  const gitignorePath = path27.join(reviewRoot, ".gitignore");
   if (!await isFile(gitignorePath)) {
     issues.push(
       issue(
@@ -6802,8 +7195,8 @@ async function validateReviewArtifacts(root) {
 }
 async function validateReviewPack(reviewPackDir) {
   const issues = [];
-  const reviewRequestPath = path25.join(reviewPackDir, "review_request.md");
-  const summaryPath = path25.join(reviewPackDir, "summary.json");
+  const reviewRequestPath = path27.join(reviewPackDir, "review_request.md");
+  const summaryPath = path27.join(reviewPackDir, "summary.json");
   if (!await isFile(reviewRequestPath)) {
     issues.push(
       issue(
@@ -6846,7 +7239,7 @@ async function validateReviewPack(reviewPackDir) {
 async function validateSummarySchema(summaryPath) {
   let parsed;
   try {
-    parsed = JSON.parse(await readFile17(summaryPath, "utf-8"));
+    parsed = JSON.parse(await readFile19(summaryPath, "utf-8"));
   } catch (error2) {
     return [
       issue(
@@ -6935,7 +7328,7 @@ async function listReviewPackDirs(reviewRoot) {
   } catch {
     return [];
   }
-  return entries.map((name) => path25.join(reviewRoot, name));
+  return entries.map((name) => path27.join(reviewRoot, name));
 }
 async function listReviewerFiles(reviewPackDir) {
   try {
@@ -6947,7 +7340,7 @@ async function listReviewerFiles(reviewPackDir) {
 }
 async function isFile(target) {
   try {
-    const stats = await stat2(target);
+    const stats = await stat3(target);
     return stats.isFile();
   } catch {
     return false;
@@ -6983,8 +7376,8 @@ function formatError6(error2) {
 }
 
 // src/core/validators/specPack.ts
-import { readFile as readFile18 } from "fs/promises";
-import path26 from "path";
+import { readFile as readFile20 } from "fs/promises";
+import path28 from "path";
 var LEDGER_REQUIRED_COLUMNS = [
   "trace_id",
   "obj_id",
@@ -7271,7 +7664,7 @@ async function validateLayeredSpecEntry(entry) {
       );
     }
   }
-  const capabilitiesText = await readSafe3(entry.capabilityPath);
+  const capabilitiesText = await readSafe4(entry.capabilityPath);
   issues.push(
     ...validateLayeredIdFormat(
       entry.capabilityPath,
@@ -7284,11 +7677,11 @@ async function validateLayeredSpecEntry(entry) {
     return issues;
   }
   const [userStoriesText, acceptanceCriteriaText, businessRulesText, examplesText, testCasesText] = await Promise.all([
-    readSafe3(entry.userStoriesPath),
-    readSafe3(entry.acceptanceCriteriaPath),
-    readSafe3(entry.businessRulesPath),
-    readSafe3(entry.examplesPath),
-    readSafe3(entry.testCasesPath)
+    readSafe4(entry.userStoriesPath),
+    readSafe4(entry.acceptanceCriteriaPath),
+    readSafe4(entry.businessRulesPath),
+    readSafe4(entry.examplesPath),
+    readSafe4(entry.testCasesPath)
   ]);
   issues.push(
     ...validateLayeredIdFormat(
@@ -7402,7 +7795,7 @@ function validateLayeredNamespace(entry, filePath, ids, prefix) {
       "specPack.layered.namespace",
       mismatched,
       "compatibility",
-      `${path26.basename(filePath)} \u306E ${prefix} ID \u3092 spec-${entry.specNumber} \u306B\u5408\u308F\u305B\u3066\u4FEE\u6B63\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+      `${path28.basename(filePath)} \u306E ${prefix} ID \u3092 spec-${entry.specNumber} \u306B\u5408\u308F\u305B\u3066\u4FEE\u6B63\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
     )
   ];
 }
@@ -7410,7 +7803,7 @@ async function collectExistingLayeredDeltaFiles(entry) {
   const candidates = Array.from(new Set(entry.deltaCandidates));
   const existing = [];
   for (const candidate of candidates) {
-    if (!/(?:^|_)delta\.md$/i.test(path26.basename(candidate))) {
+    if (!/(?:^|_)delta\.md$/i.test(path28.basename(candidate))) {
       continue;
     }
     if (await fileExists(candidate)) {
@@ -7421,7 +7814,7 @@ async function collectExistingLayeredDeltaFiles(entry) {
 }
 async function fileExists(target) {
   try {
-    await readFile18(target, "utf-8");
+    await readFile20(target, "utf-8");
     return true;
   } catch {
     return false;
@@ -7582,7 +7975,7 @@ async function validateTraceabilityLedger(entry, contractIds) {
   const issues = [];
   let ledgerText;
   try {
-    ledgerText = await readFile18(entry.traceabilityLedgerPath, "utf-8");
+    ledgerText = await readFile20(entry.traceabilityLedgerPath, "utf-8");
   } catch {
     return issues;
   }
@@ -7873,14 +8266,14 @@ async function collectDefinitions(entry) {
     examplesText,
     tcText
   ] = await Promise.all([
-    readSafe3(entry.objectivePath),
-    readSafe3(entry.initiativePath),
-    readSafe3(entry.capabilityPath),
-    readSafe3(entry.flowPath),
-    readSafe3(entry.userStoriesPath),
-    readSafe3(entry.acceptanceCriteriaPath),
-    readSafe3(entry.examplesPath),
-    readSafe3(entry.testCasesPath)
+    readSafe4(entry.objectivePath),
+    readSafe4(entry.initiativePath),
+    readSafe4(entry.capabilityPath),
+    readSafe4(entry.flowPath),
+    readSafe4(entry.userStoriesPath),
+    readSafe4(entry.acceptanceCriteriaPath),
+    readSafe4(entry.examplesPath),
+    readSafe4(entry.testCasesPath)
   ]);
   const examples = parseExamplesFeature(examplesText, entry.examplesPath);
   const exIds = /* @__PURE__ */ new Set();
@@ -7974,16 +8367,16 @@ async function loadExistingRequiredTexts(entry, missingFiles) {
     if (!fullPath) {
       continue;
     }
-    texts[fileName] = await readSafe3(fullPath);
+    texts[fileName] = await readSafe4(fullPath);
   }
   return texts;
 }
 async function loadLayerPolicy(root, config) {
   const skillsDir = resolvePath(root, config, "skillsDir");
-  const assistantRoot = path26.dirname(skillsDir);
-  const policyPath = path26.join(assistantRoot, "steering", "test-layers.md");
+  const assistantRoot = path28.dirname(skillsDir);
+  const policyPath = path28.join(assistantRoot, "steering", "test-layers.md");
   try {
-    const policyText = await readFile18(policyPath, "utf-8");
+    const policyText = await readFile20(policyPath, "utf-8");
     return {
       tags: resolveAllowedLayerTagsFromPolicy(policyText),
       issues: []
@@ -8089,17 +8482,17 @@ function extractMarkdownSection(text, heading) {
   }
   return lines.slice(start, end).join("\n");
 }
-async function readSafe3(filePath) {
+async function readSafe4(filePath) {
   try {
-    return await readFile18(filePath, "utf-8");
+    return await readFile20(filePath, "utf-8");
   } catch {
     return "";
   }
 }
 
 // src/core/validators/traceability.ts
-import { access as access11, readFile as readFile19 } from "fs/promises";
-import path27 from "path";
+import { access as access11, readFile as readFile21 } from "fs/promises";
+import path29 from "path";
 var SC_TAG_RE3 = /^SC-\d{4}-\d{4}$/;
 var SC_TAG_RE_GLOBAL = /\bSC-\d{4}-\d{4}\b/g;
 var SPEC_TAG_RE = /^SPEC-\d{4}$/;
@@ -8116,10 +8509,10 @@ async function validateTraceability(root, config, phase) {
   if (layeredEntries.length === 0) {
     return issues;
   }
-  const policiesDir = layeredEntries[0]?.sharedDir ?? path27.join(specsRoot, "_policies");
-  const capabilitiesPath = path27.join(policiesDir, "03_Capabilities.md");
+  const policiesDir = layeredEntries[0]?.sharedDir ?? path29.join(specsRoot, "_policies");
+  const capabilitiesPath = path29.join(policiesDir, "03_Capabilities.md");
   const capabilitiesExists = await exists11(capabilitiesPath);
-  const capabilitiesText = await readSafe4(capabilitiesPath);
+  const capabilitiesText = await readSafe5(capabilitiesPath);
   const capIds = new Set(extractIds(capabilitiesText, "CAP"));
   const capSpecNumbers = new Set(
     Array.from(capIds).map((capId) => capId.match(/^CAP-(\d{4})$/)?.[1]).filter((value) => Boolean(value))
@@ -8198,8 +8591,8 @@ async function validatePoliciesLayerDownRef(policiesDir) {
     "04_Business-flow.md"
   ];
   for (const fileName of targets) {
-    const targetPath = path27.join(policiesDir, fileName);
-    const text = await readSafe4(targetPath);
+    const targetPath = path29.join(policiesDir, fileName);
+    const text = await readSafe5(targetPath);
     if (text.length === 0) {
       continue;
     }
@@ -8221,11 +8614,11 @@ async function validatePoliciesLayerDownRef(policiesDir) {
   return issues;
 }
 async function collectLayeredEdgeData(entry, issues) {
-  const userStoriesText = await readSafe4(entry.userStoriesPath);
-  const acceptanceCriteriaText = await readSafe4(entry.acceptanceCriteriaPath);
-  const businessRulesText = await readSafe4(entry.businessRulesPath);
-  const examplesText = await readSafe4(entry.examplesPath);
-  const testCasesText = await readSafe4(entry.testCasesPath);
+  const userStoriesText = await readSafe5(entry.userStoriesPath);
+  const acceptanceCriteriaText = await readSafe5(entry.acceptanceCriteriaPath);
+  const businessRulesText = await readSafe5(entry.businessRulesPath);
+  const examplesText = await readSafe5(entry.examplesPath);
+  const testCasesText = await readSafe5(entry.testCasesPath);
   const usIds = extractTableDefinitionIds(userStoriesText, /^US-\d{4}-\d{4}$/);
   const { definitions: acIds, refsByDefinition: acToUs } = extractTableDefinitionRefs(
     acceptanceCriteriaText,
@@ -8655,9 +9048,9 @@ function cloneGlobal2(re) {
   const flags = re.flags.includes("g") ? re.flags : `${re.flags}g`;
   return new RegExp(re.source, flags);
 }
-async function readSafe4(target) {
+async function readSafe5(target) {
   try {
-    return await readFile19(target, "utf-8");
+    return await readFile21(target, "utf-8");
   } catch {
     return "";
   }
@@ -8673,11 +9066,11 @@ async function exists11(target) {
 
 // src/core/validators/atddCodeTraceability.ts
 import { mkdir as mkdir5, writeFile as writeFile4 } from "fs/promises";
-import path29 from "path";
+import path31 from "path";
 
 // src/core/atddTraceability.ts
-import { readFile as readFile20 } from "fs/promises";
-import path28 from "path";
+import { readFile as readFile22 } from "fs/promises";
+import path30 from "path";
 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;
@@ -8688,15 +9081,15 @@ var TEST_FILE_GLOB = "**/*.{ts,tsx,js,jsx,mjs,cjs,mts,cts,feature,md,markdown}";
 async function evaluateAtddCodeTraceability(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
   const contractsRoot = resolvePath(root, config, "contractsDir");
-  const contractsApiRoot = path28.join(contractsRoot, "api");
+  const contractsApiRoot = path30.join(contractsRoot, "api");
   const [specRefs, apiContractIds] = await Promise.all([
     collectSpecRefs(specsRoot),
     collectApiContractIds(contractsApiRoot)
   ]);
   const testsRoot = resolvePath(root, config, "testsDir");
-  const e2eRoot = path28.join(testsRoot, "e2e");
-  const apiRoot = path28.join(testsRoot, "api");
-  const integrationRoot = path28.join(testsRoot, "integration");
+  const e2eRoot = path30.join(testsRoot, "e2e");
+  const apiRoot = path30.join(testsRoot, "api");
+  const integrationRoot = path30.join(testsRoot, "integration");
   const scanGlobs = buildAtddTestGlobs(root, testsRoot);
   const scanResult = await collectTestFiles(root, scanGlobs);
   const usRefs = /* @__PURE__ */ new Map();
@@ -8717,7 +9110,7 @@ async function evaluateAtddCodeTraceability(root, config) {
     if (!kind) {
       continue;
     }
-    const text = await readSafe5(file);
+    const text = await readSafe6(file);
     const usAnnotations = extractSpecScopedAnnotations(text, US_TEST_ANNOTATION_RE);
     const tcAnnotations = extractSpecScopedAnnotations(text, TC_TEST_ANNOTATION_RE);
     const apiAnnotations = extractApiContractAnnotations(text);
@@ -8798,8 +9191,8 @@ async function collectSpecRefs(specsRoot) {
   const tc = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     const [usText, tcText] = await Promise.all([
-      readSafe5(entry.userStoriesPath),
-      readSafe5(entry.testCasesPath)
+      readSafe6(entry.userStoriesPath),
+      readSafe6(entry.testCasesPath)
     ]);
     const usIds = collectShortIds(usText, "US");
     const tcIds = collectShortIds(tcText, "TC");
@@ -8816,7 +9209,7 @@ async function collectApiContractIds(apiRoot) {
   const files = await collectApiContractFiles(apiRoot);
   const ids = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const text = await readSafe5(file);
+    const text = await readSafe6(file);
     const declared = extractDeclaredContractIds(text);
     for (const id of declared) {
       const normalized = id.toUpperCase();
@@ -8841,8 +9234,8 @@ function collectShortIds(text, prefix) {
   return ids;
 }
 function buildAtddTestGlobs(root, testsRoot) {
-  const relativeTestsRoot = path28.relative(root, testsRoot);
-  const isInsideRoot = relativeTestsRoot.length === 0 || !relativeTestsRoot.startsWith("..") && !path28.isAbsolute(relativeTestsRoot);
+  const relativeTestsRoot = path30.relative(root, testsRoot);
+  const isInsideRoot = relativeTestsRoot.length === 0 || !relativeTestsRoot.startsWith("..") && !path30.isAbsolute(relativeTestsRoot);
   const base = isInsideRoot ? toPosixPath2(relativeTestsRoot.length === 0 ? "." : relativeTestsRoot) : toPosixPath2(testsRoot);
   const normalizedBase = base.replace(/\/+$/, "");
   return [
@@ -8871,11 +9264,11 @@ function resolveTestKind(filePath, roots) {
   return null;
 }
 function isWithinPath(base, target) {
-  const relative = path28.relative(base, target);
+  const relative = path30.relative(base, target);
   if (relative === "") {
     return true;
   }
-  return !relative.startsWith("..") && !path28.isAbsolute(relative);
+  return !relative.startsWith("..") && !path30.isAbsolute(relative);
 }
 function extractSpecScopedAnnotations(text, pattern) {
   const refs = [];
@@ -8909,22 +9302,22 @@ function extractApiContractAnnotations(text) {
 function recordSpecRef(refs, specNumber, id, file) {
   const bySpec = refs.get(specNumber) ?? /* @__PURE__ */ new Map();
   const files = bySpec.get(id) ?? /* @__PURE__ */ new Set();
-  files.add(path28.normalize(file));
+  files.add(path30.normalize(file));
   bySpec.set(id, files);
   refs.set(specNumber, bySpec);
 }
 function recordApiRef(refs, id, file) {
   const files = refs.get(id) ?? /* @__PURE__ */ new Set();
-  files.add(path28.normalize(file));
+  files.add(path30.normalize(file));
   refs.set(id, files);
 }
 function recordForbidden(refs, file, id) {
-  const files = refs.get(path28.normalize(file)) ?? /* @__PURE__ */ new Set();
+  const files = refs.get(path30.normalize(file)) ?? /* @__PURE__ */ new Set();
   files.add(id);
-  refs.set(path28.normalize(file), files);
+  refs.set(path30.normalize(file), files);
 }
 function pushUnknown(unknown, dedup, file, token, kind) {
-  const normalizedFile = path28.normalize(file);
+  const normalizedFile = path30.normalize(file);
   const key = `${kind}|${normalizedFile}|${token}`;
   if (dedup.has(key)) {
     return;
@@ -9007,9 +9400,9 @@ function cloneGlobal3(pattern) {
 function toPosixPath2(value) {
   return value.replace(/\\/g, "/");
 }
-async function readSafe5(target) {
+async function readSafe6(target) {
   try {
-    return await readFile20(target, "utf-8");
+    return await readFile22(target, "utf-8");
   } catch {
     return "";
   }
@@ -9098,7 +9491,7 @@ async function validateAtddCodeTraceability(root, config) {
         "QFAI-ATDD-901",
         `atdd-traceability report \u306E\u51FA\u529B\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${formatError7(error2)}`,
         "warning",
-        path29.join(resolvePath(root, config, "outDir"), "atdd-traceability"),
+        path31.join(resolvePath(root, config, "outDir"), "atdd-traceability"),
         "atddCodeTraceability.report"
       )
     );
@@ -9129,352 +9522,137 @@ function buildUnknownIssues(unknown) {
         "error",
         entry.file,
         "atddCodeTraceability.unknown.us",
-        refs,
-        "change",
-        "spec \u5074\u306B US \u3092\u5B9A\u7FA9\u3059\u308B\u304B\u3001\u30C6\u30B9\u30C8\u6CE8\u91C8\u3092\u6B63\u3057\u3044 ID \u3078\u4FEE\u6B63\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
-      );
-    }
-    if (entry.kind === "tc") {
-      return issue(
-        "QFAI-ATDD-102",
-        `\u672A\u5B9A\u7FA9\u306E TC \u53C2\u7167\u3092\u691C\u51FA\u3057\u307E\u3057\u305F: ${refs.join(", ")}`,
-        "error",
-        entry.file,
-        "atddCodeTraceability.unknown.tc",
-        refs,
-        "change",
-        "spec \u5074\u306B TC \u3092\u5B9A\u7FA9\u3059\u308B\u304B\u3001\u30C6\u30B9\u30C8\u6CE8\u91C8\u3092\u6B63\u3057\u3044 ID \u3078\u4FEE\u6B63\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
-      );
-    }
-    return issue(
-      "QFAI-ATDD-103",
-      `\u672A\u5B9A\u7FA9\u306E CON-API \u53C2\u7167\u3092\u691C\u51FA\u3057\u307E\u3057\u305F: ${refs.join(", ")}`,
-      "error",
-      entry.file,
-      "atddCodeTraceability.unknown.conApi",
-      refs,
-      "change",
-      "contracts/api \u306B CON-API \u3092\u5BA3\u8A00\u3059\u308B\u304B\u3001\u30C6\u30B9\u30C8\u6CE8\u91C8\u3092\u6B63\u3057\u3044 ID \u3078\u4FEE\u6B63\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
-    );
-  }).sort((left, right) => {
-    if (left.code !== right.code) {
-      return left.code.localeCompare(right.code);
-    }
-    return (left.file ?? "").localeCompare(right.file ?? "");
-  });
-}
-async function writeAtddTraceabilityReport(root, config, result) {
-  const outputDir = path29.join(resolvePath(root, config, "outDir"), "atdd-traceability");
-  await mkdir5(outputDir, { recursive: true });
-  const summary = {
-    missing: {
-      us: result.missing.us,
-      tc: result.missing.tc,
-      conApi: result.missing.conApi
-    },
-    unknown: result.unknown.map((entry) => ({
-      file: entry.file,
-      token: entry.token
-    })),
-    forbidden: {
-      tcInApi: result.forbidden.tcInApi,
-      tcInE2e: result.forbidden.tcInE2e
-    },
-    scan: {
-      matchedFileCount: result.scan.matchedFileCount,
-      truncated: result.scan.truncated,
-      limit: result.scan.limit,
-      globs: result.scan.globs
-    }
-  };
-  await writeFile4(
-    path29.join(outputDir, "summary.json"),
-    `${JSON.stringify(summary, null, 2)}
-`,
-    "utf-8"
-  );
-  await writeFile4(path29.join(outputDir, "summary.md"), buildSummaryMarkdown(summary), "utf-8");
-}
-function buildSummaryMarkdown(summary) {
-  const lines = [];
-  lines.push("# ATDD Traceability Summary");
-  lines.push("");
-  lines.push("## Missing Coverage");
-  lines.push("");
-  lines.push("- US -> E2E");
-  lines.push(...toList(summary.missing.us));
-  lines.push("- TC -> Integration");
-  lines.push(...toList(summary.missing.tc));
-  lines.push("- CON-API -> API");
-  lines.push(...toList(summary.missing.conApi));
-  lines.push("");
-  lines.push("## Unknown References");
-  lines.push("");
-  if (summary.unknown.length === 0) {
-    lines.push("- \u306A\u3057");
-  } else {
-    for (const item of summary.unknown) {
-      lines.push(`- ${item.token} (${item.file})`);
-    }
-  }
-  lines.push("");
-  lines.push("## Forbidden References");
-  lines.push("");
-  lines.push("- TC in tests/api/**");
-  lines.push(...toFileIdList(summary.forbidden.tcInApi));
-  lines.push("- TC in tests/e2e/**");
-  lines.push(...toFileIdList(summary.forbidden.tcInE2e));
-  lines.push("");
-  lines.push("## Scan");
-  lines.push("");
-  lines.push(`- matchedFileCount: ${summary.scan.matchedFileCount}`);
-  lines.push(`- truncated: ${summary.scan.truncated ? "true" : "false"}`);
-  lines.push(`- limit: ${summary.scan.limit}`);
-  lines.push("- globs:");
-  for (const glob of summary.scan.globs) {
-    lines.push(`  - ${glob}`);
-  }
-  lines.push("");
-  return `${lines.join("\n")}
-`;
-}
-function toList(items) {
-  if (items.length === 0) {
-    return ["  - \u306A\u3057"];
-  }
-  return items.map((item) => `  - ${item}`);
-}
-function toFileIdList(items) {
-  if (items.length === 0) {
-    return ["  - \u306A\u3057"];
-  }
-  return items.map((item) => `  - ${item.file}: ${item.ids.join(", ")}`);
-}
-function formatError7(error2) {
-  if (error2 instanceof Error) {
-    return error2.message;
-  }
-  return String(error2);
-}
-
-// src/core/validators/discussionPack.ts
-import { readFile as readFile22, stat as stat4 } from "fs/promises";
-import path31 from "path";
-
-// src/core/discussionPack.ts
-import { readFile as readFile21, stat as stat3 } from "fs/promises";
-import path30 from "path";
-var REQUIRED_DISCUSSION_PACK_FILES = [
-  "01_Context.md",
-  "02_Inception-Deck.md",
-  "03_Story-Workshop.md",
-  "04_Sources.md",
-  "05_Scope.md",
-  "06_REQ.md",
-  "07_NFR.md",
-  "08_Glossary.md",
-  "09_Constraints.md",
-  "10_Policy.md",
-  "11_OQ-Register.md",
-  "12_OQ-Resolution-Log.md",
-  "13_Deferred.md",
-  "14_Review-Request.md",
-  "99_delta.md"
-];
-var PLACEHOLDER_LINE_RE = /^(?:[-*]\s*)?(?:tbd|todo|none|n\/a|placeholder|\(placeholder\)|to be defined|to be updated|<[^>]+>)\.?$/i;
-async function inspectLatestDiscussionPack(discussionRoot) {
-  const packs = await findPacks(discussionRoot, "discussion");
-  const legacyPackNames = packs.filter((pack) => pack.isLegacy).map((pack) => pack.name).sort((left, right) => left.localeCompare(right));
-  const dangerousPackNames = packs.filter((pack) => pack.isDangerous).map((pack) => pack.name).sort((left, right) => left.localeCompare(right));
-  const latest = latestPack(packs);
-  const latestPackDir = latest?.path ?? null;
-  const latestPackName = latest?.name ?? null;
-  if (!latestPackDir) {
-    return {
-      discussionRoot,
-      latestPackDir: null,
-      latestPackName,
-      legacyPackNames,
-      dangerousPackNames,
-      missingFiles: [...REQUIRED_DISCUSSION_PACK_FILES],
-      incompleteFiles: [],
-      blockingOqIds: [],
-      deferredWithoutDetails: []
-    };
-  }
-  const missingFiles = [];
-  const incompleteFiles = [];
-  let blockingOqIds = [];
-  let deferredWithoutDetails = [];
-  for (const fileName of REQUIRED_DISCUSSION_PACK_FILES) {
-    const target = path30.join(latestPackDir, fileName);
-    const content = await readSafe6(target);
-    if (content === null) {
-      missingFiles.push(fileName);
-      continue;
-    }
-    if (isDiscussionPackFileIncomplete(content)) {
-      incompleteFiles.push(fileName);
-    }
-    if (fileName === "11_OQ-Register.md") {
-      blockingOqIds = extractBlockingOqIds(content);
-    }
-  }
-  const oqRegisterContent = await readSafe6(path30.join(latestPackDir, "11_OQ-Register.md"));
-  const deferredContent = await readSafe6(path30.join(latestPackDir, "13_Deferred.md"));
-  if (oqRegisterContent !== null && deferredContent !== null) {
-    deferredWithoutDetails = extractDeferredWithoutDetails(oqRegisterContent, deferredContent);
-  }
-  return {
-    discussionRoot,
-    latestPackDir,
-    latestPackName,
-    legacyPackNames,
-    dangerousPackNames,
-    missingFiles,
-    incompleteFiles,
-    blockingOqIds,
-    deferredWithoutDetails
-  };
-}
-async function findLatestDiscussionPackDir(discussionRoot) {
-  const packs = await findPacks(discussionRoot, "discussion");
-  return latestPack(packs)?.path ?? null;
-}
-function isDiscussionPackFileIncomplete(text) {
-  const normalized = text.replace(/\r\n/g, "\n").trim();
-  if (normalized.length < 100) {
-    return true;
-  }
-  const contentLines = normalized.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).filter((line) => !line.startsWith("#")).filter((line) => !/^\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)*\|?$/.test(line));
-  if (contentLines.length === 0) {
-    return true;
-  }
-  if (contentLines.every((line) => isPlaceholderLine(line))) {
-    return true;
-  }
-  return false;
-}
-function isPlaceholderLine(line) {
-  const plain = line.replace(/[`*_~]/g, "").replace(/\|/g, " ").replace(/\s+/g, " ").trim();
-  return PLACEHOLDER_LINE_RE.test(plain);
-}
-function extractBlockingOqIds(text) {
-  const lines = text.replace(/\r\n/g, "\n").split("\n");
-  const oqStates = /* @__PURE__ */ new Map();
-  let currentId = null;
-  for (const line of lines) {
-    const idMatch = /\b(OQ-\d+)\b/i.exec(line);
-    if (idMatch?.[1]) {
-      currentId = idMatch[1].toUpperCase();
-    }
-    if (currentId !== null) {
-      const state = oqStates.get(currentId) ?? { disposition: null };
-      const disposition = /^\s*-\s*Disposition\s*:\s*([^\s#]+)/i.exec(line)?.[1] ?? null;
-      if (disposition) {
-        state.disposition = disposition.toLowerCase();
-      }
-      oqStates.set(currentId, state);
+        refs,
+        "change",
+        "spec \u5074\u306B US \u3092\u5B9A\u7FA9\u3059\u308B\u304B\u3001\u30C6\u30B9\u30C8\u6CE8\u91C8\u3092\u6B63\u3057\u3044 ID \u3078\u4FEE\u6B63\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+      );
     }
-    if (line.trim().startsWith("|")) {
-      const cells = parseTableCells(line);
-      for (const cell of cells) {
-        const oqMatch = /\b(OQ-\d+)\b/i.exec(cell);
-        if (oqMatch?.[1]) {
-          currentId = oqMatch[1].toUpperCase();
-          const existingState = oqStates.get(currentId) ?? { disposition: null };
-          oqStates.set(currentId, existingState);
-        }
-      }
+    if (entry.kind === "tc") {
+      return issue(
+        "QFAI-ATDD-102",
+        `\u672A\u5B9A\u7FA9\u306E TC \u53C2\u7167\u3092\u691C\u51FA\u3057\u307E\u3057\u305F: ${refs.join(", ")}`,
+        "error",
+        entry.file,
+        "atddCodeTraceability.unknown.tc",
+        refs,
+        "change",
+        "spec \u5074\u306B TC \u3092\u5B9A\u7FA9\u3059\u308B\u304B\u3001\u30C6\u30B9\u30C8\u6CE8\u91C8\u3092\u6B63\u3057\u3044 ID \u3078\u4FEE\u6B63\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+      );
     }
-  }
-  const tableOqs = extractOqTableRows(text);
-  for (const row of tableOqs) {
-    if (row.id && row.disposition) {
-      const existing = oqStates.get(row.id) ?? { disposition: null };
-      existing.disposition = row.disposition;
-      oqStates.set(row.id, existing);
+    return issue(
+      "QFAI-ATDD-103",
+      `\u672A\u5B9A\u7FA9\u306E CON-API \u53C2\u7167\u3092\u691C\u51FA\u3057\u307E\u3057\u305F: ${refs.join(", ")}`,
+      "error",
+      entry.file,
+      "atddCodeTraceability.unknown.conApi",
+      refs,
+      "change",
+      "contracts/api \u306B CON-API \u3092\u5BA3\u8A00\u3059\u308B\u304B\u3001\u30C6\u30B9\u30C8\u6CE8\u91C8\u3092\u6B63\u3057\u3044 ID \u3078\u4FEE\u6B63\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    );
+  }).sort((left, right) => {
+    if (left.code !== right.code) {
+      return left.code.localeCompare(right.code);
     }
-  }
-  const blocking = Array.from(oqStates.entries()).filter(([, state]) => state.disposition === "open").map(([id]) => id).sort((left, right) => left.localeCompare(right));
-  return blocking;
+    return (left.file ?? "").localeCompare(right.file ?? "");
+  });
 }
-function extractOqTableRows(text) {
-  const lines = text.replace(/\r\n/g, "\n").split("\n");
-  const results = [];
-  let headerIndex = -1;
-  let oqIdCol = -1;
-  let dispositionCol = -1;
-  for (let i = 0; i < lines.length - 1; i++) {
-    const line = lines[i] ?? "";
-    if (!line.includes("|")) continue;
-    const cells = parseTableCells(line);
-    const normalizedCells = cells.map((c) => c.toLowerCase().replace(/[^a-z0-9-]/g, ""));
-    oqIdCol = normalizedCells.findIndex((c) => c === "oq-id" || c === "oqid");
-    dispositionCol = normalizedCells.findIndex((c) => c === "disposition");
-    if (oqIdCol >= 0 && dispositionCol >= 0) {
-      const sepLine = lines[i + 1] ?? "";
-      const sepCells = parseTableCells(sepLine);
-      if (sepCells.length === cells.length && sepCells.every((c) => /^:?-{3,}:?$/.test(c.trim()))) {
-        headerIndex = i;
-        break;
-      }
+async function writeAtddTraceabilityReport(root, config, result) {
+  const outputDir = path31.join(resolvePath(root, config, "outDir"), "atdd-traceability");
+  await mkdir5(outputDir, { recursive: true });
+  const summary = {
+    missing: {
+      us: result.missing.us,
+      tc: result.missing.tc,
+      conApi: result.missing.conApi
+    },
+    unknown: result.unknown.map((entry) => ({
+      file: entry.file,
+      token: entry.token
+    })),
+    forbidden: {
+      tcInApi: result.forbidden.tcInApi,
+      tcInE2e: result.forbidden.tcInE2e
+    },
+    scan: {
+      matchedFileCount: result.scan.matchedFileCount,
+      truncated: result.scan.truncated,
+      limit: result.scan.limit,
+      globs: result.scan.globs
     }
-  }
-  if (headerIndex < 0) return results;
-  for (let i = headerIndex + 2; i < lines.length; i++) {
-    const line = lines[i] ?? "";
-    if (!line.trim().startsWith("|")) break;
-    const cells = parseTableCells(line);
-    const oqIdRaw = cells[oqIdCol] ?? "";
-    const dispositionRaw = cells[dispositionCol] ?? "";
-    const oqMatch = /\b(OQ-\d+)\b/i.exec(oqIdRaw);
-    if (oqMatch?.[1]) {
-      results.push({
-        id: oqMatch[1].toUpperCase(),
-        disposition: dispositionRaw.trim().toLowerCase()
-      });
+  };
+  await writeFile4(
+    path31.join(outputDir, "summary.json"),
+    `${JSON.stringify(summary, null, 2)}
+`,
+    "utf-8"
+  );
+  await writeFile4(path31.join(outputDir, "summary.md"), buildSummaryMarkdown(summary), "utf-8");
+}
+function buildSummaryMarkdown(summary) {
+  const lines = [];
+  lines.push("# ATDD Traceability Summary");
+  lines.push("");
+  lines.push("## Missing Coverage");
+  lines.push("");
+  lines.push("- US -> E2E");
+  lines.push(...toList(summary.missing.us));
+  lines.push("- TC -> Integration");
+  lines.push(...toList(summary.missing.tc));
+  lines.push("- CON-API -> API");
+  lines.push(...toList(summary.missing.conApi));
+  lines.push("");
+  lines.push("## Unknown References");
+  lines.push("");
+  if (summary.unknown.length === 0) {
+    lines.push("- \u306A\u3057");
+  } else {
+    for (const item of summary.unknown) {
+      lines.push(`- ${item.token} (${item.file})`);
     }
   }
-  return results;
-}
-function extractDeferredWithoutDetails(oqRegisterText, deferredText) {
-  const registerRows = extractOqTableRows(oqRegisterText);
-  const deferredIds = registerRows.filter((row) => row.disposition === "deferred").map((row) => row.id);
-  if (deferredIds.length === 0) return [];
-  const deferredDetailSet = extractAllOqIds(deferredText);
-  return deferredIds.filter((id) => !deferredDetailSet.has(id));
+  lines.push("");
+  lines.push("## Forbidden References");
+  lines.push("");
+  lines.push("- TC in tests/api/**");
+  lines.push(...toFileIdList(summary.forbidden.tcInApi));
+  lines.push("- TC in tests/e2e/**");
+  lines.push(...toFileIdList(summary.forbidden.tcInE2e));
+  lines.push("");
+  lines.push("## Scan");
+  lines.push("");
+  lines.push(`- matchedFileCount: ${summary.scan.matchedFileCount}`);
+  lines.push(`- truncated: ${summary.scan.truncated ? "true" : "false"}`);
+  lines.push(`- limit: ${summary.scan.limit}`);
+  lines.push("- globs:");
+  for (const glob of summary.scan.globs) {
+    lines.push(`  - ${glob}`);
+  }
+  lines.push("");
+  return `${lines.join("\n")}
+`;
 }
-function extractAllOqIds(text) {
-  const ids = /* @__PURE__ */ new Set();
-  const re = /\b(OQ-\d+)\b/gi;
-  let match;
-  while ((match = re.exec(text)) !== null) {
-    if (match[1]) {
-      ids.add(match[1].toUpperCase());
-    }
+function toList(items) {
+  if (items.length === 0) {
+    return ["  - \u306A\u3057"];
   }
-  return ids;
+  return items.map((item) => `  - ${item}`);
 }
-function parseTableCells(line) {
-  const trimmed = line.trim();
-  if (!trimmed.startsWith("|")) return [];
-  const normalized = trimmed.replace(/^\|/, "").replace(/\|$/, "");
-  return normalized.split("|").map((cell) => cell.trim());
+function toFileIdList(items) {
+  if (items.length === 0) {
+    return ["  - \u306A\u3057"];
+  }
+  return items.map((item) => `  - ${item.file}: ${item.ids.join(", ")}`);
 }
-async function readSafe6(filePath) {
-  try {
-    const stats = await stat3(filePath);
-    if (!stats.isFile()) {
-      return null;
-    }
-    return await readFile21(filePath, "utf-8");
-  } catch {
-    return null;
+function formatError7(error2) {
+  if (error2 instanceof Error) {
+    return error2.message;
   }
+  return String(error2);
 }
 
 // src/core/validators/discussionPack.ts
+import { readFile as readFile23, stat as stat4 } from "fs/promises";
+import path32 from "path";
 async function validateDiscussionPackReadiness(root, config) {
   const discussionRoot = resolvePath(root, config, "discussionDir");
   const readiness = await inspectLatestDiscussionPack(discussionRoot);
@@ -9566,7 +9744,7 @@ async function validateDiscussionPackReadiness(root, config) {
     );
   }
   if (readiness.blockingOqIds.length > 0) {
-    const oqPath = path31.join(readiness.latestPackDir, "11_OQ-Register.md");
+    const oqPath = path32.join(readiness.latestPackDir, "11_OQ-Register.md");
     issues.push(
       issue(
         "QFAI-DPACK-004",
@@ -9581,7 +9759,7 @@ async function validateDiscussionPackReadiness(root, config) {
     );
   }
   if (readiness.deferredWithoutDetails.length > 0) {
-    const deferredPath = path31.join(readiness.latestPackDir, "13_Deferred.md");
+    const deferredPath = path32.join(readiness.latestPackDir, "13_Deferred.md");
     issues.push(
       issue(
         "QFAI-DPACK-007",
@@ -9595,7 +9773,7 @@ async function validateDiscussionPackReadiness(root, config) {
       )
     );
   }
-  const storyWorkshopPath = path31.join(readiness.latestPackDir, "03_Story-Workshop.md");
+  const storyWorkshopPath = path32.join(readiness.latestPackDir, "03_Story-Workshop.md");
   const storyWorkshopText = await readSafe7(storyWorkshopPath);
   if (storyWorkshopText !== null && !containsMermaidBlock(storyWorkshopText)) {
     issues.push(
@@ -9622,28 +9800,28 @@ async function readSafe7(filePath) {
     if (!stats.isFile()) {
       return null;
     }
-    return await readFile22(filePath, "utf-8");
+    return await readFile23(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 
 // src/core/validators/discussionVisuals.ts
-import { readFile as readFile23 } from "fs/promises";
-import path32 from "path";
+import { readFile as readFile24 } from "fs/promises";
+import path33 from "path";
 var MERMAID_FENCE_RE = /^\s*(?:`{3,}|~{3,})\s*mermaid\b/im;
 var SCREEN_MOCK_HEADING_RE = /^\s*#{1,6}\s*screen mock(?:\s*[-\u2014]+\s*fallback)?\s*\(html\+css\)\s*$/im;
 var HTML_FENCE_RE = /^\s*(?:`{3,}|~{3,})\s*html\b/im;
 var CSS_FENCE_RE = /^\s*(?:`{3,}|~{3,})\s*css\b/im;
 var UI_HINT_RE = /\b(?:ui|ux|screen|screens|page|pages|layout|wireframe|mock|form|button|frontend|navigation)\b|画面|モック|遷移|フォーム|ボタン/i;
 async function validateDiscussionVisuals(root) {
-  const discussionRoot = path32.join(root, ".qfai", "discussion");
+  const discussionRoot = path33.join(root, ".qfai", "discussion");
   const latestPackDir = await findLatestDiscussionPackDir(discussionRoot);
   if (!latestPackDir) {
     return [];
   }
   const issues = [];
-  const inceptionPath = path32.join(latestPackDir, "02_Inception-Deck.md");
+  const inceptionPath = path33.join(latestPackDir, "02_Inception-Deck.md");
   const inceptionText = await readSafe8(inceptionPath);
   if (inceptionText !== null && !MERMAID_FENCE_RE.test(inceptionText)) {
     issues.push(
@@ -9659,7 +9837,7 @@ async function validateDiscussionVisuals(root) {
       )
     );
   }
-  const storyWorkshopPath = path32.join(latestPackDir, "03_Story-Workshop.md");
+  const storyWorkshopPath = path33.join(latestPackDir, "03_Story-Workshop.md");
   const storyWorkshopText = await readSafe8(storyWorkshopPath);
   const storyWorkshopPlainText = storyWorkshopText === null ? null : stripFencedCodeBlocks(storyWorkshopText);
   if (storyWorkshopText === null || storyWorkshopPlainText === null) {
@@ -9723,14 +9901,14 @@ function escapeRegExp2(value) {
 }
 async function readSafe8(filePath) {
   try {
-    return await readFile23(filePath, "utf-8");
+    return await readFile24(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 
 // src/core/validators/densityHints.ts
-import { readFile as readFile24 } from "fs/promises";
+import { readFile as readFile25 } from "fs/promises";
 var BR_ID_RE = /\bBR-[A-Za-z0-9-]+\b/g;
 var SCENARIO_RE = /^\s*Scenario(?:\s+Outline)?\s*:/gim;
 var TC_OR_CASE_RE = /\b(?:TC|CASE)-[A-Za-z0-9-]+\b/g;
@@ -9829,7 +10007,7 @@ function isSeparatorRow(line) {
 }
 async function readSafe9(filePath) {
   try {
-    return await readFile24(filePath, "utf-8");
+    return await readFile25(filePath, "utf-8");
   } catch {
     return "";
   }
@@ -9837,11 +10015,11 @@ async function readSafe9(filePath) {
 
 // src/core/validators/importLite.ts
 import { readdir as readdir7 } from "fs/promises";
-import path33 from "path";
+import path34 from "path";
 
 // src/core/validators/layerCoverage.ts
 import { mkdir as mkdir6, writeFile as writeFile5 } from "fs/promises";
-import path34 from "path";
+import path35 from "path";
 var ID_PATTERNS = {
   us: /^US-\d{4}(?:-\d{4})?$/,
   ac: /^AC-\d{4}(?:-\d{4})?$/,
@@ -9862,7 +10040,7 @@ async function validateLayerCoverage(root, config) {
   if (layeredEntries.length === 0) {
     return issues;
   }
-  const coverageRoot = path34.join(resolvePath(root, config, "outDir"), "specs-coverage");
+  const coverageRoot = path35.join(resolvePath(root, config, "outDir"), "specs-coverage");
   for (const entry of layeredEntries) {
     if (isV1421LayeredEntry(entry)) {
       const coverageResult = await validateV1421Coverage(entry);
@@ -9897,7 +10075,7 @@ async function validateLayerCoverage(root, config) {
 }
 async function validatePlanArtifacts(specsRoot, entries) {
   const issues = [];
-  const deprecatedPlanPath = path34.join(specsRoot, "plan.md");
+  const deprecatedPlanPath = path35.join(specsRoot, "plan.md");
   if (await exists8(deprecatedPlanPath)) {
     issues.push(
       issue(
@@ -9913,14 +10091,14 @@ async function validatePlanArtifacts(specsRoot, entries) {
     );
   }
   for (const entry of entries) {
-    const planFileName = path34.basename(entry.planPath).toLowerCase();
+    const planFileName = path35.basename(entry.planPath).toLowerCase();
     if (planFileName !== "10_plan.md") {
       continue;
     }
     if (!await exists8(entry.planPath)) {
       continue;
     }
-    const text = await readSafe(entry.planPath);
+    const text = await readSafe2(entry.planPath);
     const headings = extractHeadings(text);
     const forbiddenHeadingGroups = [
       {
@@ -9979,10 +10157,10 @@ async function validatePlanArtifacts(specsRoot, entries) {
 }
 async function validateV1421Coverage(entry) {
   const [acText, brText, exText, tcText] = await Promise.all([
-    readSafe(entry.acceptanceCriteriaPath),
-    readSafe(entry.businessRulesPath),
-    readSafe(entry.examplesPath),
-    readSafe(entry.testCasesPath)
+    readSafe2(entry.acceptanceCriteriaPath),
+    readSafe2(entry.businessRulesPath),
+    readSafe2(entry.examplesPath),
+    readSafe2(entry.testCasesPath)
   ]);
   const acIds = parseAcceptanceCriteriaIds2(acText);
   const brToAcRefs = parseDefinitionRefs(brText, "BR", V1421_REFS.ac, {
@@ -10295,7 +10473,7 @@ function buildSignalRows(prefix, counts, target) {
 }
 async function writeCoverageReport(coverageRoot, specNumber, snapshot) {
   await mkdir6(coverageRoot, { recursive: true });
-  const reportPath = path34.join(coverageRoot, `spec-${specNumber}.md`);
+  const reportPath = path35.join(coverageRoot, `spec-${specNumber}.md`);
   const lines = [];
   lines.push(`# Spec Coverage (spec-${specNumber})`);
   lines.push("");
@@ -10340,7 +10518,7 @@ function isV1421LayeredEntry(entry) {
   if (entry.layeredStyle === "v1421") {
     return true;
   }
-  return path34.extname(entry.examplesPath).toLowerCase() === ".md";
+  return path35.extname(entry.examplesPath).toLowerCase() === ".md";
 }
 function extractHeadings(text) {
   const headings = [];
@@ -10413,8 +10591,8 @@ async function validateUsToAcCoverage(userStoriesPath, acceptanceCriteriaPath) {
   if (!await exists8(userStoriesPath) || !await exists8(acceptanceCriteriaPath)) {
     return [];
   }
-  const usItems = collectMarkdownItems(await readSafe(userStoriesPath), "US");
-  const acItems = collectMarkdownItems(await readSafe(acceptanceCriteriaPath), "AC");
+  const usItems = collectMarkdownItems(await readSafe2(userStoriesPath), "US");
+  const acItems = collectMarkdownItems(await readSafe2(acceptanceCriteriaPath), "AC");
   const usIds = usItems.map((item) => item.id).filter((id) => ID_PATTERNS.us.test(id));
   if (usIds.length === 0) {
     return [];
@@ -10443,8 +10621,8 @@ async function validateAcToBrCoverage(acceptanceCriteriaPath, businessRulesPath)
   if (!await exists8(acceptanceCriteriaPath) || !await exists8(businessRulesPath)) {
     return [];
   }
-  const acItems = collectMarkdownItems(await readSafe(acceptanceCriteriaPath), "AC");
-  const brItems = collectMarkdownItems(await readSafe(businessRulesPath), "BR");
+  const acItems = collectMarkdownItems(await readSafe2(acceptanceCriteriaPath), "AC");
+  const brItems = collectMarkdownItems(await readSafe2(businessRulesPath), "BR");
   const acIds = acItems.map((item) => item.id).filter((id) => ID_PATTERNS.ac.test(id));
   if (acIds.length === 0) {
     return [];
@@ -10473,8 +10651,8 @@ async function validateBrToExCoverage(businessRulesPath, examplesPath) {
   if (!await exists8(businessRulesPath) || !await exists8(examplesPath)) {
     return [];
   }
-  const brItems = collectMarkdownItems(await readSafe(businessRulesPath), "BR");
-  const exItems = collectScenarioItems(await readSafe(examplesPath));
+  const brItems = collectMarkdownItems(await readSafe2(businessRulesPath), "BR");
+  const exItems = collectScenarioItems(await readSafe2(examplesPath));
   const brIds = brItems.map((item) => item.id).filter((id) => ID_PATTERNS.br.test(id));
   if (brIds.length === 0) {
     return [];
@@ -10503,8 +10681,8 @@ async function validateExToTcCoverage(examplesPath, testCasesPath) {
   if (!await exists8(examplesPath) || !await exists8(testCasesPath)) {
     return [];
   }
-  const exItems = collectScenarioItems(await readSafe(examplesPath));
-  const tcItems = collectMarkdownItems(await readSafe(testCasesPath), "TC");
+  const exItems = collectScenarioItems(await readSafe2(examplesPath));
+  const tcItems = collectMarkdownItems(await readSafe2(testCasesPath), "TC");
   const exIds = exItems.map((item) => item.exId.replace(/^@/, "")).filter((id) => ID_PATTERNS.ex.test(id));
   if (exIds.length === 0) {
     return [];
@@ -10532,7 +10710,7 @@ async function validateExToTcCoverage(examplesPath, testCasesPath) {
 
 // src/core/validators/layeredTraceability.ts
 import { readdir as readdir8 } from "fs/promises";
-import path35 from "path";
+import path36 from "path";
 var POLICIES_FILES = [
   "01_Objective.md",
   "02_Initiative.md",
@@ -10581,7 +10759,7 @@ async function validateLayeredTraceability(root, config) {
   }
   const issues = [];
   if (layeredV1417Entries.length > 0) {
-    const policiesDir = layeredV1417Entries[0]?.sharedDir ?? path35.join(specsRoot, "_policies");
+    const policiesDir = layeredV1417Entries[0]?.sharedDir ?? path36.join(specsRoot, "_policies");
     issues.push(...await validatePoliciesDownstreamReferences(policiesDir));
     for (const entry of layeredV1417Entries) {
       issues.push(...await validateSpecRootParent(entry));
@@ -10622,7 +10800,7 @@ async function validateLayeredTraceability(root, config) {
     }
   }
   if (layeredV1421Entries.length > 0) {
-    const policiesDir = layeredV1421Entries[0]?.sharedDir ?? path35.join(specsRoot, "_policies");
+    const policiesDir = layeredV1421Entries[0]?.sharedDir ?? path36.join(specsRoot, "_policies");
     issues.push(...await validatePoliciesScopeForV1421(policiesDir));
     for (const entry of layeredV1421Entries) {
       issues.push(...await validateDownstreamRefsForV1421(entry));
@@ -10633,8 +10811,8 @@ async function validateLayeredTraceability(root, config) {
 async function validatePoliciesDownstreamReferences(policiesDir) {
   const issues = [];
   for (const fileName of POLICIES_FILES) {
-    const filePath = path35.join(policiesDir, fileName);
-    const text = await readSafe(filePath);
+    const filePath = path36.join(policiesDir, fileName);
+    const text = await readSafe2(filePath);
     if (text.trim().length === 0) {
       continue;
     }
@@ -10662,7 +10840,7 @@ async function validatePoliciesScopeForV1421(policiesDir) {
   }
   const issues = [];
   for (const filePath of files) {
-    const text = await readSafe(filePath);
+    const text = await readSafe2(filePath);
     if (text.trim().length === 0) {
       continue;
     }
@@ -10693,7 +10871,7 @@ async function validateDownstreamRefsForV1421(entry) {
   ];
   const issues = [];
   for (const check of checks) {
-    const text = await readSafe(check.filePath);
+    const text = await readSafe2(check.filePath);
     if (text.trim().length === 0) {
       continue;
     }
@@ -10706,7 +10884,7 @@ async function validateDownstreamRefsForV1421(entry) {
     issues.push(
       issue(
         "TRACE_DOWNSTREAM_REF",
-        `${path35.basename(check.filePath)} \u3067\u4E0B\u4F4D\u30EC\u30A4\u30E4\u30FC\u53C2\u7167\u306F\u7981\u6B62\u3067\u3059: ${refs.join(", ")}`,
+        `${path36.basename(check.filePath)} \u3067\u4E0B\u4F4D\u30EC\u30A4\u30E4\u30FC\u53C2\u7167\u306F\u7981\u6B62\u3067\u3059: ${refs.join(", ")}`,
         "error",
         check.filePath,
         "layeredTraceability.downstream",
@@ -10736,14 +10914,14 @@ function resolveLayerFromId(id) {
 async function collectMarkdownFiles(policiesDir) {
   try {
     const entries = await readdir8(policiesDir, { withFileTypes: true });
-    return entries.filter((entry) => entry.isFile() && path35.extname(entry.name).toLowerCase() === ".md").map((entry) => path35.join(policiesDir, entry.name)).sort((left, right) => left.localeCompare(right));
+    return entries.filter((entry) => entry.isFile() && path36.extname(entry.name).toLowerCase() === ".md").map((entry) => path36.join(policiesDir, entry.name)).sort((left, right) => left.localeCompare(right));
   } catch {
     return [];
   }
 }
 async function validateSpecRootParent(entry) {
-  const specPath = path35.join(entry.dir, "01_Spec.md");
-  const text = await readSafe(specPath);
+  const specPath = path36.join(entry.dir, "01_Spec.md");
+  const text = await readSafe2(specPath);
   if (text.trim().length > 0 && /\bCAP-\d{4}\b/.test(text)) {
     return [];
   }
@@ -10758,7 +10936,7 @@ async function validateSpecRootParent(entry) {
   ];
 }
 async function validateMarkdownParentFormat(filePath, prefix, parentFormat, parentPrefix) {
-  const text = await readSafe(filePath);
+  const text = await readSafe2(filePath);
   const items = collectMarkdownItems(text, prefix);
   const issues = [];
   for (const item of items) {
@@ -10791,7 +10969,7 @@ async function validateMarkdownParentFormat(filePath, prefix, parentFormat, pare
   return issues;
 }
 async function validateExamplesParentFormat(filePath) {
-  const text = await readSafe(filePath);
+  const text = await readSafe2(filePath);
   const scenarios = collectScenarioItems(text);
   const issues = [];
   for (const scenario of scenarios) {
@@ -10824,7 +11002,7 @@ async function validateExamplesParentFormat(filePath) {
   return issues;
 }
 async function validateForbiddenRefs(filePath, pattern, messagePrefix) {
-  const text = await readSafe(filePath);
+  const text = await readSafe2(filePath);
   const refs = uniqueMatches(text, pattern);
   if (refs.length === 0) {
     return [];
@@ -10843,10 +11021,10 @@ async function validateForbiddenRefs(filePath, pattern, messagePrefix) {
 
 // src/core/validators/legacyStatusDir.ts
 import { readdir as readdir9, stat as stat5 } from "fs/promises";
-import path36 from "path";
+import path37 from "path";
 var BASELINE_STATUS_ARTIFACTS = /* @__PURE__ */ new Set(["README.md", ".gitignore"]);
 async function validateLegacyStatusDir(root) {
-  const statusDir = path36.join(root, ".qfai", "status");
+  const statusDir = path37.join(root, ".qfai", "status");
   if (!await isDirectory(statusDir)) {
     return [];
   }
@@ -10898,15 +11076,15 @@ async function isDirectory(target) {
 }
 
 // src/core/validators/mermaidEnforcement.ts
-import { readFile as readFile25 } from "fs/promises";
-import path37 from "path";
+import { readFile as readFile26 } from "fs/promises";
+import path38 from "path";
 var TARGETS = [
   { segments: [".qfai", "specs"], extensions: [".md", ".feature"] },
   { segments: [".qfai", "discussion"], extensions: [".md"] }
 ];
 var BUSINESS_FLOW_RELATIVE_CANDIDATES = [
-  path37.join(".qfai", "specs", "_policies", "04_Business-Flow.md"),
-  path37.join(".qfai", "specs", "_policies", "04_Business-flow.md")
+  path38.join(".qfai", "specs", "_policies", "04_Business-Flow.md"),
+  path38.join(".qfai", "specs", "_policies", "04_Business-flow.md")
 ];
 var MERMAID_DIRECTIVE_RE = /^\s*(?:sequenceDiagram|flowchart|erDiagram|classDiagram|stateDiagram(?:-v2)?|journey|gantt|graph\s+(?:TB|BT|RL|LR|TD))\b/i;
 var FLOW_OR_SEQUENCE_RE2 = /\b(?:sequenceDiagram|flowchart)\b/i;
@@ -10916,13 +11094,13 @@ async function validateMermaidEnforcement(root) {
   const issues = [];
   const scanResults = /* @__PURE__ */ new Map();
   for (const filePath of targetFiles) {
-    const text = await readFile25(filePath, "utf-8");
+    const text = await readFile26(filePath, "utf-8");
     const result = scanMermaidUsage(filePath, text);
     scanResults.set(filePath, result);
     issues.push(...result.issues);
   }
   if (businessFlowPath) {
-    const businessFlowScan = scanResults.get(businessFlowPath) ?? scanMermaidUsage(businessFlowPath, await readFile25(businessFlowPath, "utf-8"));
+    const businessFlowScan = scanResults.get(businessFlowPath) ?? scanMermaidUsage(businessFlowPath, await readFile26(businessFlowPath, "utf-8"));
     if (businessFlowScan.mermaidFenceCount === 0) {
       issues.push(
         issue(
@@ -10950,7 +11128,7 @@ async function validateMermaidEnforcement(root) {
         )
       );
     }
-    if (path37.basename(businessFlowPath) === "04_Business-flow.md") {
+    if (path38.basename(businessFlowPath) === "04_Business-flow.md") {
       issues.push(
         issue(
           "QFAI-MMD-005",
@@ -10971,14 +11149,14 @@ async function validateMermaidEnforcement(root) {
 async function collectTargetFiles(root) {
   const files = [];
   for (const target of TARGETS) {
-    const targetDir = path37.join(root, ...target.segments);
+    const targetDir = path38.join(root, ...target.segments);
     files.push(
       ...await collectFiles(targetDir, {
         extensions: [...target.extensions]
       })
     );
   }
-  return Array.from(new Set(files)).filter((filePath) => path37.basename(filePath).toLowerCase() !== "readme.md").sort((a, b) => a.localeCompare(b));
+  return Array.from(new Set(files)).filter((filePath) => path38.basename(filePath).toLowerCase() !== "readme.md").sort((a, b) => a.localeCompare(b));
 }
 function scanMermaidUsage(filePath, text) {
   const lines = text.replace(/\r\n/g, "\n").split("\n");
@@ -11068,13 +11246,13 @@ function parseFenceStart(line) {
   };
 }
 async function collectDeprecatedBusinessFlowFeatureWarnings(root) {
-  const policiesDir = path37.join(root, ".qfai", "specs", "_policies");
+  const policiesDir = path38.join(root, ".qfai", "specs", "_policies");
   const featureFiles = await collectFiles(policiesDir, {
     extensions: [".feature"]
   });
   const issues = [];
   for (const filePath of featureFiles) {
-    if (!/business-flow/i.test(path37.basename(filePath))) {
+    if (!/business-flow/i.test(path38.basename(filePath))) {
       continue;
     }
     issues.push(
@@ -11094,7 +11272,7 @@ async function collectDeprecatedBusinessFlowFeatureWarnings(root) {
 }
 async function resolveBusinessFlowPath(root) {
   for (const relativePath of BUSINESS_FLOW_RELATIVE_CANDIDATES) {
-    const target = path37.join(root, relativePath);
+    const target = path38.join(root, relativePath);
     if (await exists8(target)) {
       return target;
     }
@@ -11120,7 +11298,7 @@ async function validateContractReferences(root, config) {
   const issues = [];
   const severity = config.validation.traceability.unknownContractIdSeverity;
   for (const filePath of Array.from(contractIndexFiles).sort((a, b) => a.localeCompare(b))) {
-    const text = await readSafe(filePath);
+    const text = await readSafe2(filePath);
     if (text.trim().length === 0) {
       continue;
     }
@@ -11232,7 +11410,7 @@ function normalizeHeaderKey(column) {
 }
 
 // src/core/validators/orphanProhibition.ts
-import path38 from "path";
+import path39 from "path";
 async function validateOrphanProhibition(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
   const entries = await collectSpecEntries(specsRoot);
@@ -11243,16 +11421,16 @@ async function validateOrphanProhibition(root, config) {
     return [];
   }
   const issues = [];
-  const policiesDir = layeredEntries[0]?.sharedDir ?? path38.join(specsRoot, "_policies");
+  const policiesDir = layeredEntries[0]?.sharedDir ?? path39.join(specsRoot, "_policies");
   const capIds = new Set(
-    uniqueMatches(await readSafe(path38.join(policiesDir, "03_Capabilities.md")), /\bCAP-\d{4}\b/g)
+    uniqueMatches(await readSafe2(path39.join(policiesDir, "03_Capabilities.md")), /\bCAP-\d{4}\b/g)
   );
   for (const entry of layeredEntries) {
-    const usItems = collectMarkdownItems(await readSafe(entry.userStoriesPath), "US");
-    const acItems = collectMarkdownItems(await readSafe(entry.acceptanceCriteriaPath), "AC");
-    const brItems = collectMarkdownItems(await readSafe(entry.businessRulesPath), "BR");
-    const exItems = collectScenarioItems(await readSafe(entry.examplesPath));
-    const tcItems = collectMarkdownItems(await readSafe(entry.testCasesPath), "TC");
+    const usItems = collectMarkdownItems(await readSafe2(entry.userStoriesPath), "US");
+    const acItems = collectMarkdownItems(await readSafe2(entry.acceptanceCriteriaPath), "AC");
+    const brItems = collectMarkdownItems(await readSafe2(entry.businessRulesPath), "BR");
+    const exItems = collectScenarioItems(await readSafe2(entry.examplesPath));
+    const tcItems = collectMarkdownItems(await readSafe2(entry.testCasesPath), "TC");
     const usIds = new Set(usItems.map((item) => item.id));
     const acIds = new Set(acItems.map((item) => item.id));
     const brIds = new Set(brItems.map((item) => item.id));
@@ -11395,8 +11573,8 @@ function validateExParentExists(filePath, exItems, acIds, brIds) {
 }
 
 // src/core/validators/prototypingEvidence.ts
-import { access as access12, readFile as readFile26 } from "fs/promises";
-import path39 from "path";
+import { access as access12, readFile as readFile27 } from "fs/promises";
+import path40 from "path";
 var EVIDENCE_MARKDOWN_FILE = "prototyping.md";
 var EVIDENCE_JSON_FILE = "prototyping.json";
 async function validatePrototypingEvidence(root, config) {
@@ -11405,10 +11583,10 @@ async function validatePrototypingEvidence(root, config) {
   if (specEntries.length === 0) {
     return [];
   }
-  const qfaiRoot = path39.dirname(specsRoot);
-  const evidenceRoot = path39.join(qfaiRoot, "evidence");
-  const evidenceMarkdownPath = path39.join(evidenceRoot, EVIDENCE_MARKDOWN_FILE);
-  const evidenceJsonPath = path39.join(evidenceRoot, EVIDENCE_JSON_FILE);
+  const qfaiRoot = path40.dirname(specsRoot);
+  const evidenceRoot = path40.join(qfaiRoot, "evidence");
+  const evidenceMarkdownPath = path40.join(evidenceRoot, EVIDENCE_MARKDOWN_FILE);
+  const evidenceJsonPath = path40.join(evidenceRoot, EVIDENCE_JSON_FILE);
   const [markdownRaw, jsonRaw] = await Promise.all([
     readSafe10(evidenceMarkdownPath),
     readSafe10(evidenceJsonPath)
@@ -11585,7 +11763,7 @@ function extractSpecRefs(rows) {
 }
 async function readSafe10(filePath) {
   try {
-    return await readFile26(filePath, "utf-8");
+    return await readFile27(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -11741,7 +11919,7 @@ async function validateUiFidelity(root, config, evidenceJsonPath, evidence) {
   for (const screen of uiFidelity.screens) {
     const contractFiles = contractIndex.idToFiles.get(screen.uiContractId);
     const contractFile = contractFiles ? Array.from(contractFiles).sort((left, right) => left.localeCompare(right))[0] : void 0;
-    const contractRefFile = contractFile ? toPosixPath3(path39.relative(root, contractFile)) : void 0;
+    const contractRefFile = contractFile ? toPosixPath3(path40.relative(root, contractFile)) : void 0;
     if (!contractFiles || contractFiles.size === 0) {
       mismatches.push({
         contractId: screen.uiContractId,
@@ -12550,7 +12728,7 @@ async function collectMissingRenderArtifacts(root, render) {
     { label: "htmlPath", target: render.htmlPath }
   ];
   for (const candidate of candidates) {
-    const resolved = path39.isAbsolute(candidate.target) ? candidate.target : path39.resolve(root, candidate.target);
+    const resolved = path40.isAbsolute(candidate.target) ? candidate.target : path40.resolve(root, candidate.target);
     try {
       await access12(resolved);
     } catch {
@@ -12573,12 +12751,12 @@ function formatError9(error2) {
 }
 
 // src/core/validators/requireIndex.ts
-import { readFile as readFile27 } from "fs/promises";
-import path40 from "path";
+import { readFile as readFile28 } from "fs/promises";
+import path41 from "path";
 
 // src/core/validators/repositoryHygiene.ts
 import { readdir as readdir10, stat as stat6 } from "fs/promises";
-import path41 from "path";
+import path42 from "path";
 var LEGACY_DIR_RULES = [
   { legacy: "discussions", canonical: "discussion" },
   { legacy: "discuss", canonical: "discussion" },
@@ -12589,11 +12767,11 @@ var LEGACY_DIR_RULES = [
 ];
 var SUSPICIOUS_TEMPLATE_NAME_RE = /^(?:_?templates?|_?sample(?:s)?|sample-template)$/i;
 async function validateRepositoryHygiene(root, config) {
-  const qfaiRoot = path41.join(root, ".qfai");
+  const qfaiRoot = path42.join(root, ".qfai");
   const specsRoot = resolvePath(root, config, "specsDir");
   const issues = [];
   for (const rule of LEGACY_DIR_RULES) {
-    const legacyPath = path41.join(qfaiRoot, rule.legacy);
+    const legacyPath = path42.join(qfaiRoot, rule.legacy);
     if (!await isDirectory2(legacyPath)) {
       continue;
     }
@@ -12648,10 +12826,10 @@ async function collectSuspiciousTemplatePaths(root) {
       continue;
     }
     for (const entry of entries) {
-      const absolute = path41.join(current, entry.name);
+      const absolute = path42.join(current, entry.name);
       if (entry.isDirectory()) {
         if (SUSPICIOUS_TEMPLATE_NAME_RE.test(entry.name)) {
-          matches.push(toPosix(path41.relative(root, absolute)));
+          matches.push(toPosix(path42.relative(root, absolute)));
         }
         queue.push(absolute);
         continue;
@@ -12659,9 +12837,9 @@ async function collectSuspiciousTemplatePaths(root) {
       if (!entry.isFile()) {
         continue;
       }
-      const baseName = path41.parse(entry.name).name;
+      const baseName = path42.parse(entry.name).name;
       if (SUSPICIOUS_TEMPLATE_NAME_RE.test(baseName)) {
-        matches.push(toPosix(path41.relative(root, absolute)));
+        matches.push(toPosix(path42.relative(root, absolute)));
       }
     }
   }
@@ -12679,7 +12857,7 @@ function toPosix(value) {
 }
 
 // src/core/validators/specSplitByCapability.ts
-import path42 from "path";
+import path43 from "path";
 var CAP_ID_RE2 = /\bCAP-\d{4}\b/g;
 async function validateSpecSplitByCapability(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
@@ -12690,9 +12868,9 @@ async function validateSpecSplitByCapability(root, config) {
   if (layeredEntries.length === 0) {
     return [];
   }
-  const policiesDir = layeredEntries[0]?.sharedDir ?? path42.join(specsRoot, "_policies");
-  const capabilitiesPath = path42.join(policiesDir, "03_Capabilities.md");
-  const capabilityText = await readSafe(capabilitiesPath);
+  const policiesDir = layeredEntries[0]?.sharedDir ?? path43.join(specsRoot, "_policies");
+  const capabilitiesPath = path43.join(policiesDir, "03_Capabilities.md");
+  const capabilityText = await readSafe2(capabilitiesPath);
   const issues = [];
   if (!await exists8(capabilitiesPath)) {
     issues.push(
@@ -12731,7 +12909,7 @@ async function validateSpecSplitByCapability(root, config) {
     );
   }
   const actualSpecIds = new Set(
-    layeredEntries.map((entry) => path42.basename(entry.dir).toLowerCase())
+    layeredEntries.map((entry) => path43.basename(entry.dir).toLowerCase())
   );
   const expectedSpecIds = capIds.map((_, index) => `spec-${to4(index + 1)}`);
   const missingSpecIds = expectedSpecIds.filter((specId) => !actualSpecIds.has(specId));
@@ -12768,12 +12946,12 @@ async function validateSpecSplitByCapability(root, config) {
       continue;
     }
     const specId = `spec-${to4(index + 1)}`;
-    const entry = layeredEntries.find((value) => path42.basename(value.dir).toLowerCase() === specId);
+    const entry = layeredEntries.find((value) => path43.basename(value.dir).toLowerCase() === specId);
     if (!entry) {
       continue;
     }
-    const specFilePath = path42.join(entry.dir, "01_Spec.md");
-    const specText = await readSafe(specFilePath);
+    const specFilePath = path43.join(entry.dir, "01_Spec.md");
+    const specText = await readSafe2(specFilePath);
     if (specText.trim().length === 0 || !specText.includes(capId)) {
       issues.push(
         issue(
@@ -12791,8 +12969,8 @@ async function validateSpecSplitByCapability(root, config) {
 }
 
 // src/core/validators/statusInSpecs.ts
-import { readFile as readFile28 } from "fs/promises";
-import path43 from "path";
+import { readFile as readFile29 } from "fs/promises";
+import path44 from "path";
 var STRONG_PATTERNS = [
   { label: "release_candidate:", pattern: /\brelease_candidate\s*:/i },
   { label: "status:", pattern: /^\s*(?:-\s*)?status\s*:/im },
@@ -12849,23 +13027,23 @@ function hasMatch(text, pattern) {
 }
 async function readSafe11(filePath) {
   try {
-    return await readFile28(filePath, "utf-8");
+    return await readFile29(filePath, "utf-8");
   } catch {
     return "";
   }
 }
 function isOpenQuestionsFile(filePath) {
-  return /open-questions\.md$/i.test(path43.basename(filePath));
+  return /open-questions\.md$/i.test(path44.basename(filePath));
 }
 
 // src/core/validators/designToken.ts
-import { readFile as readFile29 } from "fs/promises";
-import path44 from "path";
+import { readFile as readFile30 } from "fs/promises";
+import path45 from "path";
 import fg2 from "fast-glob";
-import { parse as parseYaml6 } from "yaml";
+import { parse as parseYaml7 } from "yaml";
 
 // src/core/parse/designToken.ts
-import { parse as parseYaml5 } from "yaml";
+import { parse as parseYaml6 } from "yaml";
 var REF_PATTERN = /\{([^}]+)\}/g;
 var MAX_RESOLVE_DEPTH = 10;
 function parseDesignToken(yamlContent) {
@@ -12878,7 +13056,7 @@ function parseDesignToken(yamlContent) {
   };
   let parsed;
   try {
-    parsed = parseYaml5(yamlContent);
+    parsed = parseYaml6(yamlContent);
   } catch (error2) {
     const msg = error2 instanceof Error ? error2.message : String(error2);
     result.errors.push({ message: `YAML parse error: ${msg}` });
@@ -12907,7 +13085,7 @@ function collectLayer(layer, layerName, target, errors) {
 }
 function flattenTokens(obj, prefix, target, errors) {
   for (const [key, value] of Object.entries(obj)) {
-    const path64 = `${prefix}.${key}`;
+    const path67 = `${prefix}.${key}`;
     if (value && typeof value === "object" && !Array.isArray(value)) {
       const record2 = value;
       if ("$value" in record2) {
@@ -12923,9 +13101,9 @@ function flattenTokens(obj, prefix, target, errors) {
         if (typeof record2.platform === "string") {
           token.platform = record2.platform;
         }
-        target.set(path64, token);
+        target.set(path67, token);
       } else {
-        flattenTokens(record2, path64, target, errors);
+        flattenTokens(record2, path67, target, errors);
       }
     }
   }
@@ -12935,44 +13113,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 [path64] of allTokens) {
-    resolveTokenRef(path64, allTokens, /* @__PURE__ */ new Set(), 0, result);
+  for (const [path67] of allTokens) {
+    resolveTokenRef(path67, allTokens, /* @__PURE__ */ new Set(), 0, result);
   }
 }
-function resolveTokenRef(path64, allTokens, visited, depth, result) {
-  if (result.resolved.has(path64)) {
-    return result.resolved.get(path64);
+function resolveTokenRef(path67, allTokens, visited, depth, result) {
+  if (result.resolved.has(path67)) {
+    return result.resolved.get(path67);
   }
   if (depth > MAX_RESOLVE_DEPTH) {
     result.errors.push({
-      message: `Max reference depth exceeded at: ${path64}`,
-      path: path64
+      message: `Max reference depth exceeded at: ${path67}`,
+      path: path67
     });
     return void 0;
   }
-  if (visited.has(path64)) {
+  if (visited.has(path67)) {
     result.errors.push({
-      message: `Circular reference detected: ${path64}`,
-      path: path64
+      message: `Circular reference detected: ${path67}`,
+      path: path67
     });
     return void 0;
   }
-  const token = allTokens.get(path64);
+  const token = allTokens.get(path67);
   if (!token) {
     return void 0;
   }
   if (typeof token.$value !== "string") {
     const rawValue2 = stringifyTokenValue(token.$value);
-    result.resolved.set(path64, rawValue2);
+    result.resolved.set(path67, rawValue2);
     return rawValue2;
   }
   const rawValue = stringifyTokenValue(token.$value);
   const refs = [...rawValue.matchAll(REF_PATTERN)];
   if (refs.length === 0) {
-    result.resolved.set(path64, rawValue);
+    result.resolved.set(path67, rawValue);
     return rawValue;
   }
-  visited.add(path64);
+  visited.add(path67);
   let resolved = rawValue;
   for (const ref of refs) {
     const refPath = ref[1];
@@ -12980,8 +13158,8 @@ function resolveTokenRef(path64, allTokens, visited, depth, result) {
     const refToken = allTokens.get(refPath);
     if (!refToken) {
       result.errors.push({
-        message: `Unresolved token reference: {${refPath}} at ${path64}`,
-        path: path64
+        message: `Unresolved token reference: {${refPath}} at ${path67}`,
+        path: path67
       });
       continue;
     }
@@ -12990,7 +13168,7 @@ function resolveTokenRef(path64, allTokens, visited, depth, result) {
       resolved = resolved.split(`{${refPath}}`).join(refValue);
     }
   }
-  result.resolved.set(path64, resolved);
+  result.resolved.set(path67, resolved);
   return resolved;
 }
 function stringifyTokenValue(value) {
@@ -13045,8 +13223,8 @@ var VALID_TYPES = [
 var VALID_PLATFORMS = ["web", "windows", "mobile-ios", "mobile-android", "cross-platform"];
 async function validateDesignToken(root, config) {
   const configuredDir = config.uiux?.designTokensDir;
-  const designDir = configuredDir ? path44.resolve(root, configuredDir) : path44.join(root, config.paths.contractsDir, "design");
-  const pattern = path44.posix.join(designDir.replace(/\\/g, "/"), "design-tokens*.yaml");
+  const designDir = configuredDir ? path45.resolve(root, configuredDir) : path45.join(root, config.paths.contractsDir, "design");
+  const pattern = path45.posix.join(designDir.replace(/\\/g, "/"), "design-tokens*.yaml");
   const files = await fg2(pattern, {
     absolute: true,
     ignore: ["**/*.schema.yaml", "**/*.schema.yml"]
@@ -13056,11 +13234,11 @@ async function validateDesignToken(root, config) {
   }
   const issues = [];
   for (const filePath of files) {
-    const rel = path44.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path45.relative(root, filePath).replace(/\\/g, "/");
     let hasRootObjectError = false;
     let content;
     try {
-      content = await readFile29(filePath, "utf-8");
+      content = await readFile30(filePath, "utf-8");
     } catch {
       issues.push(
         issue(
@@ -13074,7 +13252,7 @@ async function validateDesignToken(root, config) {
       continue;
     }
     try {
-      const parsed = parseYaml6(content);
+      const parsed = parseYaml7(content);
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
         hasRootObjectError = true;
         issues.push(
@@ -13223,8 +13401,8 @@ function normalizePlatform(value) {
 }
 
 // src/core/validators/htmlMock.ts
-import { readFile as readFile30 } from "fs/promises";
-import path45 from "path";
+import { readFile as readFile31 } from "fs/promises";
+import path46 from "path";
 import fg3 from "fast-glob";
 
 // src/core/uiux/contrastRatio.ts
@@ -13604,19 +13782,19 @@ async function validateHtmlMock(root, platform, config) {
   const startTime = performance.now();
   const budget = config.uiux?.htmlMockTimeout ?? 2e3;
   const patterns = [
-    path45.posix.join(root.replace(/\\/g, "/"), config.paths.discussionDir, "**/*.md"),
-    path45.posix.join(root.replace(/\\/g, "/"), config.paths.specsDir, "**/*.md")
+    path46.posix.join(root.replace(/\\/g, "/"), config.paths.discussionDir, "**/*.md"),
+    path46.posix.join(root.replace(/\\/g, "/"), config.paths.specsDir, "**/*.md")
   ];
   const files = await fg3(patterns, { absolute: true });
   const mockBlocks = [];
   for (const filePath of files) {
     let content;
     try {
-      content = await readFile30(filePath, "utf-8");
+      content = await readFile31(filePath, "utf-8");
     } catch {
       continue;
     }
-    const rel = path45.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path46.relative(root, filePath).replace(/\\/g, "/");
     for (const block of collectHtmlMockBlocks(content)) {
       mockBlocks.push({ file: rel, html: block.html, rawBlock: block.rawBlock });
     }
@@ -13782,8 +13960,8 @@ async function validateHtmlMock(root, platform, config) {
 }
 
 // src/core/validators/mermaidScreenFlow.ts
-import { readFile as readFile31 } from "fs/promises";
-import path46 from "path";
+import { readFile as readFile32 } from "fs/promises";
+import path47 from "path";
 import fg4 from "fast-glob";
 
 // src/core/validators/mermaidUtils.ts
@@ -13834,18 +14012,18 @@ var FLOWCHART_RE = /^\s*flowchart\s+(TD|LR|TB|RL|BT)\b/;
 async function validateMermaidScreenFlow(root, config) {
   const issues = [];
   const patterns = [
-    path46.posix.join(root.replace(/\\/g, "/"), config.paths.discussionDir, "**/*.md"),
-    path46.posix.join(root.replace(/\\/g, "/"), config.paths.specsDir, "**/*.md")
+    path47.posix.join(root.replace(/\\/g, "/"), config.paths.discussionDir, "**/*.md"),
+    path47.posix.join(root.replace(/\\/g, "/"), config.paths.specsDir, "**/*.md")
   ];
   const files = await fg4(patterns, { absolute: true });
   for (const filePath of files) {
     let content;
     try {
-      content = await readFile31(filePath, "utf-8");
+      content = await readFile32(filePath, "utf-8");
     } catch {
       continue;
     }
-    const rel = path46.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path47.relative(root, filePath).replace(/\\/g, "/");
     const blocks = extractFencedCodeBlocks(content);
     for (const block of blocks) {
       if (block.language !== "mermaid") continue;
@@ -13943,10 +14121,10 @@ function parseTransitions(content) {
 }
 
 // src/core/validators/bpApDb.ts
-import { readFile as readFile32 } from "fs/promises";
-import path47 from "path";
+import { readFile as readFile33 } from "fs/promises";
+import path48 from "path";
 import fg5 from "fast-glob";
-import { parse as parseYaml7 } from "yaml";
+import { parse as parseYaml8 } from "yaml";
 var BP_ID_RE = /^BP-\d{4}$/;
 var AP_ID_RE = /^AP-\d{4}$/;
 var VALID_SEVERITIES = ["critical", "major", "minor"];
@@ -13981,9 +14159,9 @@ var AP_REQUIRED_FIELDS = [
 ];
 async function validateBpApDb(root, config) {
   const issues = [];
-  const designDir = path47.join(root, config.paths.contractsDir, "design");
-  const bpPattern = path47.posix.join(designDir.replace(/\\/g, "/"), "best-practices*.yaml");
-  const apPattern = path47.posix.join(designDir.replace(/\\/g, "/"), "anti-patterns*.yaml");
+  const designDir = path48.join(root, config.paths.contractsDir, "design");
+  const bpPattern = path48.posix.join(designDir.replace(/\\/g, "/"), "best-practices*.yaml");
+  const apPattern = path48.posix.join(designDir.replace(/\\/g, "/"), "anti-patterns*.yaml");
   const globOptions = {
     absolute: true,
     ignore: ["**/*.schema.yaml", "**/*.schema.yml"]
@@ -13996,14 +14174,14 @@ async function validateBpApDb(root, config) {
   const seenBpIds = /* @__PURE__ */ new Set();
   const seenApIds = /* @__PURE__ */ new Set();
   for (const filePath of bpFiles) {
-    const rel = path47.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path48.relative(root, filePath).replace(/\\/g, "/");
     const entries = await parseRuleFile(filePath, rel, issues);
     for (const entry of entries) {
       validateBpEntry(entry, rel, seenBpIds, issues);
     }
   }
   for (const filePath of apFiles) {
-    const rel = path47.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path48.relative(root, filePath).replace(/\\/g, "/");
     const entries = await parseRuleFile(filePath, rel, issues);
     for (const entry of entries) {
       validateApEntry(entry, rel, seenApIds, issues);
@@ -14014,7 +14192,7 @@ async function validateBpApDb(root, config) {
 async function parseRuleFile(filePath, rel, issues) {
   let content;
   try {
-    content = await readFile32(filePath, "utf-8");
+    content = await readFile33(filePath, "utf-8");
   } catch {
     issues.push(
       issue("QFAI-BPAP-001", `BP/AP file unreadable: ${rel}`, "error", rel, "bpApDb.readFile")
@@ -14023,7 +14201,7 @@ async function parseRuleFile(filePath, rel, issues) {
   }
   let parsed;
   try {
-    parsed = parseYaml7(content);
+    parsed = parseYaml8(content);
   } catch (error2) {
     issues.push(
       issue(
@@ -14178,8 +14356,8 @@ function toSafeString(value) {
 }
 
 // src/core/validators/platformDetection.ts
-import { readFile as readFile33 } from "fs/promises";
-import path48 from "path";
+import { readFile as readFile34 } from "fs/promises";
+import path49 from "path";
 var KNOWN_PLATFORMS = ["web", "windows", "mobile-ios", "mobile-android", "cross-platform"];
 async function detectPlatform(root, config, cliPlatform) {
   const issues = [];
@@ -14222,13 +14400,13 @@ async function detectPlatform(root, config, cliPlatform) {
   return { platform: "web", source: "fallback", issues };
 }
 async function inferPlatform(root, issues) {
-  if (await exists8(path48.join(root, "pubspec.yaml"))) {
-    const hasAndroid = await exists8(path48.join(root, "android"));
-    const hasIos = await exists8(path48.join(root, "ios"));
-    const hasWeb = await exists8(path48.join(root, "web"));
-    const hasWindows = await exists8(path48.join(root, "windows"));
-    const hasMacos = await exists8(path48.join(root, "macos"));
-    const hasLinux = await exists8(path48.join(root, "linux"));
+  if (await exists8(path49.join(root, "pubspec.yaml"))) {
+    const hasAndroid = await exists8(path49.join(root, "android"));
+    const hasIos = await exists8(path49.join(root, "ios"));
+    const hasWeb = await exists8(path49.join(root, "web"));
+    const hasWindows = await exists8(path49.join(root, "windows"));
+    const hasMacos = await exists8(path49.join(root, "macos"));
+    const hasLinux = await exists8(path49.join(root, "linux"));
     const mobileTargets = [hasAndroid, hasIos].filter(Boolean).length;
     const desktopTargets = [hasWeb, hasWindows, hasMacos, hasLinux].filter(Boolean).length;
     if (mobileTargets + desktopTargets > 1) {
@@ -14248,10 +14426,10 @@ async function inferPlatform(root, issues) {
     }
     return null;
   }
-  const pkgJsonPath = path48.join(root, "package.json");
+  const pkgJsonPath = path49.join(root, "package.json");
   if (await exists8(pkgJsonPath)) {
     try {
-      const raw = await readFile33(pkgJsonPath, "utf-8");
+      const raw = await readFile34(pkgJsonPath, "utf-8");
       const pkg = JSON.parse(raw);
       const deps = {
         ...typeof pkg.dependencies === "object" && pkg.dependencies !== null ? pkg.dependencies : {},
@@ -14270,8 +14448,8 @@ async function inferPlatform(root, issues) {
         return "cross-platform";
       }
       if ("react-native" in deps) {
-        const hasAndroid = await exists8(path48.join(root, "android"));
-        const hasIos = await exists8(path48.join(root, "ios"));
+        const hasAndroid = await exists8(path49.join(root, "android"));
+        const hasIos = await exists8(path49.join(root, "ios"));
         if (hasAndroid && hasIos) {
           return "cross-platform";
         }
@@ -14293,15 +14471,15 @@ function normalizePlatformInput(platform) {
 }
 
 // src/core/validators/uiDefinitionConsistency.ts
-import { readFile as readFile34 } from "fs/promises";
-import path49 from "path";
+import { readFile as readFile35 } from "fs/promises";
+import path50 from "path";
 import fg6 from "fast-glob";
-import { parse as parseYaml8 } from "yaml";
+import { parse as parseYaml9 } from "yaml";
 async function validateUiDefinitionConsistency(root, config) {
   const issues = [];
   const configuredDir = config.uiux?.designTokensDir;
-  const designDir = configuredDir ? path49.resolve(root, configuredDir) : path49.join(root, config.paths.contractsDir, "design");
-  const tokenPattern = path49.posix.join(designDir.replace(/\\/g, "/"), "design-tokens*.yaml");
+  const designDir = configuredDir ? path50.resolve(root, configuredDir) : path50.join(root, config.paths.contractsDir, "design");
+  const tokenPattern = path50.posix.join(designDir.replace(/\\/g, "/"), "design-tokens*.yaml");
   const tokenFiles = await fg6(tokenPattern, {
     absolute: true,
     ignore: ["**/*.schema.yaml", "**/*.schema.yml"]
@@ -14309,7 +14487,7 @@ async function validateUiDefinitionConsistency(root, config) {
   const resolvedTokens = /* @__PURE__ */ new Map();
   for (const tokenFile of tokenFiles) {
     try {
-      const content = await readFile34(tokenFile, "utf-8");
+      const content = await readFile35(tokenFile, "utf-8");
       const result = parseDesignToken(content);
       for (const [key, val] of result.resolved) {
         resolvedTokens.set(key, val);
@@ -14317,14 +14495,14 @@ async function validateUiDefinitionConsistency(root, config) {
     } catch {
     }
   }
-  const uiContractDir = path49.join(root, config.paths.contractsDir, "ui");
-  const uiPattern = path49.posix.join(uiContractDir.replace(/\\/g, "/"), "**/*.yaml");
+  const uiContractDir = path50.join(root, config.paths.contractsDir, "ui");
+  const uiPattern = path50.posix.join(uiContractDir.replace(/\\/g, "/"), "**/*.yaml");
   const uiFiles = await fg6(uiPattern, { absolute: true });
   const contractScreenIds = /* @__PURE__ */ new Set();
   for (const uiFile of uiFiles) {
     try {
-      const content = await readFile34(uiFile, "utf-8");
-      const parsed = parseYaml8(content);
+      const content = await readFile35(uiFile, "utf-8");
+      const parsed = parseYaml9(content);
       if (parsed && typeof parsed === "object") {
         const screens = parsed.screens;
         if (Array.isArray(screens)) {
@@ -14339,15 +14517,15 @@ async function validateUiDefinitionConsistency(root, config) {
     }
   }
   const mdPatterns = [
-    path49.posix.join(root.replace(/\\/g, "/"), config.paths.discussionDir, "**/*.md"),
-    path49.posix.join(root.replace(/\\/g, "/"), config.paths.specsDir, "**/*.md")
+    path50.posix.join(root.replace(/\\/g, "/"), config.paths.discussionDir, "**/*.md"),
+    path50.posix.join(root.replace(/\\/g, "/"), config.paths.specsDir, "**/*.md")
   ];
   const mdFiles = await fg6(mdPatterns, { absolute: true });
   const mockScreenIds = /* @__PURE__ */ new Set();
   for (const mdFile of mdFiles) {
     try {
-      const content = await readFile34(mdFile, "utf-8");
-      const rel = path49.relative(root, mdFile).replace(/\\/g, "/");
+      const content = await readFile35(mdFile, "utf-8");
+      const rel = path50.relative(root, mdFile).replace(/\\/g, "/");
       const htmlBlocks = collectHtmlMockBlocks(content);
       if (resolvedTokens.size > 0) {
         for (const htmlBlock of htmlBlocks) {
@@ -14404,8 +14582,8 @@ async function validateUiDefinitionConsistency(root, config) {
 }
 
 // src/core/validators/researchSummary.ts
-import { readFile as readFile35 } from "fs/promises";
-import path50 from "path";
+import { readFile as readFile36 } from "fs/promises";
+import path51 from "path";
 import fg7 from "fast-glob";
 var RESEARCH_SUMMARY_HEADING_RE = /^#{1,3}\s+Research\s+Summary/im;
 var SOURCE_ENTRY_RE = /^\s*-\s*id:\s*(\S+)/gm;
@@ -14413,17 +14591,17 @@ var REFLECTION_APPLY_RE = /action:\s*apply/i;
 var FULL_DATE_RE = /^\s+published:\s*["']?(\d{4}-\d{2}-\d{2})["']?/m;
 async function validateResearchSummary(root, config) {
   const issues = [];
-  const pattern = path50.posix.join(root.replace(/\\/g, "/"), config.paths.discussionDir, "**/*.md");
+  const pattern = path51.posix.join(root.replace(/\\/g, "/"), config.paths.discussionDir, "**/*.md");
   const files = await fg7(pattern, { absolute: true });
   for (const filePath of files) {
     let content;
     try {
-      content = await readFile35(filePath, "utf-8");
+      content = await readFile36(filePath, "utf-8");
     } catch {
       continue;
     }
     if (!RESEARCH_SUMMARY_HEADING_RE.test(content)) continue;
-    const rel = path50.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path51.relative(root, filePath).replace(/\\/g, "/");
     const section = extractResearchSummarySection(content);
     if (!section) continue;
     const sourceEntries = extractSourceEntries(section);
@@ -14654,9 +14832,9 @@ function resolveFreshnessReferenceNow() {
 }
 
 // src/core/validators/agentDefinition.ts
-import { readFile as readFile36 } from "fs/promises";
-import path51 from "path";
-import { parse as parseYaml9 } from "yaml";
+import { readFile as readFile37 } from "fs/promises";
+import path52 from "path";
+import { parse as parseYaml10 } from "yaml";
 var REQUIRED_AGENTS = [
   "uiux-expert.md",
   "design-expert.md",
@@ -14675,13 +14853,13 @@ var REQUIRED_SECTIONS = [
 var REQUIRED_PHASES = ["discussion", "SDD", "prototyping", "ATDD"];
 async function validateAgentDefinition(root, _config) {
   const issues = [];
-  const agentsDir = path51.join(root, ".qfai", "assistant", "agents");
+  const agentsDir = path52.join(root, ".qfai", "assistant", "agents");
   if (!await exists8(agentsDir)) {
     return [];
   }
   let anyAgentExists = false;
   for (const agentFile of REQUIRED_AGENTS) {
-    if (await exists8(path51.join(agentsDir, agentFile))) {
+    if (await exists8(path52.join(agentsDir, agentFile))) {
       anyAgentExists = true;
       break;
     }
@@ -14690,7 +14868,7 @@ async function validateAgentDefinition(root, _config) {
     return [];
   }
   for (const agentFile of REQUIRED_AGENTS) {
-    const filePath = path51.join(agentsDir, agentFile);
+    const filePath = path52.join(agentsDir, agentFile);
     const rel = `.qfai/assistant/agents/${agentFile}`;
     if (!await exists8(filePath)) {
       issues.push(
@@ -14706,7 +14884,7 @@ async function validateAgentDefinition(root, _config) {
     }
     let content;
     try {
-      content = await readFile36(filePath, "utf-8");
+      content = await readFile37(filePath, "utf-8");
     } catch {
       issues.push(
         issue(
@@ -14812,11 +14990,11 @@ async function validateAgentDefinition(root, _config) {
       }
     }
   }
-  const rosterPath = path51.join(root, ".qfai", "assistant", "steering", "review-roster.yml");
+  const rosterPath = path52.join(root, ".qfai", "assistant", "steering", "review-roster.yml");
   if (await exists8(rosterPath)) {
     try {
-      const rosterContent = await readFile36(rosterPath, "utf-8");
-      const roster = parseYaml9(rosterContent);
+      const rosterContent = await readFile37(rosterPath, "utf-8");
+      const roster = parseYaml10(rosterContent);
       if (roster && typeof roster === "object") {
         const rosterObj = roster;
         const entries = Array.isArray(rosterObj.roster) ? rosterObj.roster : [];
@@ -14860,8 +15038,8 @@ function extractPhaseBody(phaseSection, phaseName) {
 }
 
 // src/core/validators/tddList.ts
-import { readFile as readFile37, stat as stat7 } from "fs/promises";
-import path52 from "path";
+import { readFile as readFile38, stat as stat7 } from "fs/promises";
+import path53 from "path";
 var REQUIRED_COLUMNS = [
   "TDD-ID",
   "TC-Refs",
@@ -14875,7 +15053,7 @@ var REQUIRED_COLUMNS = [
 var VALID_STATUSES = /* @__PURE__ */ new Set(["todo", "red", "green", "refactor", "done", "exception"]);
 var TEST_FILE_CHECK_STATUSES = /* @__PURE__ */ new Set(["green", "refactor", "done"]);
 var TDD_ID_FORMAT = /^TDD-\d{4}$/;
-var TDD_LIST_REL_PATH = path52.join("tdd", "test-list.md");
+var TDD_LIST_REL_PATH = path53.join("tdd", "test-list.md");
 async function validateTddList(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
   const entries = await collectSpecEntries(specsRoot);
@@ -14887,8 +15065,8 @@ async function validateTddList(root, config) {
   return issues;
 }
 async function validateSpecTddList(root, specDir, specNumber) {
-  const filePath = path52.join(specDir, TDD_LIST_REL_PATH);
-  const relPath = path52.relative(root, filePath).replace(/\\/g, "/");
+  const filePath = path53.join(specDir, TDD_LIST_REL_PATH);
+  const relPath = path53.relative(root, filePath).replace(/\\/g, "/");
   const issues = [];
   if (!await exists8(filePath)) {
     issues.push(
@@ -14902,7 +15080,7 @@ async function validateSpecTddList(root, specDir, specNumber) {
     );
     return issues;
   }
-  const content = await readSafe(filePath);
+  const content = await readSafe2(filePath);
   const table = parseFirstMarkdownTable(content);
   if (!table) {
     issues.push(
@@ -15075,9 +15253,9 @@ async function validateSpecTddList(root, specDir, specNumber) {
         continue;
       }
       const normalized = testFile.replace(/\\/g, "/");
-      const resolved = path52.resolve(root, normalized);
-      const relative = path52.relative(root, resolved);
-      if (path52.isAbsolute(normalized) || path52.win32.isAbsolute(normalized) || relative === ".." || relative.startsWith(".." + path52.sep)) {
+      const resolved = path53.resolve(root, normalized);
+      const relative = path53.relative(root, resolved);
+      if (path53.isAbsolute(normalized) || path53.win32.isAbsolute(normalized) || relative === ".." || relative.startsWith(".." + path53.sep)) {
         issues.push(
           issue(
             "TDDLIST_TEST_FILE_MISSING",
@@ -15140,11 +15318,11 @@ async function validateSpecTddList(root, specDir, specNumber) {
 }
 async function collectTestCaseIds(specDir) {
   const empty = { knownTcIds: /* @__PURE__ */ new Set(), unitComponentTcIds: /* @__PURE__ */ new Set() };
-  const testCasesPath = path52.join(specDir, "06_Test-Cases.md");
+  const testCasesPath = path53.join(specDir, "06_Test-Cases.md");
   if (!await exists8(testCasesPath)) return empty;
   let content;
   try {
-    content = await readFile37(testCasesPath, "utf-8");
+    content = await readFile38(testCasesPath, "utf-8");
   } catch {
     return empty;
   }
@@ -15170,8 +15348,8 @@ async function collectTestCaseIds(specDir) {
 }
 
 // src/core/validators/ddpValidation.ts
-import { readFile as readFile38 } from "fs/promises";
-import path53 from "path";
+import { readFile as readFile39 } from "fs/promises";
+import path54 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import fg8 from "fast-glob";
 var DDP_HEADING_RE = /^#{1,3}\s+Design\s+Direction\s+Pack/im;
@@ -15189,9 +15367,9 @@ var _bannedPatterns = null;
 async function loadBannedPatterns() {
   if (_bannedPatterns !== null) return _bannedPatterns;
   try {
-    const thisDir = path53.dirname(fileURLToPath3(import.meta.url));
-    const filePath = path53.join(thisDir, "ddpBannedPatterns.txt");
-    const content = await readFile38(filePath, "utf-8");
+    const thisDir = path54.dirname(fileURLToPath3(import.meta.url));
+    const filePath = path54.join(thisDir, "ddpBannedPatterns.txt");
+    const content = await readFile39(filePath, "utf-8");
     _bannedPatterns = content.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
   } catch {
     _bannedPatterns = [];
@@ -15200,15 +15378,15 @@ async function loadBannedPatterns() {
 }
 async function validateDdpFields(root, config) {
   const issues = [];
-  const pattern = path53.posix.join(root.replace(/\\/g, "/"), config.paths.discussionDir, "**/*.md");
+  const pattern = path54.posix.join(root.replace(/\\/g, "/"), config.paths.discussionDir, "**/*.md");
   const files = await fg8(pattern, { absolute: true });
   let ddpFound = false;
   let isUiBearing2 = false;
   for (const filePath of files) {
-    const basename = path53.basename(filePath);
+    const basename = path54.basename(filePath);
     if (basename === "03_Story-Workshop.md") {
       try {
-        const storyContent = await readFile38(filePath, "utf-8");
+        const storyContent = await readFile39(filePath, "utf-8");
         if (UI_BEARING_KEYWORDS_RE.test(storyContent)) {
           isUiBearing2 = true;
         }
@@ -15219,13 +15397,13 @@ async function validateDdpFields(root, config) {
   for (const filePath of files) {
     let content;
     try {
-      content = await readFile38(filePath, "utf-8");
+      content = await readFile39(filePath, "utf-8");
     } catch {
       continue;
     }
     if (!DDP_HEADING_RE.test(content)) continue;
     ddpFound = true;
-    const rel = path53.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path54.relative(root, filePath).replace(/\\/g, "/");
     const section = extractDdpSection(content);
     if (!section) continue;
     for (const field of DDP_REQUIRED_FIELDS) {
@@ -15418,7 +15596,7 @@ var ANTI_PATTERN_CHECKS = [
 ];
 async function validateResearchTraceability(root, config, issues) {
   const requireResearchSummary = config.uiux?.requireResearchSummary === true;
-  const discussionPattern = path53.posix.join(
+  const discussionPattern = path54.posix.join(
     root.replace(/\\/g, "/"),
     config.paths.discussionDir,
     "**/*.md"
@@ -15427,7 +15605,7 @@ async function validateResearchTraceability(root, config, issues) {
   let hasResearchSummary = false;
   for (const filePath of discussionFiles) {
     try {
-      const content = await readFile38(filePath, "utf-8");
+      const content = await readFile39(filePath, "utf-8");
       if (/research_summary\s*:/m.test(content)) {
         hasResearchSummary = true;
         break;
@@ -15446,7 +15624,7 @@ async function validateResearchTraceability(root, config, issues) {
       )
     );
   }
-  const contractPattern = path53.posix.join(
+  const contractPattern = path54.posix.join(
     root.replace(/\\/g, "/"),
     config.paths.contractsDir,
     "design",
@@ -15456,11 +15634,11 @@ async function validateResearchTraceability(root, config, issues) {
   for (const filePath of contractFiles) {
     let content;
     try {
-      content = await readFile38(filePath, "utf-8");
+      content = await readFile39(filePath, "utf-8");
     } catch {
       continue;
     }
-    const rel = path53.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path54.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);
@@ -15483,11 +15661,11 @@ async function validateStoryWorkshopTemplates(root, config, issues, discussionFi
   for (const filePath of discussionFiles) {
     let content;
     try {
-      content = await readFile38(filePath, "utf-8");
+      content = await readFile39(filePath, "utf-8");
     } catch {
       continue;
     }
-    const rel = path53.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path54.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)) {
@@ -15587,7 +15765,7 @@ function validateQualityProfile(config, issues) {
   }
 }
 async function validateOptionComparison(root, config, issues) {
-  const contractPattern = path53.posix.join(
+  const contractPattern = path54.posix.join(
     root.replace(/\\/g, "/"),
     config.paths.contractsDir,
     "design",
@@ -15597,11 +15775,11 @@ async function validateOptionComparison(root, config, issues) {
   for (const filePath of contractFiles) {
     let content;
     try {
-      content = await readFile38(filePath, "utf-8");
+      content = await readFile39(filePath, "utf-8");
     } catch {
       continue;
     }
-    const rel = path53.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path54.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;
@@ -15636,7 +15814,7 @@ async function validateOptionComparison(root, config, issues) {
 }
 async function validateCompetitiveRefs(root, config, issues) {
   const minRefs = config.uiux?.competitive_refs_min ?? 3;
-  const contractPattern = path53.posix.join(
+  const contractPattern = path54.posix.join(
     root.replace(/\\/g, "/"),
     config.paths.contractsDir,
     "design",
@@ -15646,11 +15824,11 @@ async function validateCompetitiveRefs(root, config, issues) {
   for (const filePath of contractFiles) {
     let content;
     try {
-      content = await readFile38(filePath, "utf-8");
+      content = await readFile39(filePath, "utf-8");
     } catch {
       continue;
     }
-    const rel = path53.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path54.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));
@@ -15800,7 +15978,7 @@ function collectListItems(section, field) {
 }
 
 // src/core/validators/navigationFlow.ts
-import { readFile as readFile39 } from "fs/promises";
+import { readFile as readFile40 } from "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;
@@ -16079,7 +16257,7 @@ async function validateNavigationFlow(root, config) {
   const specFiles = allFiles.filter((f) => /[\\/]spec-\d{4}[\\/]/.test(f));
   const issues = [];
   for (const file of specFiles) {
-    const content = await readFile39(file, "utf-8");
+    const content = await readFile40(file, "utf-8");
     const blocks = extractFencedCodeBlocks(content);
     const mermaidBlocks = blocks.filter((b) => b.language === "mermaid");
     const _flowchartBlocks = mermaidBlocks.filter((b) => hasFlowchartDeclaration(b.content));
@@ -16101,8 +16279,8 @@ async function validateNavigationFlow(root, config) {
 }
 
 // src/core/validators/renderCritique.ts
-import path54 from "path";
-import { readFile as readFile40 } from "fs/promises";
+import path55 from "path";
+import { readFile as readFile41 } 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;
@@ -16121,31 +16299,31 @@ 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 = path54.join(root, config.paths.discussionDir).replace(/\\/g, "/");
-  const discussionFiles = await fg9(path54.posix.join(discussionDir, "**/*.md"), { absolute: true });
+  const discussionDir = path55.join(root, config.paths.discussionDir).replace(/\\/g, "/");
+  const discussionFiles = await fg9(path55.posix.join(discussionDir, "**/*.md"), { absolute: true });
   let hasDdp = false;
   for (const df of discussionFiles) {
-    const content = await readSafe(df);
+    const content = await readSafe2(df);
     if (/^#{1,3}\s+Design\s+Direction\s+Pack/im.test(content)) {
       hasDdp = true;
       break;
     }
   }
   if (!hasDdp) return issues;
-  const skillsDir = path54.join(root, config.paths.skillsDir).replace(/\\/g, "/");
-  const evidenceDir = path54.join(root, ".qfai", "evidence").replace(/\\/g, "/");
+  const skillsDir = path55.join(root, config.paths.skillsDir).replace(/\\/g, "/");
+  const evidenceDir = path55.join(root, ".qfai", "evidence").replace(/\\/g, "/");
   const renderEvidenceViewports = await collectRenderEvidenceViewports(root);
-  const skillPromptPattern = path54.posix.join(skillsDir, "qfai-{prototyping,implement}*/SKILL.md");
+  const skillPromptPattern = path55.posix.join(skillsDir, "qfai-{prototyping,implement}*/SKILL.md");
   const skillFiles = await fg9(skillPromptPattern, { dot: true });
-  const evidencePattern = path54.posix.join(evidenceDir, "{prototyping*,critique-*}.md");
+  const evidencePattern = path55.posix.join(evidenceDir, "{prototyping*,critique-*}.md");
   const evidenceFiles = await fg9(evidencePattern, { dot: true });
   for (const sf of skillFiles) {
-    const content = await readSafe(sf);
+    const content = await readSafe2(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: ${path54.relative(root, sf)}`,
+          `Skill prompt does not mention rendered/screenshot/HTML review: ${path55.relative(root, sf)}`,
           "error",
           sf,
           "renderCritique.codeOnly",
@@ -16157,12 +16335,12 @@ async function validateRenderCritique(root, config) {
     }
   }
   for (const sf of skillFiles) {
-    const content = await readSafe(sf);
+    const content = await readSafe2(sf);
     if (content.length > 0 && !DDP_REFERENCE_RE.test(content)) {
       issues.push(
         issue(
           "QFAI-CRIT-002",
-          `Downstream skill prompt missing DDP reference: ${path54.relative(root, sf)}`,
+          `Downstream skill prompt missing DDP reference: ${path55.relative(root, sf)}`,
           "error",
           sf,
           "renderCritique.ddpMissing",
@@ -16203,12 +16381,12 @@ async function validateRenderCritique(root, config) {
     );
   }
   for (const sf of skillFiles) {
-    const content = await readSafe(sf);
+    const content = await readSafe2(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): ${path54.relative(root, sf)}`,
+          `Read order not specified (DDP \u2192 Design Token \u2192 UI Contract \u2192 HTML Mock \u2192 Flow): ${path55.relative(root, sf)}`,
           "error",
           sf,
           "renderCritique.readOrder",
@@ -16220,7 +16398,7 @@ async function validateRenderCritique(root, config) {
     }
   }
   for (const ef of evidenceFiles) {
-    const content = await readSafe(ef);
+    const content = await readSafe2(ef);
     if (content.length === 0) continue;
     const hasDate = EVIDENCE_DATE_RE.test(content);
     const hasViewport = EVIDENCE_VIEWPORT_RE.test(content);
@@ -16235,7 +16413,7 @@ async function validateRenderCritique(root, config) {
       issues.push(
         issue(
           "QFAI-CRIT-006",
-          `Critique evidence incomplete (missing: ${missing.join(", ")}): ${path54.relative(root, ef)}`,
+          `Critique evidence incomplete (missing: ${missing.join(", ")}): ${path55.relative(root, ef)}`,
           "error",
           ef,
           "renderCritique.incompleteEvidence",
@@ -16345,14 +16523,14 @@ function hasViewportPass(content, viewport) {
 async function collectContent(files) {
   const contents = [];
   for (const f of files) {
-    contents.push(await readSafe(f));
+    contents.push(await readSafe2(f));
   }
   return contents.join("\n---\n");
 }
 async function collectRenderEvidenceViewports(root) {
-  const prototypingJsonPath = path54.join(root, ".qfai", "evidence", "prototyping.json");
+  const prototypingJsonPath = path55.join(root, ".qfai", "evidence", "prototyping.json");
   try {
-    const raw = await readFile40(prototypingJsonPath, "utf-8");
+    const raw = await readFile41(prototypingJsonPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return /* @__PURE__ */ new Set();
@@ -16391,8 +16569,8 @@ async function collectRenderEvidenceViewports(root) {
 }
 
 // src/core/validators/designFidelity.ts
-import { readFile as readFile41 } from "fs/promises";
-import path55 from "path";
+import { readFile as readFile42 } from "fs/promises";
+import path56 from "path";
 import fg10 from "fast-glob";
 var SCORECARD_HEADING_RE = /^#{1,3}\s+Fidelity\s+Scorecard/im;
 var BASE_DIMENSIONS = ["hierarchy", "clarity", "accessibility", "responsive"];
@@ -16417,19 +16595,19 @@ async function validateDesignFidelity(root, config) {
   const evidenceDirs = [".qfai/evidence", ".qfai/review"];
   const allFiles = [];
   for (const dir of evidenceDirs) {
-    const pattern = path55.posix.join(root.replace(/\\/g, "/"), dir, "**/*.md");
+    const pattern = path56.posix.join(root.replace(/\\/g, "/"), dir, "**/*.md");
     const files = await fg10(pattern, { absolute: true });
     allFiles.push(...files);
   }
   for (const filePath of allFiles) {
     let content;
     try {
-      content = await readFile41(filePath, "utf-8");
+      content = await readFile42(filePath, "utf-8");
     } catch {
       continue;
     }
     if (!SCORECARD_HEADING_RE.test(content)) continue;
-    const rel = path55.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path56.relative(root, filePath).replace(/\\/g, "/");
     const section = extractScorecardSection(content);
     if (!section) continue;
     const dimensions = parseDimensions(section);
@@ -16721,7 +16899,7 @@ function hasAntiPatternMention(section, code) {
 }
 
 // src/core/validators/discussionDesignHardening.ts
-import path56 from "path";
+import path57 from "path";
 var HTML_TAG_RE = /<(?:style|div|section|span|button|input|form|header|footer|nav|main|aside)\b/i;
 var MERMAID_SCREEN_FLOW_RE = /```mermaid[\s\S]*?(?:stateDiagram|flowchart|graph)[\s\S]*?(?:Screen|Page|View|Dashboard|Login|Settings|Home)\b/i;
 var DDS_HEADING = "## Design Direction Summary";
@@ -16736,10 +16914,17 @@ var DDS_SUBSECTIONS = [
 var REQUIRED_STATES = ["empty", "loading", "error", "populated"];
 var COMPETITIVE_REF_FIELDS = ["adopted_points", "rejected_points", "local_translation"];
 var PLACEHOLDER_RE = /^(?:tbd|todo|n\/a|na|xxx|\?\?\?|placeholder)$/i;
+var SURFACE_TYPE_RE = /\|\s*Surface Type\s*\|\s*(\S+)\s*\|/i;
 async function isUiBearing(packRoot) {
-  const storyPath = path56.join(packRoot, "03_Story-Workshop.md");
-  const content = await readSafe(storyPath);
+  const storyPath = path57.join(packRoot, "03_Story-Workshop.md");
+  const content = await readSafe2(storyPath);
   if (!content) return false;
+  const surfaceMatch = SURFACE_TYPE_RE.exec(content);
+  if (surfaceMatch?.[1]) {
+    const surface = surfaceMatch[1].toLowerCase();
+    if (surface === "non-ui") return false;
+    if (["web-ui", "mobile-ui", "desktop-ui", "mixed"].includes(surface)) return true;
+  }
   if (HTML_TAG_RE.test(content)) return true;
   if (MERMAID_SCREEN_FLOW_RE.test(content)) return true;
   return false;
@@ -16774,8 +16959,8 @@ function extractOptionNames(optionSection) {
 }
 async function validateDdsPresence(packRoot) {
   const issues = [];
-  const storyPath = path56.join(packRoot, "03_Story-Workshop.md");
-  const content = await readSafe(storyPath);
+  const storyPath = path57.join(packRoot, "03_Story-Workshop.md");
+  const content = await readSafe2(storyPath);
   const relPath = "03_Story-Workshop.md";
   if (!content || !content.includes(DDS_HEADING)) {
     issues.push(
@@ -16808,8 +16993,8 @@ async function validateDdsPresence(packRoot) {
 }
 async function validateOptionComparison2(packRoot) {
   const issues = [];
-  const storyPath = path56.join(packRoot, "03_Story-Workshop.md");
-  const content = await readSafe(storyPath);
+  const storyPath = path57.join(packRoot, "03_Story-Workshop.md");
+  const content = await readSafe2(storyPath);
   if (!content) return issues;
   const dds = extractDdsSection(content);
   if (dds === null) return issues;
@@ -16832,8 +17017,8 @@ async function validateOptionComparison2(packRoot) {
 }
 async function validateAnchorScreen(packRoot) {
   const issues = [];
-  const storyPath = path56.join(packRoot, "03_Story-Workshop.md");
-  const content = await readSafe(storyPath);
+  const storyPath = path57.join(packRoot, "03_Story-Workshop.md");
+  const content = await readSafe2(storyPath);
   if (!content) return issues;
   const dds = extractDdsSection(content);
   if (dds === null) return issues;
@@ -16874,8 +17059,8 @@ async function validateAnchorScreen(packRoot) {
 }
 async function validateCompetitiveRefs2(packRoot) {
   const issues = [];
-  const sourcesPath = path56.join(packRoot, "04_Sources.md");
-  const content = await readSafe(sourcesPath);
+  const sourcesPath = path57.join(packRoot, "04_Sources.md");
+  const content = await readSafe2(sourcesPath);
   if (!content) return issues;
   const registryHeadingRe = /^##\s+Competitive Reference Registry\b.*$/m;
   const registryMatch = registryHeadingRe.exec(content);
@@ -16931,8 +17116,8 @@ function fieldGuidance(field) {
 }
 async function validateCtaHierarchy(packRoot) {
   const issues = [];
-  const storyPath = path56.join(packRoot, "03_Story-Workshop.md");
-  const content = await readSafe(storyPath);
+  const storyPath = path57.join(packRoot, "03_Story-Workshop.md");
+  const content = await readSafe2(storyPath);
   if (!content) return issues;
   const dds = extractDdsSection(content);
   if (dds === null) return issues;
@@ -16969,8 +17154,8 @@ async function validateCtaHierarchy(packRoot) {
 }
 async function validateStateCoverage(packRoot) {
   const issues = [];
-  const storyPath = path56.join(packRoot, "03_Story-Workshop.md");
-  const content = await readSafe(storyPath);
+  const storyPath = path57.join(packRoot, "03_Story-Workshop.md");
+  const content = await readSafe2(storyPath);
   if (!content) return issues;
   const dds = extractDdsSection(content);
   if (dds === null) return issues;
@@ -16994,8 +17179,8 @@ async function validateStateCoverage(packRoot) {
 }
 async function validateDesignAntiGoals(packRoot) {
   const issues = [];
-  const storyPath = path56.join(packRoot, "03_Story-Workshop.md");
-  const content = await readSafe(storyPath);
+  const storyPath = path57.join(packRoot, "03_Story-Workshop.md");
+  const content = await readSafe2(storyPath);
   if (!content) return issues;
   const dds = extractDdsSection(content);
   if (dds === null) return issues;
@@ -17031,7 +17216,7 @@ async function validateDesignAntiGoals(packRoot) {
   return issues;
 }
 async function validateDiscussionDesignHardening(root, config) {
-  const discussionDir = path56.join(root, config.paths.discussionDir);
+  const discussionDir = path57.join(root, config.paths.discussionDir);
   const packRoot = await findLatestDiscussionPackDir(discussionDir);
   if (!packRoot) return [];
   const uiBearing = await isUiBearing(packRoot);
@@ -17049,7 +17234,7 @@ async function validateDiscussionDesignHardening(root, config) {
 
 // src/core/validators/designAudit.ts
 import { readdir as readdir11 } from "fs/promises";
-import path57 from "path";
+import path58 from "path";
 var COSMETIC_CATEGORIES = ["generic-shell", "stock-imagery", "placeholder-copy"];
 function resolveAuditConfig(config) {
   const audit = config.uiux?.audit;
@@ -17131,7 +17316,7 @@ var RAW_COLOR_RE = /#[0-9a-fA-F]{3,8}\b|rgb\([^)]+\)|rgba\([^)]+\)|hsl\([^)]+\)|
 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");
+  const tokensDir = configuredDir ? path58.resolve(root, configuredDir) : path58.join(root, cfg.paths.contractsDir, "design");
   let hasTokenFiles = false;
   try {
     const entries = await readdir11(tokensDir);
@@ -17140,7 +17325,7 @@ async function checkTokenDrift(root, auditConfig, cfg) {
     return findings;
   }
   if (!hasTokenFiles) return findings;
-  const contractsUiDir = path57.join(root, cfg.paths.contractsDir, "ui");
+  const contractsUiDir = path58.join(root, cfg.paths.contractsDir, "ui");
   let htmlFiles = [];
   try {
     const entries = await readdir11(contractsUiDir);
@@ -17151,7 +17336,7 @@ async function checkTokenDrift(root, auditConfig, cfg) {
   let rawCount = 0;
   const sampleLiterals = [];
   for (const htmlFile of htmlFiles) {
-    const content = await readSafe(path57.join(contractsUiDir, htmlFile));
+    const content = await readSafe2(path58.join(contractsUiDir, htmlFile));
     if (!content) continue;
     const matches = content.match(RAW_COLOR_RE);
     if (matches) {
@@ -17202,13 +17387,13 @@ function deduplicateFindings(issues, maxPerRule) {
 async function validateDesignAudit(root, config) {
   const auditConfig = resolveAuditConfig(config);
   if (!auditConfig.enabled) return [];
-  const discussionDir = path57.join(root, config.paths.discussionDir);
+  const discussionDir = path58.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);
+  const storyPath = path58.join(packRoot, "03_Story-Workshop.md");
+  const content = await readSafe2(storyPath);
   if (!content) return [];
   const findings = [];
   findings.push(...checkCtaHierarchy(content, auditConfig, "03_Story-Workshop.md"));
@@ -17219,8 +17404,8 @@ async function validateDesignAudit(root, config) {
 
 // src/core/validators/designSlop.ts
 import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile42 } from "fs/promises";
-import path58 from "path";
+import { readFile as readFile43 } from "fs/promises";
+import path59 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function isValidSlopPattern(rule) {
   if (typeof rule !== "object" || rule === null) return false;
@@ -17228,7 +17413,7 @@ function isValidSlopPattern(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 raw = await readFile43(jsonPath, "utf-8");
   const parsed = JSON.parse(raw);
   if (!Array.isArray(parsed)) return [];
   return parsed.filter((r) => isValidSlopPattern(r));
@@ -17236,11 +17421,11 @@ async function loadSlopPatterns(jsonPath) {
 function defaultPatternsPath() {
   const base = import.meta.url;
   const basePath = base.startsWith("file:") ? fileURLToPath4(base) : base;
-  const baseDir = path58.dirname(basePath);
+  const baseDir = path59.dirname(basePath);
   const candidates = [
-    path58.join(baseDir, "designSlopPatterns.json"),
-    path58.resolve(baseDir, "../../../assets/validators/designSlopPatterns.json"),
-    path58.resolve(baseDir, "../../assets/validators/designSlopPatterns.json")
+    path59.join(baseDir, "designSlopPatterns.json"),
+    path59.resolve(baseDir, "../../../assets/validators/designSlopPatterns.json"),
+    path59.resolve(baseDir, "../../assets/validators/designSlopPatterns.json")
   ];
   for (const c of candidates) {
     if (existsSync2(c)) return c;
@@ -17251,7 +17436,7 @@ 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 discussionDir = path59.join(root, config.paths.discussionDir);
   const packRoot = await findLatestDiscussionPackDir(discussionDir);
   if (!packRoot) return [];
   const uiBearing = await isUiBearing(packRoot);
@@ -17272,8 +17457,8 @@ async function validateDesignSlop(root, config) {
       continue;
     }
     for (const scope of pattern.scopes) {
-      const filePath = path58.join(packRoot, scope);
-      const content = await readSafe(filePath);
+      const filePath = path59.join(packRoot, scope);
+      const content = await readSafe2(filePath);
       if (!content) continue;
       if (regex.test(content) && !seenRules.has(pattern.id)) {
         seenRules.add(pattern.id);
@@ -17293,6 +17478,460 @@ async function validateDesignSlop(root, config) {
   return findings.map((f) => findingToIssue(f, auditConfig.qualityProfile, "slop"));
 }
 
+// src/core/validators/uixValidators.ts
+import { readdir as readdir13 } from "fs/promises";
+import path61 from "path";
+
+// src/core/validators/uixDetection.ts
+import { readdir as readdir12 } from "fs/promises";
+import path60 from "path";
+var UI_BEARING_SURFACES = /* @__PURE__ */ new Set(["web-ui", "mobile-ui", "desktop-ui", "mixed"]);
+var NON_UI_SURFACES = /* @__PURE__ */ new Set(["non-ui"]);
+function stripCodeBlocks(content) {
+  let stripped = content.replace(/```[\s\S]*?```/g, "");
+  stripped = stripped.replace(/`[^`]+`/g, "");
+  return stripped;
+}
+var HTML_TAG_RE2 = /<(?:style|div|section|span|button|input|form|header|footer|nav|main|aside)\b/i;
+var MERMAID_SCREEN_FLOW_RE2 = /```mermaid[\s\S]*?(?:stateDiagram)[\s\S]*?(?:Screen|Page|View|Dashboard|Login|Settings|Home)\b/i;
+var SCREEN_CONTRACT_YAML_RE = /screens:\s*\n\s*-\s*route:/;
+async function isUiBearingSpec(root) {
+  const specContent = await readSafe2(path60.join(root, "01_Spec.md"));
+  const surfaceMatch = /^\s*-\s*surface:\s*(\S+)/im.exec(specContent);
+  if (surfaceMatch?.[1]) {
+    const surface = surfaceMatch[1].toLowerCase();
+    if (UI_BEARING_SURFACES.has(surface)) return true;
+    if (NON_UI_SURFACES.has(surface)) return false;
+  }
+  try {
+    await readdir12(path60.join(root, "uiux"));
+    return true;
+  } catch {
+  }
+  const contractsContent = await readSafe2(path60.join(root, "uiux", "40_contracts.md"));
+  if (contractsContent && SCREEN_CONTRACT_YAML_RE.test(contractsContent)) return true;
+  const storyContent = await readSafe2(path60.join(root, "03_Story-Workshop.md"));
+  if (storyContent) {
+    const stripped = stripCodeBlocks(storyContent);
+    if (HTML_TAG_RE2.test(stripped)) return true;
+    if (MERMAID_SCREEN_FLOW_RE2.test(storyContent)) return true;
+  }
+  return false;
+}
+
+// src/core/validators/uixValidators.ts
+function uixIssue(code, message, severity, file, suggestedAction) {
+  return {
+    code,
+    severity,
+    category: "compatibility",
+    message,
+    file,
+    suggested_action: suggestedAction
+  };
+}
+function parseSimpleYaml(content) {
+  const result = {};
+  const store = (rawKey, value) => {
+    const key = rawKey.trim().toLowerCase().replace(/\s+/g, "_");
+    if (key && value) result[key] = value;
+  };
+  for (const line of content.split("\n")) {
+    const yamlMatch = /^\s*(\w[\w_]*):\s*(.*)$/.exec(line);
+    if (yamlMatch?.[1] !== void 0 && yamlMatch[2] !== void 0) {
+      store(yamlMatch[1], yamlMatch[2].trim());
+      continue;
+    }
+    const bulletMatch = /^\s*-\s+([\w][\w\s]*?):\s+(.+)$/.exec(line);
+    if (bulletMatch?.[1] !== void 0 && bulletMatch[2] !== void 0) {
+      store(bulletMatch[1], bulletMatch[2].trim());
+      continue;
+    }
+    const tableMatch = /^\s*\|\s*(\w[\w\s_]*?)\s*\|\s*(.+?)\s*\|\s*$/.exec(line);
+    if (tableMatch?.[1] !== void 0 && tableMatch[2] !== void 0) {
+      if (!/^[-:]+$/.test(tableMatch[2].trim())) {
+        store(tableMatch[1], tableMatch[2].trim());
+      }
+    }
+  }
+  return result;
+}
+async function validateSidecarMissing(root, _config) {
+  if (!await isUiBearingSpec(root)) return [];
+  try {
+    await readdir13(path61.join(root, "uiux"));
+    return [];
+  } catch {
+    return [
+      uixIssue(
+        "UIX-VAL-SIDECAR-MISSING",
+        "UI-bearing spec detected but uiux/ sidecar directory is missing.",
+        "error",
+        "uiux/",
+        "Create the uiux/ directory and populate it with the sidecar template files."
+      )
+    ];
+  }
+}
+var STRATEGY_REQUIRED_FIELDS_LEGACY = [
+  "selection_required",
+  "candidate_options",
+  "chosen_option",
+  "verification_expectations",
+  "none_as_legitimate_outcome"
+];
+var STRATEGY_REQUIRED_FIELDS_CURRENT = ["surface_type", "approach", "rationale"];
+var STRATEGY_MIN_LENGTH_FIELDS = ["rationale", "approach"];
+var STRATEGY_MIN_LENGTH = 20;
+async function validateStrategyCompleteness(root, _config) {
+  if (!await isUiBearingSpec(root)) return [];
+  const strategyPath = path61.join(root, "uiux", "10_strategy.md");
+  const content = await readSafe2(strategyPath);
+  if (!content) return [];
+  const parsed = parseSimpleYaml(content);
+  const issues = [];
+  const relPath = "uiux/10_strategy.md";
+  const isCurrentFormat = parsed["surface_type"] !== void 0;
+  const requiredFields = isCurrentFormat ? STRATEGY_REQUIRED_FIELDS_CURRENT : STRATEGY_REQUIRED_FIELDS_LEGACY;
+  for (const field of requiredFields) {
+    const value = parsed[field];
+    if (value === void 0 || value === "") {
+      issues.push(
+        uixIssue(
+          "UIX-VAL-STRATEGY-INCOMPLETE",
+          `Strategy field '${field}' is missing or empty in 10_strategy.md.`,
+          "error",
+          relPath,
+          `Add the '${field}' field to uiux/10_strategy.md with a valid value.`
+        )
+      );
+    }
+  }
+  for (const field of STRATEGY_MIN_LENGTH_FIELDS) {
+    const value = parsed[field];
+    if (value === void 0 || value.length < STRATEGY_MIN_LENGTH) {
+      issues.push(
+        uixIssue(
+          "UIX-VAL-STRATEGY-INCOMPLETE",
+          `Strategy field '${field}' must be at least ${STRATEGY_MIN_LENGTH} characters (current: ${value?.length ?? 0}).`,
+          "error",
+          relPath,
+          `Expand the '${field}' field in uiux/10_strategy.md to at least ${STRATEGY_MIN_LENGTH} characters.`
+        )
+      );
+    }
+  }
+  return issues;
+}
+async function validateScoringAxes(root, _config) {
+  if (!await isUiBearingSpec(root)) return [];
+  const singlePath = path61.join(root, "uiux", "20_eval_axes.md");
+  let content = await readSafe2(singlePath);
+  let relPath = "uiux/20_eval_axes.md";
+  if (!content) {
+    const splitFiles = [
+      "20_eval_axis_usability.md",
+      "21_eval_axis_consistency.md",
+      "22_eval_axis_accessibility.md",
+      "23_eval_axis_delight.md"
+    ];
+    const parts = [];
+    for (const f of splitFiles) {
+      const c = await readSafe2(path61.join(root, "uiux", f));
+      if (c) parts.push(c);
+    }
+    if (parts.length > 0) {
+      content = parts.join("\n");
+      relPath = "uiux/20_eval_axis_*.md";
+    }
+  }
+  if (!content) return [];
+  const issues = [];
+  const lines = content.split("\n");
+  let inTrendSection = false;
+  for (const line of lines) {
+    if (/trend[_-]derived/i.test(line)) {
+      inTrendSection = true;
+      continue;
+    }
+    if (inTrendSection && /^#+\s/.test(line)) {
+      inTrendSection = false;
+      continue;
+    }
+    const isBulletRow = /^\s*-\s/.test(line);
+    const isTableRow2 = /^\s*\|/.test(line) && !/^\s*\|[\s-:|]+\|[\s-:|]*$/.test(line);
+    if (inTrendSection && (isBulletRow || isTableRow2)) {
+      if (!/source_translation/i.test(line)) {
+        issues.push(
+          uixIssue(
+            "UIX-VAL-SCORING-AXIS-INCOMPLETE",
+            "Trend-derived scoring axis row is missing source_translation field.",
+            "error",
+            relPath,
+            "Add source_translation to each trend-derived evaluation axis row."
+          )
+        );
+      }
+    }
+  }
+  return issues;
+}
+var AGGREGATE_REQUIRED_FIELDS = ["weights", "normalization", "threshold"];
+async function validateAggregateScoringRules(root, _config) {
+  if (!await isUiBearingSpec(root)) return [];
+  const aggregatePath = path61.join(root, "uiux", "21_aggregate_scoring.md");
+  let content = await readSafe2(aggregatePath);
+  let relPath = "uiux/21_aggregate_scoring.md";
+  if (!content) {
+    const delightContent = await readSafe2(path61.join(root, "uiux", "23_eval_axis_delight.md"));
+    if (delightContent) {
+      const lines = delightContent.split("\n");
+      let inSection = false;
+      const sectionLines = [];
+      for (const line of lines) {
+        if (/^#+\s*Aggregate\s+Scoring/i.test(line)) {
+          inSection = true;
+          continue;
+        }
+        if (inSection && /^#+\s/.test(line)) break;
+        if (inSection) sectionLines.push(line);
+      }
+      if (sectionLines.length > 0) {
+        content = sectionLines.join("\n");
+        relPath = "uiux/23_eval_axis_delight.md";
+      }
+    }
+  }
+  if (!content) return [];
+  const parsed = parseSimpleYaml(content);
+  const issues = [];
+  for (const field of AGGREGATE_REQUIRED_FIELDS) {
+    const value = parsed[field] ?? parsed[`${field}s`];
+    if (value === void 0 || value === "") {
+      issues.push(
+        uixIssue(
+          "UIX-VAL-AGGREGATE-SCORING-INCOMPLETE",
+          `Aggregate scoring field '${field}' is missing in ${relPath}.`,
+          "error",
+          relPath,
+          `Add the '${field}' field to ${relPath}.`
+        )
+      );
+    }
+  }
+  return issues;
+}
+async function validateOptionComparison3(root, _config) {
+  if (!await isUiBearingSpec(root)) return [];
+  const issues = [];
+  const compPath = path61.join(root, "uiux", "30_comparison.md");
+  const compContent = await readSafe2(compPath);
+  if (compContent) {
+    const headingOptions = compContent.match(/^##\s+Option\b/gim);
+    const tableOptions = compContent.match(/\bOption\s+[A-Z]\b/gim);
+    const uniqueTableOptions = tableOptions ? new Set(tableOptions.map((m) => m.trim().toUpperCase())).size : 0;
+    const optionCount = Math.max(headingOptions?.length ?? 0, uniqueTableOptions);
+    if (optionCount < 2) {
+      issues.push(
+        uixIssue(
+          "UIX-VAL-COMPARISON-INSUFFICIENT",
+          "30_comparison.md must contain at least 2 options for meaningful comparison.",
+          "error",
+          "uiux/30_comparison.md",
+          "Add at least 2 '## Option' sections to uiux/30_comparison.md."
+        )
+      );
+    }
+  }
+  const anchorPath = path61.join(root, "uiux", "31_anchor.md");
+  const anchorContent = await readSafe2(anchorPath);
+  if (anchorContent) {
+    if (!/selected_anchor\s*:/i.test(anchorContent) && !/chosen\s*:/i.test(anchorContent) && !/source\s+option\s*:/i.test(anchorContent)) {
+      issues.push(
+        uixIssue(
+          "UIX-VAL-ANCHOR-MISSING",
+          "31_anchor.md is missing a selected anchor declaration.",
+          "error",
+          "uiux/31_anchor.md",
+          "Add a 'selected_anchor:' field to uiux/31_anchor.md."
+        )
+      );
+    }
+  }
+  return issues;
+}
+var SCREEN_CONTRACT_REQUIRED_FIELDS = [
+  "route",
+  "actor",
+  "purpose",
+  "primary_tasks",
+  "required_states",
+  "transitions",
+  "observable_outcomes"
+];
+async function validateScreenContracts(root, _config) {
+  if (!await isUiBearingSpec(root)) return [];
+  const contractsPath = path61.join(root, "uiux", "40_contracts.md");
+  const content = await readSafe2(contractsPath);
+  if (!content) return [];
+  const parsed = parseSimpleYaml(content);
+  const issues = [];
+  const relPath = "uiux/40_contracts.md";
+  const sectionHeadings = {
+    primary_tasks: /^#{3,4}\s+Primary\s+Tasks/im,
+    required_states: /^#{3,4}\s+Required\s+States/im,
+    transitions: /^#{3,4}\s+Transitions/im,
+    observable_outcomes: /^#{3,4}\s+Observable\s+Outcomes/im
+  };
+  for (const field of SCREEN_CONTRACT_REQUIRED_FIELDS) {
+    const value = parsed[field];
+    const hasValue = value !== void 0 && value !== "";
+    const headingPattern = sectionHeadings[field];
+    const hasHeading = headingPattern ? headingPattern.test(content) : false;
+    if (!hasValue && !hasHeading) {
+      issues.push(
+        uixIssue(
+          "UIX-VAL-SCREEN-CONTRACT-INCOMPLETE",
+          `Screen contract field '${field}' is missing in 40_contracts.md.`,
+          "error",
+          relPath,
+          `Add the '${field}' field to screen contracts in uiux/40_contracts.md.`
+        )
+      );
+    }
+  }
+  return issues;
+}
+async function validateOqClosure(root, _config) {
+  if (!await isUiBearingSpec(root)) return [];
+  const rootOqPath = path61.join(root, "11_OQ-Register.md");
+  const uiuxOqPath = path61.join(root, "uiux", "11_OQ-Register.md");
+  const rootContent = await readSafe2(rootOqPath);
+  const content = rootContent || await readSafe2(uiuxOqPath);
+  if (!content) return [];
+  const issues = [];
+  const relPath = rootContent ? "11_OQ-Register.md" : "uiux/11_OQ-Register.md";
+  const oqBlocks = content.split(/(?=^##\s+OQ-\d{4})/m);
+  for (const block of oqBlocks) {
+    const idMatch = /^##\s+(OQ-\d{4})/m.exec(block);
+    if (!idMatch?.[1]) continue;
+    const oqId = idMatch[1];
+    const isOpen = /status\s*:\s*open/i.test(block);
+    const isCritical = /severity\s*:\s*(?:critical|blocking)/i.test(block);
+    if (isOpen && isCritical) {
+      issues.push(
+        uixIssue(
+          "UIX-VAL-OQ-OPEN-CRITICAL",
+          `Open critical OQ found: ${oqId}. Must be resolved before proceeding.`,
+          "error",
+          relPath,
+          `Resolve or downgrade ${oqId} in uiux/11_OQ-Register.md before validation can pass.`
+        )
+      );
+    }
+  }
+  const tableRowRegex = /^\s*\|\s*(OQ-\d{4})\s*\|/;
+  for (const line of content.split("\n")) {
+    const rowMatch = tableRowRegex.exec(line);
+    if (!rowMatch?.[1]) continue;
+    const oqId = rowMatch[1];
+    const cols = line.split("|").map((c) => c.trim()).filter(Boolean);
+    const disposition = cols[3]?.toLowerCase();
+    if (disposition === "open") {
+      const fullRow = line.toLowerCase();
+      if (/critical|blocking/i.test(fullRow)) {
+        issues.push(
+          uixIssue(
+            "UIX-VAL-OQ-OPEN-CRITICAL",
+            `Open critical OQ found: ${oqId}. Must be resolved before proceeding.`,
+            "error",
+            relPath,
+            `Resolve or downgrade ${oqId} in ${relPath} before validation can pass.`
+          )
+        );
+      }
+    }
+  }
+  return issues;
+}
+var CURRENT_SIDECAR_VERSION = "1.0.0";
+async function validateMigration(root, config) {
+  if (!await isUiBearingSpec(root)) return [];
+  const strict = config.uiux?.migration?.strict === true;
+  const issues = [];
+  try {
+    await readdir13(path61.join(root, "uiux"));
+  } catch {
+    issues.push(
+      uixIssue(
+        "UIX-VAL-MIGRATION-SIDECAR-MISSING",
+        "UI-bearing spec detected but uiux/ sidecar directory is missing. Migration required.",
+        strict ? "error" : "warning",
+        "uiux/",
+        "Run the UIX sidecar migration to create the uiux/ directory structure."
+      )
+    );
+    return issues;
+  }
+  const versionPath = path61.join(root, "uiux", ".sidecar-version");
+  const versionContent = await readSafe2(versionPath);
+  if (versionContent) {
+    const version = versionContent.trim();
+    if (version && version !== CURRENT_SIDECAR_VERSION) {
+      issues.push(
+        uixIssue(
+          "UIX-VAL-MIGRATION-STALE-VERSION",
+          `Sidecar template version '${version}' is outdated (current: ${CURRENT_SIDECAR_VERSION}).`,
+          "warning",
+          "uiux/.sidecar-version",
+          `Upgrade sidecar template from ${version} to ${CURRENT_SIDECAR_VERSION}. Run the migration tool for upgrade steps.`
+        )
+      );
+    }
+  }
+  return issues;
+}
+function applyPhase1Ratchet(issues, releaseDate, now = /* @__PURE__ */ new Date()) {
+  const phase1EndMs = releaseDate.getTime() + 30 * 24 * 60 * 60 * 1e3;
+  if (now.getTime() > phase1EndMs) return issues;
+  return issues.map((iss) => {
+    if (iss.code.startsWith("UIX-VAL-") && iss.severity === "error") {
+      return { ...iss, severity: "warning" };
+    }
+    return iss;
+  });
+}
+async function runAllUixValidators(root, config) {
+  let effectiveRoot = root;
+  const directSpec = await readSafe2(path61.join(root, "01_Spec.md"));
+  if (!directSpec) {
+    const discussionDir = path61.join(root, config.paths.discussionDir);
+    const packRoot = await findLatestDiscussionPackDir(discussionDir);
+    if (!packRoot) return [];
+    effectiveRoot = packRoot;
+  }
+  const validators = [
+    validateSidecarMissing,
+    validateStrategyCompleteness,
+    validateScoringAxes,
+    validateAggregateScoringRules,
+    validateOptionComparison3,
+    validateScreenContracts,
+    validateOqClosure,
+    validateMigration
+  ];
+  const results = await Promise.all(validators.map((v) => v(effectiveRoot, config)));
+  let issues = results.flat();
+  const relDateStr = config.uiux?.phase1ReleaseDate;
+  if (relDateStr) {
+    const releaseDate = new Date(relDateStr);
+    if (!isNaN(releaseDate.getTime())) {
+      issues = applyPhase1Ratchet(issues, releaseDate);
+    }
+  }
+  return issues;
+}
+
 // src/core/validate.ts
 var UIUX_VALIDATION_BUDGET_MS = 2e3;
 async function validateProject(root, configResult, options = {}) {
@@ -17312,7 +17951,8 @@ async function validateProject(root, configResult, options = {}) {
     () => validateResearchSummary(root, config),
     () => validateAgentDefinition(root, config),
     () => validateDesignAudit(root, config),
-    () => validateDesignSlop(root, config)
+    () => validateDesignSlop(root, config),
+    () => runAllUixValidators(root, config)
   ];
   const uiuxIssueGroups = await Promise.all(uiuxValidators.map((validator) => validator()));
   const uiuxIssues = [...platformResult.issues, ...uiuxIssueGroups.flat()];
@@ -17399,15 +18039,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 = path59.resolve(root);
+  const resolvedRoot = path62.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 = path59.join(contractsRoot, "api");
-  const uiRoot = path59.join(contractsRoot, "ui");
-  const dbRoot = path59.join(contractsRoot, "db");
+  const apiRoot = path62.join(contractsRoot, "api");
+  const uiRoot = path62.join(contractsRoot, "ui");
+  const dbRoot = path62.join(contractsRoot, "db");
   const srcRoot = resolvePath(resolvedRoot, config, "srcDir");
   const testsRoot = resolvePath(resolvedRoot, config, "testsDir");
   const specEntries = await collectSpecEntries(specsRoot);
@@ -18344,7 +18984,7 @@ async function collectChangeTypeSummary(specsRoot) {
   };
   const deltaFiles = await collectDeltaFiles(specsRoot);
   for (const deltaFile of deltaFiles) {
-    const text = await readFile43(deltaFile, "utf-8");
+    const text = await readFile44(deltaFile, "utf-8");
     const parsed = parseDeltaV1(text);
     for (const entry of parsed.entries) {
       if (!entry.meta) {
@@ -18381,7 +19021,7 @@ async function collectSpecContractRefs(specFiles, contractIdList) {
     idToSpecs.set(contractId, /* @__PURE__ */ new Set());
   }
   for (const file of specFiles) {
-    const text = await readFile43(file, "utf-8");
+    const text = await readFile44(file, "utf-8");
     const parsed = parseSpec(text, file);
     const specKey = parsed.specId;
     if (!specKey) {
@@ -18418,7 +19058,7 @@ async function collectIds(files) {
     result[prefix] = /* @__PURE__ */ new Set();
   }
   for (const file of files) {
-    const text = await readFile43(file, "utf-8");
+    const text = await readFile44(file, "utf-8");
     for (const prefix of ID_PREFIXES) {
       const ids = extractIds(text, prefix);
       ids.forEach((id) => result[prefix].add(id));
@@ -18433,7 +19073,7 @@ async function collectIds(files) {
 async function collectUpstreamIds(files) {
   const ids = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const text = await readFile43(file, "utf-8");
+    const text = await readFile44(file, "utf-8");
     extractAllIds(text).forEach((id) => ids.add(id));
   }
   return ids;
@@ -18454,7 +19094,7 @@ async function evaluateTraceability(upstreamIds, srcRoot, testsRoot) {
   }
   const pattern = buildIdPattern(Array.from(upstreamIds));
   for (const file of targetFiles) {
-    const text = await readFile43(file, "utf-8");
+    const text = await readFile44(file, "utf-8");
     if (pattern.test(text)) {
       return true;
     }
@@ -18573,7 +19213,7 @@ function normalizeScSources(root, sources) {
 async function countScenarios(scenarioFiles) {
   let total = 0;
   for (const file of scenarioFiles) {
-    const text = await readFile43(file, "utf-8");
+    const text = await readFile44(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -18604,7 +19244,7 @@ async function collectTestStrategy(scenarioFiles, root, config, limit) {
   let totalScenarios = 0;
   let e2eCount = 0;
   for (const file of scenarioFiles) {
-    const text = await readFile43(file, "utf-8");
+    const text = await readFile44(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -18692,10 +19332,10 @@ function buildHotspots(issues) {
 async function collectTddCoverage(entries) {
   const specs = [];
   for (const entry of entries) {
-    const testCasesPath = path59.join(entry.dir, "06_Test-Cases.md");
+    const testCasesPath = path62.join(entry.dir, "06_Test-Cases.md");
     let tcContent;
     try {
-      tcContent = await readFile43(testCasesPath, "utf-8");
+      tcContent = await readFile44(testCasesPath, "utf-8");
     } catch {
       continue;
     }
@@ -18727,10 +19367,10 @@ async function collectTddCoverage(entries) {
       });
       continue;
     }
-    const tddListPath = path59.join(entry.dir, "tdd", "test-list.md");
+    const tddListPath = path62.join(entry.dir, "tdd", "test-list.md");
     let tddContent;
     try {
-      tddContent = await readFile43(tddListPath, "utf-8");
+      tddContent = await readFile44(tddListPath, "utf-8");
     } catch {
       specs.push({
         specNumber: entry.specNumber,
@@ -18813,8 +19453,8 @@ async function collectTddCoverage(entries) {
 }
 
 // src/core/specPackReport.ts
-import { mkdir as mkdir7, readFile as readFile44, writeFile as writeFile6 } from "fs/promises";
-import path60 from "path";
+import { mkdir as mkdir7, readFile as readFile45, writeFile as writeFile6 } from "fs/promises";
+import path63 from "path";
 var REQUIRED_LEDGER_COLUMNS = [
   "trace_id",
   "obj_id",
@@ -18832,8 +19472,8 @@ async function writeSpecPackReports(root, config) {
   const entries = await collectSpecEntries(specsRoot);
   const contractIndex = await buildContractIndex(root, config);
   for (const entry of entries) {
-    const specName = path60.basename(entry.dir);
-    const outputDir = path60.join(outRoot, specName);
+    const specName = path63.basename(entry.dir);
+    const outputDir = path63.join(outRoot, specName);
     await mkdir7(outputDir, { recursive: true });
     const [acText, tcText, exText, ledgerText] = await Promise.all([
       readSafe12(entry.acceptanceCriteriaPath),
@@ -18860,13 +19500,13 @@ async function writeSpecPackReports(root, config) {
     });
     const graph = buildTraceabilityGraph(ledgerRows);
     await writeFile6(
-      path60.join(outputDir, "coverage.md"),
+      path63.join(outputDir, "coverage.md"),
       `${formatCoverageMarkdown(specName, coverage)}
 `,
       "utf-8"
     );
     await writeFile6(
-      path60.join(outputDir, "traceability-graph.json"),
+      path63.join(outputDir, "traceability-graph.json"),
       `${JSON.stringify(graph, null, 2)}
 `,
       "utf-8"
@@ -19041,7 +19681,7 @@ function getCell(row, indexByColumn, column) {
 }
 async function readSafe12(filePath) {
   try {
-    return await readFile44(filePath, "utf-8");
+    return await readFile45(filePath, "utf-8");
   } catch {
     return "";
   }
@@ -19059,7 +19699,7 @@ function warnIfTruncated(scan, context) {
 
 // src/cli/commands/report.ts
 async function runReport(options) {
-  const root = path61.resolve(options.root);
+  const root = path64.resolve(options.root);
   const configResult = await loadConfig(root);
   let validation;
   let blockedByPhaseGuard = false;
@@ -19075,7 +19715,7 @@ async function runReport(options) {
     validation = normalized;
   } else {
     const input = options.inputPath ?? configResult.config.output.validateJsonPath;
-    const inputPath = path61.isAbsolute(input) ? input : path61.resolve(root, input);
+    const inputPath = path64.isAbsolute(input) ? input : path64.resolve(root, input);
     try {
       validation = await readValidationResult(inputPath);
     } catch (err) {
@@ -19102,10 +19742,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" ? path61.join(outRoot, "report.json") : path61.join(outRoot, "report.md");
+  const defaultOut = options.format === "json" ? path64.join(outRoot, "report.json") : path64.join(outRoot, "report.md");
   const out = options.outPath ?? defaultOut;
-  const outPath = path61.isAbsolute(out) ? out : path61.resolve(root, out);
-  await mkdir8(path61.dirname(outPath), { recursive: true });
+  const outPath = path64.isAbsolute(out) ? out : path64.resolve(root, out);
+  await mkdir8(path64.dirname(outPath), { recursive: true });
   await writeFile7(outPath, `${output}
 `, "utf-8");
   await writeSpecPackReports(root, configResult.config);
@@ -19121,7 +19761,7 @@ async function runReport(options) {
   info(`wrote report: ${outPath}`);
 }
 async function readValidationResult(inputPath) {
-  const raw = await readFile45(inputPath, "utf-8");
+  const raw = await readFile46(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}`);
@@ -19181,21 +19821,21 @@ function isMissingFileError2(error2) {
   return record2.code === "ENOENT";
 }
 async function writeValidationResult(root, outputPath, result) {
-  const abs = path61.isAbsolute(outputPath) ? outputPath : path61.resolve(root, outputPath);
-  await mkdir8(path61.dirname(abs), { recursive: true });
+  const abs = path64.isAbsolute(outputPath) ? outputPath : path64.resolve(root, outputPath);
+  await mkdir8(path64.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 path63 from "path";
+import path66 from "path";
 
 // src/core/runLog.ts
 import { mkdir as mkdir9, writeFile as writeFile8 } from "fs/promises";
-import path62 from "path";
+import path65 from "path";
 async function writeValidateRunLog(input) {
-  const root = path62.resolve(input.root);
+  const root = path65.resolve(input.root);
   const outDir = resolvePath(root, input.config, "outDir");
   await mkdir9(outDir, { recursive: true });
   const { runId, reportDir } = await allocateRunReportDir(outDir, input.startedAt);
@@ -19242,10 +19882,10 @@ async function writeValidateRunLog(input) {
     errors,
     warnings
   });
-  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}
+  await writeJson(path65.join(reportDir, "run.json"), runJson);
+  await writeJson(path65.join(reportDir, "validator.json"), validatorJson);
+  await writeJson(path65.join(reportDir, "traceability.json"), traceabilityJson);
+  await writeFile8(path65.join(reportDir, "summary.md"), `${summaryMd}
 `, "utf-8");
   return {
     runId,
@@ -19369,7 +20009,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 = path62.join(outDir, runId);
+    const reportDir = path65.join(outDir, runId);
     try {
       await mkdir9(reportDir);
       return { runId, reportDir };
@@ -19400,7 +20040,7 @@ function shouldFail(result, failOn) {
 // src/cli/commands/validate.ts
 async function runValidate(options) {
   const startedAt = /* @__PURE__ */ new Date();
-  const root = path63.resolve(options.root);
+  const root = path66.resolve(options.root);
   const configResult = await loadConfig(root);
   const blockedIssue = buildCiRefinementIssue(options.phase);
   const blockedByPhaseGuard = blockedIssue !== null;
@@ -19556,12 +20196,12 @@ function issueKey(issue2) {
 }
 async function emitJson(result, root, jsonPath) {
   const abs = resolveJsonPath(root, jsonPath);
-  await mkdir10(path63.dirname(abs), { recursive: true });
+  await mkdir10(path66.dirname(abs), { recursive: true });
   await writeFile9(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 function resolveJsonPath(root, jsonPath) {
-  return path63.isAbsolute(jsonPath) ? jsonPath : path63.resolve(root, jsonPath);
+  return path66.isAbsolute(jsonPath) ? jsonPath : path66.resolve(root, jsonPath);
 }
 var GITHUB_ANNOTATION_LIMIT = 100;
 var ISSUE_EXPECTED_BY_CODE = {
@@ -19692,6 +20332,9 @@ function parseArgs(argv, cwd) {
     options.help = true;
     command = null;
   }
+  if (command === "prototype") {
+    command = "prototyping";
+  }
   const markInvalid = () => {
     invalid = true;
     options.help = true;
@@ -19870,6 +20513,23 @@ function parseArgs(argv, cwd) {
         i += 1;
         break;
       }
+      case "--mode": {
+        if (command !== "prototyping") {
+          break;
+        }
+        const next = readOptionValue(args, i);
+        if (next === null) {
+          markInvalid();
+          break;
+        }
+        if (next === "low-cost" || next === "standard" || next === "full-harness") {
+          options.prototypingMode = next;
+        } else {
+          options.prototypingModeInvalid = next;
+        }
+        i += 1;
+        break;
+      }
       case "--autogen-ui-fidelity":
         if (command === "prototyping") {
           options.prototypingAutogen = true;
@@ -20077,6 +20737,8 @@ async function run(argv, cwd) {
           autogenOnly: options.prototypingAutogenOnly,
           ...options.prototypingBaseUrl !== void 0 ? { baseUrl: options.prototypingBaseUrl } : {},
           ...options.prototypingEvidenceOut !== void 0 ? { evidenceOut: options.prototypingEvidenceOut } : {},
+          ...options.prototypingMode !== void 0 ? { mode: options.prototypingMode } : {},
+          ...options.prototypingModeInvalid !== void 0 ? { modeInvalid: options.prototypingModeInvalid } : {},
           renderEvidence: options.prototypingRenderEvidence,
           renderViewports: options.prototypingRenderViewports,
           ...options.prototypingRenderOut !== void 0 ? { renderOut: options.prototypingRenderOut } : {}
@@ -20122,6 +20784,7 @@ Options:
   --path <path>                 guardrails: \u5BFE\u8C61\u30D5\u30A1\u30A4\u30EB/\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\uFF08\u8907\u6570\u6307\u5B9A\u53EF\uFF09
   --max <number>                guardrails extract: \u6700\u5927\u4EF6\u6570
   --keyword <text>              guardrails list/extract: \u30AD\u30FC\u30EF\u30FC\u30C9\u30D5\u30A3\u30EB\u30BF
+  --mode <low-cost|standard|full-harness>  prototyping: \u5B9F\u884C\u30E2\u30FC\u30C9 (full-harness \u306F /qfai-prototyping-full-harness \u3078\u30EB\u30FC\u30C6\u30A3\u30F3\u30B0)
   --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