@aisdlc/core 1.4.1 → 1.5.0

package/dist/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
-var fs6 = require('fs');
-var path5 = require('path');
-var yaml2 = require('js-yaml');
+var fs7 = require('fs');
+var path4 = require('path');
+var yaml3 = require('js-yaml');
 var tsMorph = require('ts-morph');
 var crypto = require('crypto');
 var child_process = require('child_process');
@@ -29,9 +29,9 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var fs6__namespace = /*#__PURE__*/_interopNamespace(fs6);
-var path5__namespace = /*#__PURE__*/_interopNamespace(path5);
-var yaml2__default = /*#__PURE__*/_interopDefault(yaml2);
+var fs7__namespace = /*#__PURE__*/_interopNamespace(fs7);
+var path4__namespace = /*#__PURE__*/_interopNamespace(path4);
+var yaml3__default = /*#__PURE__*/_interopDefault(yaml3);
 var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
 var child_process__namespace = /*#__PURE__*/_interopNamespace(child_process);
 
@@ -198,7 +198,7 @@ function buildNodeMetrics(node, filePath) {
   return { functionName, filePath, loc, cyclomatic, cognitive, maintainability: mi, codeSmells };
 }
 function createTempSourceFile(project, content, filePath) {
-  const ext = path5__namespace.extname(filePath).toLowerCase() || ".ts";
+  const ext = path4__namespace.extname(filePath).toLowerCase() || ".ts";
   const fileName = `temp_${Date.now()}_${Math.random().toString(36).substring(2, 7)}${ext}`;
   return project.createSourceFile(fileName, content, { overwrite: true });
 }
