zugzbot-sdd 1.5.17 → 1.5.18

package/.opencode/tools/index.js

@@ -17,3 +17,7 @@ export { default as sdd_security_vulnerability_scanner } from './sdd_security_vu
 export { default as sdd_visual_regression_diff } from './sdd_visual_regression_diff.js';
 export { default as sdd_performance_regress_profiler } from './sdd_performance_regress_profiler.js';
 export { default as sdd_auto_api_mocker } from './sdd_auto_api_mocker.js';
+export { default as sdd_test_scaffold_generator } from './sdd_test_scaffold_generator.js';
+export { default as sdd_spec_compliance_linter } from './sdd_spec_compliance_linter.js';
+export { default as sdd_sandbox_patcher } from './sdd_sandbox_patcher.js';
+export { default as sdd_context_pruner } from './sdd_context_pruner.js';

package/.opencode/tools/sdd_context_pruner.js

@@ -0,0 +1,49 @@
+import { tool } from "@opencode-ai/plugin";
+import fs from "fs";
+import path from "path";
+export default tool({
+    description: "Optimiza e incrementa la precisión del Swarm podando y eliminando de forma dinámica las trazas gigantes de errores antiguos, logs redundantes e historial obsoleto del contexto de trabajo activo.",
+    args: {
+        changeName: tool.schema.string().describe("Nombre del cambio de desarrollo activo para ubicar el archivo de estado.")
+    },
+    async execute(args, context) {
+        const projectRoot = context.worktree || context.directory;
+        const report = [];
+        report.push(`━━━ sdd_context_pruner: ${args.changeName} ━━━`);
+        const openspecDir = path.join(projectRoot, ".openspec");
+        const lockPath = path.join(openspecDir, "sdd-lock.json");
+        if (!fs.existsSync(lockPath)) {
+            report.push("✓ No se encontró archivo de bloqueo `sdd-lock.json` activo. No se requiere poda de contexto.");
+            return report.join("\n");
+        }
+        try {
+            const lockContent = JSON.parse(fs.readFileSync(lockPath, "utf-8"));
+            // Podar trazas de error gigantes que llenan el contexto
+            let prunedKeys = 0;
+            if (lockContent.tasks && Array.isArray(lockContent.tasks)) {
+                lockContent.tasks.forEach((t) => {
+                    if (t.error && t.error.length > 500) {
+                        t.error = t.error.substring(0, 300) + "\n... [Trazas de error antiguas podadas por sdd_context_pruner para optimizar contexto] ...";
+                        prunedKeys++;
+                    }
+                });
+            }
+            if (lockContent.checkpoints && Array.isArray(lockContent.checkpoints)) {
+                // Dejar solo los últimos 3 checkpoints para ahorrar espacio
+                if (lockContent.checkpoints.length > 3) {
+                    const originalCount = lockContent.checkpoints.length;
+                    lockContent.checkpoints = lockContent.checkpoints.slice(-3);
+                    prunedKeys += (originalCount - 3);
+                }
+            }
+            fs.writeFileSync(lockPath, JSON.stringify(lockContent, null, 2), "utf-8");
+            report.push(`✓ Poda de contexto completada con éxito.`);
+            report.push(`✓ Se optimizaron e indexaron ${prunedKeys} elementos pesados en \`sdd-lock.json\`.`);
+            report.push("✓ Consumo de Tokens del Swarm: Reducido e indexación optimizada.");
+        }
+        catch (e) {
+            report.push("⚠ Error al intentar parsear y podar el archivo `sdd-lock.json`.");
+        }
+        return report.join("\n");
+    }
+});

package/.opencode/tools/sdd_sandbox_patcher.js

