qfai 1.8.2 → 1.8.4

package/dist/index.mjs

@@ -475,7 +475,8 @@ var defaultConfig = {
       requireLayerTags: false,
       requireSizeTags: false,
       maxE2eScenarioRatio: null,
-      maxE2eScenarioCount: null
+      maxE2eScenarioCount: null,
+      forbidTestTodoStubs: true
     },
     traceability: {
       brMustHaveSc: true,
@@ -496,8 +497,7 @@ var defaultConfig = {
     },
     execution: {
       targetUrl: null,
-      browserProvider: "playwright",
-      renderProvider: "playwright"
+      browserTool: "playwright-cli"
     }
   }
 };
@@ -688,6 +688,13 @@ function normalizeValidation(raw, configPath, issues) {
         "validation.testStrategy.maxE2eScenarioCount",
         configPath,
         issues
+      ),
+      forbidTestTodoStubs: readBoolean(
+        testStrategyRaw?.forbidTestTodoStubs,
+        base.testStrategy.forbidTestTodoStubs,
+        "validation.testStrategy.forbidTestTodoStubs",
+        configPath,
+        issues
       )
     },
     traceability: {
@@ -772,14 +779,40 @@ function normalizePrototyping(raw, configPath, issues) {
   }
   const calibration = normalizePrototypingCalibration(raw.calibration, configPath, issues);
   const execution = normalizePrototypingExecution(raw.execution, configPath, issues);
-  if (!calibration && !execution) {
+  const primarySpecId = normalizePrimarySpecId(raw.primarySpecId, configPath, issues);
+  if (!calibration && !execution && primarySpecId === void 0) {
     return void 0;
   }
   return {
     ...calibration ? { calibration } : {},
-    ...execution ? { execution } : {}
+    ...execution ? { execution } : {},
+    ...primarySpecId !== void 0 ? { primarySpecId } : {}
   };
 }
+function normalizePrimarySpecId(raw, configPath, issues) {
+  if (raw === void 0 || raw === null) {
+    return void 0;
+  }
+  if (typeof raw !== "string") {
+    issues.push(
+      configIssue(
+        configPath,
+        'prototyping.primarySpecId \u306F4\u6841\u306E\u6587\u5B57\u5217\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044 (\u4F8B: "0012")\u3002'
+      )
+    );
+    return void 0;
+  }
+  if (!/^\d{4}$/.test(raw)) {
+    issues.push(
+      configIssue(
+        configPath,
+        `prototyping.primarySpecId \u306F4\u6841\u306E\u6570\u5B57\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059 (got "${raw}")\u3002`
+      )
+    );
+    return void 0;
+  }
+  return raw;
+}
 function normalizePrototypingCalibration(raw, configPath, issues) {
   const base = defaultConfig.prototyping?.calibration;
   if (raw === void 0 || raw === null) {
@@ -813,6 +846,30 @@ function normalizePrototypingExecution(raw, configPath, issues) {
     );
     return base ? { ...base } : void 0;
   }
+  for (const legacyKey of ["browserProvider", "renderProvider"]) {
+    if (raw[legacyKey] !== void 0) {
+      issues.push(
+        configIssue(
+          configPath,
+          `prototyping.execution.${legacyKey} \u306F\u5EC3\u6B62\u3055\u308C\u307E\u3057\u305F (spec-0012)\u3002 prototyping.execution.browserTool: playwright-cli \u306B\u7F6E\u304D\u63DB\u3048\u3066\u304F\u3060\u3055\u3044\u3002`
+        )
+      );
+    }
+  }
+  const browserToolRaw = raw.browserTool;
+  let browserTool = "playwright-cli";
+  if (browserToolRaw !== void 0) {
+    if (browserToolRaw !== "playwright-cli") {
+      issues.push(
+        configIssue(
+          configPath,
+          `prototyping.execution.browserTool \u306F "playwright-cli" \u306E\u307F\u6709\u52B9\u3067\u3059 (spec-0012)\u3002 \u53D7\u3051\u53D6\u3063\u305F\u5024: ${JSON.stringify(browserToolRaw)}`
+        )
+      );
+    } else {
+      browserTool = browserToolRaw;
+    }
+  }
   return {
     targetUrl: raw.targetUrl === null ? null : readOptionalString(
       raw.targetUrl,
@@ -820,20 +877,7 @@ function normalizePrototypingExecution(raw, configPath, issues) {
       configPath,
       issues
     ) ?? null,
-    browserProvider: readString(
-      raw.browserProvider,
-      base?.browserProvider ?? "playwright",
-      "prototyping.execution.browserProvider",
-      configPath,
-      issues
-    ),
-    renderProvider: readString(
-      raw.renderProvider,
-      base?.renderProvider ?? "playwright",
-      "prototyping.execution.renderProvider",
-      configPath,
-      issues
-    )
+    browserTool
   };
 }
 function validateObsoleteCalibrationFields(raw, configPath, issues) {
@@ -3028,11 +3072,12 @@ function isValidId(value, prefix) {
 init_surface();
 var PROTOTYPING_MODES = ["low-cost", "standard", "full-harness"];
 var DEFAULT_PROTOTYPING_MODE = "standard";
-var PROTOTYPING_MAX_ITERATIONS = {
+var PROTOTYPING_MAX_CYCLES = {
   "low-cost": 1,
   standard: 3,
   "full-harness": 20
 };
+var PROTOTYPING_MAX_ITERATIONS = PROTOTYPING_MAX_CYCLES;
 var PROTOTYPING_SUPPORTED_SURFACES = ["web", "mobile", "desktop", "mixed"];
 var VALID_MODE_SET = new Set(PROTOTYPING_MODES);
 var VALID_SURFACE_SET = new Set(CANONICAL_PROTOTYPING_SURFACES);
@@ -3062,14 +3107,24 @@ function resolvePrototypingMode(requested) {
   };
 }
 function derivePrototypingObligations(input) {
-  const isFullHarness = input.effectiveMode === "full-harness";
+  const maxCycles = PROTOTYPING_MAX_CYCLES[input.effectiveMode];
   return {
-    requireRuntimeGate: isFullHarness,
-    requireUiFidelity: isFullHarness,
-    requireRenderBundle: isFullHarness,
-    requireBrowserQaBundle: isFullHarness,
+    browserTool: "playwright-cli",
+    requireExecutionPlan: true,
+    requirePlaywrightEvidence: true,
+    requireReviewBundle: true,
+    requireEvaluatorReview: true,
+    requireBestOfHistory: true,
+    requireBreakthrough: true,
+    requireIndependentReviewerGate: true,
+    requirePerfect100Completion: true,
+    requireRuntimeGate: true,
+    requireUiFidelity: true,
+    requireRenderBundle: true,
+    requireBrowserQaBundle: true,
     requireIterations: true,
-    maxIterations: PROTOTYPING_MAX_ITERATIONS[input.effectiveMode],
+    maxCycles,
+    maxIterations: maxCycles,
     validCombination: true
   };
 }
@@ -3536,8 +3591,8 @@ async function readSafe4(filePath) {
 }
 
 // src/core/report.ts
-import { readFile as readFile46 } from "fs/promises";
-import path70 from "path";
+import { readFile as readFile53 } from "fs/promises";
+import path79 from "path";
 
 // src/core/contractIndex.ts
 import { readFile as readFile9 } from "fs/promises";
@@ -3579,6 +3634,31 @@ function record(index, id, file) {
   index.idToFiles.set(id, current);
 }
 
+// src/core/prototyping/round.ts
+var EXPLORATION_ROUNDS = ["r5", "r3", "r2", "r1"];
+var ABSORPTION_ROUNDS = ["r3", "r2", "r1"];
+var ROUND_SURVIVOR_COUNT = {
+  r5: 5,
+  r3: 3,
+  r2: 2,
+  r1: 1
+};
+function isExplorationRound(value) {
+  return typeof value === "string" && EXPLORATION_ROUNDS.includes(value);
+}
+function prototypingRoundsDir() {
+  return ".qfai/evidence/prototyping/rounds";
+}
+function roundDir(round) {
+  return `${prototypingRoundsDir()}/${round}`;
+}
+function roundReviewBundlePath(round) {
+  return `${roundDir(round)}/review-bundle.json`;
+}
+function roundEvaluatorReviewsDir(round) {
+  return `${roundDir(round)}/evaluator-reviews`;
+}
+
 // src/core/specPackIds.ts
 var STRICT_ID_PATTERNS2 = {
   OBJ: /\bOBJ-\d+\b/g,
@@ -4291,15 +4371,15 @@ function asTagArray(value) {
 }
 
 // src/core/validate.ts
-import path69 from "path";
+import path78 from "path";
 
 // src/core/version.ts
 import { readFile as readFile10 } from "fs/promises";
 import path13 from "path";
 import { fileURLToPath } from "url";
 async function resolveToolVersion() {
-  if ("1.8.2".length > 0) {
-    return "1.8.2";
+  if ("1.8.4".length > 0) {
+    return "1.8.4";
   }
   try {
     const packagePath = resolvePackageJsonPath();
@@ -7230,7 +7310,7 @@ var SPEC_TAG_RE = /^SPEC-\d{4}$/;
 var US_ID_RE2 = /\bUS-\d{4}-\d{4}\b/g;
 var AC_ID_RE3 = /\bAC-\d{4}-\d{4}\b/g;
 var DOWNSTREAM_ID_RE = /\b(?:US|AC|BR|SC|CASE)-\d{4}-\d{4}\b/g;
-async function validateTraceability(root, config, phase) {
+async function validateTraceability(root, config, options) {
   const issues = [];
   const specsRoot = resolvePath(root, config, "specsDir");
   const entries = await collectSpecEntries(specsRoot);
@@ -7306,7 +7386,7 @@ async function validateTraceability(root, config, phase) {
     issues.push(...validateLayeredEdges(entry, edgeData));
     issues.push(...validateLayeredHeuristics(entry, edgeData));
   }
-  if (phase !== "refinement" && allLayeredScIds.size > 0) {
+  if (options.includeCodeReferences && allLayeredScIds.size > 0) {
     issues.push(
       ...await validateLayeredScCodeReferences(root, config, allLayeredScIds, specsRoot)
     );
@@ -10086,8 +10166,109 @@ function normalizeOptionalFragment(fragment, originalRef) {
   return normalized;
 }
 
+// src/core/prototyping/candidate.ts
+var CANDIDATE_ID_PATTERN = /^c[1-9]\d*$/;
+function isCandidateId(value) {
+  return typeof value === "string" && CANDIDATE_ID_PATTERN.test(value);
+}
+
 // src/core/validators/prototypingEvidence.ts
 init_utils();
+
+// src/core/validators/prototyping/modeInvariant.ts
+init_utils();
+function isRecord5(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function detectMode(raw) {
+  if (!isRecord5(raw)) return null;
+  if (typeof raw.mode === "string" && isValidPrototypingMode(raw.mode)) {
+    return { mode: raw.mode, source: "string" };
+  }
+  if (isRecord5(raw.mode) && typeof raw.mode.effective === "string") {
+    const effective = raw.mode.effective;
+    if (isValidPrototypingMode(effective)) {
+      return { mode: effective, source: "object" };
+    }
+  }
+  return null;
+}
+function validateModeInvariant(raw, evidencePathForIssue = ".qfai/evidence/prototyping.json") {
+  if (!isRecord5(raw)) {
+    return [];
+  }
+  const detected = detectMode(raw);
+  if (!detected) {
+    return [];
+  }
+  const issues = [];
+  const expectedMaxCycles = PROTOTYPING_MAX_CYCLES[detected.mode];
+  if (raw.maxCycles !== void 0 && raw.maxIterations !== void 0 && raw.maxCycles !== raw.maxIterations) {
+    issues.push(
+      issue(
+        "QFAI-PROT-MODE-001",
+        `prototyping.json declares both maxCycles and maxIterations with conflicting values (maxCycles=${JSON.stringify(raw.maxCycles)}, maxIterations=${JSON.stringify(raw.maxIterations)}). They must agree (maxIterations is a deprecated alias).`,
+        "error",
+        evidencePathForIssue,
+        "prototyping.modeInvariant.maxCyclesAlias",
+        [JSON.stringify(raw.maxCycles), JSON.stringify(raw.maxIterations)],
+        "canonical",
+        "Remove the redundant key or align both values; prefer maxCycles (spec-0017 REQ-0001)."
+      )
+    );
+  }
+  const maxCyclesRaw = raw.maxCycles ?? raw.maxIterations;
+  if (maxCyclesRaw !== void 0) {
+    if (typeof maxCyclesRaw !== "number" || !Number.isInteger(maxCyclesRaw) || maxCyclesRaw !== expectedMaxCycles) {
+      const maxCyclesDisplay = JSON.stringify(maxCyclesRaw);
+      issues.push(
+        issue(
+          "QFAI-PROT-MODE-001",
+          `Mode differences are limited to maxCycles only. Expected maxCycles=${expectedMaxCycles} for mode=${detected.mode}, got ${maxCyclesDisplay}.`,
+          "error",
+          evidencePathForIssue,
+          "prototyping.modeInvariant",
+          [detected.mode, String(expectedMaxCycles), maxCyclesDisplay],
+          "canonical",
+          `Set prototyping.json maxCycles to ${expectedMaxCycles} to match PROTOTYPING_MAX_CYCLES[${detected.mode}], or switch the mode if a different budget is desired (spec-0017 REQ-0001).`
+        )
+      );
+    }
+  }
+  if (raw.browserTool !== void 0) {
+    if (raw.browserTool !== "playwright-cli") {
+      const browserToolDisplay = JSON.stringify(raw.browserTool);
+      issues.push(
+        issue(
+          "QFAI-PROT-MODE-001",
+          `browserTool must be "playwright-cli" (spec-0017 REQ-0002). Got: ${browserToolDisplay}`,
+          "error",
+          evidencePathForIssue,
+          "prototyping.modeInvariant.browserTool",
+          [browserToolDisplay],
+          "canonical",
+          'Set prototyping.json browserTool to "playwright-cli". Playwright MCP and legacy providers are not supported in the standard harness.'
+        )
+      );
+    }
+  }
+  return issues;
+}
+
+// src/core/validators/prototypingEvidence.ts
+var VALID_ITERATION_KIND_SET = /* @__PURE__ */ new Set(["explore", "remix", "select", "polish", "branch"]);
+var VALID_PHASE_SET = /* @__PURE__ */ new Set([
+  "planning",
+  "explore",
+  "remix",
+  "select",
+  "polish",
+  "breakthrough",
+  "reviewer_gate",
+  "completed"
+]);
+var REQUIRED_POLISH_CHECKS = ["critique", "fix", "recapture", "rereview", "breakthrough"];
+var LEGACY_PASS_95_FIELD = "allItemsPass" + String(95);
 var VALID_MODE_SOURCE_SET = /* @__PURE__ */ new Set([
   "explicit-request",
   "system-default",
@@ -10156,6 +10337,24 @@ async function validatePrototypingEvidence(root, config) {
     return issues;
   }
   const obligations = surface && isSupportedPrototypingSurface(surface) ? derivePrototypingObligations({ surface, effectiveMode: mode.effective }) : void 0;
+  issues.push(
+    ...validateModeInvariant(record2, path35.relative(root, evidencePath).replace(/\\/g, "/"))
+  );
+  const isV2Record = record2.schemaVersion === "2.0" || record2.rounds !== void 0 || record2.polishCycles !== void 0;
+  if (isV2Record) {
+    issues.push(...validateV2Lifecycle(root, evidencePath, record2, mode, obligations));
+    if (obligations?.requireRuntimeGate && !isRecord6(record2.runtimeGate)) {
+      issues.push(
+        makeSchemaIssue(root, evidencePath, "runtimeGate is required in full-harness mode.")
+      );
+    }
+    if (obligations?.requireUiFidelity && !isRecord6(record2.uiFidelity)) {
+      issues.push(
+        makeSchemaIssue(root, evidencePath, "uiFidelity is required in full-harness mode.")
+      );
+    }
+    return issues;
+  }
   const iterations = normalizeIterations(record2.iterations);
   if (!iterations || iterations.length === 0) {
     issues.push(
@@ -10186,10 +10385,14 @@ async function validatePrototypingEvidence(root, config) {
       )
     );
   }
-  let foundPass95 = false;
+  let latestPerfect100 = false;
+  let latestIterationKind = null;
+  let completedPolishCount = 0;
+  let polishWithBreakthroughCheck = false;
+  let hasLegacyPass95CompletionMarker = false;
   for (const [index, candidate] of iterations.entries()) {
     const prefix = `iterations[${index}]`;
-    if (!isRecord5(candidate)) {
+    if (!isRecord6(candidate)) {
       issues.push(makeSchemaIssue(root, evidencePath, `${prefix} must be an object.`));
       continue;
     }
@@ -10200,12 +10403,43 @@ async function validatePrototypingEvidence(root, config) {
         makeSchemaIssue(root, evidencePath, `${prefix}.iteration must be a positive integer.`)
       );
     }
-    if (typeof iteration.allItemsPass95 !== "boolean") {
+    if (typeof iteration.allReviewerAxesPerfect100 !== "boolean") {
       issues.push(
-        makeSchemaIssue(root, evidencePath, `${prefix}.allItemsPass95 must be a boolean.`)
+        makeSchemaIssue(
+          root,
+          evidencePath,
+          `${prefix}.allReviewerAxesPerfect100 must be a boolean.`
+        )
       );
-    } else if (iteration.allItemsPass95) {
-      foundPass95 = true;
+    } else if (iteration.allReviewerAxesPerfect100) {
+      latestPerfect100 = true;
+    } else {
+      latestPerfect100 = false;
+    }
+    if (iteration[LEGACY_PASS_95_FIELD] === true) {
+      hasLegacyPass95CompletionMarker = true;
+    }
+    if (iteration.kind !== void 0) {
+      if (typeof iteration.kind !== "string" || !VALID_ITERATION_KIND_SET.has(iteration.kind)) {
+        issues.push(
+          issue(
+            "QFAI-PROT-285",
+            `${prefix}.kind must be one of explore|remix|select|polish|branch.`,
+            "error",
+            path35.relative(root, evidencePath).replace(/\\/g, "/"),
+            "prototypingEvidence.phase",
+            void 0,
+            "canonical",
+            "iteration kind \u3092 phase state machine \u306B\u5408\u308F\u305B\u3066\u8A18\u9332\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+          )
+        );
+      } else {
+        latestIterationKind = iteration.kind;
+        if (iteration.kind === "polish" && hasCompletePolishChecks(iteration.checks)) {
+          completedPolishCount++;
+          polishWithBreakthroughCheck = true;
+        }
+      }
     }
     if (!Array.isArray(iteration.reviewerScores) || iteration.reviewerScores.length === 0) {
       issues.push(
@@ -10215,7 +10449,7 @@ async function validatePrototypingEvidence(root, config) {
     }
     for (const [reviewerIndex, reviewer] of iteration.reviewerScores.entries()) {
       const reviewerPath = `${prefix}.reviewerScores[${reviewerIndex}]`;
-      if (!isRecord5(reviewer)) {
+      if (!isRecord6(reviewer)) {
         issues.push(makeSchemaIssue(root, evidencePath, `${reviewerPath} must be an object.`));
         continue;
       }
@@ -10232,7 +10466,7 @@ async function validatePrototypingEvidence(root, config) {
       }
       for (const [scoreIndex, score] of reviewer.scores.entries()) {
         const scorePath = `${reviewerPath}.scores[${scoreIndex}]`;
-        if (!isRecord5(score)) {
+        if (!isRecord6(score)) {
           issues.push(makeSchemaIssue(root, evidencePath, `${scorePath} must be an object.`));
           continue;
         }
@@ -10272,27 +10506,131 @@ async function validatePrototypingEvidence(root, config) {
       }
     }
   }
+  const phaseCurrent = normalizePhaseCurrent(record2.phase);
+  if (phaseCurrent !== null && !VALID_PHASE_SET.has(phaseCurrent)) {
+    issues.push(
+      issue(
+        "QFAI-PROT-285",
+        "phase.current must follow the prototyping phase state machine.",
+        "error",
+        path35.relative(root, evidencePath).replace(/\\/g, "/"),
+        "prototypingEvidence.phase",
+        void 0,
+        "canonical",
+        "phase.current \u306F planning|explore|remix|select|polish|breakthrough|reviewer_gate|completed \u306E\u3044\u305A\u308C\u304B\u3067\u8A18\u9332\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+      )
+    );
+  }
+  const fullHarnessStatus = normalizeFullHarnessStatus(record2.fullHarness);
+  const completionClaimed = record2.completionClaimed === true || record2.completionEligible === true || phaseCurrent === "completed" || fullHarnessStatus === "completed";
+  if (hasLegacyPass95CompletionMarker && completionClaimed) {
+    issues.push(
+      issue(
+        "QFAI-PROT-288",
+        "The legacy 95-point completion field is no longer a completion border; completion requires allReviewerAxesPerfect100.",
+        "error",
+        path35.relative(root, evidencePath).replace(/\\/g, "/"),
+        "prototypingEvidence.perfect100",
+        void 0,
+        "canonical",
+        "95 \u70B9\u5230\u9054\u30D5\u30A3\u30FC\u30EB\u30C9\u3092\u5B8C\u4E86\u6761\u4EF6\u3068\u3057\u3066\u4F7F\u308F\u305A\u3001\u5168 reviewer / \u5168 axis 100 \u70B9\u3092 allReviewerAxesPerfect100 \u3067\u8A18\u9332\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+      )
+    );
+  }
+  if (completionClaimed) {
+    if (!latestPerfect100 || !allReviewerScoresArePerfect100(iterations)) {
+      issues.push(
+        issue(
+          "QFAI-PROT-287",
+          "Completion requires every reviewer to score every evaluation axis at 100.",
+          "error",
+          path35.relative(root, evidencePath).replace(/\\/g, "/"),
+          "prototypingEvidence.perfect100",
+          void 0,
+          "canonical",
+          "completionClaimed/completed \u3092\u8A18\u9332\u3059\u308B\u524D\u306B\u3001\u5168 reviewerScores[].scores[].score \u3092 100 \u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+        )
+      );
+    }
+    if (latestIterationKind === "select") {
+      issues.push(
+        issue(
+          "QFAI-PROT-285",
+          "Selection funnel completion is not stage completion; latest iteration cannot remain select when completion is claimed.",
+          "error",
+          path35.relative(root, evidencePath).replace(/\\/g, "/"),
+          "prototypingEvidence.phase",
+          void 0,
+          "canonical",
+          "winner \u9078\u5B9A\u5F8C\u306B post-selection polish iteration \u3092\u5B8C\u4E86\u3057\u3066\u304B\u3089 completion \u3092 claim \u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+        )
+      );
+    }
+    const postSelectionPolishCount = typeof record2.postSelectionPolishCount === "number" ? record2.postSelectionPolishCount : completedPolishCount;
+    if (!Number.isInteger(postSelectionPolishCount) || postSelectionPolishCount < 1) {
+      issues.push(
+        issue(
+          "QFAI-PROT-286",
+          "Completion requires at least one completed post-selection polish iteration.",
+          "error",
+          path35.relative(root, evidencePath).replace(/\\/g, "/"),
+          "prototypingEvidence.postSelectionPolish",
+          void 0,
+          "canonical",
+          "postSelectionPolishCount >= 1 \u3068\u3057\u3001polish iteration \u306B critique/fix/recapture/rereview/breakthrough checks \u3092\u8A18\u9332\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+        )
+      );
+    }
+    if (!polishWithBreakthroughCheck) {
+      issues.push(
+        issue(
+          "QFAI-PROT-286",
+          "Completion requires a polish iteration with critique/fix/recapture/rereview/breakthrough checks.",
+          "error",
+          path35.relative(root, evidencePath).replace(/\\/g, "/"),
+          "prototypingEvidence.postSelectionPolish",
+          void 0,
+          "canonical",
+          "polish iteration \u306E checks.critique/fix/recapture/rereview/breakthrough \u3092 true \u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+        )
+      );
+    }
+    if (!isRecord6(record2.completionCertificate)) {
+      issues.push(
+        issue(
+          "QFAI-PROT-289",
+          "completionCertificate is required when completion is claimed.",
+          "error",
+          path35.relative(root, evidencePath).replace(/\\/g, "/"),
+          "prototypingEvidence.completionCertificate",
+          void 0,
+          "canonical",
+          "reviewerGateResult/validateCommand/bestOfHistoryRef/breakthroughRef \u3092\u542B\u3080 completionCertificate \u3092\u8A18\u9332\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+        )
+      );
+    }
+  }
   const maxIterations = PROTOTYPING_MAX_ITERATIONS[mode.effective];
-  if (!foundPass95 && iterations.length < maxIterations) {
+  if (!latestPerfect100 && iterations.length < maxIterations) {
     issues.push(
       issue(
         "QFAI-PROT-282",
-        `mode=${mode.effective} has not reached all-items-pass-95 and has remaining iterations.`,
+        `mode=${mode.effective} has not reached all-reviewer-axes-perfect-100 and has remaining iterations.`,
         "warning",
         path35.relative(root, evidencePath).replace(/\\/g, "/"),
         "prototypingEvidence.convergence",
         [String(iterations.length), String(maxIterations)],
         "canonical",
-        "95 \u70B9\u672A\u6E80\u306E\u9805\u76EE\u304C\u6B8B\u3063\u3066\u3044\u308B\u305F\u3081\u3001mode \u4E0A\u9650\u306B\u9054\u3059\u308B\u307E\u3067\u53CD\u5FA9\u3092\u7D99\u7D9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+        "\u5168 reviewer / \u5168 axis \u304C 100 \u70B9\u306B\u9054\u3057\u3066\u3044\u306A\u3044\u305F\u3081\u3001mode \u4E0A\u9650\u306B\u9054\u3059\u308B\u307E\u3067\u53CD\u5FA9\u3092\u7D99\u7D9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
       )
     );
   }
-  if (obligations?.requireRuntimeGate && !isRecord5(record2.runtimeGate)) {
+  if (obligations?.requireRuntimeGate && !isRecord6(record2.runtimeGate)) {
     issues.push(
       makeSchemaIssue(root, evidencePath, "runtimeGate is required in full-harness mode.")
     );
   }
-  if (obligations?.requireUiFidelity && !isRecord5(record2.uiFidelity)) {
+  if (obligations?.requireUiFidelity && !isRecord6(record2.uiFidelity)) {
     issues.push(
       makeSchemaIssue(root, evidencePath, "uiFidelity is required in full-harness mode.")
     );
@@ -10331,98 +10669,446 @@ function normalizeIterations(value) {
   }
   return value;
 }
-function isRecord5(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-async function readJsonFile(filePath) {
-  try {
-    const raw = await readFile24(filePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    return isRecord5(parsed) ? { status: "ok", value: parsed } : { status: "invalid" };
-  } catch {
-    try {
-      await readFile24(filePath, "utf-8");
-      return { status: "invalid" };
-    } catch {
-      return { status: "missing" };
-    }
+function normalizeRounds(value) {
+  if (!Array.isArray(value)) {
+    return null;
   }
+  return value;
 }
-function makeSchemaIssue(root, evidencePath, message) {
-  return issue(
-    "QFAI-PROT-299",
-    message,
-    "error",
-    path35.relative(root, evidencePath).replace(/\\/g, "/"),
-    "prototypingEvidence.schema"
-  );
-}
-
-// src/core/validators/prototypingDesignSystem.ts
-import { access as access9, readFile as readFile25 } from "fs/promises";
-import path36 from "path";
-var RULE_CODE = "PROT-DS01";
-var RULE_NAME = "prototyping.designSystemCompliance";
-var MESSAGE = "prototyping.json scoringTrace is missing required `designSystemCompliance` score.";
-var SUGGESTED_ACTION = "Add `scoringTrace.designSystemCompliance` (numeric score 0..100 or null with rationale) to prototyping.json.";
-function isRecord6(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function detectMode(raw) {
-  if (!isRecord6(raw)) {
-    return "other";
+function normalizePolishCycles(value) {
+  if (!Array.isArray(value)) {
+    return null;
   }
-  const topLevel = raw.mode;
-  if (isRecord6(topLevel) && topLevel.effective === "full-harness") {
-    return "full-harness";
+  return value;
+}
+function normalizePhaseCurrent(value) {
+  if (!isRecord6(value)) {
+    return null;
   }
-  return "other";
+  return typeof value.current === "string" ? value.current : null;
 }
-function detectScorePresence(raw) {
-  if (!isRecord6(raw)) {
-    return false;
+function normalizeFullHarnessStatus(value) {
+  if (!isRecord6(value)) {
+    return null;
   }
-  const trace = raw.scoringTrace;
-  if (!isRecord6(trace)) {
+  return typeof value.status === "string" ? value.status : null;
+}
+function hasCompletePolishChecks(value) {
+  if (!isRecord6(value)) {
     return false;
   }
-  return Object.prototype.hasOwnProperty.call(trace, "designSystemCompliance");
+  return REQUIRED_POLISH_CHECKS.every((key) => value[key] === true);
 }
-async function fileExists2(filePath) {
-  try {
-    await access9(filePath);
-    return true;
-  } catch (err) {
-    if (typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT") {
-      return false;
-    }
+function allReviewerScoresArePerfect100(iterations) {
+  const candidate = iterations[iterations.length - 1];
+  if (!isRecord6(candidate) || !Array.isArray(candidate.reviewerScores)) {
     return false;
   }
-}
-async function readFileSafe(filePath) {
-  try {
-    return await readFile25(filePath, "utf-8");
-  } catch (err) {
-    if (typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT") {
-      return null;
+  return candidate.reviewerScores.every((reviewer) => {
+    if (!isRecord6(reviewer) || !Array.isArray(reviewer.scores) || reviewer.scores.length === 0) {
+      return false;
     }
-    return null;
-  }
+    return reviewer.scores.every((score) => isRecord6(score) && score.score === 100);
+  });
 }
-async function loadPrototypingArtifact(evidenceDir) {
-  const jsonPath = path36.join(evidenceDir, "prototyping.json");
-  const jsonRaw = await readFileSafe(jsonPath);
-  if (jsonRaw !== null) {
-    let parsed = null;
-    try {
-      parsed = JSON.parse(jsonRaw);
-    } catch {
+function validateV2Lifecycle(root, evidencePath, record2, mode, obligations) {
+  const issues = [];
+  const rounds = normalizeRounds(record2.rounds);
+  if (!rounds || rounds.length === 0) {
+    issues.push(
+      issue(
+        "QFAI-PROT-280",
+        "prototyping evidence requires at least one round entry.",
+        "error",
+        path35.relative(root, evidencePath).replace(/\\/g, "/"),
+        "prototypingEvidence.rounds",
+        void 0,
+        "canonical",
+        "rounds[] \u306B\u5C11\u306A\u304F\u3068\u3082 1 \u4EF6\u306E\u63A2\u7D22 round \u3092\u8A18\u9332\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+      )
+    );
+    return issues;
+  }
+  const polishCycles = normalizePolishCycles(record2.polishCycles) ?? [];
+  if (obligations && polishCycles.length > obligations.maxIterations) {
+    issues.push(
+      issue(
+        "QFAI-PROT-281",
+        `mode=${mode.effective} exceeds max polish cycles (${obligations.maxIterations}).`,
+        "error",
+        path35.relative(root, evidencePath).replace(/\\/g, "/"),
+        "prototypingEvidence.maxIterations",
+        [String(polishCycles.length), String(obligations.maxIterations)],
+        "canonical",
+        `mode=${mode.effective} \u306E polish cycle \u4E0A\u9650 ${obligations.maxIterations} \u3092\u8D85\u3048\u306A\u3044\u3088\u3046\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+      )
+    );
+  }
+  let latestPerfect100 = false;
+  let completedPolishCount = 0;
+  let polishWithBreakthroughCheck = false;
+  for (const [index, candidate] of rounds.entries()) {
+    const prefix = `rounds[${index}]`;
+    if (!isRecord6(candidate)) {
+      issues.push(makeSchemaIssue(root, evidencePath, `${prefix} must be an object.`));
+      continue;
+    }
+    let validRound = null;
+    if (!isExplorationRound(candidate.round)) {
+      issues.push(makeSchemaIssue(root, evidencePath, `${prefix}.round must be r5|r3|r2|r1.`));
+    } else {
+      validRound = candidate.round;
+      if (index >= EXPLORATION_ROUNDS.length) {
+        issues.push(
+          makeSchemaIssue(
+            root,
+            evidencePath,
+            `${prefix} exceeds the funnel limit (rounds[] must contain at most ${EXPLORATION_ROUNDS.length} entries: ${EXPLORATION_ROUNDS.join("\u2192")}).`
+          )
+        );
+      } else {
+        const expectedRound = EXPLORATION_ROUNDS[index];
+        if (expectedRound !== void 0 && validRound !== expectedRound) {
+          issues.push(
+            makeSchemaIssue(
+              root,
+              evidencePath,
+              `${prefix}.round must be ${expectedRound} (rounds[] must follow ${EXPLORATION_ROUNDS.join("\u2192")}); got ${validRound}.`
+            )
+          );
+        }
+      }
+    }
+    const candidateIds = [];
+    const seenCandidateIds = /* @__PURE__ */ new Set();
+    if (!Array.isArray(candidate.candidates) || candidate.candidates.length === 0) {
+      issues.push(
+        makeSchemaIssue(root, evidencePath, `${prefix}.candidates must be a non-empty array.`)
+      );
+    } else {
+      for (const [candidateIndex, roundCandidate] of candidate.candidates.entries()) {
+        if (!isRecord6(roundCandidate)) {
+          issues.push(
+            makeSchemaIssue(
+              root,
+              evidencePath,
+              `${prefix}.candidates[${candidateIndex}] must be an object.`
+            )
+          );
+          continue;
+        }
+        if (!isCandidateId(roundCandidate.candidateId)) {
+          issues.push(
+            makeSchemaIssue(
+              root,
+              evidencePath,
+              `${prefix}.candidates[${candidateIndex}].candidateId must be a valid candidate id.`
+            )
+          );
+        } else if (seenCandidateIds.has(roundCandidate.candidateId)) {
+          issues.push(
+            makeSchemaIssue(
+              root,
+              evidencePath,
+              `${prefix}.candidates[${candidateIndex}].candidateId must be unique within the round; ${roundCandidate.candidateId} already appears earlier.`
+            )
+          );
+        } else {
+          seenCandidateIds.add(roundCandidate.candidateId);
+          candidateIds.push(roundCandidate.candidateId);
+        }
+      }
+      if (validRound) {
+        const expectedCandidateCount = ROUND_SURVIVOR_COUNT[validRound];
+        if (candidate.candidates.length !== expectedCandidateCount) {
+          issues.push(
+            makeSchemaIssue(
+              root,
+              evidencePath,
+              `${prefix}.candidates must contain exactly ${expectedCandidateCount} entries for round ${validRound}; got ${candidate.candidates.length}.`
+            )
+          );
+        }
+      }
+    }
+    const screenMap = isRecord6(candidate.screenEvidenceByCandidate) ? candidate.screenEvidenceByCandidate : null;
+    if (screenMap === null) {
+      issues.push(
+        makeSchemaIssue(
+          root,
+          evidencePath,
+          `${prefix}.screenEvidenceByCandidate must be an object keyed by candidateId.`
+        )
+      );
+    }
+    const reviewMap = isRecord6(candidate.evaluatorReviewRefsByCandidate) ? candidate.evaluatorReviewRefsByCandidate : null;
+    if (reviewMap === null) {
+      issues.push(
+        makeSchemaIssue(
+          root,
+          evidencePath,
+          `${prefix}.evaluatorReviewRefsByCandidate must be an object keyed by candidateId.`
+        )
+      );
+    }
+    for (const candidateId of candidateIds) {
+      if (screenMap) {
+        const screens = screenMap[candidateId];
+        if (!Array.isArray(screens) || screens.length === 0) {
+          issues.push(
+            makeSchemaIssue(
+              root,
+              evidencePath,
+              `${prefix}.screenEvidenceByCandidate.${candidateId} must be a non-empty array of screen artifact refs.`
+            )
+          );
+        }
+      }
+      if (reviewMap) {
+        const reviewRef = reviewMap[candidateId];
+        if (typeof reviewRef !== "string" || reviewRef.trim().length === 0) {
+          issues.push(
+            makeSchemaIssue(
+              root,
+              evidencePath,
+              `${prefix}.evaluatorReviewRefsByCandidate.${candidateId} must be a non-empty string.`
+            )
+          );
+        }
+      }
+    }
+    if (typeof candidate.allAxesPerfect100 !== "boolean") {
+      issues.push(
+        makeSchemaIssue(root, evidencePath, `${prefix}.allAxesPerfect100 must be a boolean.`)
+      );
+    } else {
+      latestPerfect100 = candidate.allAxesPerfect100;
+    }
+  }
+  for (const [index, cycle] of polishCycles.entries()) {
+    const prefix = `polishCycles[${index}]`;
+    if (!isRecord6(cycle)) {
+      issues.push(makeSchemaIssue(root, evidencePath, `${prefix} must be an object.`));
+      continue;
+    }
+    if (typeof cycle.cycle !== "number" || !Number.isInteger(cycle.cycle) || cycle.cycle <= 0) {
+      issues.push(
+        makeSchemaIssue(root, evidencePath, `${prefix}.cycle must be a positive integer.`)
+      );
+    }
+    if (typeof cycle.kind !== "string" || !["polish", "branch", "reviewer_gate", "completed"].includes(cycle.kind)) {
+      issues.push(
+        makeSchemaIssue(
+          root,
+          evidencePath,
+          `${prefix}.kind must be polish|branch|reviewer_gate|completed.`
+        )
+      );
+    }
+    if (typeof cycle.evaluatorReviewRef !== "string" || cycle.evaluatorReviewRef.trim().length === 0) {
+      issues.push(
+        makeSchemaIssue(root, evidencePath, `${prefix}.evaluatorReviewRef must be non-empty.`)
+      );
+    }
+    if (typeof cycle.allAxesPerfect100 !== "boolean") {
+      issues.push(
+        makeSchemaIssue(root, evidencePath, `${prefix}.allAxesPerfect100 must be a boolean.`)
+      );
+    } else {
+      latestPerfect100 = cycle.allAxesPerfect100;
+    }
+    if (cycle.kind === "polish") {
+      completedPolishCount += 1;
+      if (typeof cycle.breakthroughRef === "string" && cycle.breakthroughRef.trim().length > 0) {
+        polishWithBreakthroughCheck = true;
+      }
+    }
+  }
+  const phaseCurrent = normalizePhaseCurrent(record2.phase);
+  if (phaseCurrent !== null && !VALID_PHASE_SET.has(phaseCurrent)) {
+    issues.push(
+      issue(
+        "QFAI-PROT-285",
+        "phase.current must follow the prototyping phase state machine.",
+        "error",
+        path35.relative(root, evidencePath).replace(/\\/g, "/"),
+        "prototypingEvidence.phase",
+        void 0,
+        "canonical",
+        "phase.current \u306F planning|explore|remix|select|polish|breakthrough|reviewer_gate|completed \u306E\u3044\u305A\u308C\u304B\u3067\u8A18\u9332\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+      )
+    );
+  }
+  const fullHarnessStatus = normalizeFullHarnessStatus(record2.fullHarness);
+  const completionClaimed = record2.completionClaimed === true || record2.completionEligible === true || phaseCurrent === "completed" || fullHarnessStatus === "completed";
+  if (completionClaimed) {
+    if (!latestPerfect100) {
+      issues.push(
+        issue(
+          "QFAI-PROT-287",
+          "Completion requires every reviewer to score every evaluation axis at 100.",
+          "error",
+          path35.relative(root, evidencePath).replace(/\\/g, "/"),
+          "prototypingEvidence.perfect100",
+          void 0,
+          "canonical",
+          "completionClaimed/completed \u3092\u8A18\u9332\u3059\u308B\u524D\u306B\u3001\u6700\u65B0 round \u307E\u305F\u306F polish cycle \u306E allAxesPerfect100 \u3092 true \u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+        )
+      );
+    }
+    const postSelectionPolishCount = typeof record2.postSelectionPolishCount === "number" ? record2.postSelectionPolishCount : completedPolishCount;
+    if (!Number.isInteger(postSelectionPolishCount) || postSelectionPolishCount < 1) {
+      issues.push(
+        issue(
+          "QFAI-PROT-286",
+          "Completion requires at least one completed post-selection polish cycle.",
+          "error",
+          path35.relative(root, evidencePath).replace(/\\/g, "/"),
+          "prototypingEvidence.postSelectionPolish",
+          void 0,
+          "canonical",
+          "postSelectionPolishCount >= 1 \u3068\u3057\u3001polish cycle \u3092\u5C11\u306A\u304F\u3068\u3082 1 \u4EF6\u8A18\u9332\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+        )
+      );
+    }
+    if (!polishWithBreakthroughCheck) {
+      issues.push(
+        issue(
+          "QFAI-PROT-286",
+          "Completion requires a polish cycle with breakthrough evidence.",
+          "error",
+          path35.relative(root, evidencePath).replace(/\\/g, "/"),
+          "prototypingEvidence.postSelectionPolish",
+          void 0,
+          "canonical",
+          "polish cycle \u306B breakthroughRef \u3092\u8A18\u9332\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+        )
+      );
+    }
+    if (!isRecord6(record2.completionCertificate)) {
+      issues.push(
+        issue(
+          "QFAI-PROT-289",
+          "completionCertificate is required when completion is claimed.",
+          "error",
+          path35.relative(root, evidencePath).replace(/\\/g, "/"),
+          "prototypingEvidence.completionCertificate",
+          void 0,
+          "canonical",
+          "reviewerGateResult/validateCommand/bestOfHistoryRef/breakthroughRef \u3092\u542B\u3080 completionCertificate \u3092\u8A18\u9332\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+        )
+      );
+    }
+  }
+  const maxIterations = PROTOTYPING_MAX_ITERATIONS[mode.effective];
+  if (!latestPerfect100 && polishCycles.length < maxIterations) {
+    issues.push(
+      issue(
+        "QFAI-PROT-282",
+        `mode=${mode.effective} has not reached all-reviewer-axes-perfect-100 and has remaining polish cycles.`,
+        "warning",
+        path35.relative(root, evidencePath).replace(/\\/g, "/"),
+        "prototypingEvidence.convergence",
+        [String(polishCycles.length), String(maxIterations)],
+        "canonical",
+        "\u5168 reviewer / \u5168 axis \u304C 100 \u70B9\u306B\u9054\u3057\u3066\u3044\u306A\u3044\u305F\u3081\u3001mode \u4E0A\u9650\u306B\u9054\u3059\u308B\u307E\u3067 polish cycle \u3092\u7D99\u7D9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+      )
+    );
+  }
+  return issues;
+}
+function isRecord6(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+async function readJsonFile(filePath) {
+  try {
+    const raw = await readFile24(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return isRecord6(parsed) ? { status: "ok", value: parsed } : { status: "invalid" };
+  } catch {
+    try {
+      await readFile24(filePath, "utf-8");
+      return { status: "invalid" };
+    } catch {
+      return { status: "missing" };
+    }
+  }
+}
+function makeSchemaIssue(root, evidencePath, message) {
+  return issue(
+    "QFAI-PROT-299",
+    message,
+    "error",
+    path35.relative(root, evidencePath).replace(/\\/g, "/"),
+    "prototypingEvidence.schema"
+  );
+}
+
+// src/core/validators/prototypingDesignSystem.ts
+import { access as access9, readFile as readFile25 } from "fs/promises";
+import path36 from "path";
+var RULE_CODE = "PROT-DS01";
+var RULE_NAME = "prototyping.designSystemCompliance";
+var MESSAGE = "prototyping.json scoringTrace is missing required `designSystemCompliance` score.";
+var SUGGESTED_ACTION = "Add `scoringTrace.designSystemCompliance` (numeric score 0..100 or null with rationale) to prototyping.json.";
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function detectMode2(raw) {
+  if (!isRecord7(raw)) {
+    return "other";
+  }
+  const topLevel = raw.mode;
+  if (isRecord7(topLevel) && topLevel.effective === "full-harness") {
+    return "full-harness";
+  }
+  return "other";
+}
+function detectScorePresence(raw) {
+  if (!isRecord7(raw)) {
+    return false;
+  }
+  const trace = raw.scoringTrace;
+  if (!isRecord7(trace)) {
+    return false;
+  }
+  return Object.prototype.hasOwnProperty.call(trace, "designSystemCompliance");
+}
+async function fileExists2(filePath) {
+  try {
+    await access9(filePath);
+    return true;
+  } catch (err) {
+    if (typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT") {
+      return false;
+    }
+    return false;
+  }
+}
+async function readFileSafe(filePath) {
+  try {
+    return await readFile25(filePath, "utf-8");
+  } catch (err) {
+    if (typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT") {
+      return null;
+    }
+    return null;
+  }
+}
+async function loadPrototypingArtifact(evidenceDir) {
+  const jsonPath = path36.join(evidenceDir, "prototyping.json");
+  const jsonRaw = await readFileSafe(jsonPath);
+  if (jsonRaw !== null) {
+    let parsed = null;
+    try {
+      parsed = JSON.parse(jsonRaw);
+    } catch {
       parsed = null;
     }
     return {
       source: "json",
       fileName: "prototyping.json",
-      mode: detectMode(parsed),
+      mode: detectMode2(parsed),
       designSystemCompliancePresent: detectScorePresence(parsed)
     };
   }
@@ -10444,38 +11130,1060 @@ function toIssue(severity, file) {
     suggested_action: SUGGESTED_ACTION
   };
 }
-function resolveEvidenceRoot(root, config) {
-  return path36.join(path36.dirname(resolvePath(root, config, "specsDir")), "evidence");
+function resolveEvidenceRoot(root, config) {
+  return path36.join(path36.dirname(resolvePath(root, config, "specsDir")), "evidence");
+}
+async function validatePrototypingDesignSystem(root, config) {
+  const screens = await readUiContractScreenContracts(root, config.paths.contractsDir);
+  if (screens.length === 0) {
+    return [];
+  }
+  const evidenceDir = resolveEvidenceRoot(root, config);
+  const artifact = await loadPrototypingArtifact(evidenceDir);
+  if (artifact.designSystemCompliancePresent) {
+    return [];
+  }
+  const designSystemPath = path36.join(
+    root,
+    config.paths.contractsDir,
+    "design",
+    "design-system.yaml"
+  );
+  const designSystemPresent = await fileExists2(designSystemPath);
+  const severity = designSystemPresent && artifact.mode === "full-harness" ? "error" : "warning";
+  return [toIssue(severity, artifact.fileName)];
+}
+
+// src/core/validators/prototyping/executionPlan.ts
+init_utils();
+var FIELD_SHAPE_LABEL = {
+  number: "finite number",
+  "non-empty-string": "non-empty string",
+  record: "object (not array)"
+};
+var REQUIRED_FIELDS = [
+  { key: "targetIterations", shape: "number" },
+  { key: "evaluationAxesSource", shape: "non-empty-string" },
+  { key: "delegationMap", shape: "record" },
+  { key: "plannedAt", shape: "non-empty-string" }
+];
+function describeType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function matchesShape(value, shape) {
+  switch (shape) {
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "non-empty-string":
+      return typeof value === "string" && value.trim().length > 0;
+    case "record":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+}
+function isRecord8(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function detectMode3(raw) {
+  if (!isRecord8(raw)) return "other";
+  if (typeof raw.mode === "string") return raw.mode;
+  if (isRecord8(raw.mode) && typeof raw.mode.effective === "string") {
+    return raw.mode.effective;
+  }
+  return "other";
+}
+function validateExecutionPlanIssues(prototypingJson, prototypingJsonPath) {
+  if (!isRecord8(prototypingJson)) {
+    return [];
+  }
+  if (detectMode3(prototypingJson) !== "full-harness") {
+    return [];
+  }
+  if (!isRecord8(prototypingJson.executionPlan)) {
+    return [
+      buildIssue(
+        "executionPlan is required in full-harness mode but is absent or not an object in prototyping.json.",
+        prototypingJsonPath
+      )
+    ];
+  }
+  const issues = [];
+  const executionPlan = prototypingJson.executionPlan;
+  for (const { key, shape } of REQUIRED_FIELDS) {
+    const value = executionPlan[key];
+    if (!matchesShape(value, shape)) {
+      issues.push(
+        buildIssue(
+          `executionPlan.${key} is required in full-harness mode and must be a ${FIELD_SHAPE_LABEL[shape]} (got: ${describeType(value)}).`,
+          prototypingJsonPath
+        )
+      );
+    }
+  }
+  return issues;
+}
+function buildIssue(message, prototypingJsonPath) {
+  return issue(
+    "QFAI-PROT-310",
+    message,
+    "error",
+    prototypingJsonPath,
+    "prototyping.executionPlan.presence",
+    void 0,
+    "canonical",
+    "full-harness \u30E2\u30FC\u30C9\u3067\u306F `prototyping.json.executionPlan` \u3092\u8A18\u9332\u3057\u3066\u304F\u3060\u3055\u3044 (targetIterations / evaluationAxesSource / delegationMap / plannedAt)\u3002"
+  );
+}
+
+// src/core/validators/prototyping/delegationMap.ts
+init_utils();
+var DELEGATION_SCOPE = {
+  UI\u5B9F\u88C5: ["frontend-engineer", "product-experience-architect"],
+  \u30B9\u30AF\u30EA\u30FC\u30F3\u30B7\u30E7\u30C3\u30C8: ["devops-ci-engineer"],
+  \u8A55\u4FA1\u30B9\u30B3\u30A2\u30EA\u30F3\u30B0: ["product-surface-reviewer", "product-experience-architect"],
+  \u30D3\u30EB\u30C9: ["devops-ci-engineer", "backend-engineer"]
+};
+var DELEGATION_CATEGORIES = Object.keys(DELEGATION_SCOPE);
+function validateDelegationMapIssues(delegationMap, prototypingJsonPath) {
+  if (!delegationMap) {
+    return [];
+  }
+  const issues = [];
+  for (const [category, rawRole] of Object.entries(delegationMap)) {
+    const allowedRoles = DELEGATION_SCOPE[category];
+    if (allowedRoles === void 0) {
+      continue;
+    }
+    if (typeof rawRole !== "string") {
+      issues.push(
+        issue(
+          "QFAI-PROT-311",
+          `Delegation violation: category "${category}" assigned to non-string value (got: ${describeRoleType(rawRole)}). Allowed roles: ${allowedRoles.join(", ")}.`,
+          "error",
+          prototypingJsonPath,
+          "prototyping.executionPlan.delegationMap",
+          void 0,
+          "canonical",
+          `category "${category}" \u306B\u306F string \u306E role \u3092\u5272\u308A\u5F53\u3066\u3066\u304F\u3060\u3055\u3044 (allowed: ${allowedRoles.join(", ")})\u3002`
+        )
+      );
+      continue;
+    }
+    if (!allowedRoles.includes(rawRole)) {
+      issues.push(
+        issue(
+          "QFAI-PROT-311",
+          `Delegation violation: category "${category}" assigned to undefined/invalid role "${rawRole}". Allowed roles: ${allowedRoles.join(", ")}.`,
+          "error",
+          prototypingJsonPath,
+          "prototyping.executionPlan.delegationMap",
+          void 0,
+          "canonical",
+          `category "${category}" \u3092\u8A31\u53EF\u3055\u308C\u305F role \u306B\u5272\u308A\u5F53\u3066\u3066\u304F\u3060\u3055\u3044 (allowed: ${allowedRoles.join(", ")})\u3002`
+        )
+      );
+    }
+  }
+  return issues;
+}
+function describeRoleType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+
+// src/core/validators/prototyping/screenshotDir.ts
+init_utils();
+function isRecord9(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function validateScreenshotDirIssues(scoringTrace, mode, prototypingJsonPath) {
+  if (mode !== "full-harness") {
+    return [];
+  }
+  const issues = [];
+  const suggestion = "full-harness \u30E2\u30FC\u30C9\u3067\u306F scoringTrace \u306E\u5404 entry \u306B screenshotDir \u3092\u8A18\u9332\u3057\u3066\u304F\u3060\u3055\u3044\u3002";
+  for (let i = 0; i < scoringTrace.length; i++) {
+    const entry = scoringTrace[i];
+    if (!isRecord9(entry)) {
+      issues.push(
+        issue(
+          "QFAI-PROT-331",
+          `scoringTrace[${i}] is not an object; screenshotDir cannot be verified.`,
+          "error",
+          prototypingJsonPath,
+          "prototyping.fullHarness.scoringTrace.screenshotDir",
+          void 0,
+          "canonical",
+          suggestion
+        )
+      );
+      continue;
+    }
+    if (typeof entry.screenshotDir !== "string" || entry.screenshotDir.trim() === "") {
+      issues.push(
+        issue(
+          "QFAI-PROT-331",
+          `scoringTrace[${i}].screenshotDir is missing or empty; full-harness requires screenshot evidence per iteration.`,
+          "error",
+          prototypingJsonPath,
+          "prototyping.fullHarness.scoringTrace.screenshotDir",
+          void 0,
+          "canonical",
+          suggestion
+        )
+      );
+    }
+  }
+  return issues;
+}
+
+// src/core/validators/prototyping/lighthouseGate.ts
+init_utils();
+function isRecord10(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function detectMode4(raw) {
+  if (!isRecord10(raw)) return "other";
+  if (typeof raw.mode === "string") return raw.mode;
+  if (isRecord10(raw.mode) && typeof raw.mode.effective === "string") {
+    return raw.mode.effective;
+  }
+  return "other";
+}
+function detectSurface(raw) {
+  if (!isRecord10(raw)) return "unknown";
+  if (typeof raw.surface === "string") return raw.surface;
+  return "unknown";
+}
+function hasLighthouseReport(raw) {
+  if (!isRecord10(raw)) return false;
+  const report = raw.lighthouseReport ?? raw.lighthouse;
+  if (!report) return false;
+  if (isRecord10(report)) return Object.keys(report).length > 0;
+  if (typeof report === "string") return report.trim().length > 0;
+  return false;
+}
+function validateLighthouseGateIssues(prototypingJson, prototypingJsonPath) {
+  const mode = detectMode4(prototypingJson);
+  const surface = detectSurface(prototypingJson);
+  if (mode !== "full-harness" || surface !== "web") {
+    return [];
+  }
+  if (hasLighthouseReport(prototypingJson)) {
+    return [];
+  }
+  return [
+    issue(
+      "QFAI-PROT-332",
+      "Lighthouse Gate is MUST for full-harness + web surface: no Lighthouse report found in prototyping evidence.",
+      "error",
+      prototypingJsonPath,
+      "prototyping.lighthouseReport",
+      void 0,
+      "canonical",
+      "full-harness + web surface \u3067\u306F `prototyping.json.lighthouseReport` (\u307E\u305F\u306F `lighthouse`) \u3092\u8A18\u9332\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    )
+  ];
+}
+
+// src/core/validators/prototyping/iterationGate.ts
+init_utils();
+function validateIterationGateIssues(iterations, prototypingJsonPath) {
+  if (iterations.length === 0) {
+    return [];
+  }
+  for (const entry of iterations) {
+    if (entry.iterationCount === 1 && entry.converged === true) {
+      return [
+        issue(
+          "QFAI-PROT-333",
+          "minimum 2 iterations required before convergence: iteration 1 cannot be marked converged.",
+          "error",
+          prototypingJsonPath,
+          "prototyping.fullHarness.iterations.convergence",
+          void 0,
+          "canonical",
+          "iteration 1 \u3067 converged=true \u306F\u8A31\u5BB9\u3055\u308C\u307E\u305B\u3093\u3002\u5C11\u306A\u304F\u3068\u3082 2 iteration \u4EE5\u4E0A \u8D70\u3089\u305B\u3066\u304F\u3060\u3055\u3044\u3002"
+        )
+      ];
+    }
+  }
+  return [];
+}
+
+// src/core/validators/prototyping/designSystemThreshold.ts
+init_utils();
+import { access as access10 } from "fs/promises";
+import path37 from "path";
+var DS_PASS_THRESHOLD = 0.75;
+function isRecord11(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+async function designSystemMdPresent(packDir) {
+  try {
+    await access10(path37.join(packDir, "uiux", "12_design_system.md"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function extractScore(prototypingRecord) {
+  if (!isRecord11(prototypingRecord)) return null;
+  const trace = prototypingRecord.scoringTrace;
+  if (!isRecord11(trace)) return null;
+  const score = trace.designSystemCompliance;
+  if (typeof score !== "number") return null;
+  return score;
+}
+async function validateDesignSystemThresholdIssues(packDir, prototypingRecord, prototypingJsonPath) {
+  const hasDesignSystem = await designSystemMdPresent(packDir);
+  if (!hasDesignSystem) {
+    return [];
+  }
+  const score = extractScore(prototypingRecord);
+  if (score === null) {
+    return [];
+  }
+  if (score >= DS_PASS_THRESHOLD) {
+    return [];
+  }
+  return [
+    issue(
+      "QFAI-PROT-334",
+      `designSystemCompliance score ${(score * 100).toFixed(0)}% is below threshold ${(DS_PASS_THRESHOLD * 100).toFixed(0)}%; immediate fix required for next iteration.`,
+      "error",
+      prototypingJsonPath,
+      "prototyping.scoringTrace.designSystemCompliance.threshold",
+      void 0,
+      "canonical",
+      `scoringTrace.designSystemCompliance \u3092\u95BE\u5024 ${(DS_PASS_THRESHOLD * 100).toFixed(0)}% \u4EE5\u4E0A\u306B\u4E0A\u3052\u308B\u4FEE\u6B63\u3092\u6B21\u30A4\u30C6\u30EC\u30FC\u30B7\u30E7\u30F3\u306B\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002`
+    )
+  ];
+}
+
+// src/core/validators/prototyping/stateGate.ts
+import { readFile as readFile26 } from "fs/promises";
+import path38 from "path";
+function isRecord12(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractDelegationMap(prototypingJson) {
+  if (!isRecord12(prototypingJson)) return void 0;
+  const executionPlan = prototypingJson.executionPlan;
+  if (!isRecord12(executionPlan)) return void 0;
+  const delegationMap = executionPlan.delegationMap;
+  if (!isRecord12(delegationMap)) return void 0;
+  return delegationMap;
+}
+function extractMode(prototypingJson) {
+  if (!isRecord12(prototypingJson)) return "other";
+  if (typeof prototypingJson.mode === "string") return prototypingJson.mode;
+  if (isRecord12(prototypingJson.mode) && typeof prototypingJson.mode.effective === "string") {
+    return prototypingJson.mode.effective;
+  }
+  return "other";
+}
+function extractScoringTrace(prototypingJson) {
+  if (!isRecord12(prototypingJson)) return [];
+  const fullHarness = prototypingJson.fullHarness;
+  if (!isRecord12(fullHarness)) return [];
+  const trace = fullHarness.scoringTrace;
+  return Array.isArray(trace) ? trace : [];
+}
+function extractFullHarnessIterations(prototypingJson) {
+  if (!isRecord12(prototypingJson)) return [];
+  const fullHarness = prototypingJson.fullHarness;
+  if (!isRecord12(fullHarness)) return [];
+  const iterations = fullHarness.iterations;
+  if (!Array.isArray(iterations)) return [];
+  return iterations.filter(
+    (entry) => isRecord12(entry) && typeof entry.iterationCount === "number"
+  );
+}
+function resolveCalibrationPackDir(root, config) {
+  const packPath = config.prototyping?.calibration?.packPath;
+  if (!packPath || typeof packPath !== "string") return void 0;
+  return path38.resolve(root, packPath);
+}
+async function validateStateGate(root, config) {
+  const evidenceRoot = path38.join(
+    path38.dirname(path38.resolve(root, config.paths.specsDir)),
+    "evidence"
+  );
+  const prototypingJsonPath = path38.join(evidenceRoot, "prototyping.json");
+  let raw;
+  try {
+    raw = await readFile26(prototypingJsonPath, "utf-8");
+  } catch {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  const relPath = path38.relative(root, prototypingJsonPath).replace(/\\/g, "/");
+  const mode = extractMode(parsed);
+  const issues = [];
+  issues.push(...validateExecutionPlanIssues(parsed, relPath));
+  issues.push(...validateDelegationMapIssues(extractDelegationMap(parsed), relPath));
+  issues.push(...validateScreenshotDirIssues(extractScoringTrace(parsed), mode, relPath));
+  issues.push(...validateIterationGateIssues(extractFullHarnessIterations(parsed), relPath));
+  issues.push(...validateLighthouseGateIssues(parsed, relPath));
+  const packDir = resolveCalibrationPackDir(root, config);
+  if (packDir) {
+    issues.push(...await validateDesignSystemThresholdIssues(packDir, parsed, relPath));
+  }
+  return issues;
+}
+
+// src/core/validators/prototyping/completionCertificate.ts
+import { readFile as readFile28 } from "fs/promises";
+import path40 from "path";
+
+// src/core/prototyping/certificate.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir4, readFile as readFile27, readdir as readdir8, stat as stat5, writeFile as writeFile4 } from "fs/promises";
+import path39 from "path";
+var COMPLETION_CERTIFICATE_REL_PATH = ".qfai/evidence/prototyping/completion-certificate.json";
+async function loadCompletionCertificate(root) {
+  const fullPath = path39.join(root, COMPLETION_CERTIFICATE_REL_PATH);
+  try {
+    const raw = await readFile27(fullPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!isMinimallyValidCertificate(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function isMinimallyValidCertificate(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const v = value;
+  if (v.schemaVersion !== "1.0") return false;
+  if (typeof v.runId !== "string") return false;
+  if (!Array.isArray(v.evidenceDigests)) return false;
+  for (const entry of v.evidenceDigests) {
+    if (!entry || typeof entry !== "object") return false;
+    const e = entry;
+    if (typeof e.path !== "string" || typeof e.sha256 !== "string") return false;
+  }
+  if (!v.validateRun || typeof v.validateRun !== "object") return false;
+  if (!v.verifyRun || typeof v.verifyRun !== "object") return false;
+  if (!v.reviewerSignoff || typeof v.reviewerSignoff !== "object") return false;
+  return true;
+}
+async function checkCompletionCertificate(root) {
+  const cert = await loadCompletionCertificate(root);
+  if (!cert) {
+    return {
+      ok: false,
+      reasons: [
+        `${COMPLETION_CERTIFICATE_REL_PATH} not found. Run \`qfai prototyping certify\` after all gates pass.`
+      ]
+    };
+  }
+  const reasons = [];
+  const evidenceRoot = path39.join(root, ".qfai/evidence/prototyping");
+  const currentDigests = await scanEvidenceDigests(evidenceRoot);
+  const certMap = new Map(cert.evidenceDigests.map((entry) => [entry.path, entry.sha256]));
+  const currMap = new Map(currentDigests.map((entry) => [entry.path, entry.sha256]));
+  for (const [p, hash] of certMap) {
+    const observed = currMap.get(p);
+    if (observed === void 0) {
+      reasons.push(`evidence file removed since certify: ${p}`);
+    } else if (observed !== hash) {
+      reasons.push(`digest mismatch (file modified since certify): ${p}`);
+    }
+  }
+  for (const [p] of currMap) {
+    if (!certMap.has(p)) {
+      reasons.push(`new evidence file present but not in certificate: ${p}`);
+    }
+  }
+  if (cert.validateRun.errorCount !== 0) {
+    reasons.push("validateRun.errorCount must be 0");
+  }
+  if (cert.verifyRun.status !== "PASS") {
+    reasons.push("verifyRun.status must be PASS");
+  }
+  if (!cert.reviewerSignoff.approved) {
+    reasons.push("reviewerSignoff.approved must be true");
+  }
+  return reasons.length === 0 ? { ok: true } : { ok: false, reasons };
+}
+async function scanEvidenceDigests(evidenceRoot) {
+  const out = [];
+  await walk2(evidenceRoot, evidenceRoot, out);
+  out.sort((a, b) => a.path.localeCompare(b.path));
+  return out;
+}
+async function walk2(rootDir, dir, out) {
+  let entries;
+  try {
+    entries = await readdir8(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    if (name === "completion-certificate.json") continue;
+    const full = path39.join(dir, name);
+    let s;
+    try {
+      s = await stat5(full);
+    } catch {
+      continue;
+    }
+    if (s.isDirectory()) {
+      await walk2(rootDir, full, out);
+    } else if (s.isFile()) {
+      const buf = await readFile27(full);
+      const hash = createHash("sha256").update(buf).digest("hex");
+      const rel = path39.relative(rootDir, full).replace(/\\/g, "/");
+      out.push({ path: rel, sha256: hash });
+    }
+  }
+}
+
+// src/core/validators/prototyping/completionCertificate.ts
+init_utils();
+var CERT_REL_PATH = ".qfai/evidence/prototyping/completion-certificate.json";
+function isRecord13(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function isCompletionClaimed(root, config) {
+  const evidenceRoot = path40.join(
+    path40.dirname(path40.resolve(root, config.paths.specsDir)),
+    "evidence"
+  );
+  let raw;
+  try {
+    raw = await readFile28(path40.join(evidenceRoot, "prototyping.json"), "utf-8");
+  } catch {
+    return false;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return false;
+  }
+  if (!isRecord13(parsed)) return false;
+  if (parsed.completionClaimed === true) return true;
+  if (parsed.phase === "completed") return true;
+  if (isRecord13(parsed.completionCertificate)) return true;
+  return false;
+}
+async function validateCompletionCertificateIssues(root, config) {
+  const certificate = await loadCompletionCertificate(root);
+  const claimed = await isCompletionClaimed(root, config);
+  if (!certificate) {
+    if (claimed) {
+      return [
+        issue(
+          "QFAI-PROT-335",
+          `${CERT_REL_PATH} is required when completion is claimed. Run \`qfai prototyping certify\` after all gates pass.`,
+          "error",
+          CERT_REL_PATH,
+          "prototyping.completionCertificate.presence",
+          void 0,
+          "canonical",
+          "completion \u4E3B\u5F35\u306E\u524D\u306B `qfai prototyping certify` \u3092\u6210\u529F\u3055\u305B\u3066\u304F\u3060\u3055\u3044\u3002"
+        )
+      ];
+    }
+    return [];
+  }
+  if (!claimed) return [];
+  const result = await checkCompletionCertificate(root);
+  if (result.ok) return [];
+  return [
+    issue(
+      "QFAI-PROT-336",
+      `${CERT_REL_PATH} digest mismatch \u2014 evidence has been modified since certify: ${result.reasons.join("; ")}`,
+      "error",
+      CERT_REL_PATH,
+      "prototyping.completionCertificate.digest",
+      void 0,
+      "canonical",
+      "evidence \u3092\u5909\u66F4\u3057\u305F\u5834\u5408\u306F `qfai prototyping certify` \u3092\u518D\u5B9F\u884C\u3057\u3066 certificate \u3092\u66F4\u65B0\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    )
+  ];
+}
+
+// src/core/validators/configReferenceIntegrity.ts
+init_utils();
+import { stat as stat6 } from "fs/promises";
+import path41 from "path";
+async function isDirectory(absolutePath) {
+  try {
+    const s = await stat6(absolutePath);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function pathExists(absolutePath) {
+  try {
+    await stat6(absolutePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var VERIFIED_PATH_KEYS = [
+  "specsDir",
+  "contractsDir",
+  "discussionDir",
+  "skillsDir",
+  "srcDir",
+  "testsDir"
+];
+async function validateConfigReferenceIntegrity(root, config) {
+  const issues = [];
+  const primarySpecId = config.prototyping?.primarySpecId;
+  if (primarySpecId !== void 0) {
+    const specDir = path41.join(path41.resolve(root, config.paths.specsDir), `spec-${primarySpecId}`);
+    if (!await isDirectory(specDir)) {
+      const relSpecDir = path41.relative(root, specDir).replace(/\\/g, "/");
+      issues.push(
+        issue(
+          "QFAI-CFG-LINK-001",
+          `qfai.config.yaml: prototyping.primarySpecId="${primarySpecId}" but ${relSpecDir} does not exist.`,
+          "error",
+          "qfai.config.yaml",
+          "config.prototyping.primarySpecId.reality",
+          void 0,
+          "canonical",
+          "prototyping.primarySpecId \u3092\u5B9F\u5728\u3059\u308B spec-NNNN \u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306B\u5408\u308F\u305B\u308B\u304B\u3001\u5BFE\u5FDC\u3059\u308B spec \u3092 `.qfai/specs/spec-NNNN/` \u306B\u4F5C\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+        )
+      );
+    }
+  }
+  for (const key of VERIFIED_PATH_KEYS) {
+    const relPath = config.paths[key];
+    const absolutePath = path41.resolve(root, relPath);
+    if (!await isDirectory(absolutePath)) {
+      issues.push(
+        issue(
+          "QFAI-CFG-LINK-002",
+          `qfai.config.yaml: paths.${key}="${relPath}" but the directory does not exist.`,
+          "warning",
+          "qfai.config.yaml",
+          `config.paths.${key}.reality`,
+          void 0,
+          "canonical",
+          `paths.${key} \u3092\u5B9F\u5728\u3059\u308B\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306B\u5408\u308F\u305B\u308B\u304B\u3001\u5BFE\u5FDC\u3059\u308B\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3092\u4F5C\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+        )
+      );
+    }
+  }
+  const packPath = config.prototyping?.calibration?.packPath;
+  if (packPath !== void 0) {
+    const absolutePackPath = path41.resolve(root, packPath);
+    const exists9 = await pathExists(absolutePackPath);
+    if (!exists9) {
+      issues.push(
+        issue(
+          "QFAI-CFG-LINK-003",
+          `qfai.config.yaml: prototyping.calibration.packPath="${packPath}" but the path does not exist on disk.`,
+          "error",
+          "qfai.config.yaml",
+          "config.prototyping.calibration.packPath.reality",
+          void 0,
+          "canonical",
+          "prototyping.calibration.packPath \u3092\u5B9F\u5728\u3059\u308B calibration pack (YAML \u30D5\u30A1\u30A4\u30EB \u307E\u305F\u306F \u30C7\u30A3\u30EC\u30AF\u30C8\u30EA) \u306B\u5408\u308F\u305B\u3066\u304F\u3060\u3055\u3044\u3002"
+        )
+      );
+    }
+  }
+  return issues;
+}
+
+// src/core/validators/prototyping/refIntegrity.ts
+import { readFile as readFile29, stat as stat7 } from "fs/promises";
+import path42 from "path";
+init_utils();
+function isRecord14(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function fileExists3(absolutePath) {
+  try {
+    const s = await stat7(absolutePath);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+async function loadJson(absolutePath) {
+  try {
+    const raw = await readFile29(absolutePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function collectPrototypingJsonRefs(prototypingJson, sourcePath) {
+  const out = [];
+  if (!isRecord14(prototypingJson)) return out;
+  const push = (ref, field) => {
+    if (typeof ref === "string" && ref.length > 0) {
+      out.push({ ref, source: sourcePath, field });
+    }
+  };
+  const rounds = prototypingJson.rounds;
+  if (Array.isArray(rounds)) {
+    for (let i = 0; i < rounds.length; i++) {
+      const round = rounds[i];
+      if (!isRecord14(round)) continue;
+      push(round.harvestRef, `rounds[${i}].harvestRef`);
+      push(round.narrowDecisionRef, `rounds[${i}].narrowDecisionRef`);
+      push(round.absorptionPlanRef, `rounds[${i}].absorptionPlanRef`);
+      push(round.reimplementationRef, `rounds[${i}].reimplementationRef`);
+      const evalMap = round.evaluatorReviewRefsByCandidate;
+      if (isRecord14(evalMap)) {
+        for (const [cid, ref] of Object.entries(evalMap)) {
+          push(ref, `rounds[${i}].evaluatorReviewRefsByCandidate.${cid}`);
+        }
+      }
+      const screenMap = round.screenEvidenceByCandidate;
+      if (isRecord14(screenMap)) {
+        for (const [cid, candidateScreens] of Object.entries(screenMap)) {
+          if (!isRecord14(candidateScreens)) continue;
+          for (const [screenId, refs] of Object.entries(candidateScreens)) {
+            if (!isRecord14(refs)) continue;
+            push(
+              refs.screenshotRef,
+              `rounds[${i}].screenEvidenceByCandidate.${cid}.${screenId}.screenshotRef`
+            );
+            push(refs.htmlRef, `rounds[${i}].screenEvidenceByCandidate.${cid}.${screenId}.htmlRef`);
+            push(
+              refs.snapshotRef,
+              `rounds[${i}].screenEvidenceByCandidate.${cid}.${screenId}.snapshotRef`
+            );
+            push(
+              refs.commandLogRef,
+              `rounds[${i}].screenEvidenceByCandidate.${cid}.${screenId}.commandLogRef`
+            );
+          }
+        }
+      }
+    }
+  }
+  const polishCycles = prototypingJson.polishCycles;
+  if (Array.isArray(polishCycles)) {
+    for (let i = 0; i < polishCycles.length; i++) {
+      const cycle = polishCycles[i];
+      if (!isRecord14(cycle)) continue;
+      push(cycle.breakthroughRef, `polishCycles[${i}].breakthroughRef`);
+      push(cycle.reviewerGateRef, `polishCycles[${i}].reviewerGateRef`);
+      push(cycle.evaluatorReviewRef, `polishCycles[${i}].evaluatorReviewRef`);
+    }
+  }
+  const bestOfHistory = prototypingJson.bestOfHistory;
+  if (isRecord14(bestOfHistory)) {
+    push(bestOfHistory.evidenceRef, "bestOfHistory.evidenceRef");
+  }
+  const breakthrough = prototypingJson.breakthrough;
+  if (isRecord14(breakthrough)) {
+    push(breakthrough.evidenceRef, "breakthrough.evidenceRef");
+  }
+  const reviewerGate = prototypingJson.reviewerGate;
+  if (isRecord14(reviewerGate)) {
+    push(reviewerGate.evidenceRef, "reviewerGate.evidenceRef");
+    const signoff = reviewerGate.signoff;
+    if (isRecord14(signoff)) {
+      push(signoff.evidenceRef, "reviewerGate.signoff.evidenceRef");
+    }
+  }
+  const fullHarness = prototypingJson.fullHarness;
+  if (isRecord14(fullHarness) && Array.isArray(fullHarness.iterations)) {
+    const iterations = fullHarness.iterations;
+    for (let i = 0; i < iterations.length; i++) {
+      const it = iterations[i];
+      if (!isRecord14(it)) continue;
+      const er = it.evidenceRefs;
+      if (!isRecord14(er)) continue;
+      for (const [key, refs] of Object.entries(er)) {
+        if (!Array.isArray(refs)) continue;
+        for (let j = 0; j < refs.length; j++) {
+          const refValue = refs[j];
+          push(refValue, `fullHarness.iterations[${i}].evidenceRefs.${key}[${j}]`);
+        }
+      }
+    }
+  }
+  return out;
+}
+function collectReviewBundleRefs(bundle, sourcePath) {
+  const out = [];
+  if (!isRecord14(bundle)) return out;
+  const push = (ref, field) => {
+    if (typeof ref === "string" && ref.length > 0) {
+      out.push({ ref, source: sourcePath, field });
+    }
+  };
+  push(bundle.axisDefsRef, "axisDefsRef");
+  push(bundle.designSystemChecklistRef, "designSystemChecklistRef");
+  push(bundle.commandPlanRef, "commandPlanRef");
+  const candidates = bundle.candidates;
+  if (Array.isArray(candidates)) {
+    for (let i = 0; i < candidates.length; i++) {
+      const candidate = candidates[i];
+      if (!isRecord14(candidate)) continue;
+      push(candidate.conceptRef, `candidates[${i}].conceptRef`);
+      push(candidate.previousEvaluatorReviewRef, `candidates[${i}].previousEvaluatorReviewRef`);
+    }
+  }
+  return out;
+}
+function collectBreakthroughRefs(breakthroughJson, sourcePath) {
+  const out = [];
+  if (!isRecord14(breakthroughJson)) return out;
+  const branchRefs = breakthroughJson.branchRefs;
+  if (Array.isArray(branchRefs)) {
+    for (let i = 0; i < branchRefs.length; i++) {
+      const ref = branchRefs[i];
+      if (typeof ref === "string" && ref.length > 0) {
+        out.push({ ref, source: sourcePath, field: `branchRefs[${i}]` });
+      }
+    }
+  }
+  return out;
+}
+async function validatePrototypingArtifactRefIntegrity(root, config) {
+  const issues = [];
+  const evidenceRoot = path42.join(path42.dirname(resolvePath(root, config, "specsDir")), "evidence");
+  const collectedRefs = [];
+  const protoPath = path42.join(evidenceRoot, "prototyping.json");
+  const protoJson = await loadJson(protoPath);
+  if (protoJson) {
+    const protoRel = path42.relative(root, protoPath).replace(/\\/g, "/");
+    collectedRefs.push(...collectPrototypingJsonRefs(protoJson, protoRel));
+  }
+  for (const round of EXPLORATION_ROUNDS) {
+    const bundlePath = path42.join(
+      evidenceRoot,
+      "prototyping",
+      "rounds",
+      round,
+      "review-bundle.json"
+    );
+    const bundleJson = await loadJson(bundlePath);
+    if (bundleJson) {
+      const bundleRel = path42.relative(root, bundlePath).replace(/\\/g, "/");
+      collectedRefs.push(...collectReviewBundleRefs(bundleJson, bundleRel));
+    }
+  }
+  const breakthroughPath = path42.join(evidenceRoot, "prototyping", "breakthrough.json");
+  const breakthroughJson = await loadJson(breakthroughPath);
+  if (breakthroughJson) {
+    const breakthroughRel = path42.relative(root, breakthroughPath).replace(/\\/g, "/");
+    collectedRefs.push(...collectBreakthroughRefs(breakthroughJson, breakthroughRel));
+  }
+  for (const ref of collectedRefs) {
+    const candidatePath = path42.isAbsolute(ref.ref) ? ref.ref : path42.join(root, ref.ref);
+    if (!await fileExists3(candidatePath)) {
+      issues.push(
+        issue(
+          "QFAI-PROT-REF-001",
+          `${ref.source}: ${ref.field}="${ref.ref}" points to a file that does not exist on disk.`,
+          "warning",
+          ref.source,
+          "prototyping.artifactRef.reality",
+          void 0,
+          "canonical",
+          "ref \u3092\u5B9F\u5728\u3059\u308B\u30D5\u30A1\u30A4\u30EB\u306B\u5408\u308F\u305B\u308B\u304B\u3001\u6B20\u843D artifact \u3092\u751F\u6210\u3057\u3066\u304F\u3060\u3055\u3044 (round-* / verify CLI \u3092\u518D\u5B9F\u884C)\u3002"
+        )
+      );
+    }
+  }
+  return issues;
+}
+
+// src/core/validators/prototyping/specIdLinkage.ts
+import { readFile as readFile30, stat as stat8 } from "fs/promises";
+import path43 from "path";
+init_utils();
+function isRecord15(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function isDirectory2(absolutePath) {
+  try {
+    const s = await stat8(absolutePath);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function loadJson2(absolutePath) {
+  try {
+    const raw = await readFile30(absolutePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
 }
-async function validatePrototypingDesignSystem(root, config) {
-  const screens = await readUiContractScreenContracts(root, config.paths.contractsDir);
-  if (screens.length === 0) {
-    return [];
+function normalizeSpecId(raw) {
+  if (typeof raw !== "string") return void 0;
+  const trimmed = raw.trim();
+  const direct = /^(\d{4})$/.exec(trimmed);
+  if (direct?.[1]) return direct[1];
+  const prefixed = /^spec-(\d{4})$/i.exec(trimmed);
+  if (prefixed?.[1]) return prefixed[1];
+  return void 0;
+}
+async function validateSpecIdLinkage(root, config) {
+  const issues = [];
+  const specsRoot = resolvePath(root, config, "specsDir");
+  const evidenceRoot = path43.join(path43.dirname(specsRoot), "evidence");
+  const specEntries = await collectSpecEntries(specsRoot);
+  const knownSpecIds = new Set(specEntries.map((e) => e.specNumber));
+  const protoPath = path43.join(evidenceRoot, "prototyping.json");
+  const protoJson = await loadJson2(protoPath);
+  if (isRecord15(protoJson)) {
+    const protoRel = path43.relative(root, protoPath).replace(/\\/g, "/");
+    const specs = protoJson.specs;
+    if (Array.isArray(specs)) {
+      for (let i = 0; i < specs.length; i++) {
+        const entry = specs[i];
+        if (!isRecord15(entry)) continue;
+        const rawSpecId = entry.specId;
+        if (rawSpecId === void 0) continue;
+        const id = normalizeSpecId(rawSpecId);
+        if (id === void 0) {
+          issues.push(
+            issue(
+              "QFAI-PROT-LINK-001",
+              `${protoRel}: specs[${i}].specId="${JSON.stringify(rawSpecId)}" is malformed (expected 4-digit "NNNN" or "spec-NNNN").`,
+              "warning",
+              protoRel,
+              "prototyping.specs.idReality",
+              void 0,
+              "canonical",
+              'specs[].specId \u306F 4 \u6841\u306E "NNNN" \u5F62\u5F0F\u307E\u305F\u306F "spec-NNNN" \u5F62\u5F0F\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002'
+            )
+          );
+          continue;
+        }
+        if (!knownSpecIds.has(id)) {
+          issues.push(
+            issue(
+              "QFAI-PROT-LINK-001",
+              `${protoRel}: specs[${i}].specId="${JSON.stringify(rawSpecId)}" but spec-${id} does not exist under ${path43.relative(root, specsRoot).replace(/\\/g, "/")}/.`,
+              "warning",
+              protoRel,
+              "prototyping.specs.idReality",
+              void 0,
+              "canonical",
+              "\u5BFE\u5FDC\u3059\u308B spec-NNNN \u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3092\u4F5C\u6210\u3059\u308B\u304B\u3001specs[].specId \u5024\u3092\u5B9F\u5728\u306E spec \u306B\u5408\u308F\u305B\u3066\u304F\u3060\u3055\u3044\u3002"
+            )
+          );
+        }
+      }
+    }
+    const rounds = protoJson.rounds;
+    if (Array.isArray(rounds)) {
+      for (let i = 0; i < rounds.length; i++) {
+        const round = rounds[i];
+        if (!isRecord15(round)) continue;
+        const roundName = round.round;
+        const candidates = round.candidates;
+        if (typeof roundName !== "string" || !Array.isArray(candidates)) continue;
+        for (let j = 0; j < candidates.length; j++) {
+          const candidate = candidates[j];
+          if (!isRecord15(candidate)) continue;
+          const candidateId = candidate.candidateId;
+          if (typeof candidateId !== "string") continue;
+          const candidateDir = path43.join(
+            evidenceRoot,
+            "prototyping",
+            "rounds",
+            roundName,
+            "candidates",
+            candidateId
+          );
+          if (!await isDirectory2(candidateDir)) {
+            const relCandidateDir = path43.relative(root, candidateDir).replace(/\\/g, "/");
+            issues.push(
+              issue(
+                "QFAI-PROT-LINK-003",
+                `${protoRel}: rounds[${i}].candidates[${j}].candidateId="${candidateId}" but ${relCandidateDir} does not exist.`,
+                "warning",
+                protoRel,
+                "prototyping.candidates.dirReality",
+                void 0,
+                "canonical",
+                "candidateId \u306B\u5BFE\u5FDC\u3059\u308B artifact \u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3092 `qfai prototyping round-start` \u3067\u751F\u6210\u3059\u308B\u304B\u3001\u7121\u52B9\u306A candidate \u3092 index \u304B\u3089\u524A\u9664\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+              )
+            );
+          }
+        }
+      }
+    }
+    const polishCycles = protoJson.polishCycles;
+    if (Array.isArray(polishCycles)) {
+      for (let i = 0; i < polishCycles.length; i++) {
+        const cycle = polishCycles[i];
+        if (!isRecord15(cycle)) continue;
+        const cycleNum = cycle.cycle;
+        if (typeof cycleNum !== "number" || cycleNum < 1) continue;
+        const iterationDir = path43.join(evidenceRoot, "prototyping", "iterations", String(cycleNum));
+        if (!await isDirectory2(iterationDir)) {
+          const relIterationDir = path43.relative(root, iterationDir).replace(/\\/g, "/");
+          issues.push(
+            issue(
+              "QFAI-PROT-LINK-004",
+              `${protoRel}: polishCycles[${i}].cycle=${cycleNum} but ${relIterationDir} does not exist.`,
+              "warning",
+              protoRel,
+              "prototyping.polishCycles.iterationDirReality",
+              void 0,
+              "canonical",
+              "polish cycle \u306B\u5BFE\u5FDC\u3059\u308B iteration \u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3092\u518D\u751F\u6210\u3059\u308B\u304B\u3001\u7121\u52B9\u306A polish cycle \u3092 index \u304B\u3089\u524A\u9664\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+            )
+          );
+        }
+      }
+    }
   }
-  const evidenceDir = resolveEvidenceRoot(root, config);
-  const artifact = await loadPrototypingArtifact(evidenceDir);
-  if (artifact.designSystemCompliancePresent) {
-    return [];
+  for (const round of EXPLORATION_ROUNDS) {
+    const bundlePath = path43.join(root, ...roundReviewBundlePath(round).split("/"));
+    const bundleJson = await loadJson2(bundlePath);
+    if (!isRecord15(bundleJson)) continue;
+    const id = normalizeSpecId(bundleJson.spec);
+    if (id !== void 0 && !knownSpecIds.has(id)) {
+      const bundleRel = path43.relative(root, bundlePath).replace(/\\/g, "/");
+      issues.push(
+        issue(
+          "QFAI-PROT-LINK-002",
+          `${bundleRel}: spec="${String(bundleJson.spec)}" but spec-${id} does not exist under ${path43.relative(root, specsRoot).replace(/\\/g, "/")}/.`,
+          "error",
+          bundleRel,
+          "prototyping.reviewBundle.specReality",
+          void 0,
+          "canonical",
+          "review-bundle.json \u306E spec \u3092 `qfai prototyping show-spec` \u306E\u7D50\u679C\u306B\u5408\u308F\u305B\u3066\u518D\u751F\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+        )
+      );
+    }
   }
-  const designSystemPath = path36.join(
-    root,
-    config.paths.contractsDir,
-    "design",
-    "design-system.yaml"
-  );
-  const designSystemPresent = await fileExists2(designSystemPath);
-  const severity = designSystemPresent && artifact.mode === "full-harness" ? "error" : "warning";
-  return [toIssue(severity, artifact.fileName)];
+  return issues;
 }
 
 // src/core/validators/requireIndex.ts
-import { readFile as readFile26 } from "fs/promises";
-import path37 from "path";
+import { readFile as readFile31 } from "fs/promises";
+import path44 from "path";
 init_utils();
 
 // src/core/validators/repositoryHygiene.ts
-import { readdir as readdir8, stat as stat5 } from "fs/promises";
-import path38 from "path";
+import { readdir as readdir9, stat as stat9 } from "fs/promises";
+import path45 from "path";
 init_utils();
 var LEGACY_DIR_RULES = [
   { legacy: "discussions", canonical: "discussion" },
@@ -10487,12 +12195,12 @@ var LEGACY_DIR_RULES = [
 ];
 var SUSPICIOUS_TEMPLATE_NAME_RE = /^(?:_?templates?|_?sample(?:s)?|sample-template)$/i;
 async function validateRepositoryHygiene(root, config) {
-  const qfaiRoot = path38.join(root, ".qfai");
+  const qfaiRoot = path45.join(root, ".qfai");
   const specsRoot = resolvePath(root, config, "specsDir");
   const issues = [];
   for (const rule of LEGACY_DIR_RULES) {
-    const legacyPath = path38.join(qfaiRoot, rule.legacy);
-    if (!await isDirectory(legacyPath)) {
+    const legacyPath = path45.join(qfaiRoot, rule.legacy);
+    if (!await isDirectory3(legacyPath)) {
       continue;
     }
     issues.push(
@@ -10526,7 +12234,7 @@ async function validateRepositoryHygiene(root, config) {
   return issues;
 }
 async function collectSuspiciousTemplatePaths(root) {
-  if (!await isDirectory(root)) {
+  if (!await isDirectory3(root)) {
     return [];
   }
   const matches = [];
@@ -10538,7 +12246,7 @@ async function collectSuspiciousTemplatePaths(root) {
     }
     let entries = [];
     try {
-      entries = await readdir8(current, {
+      entries = await readdir9(current, {
         withFileTypes: true,
         encoding: "utf8"
       });
@@ -10546,10 +12254,10 @@ async function collectSuspiciousTemplatePaths(root) {
       continue;
     }
     for (const entry of entries) {
-      const absolute = path38.join(current, entry.name);
+      const absolute = path45.join(current, entry.name);
       if (entry.isDirectory()) {
         if (SUSPICIOUS_TEMPLATE_NAME_RE.test(entry.name)) {
-          matches.push(toPosix(path38.relative(root, absolute)));
+          matches.push(toPosix(path45.relative(root, absolute)));
         }
         queue.push(absolute);
         continue;
@@ -10557,17 +12265,17 @@ async function collectSuspiciousTemplatePaths(root) {
       if (!entry.isFile()) {
         continue;
       }
-      const baseName = path38.parse(entry.name).name;
+      const baseName = path45.parse(entry.name).name;
       if (SUSPICIOUS_TEMPLATE_NAME_RE.test(baseName)) {
-        matches.push(toPosix(path38.relative(root, absolute)));
+        matches.push(toPosix(path45.relative(root, absolute)));
       }
     }
   }
   return matches.sort((left, right) => left.localeCompare(right));
 }
-async function isDirectory(target) {
+async function isDirectory3(target) {
   try {
-    return (await stat5(target)).isDirectory();
+    return (await stat9(target)).isDirectory();
   } catch {
     return false;
   }
@@ -10577,7 +12285,7 @@ function toPosix(value) {
 }
 
 // src/core/validators/specSplitByCapability.ts
-import path39 from "path";
+import path46 from "path";
 init_utils();
 var CAP_ID_RE2 = /\bCAP-\d{4}\b/g;
 async function validateSpecSplitByCapability(root, config) {
@@ -10589,8 +12297,8 @@ async function validateSpecSplitByCapability(root, config) {
   if (layeredEntries.length === 0) {
     return [];
   }
-  const policiesDir = layeredEntries[0]?.sharedDir ?? path39.join(specsRoot, "_policies");
-  const capabilitiesPath = path39.join(policiesDir, "03_Capabilities.md");
+  const policiesDir = layeredEntries[0]?.sharedDir ?? path46.join(specsRoot, "_policies");
+  const capabilitiesPath = path46.join(policiesDir, "03_Capabilities.md");
   const capabilityText = await readSafe(capabilitiesPath);
   const issues = [];
   if (!await exists5(capabilitiesPath)) {
@@ -10630,7 +12338,7 @@ async function validateSpecSplitByCapability(root, config) {
     );
   }
   const actualSpecIds = new Set(
-    layeredEntries.map((entry) => path39.basename(entry.dir).toLowerCase())
+    layeredEntries.map((entry) => path46.basename(entry.dir).toLowerCase())
   );
   const expectedSpecIds = capIds.map((_, index) => `spec-${to4(index + 1)}`);
   const missingSpecIds = expectedSpecIds.filter((specId) => !actualSpecIds.has(specId));
@@ -10667,11 +12375,11 @@ async function validateSpecSplitByCapability(root, config) {
       continue;
     }
     const specId = `spec-${to4(index + 1)}`;
-    const entry = layeredEntries.find((value) => path39.basename(value.dir).toLowerCase() === specId);
+    const entry = layeredEntries.find((value) => path46.basename(value.dir).toLowerCase() === specId);
     if (!entry) {
       continue;
     }
-    const specFilePath = path39.join(entry.dir, "01_Spec.md");
+    const specFilePath = path46.join(entry.dir, "01_Spec.md");
     const specText = await readSafe(specFilePath);
     if (specText.trim().length === 0 || !specText.includes(capId)) {
       issues.push(
@@ -10690,8 +12398,8 @@ async function validateSpecSplitByCapability(root, config) {
 }
 
 // src/core/validators/statusInSpecs.ts
-import { readFile as readFile27 } from "fs/promises";
-import path40 from "path";
+import { readFile as readFile32 } from "fs/promises";
+import path47 from "path";
 init_utils();
 var STRONG_PATTERNS = [
   { label: "release_candidate:", pattern: /\brelease_candidate\s*:/i },
@@ -10749,32 +12457,32 @@ function hasMatch(text, pattern) {
 }
 async function readSafe11(filePath) {
   try {
-    return await readFile27(filePath, "utf-8");
+    return await readFile32(filePath, "utf-8");
   } catch {
     return "";
   }
 }
 function isOpenQuestionsFile(filePath) {
-  return /open-questions\.md$/i.test(path40.basename(filePath));
+  return /open-questions\.md$/i.test(path47.basename(filePath));
 }
 function isDecisionFile(filePath) {
-  return /decisions\.md$/i.test(path40.basename(filePath));
+  return /decisions\.md$/i.test(path47.basename(filePath));
 }
 
 // src/core/validators/breakthroughEvidence.ts
-import { readFile as readFile28 } from "fs/promises";
-import path41 from "path";
+import { readFile as readFile33 } from "fs/promises";
+import path48 from "path";
 init_utils();
 function toPosixRelative(root, targetPath) {
-  return path41.relative(root, targetPath).replace(/\\/g, "/");
+  return path48.relative(root, targetPath).replace(/\\/g, "/");
 }
 async function validateBreakthroughEvidence(root, config) {
   const screens = await readUiContractScreenContracts(root, config.paths.contractsDir);
   if (screens.length === 0) {
     return [];
   }
-  const evidenceRoot = path41.join(path41.dirname(resolvePath(root, config, "specsDir")), "evidence");
-  const evidencePath = path41.join(evidenceRoot, "breakthrough.json");
+  const evidenceRoot = path48.join(path48.dirname(resolvePath(root, config, "specsDir")), "evidence");
+  const evidencePath = path48.join(evidenceRoot, "breakthrough.json");
   const evidenceRelativePath = toPosixRelative(root, evidencePath);
   const raw = await readJsonFile2(evidencePath);
   if (raw.status === "missing") {
@@ -10890,7 +12598,7 @@ function isNonEmptyString2(value) {
 }
 async function readJsonFile2(filePath) {
   try {
-    const raw = await readFile28(filePath, "utf-8");
+    const raw = await readFile33(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return { status: "invalid" };
@@ -10898,7 +12606,7 @@ async function readJsonFile2(filePath) {
     return { status: "ok", value: parsed };
   } catch {
     try {
-      await readFile28(filePath, "utf-8");
+      await readFile33(filePath, "utf-8");
       return { status: "invalid" };
     } catch {
       return { status: "missing" };
@@ -10907,8 +12615,8 @@ async function readJsonFile2(filePath) {
 }
 
 // src/core/validators/designToken.ts
-import { readFile as readFile29 } from "fs/promises";
-import path42 from "path";
+import { readFile as readFile34 } from "fs/promises";
+import path49 from "path";
 import fg3 from "fast-glob";
 import { parse as parseYaml7 } from "yaml";
 
@@ -10955,7 +12663,7 @@ function collectLayer(layer, layerName, target, errors) {
 }
 function flattenTokens(obj, prefix, target, errors) {
   for (const [key, value] of Object.entries(obj)) {
-    const path76 = `${prefix}.${key}`;
+    const path84 = `${prefix}.${key}`;
     if (value && typeof value === "object" && !Array.isArray(value)) {
       const record2 = value;
       if ("$value" in record2) {
@@ -10971,9 +12679,9 @@ function flattenTokens(obj, prefix, target, errors) {
         if (typeof record2.platform === "string") {
           token.platform = record2.platform;
         }
-        target.set(path76, token);
+        target.set(path84, token);
       } else {
-        flattenTokens(record2, path76, target, errors);
+        flattenTokens(record2, path84, target, errors);
       }
     }
   }
@@ -10983,44 +12691,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 [path76] of allTokens) {
-    resolveTokenRef(path76, allTokens, /* @__PURE__ */ new Set(), 0, result);
+  for (const [path84] of allTokens) {
+    resolveTokenRef(path84, allTokens, /* @__PURE__ */ new Set(), 0, result);
   }
 }
-function resolveTokenRef(path76, allTokens, visited, depth, result) {
-  if (result.resolved.has(path76)) {
-    return result.resolved.get(path76);
+function resolveTokenRef(path84, allTokens, visited, depth, result) {
+  if (result.resolved.has(path84)) {
+    return result.resolved.get(path84);
   }
   if (depth > MAX_RESOLVE_DEPTH) {
     result.errors.push({
-      message: `Max reference depth exceeded at: ${path76}`,
-      path: path76
+      message: `Max reference depth exceeded at: ${path84}`,
+      path: path84
     });
     return void 0;
   }
-  if (visited.has(path76)) {
+  if (visited.has(path84)) {
     result.errors.push({
-      message: `Circular reference detected: ${path76}`,
-      path: path76
+      message: `Circular reference detected: ${path84}`,
+      path: path84
     });
     return void 0;
   }
-  const token = allTokens.get(path76);
+  const token = allTokens.get(path84);
   if (!token) {
     return void 0;
   }
   if (typeof token.$value !== "string") {
     const rawValue2 = stringifyTokenValue(token.$value);
-    result.resolved.set(path76, rawValue2);
+    result.resolved.set(path84, rawValue2);
     return rawValue2;
   }
   const rawValue = stringifyTokenValue(token.$value);
   const refs = [...rawValue.matchAll(REF_PATTERN)];
   if (refs.length === 0) {
-    result.resolved.set(path76, rawValue);
+    result.resolved.set(path84, rawValue);
     return rawValue;
   }
-  visited.add(path76);
+  visited.add(path84);
   let resolved = rawValue;
   for (const ref of refs) {
     const refPath = ref[1];
@@ -11028,8 +12736,8 @@ function resolveTokenRef(path76, allTokens, visited, depth, result) {
     const refToken = allTokens.get(refPath);
     if (!refToken) {
       result.errors.push({
-        message: `Unresolved token reference: {${refPath}} at ${path76}`,
-        path: path76
+        message: `Unresolved token reference: {${refPath}} at ${path84}`,
+        path: path84
       });
       continue;
     }
@@ -11038,7 +12746,7 @@ function resolveTokenRef(path76, allTokens, visited, depth, result) {
       resolved = resolved.split(`{${refPath}}`).join(refValue);
     }
   }
-  result.resolved.set(path76, resolved);
+  result.resolved.set(path84, resolved);
   return resolved;
 }
 function stringifyTokenValue(value) {
@@ -11094,8 +12802,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 ? path42.resolve(root, configuredDir) : path42.join(root, config.paths.contractsDir, "design");
-  const pattern = path42.posix.join(designDir.replace(/\\/g, "/"), "design-tokens*.yaml");
+  const designDir = configuredDir ? path49.resolve(root, configuredDir) : path49.join(root, config.paths.contractsDir, "design");
+  const pattern = path49.posix.join(designDir.replace(/\\/g, "/"), "design-tokens*.yaml");
   const files = await fg3(pattern, {
     absolute: true,
     ignore: ["**/*.schema.yaml", "**/*.schema.yml"]
@@ -11105,11 +12813,11 @@ async function validateDesignToken(root, config) {
   }
   const issues = [];
   for (const filePath of files) {
-    const rel = path42.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path49.relative(root, filePath).replace(/\\/g, "/");
     let hasRootObjectError = false;
     let content;
     try {
-      content = await readFile29(filePath, "utf-8");
+      content = await readFile34(filePath, "utf-8");
     } catch {
       issues.push(
         issue(
@@ -11272,8 +12980,8 @@ function normalizePlatform(value) {
 }
 
 // src/core/validators/htmlMock.ts
-import { readFile as readFile30 } from "fs/promises";
-import path43 from "path";
+import { readFile as readFile35 } from "fs/promises";
+import path50 from "path";
 import fg4 from "fast-glob";
 
 // src/core/uiux/contrastRatio.ts
@@ -11654,19 +13362,19 @@ async function validateHtmlMock(root, platform, config) {
   const startTime = performance.now();
   const budget = config.uiux?.htmlMockTimeout ?? 2e3;
   const patterns = [
-    path43.posix.join(root.replace(/\\/g, "/"), config.paths.discussionDir, "**/*.md"),
-    path43.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 files = await fg4(patterns, { absolute: true });
   const mockBlocks = [];
   for (const filePath of files) {
     let content;
     try {
-      content = await readFile30(filePath, "utf-8");
+      content = await readFile35(filePath, "utf-8");
     } catch {
       continue;
     }
-    const rel = path43.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path50.relative(root, filePath).replace(/\\/g, "/");
     for (const block of collectHtmlMockBlocks(content)) {
       mockBlocks.push({ file: rel, html: block.html, rawBlock: block.rawBlock });
     }
@@ -11832,8 +13540,8 @@ async function validateHtmlMock(root, platform, config) {
 }
 
 // src/core/validators/mermaidScreenFlow.ts
-import { readFile as readFile31 } from "fs/promises";
-import path44 from "path";
+import { readFile as readFile36 } from "fs/promises";
+import path51 from "path";
 import fg5 from "fast-glob";
 
 // src/core/validators/mermaidUtils.ts
@@ -11887,19 +13595,19 @@ async function validateMermaidScreenFlow(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
   const discussionRoot = resolvePath(root, config, "discussionDir");
   const latestDiscussionPackDir = await findLatestDiscussionPackDir(discussionRoot);
-  const patterns = [path44.posix.join(specsRoot.replace(/\\/g, "/"), "**/*.md")];
+  const patterns = [path51.posix.join(specsRoot.replace(/\\/g, "/"), "**/*.md")];
   if (latestDiscussionPackDir) {
-    patterns.push(path44.posix.join(latestDiscussionPackDir.replace(/\\/g, "/"), "**/*.md"));
+    patterns.push(path51.posix.join(latestDiscussionPackDir.replace(/\\/g, "/"), "**/*.md"));
   }
   const files = await fg5(patterns, { absolute: true });
   for (const filePath of files) {
     let content;
     try {
-      content = await readFile31(filePath, "utf-8");
+      content = await readFile36(filePath, "utf-8");
     } catch {
       continue;
     }
-    const rel = path44.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path51.relative(root, filePath).replace(/\\/g, "/");
     const blocks = extractFencedCodeBlocks(content);
     for (const block of blocks) {
       if (block.language !== "mermaid") continue;
@@ -11998,8 +13706,8 @@ function parseTransitions(content) {
 
 // src/core/validators/bpApDb.ts
 init_utils();
-import { readFile as readFile32 } from "fs/promises";
-import path45 from "path";
+import { readFile as readFile37 } from "fs/promises";
+import path52 from "path";
 import fg6 from "fast-glob";
 import { parse as parseYaml8 } from "yaml";
 var BP_ID_RE = /^BP-\d{4}$/;
@@ -12036,9 +13744,9 @@ var AP_REQUIRED_FIELDS = [
 ];
 async function validateBpApDb(root, config) {
   const issues = [];
-  const designDir = path45.join(root, config.paths.contractsDir, "design");
-  const bpPattern = path45.posix.join(designDir.replace(/\\/g, "/"), "best-practices*.yaml");
-  const apPattern = path45.posix.join(designDir.replace(/\\/g, "/"), "anti-patterns*.yaml");
+  const designDir = path52.join(root, config.paths.contractsDir, "design");
+  const bpPattern = path52.posix.join(designDir.replace(/\\/g, "/"), "best-practices*.yaml");
+  const apPattern = path52.posix.join(designDir.replace(/\\/g, "/"), "anti-patterns*.yaml");
   const globOptions = {
     absolute: true,
     ignore: ["**/*.schema.yaml", "**/*.schema.yml"]
@@ -12051,14 +13759,14 @@ async function validateBpApDb(root, config) {
   const seenBpIds = /* @__PURE__ */ new Set();
   const seenApIds = /* @__PURE__ */ new Set();
   for (const filePath of bpFiles) {
-    const rel = path45.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path52.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 = path45.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path52.relative(root, filePath).replace(/\\/g, "/");
     const entries = await parseRuleFile(filePath, rel, issues);
     for (const entry of entries) {
       validateApEntry(entry, rel, seenApIds, issues);
@@ -12069,7 +13777,7 @@ async function validateBpApDb(root, config) {
 async function parseRuleFile(filePath, rel, issues) {
   let content;
   try {
-    content = await readFile32(filePath, "utf-8");
+    content = await readFile37(filePath, "utf-8");
   } catch {
     issues.push(
       issue("QFAI-BPAP-001", `BP/AP file unreadable: ${rel}`, "error", rel, "bpApDb.readFile")
@@ -12234,8 +13942,8 @@ function toSafeString(value) {
 
 // src/core/validators/platformDetection.ts
 init_utils();
-import { readFile as readFile33 } from "fs/promises";
-import path46 from "path";
+import { readFile as readFile38 } from "fs/promises";
+import path53 from "path";
 var KNOWN_PLATFORMS = ["web", "windows", "mobile-ios", "mobile-android", "cross-platform"];
 async function detectPlatform(root, config, cliPlatform) {
   const issues = [];
@@ -12278,13 +13986,13 @@ async function detectPlatform(root, config, cliPlatform) {
   return { platform: "web", source: "fallback", issues };
 }
 async function inferPlatform(root, issues) {
-  if (await exists5(path46.join(root, "pubspec.yaml"))) {
-    const hasAndroid = await exists5(path46.join(root, "android"));
-    const hasIos = await exists5(path46.join(root, "ios"));
-    const hasWeb = await exists5(path46.join(root, "web"));
-    const hasWindows = await exists5(path46.join(root, "windows"));
-    const hasMacos = await exists5(path46.join(root, "macos"));
-    const hasLinux = await exists5(path46.join(root, "linux"));
+  if (await exists5(path53.join(root, "pubspec.yaml"))) {
+    const hasAndroid = await exists5(path53.join(root, "android"));
+    const hasIos = await exists5(path53.join(root, "ios"));
+    const hasWeb = await exists5(path53.join(root, "web"));
+    const hasWindows = await exists5(path53.join(root, "windows"));
+    const hasMacos = await exists5(path53.join(root, "macos"));
+    const hasLinux = await exists5(path53.join(root, "linux"));
     const mobileTargets = [hasAndroid, hasIos].filter(Boolean).length;
     const desktopTargets = [hasWeb, hasWindows, hasMacos, hasLinux].filter(Boolean).length;
     if (mobileTargets + desktopTargets > 1) {
@@ -12304,10 +14012,10 @@ async function inferPlatform(root, issues) {
     }
     return null;
   }
-  const pkgJsonPath = path46.join(root, "package.json");
+  const pkgJsonPath = path53.join(root, "package.json");
   if (await exists5(pkgJsonPath)) {
     try {
-      const raw = await readFile33(pkgJsonPath, "utf-8");
+      const raw = await readFile38(pkgJsonPath, "utf-8");
       const pkg = JSON.parse(raw);
       const deps = {
         ...typeof pkg.dependencies === "object" && pkg.dependencies !== null ? pkg.dependencies : {},
@@ -12326,8 +14034,8 @@ async function inferPlatform(root, issues) {
         return "cross-platform";
       }
       if ("react-native" in deps) {
-        const hasAndroid = await exists5(path46.join(root, "android"));
-        const hasIos = await exists5(path46.join(root, "ios"));
+        const hasAndroid = await exists5(path53.join(root, "android"));
+        const hasIos = await exists5(path53.join(root, "ios"));
         if (hasAndroid && hasIos) {
           return "cross-platform";
         }
@@ -12349,16 +14057,16 @@ function normalizePlatformInput(platform) {
 }
 
 // src/core/validators/uiDefinitionConsistency.ts
-import { readFile as readFile34 } from "fs/promises";
-import path47 from "path";
+import { readFile as readFile39 } from "fs/promises";
+import path54 from "path";
 import fg7 from "fast-glob";
 import { parse as parseYaml9 } from "yaml";
 init_utils();
 async function validateUiDefinitionConsistency(root, config) {
   const issues = [];
   const configuredDir = config.uiux?.designTokensDir;
-  const designDir = configuredDir ? path47.resolve(root, configuredDir) : path47.join(root, config.paths.contractsDir, "design");
-  const tokenPattern = path47.posix.join(designDir.replace(/\\/g, "/"), "design-tokens*.yaml");
+  const designDir = configuredDir ? path54.resolve(root, configuredDir) : path54.join(root, config.paths.contractsDir, "design");
+  const tokenPattern = path54.posix.join(designDir.replace(/\\/g, "/"), "design-tokens*.yaml");
   const tokenFiles = await fg7(tokenPattern, {
     absolute: true,
     ignore: ["**/*.schema.yaml", "**/*.schema.yml"]
@@ -12366,7 +14074,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 readFile39(tokenFile, "utf-8");
       const result = parseDesignToken(content);
       for (const [key, val] of result.resolved) {
         resolvedTokens.set(key, val);
@@ -12374,13 +14082,13 @@ async function validateUiDefinitionConsistency(root, config) {
     } catch {
     }
   }
-  const uiContractDir = path47.join(root, config.paths.contractsDir, "ui");
-  const uiPattern = path47.posix.join(uiContractDir.replace(/\\/g, "/"), "**/*.yaml");
+  const uiContractDir = path54.join(root, config.paths.contractsDir, "ui");
+  const uiPattern = path54.posix.join(uiContractDir.replace(/\\/g, "/"), "**/*.yaml");
   const uiFiles = await fg7(uiPattern, { absolute: true });
   const contractScreenIds = /* @__PURE__ */ new Set();
   for (const uiFile of uiFiles) {
     try {
-      const content = await readFile34(uiFile, "utf-8");
+      const content = await readFile39(uiFile, "utf-8");
       const parsed = parseYaml9(content);
       if (parsed && typeof parsed === "object") {
         const screens = parsed.screens;
@@ -12396,15 +14104,15 @@ async function validateUiDefinitionConsistency(root, config) {
     }
   }
   const mdPatterns = [
-    path47.posix.join(root.replace(/\\/g, "/"), config.paths.discussionDir, "**/*.md"),
-    path47.posix.join(root.replace(/\\/g, "/"), config.paths.specsDir, "**/*.md")
+    path54.posix.join(root.replace(/\\/g, "/"), config.paths.discussionDir, "**/*.md"),
+    path54.posix.join(root.replace(/\\/g, "/"), config.paths.specsDir, "**/*.md")
   ];
   const mdFiles = await fg7(mdPatterns, { absolute: true });
   const mockScreenIds = /* @__PURE__ */ new Set();
   for (const mdFile of mdFiles) {
     try {
-      const content = await readFile34(mdFile, "utf-8");
-      const rel = path47.relative(root, mdFile).replace(/\\/g, "/");
+      const content = await readFile39(mdFile, "utf-8");
+      const rel = path54.relative(root, mdFile).replace(/\\/g, "/");
       const htmlBlocks = collectHtmlMockBlocks(content);
       if (resolvedTokens.size > 0) {
         for (const htmlBlock of htmlBlocks) {
@@ -12464,8 +14172,8 @@ async function validateUiDefinitionConsistency(root, config) {
 
 // src/core/validators/researchSummary.ts
 init_utils();
-import { readFile as readFile35 } from "fs/promises";
-import path48 from "path";
+import { readFile as readFile40 } from "fs/promises";
+import path55 from "path";
 import fg8 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;
@@ -12473,17 +14181,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 = path48.posix.join(root.replace(/\\/g, "/"), config.paths.discussionDir, "**/*.md");
+  const pattern = path55.posix.join(root.replace(/\\/g, "/"), config.paths.discussionDir, "**/*.md");
   const files = await fg8(pattern, { absolute: true });
   for (const filePath of files) {
     let content;
     try {
-      content = await readFile35(filePath, "utf-8");
+      content = await readFile40(filePath, "utf-8");
     } catch {
       continue;
     }
     if (!RESEARCH_SUMMARY_HEADING_RE.test(content)) continue;
-    const rel = path48.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path55.relative(root, filePath).replace(/\\/g, "/");
     const section = extractResearchSummarySection(content);
     if (!section) continue;
     const sourceEntries = extractSourceEntries(section);
@@ -12715,8 +14423,8 @@ function resolveFreshnessReferenceNow() {
 
 // src/core/validators/agentDefinition.ts
 init_utils();
-import { readFile as readFile36 } from "fs/promises";
-import path49 from "path";
+import { readFile as readFile41 } from "fs/promises";
+import path56 from "path";
 import { parse as parseYaml10 } from "yaml";
 var REQUIRED_AGENT_SECTIONS = [
   "## Mission",
@@ -12728,11 +14436,11 @@ var REQUIRED_AGENT_SECTIONS = [
 ];
 async function validateAgentDefinition(root, _config) {
   const issues = [];
-  const steeringDir = path49.join(root, ".qfai", "assistant", "steering");
-  const agentsDir = path49.join(root, ".qfai", "assistant", "agents");
-  const catalogPath = path49.join(steeringDir, "agent-catalog.yml");
-  const routingPath = path49.join(steeringDir, "agent-routing.yml");
-  const profilesPath = path49.join(steeringDir, "review-profiles.yml");
+  const steeringDir = path56.join(root, ".qfai", "assistant", "steering");
+  const agentsDir = path56.join(root, ".qfai", "assistant", "agents");
+  const catalogPath = path56.join(steeringDir, "agent-catalog.yml");
+  const routingPath = path56.join(steeringDir, "agent-routing.yml");
+  const profilesPath = path56.join(steeringDir, "review-profiles.yml");
   if (!await exists5(agentsDir) && !await exists5(catalogPath)) {
     return [];
   }
@@ -12741,7 +14449,7 @@ async function validateAgentDefinition(root, _config) {
     ["agent-routing.yml", "QFAI-AGENT-002"],
     ["review-profiles.yml", "QFAI-AGENT-003"]
   ]) {
-    const filePath = path49.join(steeringDir, fileName);
+    const filePath = path56.join(steeringDir, fileName);
     if (!await exists5(filePath)) {
       issues.push(
         issue(
@@ -12766,7 +14474,7 @@ async function validateAgentDefinition(root, _config) {
     catalog.filter((agent) => agent.kind === "reviewer").map((agent) => agent.id)
   );
   for (const agent of catalog) {
-    const filePath = path49.join(agentsDir, `${agent.id}.md`);
+    const filePath = path56.join(agentsDir, `${agent.id}.md`);
     const rel = `.qfai/assistant/agents/${agent.id}.md`;
     if (!await exists5(filePath)) {
       issues.push(
@@ -12780,7 +14488,7 @@ async function validateAgentDefinition(root, _config) {
       );
       continue;
     }
-    const content = await readFile36(filePath, "utf-8");
+    const content = await readFile41(filePath, "utf-8");
     for (const heading of REQUIRED_AGENT_SECTIONS) {
       if (!content.includes(heading)) {
         issues.push(
@@ -12801,7 +14509,7 @@ async function validateAgentDefinition(root, _config) {
 }
 async function readCatalog(catalogPath, issues) {
   try {
-    const parsed = parseYaml10(await readFile36(catalogPath, "utf-8"));
+    const parsed = parseYaml10(await readFile41(catalogPath, "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       issues.push(
         issue(
@@ -12875,7 +14583,7 @@ async function readCatalog(catalogPath, issues) {
 }
 async function validateRouting(routingPath, catalogIds, issues) {
   try {
-    const parsed = parseYaml10(await readFile36(routingPath, "utf-8"));
+    const parsed = parseYaml10(await readFile41(routingPath, "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       issues.push(
         issue(
@@ -12991,7 +14699,7 @@ function validateAgentRefs(value, catalogIds, issues, skill, routeIndex, phaseIn
 }
 async function validateProfiles(profilesPath, reviewerIds, issues) {
   try {
-    const parsed = parseYaml10(await readFile36(profilesPath, "utf-8"));
+    const parsed = parseYaml10(await readFile41(profilesPath, "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       issues.push(
         issue(
@@ -13070,8 +14778,8 @@ function validateReviewerRefs(value, reviewerIds, issues, profileName, field) {
 }
 
 // src/core/validators/tddList.ts
-import { readFile as readFile37, stat as stat6 } from "fs/promises";
-import path50 from "path";
+import { readFile as readFile42, stat as stat10 } from "fs/promises";
+import path57 from "path";
 init_utils();
 var REQUIRED_COLUMNS = [
   "TDD-ID",
@@ -13086,7 +14794,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 = path50.join("tdd", "test-list.md");
+var TDD_LIST_REL_PATH = path57.join("tdd", "test-list.md");
 async function validateTddList(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
   const entries = await collectSpecEntries(specsRoot);
@@ -13098,8 +14806,8 @@ async function validateTddList(root, config) {
   return issues;
 }
 async function validateSpecTddList(root, specDir, specNumber) {
-  const filePath = path50.join(specDir, TDD_LIST_REL_PATH);
-  const relPath = path50.relative(root, filePath).replace(/\\/g, "/");
+  const filePath = path57.join(specDir, TDD_LIST_REL_PATH);
+  const relPath = path57.relative(root, filePath).replace(/\\/g, "/");
   const issues = [];
   if (!await exists5(filePath)) {
     issues.push(
@@ -13286,9 +14994,9 @@ async function validateSpecTddList(root, specDir, specNumber) {
         continue;
       }
       const normalized = testFile.replace(/\\/g, "/");
-      const resolved = path50.resolve(root, normalized);
-      const relative = path50.relative(root, resolved);
-      if (path50.isAbsolute(normalized) || path50.win32.isAbsolute(normalized) || relative === ".." || relative.startsWith(".." + path50.sep)) {
+      const resolved = path57.resolve(root, normalized);
+      const relative = path57.relative(root, resolved);
+      if (path57.isAbsolute(normalized) || path57.win32.isAbsolute(normalized) || relative === ".." || relative.startsWith(".." + path57.sep)) {
         issues.push(
           issue(
             "TDDLIST_TEST_FILE_MISSING",
@@ -13302,7 +15010,7 @@ async function validateSpecTddList(root, specDir, specNumber) {
       }
       let isFile2 = false;
       try {
-        isFile2 = (await stat6(resolved)).isFile();
+        isFile2 = (await stat10(resolved)).isFile();
       } catch {
       }
       if (!isFile2) {
@@ -13351,11 +15059,11 @@ async function validateSpecTddList(root, specDir, specNumber) {
 }
 async function collectTestCaseIds(specDir) {
   const empty = { knownTcIds: /* @__PURE__ */ new Set(), unitComponentTcIds: /* @__PURE__ */ new Set() };
-  const testCasesPath = path50.join(specDir, "06_Test-Cases.md");
+  const testCasesPath = path57.join(specDir, "06_Test-Cases.md");
   if (!await exists5(testCasesPath)) return empty;
   let content;
   try {
-    content = await readFile37(testCasesPath, "utf-8");
+    content = await readFile42(testCasesPath, "utf-8");
   } catch {
     return empty;
   }
@@ -13381,7 +15089,7 @@ async function collectTestCaseIds(specDir) {
 }
 
 // src/core/validators/navigationFlow.ts
-import { readFile as readFile38 } from "fs/promises";
+import { readFile as readFile43 } from "fs/promises";
 init_utils();
 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;
@@ -13661,7 +15369,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 readFile38(file, "utf-8");
+    const content = await readFile43(file, "utf-8");
     const blocks = extractFencedCodeBlocks(content);
     const mermaidBlocks = blocks.filter((b) => b.language === "mermaid");
     const _flowchartBlocks = mermaidBlocks.filter((b) => hasFlowchartDeclaration(b.content));
@@ -13684,8 +15392,8 @@ async function validateNavigationFlow(root, config) {
 
 // src/core/validators/renderCritique.ts
 init_utils();
-import path51 from "path";
-import { readFile as readFile39 } from "fs/promises";
+import path58 from "path";
+import { readFile as readFile44 } from "fs/promises";
 import fg9 from "fast-glob";
 var RENDERED_KEYWORDS_RE = /\b(rendered|screenshot|html\b|preview|visual\s*review)/i;
 var SPEC_RE = /\b(01_spec|03_acceptance-criteria|spec-|\bspec\b)\b/i;
@@ -13709,11 +15417,11 @@ 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 skillsDir = path51.join(root, config.paths.skillsDir).replace(/\\/g, "/");
-  const evidenceDir = path51.join(root, ".qfai", "evidence").replace(/\\/g, "/");
-  const skillPromptPattern = path51.posix.join(skillsDir, "qfai-{prototyping,implement}*/SKILL.md");
+  const skillsDir = path58.join(root, config.paths.skillsDir).replace(/\\/g, "/");
+  const evidenceDir = path58.join(root, ".qfai", "evidence").replace(/\\/g, "/");
+  const skillPromptPattern = path58.posix.join(skillsDir, "qfai-{prototyping,implement}*/SKILL.md");
   const skillFiles = await fg9(skillPromptPattern, { dot: true });
-  const evidencePattern = path51.posix.join(evidenceDir, "{prototyping*,critique-*}.md");
+  const evidencePattern = path58.posix.join(evidenceDir, "{prototyping*,critique-*}.md");
   const evidenceFiles = await fg9(evidencePattern, { dot: true });
   if (skillFiles.length === 0 && evidenceFiles.length === 0) return issues;
   const renderEvidenceViewports = await collectRenderEvidenceViewports(root);
@@ -13723,7 +15431,7 @@ async function validateRenderCritique(root, config) {
       issues.push(
         issue(
           "QFAI-CRIT-001",
-          `Skill prompt does not mention rendered/screenshot/HTML review: ${path51.relative(root, sf)}`,
+          `Skill prompt does not mention rendered/screenshot/HTML review: ${path58.relative(root, sf)}`,
           "error",
           sf,
           "renderCritique.codeOnly",
@@ -13740,7 +15448,7 @@ async function validateRenderCritique(root, config) {
       issues.push(
         issue(
           "QFAI-CRIT-002",
-          `Downstream skill prompt missing canonical spec/contract references: ${path51.relative(root, sf)}`,
+          `Downstream skill prompt missing canonical spec/contract references: ${path58.relative(root, sf)}`,
           "error",
           sf,
           "renderCritique.contractMissing",
@@ -13802,7 +15510,7 @@ async function validateRenderCritique(root, config) {
         issues.push(
           issue(
             "QFAI-CRIT-005",
-            `Read order missing required tokens (${missing.join(", ")}): ${path51.relative(root, sf)}`,
+            `Read order missing required tokens (${missing.join(", ")}): ${path58.relative(root, sf)}`,
             "error",
             sf,
             "renderCritique.readOrder",
@@ -13830,7 +15538,7 @@ async function validateRenderCritique(root, config) {
       issues.push(
         issue(
           "QFAI-CRIT-006",
-          `Critique evidence incomplete (missing: ${missing.join(", ")}): ${path51.relative(root, ef)}`,
+          `Critique evidence incomplete (missing: ${missing.join(", ")}): ${path58.relative(root, ef)}`,
           "error",
           ef,
           "renderCritique.incompleteEvidence",
@@ -13945,9 +15653,9 @@ async function collectContent(files) {
   return contents.join("\n---\n");
 }
 async function collectRenderEvidenceViewports(root) {
-  const prototypingJsonPath = path51.join(root, ".qfai", "evidence", "prototyping.json");
+  const prototypingJsonPath = path58.join(root, ".qfai", "evidence", "prototyping.json");
   try {
-    const raw = await readFile39(prototypingJsonPath, "utf-8");
+    const raw = await readFile44(prototypingJsonPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return /* @__PURE__ */ new Set();
@@ -13987,8 +15695,8 @@ async function collectRenderEvidenceViewports(root) {
 
 // src/core/validators/designFidelity.ts
 init_utils();
-import { readFile as readFile40 } from "fs/promises";
-import path52 from "path";
+import { readFile as readFile45 } from "fs/promises";
+import path59 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"];
@@ -14013,19 +15721,19 @@ async function validateDesignFidelity(root, config) {
   const evidenceDirs = [".qfai/evidence", ".qfai/review"];
   const allFiles = [];
   for (const dir of evidenceDirs) {
-    const pattern = path52.posix.join(root.replace(/\\/g, "/"), dir, "**/*.md");
+    const pattern = path59.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 readFile40(filePath, "utf-8");
+      content = await readFile45(filePath, "utf-8");
     } catch {
       continue;
     }
     if (!SCORECARD_HEADING_RE.test(content)) continue;
-    const rel = path52.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path59.relative(root, filePath).replace(/\\/g, "/");
     const section = extractScorecardSection(content);
     if (!section) continue;
     const dimensions = parseDimensions(section);
@@ -14318,7 +16026,7 @@ function hasAntiPatternMention(section, code) {
 
 // src/core/validators/discussionDesignHardening.ts
 init_surfaceType();
-import path53 from "path";
+import path60 from "path";
 init_utils();
 var REQUIRED_SIDECARS = [
   "uiux/30_exploration_brief.md",
@@ -14333,14 +16041,14 @@ function canonicalIssue(code, message, severity, file, rule) {
   return issue(code, message, severity, file, rule, void 0, "canonical");
 }
 async function validateDiscussionDesignHardening(root, config) {
-  const discussionDir = path53.join(root, config.paths.discussionDir);
+  const discussionDir = path60.join(root, config.paths.discussionDir);
   const packRoot = await findLatestDiscussionPackDir(discussionDir);
   if (!packRoot) return [];
   const uiBearing = await isDiscussionUiBearingPack(packRoot);
   if (!uiBearing) return [];
   const issues = [];
   for (const relPath of REQUIRED_SIDECARS) {
-    const content = await readSafe(path53.join(packRoot, relPath));
+    const content = await readSafe(path60.join(packRoot, relPath));
     if (!content) {
       issues.push(
         canonicalIssue(
@@ -14382,7 +16090,7 @@ async function validateDiscussionDesignHardening(root, config) {
       "UIX-VAL-EVAL-CALIBRATION"
     )
   );
-  const antiGoals = await readSafe(path53.join(packRoot, "uiux/32_design_anti_goals.md"));
+  const antiGoals = await readSafe(path60.join(packRoot, "uiux/32_design_anti_goals.md"));
   if (antiGoals && !/^- /m.test(antiGoals)) {
     issues.push(
       canonicalIssue(
@@ -14394,7 +16102,7 @@ async function validateDiscussionDesignHardening(root, config) {
       )
     );
   }
-  const reviewBundle = await readSafe(path53.join(packRoot, "uiux/50_review_input_bundle.md"));
+  const reviewBundle = await readSafe(path60.join(packRoot, "uiux/50_review_input_bundle.md"));
   if (reviewBundle && !/best-of-history/i.test(reviewBundle)) {
     issues.push(
       canonicalIssue(
@@ -14409,7 +16117,7 @@ async function validateDiscussionDesignHardening(root, config) {
   return issues;
 }
 async function validateSection(packRoot, relPath, headings, code) {
-  const content = await readSafe(path53.join(packRoot, relPath));
+  const content = await readSafe(path60.join(packRoot, relPath));
   if (!content) {
     return [];
   }
@@ -14432,12 +16140,12 @@ async function validateSection(packRoot, relPath, headings, code) {
 
 // src/core/validators/designAudit.ts
 init_surfaceType();
-import { readdir as readdir9 } from "fs/promises";
-import path54 from "path";
+import { readdir as readdir10 } from "fs/promises";
+import path61 from "path";
 init_utils();
 var COSMETIC_CATEGORIES = ["generic-shell", "stock-imagery", "placeholder-copy"];
 function toPosixRelative2(root, targetPath) {
-  return path54.relative(root, targetPath).replace(/\\/g, "/");
+  return path61.relative(root, targetPath).replace(/\\/g, "/");
 }
 function resolveAuditConfig(config) {
   const audit = config.uiux?.audit;
@@ -14559,19 +16267,19 @@ 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 ? path54.resolve(root, configuredDir) : path54.join(root, cfg.paths.contractsDir, "design");
+  const tokensDir = configuredDir ? path61.resolve(root, configuredDir) : path61.join(root, cfg.paths.contractsDir, "design");
   let hasTokenFiles = false;
   try {
-    const entries = await readdir9(tokensDir);
+    const entries = await readdir10(tokensDir);
     hasTokenFiles = entries.some((e) => /\.ya?ml$/i.test(e));
   } catch {
     return findings;
   }
   if (!hasTokenFiles) return findings;
-  const contractsUiDir = path54.join(root, cfg.paths.contractsDir, "ui");
+  const contractsUiDir = path61.join(root, cfg.paths.contractsDir, "ui");
   let htmlFiles = [];
   try {
-    const entries = await readdir9(contractsUiDir);
+    const entries = await readdir10(contractsUiDir);
     htmlFiles = entries.filter((e) => /\.html?$/i.test(e));
   } catch {
     return findings;
@@ -14579,7 +16287,7 @@ async function checkTokenDrift(root, auditConfig, cfg) {
   let rawCount = 0;
   const sampleLiterals = [];
   for (const htmlFile of htmlFiles) {
-    const content = await readSafe(path54.join(contractsUiDir, htmlFile));
+    const content = await readSafe(path61.join(contractsUiDir, htmlFile));
     if (!content) continue;
     const matches = content.match(RAW_COLOR_RE);
     if (matches) {
@@ -14630,14 +16338,14 @@ function deduplicateFindings(issues, maxPerRule) {
 async function validateDesignAudit(root, config) {
   const auditConfig = resolveAuditConfig(config);
   if (!auditConfig.enabled) return [];
-  const discussionDir = path54.join(root, config.paths.discussionDir);
+  const discussionDir = path61.join(root, config.paths.discussionDir);
   const packRoot = await findLatestDiscussionPackDir(discussionDir);
   if (!packRoot) return [];
   const uiBearing = await isDiscussionUiBearingPack(packRoot);
   if (!uiBearing) return [];
-  const contractsPath = path54.join(packRoot, "uiux", "40_screen_contracts.md");
+  const contractsPath = path61.join(packRoot, "uiux", "40_screen_contracts.md");
   const contractsContent = await readSafe(contractsPath);
-  const selectedDirectionPath = path54.join(
+  const selectedDirectionPath = path61.join(
     root,
     config.paths.contractsDir,
     "design",
@@ -14665,8 +16373,8 @@ async function validateDesignAudit(root, config) {
 // src/core/validators/designSlop.ts
 init_surfaceType();
 import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile41 } from "fs/promises";
-import path55 from "path";
+import { readFile as readFile46 } from "fs/promises";
+import path62 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 init_utils();
 function isValidSlopPattern(rule) {
@@ -14675,7 +16383,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 readFile41(jsonPath, "utf-8");
+  const raw = await readFile46(jsonPath, "utf-8");
   const parsed = JSON.parse(raw);
   if (!Array.isArray(parsed)) return [];
   return parsed.filter((r) => isValidSlopPattern(r));
@@ -14683,11 +16391,11 @@ async function loadSlopPatterns(jsonPath) {
 function defaultPatternsPath() {
   const base = import.meta.url;
   const basePath = base.startsWith("file:") ? fileURLToPath3(base) : base;
-  const baseDir = path55.dirname(basePath);
+  const baseDir = path62.dirname(basePath);
   const candidates = [
-    path55.join(baseDir, "designSlopPatterns.json"),
-    path55.resolve(baseDir, "../../../assets/validators/designSlopPatterns.json"),
-    path55.resolve(baseDir, "../../assets/validators/designSlopPatterns.json")
+    path62.join(baseDir, "designSlopPatterns.json"),
+    path62.resolve(baseDir, "../../../assets/validators/designSlopPatterns.json"),
+    path62.resolve(baseDir, "../../assets/validators/designSlopPatterns.json")
   ];
   for (const c of candidates) {
     if (existsSync2(c)) return c;
@@ -14698,7 +16406,7 @@ async function validateDesignSlop(root, config) {
   const auditConfig = resolveAuditConfig(config);
   if (!auditConfig.enabled) return [];
   if (!auditConfig.slopDetection) return [];
-  const discussionDir = path55.join(root, config.paths.discussionDir);
+  const discussionDir = path62.join(root, config.paths.discussionDir);
   const packRoot = await findLatestDiscussionPackDir(discussionDir);
   if (!packRoot) return [];
   const uiBearing = await isDiscussionUiBearingPack(packRoot);
@@ -14719,7 +16427,7 @@ async function validateDesignSlop(root, config) {
       continue;
     }
     for (const scope of pattern.scopes) {
-      const filePath = path55.join(packRoot, scope);
+      const filePath = path62.join(packRoot, scope);
       const content = await readSafe(filePath);
       if (!content) continue;
       if (regex.test(content) && !seenRules.has(pattern.id)) {
@@ -14742,8 +16450,8 @@ async function validateDesignSlop(root, config) {
 
 // src/core/validators/designContractReadiness.ts
 init_utils();
-import path56 from "path";
-import { readFile as readFile42 } from "fs/promises";
+import path63 from "path";
+import { readFile as readFile47 } from "fs/promises";
 import fg11 from "fast-glob";
 import { parse as parseYaml11 } from "yaml";
 var REQUIRED_DESIGN_FILES = [
@@ -14754,24 +16462,24 @@ var REQUIRED_DESIGN_FILES = [
   "design-system.yaml"
 ];
 function toPosixRelative3(root, targetPath) {
-  return path56.relative(root, targetPath).replace(/\\/g, "/");
+  return path63.relative(root, targetPath).replace(/\\/g, "/");
 }
 async function validateDesignContractReadiness(root, config) {
-  const uiPattern = path56.posix.join(
-    path56.join(root, config.paths.contractsDir, "ui").replace(/\\/g, "/"),
+  const uiPattern = path63.posix.join(
+    path63.join(root, config.paths.contractsDir, "ui").replace(/\\/g, "/"),
     "**/*.yaml"
   );
   const uiContracts = await fg11(uiPattern, { absolute: true });
   if (uiContracts.length === 0) {
     return [];
   }
-  const designDir = path56.join(root, config.paths.contractsDir, "design");
+  const designDir = path63.join(root, config.paths.contractsDir, "design");
   const designDirRelative = toPosixRelative3(root, designDir);
   const issues = [];
   for (const fileName of REQUIRED_DESIGN_FILES) {
-    const filePath = path56.join(designDir, fileName);
+    const filePath = path63.join(designDir, fileName);
     try {
-      await readFile42(filePath, "utf-8");
+      await readFile47(filePath, "utf-8");
     } catch {
       issues.push(
         issue(
@@ -14795,7 +16503,7 @@ async function validateDesignContractReadiness(root, config) {
   return issues;
 }
 async function validateExplorationBrief(root, config) {
-  const filePath = path56.join(root, config.paths.contractsDir, "design", "exploration-brief.yaml");
+  const filePath = path63.join(root, config.paths.contractsDir, "design", "exploration-brief.yaml");
   const parsed = await readYaml(filePath);
   if (parsed.kind !== "ok") {
     return parsed.kind === "invalid" ? [
@@ -14826,7 +16534,7 @@ async function validateExplorationBrief(root, config) {
   );
 }
 async function validateEvaluationRubric(root, config) {
-  const filePath = path56.join(root, config.paths.contractsDir, "design", "evaluation-rubric.yaml");
+  const filePath = path63.join(root, config.paths.contractsDir, "design", "evaluation-rubric.yaml");
   const parsed = await readYaml(filePath);
   if (parsed.kind !== "ok") {
     return parsed.kind === "invalid" ? [
@@ -14857,7 +16565,7 @@ async function validateEvaluationRubric(root, config) {
   return issues;
 }
 async function validateEvaluatorCalibration(root, config) {
-  const filePath = path56.join(
+  const filePath = path63.join(
     root,
     config.paths.contractsDir,
     "design",
@@ -14891,7 +16599,7 @@ async function validateEvaluatorCalibration(root, config) {
   );
 }
 async function validateSelectedDirection(root, config) {
-  const filePath = path56.join(root, config.paths.contractsDir, "design", "selected-direction.yaml");
+  const filePath = path63.join(root, config.paths.contractsDir, "design", "selected-direction.yaml");
   const parsed = await readYaml(filePath);
   if (parsed.kind !== "ok") {
     return parsed.kind === "invalid" ? [
@@ -14929,7 +16637,7 @@ async function validateSelectedDirection(root, config) {
   return issues;
 }
 async function validateDesignSystem(root, config) {
-  const filePath = path56.join(root, config.paths.contractsDir, "design", "design-system.yaml");
+  const filePath = path63.join(root, config.paths.contractsDir, "design", "design-system.yaml");
   const parsed = await readYaml(filePath);
   if (parsed.kind !== "ok") {
     return parsed.kind === "invalid" ? [
@@ -14987,14 +16695,14 @@ function isNonEmptyStringValue(value) {
 }
 async function readYaml(filePath) {
   try {
-    const parsed = parseYaml11(await readFile42(filePath, "utf-8"));
+    const parsed = parseYaml11(await readFile47(filePath, "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return { kind: "invalid" };
     }
     return { kind: "ok", value: parsed };
   } catch {
     try {
-      await readFile42(filePath, "utf-8");
+      await readFile47(filePath, "utf-8");
       return { kind: "invalid" };
     } catch {
       return { kind: "missing" };
@@ -15002,14 +16710,184 @@ async function readYaml(filePath) {
   }
 }
 
+// src/core/validators/evaluatorReviewHardFloor.ts
+import { readFile as readFile48, readdir as readdir11 } from "fs/promises";
+import path64 from "path";
+import { parse as parseYaml12 } from "yaml";
+init_utils();
+var ISSUE_CODE = "QFAI-PROT-AXIS-FLOOR-001";
+var RULE = "evaluatorReviewHardFloor.perAxisScore";
+function isRecord16(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function toPosixRelative4(root, target) {
+  return path64.relative(root, target).replace(/\\/g, "/");
+}
+function isEnoentError(error) {
+  return error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT";
+}
+async function readYamlObject(filePath) {
+  let raw;
+  try {
+    raw = await readFile48(filePath, "utf-8");
+  } catch (error) {
+    if (isEnoentError(error)) {
+      return { kind: "missing" };
+    }
+    return { kind: "invalid" };
+  }
+  try {
+    const parsed = parseYaml12(raw);
+    return isRecord16(parsed) ? { kind: "ok", value: parsed } : { kind: "invalid" };
+  } catch {
+    return { kind: "invalid" };
+  }
+}
+async function readJsonObject(filePath) {
+  let raw;
+  try {
+    raw = await readFile48(filePath, "utf-8");
+  } catch (error) {
+    if (isEnoentError(error)) {
+      return { kind: "missing" };
+    }
+    return { kind: "invalid" };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return isRecord16(parsed) ? { kind: "ok", value: parsed } : { kind: "invalid" };
+  } catch {
+    return { kind: "invalid" };
+  }
+}
+function loadHardFloors(rubric) {
+  const map = /* @__PURE__ */ new Map();
+  const entries = rubric.hard_floors;
+  if (!Array.isArray(entries)) {
+    return map;
+  }
+  for (const entry of entries) {
+    if (!isRecord16(entry)) {
+      continue;
+    }
+    const id = entry.id;
+    const minScore = entry.min_score;
+    if (typeof id !== "string" || id.trim().length === 0 || typeof minScore !== "number" || !Number.isFinite(minScore)) {
+      continue;
+    }
+    map.set(id, minScore);
+  }
+  return map;
+}
+async function listCandidateReviewFiles(reviewsDirAbsolute) {
+  try {
+    const names = await readdir11(reviewsDirAbsolute);
+    return names.filter((name) => name.endsWith(".json"));
+  } catch (error) {
+    if (isEnoentError(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+function extractCandidateId(fileName) {
+  return fileName.replace(/\.json$/i, "");
+}
+function evaluatePerAxis(review, hardFloors) {
+  const perAxis = review.perAxis;
+  if (!Array.isArray(perAxis)) {
+    return [];
+  }
+  const violations = [];
+  for (const axis of perAxis) {
+    if (!isRecord16(axis)) {
+      continue;
+    }
+    const axisId = axis.axisId;
+    const score = axis.score;
+    if (typeof axisId !== "string" || axisId.trim().length === 0 || typeof score !== "number" || !Number.isFinite(score)) {
+      continue;
+    }
+    const minScore = hardFloors.get(axisId);
+    if (minScore === void 0) {
+      continue;
+    }
+    if (score < minScore) {
+      violations.push({ axisId, score, minScore });
+    }
+  }
+  return violations;
+}
+async function checkRound(root, round, hardFloors) {
+  const reviewsDirRelative = roundEvaluatorReviewsDir(round);
+  const reviewsDirAbsolute = path64.join(root, reviewsDirRelative);
+  const files = await listCandidateReviewFiles(reviewsDirAbsolute);
+  if (files === null || files.length === 0) {
+    return [];
+  }
+  const issues = [];
+  for (const fileName of files) {
+    const candidateId = extractCandidateId(fileName);
+    const reviewPathAbsolute = path64.join(reviewsDirAbsolute, fileName);
+    const result = await readJsonObject(reviewPathAbsolute);
+    if (result.kind !== "ok") {
+      continue;
+    }
+    const violations = evaluatePerAxis(result.value, hardFloors);
+    const reviewPathRelative = toPosixRelative4(root, reviewPathAbsolute);
+    for (const violation of violations) {
+      issues.push(
+        issue(
+          ISSUE_CODE,
+          `Candidate ${candidateId} axis ${violation.axisId} score ${violation.score} is below hard_floors min_score ${violation.minScore} in round ${round}.`,
+          "error",
+          reviewPathRelative,
+          RULE,
+          [
+            round,
+            candidateId,
+            violation.axisId,
+            String(violation.score),
+            String(violation.minScore)
+          ],
+          "canonical",
+          `${reviewPathRelative} \u306E ${violation.axisId} \u30B9\u30B3\u30A2\u3092\u518D\u8A55\u4FA1\u3057\u3001hard_floors[].min_score (${violation.minScore}) \u4EE5\u4E0A\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+        )
+      );
+    }
+  }
+  return issues;
+}
+async function validateEvaluatorReviewHardFloor(root, config) {
+  const screens = await readUiContractScreenContracts(root, config.paths.contractsDir);
+  if (screens.length === 0) {
+    return [];
+  }
+  const rubricPath = path64.join(root, config.paths.contractsDir, "design", "evaluation-rubric.yaml");
+  const rubric = await readYamlObject(rubricPath);
+  if (rubric.kind !== "ok") {
+    return [];
+  }
+  const hardFloors = loadHardFloors(rubric.value);
+  if (hardFloors.size === 0) {
+    return [];
+  }
+  const issues = [];
+  for (const round of ABSORPTION_ROUNDS) {
+    const roundIssues = await checkRound(root, round, hardFloors);
+    issues.push(...roundIssues);
+  }
+  return issues;
+}
+
 // src/core/validators/uiEvidenceArtifacts.ts
-import path57 from "path";
+import path65 from "path";
 init_utils();
 function resolveEvidenceRoot2(root, config) {
-  return path57.join(path57.dirname(resolvePath(root, config, "specsDir")), "evidence");
+  return path65.join(path65.dirname(resolvePath(root, config, "specsDir")), "evidence");
 }
-function toPosixRelative4(root, targetPath) {
-  return path57.relative(root, targetPath).replace(/\\/g, "/");
+function toPosixRelative5(root, targetPath) {
+  return path65.relative(root, targetPath).replace(/\\/g, "/");
 }
 var SAFE_SCREEN_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/u;
 async function validateUiEvidenceArtifacts(root, config) {
@@ -15019,8 +16897,8 @@ async function validateUiEvidenceArtifacts(root, config) {
     return issues;
   }
   const evidenceRoot = resolveEvidenceRoot2(root, config);
-  const screenshotRoot = path57.join(evidenceRoot, "prototyping", "screenshots");
-  const htmlRoot = path57.join(evidenceRoot, "prototyping", "html");
+  const screenshotRoot = path65.join(evidenceRoot, "prototyping", "screenshots");
+  const htmlRoot = path65.join(evidenceRoot, "prototyping", "html");
   for (const screen of screens) {
     if (!SAFE_SCREEN_ID_PATTERN.test(screen.screenId)) {
       issues.push(
@@ -15037,11 +16915,11 @@ async function validateUiEvidenceArtifacts(root, config) {
       );
       continue;
     }
-    const screenshotPath = path57.join(screenshotRoot, `${screen.screenId}.png`);
-    const htmlPath = path57.join(htmlRoot, `${screen.screenId}.html`);
+    const screenshotPath = path65.join(screenshotRoot, `${screen.screenId}.png`);
+    const htmlPath = path65.join(htmlRoot, `${screen.screenId}.html`);
     if (!await exists5(screenshotPath)) {
-      const screenshotPattern = path57.posix.join(
-        toPosixRelative4(root, screenshotRoot),
+      const screenshotPattern = path65.posix.join(
+        toPosixRelative5(root, screenshotRoot),
         "<screen-id>.png"
       );
       issues.push(
@@ -15049,7 +16927,7 @@ async function validateUiEvidenceArtifacts(root, config) {
           "QFAI-UIE-001",
           `Missing screenshot evidence for declared screen "${screen.screenId}".`,
           "error",
-          toPosixRelative4(root, screenshotPath),
+          toPosixRelative5(root, screenshotPath),
           "uiEvidenceArtifacts.screenshotRequired",
           [screen.sourceRef],
           "canonical",
@@ -15058,13 +16936,13 @@ async function validateUiEvidenceArtifacts(root, config) {
       );
     }
     if (!await exists5(htmlPath)) {
-      const htmlPattern = path57.posix.join(toPosixRelative4(root, htmlRoot), "<screen-id>.html");
+      const htmlPattern = path65.posix.join(toPosixRelative5(root, htmlRoot), "<screen-id>.html");
       issues.push(
         issue(
           "QFAI-UIE-002",
           `Missing HTML snapshot evidence for declared screen "${screen.screenId}".`,
           "error",
-          toPosixRelative4(root, htmlPath),
+          toPosixRelative5(root, htmlPath),
           "uiEvidenceArtifacts.htmlRequired",
           [screen.sourceRef],
           "canonical",
@@ -15083,8 +16961,8 @@ async function isUiBearingSpec(root) {
 }
 
 // src/core/validators/uix/threeLayer.ts
-import { readdir as readdir10 } from "fs/promises";
-import path58 from "path";
+import { readdir as readdir12 } from "fs/promises";
+import path66 from "path";
 init_utils();
 var EXPLORATION_SECTIONS = [
   "product_intent",
@@ -15139,7 +17017,7 @@ async function validateThreeLayerModel(root, _config) {
   if (!await isUiBearingSpec(root)) return [];
   const issues = [];
   for (const sidecar of CANONICAL_REQUIRED_SIDECAR_FILES) {
-    const content = await readSafe(path58.join(root, "uiux", sidecar));
+    const content = await readSafe(path66.join(root, "uiux", sidecar));
     if (!content) {
       continue;
     }
@@ -15181,7 +17059,7 @@ async function validateForbiddenLegacyFiles(root, _config) {
   if (!await isUiBearingSpec(root)) return [];
   let entries = [];
   try {
-    entries = await readdir10(path58.join(root, "uiux"));
+    entries = await readdir12(path66.join(root, "uiux"));
   } catch {
     return [];
   }
@@ -15197,11 +17075,11 @@ async function validateForbiddenLegacyFiles(root, _config) {
 }
 async function validateThreeLayerFamilyCompleteness(root, _config) {
   if (!await isUiBearingSpec(root)) return [];
-  const indexContent = await readSafe(path58.join(root, "uiux", "00_index.md"));
+  const indexContent = await readSafe(path66.join(root, "uiux", "00_index.md"));
   if (!indexContent) return [];
   const issues = [];
   for (const required of CANONICAL_REQUIRED_SIDECAR_FILES) {
-    const content = await readSafe(path58.join(root, "uiux", required));
+    const content = await readSafe(path66.join(root, "uiux", required));
     if (!content) {
       issues.push(
         threeLayerIssue(
@@ -15218,7 +17096,7 @@ async function validateThreeLayerFamilyCompleteness(root, _config) {
 }
 
 // src/core/validators/uix/taste.ts
-import path59 from "path";
+import path67 from "path";
 init_utils();
 var REQUIRED_SECTIONS = [
   "visual_character",
@@ -15235,12 +17113,12 @@ var REQUIRED_SECTIONS = [
 var REQUIRED_SECTION_COUNT = REQUIRED_SECTIONS.length;
 
 // src/core/validators/uix/trendScan.ts
-import path60 from "path";
+import path68 from "path";
 init_utils();
 
 // src/core/validators/uix/strategy.ts
 init_surface();
-import path61 from "path";
+import path69 from "path";
 
 // src/core/domain/strategyDecision.ts
 var CANONICAL_STRATEGY_DECISIONS = [
@@ -15257,9 +17135,9 @@ var CANONICAL_STRATEGY_DECISION_SET = new Set(CANONICAL_STRATEGY_DECISIONS);
 init_utils();
 
 // src/core/validators/uix/screenContract.ts
-import path62 from "path";
+import path70 from "path";
 init_utils();
-var REQUIRED_FIELDS = [
+var REQUIRED_FIELDS2 = [
   "screen_id",
   "route",
   "purpose",
@@ -15388,7 +17266,7 @@ function assignNestedChild(block, key, value) {
 }
 async function validateScreenContractSchema(root, _config) {
   if (!await isUiBearingSpec(root)) return [];
-  const contractsPath = path62.join(root, "uiux", "40_screen_contracts.md");
+  const contractsPath = path70.join(root, "uiux", "40_screen_contracts.md");
   const content = await readSafe(contractsPath);
   if (!content) return [];
   const screens = parseScreenBlocks2(content);
@@ -15424,7 +17302,7 @@ async function validateScreenContractSchema(root, _config) {
       );
       continue;
     }
-    const missing = REQUIRED_FIELDS.filter((f) => {
+    const missing = REQUIRED_FIELDS2.filter((f) => {
       if (f === "primary_tasks") return screen.primaryTasks.length === 0;
       if (f === "secondary_tasks") return screen.secondaryTasks.length === 0;
       if (f === "required_states") return Object.keys(screen.requiredStates).length === 0;
@@ -15462,12 +17340,12 @@ async function validateScreenContractSchema(root, _config) {
 
 // src/core/validators/uix/canonical.ts
 init_utils();
-import path67 from "path";
+import path75 from "path";
 
 // src/core/validators/uix/classification.ts
 init_surfaceType();
 init_utils();
-import path63 from "path";
+import path71 from "path";
 var VALID_PRIMARY_SURFACES = [
   "web",
   "mobile",
@@ -15488,7 +17366,7 @@ function classificationIssue(code, message, severity, file, suggestedAction) {
   };
 }
 async function validateClassification(root, _config) {
-  const contextPath = path63.join(root, "01_Context.md");
+  const contextPath = path71.join(root, "01_Context.md");
   const content = await readSafe(contextPath);
   if (!content) {
     return [];
@@ -15666,8 +17544,8 @@ async function validateClassification(root, _config) {
 }
 
 // src/core/validators/uix/foundation.ts
-import { readdir as readdir11 } from "fs/promises";
-import path64 from "path";
+import { readdir as readdir13 } from "fs/promises";
+import path72 from "path";
 function canonicalIssue2(code, message, severity, file, suggestedAction) {
   return {
     code,
@@ -15681,7 +17559,7 @@ function canonicalIssue2(code, message, severity, file, suggestedAction) {
 async function validateSidecarMissing(root, _config) {
   if (!await isUiBearingSpec(root)) return [];
   try {
-    await readdir11(path64.join(root, "uiux"));
+    await readdir13(path72.join(root, "uiux"));
     return [];
   } catch (err) {
     if (typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT") {
@@ -15700,7 +17578,7 @@ async function validateSidecarMissing(root, _config) {
 }
 
 // src/core/validators/uix/comparisonValidator.ts
-import path65 from "path";
+import path73 from "path";
 init_utils();
 function canonicalIssue3(code, message, severity, file, suggestedAction) {
   return {
@@ -15715,10 +17593,10 @@ function canonicalIssue3(code, message, severity, file, suggestedAction) {
 async function validateExplorationArtifacts(root, _config) {
   if (!await isUiBearingSpec(root)) return [];
   const issues = [];
-  const briefPath = path65.join(root, "uiux", "30_exploration_brief.md");
-  const rubricPath = path65.join(root, "uiux", "33_exploration_rubric.md");
-  const calibrationPath = path65.join(root, "uiux", "34_evaluator_calibration.md");
-  const reviewBundlePath = path65.join(root, "uiux", "50_review_input_bundle.md");
+  const briefPath = path73.join(root, "uiux", "30_exploration_brief.md");
+  const rubricPath = path73.join(root, "uiux", "33_exploration_rubric.md");
+  const calibrationPath = path73.join(root, "uiux", "34_evaluator_calibration.md");
+  const reviewBundlePath = path73.join(root, "uiux", "50_review_input_bundle.md");
   const briefContent = await readSafe(briefPath);
   if (!briefContent) {
     issues.push(
@@ -15818,7 +17696,7 @@ async function validateExplorationArtifacts(root, _config) {
 }
 
 // src/core/validators/uix/oqClosure.ts
-import path66 from "path";
+import path74 from "path";
 init_utils();
 function canonicalIssue4(code, message, severity, file, suggestedAction) {
   return {
@@ -15832,8 +17710,8 @@ function canonicalIssue4(code, message, severity, file, suggestedAction) {
 }
 async function validateOqClosure(root, _config) {
   if (!await isUiBearingSpec(root)) return [];
-  const rootOqPath = path66.join(root, "11_OQ-Register.md");
-  const uiuxOqPath = path66.join(root, "uiux", "11_OQ-Register.md");
+  const rootOqPath = path74.join(root, "11_OQ-Register.md");
+  const uiuxOqPath = path74.join(root, "uiux", "11_OQ-Register.md");
   const rootContent = await readSafe(rootOqPath);
   const content = rootContent || await readSafe(uiuxOqPath);
   if (!content) return [];
@@ -15885,7 +17763,7 @@ async function validateOqClosure(root, _config) {
 
 // src/core/validators/uix/canonical.ts
 async function runCanonicalUixValidators(root, config) {
-  const directSpec = await readSafe(path67.join(root, "01_Spec.md"));
+  const directSpec = await readSafe(path75.join(root, "01_Spec.md"));
   if (!directSpec) {
     return [];
   }
@@ -15912,8 +17790,8 @@ async function runCanonicalUixValidators(root, config) {
 
 // src/core/validators/traceabilityIntegrity.ts
 import { execFileSync } from "child_process";
-import { readFile as readFile43 } from "fs/promises";
-import path68 from "path";
+import { readFile as readFile49 } from "fs/promises";
+import path76 from "path";
 init_utils();
 var BR_AC_FILES = /* @__PURE__ */ new Set(["04_Business-Rules.md", "03_Acceptance-Criteria.md"]);
 function normalizePath2(p) {
@@ -15997,10 +17875,10 @@ async function validateTraceabilityIntegrity(root, config) {
   const specsRelDir = config.paths.specsDir;
   const changedSpecIds = findChangedSpecDirs(changedFiles, specsRelDir);
   for (const specId of changedSpecIds) {
-    const ledgerPath = path68.join(specsDir, specId, "16_Traceability-ledger.md");
+    const ledgerPath = path76.join(specsDir, specId, "16_Traceability-ledger.md");
     let ledgerContent;
     try {
-      ledgerContent = await readFile43(ledgerPath, "utf-8");
+      ledgerContent = await readFile49(ledgerPath, "utf-8");
     } catch {
       issues.push(
         issue(
@@ -16256,16 +18134,187 @@ function validatePrototypingSkillContent(content) {
   };
 }
 
+// src/core/validators/testTodoStubs.ts
+import { readFile as readFile50 } from "fs/promises";
+import path77 from "path";
+init_utils();
+var TEST_TODO_PATTERN = /\b(it|test|describe)\.todo\s*\(/g;
+async function validateTestTodoStubs(root, config) {
+  if (!config.validation.testStrategy.forbidTestTodoStubs) {
+    return [];
+  }
+  const globs = config.validation.traceability.testFileGlobs;
+  if (globs.length === 0) {
+    return [];
+  }
+  const excludeGlobs = Array.from(
+    /* @__PURE__ */ new Set([
+      ...DEFAULT_TEST_FILE_EXCLUDE_GLOBS,
+      ...config.validation.traceability.testFileExcludeGlobs
+    ])
+  );
+  const { files } = await collectFilesByGlobs(root, {
+    globs,
+    ignore: excludeGlobs,
+    limit: DEFAULT_GLOB_FILE_LIMIT
+  });
+  const issues = [];
+  for (const absFile of files) {
+    const relFile = path77.relative(root, absFile).replace(/\\/g, "/");
+    let content;
+    try {
+      content = await readFile50(absFile, "utf-8");
+    } catch {
+      continue;
+    }
+    const lines = content.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i += 1) {
+      const line = lines[i] ?? "";
+      const lineNumber = i + 1;
+      for (const match of line.matchAll(TEST_TODO_PATTERN)) {
+        const matchedKind = match[1];
+        const stubIssue = issue(
+          "QFAI-TEST-001",
+          `Test todo stub found: ${matchedKind}.todo at ${relFile}:${lineNumber}. Stubs are silent in vitest/jest and rot as missed work. Implement the body or delete the stub (spec-0017 REQ-0009).`,
+          "error",
+          relFile,
+          "validation.testStrategy.forbidTestTodoStubs",
+          [`${matchedKind}.todo`],
+          "canonical",
+          "Implement the test body, or delete the stub entirely. If you need to temporarily opt out of this check, set `validation.testStrategy.forbidTestTodoStubs: false` in qfai.config.yaml."
+        );
+        stubIssue.loc = { line: lineNumber };
+        issues.push(stubIssue);
+      }
+    }
+  }
+  return issues;
+}
+
 // src/core/validate.ts
 init_utils();
 var UIUX_VALIDATION_BUDGET_MS = 2e3;
 async function validateProject(root, configResult, options = {}) {
   const resolved = configResult ?? await loadConfig(root);
   const { config, issues: configIssues } = resolved;
-  const phase = options.phase ?? "full";
-  const atddCodeTraceabilityIssues = phase === "refinement" ? [] : await validateAtddCodeTraceability(root, config);
+  const profile = options.profile ?? "full";
+  const findings = [
+    ...configIssues,
+    ...await runProfileValidators(root, config, profile, options.platform)
+  ];
+  const { issues, waivers } = await applyWaivers(root, findings);
+  const specsRoot = resolvePath(root, config, "specsDir");
+  const scenarioFiles = await collectScenarioFiles(specsRoot);
+  const scIds = await collectScIdsFromScenarioFiles(scenarioFiles);
+  const { refs: scTestRefs, scan: testFiles } = await collectScTestReferences(
+    root,
+    config.validation.traceability.testFileGlobs,
+    config.validation.traceability.testFileExcludeGlobs
+  );
+  const scCoverage = buildScCoverage(scIds, scTestRefs);
+  const toolVersion = await resolveToolVersion();
+  return {
+    toolVersion,
+    profile,
+    issues,
+    counts: countIssues(issues),
+    traceability: {
+      sc: scCoverage,
+      testFiles
+    },
+    waivers
+  };
+}
+async function runProfileValidators(root, config, profile, platformOption) {
+  switch (profile) {
+    case "discussion":
+      return runDiscussionValidators(root, config);
+    case "sdd":
+      return runSddValidators(root, config);
+    case "prototyping":
+      return runPrototypingValidators(root, config, platformOption);
+    case "atdd":
+      return runAtddValidators(root, config);
+    case "tdd":
+      return runTddValidators(root, config);
+    case "verify":
+    case "full":
+      return runFullValidators(root, config, platformOption);
+  }
+}
+async function runDiscussionValidators(root, config) {
+  return [
+    ...await validateDiscussionMermaid(root),
+    ...await validateDiscussionPackReadiness(root, config),
+    ...await validateDiscussionVisuals(root),
+    ...await validateDiscussionDesignHardening(root, config),
+    ...await validateResearchSummary(root, config),
+    ...await runCanonicalUixValidators(root, config)
+  ];
+}
+async function runSddValidators(root, config, includeCodeReferences = false) {
+  return [
+    ...await validateMermaidEnforcement(root),
+    ...await validateSpecPacks(root, config),
+    ...await validateStatusInSpecs(root, config),
+    ...await validateDensityHints(root, config),
+    ...await validateSpecSplitByCapability(root, config),
+    ...await validateLayeredTraceability(root, config),
+    ...await validateOrphanProhibition(root, config),
+    ...await validateLayerCoverage(root, config),
+    ...await validateContractReferences(root, config),
+    ...await validateTraceability(root, config, { includeCodeReferences }),
+    ...await validateDefinedIds(root, config),
+    ...await validateContracts(root, config),
+    ...await validateNavigationFlow(root, config)
+  ];
+}
+async function runPrototypingValidators(root, config, platformOption) {
+  return [
+    ...await runUiuxValidators(root, config, platformOption),
+    ...await validatePrototypingEvidence(root, config),
+    ...await validateBreakthroughEvidence(root, config),
+    ...await validatePrototypingDesignSystem(root, config),
+    ...await validateUiEvidenceArtifacts(root, config),
+    ...await validateRenderCritique(root, config),
+    ...await validateDesignFidelity(root, config),
+    ...await validateDesignContractReadiness(root, config),
+    ...await validateEvaluatorReviewHardFloor(root, config),
+    ...await validateStateGate(root, config),
+    ...await validateCompletionCertificateIssues(root, config),
+    ...await validateConfigReferenceIntegrity(root, config),
+    ...await validatePrototypingArtifactRefIntegrity(root, config),
+    ...await validateSpecIdLinkage(root, config)
+  ];
+}
+async function runAtddValidators(root, config) {
+  return [...await validateAtddCodeTraceability(root, config)];
+}
+async function runTddValidators(root, config, includeTraceability = true) {
+  return [
+    ...await validateTddList(root, config),
+    ...await validateTestTodoStubs(root, config),
+    ...includeTraceability ? await validateTraceability(root, config, { includeCodeReferences: true }) : [],
+    ...await validateTraceabilityIntegrity(root, config)
+  ];
+}
+async function runFullValidators(root, config, platformOption) {
+  return [
+    ...await validateRepositoryHygiene(root, config),
+    ...await validateSkillsIntegrity(root, config),
+    ...await validateAssistantAssets(root, config),
+    ...await runDiscussionValidators(root, config),
+    ...await runSddValidators(root, config, true),
+    ...await validateReviewArtifacts(root),
+    ...await runPrototypingValidators(root, config, platformOption),
+    ...await runAtddValidators(root, config),
+    ...await runTddValidators(root, config, false),
+    ...await validatePrototypingSkill(root, config)
+  ];
+}
+async function runUiuxValidators(root, config, platformOption) {
   const uiuxStart = performance.now();
-  const platformResult = await detectPlatform(root, config, options.platform);
+  const platformResult = await detectPlatform(root, config, platformOption);
   const platform = platformResult.platform;
   const uiuxValidators = [
     () => validateDesignToken(root, config),
@@ -16291,68 +18340,13 @@ async function validateProject(root, configResult, options = {}) {
       rule: "uiux.performanceBudget"
     });
   }
+  return uiuxIssues;
+}
+async function validatePrototypingSkill(root, config) {
   const skillsDir = resolvePath(root, config, "skillsDir");
-  const prototypingSkillPath = path69.join(skillsDir, "qfai-prototyping", "SKILL.md");
+  const prototypingSkillPath = path78.join(skillsDir, "qfai-prototyping", "SKILL.md");
   const prototypingSkillContent = await readSafe(prototypingSkillPath);
-  const prototypingSkillResult = prototypingSkillContent.length > 0 ? validatePrototypingSkillContent(prototypingSkillContent) : { issues: [] };
-  const findings = [
-    ...configIssues,
-    ...await validateRepositoryHygiene(root, config),
-    ...await validateSkillsIntegrity(root, config),
-    ...await validateAssistantAssets(root, config),
-    ...await validateDiscussionMermaid(root),
-    ...await validateMermaidEnforcement(root),
-    ...await validateSpecPacks(root, config),
-    ...await validateDiscussionPackReadiness(root, config),
-    ...await validateDiscussionVisuals(root),
-    ...await validateStatusInSpecs(root, config),
-    ...await validateDensityHints(root, config),
-    ...await validateReviewArtifacts(root),
-    ...await validatePrototypingEvidence(root, config),
-    ...await validateBreakthroughEvidence(root, config),
-    ...await validatePrototypingDesignSystem(root, config),
-    ...await validateUiEvidenceArtifacts(root, config),
-    ...await validateSpecSplitByCapability(root, config),
-    ...await validateLayeredTraceability(root, config),
-    ...await validateOrphanProhibition(root, config),
-    ...await validateLayerCoverage(root, config),
-    ...atddCodeTraceabilityIssues,
-    ...await validateContractReferences(root, config),
-    ...await validateTraceability(root, config, phase),
-    ...await validateDefinedIds(root, config),
-    ...await validateContracts(root, config),
-    ...await validateTddList(root, config),
-    ...await validateDiscussionDesignHardening(root, config),
-    ...await validateNavigationFlow(root, config),
-    ...await validateRenderCritique(root, config),
-    ...await validateDesignFidelity(root, config),
-    ...await validateDesignContractReadiness(root, config),
-    ...await validateTraceabilityIntegrity(root, config),
-    ...prototypingSkillResult.issues,
-    ...uiuxIssues
-  ];
-  const { issues, waivers } = await applyWaivers(root, findings);
-  const specsRoot = resolvePath(root, config, "specsDir");
-  const scenarioFiles = await collectScenarioFiles(specsRoot);
-  const scIds = await collectScIdsFromScenarioFiles(scenarioFiles);
-  const { refs: scTestRefs, scan: testFiles } = await collectScTestReferences(
-    root,
-    config.validation.traceability.testFileGlobs,
-    config.validation.traceability.testFileExcludeGlobs
-  );
-  const scCoverage = buildScCoverage(scIds, scTestRefs);
-  const toolVersion = await resolveToolVersion();
-  return {
-    toolVersion,
-    phase,
-    issues,
-    counts: countIssues(issues),
-    traceability: {
-      sc: scCoverage,
-      testFiles
-    },
-    waivers
-  };
+  return prototypingSkillContent.length > 0 ? validatePrototypingSkillContent(prototypingSkillContent).issues : [];
 }
 function countIssues(issues) {
   return issues.reduce(
@@ -16368,11 +18362,11 @@ function countIssues(issues) {
 }
 
 // src/core/uiux/renderEvidence.ts
-import { readFile as readFile44 } from "fs/promises";
+import { readFile as readFile51 } from "fs/promises";
 async function readRenderEvidenceBundle(filePath) {
   let raw;
   try {
-    raw = await readFile44(filePath, "utf-8");
+    raw = await readFile51(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -16382,9 +18376,9 @@ async function readRenderEvidenceBundle(filePath) {
   } catch {
     return null;
   }
-  return isRecord7(parsed) ? parsed : null;
+  return isRecord17(parsed) ? parsed : null;
 }
-function isRecord7(value) {
+function isRecord17(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function summarizeRenderEvidence(bundle) {
@@ -16392,7 +18386,7 @@ function summarizeRenderEvidence(bundle) {
   let inlinePayloadViolation = false;
   if (bundle?.screens) {
     for (const screen of bundle.screens) {
-      if (isRecord7(screen)) {
+      if (isRecord17(screen)) {
         const s = screen;
         if (s.status === "captured" || s.status === "skipped" || s.status === "failed") {
           counts[s.status] += 1;
@@ -16417,7 +18411,7 @@ function summarizeRenderEvidence(bundle) {
 }
 
 // src/core/browserQa/index.ts
-import { readFile as readFile45 } from "fs/promises";
+import { readFile as readFile52 } from "fs/promises";
 
 // src/core/browserQa/types.ts
 var BROWSER_QA_PHASES = [
@@ -16980,7 +18974,7 @@ function summarizeBrowserQaResult(result) {
 async function readBrowserQaBundle(filePath) {
   let raw;
   try {
-    raw = await readFile45(filePath, "utf-8");
+    raw = await readFile52(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -16990,9 +18984,9 @@ async function readBrowserQaBundle(filePath) {
   } catch {
     return null;
   }
-  return isRecord8(parsed) ? parsed : null;
+  return isRecord18(parsed) ? parsed : null;
 }
-function isRecord8(value) {
+function isRecord18(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 
@@ -17001,15 +18995,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 = path70.resolve(root);
+  const resolvedRoot = path79.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 = path70.join(contractsRoot, "api");
-  const uiRoot = path70.join(contractsRoot, "ui");
-  const dbRoot = path70.join(contractsRoot, "db");
+  const apiRoot = path79.join(contractsRoot, "api");
+  const uiRoot = path79.join(contractsRoot, "ui");
+  const dbRoot = path79.join(contractsRoot, "db");
   const srcRoot = resolvePath(resolvedRoot, config, "srcDir");
   const testsRoot = resolvePath(resolvedRoot, config, "testsDir");
   const specEntries = await collectSpecEntries(specsRoot);
@@ -17806,6 +19800,28 @@ function formatReportMarkdown(data, options = {}) {
       );
       lines.push("");
     }
+    if (data.prototyping.roundLifecycle) {
+      const lifecycle = data.prototyping.roundLifecycle;
+      lines.push("### prototyping.roundLifecycle");
+      lines.push("");
+      lines.push(`- schemaVersion: ${lifecycle.schemaVersion}`);
+      lines.push(`- rounds: ${lifecycle.rounds}`);
+      lines.push(`- round ids: ${lifecycle.roundIds.join(", ") || "(none)"}`);
+      lines.push(`- candidates observed: ${lifecycle.candidatesObserved}`);
+      lines.push(`- harvest artifacts: ${lifecycle.harvestArtifacts}`);
+      lines.push(`- narrow decisions: ${lifecycle.narrowDecisions}`);
+      lines.push(`- absorption plans: ${lifecycle.absorptionPlans}`);
+      lines.push(`- reimplementations: ${lifecycle.reimplementations}`);
+      lines.push(`- perfect rounds: ${lifecycle.perfectRounds}`);
+      lines.push(`- polish cycles: ${lifecycle.polishCycles}`);
+      lines.push(`- completed polish cycles: ${lifecycle.completedPolishCycles}`);
+      lines.push(`- perfect polish cycles: ${lifecycle.perfectPolishCycles}`);
+      if (Object.keys(lifecycle.polishKinds).length > 0) {
+        const kinds = Object.entries(lifecycle.polishKinds).map(([kind, count]) => `${kind}=${count}`).join(", ");
+        lines.push(`- polish kinds: ${kinds}`);
+      }
+      lines.push("");
+    }
     lines.push("### prototyping.mode");
     lines.push("");
     lines.push(`- requested: ${data.prototyping.mode.requested ?? "(none)"}`);
@@ -18162,7 +20178,7 @@ async function collectChangeTypeSummary(specsRoot) {
   };
   const deltaFiles = await collectDeltaFiles(specsRoot);
   for (const deltaFile of deltaFiles) {
-    const text = await readFile46(deltaFile, "utf-8");
+    const text = await readFile53(deltaFile, "utf-8");
     const parsed = parseDeltaV1(text);
     for (const entry of parsed.entries) {
       if (!entry.meta) {
@@ -18191,13 +20207,46 @@ async function collectChangeTypeSummary(specsRoot) {
   }
   return summary;
 }
+var PROTOTYPING_ROUND_DIR_NAMES = new Set(EXPLORATION_ROUNDS);
+async function scanPrototypingRoundsFilesystem(evidenceRoot) {
+  const result = {
+    observedRoundIds: [],
+    harvestArtifacts: 0,
+    narrowDecisions: 0,
+    absorptionPlans: 0,
+    reimplementations: 0
+  };
+  const roundsDir = path79.join(evidenceRoot, "prototyping", "rounds");
+  const { readdir: readdir14 } = await import("fs/promises");
+  let entries;
+  try {
+    entries = await readdir14(roundsDir);
+  } catch {
+    return result;
+  }
+  for (const name of entries.sort()) {
+    if (!PROTOTYPING_ROUND_DIR_NAMES.has(name)) continue;
+    let files;
+    try {
+      files = await readdir14(path79.join(roundsDir, name));
+    } catch {
+      continue;
+    }
+    result.observedRoundIds.push(name);
+    if (files.includes("harvest.json")) result.harvestArtifacts += 1;
+    if (files.includes("narrow-decision.json")) result.narrowDecisions += 1;
+    if (files.includes("absorption-plan.json")) result.absorptionPlans += 1;
+    if (files.includes("reimplementation.json")) result.reimplementations += 1;
+  }
+  return result;
+}
 async function collectPrototypingSummary(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
-  const evidenceRoot = path70.join(path70.dirname(specsRoot), "evidence");
-  const evidencePath = path70.join(evidenceRoot, "prototyping.json");
+  const evidenceRoot = path79.join(path79.dirname(specsRoot), "evidence");
+  const evidencePath = path79.join(evidenceRoot, "prototyping.json");
   let raw;
   try {
-    raw = await readFile46(evidencePath, "utf-8");
+    raw = await readFile53(evidencePath, "utf-8");
   } catch {
     return void 0;
   }
@@ -18224,10 +20273,12 @@ async function collectPrototypingSummary(root, config) {
   const warnings = [];
   const obligations = derivePrototypingObligations({ surface: effectiveSurface, effectiveMode });
   const fullHarness = asRecord2(record2.fullHarness);
+  const rounds = Array.isArray(record2.rounds) ? record2.rounds : [];
+  const polishCycles = Array.isArray(record2.polishCycles) ? record2.polishCycles : [];
   const runtimeGate = asRecord2(record2.runtimeGate);
   const uiFidelity = asRecord2(record2.uiFidelity);
-  const renderBundle = await readRenderEvidenceBundle(path70.join(evidenceRoot, "render.json"));
-  const browserQaBundle = await readBrowserQaBundle(path70.join(evidenceRoot, "browser-qa.json"));
+  const renderBundle = await readRenderEvidenceBundle(path79.join(evidenceRoot, "render.json"));
+  const browserQaBundle = await readBrowserQaBundle(path79.join(evidenceRoot, "browser-qa.json"));
   const specs = Array.isArray(record2.specs) ? record2.specs : [];
   const specEntries = await collectSpecEntries(specsRoot);
   const expectedSpecIds = specEntries.map((entry) => `spec-${entry.specNumber}`.toLowerCase());
@@ -18284,8 +20335,81 @@ async function collectPrototypingSummary(root, config) {
     ...classificationBlock?.secondary_surfaces?.length ? { secondarySurfaces: classificationBlock.secondary_surfaces } : {},
     ...classificationBlock?.classification_rationale ? { classificationRationale: classificationBlock.classification_rationale } : {}
   };
+  const fsRoundScan = await scanPrototypingRoundsFilesystem(evidenceRoot);
+  const roundLifecycle = record2.schemaVersion === "2.0" || rounds.length > 0 || polishCycles.length > 0 || fsRoundScan.observedRoundIds.length > 0 ? (() => {
+    const polishKinds = {};
+    let candidatesObserved = 0;
+    let perfectRounds = 0;
+    let completedPolishCycles = 0;
+    let perfectPolishCycles = 0;
+    for (const item of rounds) {
+      const round = asRecord2(item);
+      if (!round) {
+        continue;
+      }
+      const candidates = Array.isArray(round.candidates) ? round.candidates : [];
+      candidatesObserved += candidates.length;
+      if (round.allAxesPerfect100 === true) {
+        perfectRounds += 1;
+      }
+    }
+    for (const item of polishCycles) {
+      const cycle = asRecord2(item);
+      if (!cycle) {
+        continue;
+      }
+      if (typeof cycle.kind === "string" && cycle.kind.length > 0) {
+        polishKinds[cycle.kind] = (polishKinds[cycle.kind] ?? 0) + 1;
+        if (cycle.kind === "completed") {
+          completedPolishCycles += 1;
+        }
+      }
+      if (cycle.allAxesPerfect100 === true) {
+        perfectPolishCycles += 1;
+      }
+    }
+    const indexAbsorptionRefs = rounds.map((item) => asRecord2(item)).filter(
+      (round) => round && typeof round.absorptionPlanRef === "string" && round.absorptionPlanRef.length > 0
+    ).length;
+    if (indexAbsorptionRefs !== fsRoundScan.absorptionPlans) {
+      warnings.push(
+        `prototyping.json index references ${indexAbsorptionRefs} absorption-plan(s) but filesystem has ${fsRoundScan.absorptionPlans}; counts use filesystem (canonical SoT).`
+      );
+    }
+    const indexReimplRefs = rounds.map((item) => asRecord2(item)).filter(
+      (round) => round && typeof round.reimplementationRef === "string" && round.reimplementationRef.length > 0
+    ).length;
+    if (indexReimplRefs !== fsRoundScan.reimplementations) {
+      warnings.push(
+        `prototyping.json index references ${indexReimplRefs} reimplementation record(s) but filesystem has ${fsRoundScan.reimplementations}; counts use filesystem (canonical SoT).`
+      );
+    }
+    const indexRoundIds = rounds.map((item) => asRecord2(item)).flatMap(
+      (round) => round && typeof round.round === "string" && round.round.length > 0 ? [round.round] : []
+    );
+    const roundIdSet = /* @__PURE__ */ new Set([...indexRoundIds, ...fsRoundScan.observedRoundIds]);
+    return {
+      schemaVersion: "2.0",
+      // Use the union size — Math.max underestimates when index and
+      // filesystem describe disjoint round IDs (Copilot MAJOR review
+      // on PR #201).
+      rounds: roundIdSet.size,
+      roundIds: Array.from(roundIdSet),
+      candidatesObserved,
+      perfectRounds,
+      harvestArtifacts: fsRoundScan.harvestArtifacts,
+      narrowDecisions: fsRoundScan.narrowDecisions,
+      absorptionPlans: fsRoundScan.absorptionPlans,
+      reimplementations: fsRoundScan.reimplementations,
+      polishCycles: polishCycles.length,
+      completedPolishCycles,
+      perfectPolishCycles,
+      polishKinds
+    };
+  })() : void 0;
   return {
     surfaceClassification,
+    ...roundLifecycle ? { roundLifecycle } : {},
     mode: {
       ...resolvedMode.requested ? { requested: resolvedMode.requested } : {},
       effective: effectiveMode,
@@ -18378,7 +20502,7 @@ async function collectSpecContractRefs(specFiles, contractIdList) {
     idToSpecs.set(contractId, /* @__PURE__ */ new Set());
   }
   for (const file of specFiles) {
-    const text = await readFile46(file, "utf-8");
+    const text = await readFile53(file, "utf-8");
     const parsed = parseSpec(text, file);
     const specKey = parsed.specId;
     if (!specKey) {
@@ -18415,7 +20539,7 @@ async function collectIds(files) {
     result[prefix] = /* @__PURE__ */ new Set();
   }
   for (const file of files) {
-    const text = await readFile46(file, "utf-8");
+    const text = await readFile53(file, "utf-8");
     for (const prefix of ID_PREFIXES) {
       const ids = extractIds(text, prefix);
       ids.forEach((id) => result[prefix].add(id));
@@ -18430,7 +20554,7 @@ async function collectIds(files) {
 async function collectUpstreamIds(files) {
   const ids = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const text = await readFile46(file, "utf-8");
+    const text = await readFile53(file, "utf-8");
     extractAllIds(text).forEach((id) => ids.add(id));
   }
   return ids;
@@ -18451,7 +20575,7 @@ async function evaluateTraceability(upstreamIds, srcRoot, testsRoot) {
   }
   const pattern = buildIdPattern(Array.from(upstreamIds));
   for (const file of targetFiles) {
-    const text = await readFile46(file, "utf-8");
+    const text = await readFile53(file, "utf-8");
     if (pattern.test(text)) {
       return true;
     }
@@ -18573,7 +20697,7 @@ function normalizeScSources(root, sources) {
 async function countScenarios(scenarioFiles) {
   let total = 0;
   for (const file of scenarioFiles) {
-    const text = await readFile46(file, "utf-8");
+    const text = await readFile53(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -18604,7 +20728,7 @@ async function collectTestStrategy(scenarioFiles, root, config, limit) {
   let totalScenarios = 0;
   let e2eCount = 0;
   for (const file of scenarioFiles) {
-    const text = await readFile46(file, "utf-8");
+    const text = await readFile53(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -18692,10 +20816,10 @@ function buildHotspots(issues) {
 async function collectTddCoverage(entries) {
   const specs = [];
   for (const entry of entries) {
-    const testCasesPath = path70.join(entry.dir, "06_Test-Cases.md");
+    const testCasesPath = path79.join(entry.dir, "06_Test-Cases.md");
     let tcContent;
     try {
-      tcContent = await readFile46(testCasesPath, "utf-8");
+      tcContent = await readFile53(testCasesPath, "utf-8");
     } catch {
       continue;
     }
@@ -18727,10 +20851,10 @@ async function collectTddCoverage(entries) {
       });
       continue;
     }
-    const tddListPath = path70.join(entry.dir, "tdd", "test-list.md");
+    const tddListPath = path79.join(entry.dir, "tdd", "test-list.md");
     let tddContent;
     try {
-      tddContent = await readFile46(tddListPath, "utf-8");
+      tddContent = await readFile53(tddListPath, "utf-8");
     } catch {
       specs.push({
         specNumber: entry.specNumber,
@@ -18881,16 +21005,16 @@ async function runRenderCapture(targets, outputDir, adapter, options) {
 }
 
 // src/core/evidence/bundleWriter.ts
-import { mkdir as mkdir5 } from "fs/promises";
-import path72 from "path";
+import { mkdir as mkdir6 } from "fs/promises";
+import path81 from "path";
 
 // src/core/evidence/fsEvidenceWriter.ts
-import { writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
-import path71 from "path";
+import { writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
+import path80 from "path";
 async function writeEvidenceFile(filePath, content) {
   try {
-    await mkdir4(path71.dirname(filePath), { recursive: true });
-    await writeFile4(filePath, content);
+    await mkdir5(path80.dirname(filePath), { recursive: true });
+    await writeFile5(filePath, content);
     return { path: filePath, written: true };
   } catch (error) {
     return {
@@ -18902,20 +21026,20 @@ async function writeEvidenceFile(filePath, content) {
 }
 
 // src/core/evidence/bundleWriter.ts
-function toPosixRelative5(root, targetPath) {
-  return path72.relative(root, targetPath).replace(/\\/g, "/");
+function toPosixRelative6(root, targetPath) {
+  return path81.relative(root, targetPath).replace(/\\/g, "/");
 }
 async function writeEvidenceBundles(input) {
-  const evidenceRoot = path72.join(input.root, ".qfai", "evidence");
-  const renderAssetRoot = path72.join(evidenceRoot, "render");
-  await mkdir5(renderAssetRoot, { recursive: true });
-  const prototypingPath = path72.join(evidenceRoot, "prototyping.json");
-  const renderPath = path72.join(evidenceRoot, "render.json");
-  const browserQaPath = path72.join(evidenceRoot, "browser-qa.json");
-  const browserQaSummaryPath = path72.join(evidenceRoot, "browserQa.summary.json");
-  const browserQaFindingsPath = path72.join(evidenceRoot, "browserQa.findings.json");
-  const browserQaRepairsPath = path72.join(evidenceRoot, "browserQa.repairs.json");
-  const breakthroughPath = path72.join(evidenceRoot, "breakthrough.json");
+  const evidenceRoot = path81.join(input.root, ".qfai", "evidence");
+  const renderAssetRoot = path81.join(evidenceRoot, "render");
+  await mkdir6(renderAssetRoot, { recursive: true });
+  const prototypingPath = path81.join(evidenceRoot, "prototyping.json");
+  const renderPath = path81.join(evidenceRoot, "render.json");
+  const browserQaPath = path81.join(evidenceRoot, "browser-qa.json");
+  const browserQaSummaryPath = path81.join(evidenceRoot, "browserQa.summary.json");
+  const browserQaFindingsPath = path81.join(evidenceRoot, "browserQa.findings.json");
+  const browserQaRepairsPath = path81.join(evidenceRoot, "browserQa.repairs.json");
+  const breakthroughPath = path81.join(evidenceRoot, "breakthrough.json");
   const renderBundle = input.render === void 0 ? {
     renderEvidence: {
       status: "skipped",
@@ -18937,7 +21061,7 @@ async function writeEvidenceBundles(input) {
   await Promise.all([
     writeEvidenceFile(prototypingPath, JSON.stringify(input.prototyping, null, 2)),
     writeEvidenceFile(
-      path72.join(evidenceRoot, "prototyping.md"),
+      path81.join(evidenceRoot, "prototyping.md"),
       buildPrototypingMarkdown(input.prototyping)
     ),
     writeEvidenceFile(renderPath, JSON.stringify(renderBundle, null, 2)),
@@ -18954,15 +21078,15 @@ async function writeEvidenceBundles(input) {
     writeEvidenceFile(breakthroughPath, JSON.stringify(input.prototyping.breakthrough, null, 2)),
     ...input.fullHarnessArtifacts ? [
       writeEvidenceFile(
-        path72.join(evidenceRoot, "fullHarness.fakeUiDetection.json"),
+        path81.join(evidenceRoot, "fullHarness.fakeUiDetection.json"),
         JSON.stringify(input.fullHarnessArtifacts.fakeUiDetection, null, 2)
       ),
       writeEvidenceFile(
-        path72.join(evidenceRoot, "fullHarness.handoff.json"),
+        path81.join(evidenceRoot, "fullHarness.handoff.json"),
         JSON.stringify(input.fullHarnessArtifacts.handoff, null, 2)
       ),
       writeEvidenceFile(
-        path72.join(evidenceRoot, "fullHarness.exit.json"),
+        path81.join(evidenceRoot, "fullHarness.exit.json"),
         JSON.stringify({ exit_reason: input.fullHarnessArtifacts.exitReason }, null, 2)
       )
     ] : []
@@ -18976,8 +21100,8 @@ function buildRenderBundle(root, input) {
     status: entry.status,
     width: 1440,
     height: 900,
-    ...entry.screenshot_path ? { imagePath: toPosixRelative5(root, entry.screenshot_path) } : {},
-    ...entry.html_path ? { htmlPath: toPosixRelative5(root, entry.html_path) } : {},
+    ...entry.screenshot_path ? { imagePath: toPosixRelative6(root, entry.screenshot_path) } : {},
+    ...entry.html_path ? { htmlPath: toPosixRelative6(root, entry.html_path) } : {},
     ...entry.reason ? entry.status === "failed" ? { error: entry.reason } : { skippedReason: entry.reason } : {}
   }));
   const topStatus = screens.some((screen) => screen.status === "captured") ? "captured" : screens.some((screen) => screen.status === "failed") ? "failed" : "skipped";
@@ -19062,15 +21186,15 @@ function buildPrototypingMarkdown(bundle) {
 }
 
 // src/core/harness/history.ts
-import { readFile as readFile47 } from "fs/promises";
-import path73 from "path";
+import { readFile as readFile54 } from "fs/promises";
+import path82 from "path";
 var EVIDENCE_PATH = ".qfai/evidence/prototyping.json";
 async function loadHistory(root) {
   try {
-    const filePath = path73.join(root, EVIDENCE_PATH);
-    const content = await readFile47(filePath, "utf-8");
+    const filePath = path82.join(root, EVIDENCE_PATH);
+    const content = await readFile54(filePath, "utf-8");
     const parsed = JSON.parse(content);
-    if (isRecord9(parsed) && isRecord9(parsed.fullHarness)) {
+    if (isRecord19(parsed) && isRecord19(parsed.fullHarness)) {
       const fh = parsed.fullHarness;
       if (Array.isArray(fh.iterations)) {
         return {
@@ -19119,7 +21243,7 @@ function computeTerminationReason(history, iterationPolicy) {
     return void 0;
   }
   const latestIteration = history.iterations[count - 1];
-  if (latestIteration?.allItemsPass95) {
+  if (latestIteration && hasAllReviewerAxesPerfect100(latestIteration.reviewerScores)) {
     return "converged";
   }
   if (count >= iterationPolicy.maxIterations) {
@@ -19131,6 +21255,7 @@ function buildScoreSnapshot(iteration) {
   const axisScores = iteration.reviewerScores.flatMap(
     (reviewer) => reviewer.scores.map((score) => score.score)
   );
+  const allReviewerAxesPerfect100 = hasAllReviewerAxesPerfect100(iteration.reviewerScores);
   if (axisScores.length === 0) {
     return {
       iteration: iteration.iteration,
@@ -19138,7 +21263,7 @@ function buildScoreSnapshot(iteration) {
       axisCount: 0,
       minScore: null,
       averageScore: null,
-      allItemsPass95: iteration.allItemsPass95,
+      allReviewerAxesPerfect100: false,
       commitSha: iteration.commitSha
     };
   }
@@ -19149,13 +21274,13 @@ function buildScoreSnapshot(iteration) {
     axisCount: axisScores.length,
     minScore: Math.min(...axisScores),
     averageScore: total / axisScores.length,
-    allItemsPass95: iteration.allItemsPass95,
+    allReviewerAxesPerfect100,
     commitSha: iteration.commitSha
   };
 }
 function compareSnapshots(left, right) {
-  if (left.allItemsPass95 !== right.allItemsPass95) {
-    return left.allItemsPass95 ? 1 : -1;
+  if (left.allReviewerAxesPerfect100 !== right.allReviewerAxesPerfect100) {
+    return left.allReviewerAxesPerfect100 ? 1 : -1;
   }
   const leftMin = left.minScore ?? -1;
   const rightMin = right.minScore ?? -1;
@@ -19169,7 +21294,15 @@ function compareSnapshots(left, right) {
   }
   return left.iteration - right.iteration;
 }
-function isRecord9(value) {
+function hasAllReviewerAxesPerfect100(reviewerScores) {
+  if (reviewerScores.length === 0) {
+    return false;
+  }
+  return reviewerScores.every(
+    (reviewer) => reviewer.scores.length > 0 && reviewer.scores.every((score) => score.score === 100)
+  );
+}
+function isRecord19(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -19204,16 +21337,16 @@ function validateReviewer(reviewer) {
 }
 
 // src/core/harness/gitRevision.ts
-import { readFile as readFile48, stat as stat7 } from "fs/promises";
-import path74 from "path";
+import { readFile as readFile55, stat as stat11 } from "fs/promises";
+import path83 from "path";
 async function resolveGitDirs(root) {
-  const dotGit = path74.join(root, ".git");
-  const info = await stat7(dotGit);
+  const dotGit = path83.join(root, ".git");
+  const info = await stat11(dotGit);
   const gitDir = info.isDirectory() ? dotGit : await resolveWorktreeGitDir(root, dotGit);
   try {
-    const commondirText = (await readFile48(path74.join(gitDir, "commondir"), "utf-8")).trim();
+    const commondirText = (await readFile55(path83.join(gitDir, "commondir"), "utf-8")).trim();
     if (commondirText.length > 0) {
-      const commonDir = path74.isAbsolute(commondirText) ? commondirText : path74.resolve(gitDir, commondirText);
+      const commonDir = path83.isAbsolute(commondirText) ? commondirText : path83.resolve(gitDir, commondirText);
       return { gitDir, commonDir };
     }
   } catch {
@@ -19221,18 +21354,18 @@ async function resolveGitDirs(root) {
   return { gitDir, commonDir: gitDir };
 }
 async function resolveWorktreeGitDir(root, dotGitFile) {
-  const text = (await readFile48(dotGitFile, "utf-8")).trim();
+  const text = (await readFile55(dotGitFile, "utf-8")).trim();
   const match = /^gitdir:\s*(.+)$/m.exec(text);
   if (!match?.[1]) {
     throw new Error(`Unrecognized .git file format at ${dotGitFile}`);
   }
   const gitdirValue = match[1].trim();
-  return path74.isAbsolute(gitdirValue) ? gitdirValue : path74.resolve(root, gitdirValue);
+  return path83.isAbsolute(gitdirValue) ? gitdirValue : path83.resolve(root, gitdirValue);
 }
 async function lookupPackedRef(commonDir, refName) {
   try {
-    const packedPath = path74.join(commonDir, "packed-refs");
-    const content = await readFile48(packedPath, "utf-8");
+    const packedPath = path83.join(commonDir, "packed-refs");
+    const content = await readFile55(packedPath, "utf-8");
     for (const rawLine of content.split(/\r?\n/)) {
       const line = rawLine.trim();
       if (line.length === 0 || line.startsWith("#") || line.startsWith("^")) continue;
@@ -19248,7 +21381,7 @@ async function lookupPackedRef(commonDir, refName) {
 }
 async function readRefLoose(dir, refName) {
   try {
-    const sha = (await readFile48(path74.join(dir, refName), "utf-8")).trim();
+    const sha = (await readFile55(path83.join(dir, refName), "utf-8")).trim();
     return sha.length > 0 ? sha : null;
   } catch {
     return null;
@@ -19257,8 +21390,8 @@ async function readRefLoose(dir, refName) {
 async function resolveCommitSha(root) {
   try {
     const { gitDir, commonDir } = await resolveGitDirs(root);
-    const headPath = path74.join(gitDir, "HEAD");
-    const headContent = (await readFile48(headPath, "utf-8")).trim();
+    const headPath = path83.join(gitDir, "HEAD");
+    const headContent = (await readFile55(headPath, "utf-8")).trim();
     if (headContent.startsWith("ref: ")) {
       const refName = headContent.slice(5).trim();
       const looseLocal = await readRefLoose(gitDir, refName);
@@ -19279,168 +21412,13 @@ async function resolveCommitSha(root) {
     );
   }
 }
-
-// src/core/evidence/playwrightRenderAdapter.ts
-import { mkdir as mkdir6, writeFile as writeFile5 } from "fs/promises";
-import path75 from "path";
-function sanitizeName(value) {
-  return value.replace(/[^a-zA-Z0-9_-]+/g, "-");
-}
-async function loadPlaywright() {
-  return import("playwright");
-}
-function createPlaywrightRenderAdapter(input) {
-  async function _renderTarget(target) {
-    if (!input.targetUrl) {
-      throw new Error("target URL is required for Playwright render capture");
-    }
-    const playwright = await loadPlaywright();
-    const browser = await playwright.chromium.launch();
-    try {
-      const page = await browser.newPage({
-        viewport: {
-          width: target.width ?? 1440,
-          height: target.height ?? 900
-        }
-      });
-      const resolvedUrl = new URL(target.route ?? "/", input.targetUrl).toString();
-      await page.goto(resolvedUrl, { waitUntil: "networkidle" });
-      const slug = sanitizeName(`${target.targetId}.${target.viewport}`);
-      const screenshotPath = path75.join(process.cwd(), ".", slug);
-      return {
-        screenshotPath,
-        htmlPath: await page.content()
-      };
-    } finally {
-      await browser.close();
-    }
-  }
-  return {
-    async captureScreenshot(target, outputDir) {
-      if (!input.targetUrl) {
-        throw new Error("target URL is required for Playwright render capture");
-      }
-      const playwright = await loadPlaywright();
-      const browser = await playwright.chromium.launch();
-      try {
-        await mkdir6(outputDir, { recursive: true });
-        const page = await browser.newPage({
-          viewport: {
-            width: target.width ?? 1440,
-            height: target.height ?? 900
-          }
-        });
-        const resolvedUrl = new URL(target.route ?? "/", input.targetUrl).toString();
-        await page.goto(resolvedUrl, { waitUntil: "networkidle" });
-        const targetName = sanitizeName(`${target.targetId}.${target.viewport}`);
-        const screenshotPath = path75.join(outputDir, `${targetName}.png`);
-        await page.screenshot({ path: screenshotPath, fullPage: true });
-        return screenshotPath;
-      } finally {
-        await browser.close();
-      }
-    },
-    async captureHtml(target, outputDir) {
-      if (!input.targetUrl) {
-        throw new Error("target URL is required for Playwright render capture");
-      }
-      const playwright = await loadPlaywright();
-      const browser = await playwright.chromium.launch();
-      try {
-        await mkdir6(outputDir, { recursive: true });
-        const page = await browser.newPage({
-          viewport: {
-            width: target.width ?? 1440,
-            height: target.height ?? 900
-          }
-        });
-        const resolvedUrl = new URL(target.route ?? "/", input.targetUrl).toString();
-        await page.goto(resolvedUrl, { waitUntil: "networkidle" });
-        const targetName = sanitizeName(`${target.targetId}.${target.viewport}`);
-        const htmlPath = path75.join(outputDir, `${targetName}.html`);
-        await writeFile5(htmlPath, await page.content(), "utf-8");
-        return htmlPath;
-      } finally {
-        await browser.close();
-      }
-    }
-  };
-}
-
-// src/core/providers/playwrightBrowserQaProvider.ts
-init_surfaceType();
-async function loadPlaywright2() {
-  try {
-    return await import("playwright");
-  } catch {
-    throw new Error("Playwright is not installed. Install it with: npm install playwright");
-  }
-}
-async function withPage(input, task) {
-  const playwright = await loadPlaywright2();
-  const browser = await playwright.chromium.launch();
-  try {
-    const page = await browser.newPage();
-    if (input.targetUrl) {
-      await page.goto(input.targetUrl, { waitUntil: "networkidle" });
-    } else if (input.htmlContent) {
-      await page.setContent(input.htmlContent, { waitUntil: "load" });
-    } else {
-      throw new Error("Browser QA requires targetUrl or htmlContent");
-    }
-    return await task(page);
-  } finally {
-    await browser.close();
-  }
-}
-function completed(phase) {
-  return {
-    phase,
-    status: "executed",
-    findings: [],
-    repair_suggestions: [],
-    evidence_refs: [`provider:playwright:${phase}`],
-    checks_performed: [`playwright executed ${phase} checks`]
-  };
-}
-function createPlaywrightBrowserQaProvider() {
-  return {
-    providerId: "playwright",
-    canRun(surface) {
-      return requiresVisualBrowserEvidence(surface);
-    },
-    async runSmoke(input) {
-      return withPage(input, async (page) => {
-        await page.title();
-        return completed("smoke");
-      });
-    },
-    async runInteraction(input) {
-      return withPage(input, async (page) => {
-        await page.locator("button, a, input, form").count();
-        return completed("interaction");
-      });
-    },
-    async runVisual(input) {
-      return withPage(input, async (page) => {
-        await page.viewportSize();
-        return completed("visual");
-      });
-    },
-    async runAccessibility(input) {
-      return withPage(input, async (page) => {
-        await page.locator("html").getAttribute("lang");
-        return completed("accessibility");
-      });
-    }
-  };
-}
 export {
   BROWSER_QA_PHASES,
   DEFAULT_PROTOTYPING_MODE,
   DISCUSSION_NON_UI_SURFACES,
   DISCUSSION_UI_BEARING_SURFACES,
   ID_PREFIXES,
+  PROTOTYPING_MAX_CYCLES,
   PROTOTYPING_MAX_ITERATIONS,
   PROTOTYPING_MODES,
   PROTOTYPING_SUPPORTED_SURFACES,
@@ -19449,8 +21427,6 @@ export {
   appendIteration,
   checkDecisionGuardrails,
   computeTerminationReason,
-  createPlaywrightBrowserQaProvider,
-  createPlaywrightRenderAdapter,
   createReportData,
   defaultConfig,
   derivePrototypingObligations,