zugzbot-sdd 1.5.0

package/tools/sdd_requirement_tracker.ts

@@ -0,0 +1,236 @@
+import { tool } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+
+export default tool({
+  description: "Rastreador Semántico de Requerimientos: Compara los criterios de aceptación en spec.md con las aserciones y títulos de prueba en tests/ para asegurar una cobertura del 100%.",
+  args: {
+    changeName: tool.schema.string().optional().describe("Nombre del cambio en kebab-case. Por defecto se autodetectará del sdd-lock.")
+  },
+  async execute(args, context) {
+    const projectRoot = context.worktree || context.directory;
+    let changeName = args.changeName;
+    let isManualQa = false;
+
+    // 1. Detectar cambio activo y verificar si hay QA manual configurado en el lockfile
+    const lockfilePath = path.join(projectRoot, ".openspec/sdd-lock.json");
+    const altLockPath = path.join(projectRoot, "openspec/sdd-lock.json");
+    const activeLockPath = fs.existsSync(lockfilePath) ? lockfilePath : (fs.existsSync(altLockPath) ? altLockPath : null);
+    if (activeLockPath) {
+      try {
+        const lockObj = JSON.parse(fs.readFileSync(activeLockPath, "utf-8"));
+        if (!changeName && lockObj.change_name && lockObj.change_name !== "nuevo-cambio") {
+          changeName = lockObj.change_name;
+        }
+        if (lockObj.qa_manual === true || lockObj.manual_qa === true) {
+          isManualQa = true;
+        }
+      } catch (e) {}
+    }
+
+    // Verificar si hay QA manual configurado en opencode.json
+    const opencodeJsonPath = path.join(projectRoot, "opencode.json");
+    if (fs.existsSync(opencodeJsonPath)) {
+      try {
+        const config = JSON.parse(fs.readFileSync(opencodeJsonPath, "utf-8"));
+        if (config.sdd?.qa_manual === true || config.sdd?.manual_qa === true) {
+          isManualQa = true;
+        }
+      } catch (e) {}
+    }
+
+    if (!changeName || changeName === "nuevo-cambio") {
+      return JSON.stringify({
+        status: "FAILED",
+        reason: "No se pudo resolver el nombre del cambio activo."
+      }, null, 2);
+    }
+
+    // 2. Leer spec.md
+    const specPath = path.join(projectRoot, ".openspec/changes", changeName, "specs/spec.md");
+    if (!fs.existsSync(specPath)) {
+      return JSON.stringify({
+        status: "FAILED",
+        reason: `No se encuentra spec.md en ${specPath}`
+      }, null, 2);
+    }
+
+    const specContent = fs.readFileSync(specPath, "utf-8");
+
+    // Autodetección de modo QA Manual explícito en spec.md
+    if (
+      specContent.includes("[QA Manual]") ||
+      specContent.includes("QA Mode: Manual") ||
+      specContent.includes("QA: Manual") ||
+      specContent.toLowerCase().includes("qa_manual: true")
+    ) {
+      isManualQa = true;
+    }
+
+    // 3. Extraer criterios de aceptación
+    const criteria: string[] = [];
+    let inCriteriaSection = false;
+
+    specContent.split("\n").forEach(line => {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("## 5. Criterios")) {
+        inCriteriaSection = true;
+        return;
+      }
+      if (inCriteriaSection && trimmed.startsWith("##")) {
+        inCriteriaSection = false;
+      }
+
+      if (inCriteriaSection && (trimmed.startsWith("- [ ]") || trimmed.startsWith("- [x]") || trimmed.startsWith("- [X]"))) {
+        // Extraer texto del criterio sin el prefijo del checkbox
+        const text = trimmed.substring(5).trim();
+        if (text) criteria.push(text);
+      }
+    });
+
+    if (criteria.length === 0) {
+      return JSON.stringify({
+        status: "WARNING",
+        criteriaCount: 0,
+        message: "⚠️ RASTREADOR SEMÁNTICO: No se encontraron criterios de aceptación con casillas '- [ ]' en la sección '## 5. Criterios de Aceptación' de tu spec.md."
+      }, null, 2);
+    }
+
+    if (isManualQa) {
+      return JSON.stringify({
+        status: "APPROVED",
+        criteriaCount: criteria.length,
+        message: `✅ VALIDACIÓN MANUAL (QA MANUAL) ACTIVA: Conforme al reglamento de AGENTS.md y la configuración del proyecto, se aprueba la transición sin requerir cobertura de pruebas automatizadas. Todos los ${criteria.length} criterios de aceptación deben validarse empíricamente en el entorno en caliente.`
+      }, null, 2);
+    }
+
+    // 4. Ubicar y leer archivos de prueba de forma recursiva y distribuida
+    const testFiles: string[] = [];
+    const excludeDirs = [
+      "node_modules", ".git", ".openspec", ".opencode", "dist",
+      "build", ".next", "coverage"
+    ];
+
+    function findTestFilesRecursive(dir: string) {
+      if (!fs.existsSync(dir)) return;
+      let entries: string[] = [];
+      try {
+        entries = fs.readdirSync(dir);
+      } catch (e) {
+        return;
+      }
+
+      entries.forEach(entry => {
+        const fullPath = path.join(dir, entry);
+        let stat;
+        try {
+          stat = fs.statSync(fullPath);
+        } catch (e) {
+          return;
+        }
+
+        if (stat.isDirectory()) {
+          if (!excludeDirs.includes(entry)) {
+            findTestFilesRecursive(fullPath);
+          }
+        } else {
+          const lowerFile = entry.toLowerCase();
+          const ext = path.extname(entry).toLowerCase();
+          const isTestFile = 
+            lowerFile.includes(".test.") || 
+            lowerFile.includes(".spec.") || 
+            lowerFile.startsWith("test_") || 
+            lowerFile.endsWith("_test.go") || 
+            (dir.split(path.sep).some(p => p === "tests" || p === "test") && [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs"].includes(ext));
+
+          if (isTestFile) {
+            testFiles.push(fullPath);
+          }
+        }
+      });
+    }
+
+    findTestFilesRecursive(projectRoot);
+
+    if (testFiles.length === 0) {
+      return JSON.stringify({
+        status: "APPROVED",
+        criteriaCount: criteria.length,
+        message: `⚠️ ADVERTENCIA SEMÁNTICA (FALLBACK MANUAL): No se detectaron archivos de prueba distribuidos en el repositorio. Consecuentemente, se asume un flujo de VALIDACIÓN MANUAL (QA Manual) de forma automática para evitar bloquear el ciclo SDD. Por favor, asegúrate de verificar los ${criteria.length} criterios de aceptación manualmente en el entorno en caliente.`
+      }, null, 2);
+    }
+
+    // 5. Comparar semánticamente los criterios con los tests
+    interface CriterionAudit {
+      criterio: string;
+      covered: boolean;
+      matchedInFile?: string;
+      matchingSnippet?: string;
+    }
+
+    const auditResults: CriterionAudit[] = [];
+
+    criteria.forEach(crit => {
+      // Extraer palabras clave de más de 3 letras ignorando conectores
+      const keywords = crit
+        .toLowerCase()
+        .replace(/[^a-záéíóúñü0-9\s]/g, "")
+        .split(/\s+/)
+        .filter(word => word.length > 3 && !["debe", "para", "como", "esta", "este", "consecuente"].includes(word));
+
+      let matched = false;
+      let matchedFile = "";
+      let matchedSnippet = "";
+
+      for (const testFile of testFiles) {
+        try {
+          const testContent = fs.readFileSync(testFile, "utf-8");
+          const testLines = testContent.split("\n");
+
+          // Búsqueda aproximada: comprobar si el test contiene palabras clave del criterio
+          for (let i = 0; i < testLines.length; i++) {
+            const line = testLines[i].toLowerCase();
+            // Si coincide con más del 60% de las palabras clave de un criterio en la misma línea
+            const matchCount = keywords.filter(keyword => line.includes(keyword)).length;
+            const threshold = Math.max(1, Math.floor(keywords.length * 0.5));
+
+            if (matchCount >= threshold && threshold > 0) {
+              matched = true;
+              matchedFile = path.basename(testFile);
+              matchedSnippet = `Línea ${i + 1}: ${testLines[i].trim()}`;
+              break;
+            }
+          }
+
+          if (matched) break;
+        } catch (e) {}
+      }
+
+      auditResults.push({
+        criterio: crit,
+        covered: matched,
+        matchedInFile: matchedFile || undefined,
+        matchingSnippet: matchedSnippet || undefined
+      });
+    });
+
+    const uncoveredCount = auditResults.filter(r => !r.covered).length;
+
+    if (uncoveredCount > 0) {
+      return JSON.stringify({
+        status: "FAILED",
+        criteriaCount: criteria.length,
+        uncoveredCount,
+        results: auditResults,
+        message: `❌ AUDITORÍA SEMÁNTICA FALLIDA: Se detectaron ${uncoveredCount} criterios de aceptación sin cobertura de pruebas en la suite de pruebas detectada:\n\n${auditResults.map(r => r.covered ? `  - [✓] "${r.criterio}" (Cubierto por ${r.matchedInFile})` : `  - [ ] "${r.criterio}" (⚠️ ¡SIN PRUEBA DE COBERTURA EN LA SUITE!)`).join("\n")}\n\nPor favor, pide a @sdd-builder que añada casos de prueba para cubrir estos criterios de QA.`
+      }, null, 2);
+    }
+
+    return JSON.stringify({
+      status: "APPROVED",
+      criteriaCount: criteria.length,
+      results: auditResults,
+      message: `✅ AUDITORÍA SEMÁNTICA EXITOSA: Todos los ${criteria.length} criterios de aceptación definidos en spec.md tienen cobertura de aserción correspondiente en la suite de pruebas.\n\n${auditResults.map(r => `  - [✓] "${r.criterio}" (Validado en ${r.matchedInFile})`).join("\n")}`
+    }, null, 2);
+  }
+})

package/tools/sdd_secret_scanner.ts

@@ -0,0 +1,205 @@
+import { tool } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+import { execSync } from "child_process"
+
+function decodeGitPath(gitPath: string): string {
+  let cleaned = gitPath.replace(/^"|"$/g, "");
+  
+  if (cleaned.includes("\\")) {
+    try {
+      const bytes: number[] = []
+      let i = 0
+      while (i < cleaned.length) {
+        if (cleaned[i] === "\\" && i + 3 < cleaned.length && /^[0-7]{3}$/.test(cleaned.substring(i + 1, i + 4))) {
+          const octalVal = cleaned.substring(i + 1, i + 4)
+          bytes.push(parseInt(octalVal, 8))
+          i += 4
+        } else {
+          if (cleaned[i] === "\\" && i + 1 < cleaned.length) {
+            const next = cleaned[i + 1]
+            if (next === "n") { bytes.push(10); i += 2 }
+            else if (next === "t") { bytes.push(9); i += 2 }
+            else if (next === "\\") { bytes.push(92); i += 2 }
+            else if (next === "\"") { bytes.push(34); i += 2 }
+            else { bytes.push(cleaned.charCodeAt(i)); i++ }
+          } else {
+            const code = cleaned.charCodeAt(i)
+            if (code < 128) {
+              bytes.push(code)
+            } else {
+              const buf = Buffer.from(cleaned[i], "utf-8")
+              for (let b = 0; b < buf.length; b++) {
+                bytes.push(buf[b])
+              }
+            }
+            i++
+          }
+        }
+      }
+      return Buffer.from(bytes).toString("utf-8")
+    } catch (e) {
+      return cleaned.replace(/\\([0-7]{3})/g, (match, octal) => {
+        return String.fromCharCode(parseInt(octal, 8))
+      })
+    }
+  }
+  return cleaned
+}
+
+function sanitizeGitPath(line: string): string {
+  const content = line.substring(3).trim()
+  if (content.includes(" -> ")) {
+    const parts = content.split(" -> ")
+    return decodeGitPath(parts[1])
+  }
+  return decodeGitPath(content)
+}
+
+export default tool({
+  description: "Escanea archivos modificados o listados en Git en busca de posibles fugas de secretos (tokens, llaves privadas, contraseñas en caliente) antes del commit de cierre de la Fase 3.",
+  args: {
+    scanAll: tool.schema.boolean().optional().default(false).describe("Si es true, escanea todos los archivos de código del proyecto; por defecto solo escanea archivos modificados en Git.")
+  },
+  async execute(args, context) {
+    const projectRoot = context.worktree || context.directory;
+    const findings: Array<{ file: string; line: number; type: string; snippet: string }> = [];
+
+    // 1. Obtener la lista de archivos a escanear
+    let filesToScan: string[] = [];
+
+    if (args.scanAll) {
+      // Escaneo recursivo simple excluyendo carpetas prohibidas
+      function scanDirRecursive(dir: string) {
+        if (!fs.existsSync(dir)) return;
+        const list = fs.readdirSync(dir);
+        list.forEach(file => {
+          const fullPath = path.join(dir, file);
+          let stat;
+          try {
+            stat = fs.statSync(fullPath);
+          } catch (e) {
+            return;
+          }
+          if (stat.isDirectory()) {
+            if (!["node_modules", ".git", ".openspec", ".opencode", "dist", "build", ".next", "coverage"].includes(file)) {
+              scanDirRecursive(fullPath);
+            }
+          } else {
+            const ext = path.extname(file).toLowerCase();
+            if ([".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".json", ".env"].includes(ext)) {
+              filesToScan.push(fullPath);
+            }
+          }
+        });
+      }
+      scanDirRecursive(projectRoot);
+    } else {
+      // Buscar solo archivos modificados o sin trackear usando Git de forma robusta
+      if (fs.existsSync(path.join(projectRoot, ".git"))) {
+        try {
+          const gitOutput = execSync("git status --porcelain", { cwd: projectRoot, encoding: "utf-8" });
+          gitOutput.split("\n").forEach(line => {
+            if (!line || line.length < 4) return;
+            const filePathRel = sanitizeGitPath(line);
+            const fullPath = path.join(projectRoot, filePathRel);
+            if (fs.existsSync(fullPath)) {
+              let stat;
+              try { stat = fs.statSync(fullPath) } catch (e) { return }
+              if (stat.isFile()) {
+                const ext = path.extname(fullPath).toLowerCase();
+                if ([".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".json", ".env"].includes(ext)) {
+                  filesToScan.push(fullPath);
+                }
+              }
+            }
+          });
+        } catch (e) {
+          return JSON.stringify({
+            status: "WARNING",
+            reason: "Git no disponible o error al consultar git status. Usa scanAll: true."
+          }, null, 2);
+        }
+      } else {
+        return JSON.stringify({
+          status: "WARNING",
+          reason: "No se detectó un repositorio de Git en la raíz del proyecto. Usa scanAll: true para escanear todo el proyecto."
+        }, null, 2);
+      }
+    }
+
+    if (filesToScan.length === 0) {
+      return JSON.stringify({
+        status: "APPROVED",
+        scannedCount: 0,
+        message: "✅ ESCANEO DE SEGURIDAD: No se encontraron archivos modificados para escanear."
+      }, null, 2);
+    }
+
+    // 2. Patrones de secretos de alta confianza
+    const secretRegexes = [
+      { type: "AWS Access Key ID", regex: /AKIA[0-9A-Z]{16}/ },
+      { type: "AWS Secret Access Key", regex: /[^A-Za-z0-9/+=][A-Za-z0-9/+=]{40}[^A-Za-z0-9/+=]/ },
+      { type: "Private Key", regex: /-----BEGIN (RSA|EC|PGP|OPENSSH)? PRIVATE KEY-----/i },
+      { type: "Slack Token", regex: /xox[bapr]-[0-9]{12}-[a-zA-Z0-9]{24}/ },
+      { type: "Stripe API Key", regex: /sk_live_[0-9a-zA-Z]{24}/ },
+      { type: "OpenAI API Key", regex: /sk-[a-zA-Z0-9]{48}/ },
+      { type: "Google API Key", regex: /AIzaSy[A-Za-z0-9_-]{35}/ },
+      { type: "Github Personal Access Token", regex: /ghp_[a-zA-Z0-9]{36}/ },
+      { type: "Generic High-Entropy Credential Assignment", regex: /(api_key|secret_key|client_secret|password|access_token|db_pass|auth_token)\s*[:=]\s*["'][a-zA-Z0-9_./-]{16,}["']/i }
+    ];
+
+    const ignoreFilter = (line: string): boolean => {
+      if (/process\.env/i.test(line)) return true;
+      if (/\{env:/i.test(line)) return true;
+      if (/\$env:/i.test(line)) return true;
+      if (/"Authorization"\s*:\s*["']Bearer /i.test(line) && line.includes("env")) return true;
+      return false;
+    };
+
+    // 3. Escaneo de archivos
+    filesToScan.forEach(file => {
+      try {
+        const content = fs.readFileSync(file, "utf-8");
+        const lines = content.split("\n");
+        lines.forEach((line, index) => {
+          if (ignoreFilter(line)) return;
+
+          secretRegexes.forEach(pattern => {
+            const match = line.match(pattern.regex);
+            if (match) {
+              const relPath = path.relative(projectRoot, file);
+              const matchedStr = match[0];
+              const redacted = matchedStr.length > 8 
+                ? matchedStr.substring(0, 4) + "..." + matchedStr.substring(matchedStr.length - 4)
+                : "****";
+              
+              findings.push({
+                file: relPath,
+                line: index + 1,
+                type: pattern.type,
+                snippet: line.trim().replace(matchedStr, redacted)
+              });
+            }
+          });
+        });
+      } catch (e) {}
+    });
+
+    if (findings.length > 0) {
+      return JSON.stringify({
+        status: "FAILED",
+        scannedCount: filesToScan.length,
+        findingsCount: findings.length,
+        findings,
+        message: `❌ ESCANEO DE SEGURIDAD FALLIDO: Se detectaron ${findings.length} posibles fugas de secretos en archivos modificados:\n\n${findings.map(f => `  - 📁 [${f.file} : Línea ${f.line}] - Tipo: ${f.type}\n    Línea: "${f.snippet}"`).join("\n\n")}\n\nPor favor, remueve estos secretos en caliente antes de archivar y realizar commits.`
+      }, null, 2);
+    }
+
+    return JSON.stringify({
+      status: "APPROVED",
+      scannedCount: filesToScan.length,
+      message: `✅ ESCANEO DE SEGURIDAD EXITOSO: Se escanearon ${filesToScan.length} archivos y no se detectaron credenciales ni secretos en caliente. ¡Estabilidad y cumplimiento impecables!`
+    }, null, 2);
+  }
+})

package/tools/sdd_spec_validator.ts

@@ -0,0 +1,139 @@
+import { tool } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+
+export default tool({
+  description: "Audita y valida el plano técnico (spec.md) del cambio de desarrollo activo para asegurar que cumpla con los estándares de calidad y secciones mandatorias de la metodología SDD.",
+  args: {
+    changeName: tool.schema.string().optional().describe("Nombre del cambio en kebab-case. Por defecto se autodetectará del sdd-lock.")
+  },
+  async execute(args, context) {
+    const projectRoot = context.worktree || context.directory;
+    let changeName = args.changeName;
+    let complexity = "high";
+
+    // 1. Detectar cambio activo y complejidad del sdd-lock si no se provee
+    const lockfilePath = path.join(projectRoot, ".openspec/sdd-lock.json");
+    const altLockPath = path.join(projectRoot, "openspec/sdd-lock.json");
+    const activeLockPath = fs.existsSync(lockfilePath) ? lockfilePath : (fs.existsSync(altLockPath) ? altLockPath : null);
+    if (activeLockPath) {
+      try {
+        const lockObj = JSON.parse(fs.readFileSync(activeLockPath, "utf-8"));
+        if (!changeName && lockObj.change_name && lockObj.change_name !== "nuevo-cambio") {
+          changeName = lockObj.change_name;
+        }
+        if (lockObj.complexity) {
+          complexity = lockObj.complexity;
+        }
+      } catch (e) {}
+    }
+
+    if (!changeName || changeName === "nuevo-cambio") {
+      return JSON.stringify({
+        status: "FAILED",
+        reason: "No se pudo autodetectar un cambio de desarrollo activo en .openspec/sdd-lock.json. Asegúrate de iniciar la Fase 1 primero."
+      }, null, 2);
+    }
+
+    const specPath = path.join(projectRoot, ".openspec/changes", changeName, "specs/spec.md");
+    if (!fs.existsSync(specPath)) {
+      return JSON.stringify({
+        status: "FAILED",
+        reason: `No se encuentra el archivo de especificación specs/spec.md para el cambio '${changeName}'. Ruta esperada: ${path.relative(projectRoot, specPath)}`
+      }, null, 2);
+    }
+
+    const specContent = fs.readFileSync(specPath, "utf-8");
+
+    // Secciones requeridas y sus expresiones regulares de validación según complejidad
+    const requiredSections = [
+      { name: "Plano Técnico / Título", regex: /^# Plano Técnico de Especificación/m },
+      { name: "1. Diagnóstico y Archivos Afectados", regex: /^## 1\. Diagnóstico/m },
+      { name: "3. Propuesta de Solución y Arquitectura", regex: /^## 3\. Propuesta/m },
+      { name: "5. Criterios de Aceptación y Calidad", regex: /^## 5\. Criterios/m }
+    ];
+
+    if (complexity !== "low") {
+      requiredSections.push(
+        { name: "2. Consenso de Encuesta con el Usuario", regex: /^## 2\. Consenso/m },
+        { name: "4. Especificaciones BDD (Comportamiento)", regex: /^## 4\. Especificaciones BDD|Feature:/m }
+      );
+    }
+
+    const missingSections: string[] = [];
+    requiredSections.forEach(section => {
+      if (!section.regex.test(specContent)) {
+        missingSections.push(section.name);
+      }
+    });
+
+    if (missingSections.length > 0) {
+      return JSON.stringify({
+        status: "FAILED",
+        changeName,
+        complexity,
+        reason: "El archivo spec.md no cumple con el formato mandatorio.",
+        missingSections,
+        message: `❌ VALIDACIÓN FALLIDA [Complejidad: ${complexity}]: Faltan las siguientes secciones requeridas en el plano técnico:\n${missingSections.map(s => `  - ${s}`).join("\n")}\n\nPor favor, pide a @sdd-planner que complete todas las secciones requeridas.`
+      }, null, 2);
+    }
+
+    // Comprobar si hay placeholders obvios sin completar según complejidad
+    const placeholders = [
+      /\[nombre-cambio\]/i,
+      /\[Un solo párrafo conciso con el enfoque técnico\]/i
+    ];
+
+    if (complexity !== "low") {
+      placeholders.push(
+        /\[Resumen de la duda y decisión adoptada\]/i,
+        /\[Caso de prueba principal o flujo clave\]/i,
+        /\[Contexto inicial del sistema\]/i,
+        /\[Acción que realiza el usuario o sistema\]/i,
+        /\[Resultado final esperado\]/i
+      );
+    }
+
+    const detectedPlaceholders: string[] = [];
+    placeholders.forEach(regex => {
+      const match = specContent.match(regex);
+      if (match) {
+        detectedPlaceholders.push(match[0]);
+      }
+    });
+
+    if (detectedPlaceholders.length > 0) {
+      return JSON.stringify({
+        status: "FAILED",
+        changeName,
+        complexity,
+        reason: "Se detectaron placeholders sin completar en el plano técnico.",
+        detectedPlaceholders,
+        message: `❌ VALIDACIÓN FALLIDA [Complejidad: ${complexity}]: El spec.md contiene marcadores de posición (placeholders) que no han sido completados:\n${detectedPlaceholders.map(p => `  - ${p}`).join("\n")}\n\nPor favor, reemplaza estos valores con las especificaciones reales antes de avanzar.`
+      }, null, 2);
+    }
+
+    // Validar Given-When-Then solo si la complejidad es alta
+    if (complexity !== "low") {
+      const hasScenario = /Scenario:|Escenario:/i.test(specContent);
+      const hasGWT = /(Given|Dado)[\s\S]+(When|Cuando)[\s\S]+(Then|Entonces)/i.test(specContent);
+
+      if (!hasScenario || !hasGWT) {
+        return JSON.stringify({
+          status: "FAILED",
+          changeName,
+          complexity,
+          reason: "No se encontraron escenarios Given-When-Then estructurados.",
+          message: `❌ VALIDACIÓN FALLIDA [Complejidad: ${complexity}]: Se requiere al menos un escenario estructurado 'Scenario:' con pasos Given-When-Then (Dado-Cuando-Entonces) para habilitar las pruebas automáticas en la Fase 2.`
+        }, null, 2);
+      }
+    }
+
+    return JSON.stringify({
+      status: "APPROVED",
+      changeName,
+      complexity,
+      message: `✅ VALIDACIÓN EXITOSA [Complejidad: ${complexity}]: El plano técnico 'specs/spec.md' para '${changeName}' cumple al 100% con los contratos de calidad de la metodología SDD. Está listo para ser implementado en la Fase 2.`
+    }, null, 2);
+  }
+})