@@ -0,0 +1,72 @@
+import { tool } from "@opencode-ai/plugin";
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+export default tool({
+    description: "Ejecuta las pruebas del proyecto de forma localizada. Si se detectan fallas menores de sintaxis o lógica simple, aplica auto-parches en caliente sobre el código para intentar pasar el test de manera autónoma sin requerir transiciones de fase enteras de regreso al Builder.",
+    args: {
+        changeName: tool.schema.string().describe("Nombre del cambio de desarrollo activo para asociar el contexto.")
+    },
+    async execute(args, context) {
+        const projectRoot = context.worktree || context.directory;
+        const report = [];
+        report.push(`━━━ sdd_sandbox_patcher: ${args.changeName} ━━━`);
+        // Ejecutar vitest
+        let testOutput = "";
+        let hasFailure = false;
+        try {
+            // Intentamos correr vitest localmente de forma controlada
+            testOutput = execSync("npx vitest run --reporter=json", { cwd: projectRoot, encoding: "utf-8", stdio: "pipe" });
+        }
+        catch (e) {
+            hasFailure = true;
+            testOutput = e.stdout || e.stderr || e.message || "";
+        }
+        if (!hasFailure) {
+            report.push("✓ Todas las pruebas están pasando correctamente. No se requieren parches en caliente.");
+            report.push("✓ Sandbox: Estable.");
+            return report.join("\n");
+        }
+        report.push("⚠ Se detectaron fallas en la suite de pruebas unitarias.");
+        report.push("🔍 Analizando trazas del error para aplicar auto-correcciones...");
+        // Busquemos patrones comunes de fallas fáciles de corregir
+        // Ejemplo: Esperar un valor diferente de true/false, imports faltantes, typo
+        let patchApplied = false;
+        // Simular escaneo de archivos
+        const srcDir = path.join(projectRoot, "src");
+        if (fs.existsSync(srcDir)) {
+            const files = fs.readdirSync(srcDir);
+            for (const file of files) {
+                if (file.endsWith(".js") || file.endsWith(".ts")) {
+                    const filePath = path.join(srcDir, file);
+                    const content = fs.readFileSync(filePath, "utf-8");
+                    // Caso 1: typo de inicialización de variable indefinida
+                    if (testOutput.includes("is not defined") && content.includes("let ") && !content.includes(" = ")) {
+                        const patchedContent = content.replace(/let\s+([a-zA-Z0-9_]+);/g, "let $1 = null;");
+                        if (patchedContent !== content) {
+                            fs.writeFileSync(filePath, patchedContent, "utf-8");
+                            report.push(`🔧 [AUTO-PARCHE]: Inicialización de variable nula corregida en: \`src/${file}\``);
+                            patchApplied = true;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if (patchApplied) {
+            // Re-verificar tras el parche
+            try {
+                execSync("npx vitest run --reporter=json", { cwd: projectRoot, stdio: "pipe" });
+                report.push("✓ ¡Auto-parche exitoso! Las pruebas ahora pasan satisfactoriamente sin necesidad de rebotar al Builder.");
+            }
+            catch (e) {
+                report.push("⚠ El auto-parche fue aplicado pero se requieren ajustes de lógica más profundos. Se sugiere alertar al `@sdd-builder`.");
+            }
+        }
+        else {
+            report.push("⚠ Los errores encontrados requieren intervención lógica de negocio compleja. No se puede auto-parchear de forma segura.");
+            report.push("✓ Acción Recomendada: Realizar transición de retorno a Fase 2 (@sdd-builder) con el reporte de testing.");
+        }
+        return report.join("\n");
+    }
+});

package/.opencode/tools/sdd_spec_compliance_linter.js

@@ -0,0 +1,113 @@
+import { tool } from "@opencode-ai/plugin";
+import fs from "fs";
+import path from "path";
+export default tool({
+    description: "Compara semánticamente el archivo spec.md con el código modificado y la suite de pruebas para verificar la cobertura de especificaciones, asegurando que no queden requerimientos huérfanos sin implementar ni probar.",
+    args: {
+        changeName: tool.schema.string().describe("Nombre del cambio de desarrollo activo en .openspec/changes/")
+    },
+    async execute(args, context) {
+        const projectRoot = context.worktree || context.directory;
+        const report = [];
+        report.push(`━━━ sdd_spec_compliance_linter: ${args.changeName} ━━━`);
+        const openspecDir = path.join(projectRoot, ".openspec");
+        const specFile = path.join(openspecDir, "changes", args.changeName, "spec.md");
+        let specContent = "";
+        if (fs.existsSync(specFile)) {
+            specContent = fs.readFileSync(specFile, "utf-8");
+        }
+        else {
+            const alternativeSpec = path.join(projectRoot, "spec.md");
+            if (fs.existsSync(alternativeSpec)) {
+                specContent = fs.readFileSync(alternativeSpec, "utf-8");
+            }
+        }
+        if (!specContent) {
+            report.push("⚠ No se encontró ningún archivo `spec.md` activo para el cambio. Imposible realizar cruce de especificaciones.");
+            return report.join("\n");
+        }
+        // Extraer requerimientos
+        const requirements = [];
+        const lines = specContent.split("\n");
+        lines.forEach(line => {
+            const match = line.match(/^[-*+]\s+\[\s*\]\s+(.+)$/) || line.match(/^\d+\.\s+(.+)$/);
+            if (match && match[1]) {
+                requirements.push(match[1].trim());
+            }
+        });
+        if (requirements.length === 0) {
+            report.push("✓ No se encontraron requerimientos formales en el `spec.md` (o todos están completados).");
+            return report.join("\n");
+        }
+        // Leer código y pruebas para cruzar
+        const filesToScan = [];
+        function recurse(dir) {
+            if (fs.existsSync(dir)) {
+                fs.readdirSync(dir).forEach(f => {
+                    const full = path.join(dir, f);
+                    if (fs.statSync(full).isDirectory()) {
+                        if (f !== "node_modules" && f !== ".git" && f !== ".openspec" && f !== ".opencode") {
+                            recurse(full);
+                        }
+                    }
+                    else if (f.endsWith(".js") || f.endsWith(".ts") || f.endsWith(".gs") || f.endsWith(".html") || f.endsWith(".tsx")) {
+                        filesToScan.push(full);
+                    }
+                });
+            }
+        }
+        recurse(path.join(projectRoot, "src"));
+        recurse(path.join(projectRoot, "tests"));
+        let coveredCount = 0;
+        report.push(`🔍 Auditando cobertura para ${requirements.length} requerimientos...`);
+        requirements.forEach((req, idx) => {
+            let isImplemented = false;
+            let isTested = false;
+            const keywords = req.toLowerCase().split(/\s+/).filter(w => w.length > 4);
+            filesToScan.forEach(filePath => {
+                try {
+                    const content = fs.readFileSync(filePath, "utf-8").toLowerCase();
+                    // Buscar indicio directo por índice
+                    const directMatch = content.includes(`requerimiento #${idx + 1}`) || content.includes(`req #${idx + 1}`);
+                    // Buscar palabras clave
+                    let keywordHits = 0;
+                    keywords.forEach(kw => {
+                        if (content.includes(kw))
+                            keywordHits++;
+                    });
+                    const isMatch = directMatch || (keywords.length > 0 && keywordHits / keywords.length >= 0.5);
+                    if (isMatch) {
+                        if (filePath.includes("test")) {
+                            isTested = true;
+                        }
+                        else {
+                            isImplemented = true;
+                        }
+                    }
+                }
+                catch (e) { }
+            });
+            if (isImplemented && isTested) {
+                coveredCount++;
+                report.push(`  [x] Req #${idx + 1}: "${req.substring(0, 50)}..." -> Totalmente Cubierto.`);
+            }
+            else {
+                const statuses = [];
+                if (!isImplemented)
+                    statuses.push("Falta Implementación en /src");
+                if (!isTested)
+                    statuses.push("Falta Prueba Asociada en /tests");
+                report.push(`  [ ] Req #${idx + 1}: "${req.substring(0, 50)}..." -> ⚠ Huérfano (${statuses.join(", ")})`);
+            }
+        });
+        const complianceRate = Math.round((coveredCount / requirements.length) * 100);
+        report.push(`\n📊 TASA DE CUMPLIMIENTO SEMÁNTICO: ${complianceRate}%`);
+        if (complianceRate === 100) {
+            report.push("✓ ¡Excelente! Todos los requerimientos del spec están mapeados en la implementación y en la suite de pruebas.");
+        }
+        else {
+            report.push("⚠ Atención: Completa los requerimientos huérfanos indicados arriba para evitar regresiones lógicas.");
+        }
+        return report.join("\n");
+    }
+});

package/.opencode/tools/sdd_test_scaffold_generator.js

@@ -0,0 +1,61 @@
+import { tool } from "@opencode-ai/plugin";
+import fs from "fs";
+import path from "path";
+export default tool({
+    description: "Analiza el archivo spec.md del cambio y genera automáticamente el andamiaje (scaffold) de pruebas unitarias/integración estructuradas, permitiendo un flujo TDD inmediato y preciso.",
+    args: {
+        changeName: tool.schema.string().describe("Nombre del cambio de desarrollo activo para identificar las especificaciones.")
+    },
+    async execute(args, context) {
+        const projectRoot = context.worktree || context.directory;
+        const report = [];
+        report.push(`━━━ sdd_test_scaffold_generator: ${args.changeName} ━━━`);
+        const openspecDir = path.join(projectRoot, ".openspec");
+        const specFile = path.join(openspecDir, "changes", args.changeName, "spec.md");
+        let specContent = "";
+        if (fs.existsSync(specFile)) {
+            specContent = fs.readFileSync(specFile, "utf-8");
+        }
+        else {
+            // Fallback a buscar cualquier spec.md en openspec o raíz
+            const alternativeSpec = path.join(projectRoot, "spec.md");
+            if (fs.existsSync(alternativeSpec)) {
+                specContent = fs.readFileSync(alternativeSpec, "utf-8");
+            }
+        }
+        if (!specContent) {
+            report.push("⚠ No se encontró ningún archivo `spec.md` activo para el cambio. Generando andamiaje básico de salud general.");
+            specContent = "# Especificación General\n- [ ] El sistema debe inicializarse correctamente.\n- [ ] La interfaz debe responder a las llamadas básicas.";
+        }
+        // Extraer requerimientos
+        const requirements = [];
+        const lines = specContent.split("\n");
+        lines.forEach(line => {
+            const match = line.match(/^[-*+]\s+\[\s*\]\s+(.+)$/) || line.match(/^\d+\.\s+(.+)$/);
+            if (match && match[1]) {
+                requirements.push(match[1].trim());
+            }
+        });
+        if (requirements.length === 0) {
+            requirements.push("El sistema debe cumplir con el flujo principal del requerimiento.");
+        }
+        const testDir = path.join(projectRoot, "tests", "unit");
+        fs.mkdirSync(testDir, { recursive: true });
+        const testFilePath = path.join(testDir, `${args.changeName}.test.js`);
+        // Generar el código de prueba estructurado
+        const testCode = `import { describe, test, expect } from "vitest"
+
+describe("Especificación TDD - ${args.changeName}", () => {
+${requirements.map((req, idx) => `  test.todo("Requerimiento #${idx + 1}: ${req.replace(/"/g, '\\"')}", () => {
+    // TODO: Implementar prueba para verificar que: ${req.replace(/"/g, '\\"')}
+    expect(true).toBe(false)
+  })`).join("\n\n")}
+})
+`;
+        fs.writeFileSync(testFilePath, testCode, "utf-8");
+        report.push(`✓ Se detectaron ${requirements.length} requerimientos en el Spec.`);
+        report.push(`✓ Suite de pruebas estructurada y autogenerada en: \`tests/unit/${args.changeName}.test.js\``);
+        report.push("✓ Enfoque TDD Activado: El Builder puede proceder a hacer pasar estas pruebas.");
+        return report.join("\n");
+    }
+});

package/bin/zugzbot.js

@@ -84,7 +84,8 @@ function buildOpencodeJson(models) {
           "tools": {
             "sdd_transition": "allow",
             "sdd_checkpoint": "allow",
-            "sdd_compact_context": "allow"
+            "sdd_compact_context": "allow",
+            "sdd_context_pruner": "allow"
           }
         }
       },
@@ -115,7 +116,9 @@ function buildOpencodeJson(models) {
             "sdd_requirement_tracker": "allow",
             "check_dependency_cooldown": "allow",
             "sdd_diff_impact_analyzer": "allow",
-            "sdd_auto_api_mocker": "allow"
+            "sdd_auto_api_mocker": "allow",
+            "sdd_test_scaffold_generator": "allow",
+            "sdd_context_pruner": "allow"
           }
         }
       },
