qfai 1.7.8 → 1.7.9

package/dist/cli/index.cjs

@@ -1739,8 +1739,8 @@ var import_promises7 = require("fs/promises");
 var import_node_path8 = __toESM(require("path"), 1);
 var import_node_url2 = require("url");
 async function resolveToolVersion() {
-  if ("1.7.8".length > 0) {
-    return "1.7.8";
+  if ("1.7.9".length > 0) {
+    return "1.7.9";
   }
   try {
     const packagePath = resolvePackageJsonPath();
@@ -4906,7 +4906,7 @@ function extractRouteHintsFromEvidence(evidence) {
 
 // src/cli/commands/report.ts
 var import_promises61 = require("fs/promises");
-var import_node_path64 = __toESM(require("path"), 1);
+var import_node_path66 = __toESM(require("path"), 1);
 
 // src/core/normalize.ts
 function normalizeIssuePaths(root, issues) {
@@ -5002,7 +5002,7 @@ async function createPhaseGuardResult(phase, blockedIssue) {
 
 // src/core/report.ts
 var import_promises59 = require("fs/promises");
-var import_node_path62 = __toESM(require("path"), 1);
+var import_node_path64 = __toESM(require("path"), 1);
 
 // src/core/contractIndex.ts
 var import_promises18 = require("fs/promises");
@@ -5699,6 +5699,9 @@ function asTagArray(value) {
   return [];
 }
 
+// src/core/validate.ts
+var import_node_path63 = __toESM(require("path"), 1);
+
 // src/core/waivers.ts
 var import_promises20 = require("fs/promises");
 var import_node_path22 = __toESM(require("path"), 1);
@@ -13098,7 +13101,7 @@ function collectLayer(layer, layerName, target, errors) {
 }
 function flattenTokens(obj, prefix, target, errors) {
   for (const [key, value] of Object.entries(obj)) {
-    const path67 = `${prefix}.${key}`;
+    const path69 = `${prefix}.${key}`;
     if (value && typeof value === "object" && !Array.isArray(value)) {
       const record2 = value;
       if ("$value" in record2) {
@@ -13114,9 +13117,9 @@ function flattenTokens(obj, prefix, target, errors) {
         if (typeof record2.platform === "string") {
           token.platform = record2.platform;
         }
-        target.set(path67, token);
+        target.set(path69, token);
       } else {
-        flattenTokens(record2, path67, target, errors);
+        flattenTokens(record2, path69, target, errors);
       }
     }
   }
@@ -13126,44 +13129,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 [path67] of allTokens) {
-    resolveTokenRef(path67, allTokens, /* @__PURE__ */ new Set(), 0, result);
+  for (const [path69] of allTokens) {
+    resolveTokenRef(path69, allTokens, /* @__PURE__ */ new Set(), 0, result);
   }
 }
-function resolveTokenRef(path67, allTokens, visited, depth, result) {
-  if (result.resolved.has(path67)) {
-    return result.resolved.get(path67);
+function resolveTokenRef(path69, allTokens, visited, depth, result) {
+  if (result.resolved.has(path69)) {
+    return result.resolved.get(path69);
   }
   if (depth > MAX_RESOLVE_DEPTH) {
     result.errors.push({
-      message: `Max reference depth exceeded at: ${path67}`,
-      path: path67
+      message: `Max reference depth exceeded at: ${path69}`,
+      path: path69
     });
     return void 0;
   }
-  if (visited.has(path67)) {
+  if (visited.has(path69)) {
     result.errors.push({
-      message: `Circular reference detected: ${path67}`,
-      path: path67
+      message: `Circular reference detected: ${path69}`,
+      path: path69
     });
     return void 0;
   }
-  const token = allTokens.get(path67);
+  const token = allTokens.get(path69);
   if (!token) {
     return void 0;
   }
   if (typeof token.$value !== "string") {
     const rawValue2 = stringifyTokenValue(token.$value);
-    result.resolved.set(path67, rawValue2);
+    result.resolved.set(path69, rawValue2);
     return rawValue2;
   }
   const rawValue = stringifyTokenValue(token.$value);
   const refs = [...rawValue.matchAll(REF_PATTERN)];
   if (refs.length === 0) {
-    result.resolved.set(path67, rawValue);
+    result.resolved.set(path69, rawValue);
     return rawValue;
   }
-  visited.add(path67);
+  visited.add(path69);
   let resolved = rawValue;
   for (const ref of refs) {
     const refPath = ref[1];
@@ -13171,8 +13174,8 @@ function resolveTokenRef(path67, allTokens, visited, depth, result) {
     const refToken = allTokens.get(refPath);
     if (!refToken) {
       result.errors.push({
-        message: `Unresolved token reference: {${refPath}} at ${path67}`,
-        path: path67
+        message: `Unresolved token reference: {${refPath}} at ${path69}`,
+        path: path69
       });
       continue;
     }
@@ -13181,7 +13184,7 @@ function resolveTokenRef(path67, allTokens, visited, depth, result) {
       resolved = resolved.split(`{${refPath}}`).join(refValue);
     }
   }
-  result.resolved.set(path67, resolved);
+  result.resolved.set(path69, resolved);
   return resolved;
 }
 function stringifyTokenValue(value) {
@@ -16912,9 +16915,64 @@ function hasAntiPatternMention(section, code) {
 }
 
 // src/core/validators/discussionDesignHardening.ts
+var import_node_path58 = __toESM(require("path"), 1);
+
+// src/core/detection/surfaceType.ts
+var import_promises55 = require("fs/promises");
 var import_node_path57 = __toESM(require("path"), 1);
+var VALID_SURFACES = /* @__PURE__ */ new Set([
+  "web-ui",
+  "mobile-ui",
+  "desktop-ui",
+  "mixed",
+  "non-ui"
+]);
 var HTML_TAG_RE = /<(?:style|div|section|span|button|input|form|header|footer|nav|main|aside)\b/i;
 var MERMAID_SCREEN_FLOW_RE = /```mermaid[\s\S]*?(?:stateDiagram|flowchart|graph)[\s\S]*?(?:Screen|Page|View|Dashboard|Login|Settings|Home)\b/i;
+var YAML_SURFACE_RE = /^\s*-\s*surface(?:_type)?:\s*(\S+)/im;
+var TABLE_SURFACE_RE = /\|\s*Surface Type\s*\|\s*(\S+)\s*\|/i;
+var SCREEN_CONTRACT_YAML_RE = /screens:\s*\n\s*-\s*route:/;
+function parseSurface(raw) {
+  const s = raw.toLowerCase();
+  return VALID_SURFACES.has(s) ? s : void 0;
+}
+async function detectSurfaceType(root) {
+  for (const fileName of ["01_Spec.md", "01_Context.md"]) {
+    const content = await readSafe2(import_node_path57.default.join(root, fileName));
+    const match = YAML_SURFACE_RE.exec(content);
+    if (match?.[1]) {
+      const surface = parseSurface(match[1]);
+      if (surface) return surface;
+    }
+  }
+  const storyContent = await readSafe2(import_node_path57.default.join(root, "03_Story-Workshop.md"));
+  if (storyContent) {
+    const tableMatch = TABLE_SURFACE_RE.exec(storyContent);
+    if (tableMatch?.[1]) {
+      const surface = parseSurface(tableMatch[1]);
+      if (surface) return surface;
+    }
+  }
+  try {
+    await (0, import_promises55.readdir)(import_node_path57.default.join(root, "uiux"));
+    return "web-ui";
+  } catch {
+  }
+  const contractsContent = await readSafe2(import_node_path57.default.join(root, "uiux", "40_contracts.md"));
+  if (contractsContent && SCREEN_CONTRACT_YAML_RE.test(contractsContent)) return "web-ui";
+  if (storyContent) {
+    const stripped = storyContent.replace(/```[\s\S]*?```/g, "").replace(/`[^`]+`/g, "");
+    if (HTML_TAG_RE.test(stripped)) return "web-ui";
+    if (MERMAID_SCREEN_FLOW_RE.test(storyContent)) return "web-ui";
+  }
+  return "non-ui";
+}
+async function isUiBearingSurface(root) {
+  const surface = await detectSurfaceType(root);
+  return surface !== "non-ui";
+}
+
+// src/core/validators/discussionDesignHardening.ts
 var DDS_HEADING = "## Design Direction Summary";
 var DDS_SUBSECTIONS = [
   "Option Comparison",
@@ -16927,20 +16985,8 @@ var DDS_SUBSECTIONS = [
 var REQUIRED_STATES = ["empty", "loading", "error", "populated"];
 var COMPETITIVE_REF_FIELDS = ["adopted_points", "rejected_points", "local_translation"];
 var PLACEHOLDER_RE = /^(?:tbd|todo|n\/a|na|xxx|\?\?\?|placeholder)$/i;
-var SURFACE_TYPE_RE = /\|\s*Surface Type\s*\|\s*(\S+)\s*\|/i;
 async function isUiBearing(packRoot) {
-  const storyPath = import_node_path57.default.join(packRoot, "03_Story-Workshop.md");
-  const content = await readSafe2(storyPath);
-  if (!content) return false;
-  const surfaceMatch = SURFACE_TYPE_RE.exec(content);
-  if (surfaceMatch?.[1]) {
-    const surface = surfaceMatch[1].toLowerCase();
-    if (surface === "non-ui") return false;
-    if (["web-ui", "mobile-ui", "desktop-ui", "mixed"].includes(surface)) return true;
-  }
-  if (HTML_TAG_RE.test(content)) return true;
-  if (MERMAID_SCREEN_FLOW_RE.test(content)) return true;
-  return false;
+  return isUiBearingSurface(packRoot);
 }
 function extractDdsSection(content) {
   const idx = content.indexOf(DDS_HEADING);
@@ -16972,7 +17018,7 @@ function extractOptionNames(optionSection) {
 }
 async function validateDdsPresence(packRoot) {
   const issues = [];
-  const storyPath = import_node_path57.default.join(packRoot, "03_Story-Workshop.md");
+  const storyPath = import_node_path58.default.join(packRoot, "03_Story-Workshop.md");
   const content = await readSafe2(storyPath);
   const relPath = "03_Story-Workshop.md";
   if (!content || !content.includes(DDS_HEADING)) {
@@ -17006,7 +17052,7 @@ async function validateDdsPresence(packRoot) {
 }
 async function validateOptionComparison2(packRoot) {
   const issues = [];
-  const storyPath = import_node_path57.default.join(packRoot, "03_Story-Workshop.md");
+  const storyPath = import_node_path58.default.join(packRoot, "03_Story-Workshop.md");
   const content = await readSafe2(storyPath);
   if (!content) return issues;
   const dds = extractDdsSection(content);
@@ -17030,7 +17076,7 @@ async function validateOptionComparison2(packRoot) {
 }
 async function validateAnchorScreen(packRoot) {
   const issues = [];
-  const storyPath = import_node_path57.default.join(packRoot, "03_Story-Workshop.md");
+  const storyPath = import_node_path58.default.join(packRoot, "03_Story-Workshop.md");
   const content = await readSafe2(storyPath);
   if (!content) return issues;
   const dds = extractDdsSection(content);
@@ -17072,7 +17118,7 @@ async function validateAnchorScreen(packRoot) {
 }
 async function validateCompetitiveRefs2(packRoot) {
   const issues = [];
-  const sourcesPath = import_node_path57.default.join(packRoot, "04_Sources.md");
+  const sourcesPath = import_node_path58.default.join(packRoot, "04_Sources.md");
   const content = await readSafe2(sourcesPath);
   if (!content) return issues;
   const registryHeadingRe = /^##\s+Competitive Reference Registry\b.*$/m;
@@ -17129,7 +17175,7 @@ function fieldGuidance(field) {
 }
 async function validateCtaHierarchy(packRoot) {
   const issues = [];
-  const storyPath = import_node_path57.default.join(packRoot, "03_Story-Workshop.md");
+  const storyPath = import_node_path58.default.join(packRoot, "03_Story-Workshop.md");
   const content = await readSafe2(storyPath);
   if (!content) return issues;
   const dds = extractDdsSection(content);
@@ -17167,7 +17213,7 @@ async function validateCtaHierarchy(packRoot) {
 }
 async function validateStateCoverage(packRoot) {
   const issues = [];
-  const storyPath = import_node_path57.default.join(packRoot, "03_Story-Workshop.md");
+  const storyPath = import_node_path58.default.join(packRoot, "03_Story-Workshop.md");
   const content = await readSafe2(storyPath);
   if (!content) return issues;
   const dds = extractDdsSection(content);
@@ -17192,7 +17238,7 @@ async function validateStateCoverage(packRoot) {
 }
 async function validateDesignAntiGoals(packRoot) {
   const issues = [];
-  const storyPath = import_node_path57.default.join(packRoot, "03_Story-Workshop.md");
+  const storyPath = import_node_path58.default.join(packRoot, "03_Story-Workshop.md");
   const content = await readSafe2(storyPath);
   if (!content) return issues;
   const dds = extractDdsSection(content);
@@ -17229,7 +17275,7 @@ async function validateDesignAntiGoals(packRoot) {
   return issues;
 }
 async function validateDiscussionDesignHardening(root, config) {
-  const discussionDir = import_node_path57.default.join(root, config.paths.discussionDir);
+  const discussionDir = import_node_path58.default.join(root, config.paths.discussionDir);
   const packRoot = await findLatestDiscussionPackDir(discussionDir);
   if (!packRoot) return [];
   const uiBearing = await isUiBearing(packRoot);
@@ -17246,8 +17292,8 @@ async function validateDiscussionDesignHardening(root, config) {
 }
 
 // src/core/validators/designAudit.ts
-var import_promises55 = require("fs/promises");
-var import_node_path58 = __toESM(require("path"), 1);
+var import_promises56 = require("fs/promises");
+var import_node_path59 = __toESM(require("path"), 1);
 var COSMETIC_CATEGORIES = ["generic-shell", "stock-imagery", "placeholder-copy"];
 function resolveAuditConfig(config) {
   const audit = config.uiux?.audit;
@@ -17329,19 +17375,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 ? import_node_path58.default.resolve(root, configuredDir) : import_node_path58.default.join(root, cfg.paths.contractsDir, "design");
+  const tokensDir = configuredDir ? import_node_path59.default.resolve(root, configuredDir) : import_node_path59.default.join(root, cfg.paths.contractsDir, "design");
   let hasTokenFiles = false;
   try {
-    const entries = await (0, import_promises55.readdir)(tokensDir);
+    const entries = await (0, import_promises56.readdir)(tokensDir);
     hasTokenFiles = entries.some((e) => /\.ya?ml$/i.test(e));
   } catch {
     return findings;
   }
   if (!hasTokenFiles) return findings;
-  const contractsUiDir = import_node_path58.default.join(root, cfg.paths.contractsDir, "ui");
+  const contractsUiDir = import_node_path59.default.join(root, cfg.paths.contractsDir, "ui");
   let htmlFiles = [];
   try {
-    const entries = await (0, import_promises55.readdir)(contractsUiDir);
+    const entries = await (0, import_promises56.readdir)(contractsUiDir);
     htmlFiles = entries.filter((e) => /\.html?$/i.test(e));
   } catch {
     return findings;
@@ -17349,7 +17395,7 @@ async function checkTokenDrift(root, auditConfig, cfg) {
   let rawCount = 0;
   const sampleLiterals = [];
   for (const htmlFile of htmlFiles) {
-    const content = await readSafe2(import_node_path58.default.join(contractsUiDir, htmlFile));
+    const content = await readSafe2(import_node_path59.default.join(contractsUiDir, htmlFile));
     if (!content) continue;
     const matches = content.match(RAW_COLOR_RE);
     if (matches) {
@@ -17400,12 +17446,12 @@ function deduplicateFindings(issues, maxPerRule) {
 async function validateDesignAudit(root, config) {
   const auditConfig = resolveAuditConfig(config);
   if (!auditConfig.enabled) return [];
-  const discussionDir = import_node_path58.default.join(root, config.paths.discussionDir);
+  const discussionDir = import_node_path59.default.join(root, config.paths.discussionDir);
   const packRoot = await findLatestDiscussionPackDir(discussionDir);
   if (!packRoot) return [];
   const uiBearing = await isUiBearing(packRoot);
   if (!uiBearing) return [];
-  const storyPath = import_node_path58.default.join(packRoot, "03_Story-Workshop.md");
+  const storyPath = import_node_path59.default.join(packRoot, "03_Story-Workshop.md");
   const content = await readSafe2(storyPath);
   if (!content) return [];
   const findings = [];
@@ -17417,8 +17463,8 @@ async function validateDesignAudit(root, config) {
 
 // src/core/validators/designSlop.ts
 var import_node_fs2 = require("fs");
-var import_promises56 = require("fs/promises");
-var import_node_path59 = __toESM(require("path"), 1);
+var import_promises57 = require("fs/promises");
+var import_node_path60 = __toESM(require("path"), 1);
 var import_node_url4 = require("url");
 function isValidSlopPattern(rule) {
   if (typeof rule !== "object" || rule === null) return false;
@@ -17426,7 +17472,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 (0, import_promises56.readFile)(jsonPath, "utf-8");
+  const raw = await (0, import_promises57.readFile)(jsonPath, "utf-8");
   const parsed = JSON.parse(raw);
   if (!Array.isArray(parsed)) return [];
   return parsed.filter((r) => isValidSlopPattern(r));
@@ -17434,11 +17480,11 @@ async function loadSlopPatterns(jsonPath) {
 function defaultPatternsPath() {
   const base = __filename;
   const basePath = base.startsWith("file:") ? (0, import_node_url4.fileURLToPath)(base) : base;
-  const baseDir = import_node_path59.default.dirname(basePath);
+  const baseDir = import_node_path60.default.dirname(basePath);
   const candidates = [
-    import_node_path59.default.join(baseDir, "designSlopPatterns.json"),
-    import_node_path59.default.resolve(baseDir, "../../../assets/validators/designSlopPatterns.json"),
-    import_node_path59.default.resolve(baseDir, "../../assets/validators/designSlopPatterns.json")
+    import_node_path60.default.join(baseDir, "designSlopPatterns.json"),
+    import_node_path60.default.resolve(baseDir, "../../../assets/validators/designSlopPatterns.json"),
+    import_node_path60.default.resolve(baseDir, "../../assets/validators/designSlopPatterns.json")
   ];
   for (const c of candidates) {
     if ((0, import_node_fs2.existsSync)(c)) return c;
@@ -17449,7 +17495,7 @@ async function validateDesignSlop(root, config) {
   const auditConfig = resolveAuditConfig(config);
   if (!auditConfig.enabled) return [];
   if (!auditConfig.slopDetection) return [];
-  const discussionDir = import_node_path59.default.join(root, config.paths.discussionDir);
+  const discussionDir = import_node_path60.default.join(root, config.paths.discussionDir);
   const packRoot = await findLatestDiscussionPackDir(discussionDir);
   if (!packRoot) return [];
   const uiBearing = await isUiBearing(packRoot);
@@ -17470,7 +17516,7 @@ async function validateDesignSlop(root, config) {
       continue;
     }
     for (const scope of pattern.scopes) {
-      const filePath = import_node_path59.default.join(packRoot, scope);
+      const filePath = import_node_path60.default.join(packRoot, scope);
       const content = await readSafe2(filePath);
       if (!content) continue;
       if (regex.test(content) && !seenRules.has(pattern.id)) {
@@ -17496,40 +17542,8 @@ var import_promises58 = require("fs/promises");
 var import_node_path61 = __toESM(require("path"), 1);
 
 // src/core/validators/uixDetection.ts
-var import_promises57 = require("fs/promises");
-var import_node_path60 = __toESM(require("path"), 1);
-var UI_BEARING_SURFACES = /* @__PURE__ */ new Set(["web-ui", "mobile-ui", "desktop-ui", "mixed"]);
-var NON_UI_SURFACES = /* @__PURE__ */ new Set(["non-ui"]);
-function stripCodeBlocks(content) {
-  let stripped = content.replace(/```[\s\S]*?```/g, "");
-  stripped = stripped.replace(/`[^`]+`/g, "");
-  return stripped;
-}
-var HTML_TAG_RE2 = /<(?:style|div|section|span|button|input|form|header|footer|nav|main|aside)\b/i;
-var MERMAID_SCREEN_FLOW_RE2 = /```mermaid[\s\S]*?(?:stateDiagram)[\s\S]*?(?:Screen|Page|View|Dashboard|Login|Settings|Home)\b/i;
-var SCREEN_CONTRACT_YAML_RE = /screens:\s*\n\s*-\s*route:/;
 async function isUiBearingSpec(root) {
-  const specContent = await readSafe2(import_node_path60.default.join(root, "01_Spec.md"));
-  const surfaceMatch = /^\s*-\s*surface:\s*(\S+)/im.exec(specContent);
-  if (surfaceMatch?.[1]) {
-    const surface = surfaceMatch[1].toLowerCase();
-    if (UI_BEARING_SURFACES.has(surface)) return true;
-    if (NON_UI_SURFACES.has(surface)) return false;
-  }
-  try {
-    await (0, import_promises57.readdir)(import_node_path60.default.join(root, "uiux"));
-    return true;
-  } catch {
-  }
-  const contractsContent = await readSafe2(import_node_path60.default.join(root, "uiux", "40_contracts.md"));
-  if (contractsContent && SCREEN_CONTRACT_YAML_RE.test(contractsContent)) return true;
-  const storyContent = await readSafe2(import_node_path60.default.join(root, "03_Story-Workshop.md"));
-  if (storyContent) {
-    const stripped = stripCodeBlocks(storyContent);
-    if (HTML_TAG_RE2.test(stripped)) return true;
-    if (MERMAID_SCREEN_FLOW_RE2.test(storyContent)) return true;
-  }
-  return false;
+  return isUiBearingSurface(root);
 }
 
 // src/core/validators/uixValidators.ts
@@ -17945,6 +17959,177 @@ async function runAllUixValidators(root, config) {
   return issues;
 }
 
+// src/core/validators/skill/fullHarnessSkill.ts
+var import_node_path62 = __toESM(require("path"), 1);
+function harnessIssue(code, message, severity, file, suggestedAction) {
+  return {
+    code,
+    severity,
+    category: "compatibility",
+    message,
+    file,
+    suggested_action: suggestedAction
+  };
+}
+var WORKFLOW_INDICATORS = ["iteration", "loop", "convergence", "evidence"];
+var EVIDENCE_INDICATORS = [
+  "render evidence",
+  "test results",
+  "validator output",
+  "evidence collection"
+];
+var REVIEWER_INDICATORS = ["reviewer", "review findings", "review summary"];
+var CALIBRATION_INDICATORS = ["calibration", "scoring-ready", "threshold"];
+async function validateFullHarnessSkill(skillsDir) {
+  const issues = [];
+  const skillPath = import_node_path62.default.join(skillsDir, "qfai-prototyping-full-harness");
+  const skillMdPath = import_node_path62.default.join(skillPath, "SKILL.md");
+  const content = await readSafe2(skillMdPath);
+  const skillFileExists = content.length > 0;
+  if (!skillFileExists) {
+    issues.push(
+      harnessIssue(
+        "UIX-VAL-FULL-HARNESS-ENTRYPOINT-MISSING",
+        "Dedicated full-harness skill file is missing.",
+        "error",
+        "qfai-prototyping-full-harness/SKILL.md",
+        "Create a dedicated full-harness skill file at the skills directory."
+      )
+    );
+    return {
+      skillFileExists: false,
+      hasWorkflowLoop: false,
+      hasEvidenceCollection: false,
+      hasReviewerInvocation: false,
+      hasCalibrationObligation: false,
+      issues
+    };
+  }
+  const lower = content.toLowerCase();
+  const hasWorkflowLoop = WORKFLOW_INDICATORS.some((i) => lower.includes(i)) && !isRoutingOnly(lower);
+  const hasEvidenceCollection = EVIDENCE_INDICATORS.some((i) => lower.includes(i));
+  const hasReviewerInvocation = REVIEWER_INDICATORS.some((i) => lower.includes(i));
+  const hasCalibrationObligation = CALIBRATION_INDICATORS.some((i) => lower.includes(i));
+  if (!hasWorkflowLoop) {
+    issues.push(
+      harnessIssue(
+        "UIX-VAL-FULL-HARNESS-NO-WORKFLOW",
+        "Full-harness skill file does not define a workflow loop.",
+        "error",
+        "qfai-prototyping-full-harness/SKILL.md",
+        "Add workflow loop definition with iteration, evidence, review, and calibration steps."
+      )
+    );
+  }
+  return {
+    skillFileExists,
+    hasWorkflowLoop,
+    hasEvidenceCollection,
+    hasReviewerInvocation,
+    hasCalibrationObligation,
+    issues
+  };
+}
+function isRoutingOnly(content) {
+  const routingPatterns = [
+    /^this\s+skill\s+(?:routes?|redirects?|delegates?)\s+to/im,
+    /^see\s+`?qfai\s+prototyping/im
+  ];
+  return routingPatterns.some((p) => p.test(content));
+}
+
+// src/core/validators/skill/prototypingSkill.ts
+var BANNED_PHRASES = [
+  "must run runtime checks",
+  "ui routes reachable",
+  "api non-404",
+  "db objects present"
+];
+var REQUIRED_MODES = ["low-cost", "standard", "full-harness"];
+var STATIC_FIRST_INDICATORS = [
+  "static-first",
+  "static checks",
+  "no runtime",
+  "file-based"
+];
+var RUNTIME_HEAVY_INDICATORS = [
+  "browser required by default",
+  "runtime mandatory",
+  "always execute runtime"
+];
+function skillIssue(code, message, severity, suggestedAction) {
+  return {
+    code,
+    severity,
+    category: "compatibility",
+    message,
+    file: "SKILL.md",
+    suggested_action: suggestedAction
+  };
+}
+function scanBannedPhrases(content) {
+  const lower = content.toLowerCase();
+  return BANNED_PHRASES.filter((phrase) => lower.includes(phrase));
+}
+function checkModeHeadings(content) {
+  const present = [];
+  const missing = [];
+  for (const mode of REQUIRED_MODES) {
+    const pattern = new RegExp(`^#+\\s+.*${mode.replace("-", "[-\\s]")}`, "im");
+    if (pattern.test(content)) {
+      present.push(mode);
+    } else {
+      missing.push(mode);
+    }
+  }
+  return { present, missing };
+}
+function hasNonUiNaDocumentation(content) {
+  const lower = content.toLowerCase();
+  return lower.includes("n/a") && (lower.includes("non-ui") || lower.includes("non_ui"));
+}
+function isStaticFirstAligned(content) {
+  const lower = content.toLowerCase();
+  const hasStatic = STATIC_FIRST_INDICATORS.some((i) => lower.includes(i));
+  const hasRuntime = RUNTIME_HEAVY_INDICATORS.some((i) => lower.includes(i));
+  return hasStatic && !hasRuntime;
+}
+function validatePrototypingSkillContent(content) {
+  const bannedPhraseMatches = scanBannedPhrases(content);
+  const { present: modesPresent, missing: modesMissing } = checkModeHeadings(content);
+  const nonUiPath = hasNonUiNaDocumentation(content);
+  const staticFirst = isStaticFirstAligned(content);
+  const issues = [];
+  if (bannedPhraseMatches.length > 0) {
+    issues.push(
+      skillIssue(
+        "UIX-VAL-SKILL-BANNED-PHRASE",
+        `Prototyping skill contains banned phrases: ${bannedPhraseMatches.join(", ")}`,
+        "error",
+        "Remove banned runtime-heavy phrases from the prototyping skill body."
+      )
+    );
+  }
+  if (modesMissing.length > 0) {
+    issues.push(
+      skillIssue(
+        "UIX-VAL-SKILL-MODE-MISSING",
+        `Prototyping skill missing mode sections: ${modesMissing.join(", ")}`,
+        "error",
+        `Add section headings for: ${modesMissing.join(", ")}`
+      )
+    );
+  }
+  return {
+    bannedPhraseMatches,
+    modesPresent,
+    modesMissing,
+    hasNonUiNaPath: nonUiPath,
+    isStaticFirstAligned: staticFirst,
+    issues
+  };
+}
+
 // src/core/validate.ts
 var UIUX_VALIDATION_BUDGET_MS = 2e3;
 async function validateProject(root, configResult, options = {}) {
@@ -17979,6 +18164,11 @@ async function validateProject(root, configResult, options = {}) {
       rule: "uiux.performanceBudget"
     });
   }
+  const skillsDir = resolvePath(root, config, "skillsDir");
+  const fullHarnessResult = await validateFullHarnessSkill(skillsDir);
+  const prototypingSkillPath = import_node_path63.default.join(skillsDir, "qfai-prototyping", "SKILL.md");
+  const prototypingSkillContent = await readSafe2(prototypingSkillPath);
+  const prototypingSkillResult = prototypingSkillContent.length > 0 ? validatePrototypingSkillContent(prototypingSkillContent) : { issues: [] };
   const findings = [
     ...configIssues,
     ...await validateRepositoryHygiene(root, config),
@@ -18009,6 +18199,8 @@ async function validateProject(root, configResult, options = {}) {
     ...await validateNavigationFlow(root, config),
     ...await validateRenderCritique(root, config),
     ...await validateDesignFidelity(root, config),
+    ...fullHarnessResult.issues,
+    ...prototypingSkillResult.issues,
     ...uiuxIssues
   ];
   const { issues, waivers } = await applyWaivers(root, findings);
@@ -18052,15 +18244,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_path62.default.resolve(root);
+  const resolvedRoot = import_node_path64.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_path62.default.join(contractsRoot, "api");
-  const uiRoot = import_node_path62.default.join(contractsRoot, "ui");
-  const dbRoot = import_node_path62.default.join(contractsRoot, "db");
+  const apiRoot = import_node_path64.default.join(contractsRoot, "api");
+  const uiRoot = import_node_path64.default.join(contractsRoot, "ui");
+  const dbRoot = import_node_path64.default.join(contractsRoot, "db");
   const srcRoot = resolvePath(resolvedRoot, config, "srcDir");
   const testsRoot = resolvePath(resolvedRoot, config, "testsDir");
   const specEntries = await collectSpecEntries(specsRoot);
@@ -19345,7 +19537,7 @@ function buildHotspots(issues) {
 async function collectTddCoverage(entries) {
   const specs = [];
   for (const entry of entries) {
-    const testCasesPath = import_node_path62.default.join(entry.dir, "06_Test-Cases.md");
+    const testCasesPath = import_node_path64.default.join(entry.dir, "06_Test-Cases.md");
     let tcContent;
     try {
       tcContent = await (0, import_promises59.readFile)(testCasesPath, "utf-8");
@@ -19380,7 +19572,7 @@ async function collectTddCoverage(entries) {
       });
       continue;
     }
-    const tddListPath = import_node_path62.default.join(entry.dir, "tdd", "test-list.md");
+    const tddListPath = import_node_path64.default.join(entry.dir, "tdd", "test-list.md");
     let tddContent;
     try {
       tddContent = await (0, import_promises59.readFile)(tddListPath, "utf-8");
@@ -19467,7 +19659,7 @@ async function collectTddCoverage(entries) {
 
 // src/core/specPackReport.ts
 var import_promises60 = require("fs/promises");
-var import_node_path63 = __toESM(require("path"), 1);
+var import_node_path65 = __toESM(require("path"), 1);
 var REQUIRED_LEDGER_COLUMNS = [
   "trace_id",
   "obj_id",
@@ -19485,8 +19677,8 @@ async function writeSpecPackReports(root, config) {
   const entries = await collectSpecEntries(specsRoot);
   const contractIndex = await buildContractIndex(root, config);
   for (const entry of entries) {
-    const specName = import_node_path63.default.basename(entry.dir);
-    const outputDir = import_node_path63.default.join(outRoot, specName);
+    const specName = import_node_path65.default.basename(entry.dir);
+    const outputDir = import_node_path65.default.join(outRoot, specName);
     await (0, import_promises60.mkdir)(outputDir, { recursive: true });
     const [acText, tcText, exText, ledgerText] = await Promise.all([
       readSafe12(entry.acceptanceCriteriaPath),
@@ -19513,13 +19705,13 @@ async function writeSpecPackReports(root, config) {
     });
     const graph = buildTraceabilityGraph(ledgerRows);
     await (0, import_promises60.writeFile)(
-      import_node_path63.default.join(outputDir, "coverage.md"),
+      import_node_path65.default.join(outputDir, "coverage.md"),
       `${formatCoverageMarkdown(specName, coverage)}
 `,
       "utf-8"
     );
     await (0, import_promises60.writeFile)(
-      import_node_path63.default.join(outputDir, "traceability-graph.json"),
+      import_node_path65.default.join(outputDir, "traceability-graph.json"),
       `${JSON.stringify(graph, null, 2)}
 `,
       "utf-8"
@@ -19712,7 +19904,7 @@ function warnIfTruncated(scan, context) {
 
 // src/cli/commands/report.ts
 async function runReport(options) {
-  const root = import_node_path64.default.resolve(options.root);
+  const root = import_node_path66.default.resolve(options.root);
   const configResult = await loadConfig(root);
   let validation;
   let blockedByPhaseGuard = false;
@@ -19728,7 +19920,7 @@ async function runReport(options) {
     validation = normalized;
   } else {
     const input = options.inputPath ?? configResult.config.output.validateJsonPath;
-    const inputPath = import_node_path64.default.isAbsolute(input) ? input : import_node_path64.default.resolve(root, input);
+    const inputPath = import_node_path66.default.isAbsolute(input) ? input : import_node_path66.default.resolve(root, input);
     try {
       validation = await readValidationResult(inputPath);
     } catch (err) {
@@ -19755,10 +19947,10 @@ async function runReport(options) {
   warnIfTruncated(data.traceability.testFiles, "report");
   const output = options.format === "json" ? formatReportJson(data) : options.baseUrl ? formatReportMarkdown(data, { baseUrl: options.baseUrl }) : formatReportMarkdown(data);
   const outRoot = resolvePath(root, configResult.config, "outDir");
-  const defaultOut = options.format === "json" ? import_node_path64.default.join(outRoot, "report.json") : import_node_path64.default.join(outRoot, "report.md");
+  const defaultOut = options.format === "json" ? import_node_path66.default.join(outRoot, "report.json") : import_node_path66.default.join(outRoot, "report.md");
   const out = options.outPath ?? defaultOut;
-  const outPath = import_node_path64.default.isAbsolute(out) ? out : import_node_path64.default.resolve(root, out);
-  await (0, import_promises61.mkdir)(import_node_path64.default.dirname(outPath), { recursive: true });
+  const outPath = import_node_path66.default.isAbsolute(out) ? out : import_node_path66.default.resolve(root, out);
+  await (0, import_promises61.mkdir)(import_node_path66.default.dirname(outPath), { recursive: true });
   await (0, import_promises61.writeFile)(outPath, `${output}
 `, "utf-8");
   await writeSpecPackReports(root, configResult.config);
@@ -19834,21 +20026,21 @@ function isMissingFileError2(error2) {
   return record2.code === "ENOENT";
 }
 async function writeValidationResult(root, outputPath, result) {
-  const abs = import_node_path64.default.isAbsolute(outputPath) ? outputPath : import_node_path64.default.resolve(root, outputPath);
-  await (0, import_promises61.mkdir)(import_node_path64.default.dirname(abs), { recursive: true });
+  const abs = import_node_path66.default.isAbsolute(outputPath) ? outputPath : import_node_path66.default.resolve(root, outputPath);
+  await (0, import_promises61.mkdir)(import_node_path66.default.dirname(abs), { recursive: true });
   await (0, import_promises61.writeFile)(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 
 // src/cli/commands/validate.ts
 var import_promises63 = require("fs/promises");
-var import_node_path66 = __toESM(require("path"), 1);
+var import_node_path68 = __toESM(require("path"), 1);
 
 // src/core/runLog.ts
 var import_promises62 = require("fs/promises");
-var import_node_path65 = __toESM(require("path"), 1);
+var import_node_path67 = __toESM(require("path"), 1);
 async function writeValidateRunLog(input) {
-  const root = import_node_path65.default.resolve(input.root);
+  const root = import_node_path67.default.resolve(input.root);
   const outDir = resolvePath(root, input.config, "outDir");
   await (0, import_promises62.mkdir)(outDir, { recursive: true });
   const { runId, reportDir } = await allocateRunReportDir(outDir, input.startedAt);
@@ -19895,10 +20087,10 @@ async function writeValidateRunLog(input) {
     errors,
     warnings
   });
-  await writeJson(import_node_path65.default.join(reportDir, "run.json"), runJson);
-  await writeJson(import_node_path65.default.join(reportDir, "validator.json"), validatorJson);
-  await writeJson(import_node_path65.default.join(reportDir, "traceability.json"), traceabilityJson);
-  await (0, import_promises62.writeFile)(import_node_path65.default.join(reportDir, "summary.md"), `${summaryMd}
+  await writeJson(import_node_path67.default.join(reportDir, "run.json"), runJson);
+  await writeJson(import_node_path67.default.join(reportDir, "validator.json"), validatorJson);
+  await writeJson(import_node_path67.default.join(reportDir, "traceability.json"), traceabilityJson);
+  await (0, import_promises62.writeFile)(import_node_path67.default.join(reportDir, "summary.md"), `${summaryMd}
 `, "utf-8");
   return {
     runId,
@@ -20022,7 +20214,7 @@ async function allocateRunReportDir(outDir, startedAt) {
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
     const candidateDate = new Date(startedAt.getTime() + attempt);
     const runId = `run-${formatTimestamp17(candidateDate)}`;
-    const reportDir = import_node_path65.default.join(outDir, runId);
+    const reportDir = import_node_path67.default.join(outDir, runId);
     try {
       await (0, import_promises62.mkdir)(reportDir);
       return { runId, reportDir };
@@ -20053,7 +20245,7 @@ function shouldFail(result, failOn) {
 // src/cli/commands/validate.ts
 async function runValidate(options) {
   const startedAt = /* @__PURE__ */ new Date();
-  const root = import_node_path66.default.resolve(options.root);
+  const root = import_node_path68.default.resolve(options.root);
   const configResult = await loadConfig(root);
   const blockedIssue = buildCiRefinementIssue(options.phase);
   const blockedByPhaseGuard = blockedIssue !== null;
@@ -20209,12 +20401,12 @@ function issueKey(issue2) {
 }
 async function emitJson(result, root, jsonPath) {
   const abs = resolveJsonPath(root, jsonPath);
-  await (0, import_promises63.mkdir)(import_node_path66.default.dirname(abs), { recursive: true });
+  await (0, import_promises63.mkdir)(import_node_path68.default.dirname(abs), { recursive: true });
   await (0, import_promises63.writeFile)(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 function resolveJsonPath(root, jsonPath) {
-  return import_node_path66.default.isAbsolute(jsonPath) ? jsonPath : import_node_path66.default.resolve(root, jsonPath);
+  return import_node_path68.default.isAbsolute(jsonPath) ? jsonPath : import_node_path68.default.resolve(root, jsonPath);
 }
 var GITHUB_ANNOTATION_LIMIT = 100;
 var ISSUE_EXPECTED_BY_CODE = {