qfai 1.8.2 → 1.8.3

package/dist/index.cjs

@@ -453,6 +453,7 @@ __export(src_exports, {
   DISCUSSION_NON_UI_SURFACES: () => DISCUSSION_NON_UI_SURFACES,
   DISCUSSION_UI_BEARING_SURFACES: () => DISCUSSION_UI_BEARING_SURFACES,
   ID_PREFIXES: () => ID_PREFIXES,
+  PROTOTYPING_MAX_CYCLES: () => PROTOTYPING_MAX_CYCLES,
   PROTOTYPING_MAX_ITERATIONS: () => PROTOTYPING_MAX_ITERATIONS,
   PROTOTYPING_MODES: () => PROTOTYPING_MODES,
   PROTOTYPING_SUPPORTED_SURFACES: () => PROTOTYPING_SUPPORTED_SURFACES,
@@ -461,8 +462,6 @@ __export(src_exports, {
   appendIteration: () => appendIteration,
   checkDecisionGuardrails: () => checkDecisionGuardrails,
   computeTerminationReason: () => computeTerminationReason,
-  createPlaywrightBrowserQaProvider: () => createPlaywrightBrowserQaProvider,
-  createPlaywrightRenderAdapter: () => createPlaywrightRenderAdapter,
   createReportData: () => createReportData,
   defaultConfig: () => defaultConfig,
   derivePrototypingObligations: () => derivePrototypingObligations,
@@ -570,7 +569,8 @@ var defaultConfig = {
       requireLayerTags: false,
       requireSizeTags: false,
       maxE2eScenarioRatio: null,
-      maxE2eScenarioCount: null
+      maxE2eScenarioCount: null,
+      forbidTestTodoStubs: true
     },
     traceability: {
       brMustHaveSc: true,
@@ -591,8 +591,7 @@ var defaultConfig = {
     },
     execution: {
       targetUrl: null,
-      browserProvider: "playwright",
-      renderProvider: "playwright"
+      browserTool: "playwright-cli"
     }
   }
 };
@@ -783,6 +782,13 @@ function normalizeValidation(raw, configPath, issues) {
         "validation.testStrategy.maxE2eScenarioCount",
         configPath,
         issues
+      ),
+      forbidTestTodoStubs: readBoolean(
+        testStrategyRaw?.forbidTestTodoStubs,
+        base.testStrategy.forbidTestTodoStubs,
+        "validation.testStrategy.forbidTestTodoStubs",
+        configPath,
+        issues
       )
     },
     traceability: {
@@ -908,6 +914,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,
@@ -915,20 +945,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) {
@@ -3123,11 +3140,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);
@@ -3157,14 +3175,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
   };
 }
@@ -3631,8 +3659,8 @@ async function readSafe4(filePath) {
 }
 
 // src/core/report.ts
-var import_promises58 = require("fs/promises");
-var import_node_path70 = __toESM(require("path"), 1);
+var import_promises59 = require("fs/promises");
+var import_node_path71 = __toESM(require("path"), 1);
 
 // src/core/contractIndex.ts
 var import_promises13 = require("fs/promises");
@@ -4386,15 +4414,15 @@ function asTagArray(value) {
 }
 
 // src/core/validate.ts
-var import_node_path69 = __toESM(require("path"), 1);
+var import_node_path70 = __toESM(require("path"), 1);
 
 // src/core/version.ts
 var import_promises14 = require("fs/promises");
 var import_node_path13 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 async function resolveToolVersion() {
-  if ("1.8.2".length > 0) {
-    return "1.8.2";
+  if ("1.8.3".length > 0) {
+    return "1.8.3";
   }
   try {
     const packagePath = resolvePackageJsonPath();
@@ -7325,7 +7353,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);
@@ -7401,7 +7429,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)
     );
@@ -10181,8 +10209,121 @@ 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/prototyping/round.ts
+var EXPLORATION_ROUNDS = ["r5", "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);
+}
+
 // 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",
@@ -10251,6 +10392,24 @@ async function validatePrototypingEvidence(root, config) {
     return issues;
   }
   const obligations = surface && isSupportedPrototypingSurface(surface) ? derivePrototypingObligations({ surface, effectiveMode: mode.effective }) : void 0;