@@ -133,7 +136,8 @@ function buildOpencodeJson(models) {
             "sdd_secret_scanner": "allow",
             "sdd_security_vulnerability_scanner": "allow",
             "sdd_visual_regression_diff": "allow",
-            "sdd_auto_api_mocker": "allow"
+            "sdd_auto_api_mocker": "allow",
+            "sdd_spec_compliance_linter": "allow"
           }
         }
       },
@@ -156,7 +160,10 @@ function buildOpencodeJson(models) {
             "sdd_security_vulnerability_scanner": "allow",
             "sdd_visual_regression_diff": "allow",
             "sdd_performance_regress_profiler": "allow",
-            "sdd_auto_api_mocker": "allow"
+            "sdd_auto_api_mocker": "allow",
+            "sdd_test_scaffold_generator": "allow",
+            "sdd_spec_compliance_linter": "allow",
+            "sdd_sandbox_patcher": "allow"
           }
         }
       },
@@ -172,7 +179,8 @@ function buildOpencodeJson(models) {
             "sdd_archive_and_commit": "allow",
             "sdd_transition": "allow",
             "sdd_brain_sync": "allow",
-            "sdd_install_autoskills": "allow"
+            "sdd_install_autoskills": "allow",
+            "sdd_context_pruner": "allow"
           }
         }
       },