@@ -235,7 +235,7 @@ function extractFunctionsTypeScriptAst(content, filePath) {
   }
 }
 function extractFunctionsPolyglot(content, filePath) {
-  const ext = path5__namespace.extname(filePath).toLowerCase();
+  const ext = path4__namespace.extname(filePath).toLowerCase();
   return ext === ".py" ? extractPythonFunctions(content, filePath) : extractBraceFunctions(content, filePath);
 }
 function isDocstringToggle(trimmed) {
@@ -312,7 +312,7 @@ function processBraceLine(line, state, blocks, lineIndex, ext) {
   }
 }
 function extractBraceFunctions(content, filePath) {
-  const ext = path5__namespace.extname(filePath).toLowerCase();
+  const ext = path4__namespace.extname(filePath).toLowerCase();
   const lines = content.split("\n");
   const blocks = [];
   const state = { currentFn: null, braceCount: 0, fnLines: [], inBlockComment: false };
@@ -457,7 +457,7 @@ function countCommentsAndLoc(rawLines, isPy) {
   return { loc, commentCount, cleanLines };
 }
 function calculatePolyglotMetrics(body, name, filePath) {
-  const ext = path5__namespace.extname(filePath).toLowerCase();
+  const ext = path4__namespace.extname(filePath).toLowerCase();
   const rawLines = body.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
   const { loc, commentCount, cleanLines } = countCommentsAndLoc(rawLines, ext === ".py");
   const cyclomatic = computePolyglotCyclomatic(body, ext);
@@ -507,6 +507,652 @@ function computePolyglotCognitive(lines, isPy) {
   }
   return cognitive;
 }
+function walkMdFiles(dir, fileList = [], excludeDirs = [
+  "node_modules",
+  ".git",
+  "dist",
+  "bin",
+  "obj",
+  "build",
+  "out",
+  "target",
+  "coverage",
+  ".changeset",
+  "scratch",
+  "test-scaffold",
+  "fixtures",
+  "templates",
+  "examples",
+  ".agent",
+  ".agents",
+  ".claude",
+  ".cursor",
+  ".github",
+  ".vscode",
+  ".vs",
+  ".idea"
+]) {
+  try {
+    if (!fs7__namespace.existsSync(dir)) return fileList;
+    const files = fs7__namespace.readdirSync(dir);
+    for (const file of files) {
+      const fullPath = path4__namespace.join(dir, file);
+      try {
+        if (fs7__namespace.statSync(fullPath).isDirectory()) {
+          if (!excludeDirs.includes(file) && !file.startsWith("temp-") && !file.startsWith(".temp-")) {
+            walkMdFiles(fullPath, fileList, excludeDirs);
+          }
+        } else if (file.endsWith(".md")) {
+          fileList.push(fullPath);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return fileList;
+}
+function parseMarkdownFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return { frontmatter: {}, body: content };
+  const yamlLines = match[1].split("\n");
+  const frontmatter = {};
+  for (const line of yamlLines) {
+    const parts = line.split(":");
+    if (parts.length >= 2) {
+      const key = parts[0].trim();
+      let val = parts.slice(1).join(":").trim();
+      if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+        val = val.substring(1, val.length - 1);
+      }
+      frontmatter[key] = val;
+    }
+  }
+  const body = content.substring(match[0].length);
+  return { frontmatter, body };
+}
+function extractGherkinBlock(body) {
+  const gherkinRegex = /```gherkin\r?\n([\s\S]*?)\r?\n```/g;
+  const blocks = [];
+  let match;
+  while ((match = gherkinRegex.exec(body)) !== null) {
+    blocks.push(match[1].trim());
+  }
+  return blocks;
+}
+function resolveTargetFiles(rootDir, targetPath) {
+  if (targetPath) {
+    const fullTarget = path4__namespace.isAbsolute(targetPath) ? targetPath : path4__namespace.join(rootDir, targetPath);
+    if (!fs7__namespace.existsSync(fullTarget)) return [];
+    return fs7__namespace.statSync(fullTarget).isDirectory() ? walkMdFiles(fullTarget) : [fullTarget];
+  }
+  const searchDirs = [
+    path4__namespace.join(rootDir, "product"),
+    path4__namespace.join(rootDir, "security"),
+    path4__namespace.join(rootDir, "specs"),
+    path4__namespace.join(rootDir, "examples", "product"),
+    path4__namespace.join(rootDir, "examples", "security"),
+    path4__namespace.join(rootDir, "examples", "specs")
+  ];
+  return searchDirs.filter((d) => fs7__namespace.existsSync(d)).flatMap((d) => walkMdFiles(d));
+}
+function resolveFeatureFilePath(rootDir, filePath, id, customTarget) {
+  if (customTarget) {
+    return path4__namespace.isAbsolute(customTarget) ? customTarget : path4__namespace.join(rootDir, customTarget);
+  }
+  const baseDir = path4__namespace.join(rootDir, "tests", "features");
+  const candidateSecurity = path4__namespace.join(baseDir, "security", `${id.toLowerCase()}.feature`);
+  const candidateRoot = path4__namespace.join(baseDir, `${id.toLowerCase()}.feature`);
+  if (fs7__namespace.existsSync(candidateSecurity)) return candidateSecurity;
+  if (fs7__namespace.existsSync(candidateRoot)) return candidateRoot;
+  const subDir = filePath.includes("security") ? "security" : "";
+  return path4__namespace.join(baseDir, subDir, `${id.toLowerCase()}.feature`);
+}
+function buildFeatureFileContent(rootDir, filePath, id, version, gherkinBlocks) {
+  const banner = [
+    `# ==============================================================================`,
+    `# AUTO-GENERADO POR AI-SDLC (Cucumber Integration)`,
+    `# Origen: ${path4__namespace.relative(rootDir, filePath).replace(/\\/g, "/")}`,
+    `# ID Requerimiento: ${id}`,
+    `# Versi\xF3n: ${version || "1.0.0"}`,
+    `# NO EDITAR MANUALMENTE: Cualquier cambio debe realizarse en el Markdown origen.`,
+    `# ==============================================================================`,
+    "",
+    ""
+  ].join("\n");
+  return banner + gherkinBlocks.join("\n\n") + "\n";
+}
+function countScenarios(gherkinBlocks) {
+  let count = 0;
+  for (const block of gherkinBlocks) {
+    const matches = block.match(/\b(Scenario|Escenario|Scenario Outline|Esquema del escenario):/g);
+    if (matches) count += matches.length;
+  }
+  return count;
+}
+function extractGherkinFeatures(options = {}) {
+  const rootDir = options.rootDir || process.cwd();
+  const features = [];
+  let totalScenarios = 0;
+  const targetFiles = resolveTargetFiles(rootDir, options.targetPath);
+  for (const filePath of targetFiles) {
+    try {
+      const content = fs7__namespace.readFileSync(filePath, "utf-8");
+      const { frontmatter, body } = parseMarkdownFrontmatter(content);
+      const gherkinBlocks = extractGherkinBlock(body);
+      if (gherkinBlocks.length === 0) continue;
+      const id = frontmatter.id || path4__namespace.basename(filePath, path4__namespace.extname(filePath));
+      const targetPath = resolveFeatureFilePath(rootDir, filePath, id, frontmatter["cucumber-feature-file"]);
+      fs7__namespace.mkdirSync(path4__namespace.dirname(targetPath), { recursive: true });
+      const fullContent = buildFeatureFileContent(rootDir, filePath, id, frontmatter.version, gherkinBlocks);
+      fs7__namespace.writeFileSync(targetPath, fullContent, "utf-8");
+      const scenarioCount = countScenarios(gherkinBlocks);
+      totalScenarios += scenarioCount;
+      features.push({
+        sourceFile: path4__namespace.relative(rootDir, filePath).replace(/\\/g, "/"),
+        outputFile: path4__namespace.relative(rootDir, targetPath).replace(/\\/g, "/"),
+        featureName: id,
+        scenarioCount
+      });
+    } catch {
+    }
+  }
+  return { success: true, features, totalScenarios };
+}
+function checkGherkinInSync(options = {}) {
+  const rootDir = options.rootDir || process.cwd();
+  const targetFiles = resolveTargetFiles(rootDir, options.targetPath);
+  const outOfSyncFiles = [];
+  const missingFiles = [];
+  let totalFeatures = 0;
+  for (const filePath of targetFiles) {
+    try {
+      const content = fs7__namespace.readFileSync(filePath, "utf-8");
+      const { frontmatter, body } = parseMarkdownFrontmatter(content);
+      const gherkinBlocks = extractGherkinBlock(body);
+      if (gherkinBlocks.length === 0) continue;
+      totalFeatures++;
+      const id = frontmatter.id || path4__namespace.basename(filePath, path4__namespace.extname(filePath));
+      const targetPath = resolveFeatureFilePath(rootDir, filePath, id, frontmatter["cucumber-feature-file"]);
+      const relTarget = path4__namespace.relative(rootDir, targetPath).replace(/\\/g, "/");
+      if (!fs7__namespace.existsSync(targetPath)) {
+        missingFiles.push(relTarget);
+        continue;
+      }
+      const expectedContent = buildFeatureFileContent(rootDir, filePath, id, frontmatter.version, gherkinBlocks);
+      const actualContent = fs7__namespace.readFileSync(targetPath, "utf-8");
+      if (actualContent.replace(/\r\n/g, "\n") !== expectedContent.replace(/\r\n/g, "\n")) {
+        outOfSyncFiles.push(relTarget);
+      }
+    } catch {
+    }
+  }
+  return {
+    inSync: missingFiles.length === 0 && outOfSyncFiles.length === 0,
+    outOfSyncFiles,
+    missingFiles,
+    totalFeatures
+  };
+}
+
+// src/verifiers/testing-coverage.ts
+function parseTaskVerification(v) {
+  const verification = {};
+  if (v && typeof v === "object") {
+    const rec = v;
+    if (typeof rec["method"] === "string") verification.method = rec["method"];
+    if (typeof rec["command-or-criteria"] === "string") verification.criteria = rec["command-or-criteria"];
+  }
+  return verification;
+}
+function parseTaskItem(t) {
+  return {
+    id: typeof t["id"] === "string" ? t["id"] : String(t["id"] ?? ""),
+    title: typeof t["title"] === "string" ? t["title"] : void 0,
+    verification: parseTaskVerification(t["verification"])
+  };
+}
+function parseVerifiedByTests(verifiedBy) {
+  if (Array.isArray(verifiedBy)) {
+    return verifiedBy.map(String);
+  }
+  if (typeof verifiedBy === "string") {
+    return [verifiedBy];
+  }
+  return void 0;
+}
+function parseGenericDoc(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return { frontmatter: {}, body: content };
+  let parsed;
+  try {
+    parsed = yaml3__default.default.load(match[1]);
+  } catch {
+    return { frontmatter: {}, body: content };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { frontmatter: {}, body: content };
+  }
+  const raw = parsed;
+  const rawTasks = Array.isArray(raw["tasks"]) ? raw["tasks"] : [];
+  const tasks = rawTasks.map(parseTaskItem);
+  const frontmatter = {
+    ...raw,
+    tasks,
+    "verified-by-tests": parseVerifiedByTests(raw["verified-by-tests"])
+  };
+  return { frontmatter, body: content.substring(match[0].length) };
+}
+function buildRequirementsTable(reqAudit) {
+  const lines = [
+    `## 1. Requirements Audit (Product, Quality, and Security)`,
+    ``,
+    `| Requirement ID | Title | Source File | Declared Method | Linked Test Files | Status |`,
+    `| :--- | :--- | :--- | :---: | :--- | :---: |`
+  ];
+  for (const r of reqAudit) {
+    const icon = r.status === "VERIFICADO_CON_PRUEBA" ? "\u2705 VERIFIED" : "\u274C NO TESTS";
+    lines.push(
+      `| **\`${r.id}\`** | ${r.title} | \`${r.file}\` | \`${r.method}\` | \`${r.testRefs}\` | ${icon} |`
+    );
+  }
+  return lines;
+}
+function buildTasksTable(taskAudit) {
+  const lines = [
+    `## 2. Tasks Audit (SDD Delivery Engineering)`,
+    ``,
+    `| Task ID | Title | tasks.md File | Method | Verification Command / Criterion | Status |`,
+    `| :--- | :--- | :--- | :---: | :--- | :---: |`
+  ];
+  for (const t of taskAudit) {
+    const icon = t.status === "VERIFICADO_CON_PRUEBA" ? "\u2705 VERIFIED" : "\u274C NO TESTS";
+    lines.push(
+      `| **\`${t.id}\`** | ${t.title} | \`${t.file}\` | \`${t.method}\` | \`${t.commandOrCriteria}\` | ${icon} |`
+    );
+  }
+  return lines;
+}
+function generateTestingCoverageReportMarkdown(reqAudit, taskAudit, reqErrors, taskErrors) {
+  const totalErrors = reqErrors + taskErrors;
+  const verdict = totalErrors === 0 ? "100% VERIFIED WITH TESTS (PASSED)" : `BLOCKED: Detected ${totalErrors} items without tests (${reqErrors} Requirements, ${taskErrors} Tasks)`;
+  const reportLines = [
+    `# \u{1F9EA} Deterministic Test Coverage Audit for Requirements and Tasks`,
+    ``,
+    `> **Audit Date:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    `> **Overall Verdict:** ${verdict}`,
+    ``,
+    `---`,
+    ``,
+    ...buildRequirementsTable(reqAudit),
+    ``,
+    `---`,
+    ``,
+    ...buildTasksTable(taskAudit)
+  ];
+  return reportLines.join("\n");
+}
+var EXCLUDED_TEST_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "bin",
+  "obj",
+  "build",
+  "out",
+  "target",
+  "coverage",
+  ".changeset",
+  "scratch",
+  "fixtures",
+  "templates",
+  "examples",
+  ".vs",
+  ".idea"
+]);
+var TEST_EXTENSIONS = [".feature", ".spec.ts", ".spec.js", ".test.ts", ".test.js", "_test.py", "_test.go"];
+function isTestFile(fileName) {
+  return TEST_EXTENSIONS.some((ext) => fileName.endsWith(ext));
+}
+function recordRequirementTest(reqToTestsMap, reqId, relTest) {
+  const existing = reqToTestsMap.get(reqId) || [];
+  if (!existing.includes(relTest)) {
+    existing.push(relTest);
+    reqToTestsMap.set(reqId, existing);
+  }
+}
+function parseFeatureTags(content, relTest, reqToTestsMap) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("@")) continue;
+    const tags = trimmed.split(/\s+/).filter((t) => t.startsWith("@"));
+    for (const t of tags) {
+      recordRequirementTest(reqToTestsMap, t.substring(1), relTest);
+    }
+  }
+}
+var REQ_ID_REGEX = /\b(FR|QR|CON|SEC-REQ)-[A-Z0-9]+(-[A-Z0-9]+)*\b/g;
+function parseCodeTestIds(content, relTest, reqToTestsMap) {
+  const idMatches = content.match(REQ_ID_REGEX);
+  if (!idMatches) return;
+  for (const reqId of idMatches) {
+    recordRequirementTest(reqToTestsMap, reqId, relTest);
+  }
+}
+function processTestFile(fullPath, rootDir, reqToTestsMap) {
+  try {
+    const content = fs7__namespace.readFileSync(fullPath, "utf-8");
+    const relTest = path4__namespace.relative(rootDir, fullPath).replace(/\\/g, "/");
+    if (fullPath.endsWith(".feature")) {
+      parseFeatureTags(content, relTest, reqToTestsMap);
+    }
+    parseCodeTestIds(content, relTest, reqToTestsMap);
+  } catch {
+  }
+}
+function collectTestFiles(dir, files = []) {
+  if (!fs7__namespace.existsSync(dir)) return files;
+  try {
+    const entries = fs7__namespace.readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        if (!EXCLUDED_TEST_DIRS.has(e.name)) {
+          collectTestFiles(path4__namespace.join(dir, e.name), files);
+        }
+      } else if (isTestFile(e.name)) {
+        files.push(path4__namespace.join(dir, e.name));
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function scanAllTestArtifacts(rootDir) {
+  const reqToTestsMap = /* @__PURE__ */ new Map();
+  const testFiles = collectTestFiles(rootDir);
+  for (const file of testFiles) {
+    processTestFile(file, rootDir, reqToTestsMap);
+  }
+  return reqToTestsMap;
+}
+var NOMINAL_KEYWORDS = /\b(nominal|happy|valid|exitoso|normal|standard|flujo principal)\b/i;
+var BOUNDARY_KEYWORDS = /\b(boundary|limit|edge|min|max|l[ií]mite|borde|extremo|rango)\b/i;
+var INVALID_KEYWORDS = /\b(invalid|out[- ]of[- ]range|error|null|empty|reject|fail|unauthorized|exception|inv[aá]lido|fuera de rango|rechaz|excepci[oó]n|fallo)\b/i;
+function extractScenariosForReq(gherkinText, reqId) {
+  const lines = gherkinText.split(/\r?\n/);
+  const featureApplies = gherkinText.includes(`@${reqId}`);
+  if (!featureApplies) return [];
+  const chunks = [];
+  let pendingTags = "";
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (line.startsWith("@")) {
+      pendingTags += " " + line;
+    } else if (/^(Scenario|Escenario|Scenario Outline|Esquema del escenario):/i.test(line)) {
+      const isOutline = /^(Scenario Outline|Esquema del escenario):/i.test(line);
+      chunks.push({ tags: pendingTags.toLowerCase(), header: line, isOutline });
+      pendingTags = "";
+    }
+  }
+  return chunks;
+}
+var INVALID_TAG_RE = /@(invalid|error|out-of-range)\b/i;
+function isInvalidScenario(chunk, combined) {
+  return INVALID_TAG_RE.test(chunk.tags) || INVALID_KEYWORDS.test(combined);
+}
+function isBoundaryScenario(chunk, combined, isInvalid) {
+  if (chunk.tags.includes("@boundary") || BOUNDARY_KEYWORDS.test(combined)) return true;
+  return chunk.isOutline && !isInvalid;
+}
+function classifyScenarioChunk(chunk, cov) {
+  const combined = `${chunk.tags} ${chunk.header}`;
+  const isInvalid = isInvalidScenario(chunk, combined);
+  const isBoundary = isBoundaryScenario(chunk, combined, isInvalid);
+  const isNominal = chunk.tags.includes("@nominal") || NOMINAL_KEYWORDS.test(combined) || !isInvalid && !isBoundary;
+  if (isNominal) cov.nominal = true;
+  if (isBoundary) cov.boundary = true;
+  if (isInvalid) cov.invalid = true;
+}
+function analyzeBddVariantsForRequirement(reqId, gherkinSources) {
+  const cov = { nominal: false, boundary: false, invalid: false, totalScenarios: 0 };
+  for (const src of gherkinSources) {
+    const chunks = extractScenariosForReq(src, reqId);
+    cov.totalScenarios += chunks.length;
+    for (const chunk of chunks) {
+      classifyScenarioChunk(chunk, cov);
+    }
+  }
+  return cov;
+}
+function computeMissingVariants(cov) {
+  const missing = [];
+  if (!cov.nominal) missing.push("nominal");
+  if (!cov.boundary) missing.push("boundary");
+  if (!cov.invalid) missing.push("invalid");
+  return missing;
+}
+var REQ_PREFIXES = ["FR-", "QR-", "CON-", "SEC-REQ-"];
+function isRequirementArtifact(frontmatter, id) {
+  if (frontmatter.type === "requirement" || frontmatter.type === "security-requirement") {
+    return true;
+  }
+  return REQ_PREFIXES.some((prefix) => id.startsWith(prefix));
+}
+function resolveRequirementMethod(declaredMethod, matchingTests) {
+  if (typeof declaredMethod === "string" && declaredMethod) {
+    return declaredMethod;
+  }
+  return matchingTests.some((t) => t.endsWith(".feature")) ? "BDD_CUCUMBER" : "TEST_EXECUTION";
+}
+function shouldEnforceVariantsForReq(id, frontmatter, options) {
+  if (!id.startsWith("FR-")) return false;
+  return Boolean(options.enforceBddVariants || frontmatter["enforce-bdd-variants"] === true);
+}
+function evaluateReqVerification(id, isTemplate, hasTests, missingVariants, frontmatter, options) {
+  if (isTemplate) return true;
+  const enforceVariants = shouldEnforceVariantsForReq(id, frontmatter, options);
+  const variantsOk = !enforceVariants || missingVariants.length === 0;
+  return hasTests && variantsOk;
+}
+function formatTestRefs(matchingTests, relPath, totalScenarios) {
+  if (matchingTests.length > 0) return matchingTests.join(", ");
+  return totalScenarios > 0 ? `${relPath} (gherkin)` : "NINGUNA DETECTADA";
+}
+function buildRequirementAuditItem(frontmatter, id, relPath, isTemplate, matchingTests, bddVariants, missingVariants, isVerified) {
+  const status = isVerified ? "VERIFICADO_CON_PRUEBA" : "FALLO_SIN_PRUEBA";
+  return {
+    id: id || "SIN-ID",
+    title: frontmatter.title || "Sin t\xEDtulo",
+    file: relPath,
+    isTemplate,
+    method: resolveRequirementMethod(frontmatter["verifiable-by"], matchingTests),
+    testRefs: formatTestRefs(matchingTests, relPath, bddVariants.totalScenarios),
+    existingCount: matchingTests.length || bddVariants.totalScenarios,
+    bddVariants,
+    missingVariants,
+    status
+  };
+}
+function auditRequirement(frontmatter, id, relPath, isTemplate, reqToTestsMap, gherkinSources, options) {
+  const matchingTests = reqToTestsMap.get(id) || [];
+  const bddVariants = analyzeBddVariantsForRequirement(id, gherkinSources);
+  const missingVariants = id.startsWith("FR-") ? computeMissingVariants(bddVariants) : [];
+  const hasTests = matchingTests.length > 0 || bddVariants.totalScenarios > 0;
+  const isVerified = evaluateReqVerification(id, isTemplate, hasTests, missingVariants, frontmatter, options);
+  const item = buildRequirementAuditItem(
+    frontmatter,
+    id,
+    relPath,
+    isTemplate,
+    matchingTests,
+    bddVariants,
+    missingVariants,
+    isVerified
+  );
+  return { item, isError: !isVerified };
+}
+function parseSingleFlowEntry(entry) {
+  if (typeof entry === "string") return entry.trim();
+  if (entry && typeof entry === "object") {
+    const rec = entry;
+    return String(rec.id || rec.name || "").trim();
+  }
+  return "";
+}
+function extractDeclaredUseCaseFlows(frontmatter) {
+  const flows = [];
+  const rawLists = [frontmatter["alternative-flows"], frontmatter["exception-flows"]];
+  for (const list of rawLists) {
+    if (!Array.isArray(list)) continue;
+    for (const entry of list) {
+      const flowId = parseSingleFlowEntry(entry);
+      if (flowId) flows.push(flowId);
+    }
+  }
+  return flows;
+}
+function auditUseCaseFlowItem(id, relPath, declaredFlows, combinedTestsText) {
+  const coveredFlows = [];
+  const missingFlows = [];
+  const lowerCorpus = combinedTestsText.toLowerCase();
+  for (const flow of declaredFlows) {
+    if (lowerCorpus.includes(flow.toLowerCase())) {
+      coveredFlows.push(flow);
+    } else {
+      missingFlows.push(flow);
+    }
+  }
+  return {
+    id,
+    file: relPath,
+    declaredFlows,
+    coveredFlows,
+    missingFlows,
+    status: missingFlows.length === 0 ? "VERIFICADO_CON_PRUEBA" : "FALLO_SIN_PRUEBA"
+  };
+}
+function isTaskProofValid(criteria, isTemplate) {
+  if (isTemplate) return true;
+  return criteria.length > 4 && !criteria.includes("TODO") && !criteria.includes("TBD");
+}
+function auditSingleTask(t, relPath, isTemplate) {
+  const crit = t.verification?.criteria || "";
+  const method = t.verification?.method || "TEST_EXECUTION";
+  const hasProof = isTaskProofValid(crit, isTemplate);
+  return {
+    item: {
+      id: t.id,
+      title: t.title || "Sin t\xEDtulo",
+      file: relPath,
+      method,
+      commandOrCriteria: crit || "AUSENTE",
+      status: hasProof ? "VERIFICADO_CON_PRUEBA" : "FALLO_SIN_PRUEBA"
+    },
+    hasProof
+  };
+}
+function auditTasks(tasks, relPath, isTemplate) {
+  if (!Array.isArray(tasks) || tasks.length === 0) {
+    return { items: [], errorCount: 0 };
+  }
+  const items = [];
+  let errorCount = 0;
+  for (const t of tasks) {
+    const { item, hasProof } = auditSingleTask(t, relPath, isTemplate);
+    if (!hasProof) errorCount++;
+    items.push(item);
+  }
+  return { items, errorCount };
+}
+function collectTestCorpus(rootDir, allMdFiles) {
+  const gherkinSources = [];
+  const testContents = [];
+  for (const tf of collectTestFiles(rootDir)) {
+    try {
+      const content = fs7__namespace.readFileSync(tf, "utf-8");
+      testContents.push(content);
+      if (tf.endsWith(".feature")) gherkinSources.push(content);
+    } catch {
+    }
+  }
+  for (const md of allMdFiles) {
+    try {
+      const blocks = extractGherkinBlock(fs7__namespace.readFileSync(md, "utf-8"));
+      gherkinSources.push(...blocks);
+      testContents.push(...blocks);
+    } catch {
+    }
+  }
+  return { gherkinSources, combinedTests: testContents.join("\n") };
+}
+function assembleCoverageResult(reqAudit, taskAudit, useCaseFlows, reqErrors, taskErrors, ucErrors) {
+  return {
+    success: reqErrors === 0 && taskErrors === 0 && ucErrors === 0,
+    totalRequirements: reqAudit.length,
+    passedRequirements: reqAudit.length - reqErrors,
+    failedRequirements: reqErrors,
+    totalTasks: taskAudit.length,
+    passedTasks: taskAudit.length - taskErrors,
+    failedTasks: taskErrors,
+    requirements: reqAudit,
+    tasks: taskAudit,
+    useCaseFlows,
+    failedUseCaseFlows: ucErrors,
+    reportMarkdown: generateTestingCoverageReportMarkdown(reqAudit, taskAudit, reqErrors, taskErrors)
+  };
+}
+function recordUseCaseAuditIfPresent(frontmatter, id, relPath, isTemplate, combinedTests, state) {
+  if (isTemplate || !(frontmatter.type === "use-case" || id.startsWith("UC-"))) return;
+  const declaredFlows = extractDeclaredUseCaseFlows(frontmatter);
+  if (declaredFlows.length === 0) return;
+  const flowAudit = auditUseCaseFlowItem(id, relPath, declaredFlows, combinedTests);
+  state.useCaseFlows.push(flowAudit);
+  if (flowAudit.status === "FALLO_SIN_PRUEBA") state.ucErrors++;
+}
+function processMdFileForCoverage(file, rootDir, reqToTestsMap, corpus, options, state) {
+  const { frontmatter } = parseGenericDoc(fs7__namespace.readFileSync(file, "utf-8"));
+  const relPath = path4__namespace.relative(rootDir, file).replace(/\\/g, "/");
+  const isTemplate = relPath.includes("templates/");
+  const id = frontmatter.id || "";
+  if (isRequirementArtifact(frontmatter, id)) {
+    const audited = auditRequirement(frontmatter, id, relPath, isTemplate, reqToTestsMap, corpus.gherkinSources, options);
+    state.reqAudit.push(audited.item);
+    if (audited.isError) state.reqErrors++;
+  }
+  recordUseCaseAuditIfPresent(frontmatter, id, relPath, isTemplate, corpus.combinedTests, state);
+  const auditedTasks = auditTasks(frontmatter.tasks, relPath, isTemplate);
+  state.taskAudit.push(...auditedTasks.items);
+  state.taskErrors += auditedTasks.errorCount;
+}
+function verifyTestingCoverage(options = {}) {
+  const rootDir = options.rootDir || process.cwd();
+  const allMdFiles = walkMdFiles(rootDir);
+  const reqToTestsMap = scanAllTestArtifacts(rootDir);
+  const corpus = collectTestCorpus(rootDir, allMdFiles);
+  const state = {
+    reqAudit: [],
+    taskAudit: [],
+    useCaseFlows: [],
+    reqErrors: 0,
+    taskErrors: 0,
+    ucErrors: 0
+  };
+  for (const file of allMdFiles) {
+    try {
+      processMdFileForCoverage(file, rootDir, reqToTestsMap, corpus, options, state);
+    } catch {
+    }
+  }
+  return assembleCoverageResult(
+    state.reqAudit,
+    state.taskAudit,
+    state.useCaseFlows,
+    state.reqErrors,
+    state.taskErrors,
+    state.ucErrors
+  );
+}
 
 // src/verifiers/quality-gate.ts
 var DEFAULT_EXTENSIONS = [
@@ -621,7 +1267,7 @@ function applyOptionOverrides(policy, overrides) {
 function parseQualityPolicy(content, overrides) {
   const policy = createDefaultQualityPolicy();
   try {
-    const doc = yaml2__default.default.load(content);
+    const doc = yaml3__default.default.load(content);
     if (doc && typeof doc === "object") {
       const record = doc;
       applyDocScope(policy, record);
@@ -637,7 +1283,7 @@ function parseQualityPolicy(content, overrides) {
   return policy;
 }
 function extractFunctions(content, filePath) {
-  const ext = path5__namespace.extname(filePath).toLowerCase();
+  const ext = path4__namespace.extname(filePath).toLowerCase();
   return TS_JS_EXTENSIONS.includes(ext) ? extractFunctionsTypeScriptAst(content, filePath) : extractFunctionsPolyglot(content, filePath);
 }
 function extractFunctionsBraceLanguages(content, filePath) {
@@ -668,55 +1314,55 @@ function isExcludedFile(file, normalized, excludePatterns) {
   );
 }
 function walkDir(dir, extensions = DEFAULT_EXTENSIONS, excludePatterns = DEFAULT_EXCLUDES) {
-  if (!fs6__namespace.existsSync(dir)) return [];
+  if (!fs7__namespace.existsSync(dir)) return [];
   const results = [];
-  for (const file of fs6__namespace.readdirSync(dir)) {
-    const fullPath = path5__namespace.join(dir, file);
+  for (const file of fs7__namespace.readdirSync(dir)) {
+    const fullPath = path4__namespace.join(dir, file);
     const normalized = fullPath.replace(/\\/g, "/");
     if (isExcludedFile(file, normalized, excludePatterns)) continue;
-    const stat = fs6__namespace.statSync(fullPath);
+    const stat = fs7__namespace.statSync(fullPath);
     if (stat.isDirectory()) {
       results.push(...walkDir(fullPath, extensions, excludePatterns));
-    } else if (extensions.includes(path5__namespace.extname(file).toLowerCase())) {
+    } else if (extensions.includes(path4__namespace.extname(file).toLowerCase())) {
       results.push(fullPath);
     }
   }
   return results;
 }
 function resolvePolicy(rootDir, options) {
-  const policyFile = options.policyPath || path5__namespace.join(rootDir, "quality-policy.yaml");
+  const policyFile = options.policyPath || path4__namespace.join(rootDir, "quality-policy.yaml");
   if (options.policy) {
     const policy = { ...options.policy };
     applyOptionOverrides(policy, options.thresholds);
     return policy;
   }
-  if (fs6__namespace.existsSync(policyFile)) {
-    return parseQualityPolicy(fs6__namespace.readFileSync(policyFile, "utf-8"), options.thresholds);
+  if (fs7__namespace.existsSync(policyFile)) {
+    return parseQualityPolicy(fs7__namespace.readFileSync(policyFile, "utf-8"), options.thresholds);
   }
   return parseQualityPolicy("", options.thresholds);
 }
 function isPathExcluded(targetPath, rootDir, excludePatterns) {
-  const rel = path5__namespace.relative(rootDir, targetPath).replace(/\\/g, "/");
-  const base = path5__namespace.basename(targetPath);
+  const rel = path4__namespace.relative(rootDir, targetPath).replace(/\\/g, "/");
+  const base = path4__namespace.basename(targetPath);
   return excludePatterns.some(
     (pat) => base === pat || rel === pat || rel.startsWith(pat + "/") || rel.includes("/" + pat + "/") || rel.endsWith("/" + pat) || rel.includes(pat)
   );
 }
 function scanContainerSubdir(containerDir, subdirName, targetDir, rootDir, policy, files) {
   if (policy.exclude_patterns.includes(subdirName)) return;
-  const subTarget = path5__namespace.join(containerDir, subdirName, targetDir);
-  if (!fs6__namespace.existsSync(subTarget) || !fs6__namespace.statSync(subTarget).isDirectory()) return;
+  const subTarget = path4__namespace.join(containerDir, subdirName, targetDir);
+  if (!fs7__namespace.existsSync(subTarget) || !fs7__namespace.statSync(subTarget).isDirectory()) return;
   if (isPathExcluded(subTarget, rootDir, policy.exclude_patterns)) return;
   for (const f of walkDir(subTarget, policy.supported_extensions, policy.exclude_patterns)) {
     files.add(f);
   }
 }
 function scanMonorepoContainer(rootDir, container, targetDir, policy, files) {
-  const containerDir = path5__namespace.join(rootDir, container);
-  if (!fs6__namespace.existsSync(containerDir) || !fs6__namespace.statSync(containerDir).isDirectory()) return;
+  const containerDir = path4__namespace.join(rootDir, container);
+  if (!fs7__namespace.existsSync(containerDir) || !fs7__namespace.statSync(containerDir).isDirectory()) return;
   if (isPathExcluded(containerDir, rootDir, policy.exclude_patterns)) return;
   try {
-    for (const subdir of fs6__namespace.readdirSync(containerDir, { withFileTypes: true })) {
+    for (const subdir of fs7__namespace.readdirSync(containerDir, { withFileTypes: true })) {
       if (subdir.isDirectory()) {
         scanContainerSubdir(containerDir, subdir.name, targetDir, rootDir, policy, files);
       }
@@ -725,8 +1371,8 @@ function scanMonorepoContainer(rootDir, container, targetDir, policy, files) {
   }
 }
 function scanDirectTarget(rootDir, targetDir, policy, files) {
-  const fullDir = path5__namespace.join(rootDir, targetDir);
-  if (fs6__namespace.existsSync(fullDir) && !isPathExcluded(fullDir, rootDir, policy.exclude_patterns)) {
+  const fullDir = path4__namespace.join(rootDir, targetDir);
+  if (fs7__namespace.existsSync(fullDir) && !isPathExcluded(fullDir, rootDir, policy.exclude_patterns)) {
     for (const f of walkDir(fullDir, policy.supported_extensions, policy.exclude_patterns)) {
       files.add(f);
     }
@@ -763,23 +1409,86 @@ function evaluateViolations(fn, policy) {
   return violations;
 }
 function evaluateFileQuality(file, rootDir, policy) {
-  const content = fs6__namespace.readFileSync(file, "utf-8");
+  const content = fs7__namespace.readFileSync(file, "utf-8");
   const fns = extractFunctions(content, file);
   return fns.map((fn) => {
     const violations = evaluateViolations(fn, policy);
     return {
       ...fn,
-      relPath: path5__namespace.relative(rootDir, file).replace(/\\/g, "/"),
+      relPath: path4__namespace.relative(rootDir, file).replace(/\\/g, "/"),
       status: violations.length === 0 ? "PASS" : "FAIL",
       violations
     };
   });
 }
-function buildQualityGateResult(results, totalFiles, policy) {
+var UNIT_TEST_SUFFIXES = [".spec.ts", ".test.ts", ".spec.js", ".test.js", "_test.py", "_test.go"];
+function collectUnitTestCorpus(rootDir) {
+  const allCodeFiles = walkDir(rootDir, DEFAULT_EXTENSIONS, DEFAULT_EXCLUDES);
+  const chunks = [];
+  for (const tf of allCodeFiles) {
+    if (!UNIT_TEST_SUFFIXES.some((s) => tf.endsWith(s))) continue;
+    try {
+      chunks.push(fs7__namespace.readFileSync(tf, "utf-8"));
+    } catch {
+    }
+  }
+  return chunks.join("\n");
+}
+function auditUnitTestsPerFunction(results, rootDir) {
+  const corpus = collectUnitTestCorpus(rootDir);
+  const untested = [];
+  for (const r of results) {
+    const fnName = r.functionName.includes(".") ? r.functionName.split(".").pop() : r.functionName;
+    if (!fnName || fnName === "anonymous" || fnName === "constructor") continue;
+    if (!corpus.includes(fnName)) {
+      untested.push({ file: r.relPath, functionName: r.functionName });
+      r.violations.push(`Missing unit test for function '${r.functionName}'`);
+      r.status = "FAIL";
+    }
+  }
+  return untested;
+}
+function readSummaryCoverageJson(rootDir) {
+  for (const rel of ["coverage/coverage-summary.json", "reports/coverage-summary.json"]) {
+    const full = path4__namespace.join(rootDir, rel);
+    if (!fs7__namespace.existsSync(full)) continue;
+    try {
+      const raw = JSON.parse(fs7__namespace.readFileSync(full, "utf-8"));
+      const total = raw.total;
+      if (!total) continue;
+      return {
+        linesPct: Number(total.lines?.pct ?? 0),
+        branchesPct: Number(total.branches?.pct ?? 0),
+        functionsPct: Number(total.functions?.pct ?? 0),
+        source: rel
+      };
+    } catch {
+    }
+  }
+  return null;
+}
+function checkCoverageThreshold(label, actual, min, out) {
+  if (actual < min) {
+    out.push(`${label} coverage ${actual}% is below minimum threshold of ${min}%`);
+  }
+}
+function evaluateCoverageThresholds(rootDir, policy, requireReport) {
+  const cov = readSummaryCoverageJson(rootDir);
+  if (!cov) {
+    return requireReport ? ["Missing code coverage summary report (coverage/coverage-summary.json)"] : [];
+  }
+  const violations = [];
+  checkCoverageThreshold("Line", cov.linesPct, policy.min_line_coverage, violations);
+  checkCoverageThreshold("Branch", cov.branchesPct, policy.min_branch_coverage, violations);
+  checkCoverageThreshold("Function", cov.functionsPct, policy.min_function_coverage, violations);
+  return violations;
+}
+function buildQualityGateResult(results, totalFiles, policy, coverageViolations, untestedFunctions) {
   const failCount = results.filter((r) => r.status === "FAIL").length;
   const passCount = results.length - failCount;
-  const violationsCount = results.reduce((acc, r) => acc + r.violations.length, 0);
-  const success = policy.enforce_mode === "STRICT" ? failCount === 0 : true;
+  const violationsCount = results.reduce((acc, r) => acc + r.violations.length, 0) + coverageViolations.length;
+  const hasFailures = failCount > 0 || coverageViolations.length > 0;
+  const success = policy.enforce_mode === "STRICT" ? !hasFailures : true;
   return {
     success,
     totalFiles,
@@ -788,7 +1497,9 @@ function buildQualityGateResult(results, totalFiles, policy) {
     failCount,
     violationsCount,
     results,
-    policy
+    policy,
+    coverageViolations,
+    untestedFunctions
   };
 }
 function verifyQualityGate(options = {}) {
@@ -802,199 +1513,10 @@ function verifyQualityGate(options = {}) {
     } catch {
     }
   }
-  return buildQualityGateResult(results, allFiles.length, policy);
-}
-function walkMdFiles(dir, fileList = [], excludeDirs = [
-  "node_modules",
-  ".git",
-  "dist",
-  "bin",
-  "obj",
-  "build",
-  "out",
-  "target",
-  "coverage",
-  ".changeset",
-  "scratch",
-  "test-scaffold",
-  "fixtures",
-  "templates",
-  "examples",
-  ".agent",
-  ".agents",
-  ".claude",
-  ".cursor",
-  ".github",
-  ".vscode",
-  ".vs",
-  ".idea"
-]) {
-  try {
-    if (!fs6__namespace.existsSync(dir)) return fileList;
-    const files = fs6__namespace.readdirSync(dir);
-    for (const file of files) {
-      const fullPath = path5__namespace.join(dir, file);
-      try {
-        if (fs6__namespace.statSync(fullPath).isDirectory()) {
-          if (!excludeDirs.includes(file) && !file.startsWith("temp-") && !file.startsWith(".temp-")) {
-            walkMdFiles(fullPath, fileList, excludeDirs);
-          }
-        } else if (file.endsWith(".md")) {
-          fileList.push(fullPath);
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return fileList;
-}
-
-// src/verifiers/gherkin.ts
-function parseMarkdownFrontmatter(content) {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match) return { frontmatter: {}, body: content };
-  const yamlLines = match[1].split("\n");
-  const frontmatter = {};
-  for (const line of yamlLines) {
-    const parts = line.split(":");
-    if (parts.length >= 2) {
-      const key = parts[0].trim();
-      let val = parts.slice(1).join(":").trim();
-      if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
-        val = val.substring(1, val.length - 1);
-      }
-      frontmatter[key] = val;
-    }
-  }
-  const body = content.substring(match[0].length);
-  return { frontmatter, body };
-}
-function extractGherkinBlock(body) {
-  const gherkinRegex = /```gherkin\r?\n([\s\S]*?)\r?\n```/g;
-  const blocks = [];
-  let match;
-  while ((match = gherkinRegex.exec(body)) !== null) {
-    blocks.push(match[1].trim());
-  }
-  return blocks;
-}
-function resolveTargetFiles(rootDir, targetPath) {
-  if (targetPath) {
-    const fullTarget = path5__namespace.isAbsolute(targetPath) ? targetPath : path5__namespace.join(rootDir, targetPath);
-    if (!fs6__namespace.existsSync(fullTarget)) return [];
-    return fs6__namespace.statSync(fullTarget).isDirectory() ? walkMdFiles(fullTarget) : [fullTarget];
-  }
-  const searchDirs = [
-    path5__namespace.join(rootDir, "product"),
-    path5__namespace.join(rootDir, "security"),
-    path5__namespace.join(rootDir, "specs"),
-    path5__namespace.join(rootDir, "examples", "product"),
-    path5__namespace.join(rootDir, "examples", "security"),
-    path5__namespace.join(rootDir, "examples", "specs")
-  ];
-  return searchDirs.filter((d) => fs6__namespace.existsSync(d)).flatMap((d) => walkMdFiles(d));
-}
-function resolveFeatureFilePath(rootDir, filePath, id, customTarget) {
-  if (customTarget) {
-    return path5__namespace.isAbsolute(customTarget) ? customTarget : path5__namespace.join(rootDir, customTarget);
-  }
-  const baseDir = path5__namespace.join(rootDir, "tests", "features");
-  const candidateSecurity = path5__namespace.join(baseDir, "security", `${id.toLowerCase()}.feature`);
-  const candidateRoot = path5__namespace.join(baseDir, `${id.toLowerCase()}.feature`);
-  if (fs6__namespace.existsSync(candidateSecurity)) return candidateSecurity;
-  if (fs6__namespace.existsSync(candidateRoot)) return candidateRoot;
-  const subDir = filePath.includes("security") ? "security" : "";
-  return path5__namespace.join(baseDir, subDir, `${id.toLowerCase()}.feature`);
-}
-function buildFeatureFileContent(rootDir, filePath, id, version, gherkinBlocks) {
-  const banner = [
-    `# ==============================================================================`,
-    `# AUTO-GENERADO POR AI-SDLC (Cucumber Integration)`,
-    `# Origen: ${path5__namespace.relative(rootDir, filePath).replace(/\\/g, "/")}`,
-    `# ID Requerimiento: ${id}`,
-    `# Versi\xF3n: ${version || "1.0.0"}`,
-    `# NO EDITAR MANUALMENTE: Cualquier cambio debe realizarse en el Markdown origen.`,
-    `# ==============================================================================`,
-    "",
-    ""
-  ].join("\n");
-  return banner + gherkinBlocks.join("\n\n") + "\n";
-}
-function countScenarios(gherkinBlocks) {
-  let count = 0;
-  for (const block of gherkinBlocks) {
-    const matches = block.match(/\b(Scenario|Escenario|Scenario Outline|Esquema del escenario):/g);
-    if (matches) count += matches.length;
-  }
-  return count;
-}
-function extractGherkinFeatures(options = {}) {
-  const rootDir = options.rootDir || process.cwd();
-  const features = [];
-  let totalScenarios = 0;
-  const targetFiles = resolveTargetFiles(rootDir, options.targetPath);
-  for (const filePath of targetFiles) {
-    try {
-      const content = fs6__namespace.readFileSync(filePath, "utf-8");
-      const { frontmatter, body } = parseMarkdownFrontmatter(content);
-      const gherkinBlocks = extractGherkinBlock(body);
-      if (gherkinBlocks.length === 0) continue;
-      const id = frontmatter.id || path5__namespace.basename(filePath, path5__namespace.extname(filePath));
-      const targetPath = resolveFeatureFilePath(rootDir, filePath, id, frontmatter["cucumber-feature-file"]);
-      fs6__namespace.mkdirSync(path5__namespace.dirname(targetPath), { recursive: true });
-      const fullContent = buildFeatureFileContent(rootDir, filePath, id, frontmatter.version, gherkinBlocks);
-      fs6__namespace.writeFileSync(targetPath, fullContent, "utf-8");
-      const scenarioCount = countScenarios(gherkinBlocks);
-      totalScenarios += scenarioCount;
-      features.push({
-        sourceFile: path5__namespace.relative(rootDir, filePath).replace(/\\/g, "/"),
-        outputFile: path5__namespace.relative(rootDir, targetPath).replace(/\\/g, "/"),
-        featureName: id,
-        scenarioCount
-      });
-    } catch {
-    }
-  }
-  return { success: true, features, totalScenarios };
-}
-function checkGherkinInSync(options = {}) {
-  const rootDir = options.rootDir || process.cwd();
-  const targetFiles = resolveTargetFiles(rootDir, options.targetPath);
-  const outOfSyncFiles = [];
-  const missingFiles = [];
-  let totalFeatures = 0;
-  for (const filePath of targetFiles) {
-    try {
-      const content = fs6__namespace.readFileSync(filePath, "utf-8");
-      const { frontmatter, body } = parseMarkdownFrontmatter(content);
-      const gherkinBlocks = extractGherkinBlock(body);
-      if (gherkinBlocks.length === 0) continue;
-      totalFeatures++;
-      const id = frontmatter.id || path5__namespace.basename(filePath, path5__namespace.extname(filePath));
-      const targetPath = resolveFeatureFilePath(rootDir, filePath, id, frontmatter["cucumber-feature-file"]);
-      const relTarget = path5__namespace.relative(rootDir, targetPath).replace(/\\/g, "/");
-      if (!fs6__namespace.existsSync(targetPath)) {
-        missingFiles.push(relTarget);
-        continue;
-      }
-      const expectedContent = buildFeatureFileContent(rootDir, filePath, id, frontmatter.version, gherkinBlocks);
-      const actualContent = fs6__namespace.readFileSync(targetPath, "utf-8");
-      if (actualContent.replace(/\r\n/g, "\n") !== expectedContent.replace(/\r\n/g, "\n")) {
-        outOfSyncFiles.push(relTarget);
-      }
-    } catch {
-    }
-  }
-  return {
-    inSync: missingFiles.length === 0 && outOfSyncFiles.length === 0,
-    outOfSyncFiles,
-    missingFiles,
-    totalFeatures
-  };
+  const untestedFunctions = options.requireFunctionUnitTests ? auditUnitTestsPerFunction(results, rootDir) : [];
+  const coverageViolations = evaluateCoverageThresholds(rootDir, policy, options.requireCoverageReport);
+  return buildQualityGateResult(results, allFiles.length, policy, coverageViolations, untestedFunctions);
 }
-
-// src/adapters/sdd/openspec.ts
 function normalizeHandoffPayload(handoff, changeId) {
   return {
     ...handoff,
@@ -1004,12 +1526,12 @@ function normalizeHandoffPayload(handoff, changeId) {
   };
 }
 function parseChangeProfile(specFile) {
-  if (!fs6__namespace.existsSync(specFile)) return "standard";
+  if (!fs7__namespace.existsSync(specFile)) return "standard";
   try {
-    const rawSpec = fs6__namespace.readFileSync(specFile, "utf-8").replace(/^\uFEFF/, "");
+    const rawSpec = fs7__namespace.readFileSync(specFile, "utf-8").replace(/^\uFEFF/, "");
     const match = rawSpec.match(/^---\r?\n([\s\S]*?)\r?\n---/);
     if (match) {
-      const parsedFm = yaml2__default.default.load(match[1]);
+      const parsedFm = yaml3__default.default.load(match[1]);
       if (parsedFm?.profile && ["patch", "standard", "critical"].includes(String(parsedFm.profile))) {
         return parsedFm.profile;
       }
@@ -1028,15 +1550,15 @@ function checkSpecGherkinFormat(parsedFm, rawSpec, changeWorkspaceDir, errors) {
   }
 }
 function validateSpecFileContent(specFile, changeWorkspaceDir, errors) {
-  if (!fs6__namespace.existsSync(specFile)) {
+  if (!fs7__namespace.existsSync(specFile)) {
     errors.push(`Falta el archivo obligatorio 'spec.md' en ${changeWorkspaceDir}.`);
     return;
   }
   try {
-    const rawSpec = fs6__namespace.readFileSync(specFile, "utf-8").replace(/^\uFEFF/, "");
+    const rawSpec = fs7__namespace.readFileSync(specFile, "utf-8").replace(/^\uFEFF/, "");
     const match = rawSpec.match(/^---\r?\n([\s\S]*?)\r?\n---/);
     if (match) {
-      const parsedFm = yaml2__default.default.load(match[1]);
+      const parsedFm = yaml3__default.default.load(match[1]);
       if (parsedFm) checkSpecGherkinFormat(parsedFm, rawSpec, changeWorkspaceDir, errors);
     }
   } catch {
@@ -1052,19 +1574,19 @@ function validateHandoffSidecar(handoff, changeWorkspaceDir, errors) {
   if (!handoff.subgraph || !Array.isArray(handoff.subgraph.requirements)) {
     errors.push(`El sidecar '${handoff.id}' no define un subgrafo de requerimientos v\xE1lido.`);
   }
-  return path5__namespace.join(changeWorkspaceDir, "handoff.yaml");
+  return path4__namespace.join(changeWorkspaceDir, "handoff.yaml");
 }
 function validateOpenSpecStructure(profile, changeWorkspaceDir, adapter, errors, warnings) {
-  const proposalFile = path5__namespace.join(changeWorkspaceDir, "proposal.md");
-  const tasksFile = path5__namespace.join(changeWorkspaceDir, "tasks.md");
+  const proposalFile = path4__namespace.join(changeWorkspaceDir, "proposal.md");
+  const tasksFile = path4__namespace.join(changeWorkspaceDir, "tasks.md");
   if (profile === "patch") {
     const handoff2 = adapter.loadSidecar(changeWorkspaceDir);
-    return { handoff: handoff2, sidecarFile: handoff2 ? path5__namespace.join(changeWorkspaceDir, "handoff.yaml") : void 0 };
+    return { handoff: handoff2, sidecarFile: handoff2 ? path4__namespace.join(changeWorkspaceDir, "handoff.yaml") : void 0 };
   }
-  if (!fs6__namespace.existsSync(proposalFile)) {
+  if (!fs7__namespace.existsSync(proposalFile)) {
     warnings.push(`Falta 'proposal.md' en el espacio de trabajo OpenSpec.`);
   }
-  if (!fs6__namespace.existsSync(tasksFile)) {
+  if (!fs7__namespace.existsSync(tasksFile)) {
     errors.push(`Falta el archivo obligatorio 'tasks.md' en ${changeWorkspaceDir}.`);
   }
   const handoff = adapter.loadSidecar(changeWorkspaceDir);
@@ -1072,20 +1594,20 @@ function validateOpenSpecStructure(profile, changeWorkspaceDir, adapter, errors,
   return { handoff, sidecarFile };
 }
 function buildOpenSpecWorkspaceInfo(changeWorkspaceDir, profile, handoff, sidecarFile) {
-  const changeId = path5__namespace.basename(changeWorkspaceDir);
-  const proposalFile = path5__namespace.join(changeWorkspaceDir, "proposal.md");
-  const specFile = path5__namespace.join(changeWorkspaceDir, "spec.md");
-  const designFile = path5__namespace.join(changeWorkspaceDir, "design.md");
-  const tasksFile = path5__namespace.join(changeWorkspaceDir, "tasks.md");
+  const changeId = path4__namespace.basename(changeWorkspaceDir);
+  const proposalFile = path4__namespace.join(changeWorkspaceDir, "proposal.md");
+  const specFile = path4__namespace.join(changeWorkspaceDir, "spec.md");
+  const designFile = path4__namespace.join(changeWorkspaceDir, "design.md");
+  const tasksFile = path4__namespace.join(changeWorkspaceDir, "tasks.md");
   return {
     framework: "openspec",
     changeId,
     changeDir: changeWorkspaceDir,
     profile,
-    proposalFile: fs6__namespace.existsSync(proposalFile) ? proposalFile : void 0,
-    specFile: fs6__namespace.existsSync(specFile) ? specFile : void 0,
-    designFile: fs6__namespace.existsSync(designFile) ? designFile : void 0,
-    tasksFile: fs6__namespace.existsSync(tasksFile) ? tasksFile : void 0,
+    proposalFile: fs7__namespace.existsSync(proposalFile) ? proposalFile : void 0,
+    specFile: fs7__namespace.existsSync(specFile) ? specFile : void 0,
+    designFile: fs7__namespace.existsSync(designFile) ? designFile : void 0,
+    tasksFile: fs7__namespace.existsSync(tasksFile) ? tasksFile : void 0,
     sidecarFile,
     handoff: handoff || void 0
   };
@@ -1093,28 +1615,28 @@ function buildOpenSpecWorkspaceInfo(changeWorkspaceDir, profile, handoff, sideca
 var OpenSpecAdapter = class {
   framework = "openspec";
   getChangeWorkspaceDir(rootDir, changeId) {
-    const openspecDir = path5__namespace.join(rootDir, "openspec", "changes", changeId);
-    if (fs6__namespace.existsSync(openspecDir)) return openspecDir;
-    const activeChangeDir = path5__namespace.join(rootDir, "specs", "changes", "active", changeId);
-    if (fs6__namespace.existsSync(activeChangeDir)) return activeChangeDir;
-    const completedChangeDir = path5__namespace.join(rootDir, "specs", "changes", "completed", changeId);
-    if (fs6__namespace.existsSync(completedChangeDir)) return completedChangeDir;
+    const openspecDir = path4__namespace.join(rootDir, "openspec", "changes", changeId);
+    if (fs7__namespace.existsSync(openspecDir)) return openspecDir;
+    const activeChangeDir = path4__namespace.join(rootDir, "specs", "changes", "active", changeId);
+    if (fs7__namespace.existsSync(activeChangeDir)) return activeChangeDir;
+    const completedChangeDir = path4__namespace.join(rootDir, "specs", "changes", "completed", changeId);
+    if (fs7__namespace.existsSync(completedChangeDir)) return completedChangeDir;
     return activeChangeDir;
   }
   depositSidecar(options) {
     const changeDir = this.getChangeWorkspaceDir(options.rootDir, options.changeId);
-    if (!fs6__namespace.existsSync(changeDir)) {
-      fs6__namespace.mkdirSync(changeDir, { recursive: true });
+    if (!fs7__namespace.existsSync(changeDir)) {
+      fs7__namespace.mkdirSync(changeDir, { recursive: true });
     }
     const handoff = normalizeHandoffPayload(options.handoff, options.changeId);
     const filename = options.format === "json" ? "handoff.json" : "handoff.yaml";
-    const filePath = path5__namespace.join(changeDir, filename);
-    const content = options.format === "json" ? JSON.stringify(handoff, null, 2) : yaml2__default.default.dump(handoff, { indent: 2, lineWidth: -1 });
-    fs6__namespace.writeFileSync(filePath, content, "utf-8");
+    const filePath = path4__namespace.join(changeDir, filename);
+    const content = options.format === "json" ? JSON.stringify(handoff, null, 2) : yaml3__default.default.dump(handoff, { indent: 2, lineWidth: -1 });
+    fs7__namespace.writeFileSync(filePath, content, "utf-8");
     return filePath;
   }
   loadSidecar(changeWorkspaceDir) {
-    if (!fs6__namespace.existsSync(changeWorkspaceDir)) return null;
+    if (!fs7__namespace.existsSync(changeWorkspaceDir)) return null;
     const candidateFiles = [
       "handoff.yaml",
       "handoff.yml",
@@ -1125,11 +1647,11 @@ var OpenSpecAdapter = class {
       "product-handoff.json"
     ];
     for (const file of candidateFiles) {
-      const fullPath = path5__namespace.join(changeWorkspaceDir, file);
-      if (fs6__namespace.existsSync(fullPath)) {
+      const fullPath = path4__namespace.join(changeWorkspaceDir, file);
+      if (fs7__namespace.existsSync(fullPath)) {
         try {
-          const raw = fs6__namespace.readFileSync(fullPath, "utf-8").replace(/^\uFEFF/, "");
-          const parsed = file.endsWith(".json") ? JSON.parse(raw) : yaml2__default.default.load(raw);
+          const raw = fs7__namespace.readFileSync(fullPath, "utf-8").replace(/^\uFEFF/, "");
+          const parsed = file.endsWith(".json") ? JSON.parse(raw) : yaml3__default.default.load(raw);
           if (parsed && typeof parsed === "object" && parsed.id && String(parsed.id).startsWith("HOF-")) {
             return parsed;
           }
@@ -1140,7 +1662,7 @@ var OpenSpecAdapter = class {
     return null;
   }
   validateWorkspace(changeWorkspaceDir) {
-    if (!fs6__namespace.existsSync(changeWorkspaceDir)) {
+    if (!fs7__namespace.existsSync(changeWorkspaceDir)) {
       return {
         valid: false,
         errors: [`El directorio del cambio OpenSpec no existe: ${changeWorkspaceDir}`],
@@ -1149,7 +1671,7 @@ var OpenSpecAdapter = class {
     }
     const errors = [];
     const warnings = [];
-    const specFile = path5__namespace.join(changeWorkspaceDir, "spec.md");
+    const specFile = path4__namespace.join(changeWorkspaceDir, "spec.md");
     const profile = parseChangeProfile(specFile);
     validateSpecFileContent(specFile, changeWorkspaceDir, errors);
     const { handoff, sidecarFile } = validateOpenSpecStructure(profile, changeWorkspaceDir, this, errors, warnings);
@@ -1163,12 +1685,12 @@ var OpenSpecAdapter = class {
   }
 };
 function parseChangeProfile2(specFile) {
-  if (!fs6__namespace.existsSync(specFile)) return "standard";
+  if (!fs7__namespace.existsSync(specFile)) return "standard";
   try {
-    const rawSpec = fs6__namespace.readFileSync(specFile, "utf-8").replace(/^\uFEFF/, "");
+    const rawSpec = fs7__namespace.readFileSync(specFile, "utf-8").replace(/^\uFEFF/, "");
     const match = rawSpec.match(/^---\r?\n([\s\S]*?)\r?\n---/);
     if (match) {
-      const parsedFm = yaml2__default.default.load(match[1]);
+      const parsedFm = yaml3__default.default.load(match[1]);
       if (parsedFm?.profile && ["patch", "standard", "critical"].includes(String(parsedFm.profile))) {
         return parsedFm.profile;
       }
@@ -1187,15 +1709,15 @@ function checkSpecGherkinFormat2(parsedFm, rawSpec, changeWorkspaceDir, errors)
   }
 }
 function validateSpecFileContent2(specFile, changeWorkspaceDir, errors) {
-  if (!fs6__namespace.existsSync(specFile)) {
+  if (!fs7__namespace.existsSync(specFile)) {
     errors.push(`Falta el archivo de especificaci\xF3n obligatorio 'spec.md' en ${changeWorkspaceDir}.`);
     return;
   }
   try {
-    const rawSpec = fs6__namespace.readFileSync(specFile, "utf-8").replace(/^\uFEFF/, "");
+    const rawSpec = fs7__namespace.readFileSync(specFile, "utf-8").replace(/^\uFEFF/, "");
     const match = rawSpec.match(/^---\r?\n([\s\S]*?)\r?\n---/);
     if (match) {
-      const parsedFm = yaml2__default.default.load(match[1]);
+      const parsedFm = yaml3__default.default.load(match[1]);
       if (parsedFm) checkSpecGherkinFormat2(parsedFm, rawSpec, changeWorkspaceDir, errors);
     }
   } catch {
@@ -1211,19 +1733,19 @@ function validateHandoffSidecar2(handoff, changeWorkspaceDir, errors) {
   if (!handoff.subgraph || !Array.isArray(handoff.subgraph.requirements)) {
     errors.push(`El sidecar '${handoff.id}' no define un subgrafo de requerimientos v\xE1lido.`);
   }
-  return path5__namespace.join(changeWorkspaceDir, "handoff.yaml");
+  return path4__namespace.join(changeWorkspaceDir, "handoff.yaml");
 }
 function validateSpecKitStructure(profile, changeWorkspaceDir, adapter, errors, warnings) {
-  const planFile = path5__namespace.join(changeWorkspaceDir, "plan.md");
-  const tasksFile = path5__namespace.join(changeWorkspaceDir, "tasks.md");
+  const planFile = path4__namespace.join(changeWorkspaceDir, "plan.md");
+  const tasksFile = path4__namespace.join(changeWorkspaceDir, "tasks.md");
   if (profile === "patch") {
     const handoff2 = adapter.loadSidecar(changeWorkspaceDir);
-    return { handoff: handoff2, sidecarFile: handoff2 ? path5__namespace.join(changeWorkspaceDir, "handoff.yaml") : void 0 };
+    return { handoff: handoff2, sidecarFile: handoff2 ? path4__namespace.join(changeWorkspaceDir, "handoff.yaml") : void 0 };
   }
-  if (!fs6__namespace.existsSync(tasksFile)) {
+  if (!fs7__namespace.existsSync(tasksFile)) {
     errors.push(`Falta el archivo de tareas obligatorio 'tasks.md' en ${changeWorkspaceDir}.`);
   }
-  if (!fs6__namespace.existsSync(planFile)) {
+  if (!fs7__namespace.existsSync(planFile)) {
     warnings.push(`Se recomienda incluir 'plan.md' en el espacio de trabajo Spec Kit.`);
   }
   const handoff = adapter.loadSidecar(changeWorkspaceDir);
@@ -1231,18 +1753,18 @@ function validateSpecKitStructure(profile, changeWorkspaceDir, adapter, errors,
   return { handoff, sidecarFile };
 }
 function buildSpecKitWorkspaceInfo(changeWorkspaceDir, profile, handoff, sidecarFile) {
-  const changeId = path5__namespace.basename(changeWorkspaceDir);
-  const specFile = path5__namespace.join(changeWorkspaceDir, "spec.md");
-  const planFile = path5__namespace.join(changeWorkspaceDir, "plan.md");
-  const tasksFile = path5__namespace.join(changeWorkspaceDir, "tasks.md");
+  const changeId = path4__namespace.basename(changeWorkspaceDir);
+  const specFile = path4__namespace.join(changeWorkspaceDir, "spec.md");
+  const planFile = path4__namespace.join(changeWorkspaceDir, "plan.md");
+  const tasksFile = path4__namespace.join(changeWorkspaceDir, "tasks.md");
   return {
     framework: "speckit",
     changeId,
     changeDir: changeWorkspaceDir,
     profile,
-    specFile: fs6__namespace.existsSync(specFile) ? specFile : void 0,
-    designFile: fs6__namespace.existsSync(planFile) ? planFile : void 0,
-    tasksFile: fs6__namespace.existsSync(tasksFile) ? tasksFile : void 0,
+    specFile: fs7__namespace.existsSync(specFile) ? specFile : void 0,
+    designFile: fs7__namespace.existsSync(planFile) ? planFile : void 0,
+    tasksFile: fs7__namespace.existsSync(tasksFile) ? tasksFile : void 0,
     sidecarFile,
     handoff: handoff || void 0
   };
@@ -1250,18 +1772,18 @@ function buildSpecKitWorkspaceInfo(changeWorkspaceDir, profile, handoff, sidecar
 var SpecKitAdapter = class {
   framework = "speckit";
   getChangeWorkspaceDir(rootDir, changeId) {
-    const standardDir = path5__namespace.join(rootDir, "specs", changeId);
-    if (fs6__namespace.existsSync(standardDir)) return standardDir;
-    const activeChangeDir = path5__namespace.join(rootDir, "specs", "changes", "active", changeId);
-    if (fs6__namespace.existsSync(activeChangeDir)) return activeChangeDir;
-    const completedChangeDir = path5__namespace.join(rootDir, "specs", "changes", "completed", changeId);
-    if (fs6__namespace.existsSync(completedChangeDir)) return completedChangeDir;
+    const standardDir = path4__namespace.join(rootDir, "specs", changeId);
+    if (fs7__namespace.existsSync(standardDir)) return standardDir;
+    const activeChangeDir = path4__namespace.join(rootDir, "specs", "changes", "active", changeId);
+    if (fs7__namespace.existsSync(activeChangeDir)) return activeChangeDir;
+    const completedChangeDir = path4__namespace.join(rootDir, "specs", "changes", "completed", changeId);
+    if (fs7__namespace.existsSync(completedChangeDir)) return completedChangeDir;
     return standardDir;
   }
   depositSidecar(options) {
     const changeDir = this.getChangeWorkspaceDir(options.rootDir, options.changeId);
-    if (!fs6__namespace.existsSync(changeDir)) {
-      fs6__namespace.mkdirSync(changeDir, { recursive: true });
+    if (!fs7__namespace.existsSync(changeDir)) {
+      fs7__namespace.mkdirSync(changeDir, { recursive: true });
     }
     const handoff = { ...options.handoff };
     if (!handoff.id.startsWith("HOF-")) {
@@ -1274,20 +1796,20 @@ var SpecKitAdapter = class {
       handoff.createdAt = (/* @__PURE__ */ new Date()).toISOString();
     }
     const filename = options.format === "json" ? "handoff.json" : "handoff.yaml";
-    const filePath = path5__namespace.join(changeDir, filename);
-    const content = options.format === "json" ? JSON.stringify(handoff, null, 2) : yaml2__default.default.dump(handoff, { indent: 2, lineWidth: -1 });
-    fs6__namespace.writeFileSync(filePath, content, "utf-8");
-    const specifyMemoryDir = path5__namespace.join(options.rootDir, ".specify", "memory");
-    if (fs6__namespace.existsSync(path5__namespace.join(options.rootDir, ".specify"))) {
-      if (!fs6__namespace.existsSync(specifyMemoryDir)) {
-        fs6__namespace.mkdirSync(specifyMemoryDir, { recursive: true });
+    const filePath = path4__namespace.join(changeDir, filename);
+    const content = options.format === "json" ? JSON.stringify(handoff, null, 2) : yaml3__default.default.dump(handoff, { indent: 2, lineWidth: -1 });
+    fs7__namespace.writeFileSync(filePath, content, "utf-8");
+    const specifyMemoryDir = path4__namespace.join(options.rootDir, ".specify", "memory");
+    if (fs7__namespace.existsSync(path4__namespace.join(options.rootDir, ".specify"))) {
+      if (!fs7__namespace.existsSync(specifyMemoryDir)) {
+        fs7__namespace.mkdirSync(specifyMemoryDir, { recursive: true });
       }
-      fs6__namespace.writeFileSync(path5__namespace.join(specifyMemoryDir, `${options.changeId}.handoff.yaml`), content, "utf-8");
+      fs7__namespace.writeFileSync(path4__namespace.join(specifyMemoryDir, `${options.changeId}.handoff.yaml`), content, "utf-8");
     }
     return filePath;
   }
   loadSidecar(changeWorkspaceDir) {
-    if (!fs6__namespace.existsSync(changeWorkspaceDir)) return null;
+    if (!fs7__namespace.existsSync(changeWorkspaceDir)) return null;
     const candidateFiles = [
       "handoff.yaml",
       "handoff.yml",
@@ -1297,11 +1819,11 @@ var SpecKitAdapter = class {
       "handoff.json"
     ];
     for (const file of candidateFiles) {
-      const fullPath = path5__namespace.join(changeWorkspaceDir, file);
-      if (fs6__namespace.existsSync(fullPath)) {
+      const fullPath = path4__namespace.join(changeWorkspaceDir, file);
+      if (fs7__namespace.existsSync(fullPath)) {
         try {
-          const raw = fs6__namespace.readFileSync(fullPath, "utf-8").replace(/^\uFEFF/, "");
-          const parsed = file.endsWith(".json") ? JSON.parse(raw) : yaml2__default.default.load(raw);
+          const raw = fs7__namespace.readFileSync(fullPath, "utf-8").replace(/^\uFEFF/, "");
+          const parsed = file.endsWith(".json") ? JSON.parse(raw) : yaml3__default.default.load(raw);
           if (parsed && typeof parsed === "object" && parsed.id && String(parsed.id).startsWith("HOF-")) {
             return parsed;
           }
@@ -1312,7 +1834,7 @@ var SpecKitAdapter = class {
     return null;
   }
   validateWorkspace(changeWorkspaceDir) {
-    if (!fs6__namespace.existsSync(changeWorkspaceDir)) {
+    if (!fs7__namespace.existsSync(changeWorkspaceDir)) {
       return {
         valid: false,
         errors: [`El directorio del cambio Spec Kit no existe: ${changeWorkspaceDir}`],
@@ -1321,7 +1843,7 @@ var SpecKitAdapter = class {
     }
     const errors = [];
     const warnings = [];
-    const specFile = path5__namespace.join(changeWorkspaceDir, "spec.md");
+    const specFile = path4__namespace.join(changeWorkspaceDir, "spec.md");
     const profile = parseChangeProfile2(specFile);
     validateSpecFileContent2(specFile, changeWorkspaceDir, errors);
     const { handoff, sidecarFile } = validateSpecKitStructure(profile, changeWorkspaceDir, this, errors, warnings);
@@ -1464,27 +1986,27 @@ ${frontmatter}---
 ${body}`;
 }
 function materializeCanonicalArtifact(rootDir, item, changeId, author, date) {
-  const targetPath = path5__namespace.join(rootDir, item.targetDir, `${item.id}.md`);
-  if (fs6__namespace.existsSync(targetPath)) return targetPath;
-  fs6__namespace.mkdirSync(path5__namespace.dirname(targetPath), { recursive: true });
+  const targetPath = path4__namespace.join(rootDir, item.targetDir, `${item.id}.md`);
+  if (fs7__namespace.existsSync(targetPath)) return targetPath;
+  fs7__namespace.mkdirSync(path4__namespace.dirname(targetPath), { recursive: true });
   const initialContent = buildCanonicalInitialContent(item, changeId, author, date);
-  fs6__namespace.writeFileSync(targetPath, initialContent, "utf-8");
+  fs7__namespace.writeFileSync(targetPath, initialContent, "utf-8");
   return targetPath;
 }
 function findChangeWorkspaceDir(rootDir, changeId) {
-  const activeDir = path5__namespace.join(rootDir, "specs", "changes", "active", changeId);
-  if (fs6__namespace.existsSync(activeDir)) return activeDir;
-  const completedDir = path5__namespace.join(rootDir, "specs", "changes", "completed", changeId);
-  if (fs6__namespace.existsSync(completedDir)) return completedDir;
-  const openspecActive = path5__namespace.join(rootDir, "openspec", "changes", changeId);
-  if (fs6__namespace.existsSync(openspecActive)) return openspecActive;
+  const activeDir = path4__namespace.join(rootDir, "specs", "changes", "active", changeId);
+  if (fs7__namespace.existsSync(activeDir)) return activeDir;
+  const completedDir = path4__namespace.join(rootDir, "specs", "changes", "completed", changeId);
+  if (fs7__namespace.existsSync(completedDir)) return completedDir;
+  const openspecActive = path4__namespace.join(rootDir, "openspec", "changes", changeId);
+  if (fs7__namespace.existsSync(openspecActive)) return openspecActive;
   return null;
 }
 function checkTasksExecution(changeDir, changeId) {
-  const tasksFile = path5__namespace.join(changeDir, "tasks.md");
+  const tasksFile = path4__namespace.join(changeDir, "tasks.md");
   const allTasks = [];
-  if (fs6__namespace.existsSync(tasksFile)) {
-    allTasks.push(...parseTasksFromContent(fs6__namespace.readFileSync(tasksFile, "utf-8")));
+  if (fs7__namespace.existsSync(tasksFile)) {
+    allTasks.push(...parseTasksFromContent(fs7__namespace.readFileSync(tasksFile, "utf-8")));
   }
   const completedTasks = allTasks.filter((t) => t.status === "COMPLETED").map((t) => t.id);
   const pendingTasks = allTasks.filter((t) => t.status !== "COMPLETED").map((t) => t.id);
@@ -1501,9 +2023,9 @@ function checkTasksExecution(changeDir, changeId) {
 function resolveChangeHandoff(changeDir, changeId) {
   const sidecar = loadProductHandoffSidecar(changeDir);
   if (sidecar) return sidecar;
-  const proposalFile = path5__namespace.join(changeDir, "proposal.md");
-  if (!fs6__namespace.existsSync(proposalFile)) return null;
-  const propContent = fs6__namespace.readFileSync(proposalFile, "utf-8");
+  const proposalFile = path4__namespace.join(changeDir, "proposal.md");
+  if (!fs7__namespace.existsSync(proposalFile)) return null;
+  const propContent = fs7__namespace.readFileSync(proposalFile, "utf-8");
   const { frontmatter } = parseFrontmatter(propContent);
   const citations = Array.isArray(frontmatter.citations) ? frontmatter.citations : [];
   const reqs = citations.map((c) => c.id || "").filter((id) => id.startsWith("FR-") || id.startsWith("QR-") || id.startsWith("CON-") || id.startsWith("SEC-REQ-"));
@@ -1517,9 +2039,9 @@ function resolveChangeHandoff(changeDir, changeId) {
 }
 function materializeNewCatalogArtifacts(changeDir, rootDir, changeId, author, date, errors) {
   const created = [];
-  const specFile = path5__namespace.join(changeDir, "spec.md");
-  if (!fs6__namespace.existsSync(specFile)) return created;
-  const specContent = fs6__namespace.readFileSync(specFile, "utf-8");
+  const specFile = path4__namespace.join(changeDir, "spec.md");
+  if (!fs7__namespace.existsSync(specFile)) return created;
+  const specContent = fs7__namespace.readFileSync(specFile, "utf-8");
   const { newItems } = parseSpecCatalogScope(specContent);
   for (const item of newItems) {
     try {
@@ -1536,10 +2058,10 @@ function loadCanonicalArtifacts(rootDir) {
   const allMdFiles = walkMdFiles(rootDir);
   const canonicalArtifacts = /* @__PURE__ */ new Map();
   for (const file of allMdFiles) {
-    const relFile = path5__namespace.relative(rootDir, file).replace(/\\/g, "/");
+    const relFile = path4__namespace.relative(rootDir, file).replace(/\\/g, "/");
     if (relFile.includes("specs/changes/") || relFile.includes("templates/")) continue;
     try {
-      const content = fs6__namespace.readFileSync(file, "utf-8");
+      const content = fs7__namespace.readFileSync(file, "utf-8");
       const { frontmatter, body } = parseFrontmatter(content);
       if (frontmatter.id) canonicalArtifacts.set(String(frontmatter.id), { file, frontmatter, body });
     } catch {
@@ -1549,10 +2071,10 @@ function loadCanonicalArtifacts(rootDir) {
 }
 function writeUpdatedArtifact(file, frontmatter, body) {
   const yamlHeader = `---
-${yaml2__default.default.dump(frontmatter, { indent: 2, lineWidth: -1 }).trim()}
+${yaml3__default.default.dump(frontmatter, { indent: 2, lineWidth: -1 }).trim()}
 ---
 `;
-  fs6__namespace.writeFileSync(file, yamlHeader + body, "utf-8");
+  fs7__namespace.writeFileSync(file, yamlHeader + body, "utf-8");
 }
 function updateSingleCanonicalRequirement(canonical, completedTasks, changeId, date, author) {
   const fm = canonical.frontmatter;
@@ -1664,28 +2186,28 @@ function updateArchitectureComponents(citedComponents, canonicalArtifacts, targe
   return updated;
 }
 function moveToCompletedFolder(changeDir, changeId, rootDir) {
-  const completedParent = path5__namespace.join(rootDir, "specs", "changes", "completed");
-  if (!fs6__namespace.existsSync(completedParent)) fs6__namespace.mkdirSync(completedParent, { recursive: true });
-  const destDir = path5__namespace.join(completedParent, changeId);
-  if (fs6__namespace.existsSync(destDir)) fs6__namespace.rmSync(destDir, { recursive: true, force: true });
-  fs6__namespace.renameSync(changeDir, destDir);
-  const destProposal = path5__namespace.join(destDir, "proposal.md");
-  if (fs6__namespace.existsSync(destProposal)) {
-    const { frontmatter, body } = parseFrontmatter(fs6__namespace.readFileSync(destProposal, "utf-8"));
+  const completedParent = path4__namespace.join(rootDir, "specs", "changes", "completed");
+  if (!fs7__namespace.existsSync(completedParent)) fs7__namespace.mkdirSync(completedParent, { recursive: true });
+  const destDir = path4__namespace.join(completedParent, changeId);
+  if (fs7__namespace.existsSync(destDir)) fs7__namespace.rmSync(destDir, { recursive: true, force: true });
+  fs7__namespace.renameSync(changeDir, destDir);
+  const destProposal = path4__namespace.join(destDir, "proposal.md");
+  if (fs7__namespace.existsSync(destProposal)) {
+    const { frontmatter, body } = parseFrontmatter(fs7__namespace.readFileSync(destProposal, "utf-8"));
     frontmatter.status = "applied";
     writeUpdatedArtifact(destProposal, frontmatter, body);
   }
   return destDir;
 }
 function archiveChangeWorkspace(changeDir, changeId, rootDir, autoArchive, completedAll) {
-  const isActiveFolder = changeDir.includes("specs" + path5__namespace.sep + "changes" + path5__namespace.sep + "active");
+  const isActiveFolder = changeDir.includes("specs" + path4__namespace.sep + "changes" + path4__namespace.sep + "active");
   if (completedAll && autoArchive && isActiveFolder) {
     const destDir = moveToCompletedFolder(changeDir, changeId, rootDir);
     return { archived: true, archivedPath: destDir };
   }
-  const proposalFile = path5__namespace.join(changeDir, "proposal.md");
-  if (fs6__namespace.existsSync(proposalFile)) {
-    const { frontmatter, body } = parseFrontmatter(fs6__namespace.readFileSync(proposalFile, "utf-8"));
+  const proposalFile = path4__namespace.join(changeDir, "proposal.md");
+  if (fs7__namespace.existsSync(proposalFile)) {
+    const { frontmatter, body } = parseFrontmatter(fs7__namespace.readFileSync(proposalFile, "utf-8"));
     if (completedAll) frontmatter.status = "completed";
     writeUpdatedArtifact(proposalFile, frontmatter, body);
   }
@@ -1779,8 +2301,8 @@ function resolveAuditStatus(integratedCount, targetCount, gapsCount) {
 function auditChangeEntry(changeDir, changeName, canonicalMap) {
   const handoff = loadProductHandoffSidecar(changeDir);
   if (!handoff) return null;
-  const tasksFile = path5__namespace.join(changeDir, "tasks.md");
-  const tasks = fs6__namespace.existsSync(tasksFile) ? parseTasksFromContent(fs6__namespace.readFileSync(tasksFile, "utf-8")) : [];
+  const tasksFile = path4__namespace.join(changeDir, "tasks.md");
+  const tasks = fs7__namespace.existsSync(tasksFile) ? parseTasksFromContent(fs7__namespace.readFileSync(tasksFile, "utf-8")) : [];
   const completed = tasks.filter((t) => t.status === "COMPLETED");
   const targetReqs = handoff.subgraph?.requirements || [];
   const { integrated, missing, gaps } = auditChangeRequirements(targetReqs, canonicalMap);
@@ -1796,11 +2318,11 @@ function auditChangeEntry(changeDir, changeName, canonicalMap) {
   };
 }
 function collectParentDirAudits(parent, canonicalMap, audits, errors) {
-  if (!fs6__namespace.existsSync(parent)) return;
-  const entries = fs6__namespace.readdirSync(parent, { withFileTypes: true });
+  if (!fs7__namespace.existsSync(parent)) return;
+  const entries = fs7__namespace.readdirSync(parent, { withFileTypes: true });
   for (const e of entries) {
     if (!e.isDirectory()) continue;
-    const audit = auditChangeEntry(path5__namespace.join(parent, e.name), e.name, canonicalMap);
+    const audit = auditChangeEntry(path4__namespace.join(parent, e.name), e.name, canonicalMap);
     if (audit) {
       if (audit.gaps.length > 0) errors.push(`[${e.name}] Desalineaci\xF3n: ${audit.gaps.join("; ")}`);
       audits.push(audit);
@@ -1812,8 +2334,8 @@ function verifySddIntegration(options = {}) {
   const audits = [];
   const errors = [];
   const searchDirs = [
-    path5__namespace.join(rootDir, "specs", "changes", "completed"),
-    path5__namespace.join(rootDir, "specs", "changes", "active")
+    path4__namespace.join(rootDir, "specs", "changes", "completed"),
+    path4__namespace.join(rootDir, "specs", "changes", "active")
   ];
   const canonicalMap = loadCanonicalArtifacts(rootDir);
   for (const parent of searchDirs) {
@@ -1861,10 +2383,10 @@ function resolveMatchFromMetadata(activeFolders, options) {
   return {};
 }
 function validateActiveDirectory(activeParent) {
-  if (!fs6__namespace.existsSync(activeParent)) {
+  if (!fs7__namespace.existsSync(activeParent)) {
     return { ok: false, folders: [], error: `No existe el directorio de cambios activos en '${activeParent}'.` };
   }
-  const entries = fs6__namespace.readdirSync(activeParent, { withFileTypes: true });
+  const entries = fs7__namespace.readdirSync(activeParent, { withFileTypes: true });
   const activeFolders = entries.filter((e) => e.isDirectory()).map((e) => e.name);
   if (activeFolders.length === 0) {
     return { ok: false, folders: [], error: "No se encontraron carpetas de cambios activos en specs/changes/active/." };
@@ -1896,7 +2418,7 @@ function evaluateTasksProgress(changeId, tasks) {
 }
 function detectActiveChangeForIntegration(options = {}) {
   const rootDir = options.rootDir || process.cwd();
-  const activeParent = path5__namespace.join(rootDir, "specs", "changes", "active");
+  const activeParent = path4__namespace.join(rootDir, "specs", "changes", "active");
   const dirCheck = validateActiveDirectory(activeParent);
   if (!dirCheck.ok) {
     return {
@@ -1911,9 +2433,9 @@ function detectActiveChangeForIntegration(options = {}) {
   if (!match.changeId) {
     return buildUnmatchedActiveResult(dirCheck.folders, options);
   }
-  const changeDir = path5__namespace.join(activeParent, match.changeId);
-  const tasksFile = path5__namespace.join(changeDir, "tasks.md");
-  const tasks = fs6__namespace.existsSync(tasksFile) ? parseTasksFromContent(fs6__namespace.readFileSync(tasksFile, "utf-8")) : [];
+  const changeDir = path4__namespace.join(activeParent, match.changeId);
+  const tasksFile = path4__namespace.join(changeDir, "tasks.md");
+  const tasks = fs7__namespace.existsSync(tasksFile) ? parseTasksFromContent(fs7__namespace.readFileSync(tasksFile, "utf-8")) : [];
   const progress = evaluateTasksProgress(match.changeId, tasks);
   const reasons = match.reason ? [match.reason] : [];
   if (progress.error) reasons.push(progress.error);
@@ -2044,9 +2566,9 @@ function isPdacDeliveryDoc(relFile) {
 }
 function processPdacFile(file, rootDir, baselineMap, allCitations) {
   try {
-    const content = fs6__namespace.readFileSync(file, "utf-8");
+    const content = fs7__namespace.readFileSync(file, "utf-8");
     const { id, type, title } = parseFrontmatterId(content);
-    const relFile = path5__namespace.relative(rootDir, file).replace(/\\/g, "/");
+    const relFile = path4__namespace.relative(rootDir, file).replace(/\\/g, "/");
     if (id) {
       const citations = extractCitations(content, relFile);
       baselineMap.set(id, {
@@ -2174,22 +2696,22 @@ function updateCitationsInContent(content, baselineMap, sourceFile, details) {
 }
 function collectCandidateFilesForSync(rootDir, targetPath) {
   if (targetPath) {
-    const fullTarget = path5__namespace.isAbsolute(targetPath) ? targetPath : path5__namespace.join(rootDir, targetPath);
-    if (!fs6__namespace.existsSync(fullTarget)) return [];
-    return fs6__namespace.statSync(fullTarget).isDirectory() ? walkMdFiles(fullTarget) : [fullTarget];
+    const fullTarget = path4__namespace.isAbsolute(targetPath) ? targetPath : path4__namespace.join(rootDir, targetPath);
+    if (!fs7__namespace.existsSync(fullTarget)) return [];
+    return fs7__namespace.statSync(fullTarget).isDirectory() ? walkMdFiles(fullTarget) : [fullTarget];
   }
   return walkMdFiles(rootDir).filter((f) => {
-    const relFile = path5__namespace.relative(rootDir, f).replace(/\\/g, "/");
+    const relFile = path4__namespace.relative(rootDir, f).replace(/\\/g, "/");
     return isPdacDeliveryDoc(relFile);
   });
 }
 function syncSingleFile(file, rootDir, baselineMap, details) {
   try {
-    const content = fs6__namespace.readFileSync(file, "utf-8");
-    const relFile = path5__namespace.relative(rootDir, file).replace(/\\/g, "/");
+    const content = fs7__namespace.readFileSync(file, "utf-8");
+    const relFile = path4__namespace.relative(rootDir, file).replace(/\\/g, "/");
     const { updatedContent, changed } = updateCitationsInContent(content, baselineMap, relFile, details);
     if (changed) {
-      fs6__namespace.writeFileSync(file, updatedContent, "utf-8");
+      fs7__namespace.writeFileSync(file, updatedContent, "utf-8");
       return relFile;
     }
   } catch {
@@ -2309,7 +2831,7 @@ function extractFrontmatter(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!match) return null;
   try {
-    const parsed = yaml2__default.default.load(match[1]);
+    const parsed = yaml3__default.default.load(match[1]);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
     }
@@ -2345,10 +2867,10 @@ var EXCLUDED_SCHEMA_DIRS = /* @__PURE__ */ new Set([
 ]);
 function walkHandoffSidecars(dir, fileList = []) {
   try {
-    if (!fs6__namespace.existsSync(dir)) return fileList;
-    for (const file of fs6__namespace.readdirSync(dir)) {
-      const fullPath = path5__namespace.join(dir, file);
-      if (fs6__namespace.statSync(fullPath).isDirectory()) {
+    if (!fs7__namespace.existsSync(dir)) return fileList;
+    for (const file of fs7__namespace.readdirSync(dir)) {
+      const fullPath = path4__namespace.join(dir, file);
+      if (fs7__namespace.statSync(fullPath).isDirectory()) {
         if (!EXCLUDED_SCHEMA_DIRS.has(file) && !file.startsWith("temp-") && !file.startsWith(".temp-")) {
           walkHandoffSidecars(fullPath, fileList);
         }
@@ -2363,7 +2885,7 @@ function walkHandoffSidecars(dir, fileList = []) {
 function extractArtifactData(filePath, content) {
   if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
     try {
-      const parsed = yaml2__default.default.load(content);
+      const parsed = yaml3__default.default.load(content);
       return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
     } catch {
       return null;
@@ -2512,10 +3034,10 @@ function validateAgainstSchema(value, schema, propPath = "") {
   return validateTypeSpecificRules(value, schema, propPath, currentProp);
 }
 function findSchemaFile(relSchemaPath, rootDir) {
-  const fullPath = path5__namespace.join(rootDir, relSchemaPath);
-  if (fs6__namespace.existsSync(fullPath)) return fullPath;
-  const fallbackPath = path5__namespace.join(process.cwd(), relSchemaPath);
-  if (fs6__namespace.existsSync(fallbackPath)) return fallbackPath;
+  const fullPath = path4__namespace.join(rootDir, relSchemaPath);
+  if (fs7__namespace.existsSync(fullPath)) return fullPath;
+  const fallbackPath = path4__namespace.join(process.cwd(), relSchemaPath);
+  if (fs7__namespace.existsSync(fallbackPath)) return fallbackPath;
   return null;
 }
 function resolveSchemaForArtifact(frontmatter, rootDir) {
@@ -2525,7 +3047,7 @@ function resolveSchemaForArtifact(frontmatter, rootDir) {
   const fullPath = findSchemaFile(relSchemaPath, rootDir);
   if (!fullPath) return null;
   try {
-    const raw = fs6__namespace.readFileSync(fullPath, "utf-8");
+    const raw = fs7__namespace.readFileSync(fullPath, "utf-8");
     return { schemaPath: relSchemaPath, schema: JSON.parse(raw) };
   } catch {
     return null;
@@ -2533,15 +3055,15 @@ function resolveSchemaForArtifact(frontmatter, rootDir) {
 }
 function loadSchemaFromPathOrType(schemaOrType, rootDir) {
   if (schemaOrType.endsWith(".json")) {
-    const fullPath = path5__namespace.isAbsolute(schemaOrType) ? schemaOrType : findSchemaFile(schemaOrType, rootDir);
-    if (fullPath && fs6__namespace.existsSync(fullPath)) {
-      return { schema: JSON.parse(fs6__namespace.readFileSync(fullPath, "utf-8")), schemaId: schemaOrType };
+    const fullPath = path4__namespace.isAbsolute(schemaOrType) ? schemaOrType : findSchemaFile(schemaOrType, rootDir);
+    if (fullPath && fs7__namespace.existsSync(fullPath)) {
+      return { schema: JSON.parse(fs7__namespace.readFileSync(fullPath, "utf-8")), schemaId: schemaOrType };
     }
   } else if (TYPE_TO_SCHEMA_MAP[schemaOrType]) {
     const relPath = TYPE_TO_SCHEMA_MAP[schemaOrType];
     const fullPath = findSchemaFile(relPath, rootDir);
-    if (fullPath && fs6__namespace.existsSync(fullPath)) {
-      return { schema: JSON.parse(fs6__namespace.readFileSync(fullPath, "utf-8")), schemaId: relPath };
+    if (fullPath && fs7__namespace.existsSync(fullPath)) {
+      return { schema: JSON.parse(fs7__namespace.readFileSync(fullPath, "utf-8")), schemaId: relPath };
     }
   }
   return { schema: null };
@@ -2579,9 +3101,9 @@ function collectCandidateSchemaFiles(options, rootDir) {
   if (!options.targetPath) {
     return [...walkMdFiles(rootDir), ...walkHandoffSidecars(rootDir)];
   }
-  const target = path5__namespace.isAbsolute(options.targetPath) ? options.targetPath : path5__namespace.join(rootDir, options.targetPath);
-  if (!fs6__namespace.existsSync(target)) return [];
-  if (fs6__namespace.statSync(target).isDirectory()) {
+  const target = path4__namespace.isAbsolute(options.targetPath) ? options.targetPath : path4__namespace.join(rootDir, options.targetPath);
+  if (!fs7__namespace.existsSync(target)) return [];
+  if (fs7__namespace.statSync(target).isDirectory()) {
     return [...walkMdFiles(target), ...walkHandoffSidecars(target)];
   }
   if (target.endsWith(".md") || target.endsWith(".yaml") || target.endsWith(".yml")) {
@@ -2632,7 +3154,7 @@ function buildEvaluationFailure(relPath, err) {
 }
 function evaluateArtifactFile(file, relPath, rootDir) {
   try {
-    const content = fs6__namespace.readFileSync(file, "utf-8");
+    const content = fs7__namespace.readFileSync(file, "utf-8");
     const frontmatter = extractArtifactData(file, content);
     if (!frontmatter || !frontmatter.id) return null;
     const schemaInfo = resolveSchemaForArtifact(frontmatter, rootDir);
@@ -2667,7 +3189,7 @@ function verifyArtifactsSchemas(options = {}) {
   let validCount = 0;
   let totalEvaluated = 0;
   for (const file of filesToScan) {
-    const relPath = path5__namespace.relative(rootDir, file).replace(/\\/g, "/");
+    const relPath = path4__namespace.relative(rootDir, file).replace(/\\/g, "/");
     if (isIgnoredArtifactPath(relPath, Boolean(options.targetPath))) continue;
     const evaluation = evaluateArtifactFile(file, relPath, rootDir);
     if (!evaluation) continue;
@@ -2686,10 +3208,10 @@ function slugify(text) {
   return text.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
 function extractDirMaxNum(dir) {
-  if (!fs6__namespace.existsSync(dir)) return 0;
+  if (!fs7__namespace.existsSync(dir)) return 0;
   let max = 0;
   try {
-    const entries = fs6__namespace.readdirSync(dir, { withFileTypes: true });
+    const entries = fs7__namespace.readdirSync(dir, { withFileTypes: true });
     for (const e of entries) {
       if (!e.isDirectory()) continue;
       const match = e.name.match(/^(?:chg|CHG|patch|PATCH)-(\d+)/i);
@@ -2706,10 +3228,10 @@ function extractDirMaxNum(dir) {
 }
 function getNextCorrelativeNumber(rootDir) {
   const candidateDirs = [
-    path5__namespace.join(rootDir, "specs", "changes", "active"),
-    path5__namespace.join(rootDir, "specs", "changes", "completed"),
-    path5__namespace.join(rootDir, "specs"),
-    path5__namespace.join(rootDir, "openspec", "changes")
+    path4__namespace.join(rootDir, "specs", "changes", "active"),
+    path4__namespace.join(rootDir, "specs", "changes", "completed"),
+    path4__namespace.join(rootDir, "specs"),
+    path4__namespace.join(rootDir, "openspec", "changes")
   ];
   let maxNum = 0;
   for (const dir of candidateDirs) {
@@ -2739,13 +3261,13 @@ function resolveChangeIdentifiers(rootDir, name, profile, options) {
   };
 }
 function ensureEmptyChangeDir(changeDir) {
-  if (fs6__namespace.existsSync(changeDir)) {
-    const existing = fs6__namespace.readdirSync(changeDir);
+  if (fs7__namespace.existsSync(changeDir)) {
+    const existing = fs7__namespace.readdirSync(changeDir);
     if (existing.length > 0) {
       return `El directorio del cambio '${changeDir}' ya existe y no est\xE1 vac\xEDo.`;
     }
   } else {
-    fs6__namespace.mkdirSync(changeDir, { recursive: true });
+    fs7__namespace.mkdirSync(changeDir, { recursive: true });
   }
   return null;
 }
@@ -2754,7 +3276,7 @@ function scanCanonicalArtifacts(rootDir) {
   const artifactMap = /* @__PURE__ */ new Map();
   for (const file of allMdFiles) {
     try {
-      const content = fs6__namespace.readFileSync(file, "utf-8");
+      const content = fs7__namespace.readFileSync(file, "utf-8");
       const { frontmatter } = parseFrontmatter(content);
       if (frontmatter?.id) {
         const id = String(frontmatter.id);
@@ -2782,7 +3304,7 @@ function parseInputFromIds(rawFrom) {
 }
 function renderCitationsYamlBlock(citedArtifacts) {
   if (citedArtifacts.length === 0) return "";
-  return yaml2__default.default.dump(
+  return yaml3__default.default.dump(
     citedArtifacts.map((c) => ({ id: c.id, digest: c.digest, comment: c.comment })),
     { indent: 2, lineWidth: -1 }
   ).trim().split("\n").map((line) => `  ${line}`).join("\n");
@@ -2817,16 +3339,39 @@ El sistema DEBE implementar y soportar la capacidad de {{NAME}}.
 ## 2. Criterios de Aceptaci\xF3n en Formato Gherkin (Cucumber)
 
 \`\`\`gherkin
-@{{REQ_ID}} @automated
+@{{REQ_ID}} @automated @regression
 Feature: {{NAME}}
   As a user or client system
   I want to execute the capability for {{NAME}}
   So that the expected outcome and value are achieved
 
+  @nominal
   Scenario: Nominal successful flow
     Given the system is in an operational state
     When the operation for "{{NAME}}" is executed
     Then the operation completes successfully
+
+  @boundary
+  Scenario Outline: Boundary limits validation
+    Given the system receives boundary input "<boundary_input>"
+    When the operation for "{{NAME}}" is evaluated at range limits
+    Then the system responds with expected boundary status "<expected_status>"
+
+    Examples:
+      | boundary_input | expected_status |
+      | min_bound      | 200             |
+      | max_bound      | 200             |
+
+  @invalid
+  Scenario Outline: Out-of-range and invalid payload rejection
+    Given the system receives invalid or out-of-range input "<invalid_input>"
+    When the operation for "{{NAME}}" is invoked
+    Then the system rejects the request with error "<error_code>"
+
+    Examples:
+      | invalid_input | error_code       |
+      | empty_payload | ERR_INVALID_ARGS |
+      | overflow_val  | ERR_OUT_OF_RANGE |
 \`\`\`
 
 ---
@@ -2845,12 +3390,33 @@ Definici\xF3n de artefacto citado en {{CANONICAL_ID}}.
 ## 2. Criterios de Aceptaci\xF3n en Formato Gherkin (Cucumber)
 
 \`\`\`gherkin
-@{{ID}} @automated
+@{{ID}} @automated @regression
 Feature: {{NAME}}
+  @nominal
   Scenario: Expected behavior verification
     Given the system is initialized for "{{NAME}}"
     When the request associated with {{ID}} is processed
     Then the response satisfies acceptance criteria
+
+  @boundary
+  Scenario Outline: Boundary limits verification
+    Given boundary input "<input>" for {{ID}}
+    When the request is processed
+    Then the response status is "<status>"
+
+    Examples:
+      | input | status |
+      | min   | 200    |
+
+  @invalid
+  Scenario Outline: Invalid input rejection
+    Given invalid input "<input>" for {{ID}}
+    When the request is processed
+    Then the request is rejected with "<error>"
+
+    Examples:
+      | input | error            |
+      | null  | ERR_INVALID_ARGS |
 \`\`\`
 `;
 var SPEC_BODY = `# Delivery Specification: {{CANONICAL_ID}}
@@ -2864,10 +3430,33 @@ Feature: {{NAME}}
   I want to process the operation for {{NAME}}
   So that delivery criteria are satisfied
 
+  @nominal
   Scenario: Nominal successful flow
     Given the system is in a nominal operational state
     When the operation for "{{NAME}}" is processed
     Then the operation completes successfully satisfying acceptance criteria
+
+  @boundary
+  Scenario Outline: Boundary conditions verification
+    Given the system is configured with boundary value "<value>"
+    When the operation for "{{NAME}}" is processed
+    Then the boundary result matches "<expected>"
+
+    Examples:
+      | value | expected |
+      | min   | accepted |
+      | max   | accepted |
+
+  @invalid
+  Scenario Outline: Out-of-range and invalid input handling
+    Given an invalid or malformed payload "<payload>"
+    When the operation for "{{NAME}}" is attempted
+    Then the system rejects the operation with "<error>"
+
+    Examples:
+      | payload  | error            |
+      | null     | ERR_INVALID_DATA |
+      | overflow | ERR_OUT_OF_RANGE |
 \`\`\`
 
 ---
@@ -2972,6 +3561,7 @@ derives-from:
   - {{UC_ID}}
 verifiable-by: cucumber-bdd
 acceptance-format: gherkin
+enforce-bdd-variants: true
 cucumber-tags:
   - "@{{REQ_ID}}"
   - "@automated"
@@ -2989,6 +3579,7 @@ schema-version: "1.0"
 category: functional
 verifiable-by: cucumber-bdd
 acceptance-format: gherkin
+enforce-bdd-variants: true
 cucumber-tags:
   - "@{{ID}}"
   - "@automated"
@@ -3064,7 +3655,7 @@ function buildPatchSuccess(slug, canonicalId, specPath, citedArtifacts, errors)
     changeId: slug,
     canonicalId,
     profile: "patch",
-    changeDir: path5__namespace.dirname(specPath),
+    changeDir: path4__namespace.dirname(specPath),
     createdFiles: [specPath],
     citedArtifacts,
     errors
@@ -3075,10 +3666,10 @@ function scaffoldPatchChange(rootDir, changeDir, slug, canonicalId, name, inputF
   const citationsSection = citedArtifacts.length > 0 ? `citations:
 ${renderCitationsYamlBlock(citedArtifacts)}
 ` : "";
-  const specPath = path5__namespace.join(changeDir, "spec.md");
+  const specPath = path4__namespace.join(changeDir, "spec.md");
   const specFmObj = buildPatchFmObj(canonicalId);
   const specContent = buildPatchSpecContent(canonicalId, name, citationsSection);
-  fs6__namespace.writeFileSync(specPath, specContent, "utf-8");
+  fs7__namespace.writeFileSync(specPath, specContent, "utf-8");
   const errors = validatePatchArtifacts(rootDir, changeDir, specContent, specFmObj, adapter);
   return buildPatchSuccess(slug, canonicalId, specPath, citedArtifacts, errors);
 }
@@ -3092,26 +3683,26 @@ function createGreenfieldRequirement(rootDir, name, padNum, canonicalId, author,
   const nameSlugUpper = slugify(name).toUpperCase();
   const reqId = `FR-${padNum}-${nameSlugUpper}-001`;
   const ucId = `UC-${padNum}-${nameSlugUpper}`;
-  const productDir = path5__namespace.join(rootDir, "specs", "product");
-  if (!fs6__namespace.existsSync(productDir)) fs6__namespace.mkdirSync(productDir, { recursive: true });
-  const reqFilePath = path5__namespace.join(productDir, `${reqId}.md`);
-  if (fs6__namespace.existsSync(reqFilePath)) return null;
+  const productDir = path4__namespace.join(rootDir, "specs", "product");
+  if (!fs7__namespace.existsSync(productDir)) fs7__namespace.mkdirSync(productDir, { recursive: true });
+  const reqFilePath = path4__namespace.join(productDir, `${reqId}.md`);
+  if (fs7__namespace.existsSync(reqFilePath)) return null;
   const reqContent = buildGreenfieldContent(reqId, ucId, name, canonicalId, author, dateStr);
-  fs6__namespace.writeFileSync(reqFilePath, reqContent, "utf-8");
+  fs7__namespace.writeFileSync(reqFilePath, reqContent, "utf-8");
   createdFiles.push(reqFilePath);
   const digest = computeCanonicalSha256(reqContent);
   return { reqId, ucId, reqFilePath, digest };
 }
 function createMissingDraftRequirement(rootDir, name, id, canonicalId, createdFiles) {
-  const productDir = path5__namespace.join(rootDir, "specs", "product");
-  if (!fs6__namespace.existsSync(productDir)) fs6__namespace.mkdirSync(productDir, { recursive: true });
-  const reqFilePath = path5__namespace.join(productDir, `${id}.md`);
+  const productDir = path4__namespace.join(rootDir, "specs", "product");
+  if (!fs7__namespace.existsSync(productDir)) fs7__namespace.mkdirSync(productDir, { recursive: true });
+  const reqFilePath = path4__namespace.join(productDir, `${id}.md`);
   const reqType = id.startsWith("UC-") ? "use-case" : id.startsWith("SEC-REQ-") ? "security-requirement" : "requirement";
   const header = MISSING_DRAFT_HEADER.replaceAll("{{ID}}", id).replaceAll("{{TYPE}}", reqType).replaceAll("{{NAME}}", name);
   const body = MISSING_DRAFT_BODY.replaceAll("{{ID}}", id).replaceAll("{{NAME}}", name).replaceAll("{{CANONICAL_ID}}", canonicalId);
   const reqContent = `${header}
 ${body}`;
-  fs6__namespace.writeFileSync(reqFilePath, reqContent, "utf-8");
+  fs7__namespace.writeFileSync(reqFilePath, reqContent, "utf-8");
   createdFiles.push(reqFilePath);
   const digest = computeCanonicalSha256(reqContent);
   return { reqFilePath, digest };
@@ -3199,7 +3790,7 @@ function collectChangeCitations(rootDir, name, padNum, canonicalId, author, date
   return col;
 }
 function renderProposalFile(changeDir, canonicalId, name, author, citationsYamlBlock) {
-  const proposalPath = path5__namespace.join(changeDir, "proposal.md");
+  const proposalPath = path4__namespace.join(changeDir, "proposal.md");
   const citationsSection = citationsYamlBlock ? `citations:
 ${citationsYamlBlock}
 ` : "";
@@ -3219,11 +3810,11 @@ ${name}
 ## 2. Dependencias Externas Evaluadas
 - Lista de dependencias nuevas a incorporar y verificaci\xF3n de licencia seg\xFAn \`license-policy.yaml\`.
 `;
-  fs6__namespace.writeFileSync(proposalPath, proposalContent, "utf-8");
+  fs7__namespace.writeFileSync(proposalPath, proposalContent, "utf-8");
   return proposalPath;
 }
 function renderSpecFile(changeDir, canonicalId, name, profile) {
-  const specPath = path5__namespace.join(changeDir, "spec.md");
+  const specPath = path4__namespace.join(changeDir, "spec.md");
   const specFmObj = {
     id: `SPEC-${canonicalId}`,
     type: "delivery-spec",
@@ -3244,12 +3835,12 @@ cucumber-tags:
 ---
 `;
   const body = SPEC_BODY.replaceAll("{{CANONICAL_ID}}", canonicalId).replaceAll("{{NAME}}", name);
-  fs6__namespace.writeFileSync(specPath, `${header}
+  fs7__namespace.writeFileSync(specPath, `${header}
 ${body}`, "utf-8");
   return { specPath, specFmObj };
 }
 function renderDesignFile(changeDir, canonicalId, name, author, dateStr, citationsYamlBlock) {
-  const designPath = path5__namespace.join(changeDir, "design.md");
+  const designPath = path4__namespace.join(changeDir, "design.md");
   const citationsSection = citationsYamlBlock ? `citations:
 ${citationsYamlBlock}
 ` : "";
@@ -3264,14 +3855,20 @@ handoff: "HOF-${canonicalId}"
 architecture-component: "CMP-CORE"
 enclave: "SEC-ENC-DMZ"
 status: draft
+contracts: []
 ${citationsSection}---
 `;
   const body = DESIGN_BODY.replaceAll("{{CANONICAL_ID}}", canonicalId).replaceAll("{{NAME}}", name).replaceAll("{{AUTHOR}}", author).replaceAll("{{DATE}}", dateStr);
-  fs6__namespace.writeFileSync(designPath, `${header}
+  fs7__namespace.writeFileSync(designPath, `${header}
 ${body}`, "utf-8");
   return designPath;
 }
-function buildTasksFrontmatter(canonicalId, name) {
+function buildTasksFrontmatter(canonicalId, name, reqIds) {
+  const tasks = DEFAULT_TASKS_ARRAY.map((t) => ({
+    ...t,
+    "implements-components": ["CMP-CORE"],
+    ...reqIds.length > 0 ? { "satisfies-requirements": reqIds } : {}
+  }));
   return {
     id: `TSK-PLAN-${canonicalId}`,
     type: "task-plan",
@@ -3281,20 +3878,20 @@ function buildTasksFrontmatter(canonicalId, name) {
     "schema-version": "1.0",
     status: "draft",
     "governance-summary": GOVERNANCE_SUMMARY_DEFAULT,
-    tasks: DEFAULT_TASKS_ARRAY,
+    tasks,
     supersedes: null,
     "superseded-by": null
   };
 }
-function renderTasksFile(changeDir, canonicalId, name, author, dateStr) {
-  const tasksPath = path5__namespace.join(changeDir, "tasks.md");
-  const tasksFm = buildTasksFrontmatter(canonicalId, name);
+function renderTasksFile(changeDir, canonicalId, name, author, dateStr, reqIds) {
+  const tasksPath = path4__namespace.join(changeDir, "tasks.md");
+  const tasksFm = buildTasksFrontmatter(canonicalId, name, reqIds);
   const header = `---
-${yaml2__default.default.dump(tasksFm, { indent: 2, lineWidth: -1 }).trim()}
+${yaml3__default.default.dump(tasksFm, { indent: 2, lineWidth: -1 }).trim()}
 ---
 `;
   const body = TASKS_BODY.replaceAll("{{CANONICAL_ID}}", canonicalId).replaceAll("{{NAME}}", name).replaceAll("{{AUTHOR}}", author).replaceAll("{{DATE}}", dateStr);
-  fs6__namespace.writeFileSync(tasksPath, `${header}
+  fs7__namespace.writeFileSync(tasksPath, `${header}
 ${body}`, "utf-8");
   return { tasksPath, tasksFm };
 }
@@ -3346,12 +3943,14 @@ function buildScaffoldFailure(profile, error, slug = "", canonicalId = "", chang
     errors: [error]
   };
 }
-function renderAndCollectArtifactFiles(changeDir, canonicalId, name, author, dateStr, profile, citationsBlock, createdFiles) {
+function renderAndCollectArtifactFiles(changeDir, canonicalId, name, author, dateStr, profile, citations, createdFiles) {
+  const citationsBlock = renderCitationsYamlBlock(citations.citedArtifacts);
+  const reqIds = [...citations.subRequirements, ...citations.subSecReqs];
   createdFiles.push(renderProposalFile(changeDir, canonicalId, name, author, citationsBlock));
   const { specPath, specFmObj } = renderSpecFile(changeDir, canonicalId, name, profile);
   createdFiles.push(specPath);
   createdFiles.push(renderDesignFile(changeDir, canonicalId, name, author, dateStr, citationsBlock));
-  const { tasksPath, tasksFm } = renderTasksFile(changeDir, canonicalId, name, author, dateStr);
+  const { tasksPath, tasksFm } = renderTasksFile(changeDir, canonicalId, name, author, dateStr, reqIds);
   createdFiles.push(tasksPath);
   return { specFmObj, tasksFm };
 }
@@ -3371,8 +3970,7 @@ function buildScaffoldSuccess(slug, canonicalId, profile, changeDir, createdFile
 function executeStandardScaffolding(rootDir, changeDir, slug, canonicalId, name, padNum, author, dateStr, profile, framework, inputFromIds, artifactMap, adapter) {
   const createdFiles = [];
   const citations = collectChangeCitations(rootDir, name, padNum, canonicalId, author, dateStr, inputFromIds, artifactMap, createdFiles);
-  const citationsBlock = renderCitationsYamlBlock(citations.citedArtifacts);
-  const { specFmObj, tasksFm } = renderAndCollectArtifactFiles(changeDir, canonicalId, name, author, dateStr, profile, citationsBlock, createdFiles);
+  const { specFmObj, tasksFm } = renderAndCollectArtifactFiles(changeDir, canonicalId, name, author, dateStr, profile, citations, createdFiles);
   const { depositedPath, handoff } = renderHandoffSidecar(rootDir, slug, canonicalId, name, framework, citations);
   createdFiles.push(depositedPath);
   const errors = validateScaffoldedArtifacts(rootDir, changeDir, adapter, specFmObj, tasksFm, handoff);
@@ -3469,7 +4067,7 @@ function resolveCiEnvironment(env = process.env) {
   };
 }
 function updateExistingEnvFile(filePath, envString, uppercaseKey) {
-  const content = fs6__namespace.readFileSync(filePath, "utf-8");
+  const content = fs7__namespace.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   let found = false;
   const newLines = lines.map((line) => {
@@ -3480,15 +4078,15 @@ function updateExistingEnvFile(filePath, envString, uppercaseKey) {
     return line;
   });
   if (!found) newLines.push(envString);
-  fs6__namespace.writeFileSync(filePath, newLines.filter((l) => l.trim() !== "").join("\n") + "\n", "utf-8");
+  fs7__namespace.writeFileSync(filePath, newLines.filter((l) => l.trim() !== "").join("\n") + "\n", "utf-8");
 }
 function writeEnvOutputFile(envOutputFile, key, value) {
   const uppercaseKey = key.toUpperCase();
   const envString = `${uppercaseKey}=${value}`;
-  if (fs6__namespace.existsSync(envOutputFile)) {
+  if (fs7__namespace.existsSync(envOutputFile)) {
     updateExistingEnvFile(envOutputFile, envString, uppercaseKey);
   } else {
-    fs6__namespace.writeFileSync(envOutputFile, envString + "\n", "utf-8");
+    fs7__namespace.writeFileSync(envOutputFile, envString + "\n", "utf-8");
   }
 }
 function resolveEnvOutputFilePath(env) {
@@ -3498,8 +4096,8 @@ function resolveEnvOutputFilePath(env) {
   return void 0;
 }
 function emitCiOutput(key, value, env = process.env) {
-  if (env.GITHUB_OUTPUT && fs6__namespace.existsSync(env.GITHUB_OUTPUT)) {
-    fs6__namespace.appendFileSync(env.GITHUB_OUTPUT, `${key}=${value}
+  if (env.GITHUB_OUTPUT && fs7__namespace.existsSync(env.GITHUB_OUTPUT)) {
+    fs7__namespace.appendFileSync(env.GITHUB_OUTPUT, `${key}=${value}
 `, "utf-8");
   }
   if (env.TF_BUILD === "true") {
@@ -3541,11 +4139,11 @@ function isIgnoredEntry(name) {
   return name === "changes" || name === "active" || name === "node_modules";
 }
 function scanParentDirectoryHandoffs(parentDir, handoffsMap) {
-  if (!fs6__namespace.existsSync(parentDir)) return;
-  const entries = fs6__namespace.readdirSync(parentDir, { withFileTypes: true });
+  if (!fs7__namespace.existsSync(parentDir)) return;
+  const entries = fs7__namespace.readdirSync(parentDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory() || isIgnoredEntry(entry.name)) continue;
-    const changeDir = path5__namespace.join(parentDir, entry.name);
+    const changeDir = path4__namespace.join(parentDir, entry.name);
     if (handooffsHasDir(handoffsMap, changeDir)) continue;
     const handoff = loadProductHandoffSidecar(changeDir);
     if (handoff?.id) {
@@ -3556,10 +4154,10 @@ function scanParentDirectoryHandoffs(parentDir, handoffsMap) {
 function scanAllProductHandoffs(rootDir) {
   const handoffsMap = /* @__PURE__ */ new Map();
   const candidateParentDirs = [
-    path5__namespace.join(rootDir, "specs", "changes", "active"),
-    path5__namespace.join(rootDir, "specs", "changes", "completed"),
-    path5__namespace.join(rootDir, "specs"),
-    path5__namespace.join(rootDir, "openspec", "changes")
+    path4__namespace.join(rootDir, "specs", "changes", "active"),
+    path4__namespace.join(rootDir, "specs", "changes", "completed"),
+    path4__namespace.join(rootDir, "specs"),
+    path4__namespace.join(rootDir, "openspec", "changes")
   ];
   for (const parentDir of candidateParentDirs) {
     scanParentDirectoryHandoffs(parentDir, handoffsMap);
@@ -3567,9 +4165,9 @@ function scanAllProductHandoffs(rootDir) {
   return handoffsMap;
 }
 function handooffsHasDir(map, dir) {
-  const norm = path5__namespace.resolve(dir);
+  const norm = path4__namespace.resolve(dir);
   for (const key of map.keys()) {
-    if (path5__namespace.resolve(key) === norm) return true;
+    if (path4__namespace.resolve(key) === norm) return true;
   }
   return false;
 }
@@ -3579,7 +4177,7 @@ function parseFrontmatter(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!match) return { frontmatter: {}, body: content };
   try {
-    const parsed = yaml2__default.default.load(match[1]);
+    const parsed = yaml3__default.default.load(match[1]);
     const frontmatter = parsed && typeof parsed === "object" ? parsed : {};
     return { frontmatter, body: content.substring(match[0].length) };
   } catch {
@@ -3666,9 +4264,9 @@ function isCodeTestFile(name) {
 }
 function indexFeatureFile(fullPath, rootDir, map) {
   try {
-    const content = fs6__namespace.readFileSync(fullPath, "utf-8");
+    const content = fs7__namespace.readFileSync(fullPath, "utf-8");
     const tags = extractFeatureTags(content);
-    const relFeature = path5__namespace.relative(rootDir, fullPath).replace(/\\/g, "/");
+    const relFeature = path4__namespace.relative(rootDir, fullPath).replace(/\\/g, "/");
     for (const tag of tags) {
       const existing = map.get(tag) || [];
       if (!existing.includes(relFeature)) existing.push(relFeature);
@@ -3678,11 +4276,11 @@ function indexFeatureFile(fullPath, rootDir, map) {
   }
 }
 function scanFeatureFiles(dir, rootDir, map) {
-  if (!fs6__namespace.existsSync(dir)) return;
+  if (!fs7__namespace.existsSync(dir)) return;
   try {
-    const entries = fs6__namespace.readdirSync(dir, { withFileTypes: true });
+    const entries = fs7__namespace.readdirSync(dir, { withFileTypes: true });
     for (const e of entries) {
-      const fullPath = path5__namespace.join(dir, e.name);
+      const fullPath = path4__namespace.join(dir, e.name);
       if (e.isDirectory() && !shouldSkipDir(e.name)) {
         scanFeatureFiles(fullPath, rootDir, map);
       } else if (e.name.endsWith(".feature")) {
@@ -3694,8 +4292,8 @@ function scanFeatureFiles(dir, rootDir, map) {
 }
 function indexCodeTestFile(fullPath, rootDir, reqIds, map) {
   try {
-    const content = fs6__namespace.readFileSync(fullPath, "utf-8");
-    const relTest = path5__namespace.relative(rootDir, fullPath).replace(/\\/g, "/");
+    const content = fs7__namespace.readFileSync(fullPath, "utf-8");
+    const relTest = path4__namespace.relative(rootDir, fullPath).replace(/\\/g, "/");
     for (const artId of reqIds) {
       if (content.includes(artId)) {
         const existing = map.get(artId) || [];
@@ -3707,11 +4305,11 @@ function indexCodeTestFile(fullPath, rootDir, reqIds, map) {
   }
 }
 function scanCodeTestFiles(dir, rootDir, reqIds, map) {
-  if (!fs6__namespace.existsSync(dir)) return;
+  if (!fs7__namespace.existsSync(dir)) return;
   try {
-    const entries = fs6__namespace.readdirSync(dir, { withFileTypes: true });
+    const entries = fs7__namespace.readdirSync(dir, { withFileTypes: true });
     for (const e of entries) {
-      const fullPath = path5__namespace.join(dir, e.name);
+      const fullPath = path4__namespace.join(dir, e.name);
       if (e.isDirectory() && !shouldSkipDir(e.name)) {
         scanCodeTestFiles(fullPath, rootDir, reqIds, map);
       } else if (isCodeTestFile(e.name)) {
@@ -3745,9 +4343,9 @@ function isArchitectureViewFile(relFile, frontmatter) {
 }
 function processSingleMdFile(file, rootDir, artifactMap, componentsList, architectureViews) {
   try {
-    const content = fs6__namespace.readFileSync(file, "utf-8");
+    const content = fs7__namespace.readFileSync(file, "utf-8");
     const { frontmatter, body } = parseFrontmatter(content);
-    const relFile = path5__namespace.relative(rootDir, file).replace(/\\/g, "/");
+    const relFile = path4__namespace.relative(rootDir, file).replace(/\\/g, "/");
     if (frontmatter.id) {
       artifactMap.set(frontmatter.id, {
         file: relFile,
@@ -3908,7 +4506,7 @@ function collectArchitectureViewTraces(reqId, architectureViews) {
   const traces = [];
   for (const view of architectureViews) {
     if (view.content.includes(reqId)) {
-      const viewIdentifier = isEntityWithId(view) && view.id ? view.id : path5__namespace.basename(view.file);
+      const viewIdentifier = isEntityWithId(view) && view.id ? view.id : path4__namespace.basename(view.file);
       traces.push(viewIdentifier);
     }
   }
@@ -3990,33 +4588,115 @@ function evaluateAllRequirements(requirements, ctx) {
   }
   return { matrixRows, orphans, errorCount };
 }
-function verifyTraceability(options = {}) {
-  const rootDir = options.rootDir || process.cwd();
-  const allMdFiles = walkMdFiles(rootDir);
+var SOURCE_CODE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".java", ".cs", ".rs"];
+function isProductionSourceFile(name) {
+  if (isCodeTestFile(name) || name.endsWith(".d.ts")) return false;
+  return SOURCE_CODE_EXTS.some((ext) => name.endsWith(ext));
+}
+function collectCodeAndTestCorpora(dir, prodChunks = [], testChunks = []) {
+  if (!fs7__namespace.existsSync(dir)) return { prodCorpus: "", testCorpus: "" };
+  try {
+    for (const e of fs7__namespace.readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = path4__namespace.join(dir, e.name);
+      if (e.isDirectory() && !shouldSkipDir(e.name)) {
+        collectCodeAndTestCorpora(fullPath, prodChunks, testChunks);
+      } else if (isCodeTestFile(e.name) || e.name.endsWith(".feature")) {
+        testChunks.push(fs7__namespace.readFileSync(fullPath, "utf-8"));
+      } else if (isProductionSourceFile(e.name)) {
+        prodChunks.push(fs7__namespace.readFileSync(fullPath, "utf-8"));
+      }
+    }
+  } catch {
+  }
+  return { prodCorpus: prodChunks.join("\n"), testCorpus: testChunks.join("\n") };
+}
+function parseStringContractEntry(designId, defaultComp, raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  const parts = trimmed.split(".");
+  const method = parts.pop();
+  const interfaceName = parts.length > 0 ? parts.join(".") : void 0;
+  return { designId, component: defaultComp, interfaceName, method };
+}
+function parseObjectContractEntries(designId, defaultComp, item) {
+  if (!Array.isArray(item.methods)) return [];
+  const component = item.component || defaultComp;
+  return item.methods.filter((m) => typeof m === "string" && Boolean(m.trim())).map((m) => ({ designId, component, interfaceName: item.interface, method: m.trim() }));
+}
+function expandContractDeclarations(designId, defaultComp, rawContracts) {
+  const expanded = [];
+  for (const item of rawContracts) {
+    if (typeof item === "string") {
+      const parsed = parseStringContractEntry(designId, defaultComp, item);
+      if (parsed) expanded.push(parsed);
+    } else if (item && typeof item === "object") {
+      expanded.push(...parseObjectContractEntries(designId, defaultComp, item));
+    }
+  }
+  return expanded;
+}
+function evaluateSingleContractMethod(entry, prodCorpus, testCorpus) {
+  const symbol = entry.method.includes(".") ? entry.method.split(".").pop() : entry.method;
+  const implementedInCode = prodCorpus.includes(symbol);
+  const testedInSuite = testCorpus.includes(symbol);
+  const status = !implementedInCode ? "MISSING_IMPLEMENTATION" : !testedInSuite ? "MISSING_UNIT_TEST" : "COMPLIANT";
+  return {
+    designId: entry.designId,
+    component: entry.component,
+    interfaceName: entry.interfaceName,
+    method: entry.method,
+    implementedInCode,
+    testedInSuite,
+    status
+  };
+}
+function auditDesignContracts(rootDir, artifactMap) {
+  const pending = [];
+  for (const [id, entry] of artifactMap.entries()) {
+    if (entry.file.includes("templates/") || entry.file.includes(".template.")) continue;
+    const rawContracts = entry.frontmatter.contracts;
+    if (!Array.isArray(rawContracts) || rawContracts.length === 0) continue;
+    const defaultComp = typeof entry.frontmatter["architecture-component"] === "string" ? entry.frontmatter["architecture-component"] : void 0;
+    pending.push(...expandContractDeclarations(id, defaultComp, rawContracts));
+  }
+  if (pending.length === 0) {
+    return { contractAudits: [], missingContractsCount: 0 };
+  }
+  const { prodCorpus, testCorpus } = collectCodeAndTestCorpora(rootDir);
+  const contractAudits = pending.map((p) => evaluateSingleContractMethod(p, prodCorpus, testCorpus));
+  const missingContractsCount = contractAudits.filter((c) => c.status !== "COMPLIANT").length;
+  return { contractAudits, missingContractsCount };
+}
+function buildTraceabilityContext(rootDir, allMdFiles) {
   const { artifactMap, componentsList, architectureViews } = indexAllArtifacts(allMdFiles, rootDir);
   const handoffList = buildHandoffList(rootDir, artifactMap);
   const reqToHandoffMap = indexRequirementsToHandoff(handoffList);
   const { featureTagMap, codeTestMap } = buildTestMaps(rootDir, artifactMap);
   const requirements = collectRequirementsToVerify(artifactMap);
-  const ctx = {
-    reqToHandoffMap,
-    artifactMap,
-    componentsList,
-    architectureViews,
-    featureTagMap,
-    codeTestMap
+  return {
+    ctx: { reqToHandoffMap, artifactMap, componentsList, architectureViews, featureTagMap, codeTestMap },
+    requirements
   };
+}
+function verifyTraceability(options = {}) {
+  const rootDir = options.rootDir || process.cwd();
+  const allMdFiles = walkMdFiles(rootDir);
+  const { ctx, requirements } = buildTraceabilityContext(rootDir, allMdFiles);
   const { matrixRows, orphans, errorCount } = evaluateAllRequirements(requirements, ctx);
+  const { contractAudits, missingContractsCount } = auditDesignContracts(rootDir, ctx.artifactMap);
+  const totalIssues = errorCount + missingContractsCount;
   return {
-    success: errorCount === 0,
+    success: totalIssues === 0,
     rows: matrixRows,
     orphans,
     orphanCount: orphans.length,
     totalRequirements: requirements.length,
-    reportMarkdown: generateTraceabilityReportMarkdown(matrixRows, errorCount)
+    contractAudits,
+    missingContractsCount,
+    reportMarkdown: generateTraceabilityReportMarkdown(matrixRows, totalIssues)
   };
 }
-function parseTaskVerification(rawVerification) {
+function parseTaskVerification2(rawVerification) {
   const verification = {};
   if (rawVerification && typeof rawVerification === "object") {
     const v = rawVerification;
@@ -4025,6 +4705,12 @@ function parseTaskVerification(rawVerification) {
   }
   return verification;
 }
+function parseOptionalStringList(val) {
+  if (Array.isArray(val)) {
+    return val.map(String).filter(Boolean);
+  }
+  return void 0;
+}
 function mapRawTaskItem(t) {
   return {
     id: typeof t["id"] === "string" ? t["id"] : String(t["id"] ?? ""),
@@ -4035,7 +4721,10 @@ function mapRawTaskItem(t) {
     assignedTo: typeof t["assigned-to"] === "string" ? t["assigned-to"] : void 0,
     status: typeof t["status"] === "string" ? t["status"] : void 0,
     blockingReason: typeof t["blocking-reason"] === "string" ? t["blocking-reason"] : void 0,
-    verification: parseTaskVerification(t["verification"])
+    implementsComponents: parseOptionalStringList(t["implements-components"]),
+    satisfiesRequirements: parseOptionalStringList(t["satisfies-requirements"]),
+    implementsContracts: parseOptionalStringList(t["implements-contracts"]),
+    verification: parseTaskVerification2(t["verification"])
   };
 }
 function parseTasksDoc(content) {
@@ -4043,7 +4732,7 @@ function parseTasksDoc(content) {
   if (!match) return { frontmatter: { tasks: [] }, body: content };
   let parsed;
   try {
-    parsed = yaml2__default.default.load(match[1]);
+    parsed = yaml3__default.default.load(match[1]);
   } catch {
     return { frontmatter: { tasks: [] }, body: content };
   }
@@ -4068,12 +4757,12 @@ function walkTaskFiles(dir, fileList = [], excludeDirs = [
   "examples"
 ]) {
   try {
-    if (!fs6__namespace.existsSync(dir)) return fileList;
-    const files = fs6__namespace.readdirSync(dir);
+    if (!fs7__namespace.existsSync(dir)) return fileList;
+    const files = fs7__namespace.readdirSync(dir);
     for (const file of files) {
-      const fullPath = path5__namespace.join(dir, file);
+      const fullPath = path4__namespace.join(dir, file);
       try {
-        if (fs6__namespace.statSync(fullPath).isDirectory()) {
+        if (fs7__namespace.statSync(fullPath).isDirectory()) {
           if (!excludeDirs.includes(file)) {
             walkTaskFiles(fullPath, fileList, excludeDirs);
           }
@@ -4186,26 +4875,86 @@ function updateGovernanceCounts(t, modeCounts, riskCounts) {
   }
 }
 function parseTasksFromFile(file) {
-  if (!fs6__namespace.existsSync(file)) return [];
+  if (!fs7__namespace.existsSync(file)) return [];
   try {
-    const content = fs6__namespace.readFileSync(file, "utf-8");
+    const content = fs7__namespace.readFileSync(file, "utf-8");
     const { frontmatter } = parseTasksDoc(content);
     return frontmatter.tasks || [];
   } catch {
     return [];
   }
 }
-function processTasksFile(file, rootDir, modeCounts, riskCounts, taskSummaries, violationsList) {
+function extractDesignExpectedScope(changeDir) {
+  const designFile = path4__namespace.join(changeDir, "design.md");
+  if (!fs7__namespace.existsSync(designFile)) return [];
+  const expected = [];
+  try {
+    const { frontmatter } = parseTasksDoc(fs7__namespace.readFileSync(designFile, "utf-8"));
+    if (typeof frontmatter["architecture-component"] === "string") {
+      expected.push(frontmatter["architecture-component"]);
+    }
+    if (Array.isArray(frontmatter["architecture-components"])) {
+      expected.push(...frontmatter["architecture-components"].map(String));
+    }
+  } catch {
+  }
+  return expected;
+}
+function extractHandoffExpectedScope(changeDir, maxUc, violations) {
+  const handoff = loadProductHandoffSidecar(changeDir);
+  if (!handoff?.subgraph) return [];
+  const ucList = handoff.subgraph.useCases || [];
+  if (maxUc !== void 0 && ucList.length > maxUc && violations) {
+    violations.push(
+      `[${handoff.changeId}] Greenfield monolith detected: change bundles ${ucList.length} use cases (max ${maxUc}). Decompose into incremental SDD changes per Use Case.`
+    );
+  }
+  const reqs = handoff.subgraph.requirements || [];
+  const secReqs = handoff.subgraph.securityRequirements || [];
+  return [...reqs, ...secReqs];
+}
+function collectTaskCoveredScope(tasks) {
+  const covered = /* @__PURE__ */ new Set();
+  for (const t of tasks) {
+    for (const c of t.implementsComponents || []) covered.add(c);
+    for (const r of t.satisfiesRequirements || []) covered.add(r);
+    for (const m of t.implementsContracts || []) covered.add(m);
+  }
+  return covered;
+}
+function hasExplicitScopeBindings(tasks) {
+  return tasks.some(
+    (t) => t.implementsComponents && t.implementsComponents.length > 0 || t.satisfiesRequirements && t.satisfiesRequirements.length > 0 || t.implementsContracts && t.implementsContracts.length > 0
+  );
+}
+function auditDesignScopeForFile(file, tasks, options, unassignedList, violationsList) {
+  const changeDir = path4__namespace.dirname(file);
+  const expectedItems = [
+    ...extractDesignExpectedScope(changeDir),
+    ...extractHandoffExpectedScope(changeDir, options.maxUseCasesPerChange, violationsList)
+  ];
+  const shouldEnforce = Boolean(options.enforceDesignCoverage || hasExplicitScopeBindings(tasks));
+  if (!shouldEnforce || expectedItems.length === 0) return;
+  const covered = collectTaskCoveredScope(tasks);
+  for (const item of new Set(expectedItems)) {
+    if (!covered.has(item)) {
+      unassignedList.push(item);
+      violationsList.push(`[${path4__namespace.basename(changeDir)}] Unassigned design/handoff scope in tasks.md: missing task coverage for ${item}`);
+    }
+  }
+}
+function processTasksFile(file, rootDir, options, acc) {
   const tasks = parseTasksFromFile(file);
-  const relPath = path5__namespace.relative(rootDir, file).replace(/\\/g, "/");
+  const relPath = path4__namespace.relative(rootDir, file).replace(/\\/g, "/");
   let unverifiedDelta = 0;
   for (const t of tasks) {
     const { summary, violation, unverified } = evaluateTaskItem(t, relPath);
-    if (violation) violationsList.push(violation);
+    if (violation) acc.violationsList.push(violation);
     if (unverified) unverifiedDelta++;
-    updateGovernanceCounts(t, modeCounts, riskCounts);
-    taskSummaries.push(summary);
+    updateGovernanceCounts(t, acc.modeCounts, acc.riskCounts);
+    acc.taskSummaries.push(summary);
   }
+  auditDesignScopeForFile(file, tasks, options, acc.unassignedDesignScope, acc.violationsList);
   return { tasksCount: tasks.length, unverifiedDelta };
 }
 function createInitialModeCounts() {
@@ -4224,30 +4973,32 @@ function createInitialRiskCounts() {
     CRITICAL: 0
   };
 }
-function assembleGovernanceResult(totalTasks, unverifiedCount, riskCounts, modeCounts, taskSummaries, violationsList, reportMarkdown) {
+function assembleGovernanceResult(acc, reportMarkdown) {
   return {
-    success: violationsList.length === 0,
-    totalTasks,
-    verifiedCount: totalTasks - unverifiedCount,
-    unverifiedCount,
-    riskCounts,
-    modeCounts,
-    tasks: taskSummaries,
-    violations: violationsList,
+    success: acc.violationsList.length === 0,
+    totalTasks: acc.totalTasks,
+    verifiedCount: acc.totalTasks - acc.unverifiedCount,
+    unverifiedCount: acc.unverifiedCount,
+    riskCounts: acc.riskCounts,
+    modeCounts: acc.modeCounts,
+    tasks: acc.taskSummaries,
+    violations: acc.violationsList,
+    unassignedDesignScope: acc.unassignedDesignScope,
     reportMarkdown
   };
 }
-function collectAllTasksData(taskFiles, rootDir) {
+function collectAllTasksData(taskFiles, rootDir, options) {
   const acc = {
     totalTasks: 0,
     unverifiedCount: 0,
     taskSummaries: [],
     violationsList: [],
+    unassignedDesignScope: [],
     modeCounts: createInitialModeCounts(),
     riskCounts: createInitialRiskCounts()
   };
   for (const file of taskFiles) {
-    const delta = processTasksFile(file, rootDir, acc.modeCounts, acc.riskCounts, acc.taskSummaries, acc.violationsList);
+    const delta = processTasksFile(file, rootDir, options, acc);
     acc.totalTasks += delta.tasksCount;
     acc.unverifiedCount += delta.unverifiedDelta;
   }
@@ -4256,308 +5007,14 @@ function collectAllTasksData(taskFiles, rootDir) {
 function verifyTasksGovernance(options = {}) {
   const rootDir = options.rootDir || process.cwd();
   const searchDir = options.specsDir || rootDir;
-  const data = collectAllTasksData(walkTaskFiles(searchDir), rootDir);
+  const data = collectAllTasksData(walkTaskFiles(searchDir), rootDir, options);
   const reportMarkdown = generateGovernanceReportMarkdown(
     data.taskSummaries,
     data.violationsList.length,
     data.modeCounts,
     data.totalTasks
   );
-  return assembleGovernanceResult(
-    data.totalTasks,
-    data.unverifiedCount,
-    data.riskCounts,
-    data.modeCounts,
-    data.taskSummaries,
-    data.violationsList,
-    reportMarkdown
-  );
-}
-function parseTaskVerification2(v) {
-  const verification = {};
-  if (v && typeof v === "object") {
-    const rec = v;
-    if (typeof rec["method"] === "string") verification.method = rec["method"];
-    if (typeof rec["command-or-criteria"] === "string") verification.criteria = rec["command-or-criteria"];
-  }
-  return verification;
-}
-function parseTaskItem(t) {
-  return {
-    id: typeof t["id"] === "string" ? t["id"] : String(t["id"] ?? ""),
-    title: typeof t["title"] === "string" ? t["title"] : void 0,
-    verification: parseTaskVerification2(t["verification"])
-  };
-}
-function parseVerifiedByTests(verifiedBy) {
-  if (Array.isArray(verifiedBy)) {
-    return verifiedBy.map(String);
-  }
-  if (typeof verifiedBy === "string") {
-    return [verifiedBy];
-  }
-  return void 0;
-}
-function parseGenericDoc(content) {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match) return { frontmatter: {}, body: content };
-  let parsed;
-  try {
-    parsed = yaml2__default.default.load(match[1]);
-  } catch {
-    return { frontmatter: {}, body: content };
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    return { frontmatter: {}, body: content };
-  }
-  const raw = parsed;
-  const rawTasks = Array.isArray(raw["tasks"]) ? raw["tasks"] : [];
-  const tasks = rawTasks.map(parseTaskItem);
-  const frontmatter = {
-    ...raw,
-    tasks,
-    "verified-by-tests": parseVerifiedByTests(raw["verified-by-tests"])
-  };
-  return { frontmatter, body: content.substring(match[0].length) };
-}
-function buildRequirementsTable(reqAudit) {
-  const lines = [
-    `## 1. Requirements Audit (Product, Quality, and Security)`,
-    ``,
-    `| Requirement ID | Title | Source File | Declared Method | Linked Test Files | Status |`,
-    `| :--- | :--- | :--- | :---: | :--- | :---: |`
-  ];
-  for (const r of reqAudit) {
-    const icon = r.status === "VERIFICADO_CON_PRUEBA" ? "\u2705 VERIFIED" : "\u274C NO TESTS";
-    lines.push(
-      `| **\`${r.id}\`** | ${r.title} | \`${r.file}\` | \`${r.method}\` | \`${r.testRefs}\` | ${icon} |`
-    );
-  }
-  return lines;
-}
-function buildTasksTable(taskAudit) {
-  const lines = [
-    `## 2. Tasks Audit (SDD Delivery Engineering)`,
-    ``,
-    `| Task ID | Title | tasks.md File | Method | Verification Command / Criterion | Status |`,
-    `| :--- | :--- | :--- | :---: | :--- | :---: |`
-  ];
-  for (const t of taskAudit) {
-    const icon = t.status === "VERIFICADO_CON_PRUEBA" ? "\u2705 VERIFIED" : "\u274C NO TESTS";
-    lines.push(
-      `| **\`${t.id}\`** | ${t.title} | \`${t.file}\` | \`${t.method}\` | \`${t.commandOrCriteria}\` | ${icon} |`
-    );
-  }
-  return lines;
-}
-function generateTestingCoverageReportMarkdown(reqAudit, taskAudit, reqErrors, taskErrors) {
-  const totalErrors = reqErrors + taskErrors;
-  const verdict = totalErrors === 0 ? "100% VERIFIED WITH TESTS (PASSED)" : `BLOCKED: Detected ${totalErrors} items without tests (${reqErrors} Requirements, ${taskErrors} Tasks)`;
-  const reportLines = [
-    `# \u{1F9EA} Deterministic Test Coverage Audit for Requirements and Tasks`,
-    ``,
-    `> **Audit Date:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
-    `> **Overall Verdict:** ${verdict}`,
-    ``,
-    `---`,
-    ``,
-    ...buildRequirementsTable(reqAudit),
-    ``,
-    `---`,
-    ``,
-    ...buildTasksTable(taskAudit)
-  ];
-  return reportLines.join("\n");
-}
-var EXCLUDED_TEST_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  "bin",
-  "obj",
-  "build",
-  "out",
-  "target",
-  "coverage",
-  ".changeset",
-  "scratch",
-  "fixtures",
-  "templates",
-  "examples",
-  ".vs",
-  ".idea"
-]);
-var TEST_EXTENSIONS = [".feature", ".spec.ts", ".spec.js", ".test.ts", ".test.js", "_test.py", "_test.go"];
-function isTestFile(fileName) {
-  return TEST_EXTENSIONS.some((ext) => fileName.endsWith(ext));
-}
-function recordRequirementTest(reqToTestsMap, reqId, relTest) {
-  const existing = reqToTestsMap.get(reqId) || [];
-  if (!existing.includes(relTest)) {
-    existing.push(relTest);
-    reqToTestsMap.set(reqId, existing);
-  }
-}
-function parseFeatureTags(content, relTest, reqToTestsMap) {
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith("@")) continue;
-    const tags = trimmed.split(/\s+/).filter((t) => t.startsWith("@"));
-    for (const t of tags) {
-      recordRequirementTest(reqToTestsMap, t.substring(1), relTest);
-    }
-  }
-}
-var REQ_ID_REGEX = /\b(FR|QR|CON|SEC-REQ)-[A-Z0-9]+(-[A-Z0-9]+)*\b/g;
-function parseCodeTestIds(content, relTest, reqToTestsMap) {
-  const idMatches = content.match(REQ_ID_REGEX);
-  if (!idMatches) return;
-  for (const reqId of idMatches) {
-    recordRequirementTest(reqToTestsMap, reqId, relTest);
-  }
-}
-function processTestFile(fullPath, rootDir, reqToTestsMap) {
-  try {
-    const content = fs6__namespace.readFileSync(fullPath, "utf-8");
-    const relTest = path5__namespace.relative(rootDir, fullPath).replace(/\\/g, "/");
-    if (fullPath.endsWith(".feature")) {
-      parseFeatureTags(content, relTest, reqToTestsMap);
-    }
-    parseCodeTestIds(content, relTest, reqToTestsMap);
-  } catch {
-  }
-}
-function collectTestFiles(dir, files = []) {
-  if (!fs6__namespace.existsSync(dir)) return files;
-  try {
-    const entries = fs6__namespace.readdirSync(dir, { withFileTypes: true });
-    for (const e of entries) {
-      if (e.isDirectory()) {
-        if (!EXCLUDED_TEST_DIRS.has(e.name)) {
-          collectTestFiles(path5__namespace.join(dir, e.name), files);
-        }
-      } else if (isTestFile(e.name)) {
-        files.push(path5__namespace.join(dir, e.name));
-      }
-    }
-  } catch {
-  }
-  return files;
-}
-function scanAllTestArtifacts(rootDir) {
-  const reqToTestsMap = /* @__PURE__ */ new Map();
-  const testFiles = collectTestFiles(rootDir);
-  for (const file of testFiles) {
-    processTestFile(file, rootDir, reqToTestsMap);
-  }
-  return reqToTestsMap;
-}
-var REQ_PREFIXES = ["FR-", "QR-", "CON-", "SEC-REQ-"];
-function isRequirementArtifact(frontmatter, id) {
-  if (frontmatter.type === "requirement" || frontmatter.type === "security-requirement") {
-    return true;
-  }
-  return REQ_PREFIXES.some((prefix) => id.startsWith(prefix));
-}
-function resolveRequirementMethod(declaredMethod, matchingTests) {
-  if (typeof declaredMethod === "string" && declaredMethod) {
-    return declaredMethod;
-  }
-  return matchingTests.some((t) => t.endsWith(".feature")) ? "BDD_CUCUMBER" : "TEST_EXECUTION";
-}
-function auditRequirement(frontmatter, id, relPath, isTemplate, reqToTestsMap) {
-  const matchingTests = reqToTestsMap.get(id) || [];
-  const isVerified = isTemplate || matchingTests.length > 0;
-  const method = resolveRequirementMethod(frontmatter["verifiable-by"], matchingTests);
-  return {
-    item: {
-      id: id || "SIN-ID",
-      title: frontmatter.title || "Sin t\xEDtulo",
-      file: relPath,
-      isTemplate,
-      method,
-      testRefs: matchingTests.join(", ") || "NINGUNA DETECTADA",
-      existingCount: matchingTests.length,
-      status: isVerified ? "VERIFICADO_CON_PRUEBA" : "FALLO_SIN_PRUEBA"
-    },
-    isError: !isVerified
-  };
-}
-function isTaskProofValid(criteria, isTemplate) {
-  if (isTemplate) return true;
-  return criteria.length > 4 && !criteria.includes("TODO") && !criteria.includes("TBD");
-}
-function auditSingleTask(t, relPath, isTemplate) {
-  const crit = t.verification?.criteria || "";
-  const method = t.verification?.method || "TEST_EXECUTION";
-  const hasProof = isTaskProofValid(crit, isTemplate);
-  return {
-    item: {
-      id: t.id,
-      title: t.title || "Sin t\xEDtulo",
-      file: relPath,
-      method,
-      commandOrCriteria: crit || "AUSENTE",
-      status: hasProof ? "VERIFICADO_CON_PRUEBA" : "FALLO_SIN_PRUEBA"
-    },
-    hasProof
-  };
-}
-function auditTasks(tasks, relPath, isTemplate) {
-  if (!Array.isArray(tasks) || tasks.length === 0) {
-    return { items: [], errorCount: 0 };
-  }
-  const items = [];
-  let errorCount = 0;
-  for (const t of tasks) {
-    const { item, hasProof } = auditSingleTask(t, relPath, isTemplate);
-    if (!hasProof) errorCount++;
-    items.push(item);
-  }
-  return { items, errorCount };
-}
-function assembleCoverageResult(reqAudit, taskAudit, reqErrors, taskErrors) {
-  return {
-    success: reqErrors === 0 && taskErrors === 0,
-    totalRequirements: reqAudit.length,
-    passedRequirements: reqAudit.length - reqErrors,
-    failedRequirements: reqErrors,
-    totalTasks: taskAudit.length,
-    passedTasks: taskAudit.length - taskErrors,
-    failedTasks: taskErrors,
-    requirements: reqAudit,
-    tasks: taskAudit,
-    reportMarkdown: generateTestingCoverageReportMarkdown(reqAudit, taskAudit, reqErrors, taskErrors)
-  };
-}
-function verifyTestingCoverage(options = {}) {
-  const rootDir = options.rootDir || process.cwd();
-  const allMdFiles = walkMdFiles(rootDir);
-  const reqToTestsMap = scanAllTestArtifacts(rootDir);
-  const reqAudit = [];
-  const taskAudit = [];
-  let reqErrors = 0;
-  let taskErrors = 0;
-  for (const file of allMdFiles) {
-    try {
-      const content = fs6__namespace.readFileSync(file, "utf-8");
-      const { frontmatter } = parseGenericDoc(content);
-      const relPath = path5__namespace.relative(rootDir, file).replace(/\\/g, "/");
-      const isTemplate = relPath.includes("templates/");
-      const id = frontmatter.id || "";
-      if (isRequirementArtifact(frontmatter, id)) {
-        const auditedReq = auditRequirement(frontmatter, id, relPath, isTemplate, reqToTestsMap);
-        reqAudit.push(auditedReq.item);
-        if (auditedReq.isError) reqErrors++;
-      }
-      const auditedTasks = auditTasks(frontmatter.tasks, relPath, isTemplate);
-      taskAudit.push(...auditedTasks.items);
-      taskErrors += auditedTasks.errorCount;
-    } catch {
-    }
-  }
-  return assembleCoverageResult(reqAudit, taskAudit, reqErrors, taskErrors);
+  return assembleGovernanceResult(data, reportMarkdown);
 }
 function isToolAvailable(toolName) {
   try {
@@ -4603,8 +5060,8 @@ function findLicenseFile(pkgDir) {
     "license.txt"
   ];
   for (const c of candidates) {
-    const full = path5__namespace.join(pkgDir, c);
-    if (fs6__namespace.existsSync(full)) {
+    const full = path4__namespace.join(pkgDir, c);
+    if (fs7__namespace.existsSync(full)) {
       return full;
     }
   }
@@ -4621,9 +5078,9 @@ var LICENSE_FILE_PATTERNS = [
   [(t) => t.includes("Microsoft Reciprocal License") || t.includes("MS-RL"), "MS-RL"]
 ];
 function resolveLicenseFromFile(licenseFilePath) {
-  if (!licenseFilePath || !fs6__namespace.existsSync(licenseFilePath)) return void 0;
+  if (!licenseFilePath || !fs7__namespace.existsSync(licenseFilePath)) return void 0;
   try {
-    const text = fs6__namespace.readFileSync(licenseFilePath, "utf-8");
+    const text = fs7__namespace.readFileSync(licenseFilePath, "utf-8");
     for (const [matches, spdx] of LICENSE_FILE_PATTERNS) {
       if (matches(text)) return spdx;
     }
@@ -4632,16 +5089,16 @@ function resolveLicenseFromFile(licenseFilePath) {
   return void 0;
 }
 function readPackageJson(filePath) {
-  if (!fs6__namespace.existsSync(filePath)) return null;
+  if (!fs7__namespace.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs6__namespace.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs7__namespace.readFileSync(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function extractDirectDepNames(rootDir, productionOnly) {
   const names = /* @__PURE__ */ new Set();
-  const pkgPath = path5__namespace.join(rootDir, "package.json");
+  const pkgPath = path4__namespace.join(rootDir, "package.json");
   const pkg = readPackageJson(pkgPath);
   if (!pkg) return names;
   if (pkg.dependencies && typeof pkg.dependencies === "object") {
@@ -4661,7 +5118,7 @@ function resolveSpdxForPackage(pkg, licFile) {
   return spdx;
 }
 function processPackageDir(pkgDir, directNames, seen) {
-  const pkg = readPackageJson(path5__namespace.join(pkgDir, "package.json"));
+  const pkg = readPackageJson(path4__namespace.join(pkgDir, "package.json"));
   if (!pkg?.name || !pkg.version) return;
   const key = `${pkg.name}@${pkg.version}`;
   if (seen.has(key)) return;
@@ -4682,32 +5139,32 @@ function processPackageDir(pkgDir, directNames, seen) {
   });
 }
 function scanScopeSubdirectory(scopeDir, directNames, seen) {
-  const scopedEntries = fs6__namespace.readdirSync(scopeDir, { withFileTypes: true });
+  const scopedEntries = fs7__namespace.readdirSync(scopeDir, { withFileTypes: true });
   for (const scoped of scopedEntries) {
     if (scoped.isDirectory()) {
-      processPackageDir(path5__namespace.join(scopeDir, scoped.name), directNames, seen);
+      processPackageDir(path4__namespace.join(scopeDir, scoped.name), directNames, seen);
     }
   }
 }
 function scanSubdirectories(baseDir, directNames, seen) {
-  if (!fs6__namespace.existsSync(baseDir)) return;
-  const entries = fs6__namespace.readdirSync(baseDir, { withFileTypes: true });
+  if (!fs7__namespace.existsSync(baseDir)) return;
+  const entries = fs7__namespace.readdirSync(baseDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith("@")) {
-      scanScopeSubdirectory(path5__namespace.join(baseDir, entry.name), directNames, seen);
+      scanScopeSubdirectory(path4__namespace.join(baseDir, entry.name), directNames, seen);
     } else if (entry.name !== ".bin" && entry.name !== ".pnpm") {
-      processPackageDir(path5__namespace.join(baseDir, entry.name), directNames, seen);
+      processPackageDir(path4__namespace.join(baseDir, entry.name), directNames, seen);
     }
   }
 }
 function scanPnpmStore(pnpmDir, directNames, seen) {
-  if (!fs6__namespace.existsSync(pnpmDir)) return;
-  const entries = fs6__namespace.readdirSync(pnpmDir, { withFileTypes: true });
+  if (!fs7__namespace.existsSync(pnpmDir)) return;
+  const entries = fs7__namespace.readdirSync(pnpmDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const candidateModules = path5__namespace.join(pnpmDir, entry.name, "node_modules");
-    if (fs6__namespace.existsSync(candidateModules)) {
+    const candidateModules = path4__namespace.join(pnpmDir, entry.name, "node_modules");
+    if (fs7__namespace.existsSync(candidateModules)) {
       scanSubdirectories(candidateModules, directNames, seen);
     }
   }
@@ -4715,11 +5172,11 @@ function scanPnpmStore(pnpmDir, directNames, seen) {
 function scanWithNativeFs(rootDir, options = {}) {
   const directNames = extractDirectDepNames(rootDir, options.productionOnly);
   const seen = /* @__PURE__ */ new Map();
-  const nmDir = path5__namespace.join(rootDir, "node_modules");
-  if (fs6__namespace.existsSync(nmDir)) {
+  const nmDir = path4__namespace.join(rootDir, "node_modules");
+  if (fs7__namespace.existsSync(nmDir)) {
     scanSubdirectories(nmDir, directNames, seen);
     if (options.depth !== "direct") {
-      scanPnpmStore(path5__namespace.join(nmDir, ".pnpm"), directNames, seen);
+      scanPnpmStore(path4__namespace.join(nmDir, ".pnpm"), directNames, seen);
     }
   }
   const allDeps = Array.from(seen.values());
@@ -4843,10 +5300,10 @@ function generateCycloneDxSbom(dependencies, options = {}) {
   let name = options.projectName || "ai-sdlc-project";
   let version = options.projectVersion || "1.0.0";
   if (options.rootDir) {
-    const pkgPath = path5__namespace.join(options.rootDir, "package.json");
-    if (fs6__namespace.existsSync(pkgPath)) {
+    const pkgPath = path4__namespace.join(options.rootDir, "package.json");
+    if (fs7__namespace.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs6__namespace.readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(fs7__namespace.readFileSync(pkgPath, "utf-8"));
         if (pkg.name) name = pkg.name;
         if (pkg.version) version = pkg.version;
       } catch {
@@ -4880,15 +5337,15 @@ function generateCycloneDxSbom(dependencies, options = {}) {
 function tryAtomicWrite(filePath, content) {
   const tempPath = `${filePath}.${process.pid}.${Math.random().toString(36).substring(2)}.tmp`;
   try {
-    fs6__namespace.writeFileSync(tempPath, content, "utf-8");
+    fs7__namespace.writeFileSync(tempPath, content, "utf-8");
     try {
-      if (fs6__namespace.existsSync(filePath)) {
-        fs6__namespace.rmSync(filePath, { force: true });
+      if (fs7__namespace.existsSync(filePath)) {
+        fs7__namespace.rmSync(filePath, { force: true });
       }
-      fs6__namespace.renameSync(tempPath, filePath);
+      fs7__namespace.renameSync(tempPath, filePath);
     } catch {
-      fs6__namespace.copyFileSync(tempPath, filePath);
-      fs6__namespace.unlinkSync(tempPath);
+      fs7__namespace.copyFileSync(tempPath, filePath);
+      fs7__namespace.unlinkSync(tempPath);
     }
     return true;
   } catch {
@@ -4896,15 +5353,15 @@ function tryAtomicWrite(filePath, content) {
   }
 }
 function safeWriteFileSync(filePath, content) {
-  const dir = path5__namespace.dirname(filePath);
-  if (!fs6__namespace.existsSync(dir)) {
-    fs6__namespace.mkdirSync(dir, { recursive: true });
+  const dir = path4__namespace.dirname(filePath);
+  if (!fs7__namespace.existsSync(dir)) {
+    fs7__namespace.mkdirSync(dir, { recursive: true });
   }
   for (let attempt = 0; attempt < 10; attempt++) {
     if (tryAtomicWrite(filePath, content)) return;
   }
   try {
-    fs6__namespace.writeFileSync(filePath, content, "utf-8");
+    fs7__namespace.writeFileSync(filePath, content, "utf-8");
   } catch {
   }
 }
@@ -4930,9 +5387,9 @@ function buildThirdPartyHeader(projectName, count) {
   ];
 }
 function readLicenseTextPreview(licenseFile) {
-  if (!licenseFile || !fs6__namespace.existsSync(licenseFile)) return null;
+  if (!licenseFile || !fs7__namespace.existsSync(licenseFile)) return null;
   try {
-    const text = fs6__namespace.readFileSync(licenseFile, "utf-8").trim();
+    const text = fs7__namespace.readFileSync(licenseFile, "utf-8").trim();
     return text.slice(0, 1e3) + (text.length > 1e3 ? "\n... (texto truncado)" : "");
   } catch {
     return null;
@@ -5044,7 +5501,7 @@ function parseExceptions(exceptions) {
 }
 function parseLicensePolicy(content) {
   try {
-    const doc = yaml2__default.default.load(content);
+    const doc = yaml3__default.default.load(content);
     const { permitted, restricted, blocked } = classifyCategories(doc?.categories);
     const exception_packages = parseExceptions(doc?.exceptions);
     return {
@@ -5180,9 +5637,9 @@ function generateLicenseReportMarkdown(dependencies, violations, policy, sbomPat
   return lines.filter(Boolean).join("\n");
 }
 function parseManifestItems(manifestFile) {
-  if (!fs6__namespace.existsSync(manifestFile)) return [];
+  if (!fs7__namespace.existsSync(manifestFile)) return [];
   try {
-    const doc = yaml2__default.default.load(fs6__namespace.readFileSync(manifestFile, "utf-8"));
+    const doc = yaml3__default.default.load(fs7__namespace.readFileSync(manifestFile, "utf-8"));
     return Array.isArray(doc?.evaluated_dependencies) ? doc.evaluated_dependencies : [];
   } catch {
     return [];
@@ -5214,10 +5671,10 @@ function verifyStaticManifest(manifestFile, policy) {
 function resolveManifestPath(rootDir, customPath) {
   if (customPath) return customPath;
   const candidates = [
-    path5__namespace.join(rootDir, "compliance", "license-manifest.yaml"),
-    path5__namespace.join(rootDir, "license-manifest.yaml")
+    path4__namespace.join(rootDir, "compliance", "license-manifest.yaml"),
+    path4__namespace.join(rootDir, "license-manifest.yaml")
   ];
-  return candidates.find((p) => fs6__namespace.existsSync(p)) || candidates[0];
+  return candidates.find((p) => fs7__namespace.existsSync(p)) || candidates[0];
 }
 function handleStaticManifestVerification(options, rootDir, policy) {
   const manifestFile = resolveManifestPath(rootDir, options.manifestPath);
@@ -5238,7 +5695,7 @@ function shouldGenerateSbom(options, rawPolicy) {
 }
 function maybeGenerateSbom(options, rootDir, rawPolicy, dependencies) {
   if (!shouldGenerateSbom(options, rawPolicy)) return void 0;
-  const sbomPath = options.sbomPath || path5__namespace.join(rootDir, "reports", "sbom.cdx.json");
+  const sbomPath = options.sbomPath || path4__namespace.join(rootDir, "reports", "sbom.cdx.json");
   const sbom = generateCycloneDxSbom(dependencies, { rootDir });
   writeCycloneDxSbom(sbom, sbomPath);
   return sbomPath;
@@ -5247,7 +5704,7 @@ function maybeGenerateNotices(options, rootDir, rawPolicy, dependencies) {
   const shouldGen = options.generateNotices === true || Boolean(options.noticesPath || rawPolicy?.ci_gates?.output_notices_file);
   if (!shouldGen) return void 0;
   const noticesFileName = rawPolicy?.ci_gates?.output_notices_file || "THIRD_PARTY_NOTICES.md";
-  const noticesPath = options.noticesPath || path5__namespace.join(rootDir, noticesFileName);
+  const noticesPath = options.noticesPath || path4__namespace.join(rootDir, noticesFileName);
   const noticesContent = generateThirdPartyNotices(dependencies);
   writeThirdPartyNotices(noticesContent, noticesPath);
   return noticesPath;
@@ -5259,8 +5716,8 @@ function handleDynamicScaArtifacts(options, rootDir, rawPolicy, dependencies) {
   };
 }
 function loadLicensePolicy(rootDir, customPath) {
-  const policyFile = customPath || path5__namespace.join(rootDir, "license-policy.yaml");
-  return fs6__namespace.existsSync(policyFile) ? parseLicensePolicy(fs6__namespace.readFileSync(policyFile, "utf-8")) : parseLicensePolicy("");
+  const policyFile = customPath || path4__namespace.join(rootDir, "license-policy.yaml");
+  return fs7__namespace.existsSync(policyFile) ? parseLicensePolicy(fs7__namespace.readFileSync(policyFile, "utf-8")) : parseLicensePolicy("");
 }
 function evaluateDependencyList(dependencies, policy) {
   const violations = [];
@@ -5330,14 +5787,14 @@ var PROTECTED_BYPASS_PATTERNS = [
   /migrations?[\\/]/i
 ];
 function detectProfileFromChange(changeDir) {
-  if (!fs6__namespace.existsSync(changeDir)) return "standard";
-  const specFile = path5__namespace.join(changeDir, "spec.md");
-  if (fs6__namespace.existsSync(specFile)) {
+  if (!fs7__namespace.existsSync(changeDir)) return "standard";
+  const specFile = path4__namespace.join(changeDir, "spec.md");
+  if (fs7__namespace.existsSync(specFile)) {
     try {
-      const rawSpec = fs6__namespace.readFileSync(specFile, "utf-8").replace(/^\uFEFF/, "");
+      const rawSpec = fs7__namespace.readFileSync(specFile, "utf-8").replace(/^\uFEFF/, "");
       const match = rawSpec.match(/^---\r?\n([\s\S]*?)\r?\n---/);
       if (match) {
-        const parsedFm = yaml2__default.default.load(match[1]);
+        const parsedFm = yaml3__default.default.load(match[1]);
         if (parsedFm && parsedFm.profile && ["patch", "standard", "critical"].includes(String(parsedFm.profile))) {
           return parsedFm.profile;
         }
@@ -5352,17 +5809,17 @@ function isPathProtectedFromPatch(filePath) {
   return PROTECTED_BYPASS_PATTERNS.some((pattern) => pattern.test(normalized));
 }
 function resolveActiveChangeDir(rootDir) {
-  const activeRoot = path5__namespace.join(rootDir, "specs", "changes", "active");
-  if (!fs6__namespace.existsSync(activeRoot)) return void 0;
+  const activeRoot = path4__namespace.join(rootDir, "specs", "changes", "active");
+  if (!fs7__namespace.existsSync(activeRoot)) return void 0;
   try {
-    const dirs = fs6__namespace.readdirSync(activeRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path5__namespace.join(activeRoot, d.name));
+    const dirs = fs7__namespace.readdirSync(activeRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path4__namespace.join(activeRoot, d.name));
     return dirs.find((d) => detectProfileFromChange(d) === "patch") || dirs[0];
   } catch {
     return void 0;
   }
 }
 function detectGitDiffFiles(rootDir) {
-  if (!fs6__namespace.existsSync(path5__namespace.join(rootDir, ".git"))) return [];
+  if (!fs7__namespace.existsSync(path4__namespace.join(rootDir, ".git"))) return [];
   try {
     const tracked = child_process.execFileSync("git", ["diff", "--name-only", "HEAD"], {
       cwd: rootDir,
@@ -5385,19 +5842,19 @@ function resolveChangeDirectory(rootDir, options) {
   if (options.changeDir) return options.changeDir;
   if (options.changeId) {
     const candidates = [
-      path5__namespace.join(rootDir, "specs", options.changeId),
-      path5__namespace.join(rootDir, "specs", "changes", "active", options.changeId),
-      path5__namespace.join(rootDir, "examples", "specs", options.changeId),
-      path5__namespace.join(rootDir, "specs", "changes", "completed", options.changeId)
+      path4__namespace.join(rootDir, "specs", options.changeId),
+      path4__namespace.join(rootDir, "specs", "changes", "active", options.changeId),
+      path4__namespace.join(rootDir, "examples", "specs", options.changeId),
+      path4__namespace.join(rootDir, "specs", "changes", "completed", options.changeId)
     ];
-    return candidates.find((c) => fs6__namespace.existsSync(c));
+    return candidates.find((c) => fs7__namespace.existsSync(c));
   }
   return resolveActiveChangeDir(rootDir);
 }
 function collectPatchViolations(rootDir, modifiedFiles) {
   const violations = [];
   for (const rawFile of modifiedFiles) {
-    const relPath = path5__namespace.isAbsolute(rawFile) ? path5__namespace.relative(rootDir, rawFile) : rawFile;
+    const relPath = path4__namespace.isAbsolute(rawFile) ? path4__namespace.relative(rootDir, rawFile) : rawFile;
     if (isPathProtectedFromPatch(relPath)) {
       violations.push(
         `[ANTI-PATCH-BYPASS] File '${relPath}' is a protected path (security, schemas, architectural decisions, or master policies). Changes with 'patch' profile are strictly prohibited from modifying these paths. Must be reclassified to 'standard' or 'critical'.`
@@ -5463,7 +5920,7 @@ function parseMdFrontmatter(raw) {
     return { fm: {}, body: cleaned.trim() };
   }
   try {
-    const parsed = yaml2__default.default.load(match[1]);
+    const parsed = yaml3__default.default.load(match[1]);
     const fm = parsed && typeof parsed === "object" ? parsed : {};
     return { fm, body: cleaned.substring(match[0].length).trim() };
   } catch {
@@ -5503,13 +5960,13 @@ function extractManualMetadata(fm, id, manualType, relPath, body) {
 }
 function buildManualItem(rootDir, filePath) {
   try {
-    const raw = fs6__namespace.readFileSync(filePath, "utf-8");
+    const raw = fs7__namespace.readFileSync(filePath, "utf-8");
     const { fm, body } = parseMdFrontmatter(raw);
     const id = typeof fm.id === "string" ? fm.id.trim() : "";
     const rawType = typeof fm.type === "string" ? fm.type.trim() : "";
     const manualType = resolveManualType(id, rawType);
     if (!id || !manualType) return null;
-    const relPath = path5__namespace.relative(rootDir, filePath).replace(/\\/g, "/");
+    const relPath = path4__namespace.relative(rootDir, filePath).replace(/\\/g, "/");
     return extractManualMetadata(fm, id, manualType, relPath, body);
   } catch {
     return null;
@@ -5520,8 +5977,8 @@ function scanManualsInWorkspace(rootDir) {
   const seenIds = /* @__PURE__ */ new Set();
   const items = [];
   for (const relDir of manualDirs) {
-    const fullDir = path5__namespace.join(rootDir, relDir);
-    if (!fs6__namespace.existsSync(fullDir)) continue;
+    const fullDir = path4__namespace.join(rootDir, relDir);
+    if (!fs7__namespace.existsSync(fullDir)) continue;
     for (const file of walkMdFiles(fullDir)) {
       const item = buildManualItem(rootDir, file);
       if (item && !seenIds.has(item.id)) {
@@ -5544,10 +6001,10 @@ function classifyBaselineId(id, type, buckets) {
   }
 }
 function processBaselineFile(file, rootDir, buckets) {
-  const rel = path5__namespace.relative(rootDir, file).replace(/\\/g, "/");
+  const rel = path4__namespace.relative(rootDir, file).replace(/\\/g, "/");
   if (rel.includes("/changes/") || rel.startsWith("changes/")) return;
   try {
-    const { fm } = parseMdFrontmatter(fs6__namespace.readFileSync(file, "utf-8"));
+    const { fm } = parseMdFrontmatter(fs7__namespace.readFileSync(file, "utf-8"));
     const id = typeof fm.id === "string" ? fm.id.trim() : "";
     const status = typeof fm.status === "string" ? fm.status.trim().toLowerCase() : "active";
     if (!id || status === "retired" || status === "deprecated") return;
@@ -5568,8 +6025,8 @@ function collectBaselineTargets(rootDir) {
     enclaves: /* @__PURE__ */ new Set()
   };
   for (const dir of ["product", "architecture", "security", "specs"]) {
-    const fullDir = path5__namespace.join(rootDir, dir);
-    if (fs6__namespace.existsSync(fullDir)) {
+    const fullDir = path4__namespace.join(rootDir, dir);
+    if (fs7__namespace.existsSync(fullDir)) {
       scanDirectoryForBaseline(rootDir, fullDir, buckets);
     }
   }
@@ -5626,10 +6083,10 @@ function detectCurrentGitBranch(rootDir) {
   }
 }
 function resolveActiveChangeProfile(rootDir) {
-  const activeRoot = path5__namespace.join(rootDir, "specs", "changes", "active");
-  if (!fs6__namespace.existsSync(activeRoot)) return "standard";
+  const activeRoot = path4__namespace.join(rootDir, "specs", "changes", "active");
+  if (!fs7__namespace.existsSync(activeRoot)) return "standard";
   try {
-    const dirs = fs6__namespace.readdirSync(activeRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path5__namespace.join(activeRoot, d.name));
+    const dirs = fs7__namespace.readdirSync(activeRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path4__namespace.join(activeRoot, d.name));
     const profiles = dirs.map((d) => detectProfileFromChange(d));
     if (profiles.includes("critical")) return "critical";
     if (profiles.includes("patch") && profiles.length === 1) return "patch";
@@ -5813,7 +6270,7 @@ function extractParsedFrontmatter(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!match) return null;
   try {
-    const parsed = yaml2__default.default.load(match[1]);
+    const parsed = yaml3__default.default.load(match[1]);
     if (parsed && typeof parsed === "object") {
       const fm = parsed;
       if (fm.id && isRequirementArtifact2(fm)) {
@@ -5842,11 +6299,11 @@ function buildRequirementObject(content, fm, body, filePath, relFile) {
 }
 function parseRequirementFile(filePath, rootDir) {
   try {
-    const content = fs6__namespace.readFileSync(filePath, "utf-8");
+    const content = fs7__namespace.readFileSync(filePath, "utf-8");
     const extracted = extractParsedFrontmatter(content);
     if (!extracted) return null;
     const body = content.substring(extracted.matchLen);
-    const relFile = path5__namespace.relative(rootDir, filePath).replace(/\\/g, "/");
+    const relFile = path4__namespace.relative(rootDir, filePath).replace(/\\/g, "/");
     return buildRequirementObject(content, extracted.fm, body, filePath, relFile);
   } catch {
     return null;
@@ -5858,7 +6315,7 @@ function isIgnoredScanPath(relFile) {
 function collectRequirements(rootDir) {
   const reqs = [];
   for (const file of walkMdFiles(rootDir)) {
-    const relFile = path5__namespace.relative(rootDir, file).replace(/\\/g, "/");
+    const relFile = path4__namespace.relative(rootDir, file).replace(/\\/g, "/");
     if (isIgnoredScanPath(relFile)) continue;
     const req = parseRequirementFile(file, rootDir);
     if (req) reqs.push(req);
@@ -6217,10 +6674,10 @@ function isPathExcluded2(relPath, patterns) {
 function walkProjectFiles(dir, rootDir, excludedPatterns = DEFAULT_EXCLUDED_PATTERNS) {
   const results = [];
   try {
-    const entries = fs6__namespace.readdirSync(dir, { withFileTypes: true });
+    const entries = fs7__namespace.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path5__namespace.join(dir, entry.name);
-      const relPath = path5__namespace.relative(rootDir, fullPath).replace(/\\/g, "/");
+      const fullPath = path4__namespace.join(dir, entry.name);
+      const relPath = path4__namespace.relative(rootDir, fullPath).replace(/\\/g, "/");
       if (isPathExcluded2(relPath, excludedPatterns)) continue;
       if (entry.isDirectory()) {
         results.push(...walkProjectFiles(fullPath, rootDir, excludedPatterns));
@@ -6249,8 +6706,8 @@ function pickFirstString(...vals) {
 }
 function parseGitleaksItem(item, rootDir) {
   const rawFile = pickFirstString(item.File, item.file);
-  const filePath = path5__namespace.resolve(rootDir, rawFile);
-  const relPath = path5__namespace.relative(rootDir, filePath).replace(/\\/g, "/");
+  const filePath = path4__namespace.resolve(rootDir, rawFile);
+  const relPath = path4__namespace.relative(rootDir, filePath).replace(/\\/g, "/");
   const ruleId = pickFirstString(item.RuleID, item.ruleID) || "GITLEAKS-MATCH";
   const rawSecret = pickFirstString(item.Secret, item.secret, item.Match);
   const line = item.StartLine ?? item.line ?? 1;
@@ -6323,7 +6780,7 @@ function scanLineForSecrets(line, lineNumber, filePath, relPath, entropyThreshol
 function scanContentForSecrets(content, filePath, rootDir, entropyThreshold = 4.3) {
   const violations = [];
   const lines = content.split(/\r?\n/);
-  const relPath = path5__namespace.relative(rootDir, filePath).replace(/\\/g, "/");
+  const relPath = path4__namespace.relative(rootDir, filePath).replace(/\\/g, "/");
   for (let i = 0; i < lines.length; i++) {
     violations.push(...scanLineForSecrets(lines[i], i + 1, filePath, relPath, entropyThreshold));
   }
@@ -6343,7 +6800,7 @@ function scanDiffItems(diffLines, rootDir, excludePatterns, entropyThreshold) {
   const findings = [];
   for (const [relFile, items] of fileGroups) {
     if (isPathExcluded2(relFile, excludePatterns)) continue;
-    const absPath = path5__namespace.resolve(rootDir, relFile);
+    const absPath = path4__namespace.resolve(rootDir, relFile);
     for (const item of items) {
       const lineViolations = scanLineForSecrets(item.content, item.lineNumber, absPath, relFile, entropyThreshold);
       for (const v of lineViolations) {
@@ -6358,7 +6815,7 @@ function scanAllProjectFiles(rootDir, excludePatterns, entropyThreshold) {
   const findings = [];
   for (const file of allFiles) {
     try {
-      const content = fs6__namespace.readFileSync(file, "utf-8");
+      const content = fs7__namespace.readFileSync(file, "utf-8");
       findings.push(...scanContentForSecrets(content, file, rootDir, entropyThreshold));
     } catch {
     }
@@ -6582,8 +7039,8 @@ function runSemgrepCli(rootDir) {
       const parsed = JSON.parse(output);
       if (Array.isArray(parsed.results)) {
         for (const item of parsed.results) {
-          const filePath = path5__namespace.resolve(rootDir, item.path);
-          const relPath = path5__namespace.relative(rootDir, filePath).replace(/\\/g, "/");
+          const filePath = path4__namespace.resolve(rootDir, item.path);
+          const relPath = path4__namespace.relative(rootDir, filePath).replace(/\\/g, "/");
           violations.push({
             filePath,
             relPath,
@@ -6610,15 +7067,15 @@ function isSastExcluded(relPath, excludes) {
 function walkSourceFiles(dir, rootDir, excludes = DEFAULT_SAST_EXCLUDES) {
   const files = [];
   try {
-    const entries = fs6__namespace.readdirSync(dir, { withFileTypes: true });
+    const entries = fs7__namespace.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path5__namespace.join(dir, entry.name);
-      const relPath = path5__namespace.relative(rootDir, fullPath).replace(/\\/g, "/");
+      const fullPath = path4__namespace.join(dir, entry.name);
+      const relPath = path4__namespace.relative(rootDir, fullPath).replace(/\\/g, "/");
       if (isSastExcluded(relPath, excludes)) continue;
       if (entry.isDirectory()) {
         files.push(...walkSourceFiles(fullPath, rootDir, excludes));
       } else if (entry.isFile()) {
-        const ext = path5__namespace.extname(entry.name).toLowerCase();
+        const ext = path4__namespace.extname(entry.name).toLowerCase();
         if (GENERAL_SOURCE_EXTENSIONS.includes(ext)) {
           files.push(fullPath);
         }
@@ -6639,11 +7096,11 @@ function checkRuleMatch(rule, line, ext, minSeverity) {
 }
 function scanFileForSast(filePath, rootDir, minSeverity = "HIGH") {
   const violations = [];
-  const ext = path5__namespace.extname(filePath).toLowerCase();
+  const ext = path4__namespace.extname(filePath).toLowerCase();
   try {
-    const content = fs6__namespace.readFileSync(filePath, "utf-8");
+    const content = fs7__namespace.readFileSync(filePath, "utf-8");
     const lines = content.split(/\r?\n/);
-    const relPath = path5__namespace.relative(rootDir, filePath).replace(/\\/g, "/");
+    const relPath = path4__namespace.relative(rootDir, filePath).replace(/\\/g, "/");
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
       if (isLineExemptFromSast(line)) continue;
@@ -6669,8 +7126,8 @@ function scanFileForSast(filePath, rootDir, minSeverity = "HIGH") {
 function collectSastFiles(rootDir, targetDirs) {
   const files = [];
   for (const tDir of targetDirs) {
-    const fullDir = path5__namespace.join(rootDir, tDir);
-    if (fs6__namespace.existsSync(fullDir)) {
+    const fullDir = path4__namespace.join(rootDir, tDir);
+    if (fs7__namespace.existsSync(fullDir)) {
       files.push(...walkSourceFiles(fullDir, rootDir));
     }
   }
@@ -6825,7 +7282,7 @@ function calculateRating(mi, cc) {
   return "F";
 }
 function detectLanguage(filePath) {
-  const ext = path5__namespace.extname(filePath).toLowerCase();
+  const ext = path4__namespace.extname(filePath).toLowerCase();
   switch (ext) {
     case ".ts":
       return "TypeScript";
@@ -6850,7 +7307,7 @@ function detectLanguage(filePath) {
 }
 function parseJsonSummaryFile(filePath, relSource) {
   try {
-    const raw = JSON.parse(fs6__namespace.readFileSync(filePath, "utf-8"));
+    const raw = JSON.parse(fs7__namespace.readFileSync(filePath, "utf-8"));
     const total = raw.total;
     if (!total || typeof total !== "object") return null;
     const linesPct = Number(total.lines?.pct);
@@ -6873,7 +7330,7 @@ function updateLcovCounts(line, counts) {
 }
 function parseLcovFile(filePath, relSource) {
   try {
-    const lines = fs6__namespace.readFileSync(filePath, "utf-8").split(/\r?\n/);
+    const lines = fs7__namespace.readFileSync(filePath, "utf-8").split(/\r?\n/);
     const counts = { LF: 0, LH: 0, BRF: 0, BRH: 0, FNF: 0, FNH: 0 };
     for (const line of lines) {
       updateLcovCounts(line, counts);
@@ -6893,16 +7350,16 @@ function parseLcovFile(filePath, relSource) {
 function readCodeCoverageSummary(rootDir = process.cwd()) {
   const jsonCandidates = ["coverage/coverage-summary.json", "reports/coverage-summary.json"];
   for (const rel of jsonCandidates) {
-    const full = path5__namespace.join(rootDir, rel);
-    if (fs6__namespace.existsSync(full)) {
+    const full = path4__namespace.join(rootDir, rel);
+    if (fs7__namespace.existsSync(full)) {
       const parsed = parseJsonSummaryFile(full, rel);
       if (parsed) return parsed;
     }
   }
   const lcovCandidates = ["coverage/lcov.info", "lcov.info", "reports/lcov.info"];
   for (const rel of lcovCandidates) {
-    const full = path5__namespace.join(rootDir, rel);
-    if (fs6__namespace.existsSync(full)) {
+    const full = path4__namespace.join(rootDir, rel);
+    if (fs7__namespace.existsSync(full)) {
       const parsed = parseLcovFile(full, rel);
       if (parsed) return parsed;
     }
@@ -7038,9 +7495,9 @@ function renderQualityReportMarkdown(gateResult, coverage, accumulated, averages
   return [...header, "", "---", "", ...table, "", "---", "", ...polyglot, ...violationsSection, "", EVALUATION_STANDARDS_MD].join("\n");
 }
 function writeQualityReportFile(rootDir, markdown) {
-  const reportsDir = path5__namespace.join(rootDir, "reports");
-  fs6__namespace.mkdirSync(reportsDir, { recursive: true });
-  fs6__namespace.writeFileSync(path5__namespace.join(reportsDir, "QUALITY_REPORT.md"), markdown, "utf-8");
+  const reportsDir = path4__namespace.join(rootDir, "reports");
+  fs7__namespace.mkdirSync(reportsDir, { recursive: true });
+  fs7__namespace.writeFileSync(path4__namespace.join(reportsDir, "QUALITY_REPORT.md"), markdown, "utf-8");
 }
 function generateQualityReport(options = {}) {
   const rootDir = options.rootDir || process.cwd();
@@ -7182,12 +7639,12 @@ Flujo de Integraci\xF3n (Merges):`,
   };
 }
 function resolveVersionFromProposal(changeDir) {
-  const proposalFile = path5__namespace.join(changeDir, "proposal.md");
-  if (!fs6__namespace.existsSync(proposalFile)) return "1.0.0";
-  const propContent = fs6__namespace.readFileSync(proposalFile, "utf-8");
+  const proposalFile = path4__namespace.join(changeDir, "proposal.md");
+  if (!fs7__namespace.existsSync(proposalFile)) return "1.0.0";
+  const propContent = fs7__namespace.readFileSync(proposalFile, "utf-8");
   const propFm = propContent.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!propFm) return "1.0.0";
-  const parsedProp = yaml2__default.default.load(propFm[1]);
+  const parsedProp = yaml3__default.default.load(propFm[1]);
   return parsedProp?.version ? String(parsedProp.version) : "1.0.0";
 }
 function resolveChangeVersion(fm, changeDir) {
@@ -7201,12 +7658,12 @@ function isTaskMatchingId(currentId, cleanTaskId) {
   return currentLower === targetLower || currentLower.startsWith(`${targetLower}-`) || targetLower.startsWith(`${currentLower}-`);
 }
 function parseTasksFrontmatter(tasksFile) {
-  if (!fs6__namespace.existsSync(tasksFile)) return null;
+  if (!fs7__namespace.existsSync(tasksFile)) return null;
   try {
-    const content = fs6__namespace.readFileSync(tasksFile, "utf-8");
+    const content = fs7__namespace.readFileSync(tasksFile, "utf-8");
     const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
     if (!fmMatch) return null;
-    const fm = yaml2__default.default.load(fmMatch[1]);
+    const fm = yaml3__default.default.load(fmMatch[1]);
     return fm && Array.isArray(fm.tasks) ? fm : null;
   } catch {
     return null;
@@ -7225,7 +7682,7 @@ function buildTaskMatch(currentId, currentTitle, rawChangeId, changeDir, version
   };
 }
 function inspectChangeTasks(changeDir, entryName, cleanTaskId, availableTasks) {
-  const fm = parseTasksFrontmatter(path5__namespace.join(changeDir, "tasks.md"));
+  const fm = parseTasksFrontmatter(path4__namespace.join(changeDir, "tasks.md"));
   if (!fm || !fm.tasks) return void 0;
   const rawChangeId = resolveRawChangeId(fm, entryName);
   const versionStr = resolveChangeVersion(fm, changeDir);
@@ -7246,16 +7703,16 @@ function locateTaskInActiveChanges(taskId, rootDir = process.cwd()) {
   if (!cleanTaskId) {
     return { found: false, error: "Debe especificar un identificador de tarea v\xE1lido (ej. TSK-001)." };
   }
-  const activeChangesDir = path5__namespace.join(rootDir, "specs", "changes", "active");
-  if (!fs6__namespace.existsSync(activeChangesDir)) {
+  const activeChangesDir = path4__namespace.join(rootDir, "specs", "changes", "active");
+  if (!fs7__namespace.existsSync(activeChangesDir)) {
     return { found: false, error: `No se encontr\xF3 el directorio de cambios activos en '${activeChangesDir}'.` };
   }
   const availableTasks = [];
-  const candidateDirs = fs6__namespace.readdirSync(activeChangesDir, { withFileTypes: true });
+  const candidateDirs = fs7__namespace.readdirSync(activeChangesDir, { withFileTypes: true });
   let matchedTask;
   for (const entry of candidateDirs) {
     if (!entry.isDirectory()) continue;
-    const changeDir = path5__namespace.join(activeChangesDir, entry.name);
+    const changeDir = path4__namespace.join(activeChangesDir, entry.name);
     const m = inspectChangeTasks(changeDir, entry.name, cleanTaskId, availableTasks);
     if (m && !matchedTask) {
       matchedTask = m;
@@ -7319,7 +7776,7 @@ function resolveBranchHierarchy(match, rootDir = process.cwd()) {
   const branches = getGitBranchList(rootDir);
   const cleanVersion = (match.version || "1.0.0").replace(/^v/, "");
   const releaseBranch = detectExistingReleaseBranch(branches, cleanVersion);
-  const dirName = path5__namespace.basename(match.changeDir);
+  const dirName = path4__namespace.basename(match.changeDir);
   const changeSlug = dirName.replace(/^(chg|CHG)-/i, (m) => m.toUpperCase());
   const featureBranch = detectExistingFeatureBranch(branches, dirName, match.changeId, changeSlug);
   const parentIdMatch = featureBranch.replace(/^(feat|feature)\//i, "").match(/^[a-zA-Z0-9]+-[a-zA-Z0-9]+/);
@@ -7626,13 +8083,13 @@ function getGitConfigValue(key, cwd) {
 }
 function readSessionTelemetry(cwd) {
   const possiblePaths = [
-    path5__namespace.join(cwd, ".ai-sdlc", "session-telemetry.json"),
-    path5__namespace.join(cwd, ".ai-sdlc", "agent-session.json")
+    path4__namespace.join(cwd, ".ai-sdlc", "session-telemetry.json"),
+    path4__namespace.join(cwd, ".ai-sdlc", "agent-session.json")
   ];
   for (const p of possiblePaths) {
-    if (fs6__namespace.existsSync(p)) {
+    if (fs7__namespace.existsSync(p)) {
       try {
-        const raw = fs6__namespace.readFileSync(p, "utf-8");
+        const raw = fs7__namespace.readFileSync(p, "utf-8");
         return JSON.parse(raw);
       } catch {
       }
@@ -7852,20 +8309,20 @@ if [ -f "$TELEMETRY_FILE" ]; then
 fi
 `;
 function installGitHooks(rootDir = process.cwd()) {
-  const gitDir = path5__namespace.join(rootDir, ".git");
-  if (!fs6__namespace.existsSync(gitDir)) {
+  const gitDir = path4__namespace.join(rootDir, ".git");
+  if (!fs7__namespace.existsSync(gitDir)) {
     return {
       success: false,
       error: `No se encontr\xF3 el directorio Git en '${gitDir}'.`
     };
   }
-  const hooksDir = path5__namespace.join(gitDir, "hooks");
-  if (!fs6__namespace.existsSync(hooksDir)) {
-    fs6__namespace.mkdirSync(hooksDir, { recursive: true });
+  const hooksDir = path4__namespace.join(gitDir, "hooks");
+  if (!fs7__namespace.existsSync(hooksDir)) {
+    fs7__namespace.mkdirSync(hooksDir, { recursive: true });
   }
-  const hookPath = path5__namespace.join(hooksDir, "prepare-commit-msg");
+  const hookPath = path4__namespace.join(hooksDir, "prepare-commit-msg");
   try {
-    fs6__namespace.writeFileSync(hookPath, PREPARE_COMMIT_MSG_SCRIPT, { encoding: "utf-8", mode: 493 });
+    fs7__namespace.writeFileSync(hookPath, PREPARE_COMMIT_MSG_SCRIPT, { encoding: "utf-8", mode: 493 });
     return {
       success: true,
       hookPath
@@ -8177,16 +8634,16 @@ function formatReleaseKpiMarkdown(report) {
   ].join("\n");
 }
 function writeReleaseKpiReport(report, options = {}) {
-  const root = options.outputDir || (options.rootDir ? path5__namespace.join(options.rootDir, "reports", "releases") : path5__namespace.join(process.cwd(), "reports", "releases"));
-  if (!fs6__namespace.existsSync(root)) {
-    fs6__namespace.mkdirSync(root, { recursive: true });
+  const root = options.outputDir || (options.rootDir ? path4__namespace.join(options.rootDir, "reports", "releases") : path4__namespace.join(process.cwd(), "reports", "releases"));
+  if (!fs7__namespace.existsSync(root)) {
+    fs7__namespace.mkdirSync(root, { recursive: true });
   }
   const cleanBranchName = report.releaseBranch.replace(/[^a-zA-Z0-9.-]/g, "_");
-  const mdPath = path5__namespace.join(root, `RELEASE_KPIS_${cleanBranchName}.md`);
-  const jsonPath = path5__namespace.join(root, `release_${cleanBranchName}.kpis.json`);
+  const mdPath = path4__namespace.join(root, `RELEASE_KPIS_${cleanBranchName}.md`);
+  const jsonPath = path4__namespace.join(root, `release_${cleanBranchName}.kpis.json`);
   const mdContent = formatReleaseKpiMarkdown(report);
-  fs6__namespace.writeFileSync(mdPath, mdContent, "utf-8");
-  fs6__namespace.writeFileSync(jsonPath, JSON.stringify(report, null, 2), "utf-8");
+  fs7__namespace.writeFileSync(mdPath, mdContent, "utf-8");
+  fs7__namespace.writeFileSync(jsonPath, JSON.stringify(report, null, 2), "utf-8");
   return { markdownPath: mdPath, jsonPath };
 }
 var cachedScript = null;
@@ -8195,19 +8652,19 @@ function resolveCytoscapePath() {
   try {
     const req = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
     const entryPath = req.resolve("cytoscape");
-    const dir = path5__namespace.dirname(entryPath);
-    const minPath = path5__namespace.join(dir, "cytoscape.min.js");
-    if (fs6__namespace.existsSync(minPath)) {
+    const dir = path4__namespace.dirname(entryPath);
+    const minPath = path4__namespace.join(dir, "cytoscape.min.js");
+    if (fs7__namespace.existsSync(minPath)) {
       return minPath;
     }
   } catch {
   }
   const searchDirs = [
-    path5__namespace.join(process.cwd(), "node_modules", "cytoscape", "dist", "cytoscape.min.js"),
-    path5__namespace.join(process.cwd(), "packages", "core", "node_modules", "cytoscape", "dist", "cytoscape.min.js")
+    path4__namespace.join(process.cwd(), "node_modules", "cytoscape", "dist", "cytoscape.min.js"),
+    path4__namespace.join(process.cwd(), "packages", "core", "node_modules", "cytoscape", "dist", "cytoscape.min.js")
   ];
   for (const candidate of searchDirs) {
-    if (fs6__namespace.existsSync(candidate)) {
+    if (fs7__namespace.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -8220,7 +8677,7 @@ function getCytoscapeScript() {
   const scriptPath = resolveCytoscapePath();
   if (scriptPath) {
     try {
-      cachedScript = fs6__namespace.readFileSync(scriptPath, "utf-8");
+      cachedScript = fs7__namespace.readFileSync(scriptPath, "utf-8");
       return cachedScript;
     } catch {
     }
@@ -8304,13 +8761,13 @@ function extractFrontmatter2(fileContent) {
   const match = fileContent.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!match) return null;
   try {
-    return yaml2__default.default.load(match[1]) || null;
+    return yaml3__default.default.load(match[1]) || null;
   } catch {
     return null;
   }
 }
 function toScannedArtifact(filePath, relPath) {
-  const fileContent = fs6__namespace.readFileSync(filePath, "utf-8");
+  const fileContent = fs7__namespace.readFileSync(filePath, "utf-8");
   const fm = extractFrontmatter2(fileContent);
   const id = typeof fm?.id === "string" ? fm.id.trim() : "";
   if (!id) return null;
@@ -8322,12 +8779,12 @@ function toScannedArtifact(filePath, relPath) {
   return { id, type: classified.type, title, layer: classified.layer, filePath: relPath, content, frontmatter: fm };
 }
 function parseAndCatalogArtifactFile(rootDir, filePath, scannedMap, archViewByBasename) {
-  const relPath = path5__namespace.relative(rootDir, filePath).replace(/\\/g, "/");
+  const relPath = path4__namespace.relative(rootDir, filePath).replace(/\\/g, "/");
   if (relPath.includes("/changes/") || relPath.startsWith("changes/")) return;
   const scannedArt = toScannedArtifact(filePath, relPath);
   if (!scannedArt) return;
   if (scannedArt.layer === "architecture" && scannedArt.type === "architecture") {
-    archViewByBasename.set(path5__namespace.basename(relPath), scannedArt);
+    archViewByBasename.set(path4__namespace.basename(relPath), scannedArt);
   } else {
     scannedMap.set(scannedArt.id, scannedArt);
   }
@@ -8337,8 +8794,8 @@ function scanWorkspaceArtifacts(rootDir) {
   const archViewByBasename = /* @__PURE__ */ new Map();
   const artifactDirs = ["product", "architecture", "specs", "security"];
   for (const dirName of artifactDirs) {
-    const fullDirPath = path5__namespace.join(rootDir, dirName);
-    if (fs6__namespace.existsSync(fullDirPath)) {
+    const fullDirPath = path4__namespace.join(rootDir, dirName);
+    if (fs7__namespace.existsSync(fullDirPath)) {
       for (const f of walkMdFiles(fullDirPath)) {
         parseAndCatalogArtifactFile(rootDir, f, scannedArtifactsMap, archViewByBasename);
       }
@@ -8396,9 +8853,9 @@ function addTraceArchEdges(r, status, archViewByBasename, nodeMap, addEdge) {
   }
 }
 function loadTestContentPreview(filePath) {
-  if (!fs6__namespace.existsSync(filePath)) return void 0;
+  if (!fs7__namespace.existsSync(filePath)) return void 0;
   try {
-    const testContent = fs6__namespace.readFileSync(filePath, "utf-8");
+    const testContent = fs7__namespace.readFileSync(filePath, "utf-8");
     const lang = filePath.endsWith(".feature") ? "gherkin" : "typescript";
     const preview = testContent.substring(0, 1500) + (testContent.length > 1500 ? "\n... (truncated)" : "");
     return "```" + lang + "\n" + preview + "\n```";
@@ -8408,10 +8865,10 @@ function loadTestContentPreview(filePath) {
 }
 function ensureTestNode(t, testId, rootDir, nodeMap) {
   if (nodeMap.has(testId)) return;
-  const fullTestPath = path5__namespace.isAbsolute(t) ? t : path5__namespace.join(rootDir, t);
+  const fullTestPath = path4__namespace.isAbsolute(t) ? t : path4__namespace.join(rootDir, t);
   nodeMap.set(testId, {
     id: testId,
-    label: path5__namespace.basename(t),
+    label: path4__namespace.basename(t),
     title: t,
     type: t.endsWith(".feature") ? "bdd-feature" : "code-test",
     layer: "test",
@@ -10446,9 +10903,9 @@ var IGNORED_SCAN_DIRS = /* @__PURE__ */ new Set([
   ".agent"
 ]);
 function readKpiFilesInDir(dir) {
-  if (!fs6__namespace.existsSync(dir)) return [];
+  if (!fs7__namespace.existsSync(dir)) return [];
   try {
-    return fs6__namespace.readdirSync(dir).filter((f) => f.endsWith(".kpis.json")).map((f) => path5__namespace.join(dir, f));
+    return fs7__namespace.readdirSync(dir).filter((f) => f.endsWith(".kpis.json")).map((f) => path4__namespace.join(dir, f));
   } catch {
     return [];
   }
@@ -10456,11 +10913,11 @@ function readKpiFilesInDir(dir) {
 function scanSubdirKpiFiles(dir, depth, acc) {
   if (depth > 4) return;
   try {
-    const entries = fs6__namespace.readdirSync(dir, { withFileTypes: true });
+    const entries = fs7__namespace.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || IGNORED_SCAN_DIRS.has(entry.name)) continue;
-      const sub = path5__namespace.join(dir, entry.name);
-      if (entry.name === "releases" && path5__namespace.basename(dir) === "reports") {
+      const sub = path4__namespace.join(dir, entry.name);
+      if (entry.name === "releases" && path4__namespace.basename(dir) === "reports") {
         acc.push(...readKpiFilesInDir(sub));
       } else {
         scanSubdirKpiFiles(sub, depth + 1, acc);
@@ -10470,7 +10927,7 @@ function scanSubdirKpiFiles(dir, depth, acc) {
   }
 }
 function findKpiJsonFiles(rootDir) {
-  const primaryFiles = readKpiFilesInDir(path5__namespace.join(rootDir, "reports", "releases"));
+  const primaryFiles = readKpiFilesInDir(path4__namespace.join(rootDir, "reports", "releases"));
   if (primaryFiles.length > 0) return primaryFiles;
   const found = [];
   scanSubdirKpiFiles(rootDir, 0, found);
@@ -10481,7 +10938,7 @@ function collectHistoricalKpis(rootDir) {
   const kpiFiles = findKpiJsonFiles(rootDir);
   for (const fullPath of kpiFiles) {
     try {
-      const content = fs6__namespace.readFileSync(fullPath, "utf-8");
+      const content = fs7__namespace.readFileSync(fullPath, "utf-8");
       const report = JSON.parse(content);
       if (!items.some((it) => it.id === report.releaseBranch && it.timestamp === report.generatedAt)) {
         items.push({
@@ -10678,15 +11135,15 @@ function computeGateAverages(gateResults) {
 }
 function generateDashboardReport(options = {}) {
   const rootDir = options.rootDir || process.cwd();
-  const outputPath = options.outputPath || path5__namespace.join(rootDir, "reports", "dashboard.html");
+  const outputPath = options.outputPath || path4__namespace.join(rootDir, "reports", "dashboard.html");
   const graphData = buildGraphElements(rootDir);
   const metricsData = collectDashboardMetrics(rootDir);
   const html = renderDashboardHtml(graphData, metricsData, options.title);
-  const outDir = path5__namespace.dirname(outputPath);
-  if (!fs6__namespace.existsSync(outDir)) {
-    fs6__namespace.mkdirSync(outDir, { recursive: true });
+  const outDir = path4__namespace.dirname(outputPath);
+  if (!fs7__namespace.existsSync(outDir)) {
+    fs7__namespace.mkdirSync(outDir, { recursive: true });
   }
-  fs6__namespace.writeFileSync(outputPath, html, "utf-8");
+  fs7__namespace.writeFileSync(outputPath, html, "utf-8");
   const { bddCoverageRatio, traceabilityRatio } = computeSummaryRatios(metricsData);
   const { avgMi, avgCc } = computeGateAverages(metricsData.gate.results);
   return {
@@ -10782,18 +11239,25 @@ var SPECIALIZED_AGENT_TEMPLATES = [
   {
     id: "agent-qa-engineer",
     title: "QA Engineer and SDET",
-    description: "Translate approved requirements (FR-*, SEC-REQ-*, QR-*) into comprehensive FAILING (red) BDD/Gherkin and unit test suites before production code is written.",
+    description: "Translate approved requirements (FR-*, SEC-REQ-*, QR-*) into comprehensive FAILING (red) BDD/Gherkin, End-to-End (E2E), UI, and unit test suites before production code is written.",
     globs: "tests/**, specs/changes/**/spec.md",
     body: `## Role & Mission
 - **Role**: QA Engineer and SDET (Software Development Engineer in Test) Agent (\`agent-qa-engineer\`).
-- **Mission**: Translate approved requirements (\`FR-*\`, \`SEC-REQ-*\`, \`QR-*\`) into comprehensive FAILING (red) BDD/Gherkin test suites before \`agent-developer\` writes a single line of production code.
+- **Mission**: Translate approved requirements (\`FR-*\`, \`SEC-REQ-*\`, \`QR-*\`) into comprehensive FAILING (red) BDD/Gherkin, End-to-End (E2E), UI, and unit test suites before \`agent-developer\` writes a single line of production code.
 
 ## Operational Directives & Guardrails
 - Read exclusively requirements cited in the \`handoff.yaml\` sidecar (\`HOF-*\`) and their referenced artifacts.
-- For each \`FR-*\` requirement, generate the three mandatory test categories:
-  1. **Nominal Case** (\`Scenario\`): happy path with valid inputs within expected boundaries.
-  2. **Boundary Cases** (\`Scenario Outline\` + \`Examples\` table): values at the extremes of the accepted range.
-  3. **Out-of-Range / Invalid Cases** (\`Scenario Outline\` + \`Examples\` table): null, empty, wrong types, values exceeding bounds.
+- **Agreed Project Technology**: Always use the testing frameworks, E2E/UI runners, and technology stack agreed upon for the project (as defined in \`ADR-*\`, \`design.md\`, \`package.json\`, or project configuration) if present, without requiring the user to specify it in the prompt.
+- **Mandatory End-to-End (E2E) & User Interface (UI) Testing**: Never forget or omit End-to-End (E2E) and User Interface (UI) tests. Automatically include E2E and UI test suites alongside BDD/integration tests whenever requirements involve user-facing flows or interfaces, so the user never has to remind you in the prompt.
+- **Per-Interactive-Element Exhaustive Testing**: Create specific tests for **every** UI element with which the user can interact (buttons, inputs, selects, forms, modals, links, toggles, tabs, etc.), explicitly evaluating for each element:
+  1. **Happy Path**: nominal user interaction with valid inputs producing the expected UI state/response.
+  2. **Sad Path**: error handling, invalid interactions, validation rejections, disabled/blocked states, and failure recovery.
+  3. **Boundary Values**: minimum/maximum lengths, numeric extremes, empty/whitespace inputs, edge selections, and rapid/repeated interactions.
+- For each \`FR-*\` requirement, generate the three mandatory test categories tagged with \`@nominal\`, \`@boundary\`, and \`@invalid\`:
+  1. **Nominal Case** (\`@nominal\` \`Scenario\`): happy path with valid inputs within expected boundaries.
+  2. **Boundary Cases** (\`@boundary\` \`Scenario Outline\` + \`Examples\` table): values at the extremes of the accepted range.
+  3. **Out-of-Range / Invalid Cases** (\`@invalid\` \`Scenario Outline\` + \`Examples\` table): null, empty, wrong types, values exceeding bounds.
+- **Use Case Variant Coverage**: Inspect every \`UC-*\` in \`handoff.yaml\` and generate BDD scenarios covering 100% of its \`alternative-flows\` and \`exception-flows\`.
 - Apply conditional categories when applicable: Security (\`@security @mitigation\`), Performance (\`@performance\`), Idempotency (\`@idempotence\`), Postconditions, and Interface Contracts.
 - **Zero-Mock Integration Rule**: When an \`FR-*\` spans UI and Backend, unit tests mocking \`fetch\`/HTTP in isolation are insufficient; include integration/contract or E2E test scenarios verifying real request/response wiring and UI state transitions (\`Loading\`, \`Empty\`, \`Error\`, \`Nominal\`).
 - Tag all scenarios with \`@<FR-ID> @automated @regression\`.
@@ -10810,9 +11274,21 @@ var SPECIALIZED_AGENT_TEMPLATES = [
 - **Role**: High-Precision Software Developer / Coder Agent (\`agent-developer\`).
 - **Mission**: Implement atomic tasks from SDD specifications (\`tasks.md\`) delivering clean, strictly typed, and tested code.
 
+## Mandatory 4-Step Implementation Order
+Execute every implementation task following this strict sequential order:
+1. **Clean Architecture Definition / Redefinition**: Define or refine the module/layer architecture adhering to Clean Architecture patterns (Domain/Entities, Application/Use Cases, Interface Adapters, Frameworks/Drivers), strictly enforcing the Dependency Rule (dependencies point inward toward the domain).
+2. **Inter-Module Interfaces First**: Define explicit interfaces/ports (contracts, DTOs, types) for all interactions across module boundaries before writing concrete logic, avoiding direct coupling between modules.
+3. **Component Implementation**: Implement the concrete components, use cases, and adapters that implement and consume the defined interfaces.
+4. **Exhaustive Per-Function Unit Testing**: Write unit tests for every function in \`tests/unit/\`, always verifying:
+   - **Happy Path**: nominal execution with valid inputs.
+   - **Sad Path**: controlled error paths, rejections, and business exceptions.
+   - **Boundary Values**: minimum, maximum, exact limits, and off-by-one edges.
+   - **Unexpected, Null & Empty Values**: \`null\`, \`undefined\`, empty strings/arrays/objects, and malformed inputs.
+
 ## Operational Directives & Guardrails
 - Respect the autonomy mode assigned to each task in \`tasks.md\` (\`AUTONOMOUS\`, \`HUMAN_REVIEW_PLAN\`, \`AMBIGUOUS\`, \`HIGH_RISK_MANUAL\`).
-- Apply Test-Driven Development (TDD): make failing tests delivered by \`agent-qa-engineer\` pass green without altering tests to accommodate buggy code.
+- **100% Design & Handoff Scope Coverage in Tasks**: Ensure every task in \`tasks.md\` declares \`implements-components\` (\`CMP-*\`), \`satisfies-requirements\` (\`FR-*\`, \`SEC-REQ-*\`), and \`implements-contracts\` so 100% of \`design.md\` and \`handoff.yaml\` is mapped and implemented.
+- Apply Test-Driven Development (TDD): make failing tests delivered by \`agent-qa-engineer\` pass green without altering tests to accommodate buggy code, and write direct unit tests in \`tests/unit/\` for every exported function and contract method declared in \`design.md\` or implemented in \`src/\`.
 - Cite implemented \`FR-*\` or \`SEC-REQ-*\` IDs in test header comments to maintain 360\xB0 reverse traceability.
 - **Zero Fake-Wiring Guardrail**: Strictly forbidden from marking a task \`COMPLETED\` with hardcoded \`mockData\` arrays in production views, \`setTimeout\` simulating network calls, or empty UI event handlers (\`onClick={() => {}}\`, \`onSubmit={() => {}}\`). Frontend components must wire directly to the shared contract and real Backend endpoints.
 - **Mandatory 4 UI States Matrix**: Every data-driven UI component or screen must explicitly implement all 4 usability states: \`Loading\` (spinner/skeleton + disabled submit), \`Empty\` (clear message + CTA), \`Error\` (visible error recovery banner, never silent failure), and \`Nominal/Success\` (accessible semantic DOM + keyboard navigation).
@@ -11006,11 +11482,14 @@ This file defines the operational rules and specialized role mappings for Google
   - Emit a return handoff to \`agent-threat-modeler\` in the technical security feedback loop when infrastructure or persistence decisions introduce new attack vectors.
 
 ### 4. \`agent-qa-engineer\` (QA Engineer and SDET)
-- **Mission**: Translate approved requirements (\`FR-*\`, \`SEC-REQ-*\`, \`QR-*\`) into comprehensive FAILING (red) BDD/Gherkin test suites, before \`agent-developer\` writes production code.
+- **Mission**: Translate approved requirements (\`FR-*\`, \`SEC-REQ-*\`, \`QR-*\`) into comprehensive FAILING (red) BDD/Gherkin, End-to-End (E2E), UI, and unit test suites, before \`agent-developer\` writes production code.
 - **Input**: Approved requirements from the \`handoff.yaml\` sidecar (\`HOF-*\`).
-- **Output**: Failing Gherkin scenarios covering: nominal case, boundary cases, out-of-range cases, and conditional categories (security, performance, idempotency, postconditions, interface contract).
+- **Output**: Failing Gherkin, E2E, and UI test suites covering: nominal case, boundary cases, out-of-range cases, per-interactive-element tests (Happy Path, Sad Path, Boundary Values), and conditional categories (security, performance, idempotency, postconditions, interface contract).
 - **Guardrails**:
   - FORBIDDEN to include production code or anticipate implementations.
+  - **Agreed Project Technology**: Always use the testing frameworks, E2E/UI runners, and technology stack agreed upon for the project (if any), without requiring the user to specify it in the prompt.
+  - **Mandatory E2E & UI Testing**: Never forget or omit End-to-End (E2E) and User Interface (UI) tests.
+  - **Per-Interactive-Element Coverage**: Create specific tests for every UI element the user can interact with, covering Happy Path, Sad Path, and Boundary Values for each one.
   - Every \`FR-*\` must have at least nominal + boundary + out-of-range scenarios; missing these blocks handoff to \`agent-developer\`.
   - Mandatory tags: \`@<FR-ID> @automated @regression\`.
   - Run \`pnpm run verify:testing\` before emitting handoff.
@@ -11018,6 +11497,7 @@ This file defines the operational rules and specialized role mappings for Google
 ### 5. \`agent-developer\` (Software Developer)
 - **Mission**: Implement atomic tasks from SDD specifications (\`tasks.md\`) with clean, strictly typed code and thorough tests.
 - **Directives**:
+  - **Mandatory 4-Step Implementation Order**: (1) Define/refine Clean Architecture layers & boundaries, (2) Define interfaces/ports for all inter-module interactions to avoid direct module coupling, (3) Implement components consuming/fulfilling those interfaces, (4) Write unit tests for every function covering Happy Path, Sad Path, Boundary Values, and Unexpected/Null/Empty values.
   - Respect the autonomy mode assigned in \`tasks.md\` (\`AUTONOMOUS\`, \`HUMAN_REVIEW_PLAN\`, \`AMBIGUOUS\`, \`HIGH_RISK_MANUAL\`).
   - Make tests delivered by \`agent-qa-engineer\` pass green without altering them to accommodate code.
   - Respect \`quality-policy.yaml\` thresholds: CC $\\le 10$, Cognitive $\\le 15$, MI $\\ge 50$, LOC $\\le 40$.
@@ -11116,7 +11596,7 @@ Before finalizing changes or proposing commits:
 | \`agent-product-analyst\` | Phase 0 NAF v4 Enterprise & Capability Vision (\`ARCH-INTRO-*\`, 3\u20135 question interview) + ProductShape artifacts (\`ACT-*\`, \`UC-*\`, \`FR-*\`, \`QR-*\`, \`BR-*\`); status starts \`draft\`. |
 | \`agent-threat-modeler\` | STRIDE/OWASP threat triad (\`ACT-THREAT-*\`, \`ABUSE-*\`, \`SEC-REQ-*\`). |
 | \`agent-system-architect\` | Modular arc42 + NAF v4 architecture (\`CMP-*\`, Mermaid diagrams, \`ADR-*\`). |
-| \`agent-qa-engineer\` | FAILING BDD/Gherkin suites before \`agent-developer\` writes code. |
+| \`agent-qa-engineer\` | FAILING BDD/Gherkin, E2E, and UI suites (using agreed project tech; Happy Path, Sad Path & Boundary Values per interactive UI element) before \`agent-developer\` writes code. |
 | \`agent-developer\` | Atomic tasks from \`tasks.md\`; respects autonomy mode; runs \`pnpm run check:fix\` + \`pnpm run verify:all\`. |
 | \`agent-security-auditor\` | Adversarial PR security audit, SAST, secrets, and CVSS v3.1 evaluation. |
 | \`agent-compliance-checker\` | SPDX license compliance audit against \`license-policy.yaml\`. |
@@ -11183,7 +11663,8 @@ Canonical Reference: [\`process/09_agent_protocols.md\`](process/09_agent_protoc
 - **Function Length**: $\\le 40$ lines (warning if $> 30$).
 - If a function exceeds these limits, decompose logic into cohesive helper functions before completing the task.
 
-## 2. TDD Methodology and Unit Testing
+## 2. TDD Methodology, Clean Architecture & Unit Testing
+- **Mandatory 4-Step Implementation Order**: (1) Define/refine Clean Architecture layers & boundaries, (2) Define interfaces/ports for all inter-module interactions to avoid direct module coupling, (3) Implement components consuming/fulfilling those interfaces, (4) Write unit tests for every function covering Happy Path, Sad Path, Boundary Values, and Unexpected/Null/Empty values.
 - Apply Test-Driven Development: generate unit tests before or alongside component logic.
 - Tag tests linked to requirements with header comments citing the ID (\`FR-*\` or \`SEC-REQ-*\`) to enable reverse traceability.
 - Suppressing types (\`any\`), linter rules (\`eslint-disable\`), or unit tests to force pipeline passage is prohibited.
@@ -11256,12 +11737,12 @@ npx tsx packages/cli/src/index.ts sdd integrate --change <chg-id>
 - **Guardrails**: Declare \`satisfies-requirements\` on every \`CMP-*\` and trigger the technical security feedback loop toward \`agent-threat-modeler\` when infrastructure decisions introduce new attack vectors.
 
 ### 4. \`agent-qa-engineer\` (QA Engineer and SDET)
-- **Mission**: Translate approved requirements (\`FR-*\`, \`SEC-REQ-*\`, \`QR-*\`) into comprehensive FAILING (red) BDD/Gherkin test suites, before \`agent-developer\` writes production code.
-- **Guardrails**: FORBIDDEN to include production code. Mandatory tags: \`@<FR-ID> @automated @regression\`.
+- **Mission**: Translate approved requirements (\`FR-*\`, \`SEC-REQ-*\`, \`QR-*\`) into comprehensive FAILING (red) BDD/Gherkin, End-to-End (E2E), UI, and unit test suites, before \`agent-developer\` writes production code.
+- **Guardrails**: Always use the agreed project technology/testing stack (if any). Never omit End-to-End (E2E) and UI tests. Create specific tests for every interactive UI element covering Happy Path, Sad Path, and Boundary Values. FORBIDDEN to include production code. Mandatory tags: \`@<FR-ID> @automated @regression\`.
 
 ### 5. \`agent-developer\` (Software Developer)
 - **Mission**: Implement atomic tasks from SDD specifications (\`tasks.md\`) with clean, strictly typed code and thorough tests.
-- **Directives**: Respect the autonomy mode. Make tests delivered by \`agent-qa-engineer\` pass green. Run \`pnpm run check:fix\` and \`pnpm run verify:all\`.
+- **Directives**: Execute the mandatory 4-step order: (1) Clean Architecture definition/redefinition, (2) Inter-module interfaces first, (3) Component implementation, (4) Per-function unit tests (Happy Path, Sad Path, Boundary Values, Unexpected/Null/Empty values). Respect the autonomy mode. Make tests delivered by \`agent-qa-engineer\` pass green. Run \`pnpm run check:fix\` and \`pnpm run verify:all\`.
 
 ### 6. \`agent-security-auditor\` (Adversarial Code Auditor)
 - **Mission**: Examine Pull Requests for business logic vulnerabilities, injection vectors, secret leaks, and authorization flaws as part of the Pre-Merge Audit Triad.
@@ -11406,7 +11887,7 @@ Non-Negotiable Quality Thresholds (\`quality-policy.yaml\`):
 | \`agent-product-analyst\` | Phase 0 NAF v4 Enterprise & Capability Vision (\`ARCH-INTRO-*\`, 3\u20135 question interview) + ProductShape artifacts (\`ACT-*\`, \`UC-*\`, \`FR-*\`, \`QR-*\`, \`BR-*\`); \`status\` starts \`draft\`. |
 | \`agent-threat-modeler\` | STRIDE/OWASP threat triad (\`ACT-THREAT-*\`, \`ABUSE-*\`, \`SEC-REQ-*\`). |
 | \`agent-system-architect\` | Modular arc42 + NAF v4 architecture (\`CMP-*\`, Mermaid diagrams, \`ADR-*\`). |
-| \`agent-qa-engineer\` | FAILING BDD/Gherkin suites before \`agent-developer\` writes production code. |
+| \`agent-qa-engineer\` | FAILING BDD/Gherkin, E2E, and UI suites (using agreed project tech; Happy Path, Sad Path & Boundary Values per interactive UI element) before \`agent-developer\` writes production code. |
 | \`agent-developer\` | Atomic tasks from \`tasks.md\`; autonomy mode must be respected; runs \`pnpm run check:fix\` + \`pnpm run verify:all\`. |
 | \`agent-security-auditor\` | Adversarial PR security audit, SAST, secrets, and CVSS v3.1 evaluation. |
 | \`agent-compliance-checker\` | SPDX license compliance audit against \`license-policy.yaml\`. |
@@ -12832,14 +13313,14 @@ function collectAgentFiles(targets) {
 function writeProjectFiles(destDir, files, dryRun) {
   const filesCreated = [];
   for (const f of files) {
-    const fullFilePath = path5__namespace.join(destDir, f.relPath);
-    const parentDir = path5__namespace.dirname(fullFilePath);
+    const fullFilePath = path4__namespace.join(destDir, f.relPath);
+    const parentDir = path4__namespace.dirname(fullFilePath);
     if (!dryRun) {
-      if (!fs6__namespace.existsSync(parentDir)) {
-        fs6__namespace.mkdirSync(parentDir, { recursive: true });
+      if (!fs7__namespace.existsSync(parentDir)) {
+        fs7__namespace.mkdirSync(parentDir, { recursive: true });
       }
-      if (!fs6__namespace.existsSync(fullFilePath)) {
-        fs6__namespace.writeFileSync(fullFilePath, f.content, "utf-8");
+      if (!fs7__namespace.existsSync(fullFilePath)) {
+        fs7__namespace.writeFileSync(fullFilePath, f.content, "utf-8");
         filesCreated.push(f.relPath);
       }
     } else {
@@ -12912,7 +13393,7 @@ function getCiWorkflowFiles(ciProvider) {
 function createDirectoriesOnDisk(destDir, directories, dryRun) {
   const created = [];
   for (const d of directories) {
-    if (!dryRun) fs6__namespace.mkdirSync(path5__namespace.join(destDir, d), { recursive: true });
+    if (!dryRun) fs7__namespace.mkdirSync(path4__namespace.join(destDir, d), { recursive: true });
     created.push(d);
   }
   return created;
@@ -12930,13 +13411,13 @@ function collectStarterFiles(ciProvider, agentFiles = [], archGranularity = "min
     ...getCiWorkflowFiles(ciProvider),
     ...agentFiles,
     ...getArchitectureTemplates(archGranularity).map((t) => ({
-      relPath: path5__namespace.join("templates", "architecture", t.filename).replace(/\\/g, "/"),
+      relPath: path4__namespace.join("templates", "architecture", t.filename).replace(/\\/g, "/"),
       content: t.content
     }))
   ];
 }
 function tryInstallGitHook(destDir, dryRun) {
-  if (!dryRun && fs6__namespace.existsSync(path5__namespace.join(destDir, ".git"))) {
+  if (!dryRun && fs7__namespace.existsSync(path4__namespace.join(destDir, ".git"))) {
     return installGitHooks(destDir).success;
   }
   return false;
@@ -12978,7 +13459,7 @@ function buildInitSuccessResult(destDir, directoriesCreated, filesCreated, ciPro
 }
 function initProject(options = {}) {
   const baseDir = options.rootDir || process.cwd();
-  const destDir = path5__namespace.resolve(baseDir, options.targetDir || ".");
+  const destDir = path4__namespace.resolve(baseDir, options.targetDir || ".");
   const ciRes = validateCiProvider(options.ci);
   if (!ciRes.valid) return buildInitError(destDir, ciRes.error);
   const archRes = validateArchitectureGranularity(options.architecture);
@@ -13058,6 +13539,7 @@ exports.VALID_CI_PROVIDERS = VALID_CI_PROVIDERS;
 exports.aggregateCommitKpiRecords = aggregateCommitKpiRecords;
 exports.aggregatePrKpis = aggregatePrKpis;
 exports.aggregateReleaseKpis = aggregateReleaseKpis;
+exports.analyzeBddVariantsForRequirement = analyzeBddVariantsForRequirement;
 exports.appendRevisionHistoryRow = appendRevisionHistoryRow;
 exports.buildCycloneDxComponent = buildCycloneDxComponent;
 exports.buildFeatureFileContent = buildFeatureFileContent;