+  issues.push(
+    ...validateModeInvariant(record2, import_node_path35.default.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(
@@ -10281,10 +10440,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;
     }
@@ -10295,12 +10458,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",
+            import_node_path35.default.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(
@@ -10310,7 +10504,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;
       }
@@ -10327,7 +10521,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;
         }
@@ -10367,27 +10561,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",
+        import_node_path35.default.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",
+        import_node_path35.default.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",
+          import_node_path35.default.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",
+          import_node_path35.default.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",
+          import_node_path35.default.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",
+          import_node_path35.default.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",
+          import_node_path35.default.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",
         import_node_path35.default.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.")
     );
@@ -10426,100 +10724,448 @@ 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 (0, import_promises32.readFile)(filePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    return isRecord5(parsed) ? { status: "ok", value: parsed } : { status: "invalid" };
-  } catch {
-    try {
-      await (0, import_promises32.readFile)(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",
-    import_node_path35.default.relative(root, evidencePath).replace(/\\/g, "/"),
-    "prototypingEvidence.schema"
-  );
-}
-
-// src/core/validators/prototypingDesignSystem.ts
-var import_promises33 = require("fs/promises");
-var import_node_path36 = __toESM(require("path"), 1);
-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 normalizePolishCycles(value) {
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  return value;
 }
-function detectMode(raw) {
-  if (!isRecord6(raw)) {
-    return "other";
+function normalizePhaseCurrent(value) {
+  if (!isRecord6(value)) {
+    return null;
   }
-  const topLevel = raw.mode;
-  if (isRecord6(topLevel) && topLevel.effective === "full-harness") {
-    return "full-harness";
+  return typeof value.current === "string" ? value.current : null;
+}
+function normalizeFullHarnessStatus(value) {
+  if (!isRecord6(value)) {
+    return null;
   }
-  return "other";
+  return typeof value.status === "string" ? value.status : null;
 }
-function detectScorePresence(raw) {
-  if (!isRecord6(raw)) {
+function hasCompletePolishChecks(value) {
+  if (!isRecord6(value)) {
     return false;
   }
-  const trace = raw.scoringTrace;
-  if (!isRecord6(trace)) {
+  return REQUIRED_POLISH_CHECKS.every((key) => value[key] === true);
+}
+function allReviewerScoresArePerfect100(iterations) {
+  const candidate = iterations[iterations.length - 1];
+  if (!isRecord6(candidate) || !Array.isArray(candidate.reviewerScores)) {
     return false;
   }
-  return Object.prototype.hasOwnProperty.call(trace, "designSystemCompliance");
-}
-async function fileExists2(filePath) {
-  try {
-    await (0, import_promises33.access)(filePath);
-    return true;
-  } catch (err) {
-    if (typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT") {
+  return candidate.reviewerScores.every((reviewer) => {
+    if (!isRecord6(reviewer) || !Array.isArray(reviewer.scores) || reviewer.scores.length === 0) {
       return false;
     }
-    return false;
-  }
+    return reviewer.scores.every((score) => isRecord6(score) && score.score === 100);
+  });
 }
-async function readFileSafe(filePath) {
-  try {
-    return await (0, import_promises33.readFile)(filePath, "utf-8");
-  } catch (err) {
-    if (typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT") {
-      return null;
-    }
-    return null;
+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",
+        import_node_path35.default.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;
   }
-}
-async function loadPrototypingArtifact(evidenceDir) {
-  const jsonPath = import_node_path36.default.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),
-      designSystemCompliancePresent: detectScorePresence(parsed)
-    };
+  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",
+        import_node_path35.default.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",
+        import_node_path35.default.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",
+          import_node_path35.default.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",
+          import_node_path35.default.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",
+          import_node_path35.default.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",
+          import_node_path35.default.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",
+        import_node_path35.default.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 (0, import_promises32.readFile)(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return isRecord6(parsed) ? { status: "ok", value: parsed } : { status: "invalid" };
+  } catch {
+    try {
+      await (0, import_promises32.readFile)(filePath, "utf-8");
+      return { status: "invalid" };
+    } catch {
+      return { status: "missing" };
+    }
+  }
+}
+function makeSchemaIssue(root, evidencePath, message) {
+  return issue(
+    "QFAI-PROT-299",
+    message,
+    "error",
+    import_node_path35.default.relative(root, evidencePath).replace(/\\/g, "/"),
+    "prototypingEvidence.schema"
+  );
+}
+
+// src/core/validators/prototypingDesignSystem.ts
+var import_promises33 = require("fs/promises");
+var import_node_path36 = __toESM(require("path"), 1);
+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 (0, import_promises33.access)(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 (0, import_promises33.readFile)(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 = import_node_path36.default.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: detectMode2(parsed),
+      designSystemCompliancePresent: detectScorePresence(parsed)
+    };
   }
   return {
     source: "none",
@@ -16351,16 +16997,181 @@ function validatePrototypingSkillContent(content) {
   };
 }
 
+// src/core/validators/testTodoStubs.ts
+var import_promises56 = require("fs/promises");
+var import_node_path69 = __toESM(require("path"), 1);
+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 = import_node_path69.default.relative(root, absFile).replace(/\\/g, "/");
+    let content;
+    try {
+      content = await (0, import_promises56.readFile)(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)
+  ];
+}
+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),
@@ -16386,68 +17197,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 = import_node_path69.default.join(skillsDir, "qfai-prototyping", "SKILL.md");
+  const prototypingSkillPath = import_node_path70.default.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(
@@ -16463,11 +17219,11 @@ function countIssues(issues) {
 }
 
 // src/core/uiux/renderEvidence.ts
-var import_promises56 = require("fs/promises");
+var import_promises57 = require("fs/promises");
 async function readRenderEvidenceBundle(filePath) {
   let raw;
   try {
-    raw = await (0, import_promises56.readFile)(filePath, "utf-8");
+    raw = await (0, import_promises57.readFile)(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -16477,9 +17233,9 @@ async function readRenderEvidenceBundle(filePath) {
   } catch {
     return null;
   }
-  return isRecord7(parsed) ? parsed : null;
+  return isRecord8(parsed) ? parsed : null;
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function summarizeRenderEvidence(bundle) {
@@ -16487,7 +17243,7 @@ function summarizeRenderEvidence(bundle) {
   let inlinePayloadViolation = false;
   if (bundle?.screens) {
     for (const screen of bundle.screens) {
-      if (isRecord7(screen)) {
+      if (isRecord8(screen)) {
         const s = screen;
         if (s.status === "captured" || s.status === "skipped" || s.status === "failed") {
           counts[s.status] += 1;
@@ -16512,7 +17268,7 @@ function summarizeRenderEvidence(bundle) {
 }
 
 // src/core/browserQa/index.ts
-var import_promises57 = require("fs/promises");
+var import_promises58 = require("fs/promises");
 
 // src/core/browserQa/types.ts
 var BROWSER_QA_PHASES = [
@@ -17075,7 +17831,7 @@ function summarizeBrowserQaResult(result) {
 async function readBrowserQaBundle(filePath) {
   let raw;
   try {
-    raw = await (0, import_promises57.readFile)(filePath, "utf-8");
+    raw = await (0, import_promises58.readFile)(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -17085,9 +17841,9 @@ async function readBrowserQaBundle(filePath) {
   } catch {
     return null;
   }
-  return isRecord8(parsed) ? parsed : null;
+  return isRecord9(parsed) ? parsed : null;
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 
@@ -17096,15 +17852,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 = import_node_path70.default.resolve(root);
+  const resolvedRoot = import_node_path71.default.resolve(root);
   const resolved = configResult ?? await loadConfig(resolvedRoot);
   const config = resolved.config;
   const configPath = resolved.configPath;
   const specsRoot = resolvePath(resolvedRoot, config, "specsDir");
   const contractsRoot = resolvePath(resolvedRoot, config, "contractsDir");
-  const apiRoot = import_node_path70.default.join(contractsRoot, "api");
-  const uiRoot = import_node_path70.default.join(contractsRoot, "ui");
-  const dbRoot = import_node_path70.default.join(contractsRoot, "db");
+  const apiRoot = import_node_path71.default.join(contractsRoot, "api");
+  const uiRoot = import_node_path71.default.join(contractsRoot, "ui");
+  const dbRoot = import_node_path71.default.join(contractsRoot, "db");
   const srcRoot = resolvePath(resolvedRoot, config, "srcDir");
   const testsRoot = resolvePath(resolvedRoot, config, "testsDir");
   const specEntries = await collectSpecEntries(specsRoot);
@@ -17901,6 +18657,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)"}`);
@@ -18257,7 +19035,7 @@ async function collectChangeTypeSummary(specsRoot) {
   };
   const deltaFiles = await collectDeltaFiles(specsRoot);
   for (const deltaFile of deltaFiles) {
-    const text = await (0, import_promises58.readFile)(deltaFile, "utf-8");
+    const text = await (0, import_promises59.readFile)(deltaFile, "utf-8");
     const parsed = parseDeltaV1(text);
     for (const entry of parsed.entries) {
       if (!entry.meta) {
@@ -18288,11 +19066,11 @@ async function collectChangeTypeSummary(specsRoot) {
 }
 async function collectPrototypingSummary(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
-  const evidenceRoot = import_node_path70.default.join(import_node_path70.default.dirname(specsRoot), "evidence");
-  const evidencePath = import_node_path70.default.join(evidenceRoot, "prototyping.json");
+  const evidenceRoot = import_node_path71.default.join(import_node_path71.default.dirname(specsRoot), "evidence");
+  const evidencePath = import_node_path71.default.join(evidenceRoot, "prototyping.json");
   let raw;
   try {
-    raw = await (0, import_promises58.readFile)(evidencePath, "utf-8");
+    raw = await (0, import_promises59.readFile)(evidencePath, "utf-8");
   } catch {
     return void 0;
   }
@@ -18319,10 +19097,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(import_node_path70.default.join(evidenceRoot, "render.json"));
-  const browserQaBundle = await readBrowserQaBundle(import_node_path70.default.join(evidenceRoot, "browser-qa.json"));
+  const renderBundle = await readRenderEvidenceBundle(import_node_path71.default.join(evidenceRoot, "render.json"));
+  const browserQaBundle = await readBrowserQaBundle(import_node_path71.default.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());
@@ -18379,8 +19159,75 @@ async function collectPrototypingSummary(root, config) {
     ...classificationBlock?.secondary_surfaces?.length ? { secondarySurfaces: classificationBlock.secondary_surfaces } : {},
     ...classificationBlock?.classification_rationale ? { classificationRationale: classificationBlock.classification_rationale } : {}
   };
+  const roundLifecycle = record2.schemaVersion === "2.0" || rounds.length > 0 || polishCycles.length > 0 ? (() => {
+    const polishKinds = {};
+    let candidatesObserved = 0;
+    let perfectRounds = 0;
+    let harvestArtifacts = 0;
+    let narrowDecisions = 0;
+    let absorptionPlans = 0;
+    let reimplementations = 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;
+      }
+      if (typeof round.harvestRef === "string" && round.harvestRef.length > 0) {
+        harvestArtifacts += 1;
+      }
+      if (typeof round.narrowDecisionRef === "string" && round.narrowDecisionRef.length > 0) {
+        narrowDecisions += 1;
+      }
+      if (typeof round.absorptionPlanRef === "string" && round.absorptionPlanRef.length > 0) {
+        absorptionPlans += 1;
+      }
+      if (typeof round.reimplementationRef === "string" && round.reimplementationRef.length > 0) {
+        reimplementations += 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;
+      }
+    }
+    return {
+      schemaVersion: "2.0",
+      rounds: rounds.length,
+      roundIds: rounds.map((item) => asRecord2(item)).flatMap(
+        (round) => round && typeof round.round === "string" && round.round.length > 0 ? [round.round] : []
+      ),
+      candidatesObserved,
+      perfectRounds,
+      harvestArtifacts,
+      narrowDecisions,
+      absorptionPlans,
+      reimplementations,
+      polishCycles: polishCycles.length,
+      completedPolishCycles,
+      perfectPolishCycles,
+      polishKinds
+    };
+  })() : void 0;
   return {
     surfaceClassification,
+    ...roundLifecycle ? { roundLifecycle } : {},
     mode: {
       ...resolvedMode.requested ? { requested: resolvedMode.requested } : {},
       effective: effectiveMode,
@@ -18473,7 +19320,7 @@ async function collectSpecContractRefs(specFiles, contractIdList) {
     idToSpecs.set(contractId, /* @__PURE__ */ new Set());
   }
   for (const file of specFiles) {
-    const text = await (0, import_promises58.readFile)(file, "utf-8");
+    const text = await (0, import_promises59.readFile)(file, "utf-8");
     const parsed = parseSpec(text, file);
     const specKey = parsed.specId;
     if (!specKey) {
@@ -18510,7 +19357,7 @@ async function collectIds(files) {
     result[prefix] = /* @__PURE__ */ new Set();
   }
   for (const file of files) {
-    const text = await (0, import_promises58.readFile)(file, "utf-8");
+    const text = await (0, import_promises59.readFile)(file, "utf-8");
     for (const prefix of ID_PREFIXES) {
       const ids = extractIds(text, prefix);
       ids.forEach((id) => result[prefix].add(id));
@@ -18525,7 +19372,7 @@ async function collectIds(files) {
 async function collectUpstreamIds(files) {
   const ids = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const text = await (0, import_promises58.readFile)(file, "utf-8");
+    const text = await (0, import_promises59.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => ids.add(id));
   }
   return ids;
@@ -18546,7 +19393,7 @@ async function evaluateTraceability(upstreamIds, srcRoot, testsRoot) {
   }
   const pattern = buildIdPattern(Array.from(upstreamIds));
   for (const file of targetFiles) {
-    const text = await (0, import_promises58.readFile)(file, "utf-8");
+    const text = await (0, import_promises59.readFile)(file, "utf-8");
     if (pattern.test(text)) {
       return true;
     }
@@ -18668,7 +19515,7 @@ function normalizeScSources(root, sources) {
 async function countScenarios(scenarioFiles) {
   let total = 0;
   for (const file of scenarioFiles) {
-    const text = await (0, import_promises58.readFile)(file, "utf-8");
+    const text = await (0, import_promises59.readFile)(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -18699,7 +19546,7 @@ async function collectTestStrategy(scenarioFiles, root, config, limit) {
   let totalScenarios = 0;
   let e2eCount = 0;
   for (const file of scenarioFiles) {
-    const text = await (0, import_promises58.readFile)(file, "utf-8");
+    const text = await (0, import_promises59.readFile)(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -18787,10 +19634,10 @@ function buildHotspots(issues) {
 async function collectTddCoverage(entries) {
   const specs = [];
   for (const entry of entries) {
-    const testCasesPath = import_node_path70.default.join(entry.dir, "06_Test-Cases.md");
+    const testCasesPath = import_node_path71.default.join(entry.dir, "06_Test-Cases.md");
     let tcContent;
     try {
-      tcContent = await (0, import_promises58.readFile)(testCasesPath, "utf-8");
+      tcContent = await (0, import_promises59.readFile)(testCasesPath, "utf-8");
     } catch {
       continue;
     }
@@ -18822,10 +19669,10 @@ async function collectTddCoverage(entries) {
       });
       continue;
     }
-    const tddListPath = import_node_path70.default.join(entry.dir, "tdd", "test-list.md");
+    const tddListPath = import_node_path71.default.join(entry.dir, "tdd", "test-list.md");
     let tddContent;
     try {
-      tddContent = await (0, import_promises58.readFile)(tddListPath, "utf-8");
+      tddContent = await (0, import_promises59.readFile)(tddListPath, "utf-8");
     } catch {
       specs.push({
         specNumber: entry.specNumber,
@@ -18976,16 +19823,16 @@ async function runRenderCapture(targets, outputDir, adapter, options) {
 }
 
 // src/core/evidence/bundleWriter.ts
-var import_promises60 = require("fs/promises");
-var import_node_path72 = __toESM(require("path"), 1);
+var import_promises61 = require("fs/promises");
+var import_node_path73 = __toESM(require("path"), 1);
 
 // src/core/evidence/fsEvidenceWriter.ts
-var import_promises59 = require("fs/promises");
-var import_node_path71 = __toESM(require("path"), 1);
+var import_promises60 = require("fs/promises");
+var import_node_path72 = __toESM(require("path"), 1);
 async function writeEvidenceFile(filePath, content) {
   try {
-    await (0, import_promises59.mkdir)(import_node_path71.default.dirname(filePath), { recursive: true });
-    await (0, import_promises59.writeFile)(filePath, content);
+    await (0, import_promises60.mkdir)(import_node_path72.default.dirname(filePath), { recursive: true });
+    await (0, import_promises60.writeFile)(filePath, content);
     return { path: filePath, written: true };
   } catch (error) {
     return {
@@ -18998,19 +19845,19 @@ async function writeEvidenceFile(filePath, content) {
 
 // src/core/evidence/bundleWriter.ts
 function toPosixRelative5(root, targetPath) {
-  return import_node_path72.default.relative(root, targetPath).replace(/\\/g, "/");
+  return import_node_path73.default.relative(root, targetPath).replace(/\\/g, "/");
 }
 async function writeEvidenceBundles(input) {
-  const evidenceRoot = import_node_path72.default.join(input.root, ".qfai", "evidence");
-  const renderAssetRoot = import_node_path72.default.join(evidenceRoot, "render");
-  await (0, import_promises60.mkdir)(renderAssetRoot, { recursive: true });
-  const prototypingPath = import_node_path72.default.join(evidenceRoot, "prototyping.json");
-  const renderPath = import_node_path72.default.join(evidenceRoot, "render.json");
-  const browserQaPath = import_node_path72.default.join(evidenceRoot, "browser-qa.json");
-  const browserQaSummaryPath = import_node_path72.default.join(evidenceRoot, "browserQa.summary.json");
-  const browserQaFindingsPath = import_node_path72.default.join(evidenceRoot, "browserQa.findings.json");
-  const browserQaRepairsPath = import_node_path72.default.join(evidenceRoot, "browserQa.repairs.json");
-  const breakthroughPath = import_node_path72.default.join(evidenceRoot, "breakthrough.json");
+  const evidenceRoot = import_node_path73.default.join(input.root, ".qfai", "evidence");
+  const renderAssetRoot = import_node_path73.default.join(evidenceRoot, "render");
+  await (0, import_promises61.mkdir)(renderAssetRoot, { recursive: true });
+  const prototypingPath = import_node_path73.default.join(evidenceRoot, "prototyping.json");
+  const renderPath = import_node_path73.default.join(evidenceRoot, "render.json");
+  const browserQaPath = import_node_path73.default.join(evidenceRoot, "browser-qa.json");
+  const browserQaSummaryPath = import_node_path73.default.join(evidenceRoot, "browserQa.summary.json");
+  const browserQaFindingsPath = import_node_path73.default.join(evidenceRoot, "browserQa.findings.json");
+  const browserQaRepairsPath = import_node_path73.default.join(evidenceRoot, "browserQa.repairs.json");
+  const breakthroughPath = import_node_path73.default.join(evidenceRoot, "breakthrough.json");
   const renderBundle = input.render === void 0 ? {
     renderEvidence: {
       status: "skipped",
@@ -19032,7 +19879,7 @@ async function writeEvidenceBundles(input) {
   await Promise.all([
     writeEvidenceFile(prototypingPath, JSON.stringify(input.prototyping, null, 2)),
     writeEvidenceFile(
-      import_node_path72.default.join(evidenceRoot, "prototyping.md"),
+      import_node_path73.default.join(evidenceRoot, "prototyping.md"),
       buildPrototypingMarkdown(input.prototyping)
     ),
     writeEvidenceFile(renderPath, JSON.stringify(renderBundle, null, 2)),
@@ -19049,15 +19896,15 @@ async function writeEvidenceBundles(input) {
     writeEvidenceFile(breakthroughPath, JSON.stringify(input.prototyping.breakthrough, null, 2)),
     ...input.fullHarnessArtifacts ? [
       writeEvidenceFile(
-        import_node_path72.default.join(evidenceRoot, "fullHarness.fakeUiDetection.json"),
+        import_node_path73.default.join(evidenceRoot, "fullHarness.fakeUiDetection.json"),
         JSON.stringify(input.fullHarnessArtifacts.fakeUiDetection, null, 2)
       ),
       writeEvidenceFile(
-        import_node_path72.default.join(evidenceRoot, "fullHarness.handoff.json"),
+        import_node_path73.default.join(evidenceRoot, "fullHarness.handoff.json"),
         JSON.stringify(input.fullHarnessArtifacts.handoff, null, 2)
       ),
       writeEvidenceFile(
-        import_node_path72.default.join(evidenceRoot, "fullHarness.exit.json"),
+        import_node_path73.default.join(evidenceRoot, "fullHarness.exit.json"),
         JSON.stringify({ exit_reason: input.fullHarnessArtifacts.exitReason }, null, 2)
       )
     ] : []
@@ -19157,15 +20004,15 @@ function buildPrototypingMarkdown(bundle) {
 }
 
 // src/core/harness/history.ts
-var import_promises61 = require("fs/promises");
-var import_node_path73 = __toESM(require("path"), 1);
+var import_promises62 = require("fs/promises");
+var import_node_path74 = __toESM(require("path"), 1);
 var EVIDENCE_PATH = ".qfai/evidence/prototyping.json";
 async function loadHistory(root) {
   try {
-    const filePath = import_node_path73.default.join(root, EVIDENCE_PATH);
-    const content = await (0, import_promises61.readFile)(filePath, "utf-8");
+    const filePath = import_node_path74.default.join(root, EVIDENCE_PATH);
+    const content = await (0, import_promises62.readFile)(filePath, "utf-8");
     const parsed = JSON.parse(content);
-    if (isRecord9(parsed) && isRecord9(parsed.fullHarness)) {
+    if (isRecord10(parsed) && isRecord10(parsed.fullHarness)) {
       const fh = parsed.fullHarness;
       if (Array.isArray(fh.iterations)) {
         return {
@@ -19214,7 +20061,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) {
@@ -19226,6 +20073,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,
@@ -19233,7 +20081,7 @@ function buildScoreSnapshot(iteration) {
       axisCount: 0,
       minScore: null,
       averageScore: null,
-      allItemsPass95: iteration.allItemsPass95,
+      allReviewerAxesPerfect100: false,
       commitSha: iteration.commitSha
     };
   }
@@ -19244,13 +20092,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;
@@ -19264,7 +20112,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 isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -19299,16 +20155,16 @@ function validateReviewer(reviewer) {
 }
 
 // src/core/harness/gitRevision.ts
-var import_promises62 = require("fs/promises");
-var import_node_path74 = __toESM(require("path"), 1);
+var import_promises63 = require("fs/promises");
+var import_node_path75 = __toESM(require("path"), 1);
 async function resolveGitDirs(root) {
-  const dotGit = import_node_path74.default.join(root, ".git");
-  const info = await (0, import_promises62.stat)(dotGit);
+  const dotGit = import_node_path75.default.join(root, ".git");
+  const info = await (0, import_promises63.stat)(dotGit);
   const gitDir = info.isDirectory() ? dotGit : await resolveWorktreeGitDir(root, dotGit);
   try {
-    const commondirText = (await (0, import_promises62.readFile)(import_node_path74.default.join(gitDir, "commondir"), "utf-8")).trim();
+    const commondirText = (await (0, import_promises63.readFile)(import_node_path75.default.join(gitDir, "commondir"), "utf-8")).trim();
     if (commondirText.length > 0) {
-      const commonDir = import_node_path74.default.isAbsolute(commondirText) ? commondirText : import_node_path74.default.resolve(gitDir, commondirText);
+      const commonDir = import_node_path75.default.isAbsolute(commondirText) ? commondirText : import_node_path75.default.resolve(gitDir, commondirText);
       return { gitDir, commonDir };
     }
   } catch {
@@ -19316,18 +20172,18 @@ async function resolveGitDirs(root) {
   return { gitDir, commonDir: gitDir };
 }
 async function resolveWorktreeGitDir(root, dotGitFile) {
-  const text = (await (0, import_promises62.readFile)(dotGitFile, "utf-8")).trim();
+  const text = (await (0, import_promises63.readFile)(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 import_node_path74.default.isAbsolute(gitdirValue) ? gitdirValue : import_node_path74.default.resolve(root, gitdirValue);
+  return import_node_path75.default.isAbsolute(gitdirValue) ? gitdirValue : import_node_path75.default.resolve(root, gitdirValue);
 }
 async function lookupPackedRef(commonDir, refName) {
   try {
-    const packedPath = import_node_path74.default.join(commonDir, "packed-refs");
-    const content = await (0, import_promises62.readFile)(packedPath, "utf-8");
+    const packedPath = import_node_path75.default.join(commonDir, "packed-refs");
+    const content = await (0, import_promises63.readFile)(packedPath, "utf-8");
     for (const rawLine of content.split(/\r?\n/)) {
       const line = rawLine.trim();
       if (line.length === 0 || line.startsWith("#") || line.startsWith("^")) continue;
@@ -19343,7 +20199,7 @@ async function lookupPackedRef(commonDir, refName) {
 }
 async function readRefLoose(dir, refName) {
   try {
-    const sha = (await (0, import_promises62.readFile)(import_node_path74.default.join(dir, refName), "utf-8")).trim();
+    const sha = (await (0, import_promises63.readFile)(import_node_path75.default.join(dir, refName), "utf-8")).trim();
     return sha.length > 0 ? sha : null;
   } catch {
     return null;
@@ -19352,8 +20208,8 @@ async function readRefLoose(dir, refName) {
 async function resolveCommitSha(root) {
   try {
     const { gitDir, commonDir } = await resolveGitDirs(root);
-    const headPath = import_node_path74.default.join(gitDir, "HEAD");
-    const headContent = (await (0, import_promises62.readFile)(headPath, "utf-8")).trim();
+    const headPath = import_node_path75.default.join(gitDir, "HEAD");
+    const headContent = (await (0, import_promises63.readFile)(headPath, "utf-8")).trim();
     if (headContent.startsWith("ref: ")) {
       const refName = headContent.slice(5).trim();
       const looseLocal = await readRefLoose(gitDir, refName);
@@ -19374,162 +20230,6 @@ async function resolveCommitSha(root) {
     );
   }
 }
-
-// src/core/evidence/playwrightRenderAdapter.ts
-var import_promises63 = require("fs/promises");
-var import_node_path75 = __toESM(require("path"), 1);
-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 = import_node_path75.default.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 (0, import_promises63.mkdir)(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 = import_node_path75.default.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 (0, import_promises63.mkdir)(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 = import_node_path75.default.join(outputDir, `${targetName}.html`);
-        await (0, import_promises63.writeFile)(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");
-      });
-    }
-  };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BROWSER_QA_PHASES,
@@ -19537,6 +20237,7 @@ function createPlaywrightBrowserQaProvider() {
   DISCUSSION_NON_UI_SURFACES,
   DISCUSSION_UI_BEARING_SURFACES,
   ID_PREFIXES,
+  PROTOTYPING_MAX_CYCLES,
   PROTOTYPING_MAX_ITERATIONS,
   PROTOTYPING_MODES,
   PROTOTYPING_SUPPORTED_SURFACES,
@@ -19545,8 +20246,6 @@ function createPlaywrightBrowserQaProvider() {
   appendIteration,
   checkDecisionGuardrails,
   computeTerminationReason,
-  createPlaywrightBrowserQaProvider,
-  createPlaywrightRenderAdapter,
   createReportData,
   defaultConfig,
   derivePrototypingObligations,