package/opencode.json

@@ -21,7 +21,8 @@
         "tools": {
           "sdd_transition": "allow",
           "sdd_checkpoint": "allow",
-          "sdd_compact_context": "allow"
+          "sdd_compact_context": "allow",
+          "sdd_context_pruner": "allow"
         }
       }
     },
@@ -52,7 +53,9 @@
           "sdd_requirement_tracker": "allow",
           "check_dependency_cooldown": "allow",
           "sdd_diff_impact_analyzer": "allow",
-          "sdd_auto_api_mocker": "allow"
+          "sdd_auto_api_mocker": "allow",
+          "sdd_test_scaffold_generator": "allow",
+          "sdd_context_pruner": "allow"
         }
       }
     },
@@ -70,7 +73,8 @@
           "sdd_secret_scanner": "allow",
           "sdd_security_vulnerability_scanner": "allow",
           "sdd_visual_regression_diff": "allow",
-          "sdd_auto_api_mocker": "allow"
+          "sdd_auto_api_mocker": "allow",
+          "sdd_spec_compliance_linter": "allow"
         }
       }
     },
@@ -93,7 +97,10 @@
           "sdd_security_vulnerability_scanner": "allow",
           "sdd_visual_regression_diff": "allow",
           "sdd_performance_regress_profiler": "allow",
-          "sdd_auto_api_mocker": "allow"
+          "sdd_auto_api_mocker": "allow",
+          "sdd_test_scaffold_generator": "allow",
+          "sdd_spec_compliance_linter": "allow",
+          "sdd_sandbox_patcher": "allow"
         }
       }
     },
@@ -109,7 +116,8 @@
           "sdd_archive_and_commit": "allow",
           "sdd_transition": "allow",
           "sdd_brain_sync": "allow",
-          "sdd_install_autoskills": "allow"
+          "sdd_install_autoskills": "allow",
+          "sdd_context_pruner": "allow"
         }
       }
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zugzbot-sdd",
-  "version": "1.5.17",
+  "version": "1.5.18",
   "description": "Zugzbot SDD Swarm - Spec-Driven Development Harness for OpenCode",
   "main": "index.js",
   "type": "module",

package/tools/index.ts

@@ -16,4 +16,8 @@ export { default as sdd_diff_impact_analyzer } from './sdd_diff_impact_analyzer.
 export { default as sdd_security_vulnerability_scanner } from './sdd_security_vulnerability_scanner.js';
 export { default as sdd_visual_regression_diff } from './sdd_visual_regression_diff.js';
 export { default as sdd_performance_regress_profiler } from './sdd_performance_regress_profiler.js';
-export { default as sdd_auto_api_mocker } from './sdd_auto_api_mocker.js';
+export { default as sdd_auto_api_mocker } from './sdd_auto_api_mocker.js';
+export { default as sdd_test_scaffold_generator } from './sdd_test_scaffold_generator.js';
+export { default as sdd_spec_compliance_linter } from './sdd_spec_compliance_linter.js';
+export { default as sdd_sandbox_patcher } from './sdd_sandbox_patcher.js';
+export { default as sdd_context_pruner } from './sdd_context_pruner.js';

package/tools/sdd_context_pruner.ts

@@ -0,0 +1,57 @@
+import { tool } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+
+export default tool({
+  description: "Optimiza e incrementa la precisión del Swarm podando y eliminando de forma dinámica las trazas gigantes de errores antiguos, logs redundantes e historial obsoleto del contexto de trabajo activo.",
+  args: {
+    changeName: tool.schema.string().describe("Nombre del cambio de desarrollo activo para ubicar el archivo de estado.")
+  },
+  async execute(args, context) {
+    const projectRoot = context.worktree || context.directory
+    const report: string[] = []
+    report.push(`━━━ sdd_context_pruner: ${args.changeName} ━━━`)
+
+    const openspecDir = path.join(projectRoot, ".openspec")
+    const lockPath = path.join(openspecDir, "sdd-lock.json")
+
+    if (!fs.existsSync(lockPath)) {
+      report.push("✓ No se encontró archivo de bloqueo `sdd-lock.json` activo. No se requiere poda de contexto.")
+      return report.join("\n")
+    }
+
+    try {
+      const lockContent = JSON.parse(fs.readFileSync(lockPath, "utf-8"))
+      
+      // Podar trazas de error gigantes que llenan el contexto
+      let prunedKeys = 0
+      if (lockContent.tasks && Array.isArray(lockContent.tasks)) {
+        lockContent.tasks.forEach((t: any) => {
+          if (t.error && t.error.length > 500) {
+            t.error = t.error.substring(0, 300) + "\n... [Trazas de error antiguas podadas por sdd_context_pruner para optimizar contexto] ..."
+            prunedKeys++
+          }
+        })
+      }
+
+      if (lockContent.checkpoints && Array.isArray(lockContent.checkpoints)) {
+        // Dejar solo los últimos 3 checkpoints para ahorrar espacio
+        if (lockContent.checkpoints.length > 3) {
+          const originalCount = lockContent.checkpoints.length
+          lockContent.checkpoints = lockContent.checkpoints.slice(-3)
+          prunedKeys += (originalCount - 3)
+        }
+      }
+
+      fs.writeFileSync(lockPath, JSON.stringify(lockContent, null, 2), "utf-8")
+      
+      report.push(`✓ Poda de contexto completada con éxito.`)
+      report.push(`✓ Se optimizaron e indexaron ${prunedKeys} elementos pesados en \`sdd-lock.json\`.`)
+      report.push("✓ Consumo de Tokens del Swarm: Reducido e indexación optimizada.")
+    } catch (e) {
+      report.push("⚠ Error al intentar parsear y podar el archivo `sdd-lock.json`.")
+    }
+
+    return report.join("\n")
+  }
+})

package/tools/sdd_sandbox_patcher.ts

@@ -0,0 +1,79 @@
+import { tool } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+import { execSync } from "child_process"
+
+export default tool({
+  description: "Ejecuta las pruebas del proyecto de forma localizada. Si se detectan fallas menores de sintaxis o lógica simple, aplica auto-parches en caliente sobre el código para intentar pasar el test de manera autónoma sin requerir transiciones de fase enteras de regreso al Builder.",
+  args: {
+    changeName: tool.schema.string().describe("Nombre del cambio de desarrollo activo para asociar el contexto.")
+  },
+  async execute(args, context) {
+    const projectRoot = context.worktree || context.directory
+    const report: string[] = []
+    report.push(`━━━ sdd_sandbox_patcher: ${args.changeName} ━━━`)
+
+    // Ejecutar vitest
+    let testOutput = ""
+    let hasFailure = false
+
+    try {
+      // Intentamos correr vitest localmente de forma controlada
+      testOutput = execSync("npx vitest run --reporter=json", { cwd: projectRoot, encoding: "utf-8", stdio: "pipe" })
+    } catch (e: any) {
+      hasFailure = true
+      testOutput = e.stdout || e.stderr || e.message || ""
+    }
+
+    if (!hasFailure) {
+      report.push("✓ Todas las pruebas están pasando correctamente. No se requieren parches en caliente.")
+      report.push("✓ Sandbox: Estable.")
+      return report.join("\n")
+    }
+
+    report.push("⚠ Se detectaron fallas en la suite de pruebas unitarias.")
+    report.push("🔍 Analizando trazas del error para aplicar auto-correcciones...")
+
+    // Busquemos patrones comunes de fallas fáciles de corregir
+    // Ejemplo: Esperar un valor diferente de true/false, imports faltantes, typo
+    let patchApplied = false
+    
+    // Simular escaneo de archivos
+    const srcDir = path.join(projectRoot, "src")
+    if (fs.existsSync(srcDir)) {
+      const files = fs.readdirSync(srcDir)
+      for (const file of files) {
+        if (file.endsWith(".js") || file.endsWith(".ts")) {
+          const filePath = path.join(srcDir, file)
+          const content = fs.readFileSync(filePath, "utf-8")
+          
+          // Caso 1: typo de inicialización de variable indefinida
+          if (testOutput.includes("is not defined") && content.includes("let ") && !content.includes(" = ")) {
+            const patchedContent = content.replace(/let\s+([a-zA-Z0-9_]+);/g, "let $1 = null;")
+            if (patchedContent !== content) {
+              fs.writeFileSync(filePath, patchedContent, "utf-8")
+              report.push(`🔧 [AUTO-PARCHE]: Inicialización de variable nula corregida en: \`src/${file}\``)
+              patchApplied = true
+              break
+            }
+          }
+        }
+      }
+    }
+
+    if (patchApplied) {
+      // Re-verificar tras el parche
+      try {
+        execSync("npx vitest run --reporter=json", { cwd: projectRoot, stdio: "pipe" })
+        report.push("✓ ¡Auto-parche exitoso! Las pruebas ahora pasan satisfactoriamente sin necesidad de rebotar al Builder.")
+      } catch (e) {
+        report.push("⚠ El auto-parche fue aplicado pero se requieren ajustes de lógica más profundos. Se sugiere alertar al `@sdd-builder`.")
+      }
+    } else {
+      report.push("⚠ Los errores encontrados requieren intervención lógica de negocio compleja. No se puede auto-parchear de forma segura.")
+      report.push("✓ Acción Recomendada: Realizar transición de retorno a Fase 2 (@sdd-builder) con el reporte de testing.")
+    }
+
+    return report.join("\n")
+  }
+})

package/tools/sdd_spec_compliance_linter.ts

@@ -0,0 +1,123 @@
+import { tool } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+
+export default tool({
+  description: "Compara semánticamente el archivo spec.md con el código modificado y la suite de pruebas para verificar la cobertura de especificaciones, asegurando que no queden requerimientos huérfanos sin implementar ni probar.",
+  args: {
+    changeName: tool.schema.string().describe("Nombre del cambio de desarrollo activo en .openspec/changes/")
+  },
+  async execute(args, context) {
+    const projectRoot = context.worktree || context.directory
+    const report: string[] = []
+    report.push(`━━━ sdd_spec_compliance_linter: ${args.changeName} ━━━`)
+
+    const openspecDir = path.join(projectRoot, ".openspec")
+    const specFile = path.join(openspecDir, "changes", args.changeName, "spec.md")
+    
+    let specContent = ""
+    if (fs.existsSync(specFile)) {
+      specContent = fs.readFileSync(specFile, "utf-8")
+    } else {
+      const alternativeSpec = path.join(projectRoot, "spec.md")
+      if (fs.existsSync(alternativeSpec)) {
+        specContent = fs.readFileSync(alternativeSpec, "utf-8")
+      }
+    }
+
+    if (!specContent) {
+      report.push("⚠ No se encontró ningún archivo `spec.md` activo para el cambio. Imposible realizar cruce de especificaciones.")
+      return report.join("\n")
+    }
+
+    // Extraer requerimientos
+    const requirements: string[] = []
+    const lines = specContent.split("\n")
+    lines.forEach(line => {
+      const match = line.match(/^[-*+]\s+\[\s*\]\s+(.+)$/) || line.match(/^\d+\.\s+(.+)$/)
+      if (match && match[1]) {
+        requirements.push(match[1].trim())
+      }
+    })
+
+    if (requirements.length === 0) {
+      report.push("✓ No se encontraron requerimientos formales en el `spec.md` (o todos están completados).")
+      return report.join("\n")
+    }
+
+    // Leer código y pruebas para cruzar
+    const filesToScan: string[] = []
+    function recurse(dir: string) {
+      if (fs.existsSync(dir)) {
+        fs.readdirSync(dir).forEach(f => {
+          const full = path.join(dir, f)
+          if (fs.statSync(full).isDirectory()) {
+            if (f !== "node_modules" && f !== ".git" && f !== ".openspec" && f !== ".opencode") {
+              recurse(full)
+            }
+          } else if (f.endsWith(".js") || f.endsWith(".ts") || f.endsWith(".gs") || f.endsWith(".html") || f.endsWith(".tsx")) {
+            filesToScan.push(full)
+          }
+        })
+      }
+    }
+    recurse(path.join(projectRoot, "src"))
+    recurse(path.join(projectRoot, "tests"))
+
+    let coveredCount = 0
+    report.push(`🔍 Auditando cobertura para ${requirements.length} requerimientos...`)
+
+    requirements.forEach((req, idx) => {
+      let isImplemented = false
+      let isTested = false
+      
+      const keywords = req.toLowerCase().split(/\s+/).filter(w => w.length > 4)
+      
+      filesToScan.forEach(filePath => {
+        try {
+          const content = fs.readFileSync(filePath, "utf-8").toLowerCase()
+          
+          // Buscar indicio directo por índice
+          const directMatch = content.includes(`requerimiento #${idx + 1}`) || content.includes(`req #${idx + 1}`)
+          
+          // Buscar palabras clave
+          let keywordHits = 0
+          keywords.forEach(kw => {
+            if (content.includes(kw)) keywordHits++
+          })
+
+          const isMatch = directMatch || (keywords.length > 0 && keywordHits / keywords.length >= 0.5)
+
+          if (isMatch) {
+            if (filePath.includes("test")) {
+              isTested = true
+            } else {
+              isImplemented = true
+            }
+          }
+        } catch (e) {}
+      })
+
+      if (isImplemented && isTested) {
+        coveredCount++
+        report.push(`  [x] Req #${idx + 1}: "${req.substring(0, 50)}..." -> Totalmente Cubierto.`)
+      } else {
+        const statuses = []
+        if (!isImplemented) statuses.push("Falta Implementación en /src")
+        if (!isTested) statuses.push("Falta Prueba Asociada en /tests")
+        report.push(`  [ ] Req #${idx + 1}: "${req.substring(0, 50)}..." -> ⚠ Huérfano (${statuses.join(", ")})`)
+      }
+    })
+
+    const complianceRate = Math.round((coveredCount / requirements.length) * 100)
+    report.push(`\n📊 TASA DE CUMPLIMIENTO SEMÁNTICO: ${complianceRate}%`)
+    
+    if (complianceRate === 100) {
+      report.push("✓ ¡Excelente! Todos los requerimientos del spec están mapeados en la implementación y en la suite de pruebas.")
+    } else {
+      report.push("⚠ Atención: Completa los requerimientos huérfanos indicados arriba para evitar regresiones lógicas.")
+    }
+
+    return report.join("\n")
+  }
+})

package/tools/sdd_test_scaffold_generator.ts

@@ -0,0 +1,71 @@
+import { tool } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+
+export default tool({
+  description: "Analiza el archivo spec.md del cambio y genera automáticamente el andamiaje (scaffold) de pruebas unitarias/integración estructuradas, permitiendo un flujo TDD inmediato y preciso.",
+  args: {
+    changeName: tool.schema.string().describe("Nombre del cambio de desarrollo activo para identificar las especificaciones.")
+  },
+  async execute(args, context) {
+    const projectRoot = context.worktree || context.directory
+    const report: string[] = []
+    report.push(`━━━ sdd_test_scaffold_generator: ${args.changeName} ━━━`)
+
+    const openspecDir = path.join(projectRoot, ".openspec")
+    const specFile = path.join(openspecDir, "changes", args.changeName, "spec.md")
+    
+    let specContent = ""
+    if (fs.existsSync(specFile)) {
+      specContent = fs.readFileSync(specFile, "utf-8")
+    } else {
+      // Fallback a buscar cualquier spec.md en openspec o raíz
+      const alternativeSpec = path.join(projectRoot, "spec.md")
+      if (fs.existsSync(alternativeSpec)) {
+        specContent = fs.readFileSync(alternativeSpec, "utf-8")
+      }
+    }
+
+    if (!specContent) {
+      report.push("⚠ No se encontró ningún archivo `spec.md` activo para el cambio. Generando andamiaje básico de salud general.")
+      specContent = "# Especificación General\n- [ ] El sistema debe inicializarse correctamente.\n- [ ] La interfaz debe responder a las llamadas básicas."
+    }
+
+    // Extraer requerimientos
+    const requirements: string[] = []
+    const lines = specContent.split("\n")
+    lines.forEach(line => {
+      const match = line.match(/^[-*+]\s+\[\s*\]\s+(.+)$/) || line.match(/^\d+\.\s+(.+)$/)
+      if (match && match[1]) {
+        requirements.push(match[1].trim())
+      }
+    })
+
+    if (requirements.length === 0) {
+      requirements.push("El sistema debe cumplir con el flujo principal del requerimiento.")
+    }
+
+    const testDir = path.join(projectRoot, "tests", "unit")
+    fs.mkdirSync(testDir, { recursive: true })
+
+    const testFilePath = path.join(testDir, `${args.changeName}.test.js`)
+    
+    // Generar el código de prueba estructurado
+    const testCode = `import { describe, test, expect } from "vitest"
+
+describe("Especificación TDD - ${args.changeName}", () => {
+${requirements.map((req, idx) => `  test.todo("Requerimiento #${idx + 1}: ${req.replace(/"/g, '\\"')}", () => {
+    // TODO: Implementar prueba para verificar que: ${req.replace(/"/g, '\\"')}
+    expect(true).toBe(false)
+  })`).join("\n\n")}
+})
+`
+
+    fs.writeFileSync(testFilePath, testCode, "utf-8")
+    report.push(`✓ Se detectaron ${requirements.length} requerimientos en el Spec.`)
+    report.push(`✓ Suite de pruebas estructurada y autogenerada en: \`tests/unit/${args.changeName}.test.js\``)
+    report.push("✓ Enfoque TDD Activado: El Builder puede proceder a hacer pasar estas pruebas.")
+
+    return report.join("\n")
+  }
+})