zugzbot-sdd 1.5.29 → 1.5.31

package/.opencode/skills/sdd-secure-coding/SKILL.md

@@ -0,0 +1,51 @@
+# Skill: SDD Secure Coding (Threat Modeling & Sanitization)
+
+Esta habilidad impone directivas de codificación segura obligatorias para el enjambre de agentes en todas las fases de **Construcción (F2)** y **Calidad (F3)**, garantizando que el software desarrollado sea inherentemente inmune a vulnerabilidades de seguridad clásicas.
+
+## Trigger
+
+Se activa obligatoriamente al modificar código relacionado con:
+1. Entrada de texto o manipulación del DOM por parte del usuario (Forms, inputs, query params).
+2. Interacciones con bases de datos, APIs de persistencia o lectura/escritura de ficheros locales.
+3. Actualización de paquetes o importación de nuevas librerías.
+
+## Directivas de Seguridad del Swarm
+
+Todos los subagentes deben aplicar estrictamente las siguientes reglas operativas:
+
+### 1. Inmunización contra XSS (Cross-Site Scripting)
+Queda estrictamente prohibido inyectar HTML de forma directa en el DOM sin previa sanitización.
+* **Acción:** Utiliza siempre métodos nativos seguros de asignación como `textContent` o `innerText` en lugar de `innerHTML` o `dangerouslySetInnerHTML`.
+* Si es mandatorio renderizar HTML dinámico, pasa el contenido por un sanitizador de confianza (como `DOMPurify` o una función de escape robusta local):
+
+```javascript
+function escapeHTML(str) {
+  return str.replace(/[&<>'"]/g, 
+    tag => ({
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      "'": '&#39;',
+      '"': '&quot;'
+    }[tag] || tag)
+  );
+}
+```
+
+### 2. Parametrización Absoluta (SQL & Command Injections)
+Cualquier consulta a base de datos, llamada a bash o comandos de ejecución del sistema no debe concatenar strings de variables de usuario.
+* **Acción:** Utiliza queries preparadas (parameterized queries) o valida rigurosamente los parámetros antes de pasarlos a ejecutores dinámicos.
+
+### 3. Escaneo Pre-Commit de Secretos
+Ningún secreto, clave de API, tokens de autenticación o credenciales privadas de Git debe subirse a producción.
+* **Acción:** El `@sdd-tester` y `@sdd-archiver` deben auditar activamente las diferencias en Git (`git diff`) mediante patrones regex de entropía para detectar strings sospechosos.
+
+## Criterios de Aceptación (QA)
+
+- `[ ]` **Seguridad DOM:** Cero uso de asignaciones directas de HTML inseguras (`innerHTML`).
+- `[ ]` **Persistencia Limpia:** Todas las consultas externas utilizan interfaces tipadas o parametrizadas.
+- `[ ]` **Cero Secretos:** No se filtran API keys en el área de preparación de Git.
+
+## Tags
+
+#sdd #security #xss #sanitization #secrets #sql-injection #secure-coder

package/.opencode/tools/index.js

@@ -22,3 +22,4 @@ export { default as sdd_spec_compliance_linter } from './sdd_spec_compliance_lin
 export { default as sdd_sandbox_patcher } from './sdd_sandbox_patcher.js';
 export { default as sdd_context_pruner } from './sdd_context_pruner.js';
 export { default as gas_clasp_tools } from './gas_clasp_tools.js';
+export { default as sdd_auto_healer } from './sdd_auto_healer.js';

package/.opencode/tools/sdd_archive_and_commit.js

@@ -186,14 +186,36 @@ export default tool({
             }
         }
         // 6. Archivar la carpeta físicamente (ANTES del commit para que quede registrado de forma atómica)
-        const archiveDir = path.join(projectRoot, ".openspec/changes/archive", `${dateStr}-${args.changeName}`);
+        // Calcular el siguiente prefijo de secuencia cronológica (ej: 0001_2026-05-30_143015)
+        let seqPrefix = "0001";
+        const archiveRoot = path.join(projectRoot, ".openspec/changes/archive");
+        if (fs.existsSync(archiveRoot)) {
+            try {
+                const dirs = fs.readdirSync(archiveRoot).filter(f => fs.statSync(path.join(archiveRoot, f)).isDirectory());
+                let maxSeq = 0;
+                dirs.forEach(d => {
+                    const match = d.match(/^(\d{4})_/);
+                    if (match) {
+                        const seq = parseInt(match[1], 10);
+                        if (seq > maxSeq)
+                            maxSeq = seq;
+                    }
+                });
+                seqPrefix = String(maxSeq + 1).padStart(4, "0");
+            }
+            catch (e) { }
+        }
+        const now = new Date();
+        const timeStr = now.toTimeString().split(" ")[0].replace(/:/g, ""); // e.g. "143015"
+        const archiveFolderName = `${seqPrefix}_${dateStr}_${timeStr}-${args.changeName}`;
+        const archiveDir = path.join(archiveRoot, archiveFolderName);
         try {
             if (fs.existsSync(archiveDir)) {
                 fs.rmSync(archiveDir, { recursive: true, force: true });
             }
             fs.mkdirSync(path.dirname(archiveDir), { recursive: true });
             moveRecursive(changeDir, archiveDir);
-            report.push(`✓ Carpeta archivada en: .openspec/changes/archive/${dateStr}-${args.changeName}/`);
+            report.push(`✓ Carpeta archivada en: .openspec/changes/archive/${archiveFolderName}/`);
         }
         catch (e) {
             return `[SDD Archive Error] Error crítico archivando carpetas: ${e.message}`;

package/.opencode/tools/sdd_auto_healer.js

@@ -0,0 +1,90 @@
+import { tool } from "@opencode-ai/plugin";
+import fs from "fs";
+import path from "path";
+export default tool({
+    description: "Intenta corregir de forma autónoma errores sintácticos y de compilación simples (comillas rotas, llaves huérfanas, imports duplicados) en base a los logs de error del linter o compilador.",
+    args: {
+        errorLogs: tool.schema.string().describe("El log de error bruto del compilador o linter."),
+        targetFile: tool.schema.string().optional().describe("Archivo sugerido que contiene el error. Si no se provee, se detectará del log.")
+    },
+    async execute(args, context) {
+        const projectRoot = context.worktree || context.directory;
+        const report = ["━━━ sdd_auto_healer ━━━"];
+        let detectedFile = args.targetFile;
+        // 1. Detectar archivo del log si no se provee
+        if (!detectedFile) {
+            const fileMatch = args.errorLogs.match(/([a-zA-Z0-9_\-./]+\.[a-zA-Z0-9]+)/i);
+            if (fileMatch) {
+                detectedFile = fileMatch[1];
+            }
+        }
+        if (!detectedFile) {
+            return `[SDD AutoHealer] No se pudo identificar ningún archivo objetivo del log de error. Omitiendo.`;
+        }
+        const fullPath = path.join(projectRoot, detectedFile);
+        if (!fs.existsSync(fullPath)) {
+            return `[SDD AutoHealer] El archivo detectado no existe en el disco: ${detectedFile}`;
+        }
+        try {
+            let content = fs.readFileSync(fullPath, "utf-8");
+            let modified = false;
+            // ── MÉTODOS DE AUTOCURACIÓN ESTÁNDAR ──
+            // 1. Corregir llaves/paréntesis sin cerrar simples al final de archivos JS/TS
+            if (args.errorLogs.includes("Unexpected end of input") || args.errorLogs.includes("Unclosed")) {
+                const openBraces = (content.match(/\{/g) || []).length;
+                const closeBraces = (content.match(/\}/g) || []).length;
+                if (openBraces > closeBraces) {
+                    content += "\n" + "}".repeat(openBraces - closeBraces);
+                    report.push(`✓ Autocurado: Se añadieron ${openBraces - closeBraces} llaves '}' faltantes al final del archivo.`);
+                    modified = true;
+                }
+                const openParens = (content.match(/\(/g) || []).length;
+                const closeParens = (content.match(/\)/g) || []).length;
+                if (openParens > closeParens) {
+                    content += "\n" + ")".repeat(openParens - closeParens);
+                    report.push(`✓ Autocurado: Se añadieron ${openParens - closeParens} paréntesis ')' faltantes al final del archivo.`);
+                    modified = true;
+                }
+            }
+            // 2. Resolver imports duplicados simples
+            if (args.errorLogs.includes("has already been declared") || args.errorLogs.includes("Duplicate identifier")) {
+                const lines = content.split("\n");
+                const seenImports = new Set();
+                const cleanedLines = lines.filter(line => {
+                    if (line.trim().startsWith("import ")) {
+                        if (seenImports.has(line.trim())) {
+                            report.push(`✓ Autocurado: Import duplicado eliminado de raíz: '${line.trim()}'`);
+                            modified = true;
+                            return false;
+                        }
+                        seenImports.add(line.trim());
+                    }
+                    return true;
+                });
+                if (modified) {
+                    content = cleanedLines.join("\n");
+                }
+            }
+            // 3. Corregir punto y coma faltante o errores de formato de JSON simples
+            if (detectedFile.endsWith(".json") && (args.errorLogs.includes("JSON") || args.errorLogs.includes("Unexpected token"))) {
+                // Eliminar comas colgantes simples al final de objetos JSON (trailing commas)
+                const repaired = content.replace(/,(\s*[\]}])/g, "$1");
+                if (repaired !== content) {
+                    content = repaired;
+                    report.push(`✓ Autocurado: Se removió una coma colgante en el archivo JSON.`);
+                    modified = true;
+                }
+            }
+            // 4. Guardar archivo si fue modificado
+            if (modified) {
+                fs.writeFileSync(fullPath, content, "utf-8");
+                report.push(`✓ Archivo '${detectedFile}' guardado y reparado de manera autónoma.`);
+                return report.join("\n");
+            }
+            return `[SDD AutoHealer] No se pudo encontrar un patrón de error auto-curable conocido para '${detectedFile}'.`;
+        }
+        catch (e) {
+            return `[SDD AutoHealer] Error intentando auto-curar archivo: ${e.message || e}`;
+        }
+    }
+});

package/.opencode/tools/sdd_transition.js

@@ -344,6 +344,70 @@ export default tool({
                     }
                 };
                 fs.appendFileSync(historyPath, JSON.stringify(logEntry) + "\n", "utf-8");
+                // GENERACIÓN AUTOMÁTICA DEL DASHBOARD DE ANALÍTICAS
+                try {
+                    const lines = fs.readFileSync(historyPath, "utf-8").split("\n").filter(Boolean);
+                    const historyEntries = lines.map(l => JSON.parse(l));
+                    let totalCost = 0;
+                    let totalInputTokens = 0;
+                    let totalOutputTokens = 0;
+                    const allModels = new Set();
+                    const phaseCounts = {};
+                    historyEntries.forEach(entry => {
+                        if (entry.analytics) {
+                            totalCost = Math.max(totalCost, entry.analytics.cumulative_cost_usd || 0);
+                            totalInputTokens = Math.max(totalInputTokens, entry.analytics.cumulative_tokens_input || 0);
+                            totalOutputTokens = Math.max(totalOutputTokens, entry.analytics.cumulative_tokens_output || 0);
+                            if (Array.isArray(entry.analytics.models_used)) {
+                                entry.analytics.models_used.forEach((m) => allModels.add(m));
+                            }
+                        }
+                        phaseCounts[entry.phase] = (phaseCounts[entry.phase] || 0) + 1;
+                    });
+                    // Crear barras visuales estéticas en consola Markdown
+                    const budgetLimit = 2.00; // Presupuesto sugerido de $2.00 USD
+                    const costPercentage = Math.min(100, Math.round((totalCost / budgetLimit) * 100));
+                    const barLength = 20;
+                    const filledLength = Math.round((costPercentage / 100) * barLength);
+                    const emptyLength = barLength - filledLength;
+                    const progressBar = "█".repeat(filledLength) + "░".repeat(emptyLength);
+                    const analyticsMarkdown = `# 📊 Tablero de Analíticas del Swarm: ${lockfile.change_name}
+
+Este reporte es generado de forma autónoma por la herramienta **sdd_transition** al cierre de cada fase para auditar la economía de tokens, presupuestos y eficiencia del enjambre multi-agente.
+
+> [!NOTE]
+> **Resumen Financiero de la Sesión:**
+> - **Presupuesto Consumido:** $${totalCost.toFixed(4)} USD
+> - **Límite de Presupuesto:** $${budgetLimit.toFixed(2)} USD
+> - **Eficiencia de Tokens:** Entrada: ${totalInputTokens.toLocaleString()} | Salida: ${totalOutputTokens.toLocaleString()}
+> - **Modelos Utilizados:** ${Array.from(allModels).join(", ") || "Ninguno registrado"}
+
+### 💳 Control de Presupuesto Consumido ($${totalCost.toFixed(4)} / $${budgetLimit.toFixed(2)})
+\`\`\`text
+[${progressBar}] ${costPercentage}% de límite
+\`\`\`
+
+## 🔄 Historial Completo del Swarm (Fases e Iteraciones)
+
+| Marca de Tiempo | Fase | Subagente | Estado | Iteración | Motivo |
+| :--- | :--- | :--- | :--- | :--- | :--- |
+${historyEntries.map(e => `| ${e.timestamp.split("T")[1].substring(0, 8)} | F${e.phase} | \`@${e.subagent}\` | \`${e.status}\` | ${e.iteration} | ${e.reason} |`).join("\n")}
+
+---
+
+## 📈 Estadísticas de Frecuencia de Fases
+- **Fase 0 (Explorer):** ${phaseCounts[0] || 0} visitas.
+- **Fase 1 (Planner):** ${phaseCounts[1] || 0} visitas.
+- **Fase 2 (Builder):** ${phaseCounts[2] || 0} visitas.
+- **Fase 3 (Tester):** ${phaseCounts[3] || 0} visitas.
+- **Fase 4 (Deployer):** ${phaseCounts[4] || 0} visitas.
+- **Fase 5 (Archiver):** ${phaseCounts[5] || 0} visitas.
+
+*Nota: Múltiples visitas a una misma fase indican reintentos o ciclos correctivos activos.*
+`;
+                    fs.writeFileSync(path.join(projectRoot, ".openspec/analytics.md"), analyticsMarkdown, "utf-8");
+                }
+                catch (err) { }
             }
         }
         // INTEGRACIÓN AUTOMÁTICA CON GIT

package/AGENTS.md

@@ -15,6 +15,7 @@ Queda terminantemente prohibido para cualquier agente del swarm (incluyendo al O
 - **No Trabajo en Caliente**: Está prohibido proponer código fuente, diseños HTML/CSS o parches técnicos directamente al usuario en el chat principal sin antes haber completado la **Fase 1 (Planificación e Interrogación)** y obtenido su visto bueno explícito.
 - **Rol del Orquestador**: `@zugzbot` debe educar siempre al usuario sobre el flujo de SDD cuando se solicite una nueva característica o cambio. Debe generar un **Roadmap de las 6 Fases de SDD de una línea por fase** y delegar la Fase 1 de inmediato.
 - **Flujo de Trabajo Estricto**: Todo cambio lógico debe iniciarse a través de la delegación estructurada hacia `@sdd-planner`.
+- **Slug Semántico del Cambio (kebab-case) [CRÍTICO]**: Al iniciar un ciclo (transición a Fase 1), el orquestador `@zugzbot` o `@sdd-planner` debe generar obligatoriamente un nombre de cambio (`changeName` o `change_name`) en kebab-case que describa de manera precisa el requerimiento del usuario (ej: `crear-modulo-auth` o `setup-clasp-mocker`). Queda terminantemente prohibido utilizar el valor genérico 'nuevo-cambio' o nombres sin relación semántica.
 
 ---
 

package/package.json

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

package/skills/sdd-secure-coding/SKILL.md

@@ -0,0 +1,51 @@
+# Skill: SDD Secure Coding (Threat Modeling & Sanitization)
+
+Esta habilidad impone directivas de codificación segura obligatorias para el enjambre de agentes en todas las fases de **Construcción (F2)** y **Calidad (F3)**, garantizando que el software desarrollado sea inherentemente inmune a vulnerabilidades de seguridad clásicas.
+
+## Trigger
+
+Se activa obligatoriamente al modificar código relacionado con:
+1. Entrada de texto o manipulación del DOM por parte del usuario (Forms, inputs, query params).
+2. Interacciones con bases de datos, APIs de persistencia o lectura/escritura de ficheros locales.
+3. Actualización de paquetes o importación de nuevas librerías.
+
+## Directivas de Seguridad del Swarm
+
+Todos los subagentes deben aplicar estrictamente las siguientes reglas operativas:
+
+### 1. Inmunización contra XSS (Cross-Site Scripting)
+Queda estrictamente prohibido inyectar HTML de forma directa en el DOM sin previa sanitización.
+* **Acción:** Utiliza siempre métodos nativos seguros de asignación como `textContent` o `innerText` en lugar de `innerHTML` o `dangerouslySetInnerHTML`.
+* Si es mandatorio renderizar HTML dinámico, pasa el contenido por un sanitizador de confianza (como `DOMPurify` o una función de escape robusta local):
+
+```javascript
+function escapeHTML(str) {
+  return str.replace(/[&<>'"]/g, 
+    tag => ({
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      "'": '&#39;',
+      '"': '&quot;'
+    }[tag] || tag)
+  );
+}
+```
+
+### 2. Parametrización Absoluta (SQL & Command Injections)
+Cualquier consulta a base de datos, llamada a bash o comandos de ejecución del sistema no debe concatenar strings de variables de usuario.
+* **Acción:** Utiliza queries preparadas (parameterized queries) o valida rigurosamente los parámetros antes de pasarlos a ejecutores dinámicos.
+
+### 3. Escaneo Pre-Commit de Secretos
+Ningún secreto, clave de API, tokens de autenticación o credenciales privadas de Git debe subirse a producción.
+* **Acción:** El `@sdd-tester` y `@sdd-archiver` deben auditar activamente las diferencias en Git (`git diff`) mediante patrones regex de entropía para detectar strings sospechosos.
+
+## Criterios de Aceptación (QA)
+
+- `[ ]` **Seguridad DOM:** Cero uso de asignaciones directas de HTML inseguras (`innerHTML`).
+- `[ ]` **Persistencia Limpia:** Todas las consultas externas utilizan interfaces tipadas o parametrizadas.
+- `[ ]` **Cero Secretos:** No se filtran API keys en el área de preparación de Git.
+
+## Tags
+
+#sdd #security #xss #sanitization #secrets #sql-injection #secure-coder

package/tools/index.ts

@@ -21,4 +21,5 @@ export { default as sdd_test_scaffold_generator } from './sdd_test_scaffold_gene
 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';
-export { default as gas_clasp_tools } from './gas_clasp_tools.js';
+export { default as gas_clasp_tools } from './gas_clasp_tools.js';
+export { default as sdd_auto_healer } from './sdd_auto_healer.js';

package/tools/sdd_archive_and_commit.ts

@@ -185,14 +185,36 @@ export default tool({
     }
 
     // 6. Archivar la carpeta físicamente (ANTES del commit para que quede registrado de forma atómica)
-    const archiveDir = path.join(projectRoot, ".openspec/changes/archive", `${dateStr}-${args.changeName}`)
+    // Calcular el siguiente prefijo de secuencia cronológica (ej: 0001_2026-05-30_143015)
+    let seqPrefix = "0001";
+    const archiveRoot = path.join(projectRoot, ".openspec/changes/archive");
+    if (fs.existsSync(archiveRoot)) {
+      try {
+        const dirs = fs.readdirSync(archiveRoot).filter(f => fs.statSync(path.join(archiveRoot, f)).isDirectory());
+        let maxSeq = 0;
+        dirs.forEach(d => {
+          const match = d.match(/^(\d{4})_/);
+          if (match) {
+            const seq = parseInt(match[1], 10);
+            if (seq > maxSeq) maxSeq = seq;
+          }
+        });
+        seqPrefix = String(maxSeq + 1).padStart(4, "0");
+      } catch (e) {}
+    }
+
+    const now = new Date();
+    const timeStr = now.toTimeString().split(" ")[0].replace(/:/g, ""); // e.g. "143015"
+    const archiveFolderName = `${seqPrefix}_${dateStr}_${timeStr}-${args.changeName}`;
+    const archiveDir = path.join(archiveRoot, archiveFolderName);
+
     try {
       if (fs.existsSync(archiveDir)) {
         fs.rmSync(archiveDir, { recursive: true, force: true })
       }
       fs.mkdirSync(path.dirname(archiveDir), { recursive: true })
       moveRecursive(changeDir, archiveDir)
-      report.push(`✓ Carpeta archivada en: .openspec/changes/archive/${dateStr}-${args.changeName}/`)
+      report.push(`✓ Carpeta archivada en: .openspec/changes/archive/${archiveFolderName}/`)
     } catch (e: any) {
       return `[SDD Archive Error] Error crítico archivando carpetas: ${e.message}`
     }

package/tools/sdd_auto_healer.ts

@@ -0,0 +1,102 @@
+import { tool } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+
+export default tool({
+  description: "Intenta corregir de forma autónoma errores sintácticos y de compilación simples (comillas rotas, llaves huérfanas, imports duplicados) en base a los logs de error del linter o compilador.",
+  args: {
+    errorLogs: tool.schema.string().describe("El log de error bruto del compilador o linter."),
+    targetFile: tool.schema.string().optional().describe("Archivo sugerido que contiene el error. Si no se provee, se detectará del log.")
+  },
+  async execute(args, context) {
+    const projectRoot = context.worktree || context.directory;
+    const report: string[] = ["━━━ sdd_auto_healer ━━━"];
+
+    let detectedFile = args.targetFile;
+
+    // 1. Detectar archivo del log si no se provee
+    if (!detectedFile) {
+      const fileMatch = args.errorLogs.match(/([a-zA-Z0-9_\-./]+\.[a-zA-Z0-9]+)/i);
+      if (fileMatch) {
+        detectedFile = fileMatch[1];
+      }
+    }
+
+    if (!detectedFile) {
+      return `[SDD AutoHealer] No se pudo identificar ningún archivo objetivo del log de error. Omitiendo.`;
+    }
+
+    const fullPath = path.join(projectRoot, detectedFile);
+    if (!fs.existsSync(fullPath)) {
+      return `[SDD AutoHealer] El archivo detectado no existe en el disco: ${detectedFile}`;
+    }
+
+    try {
+      let content = fs.readFileSync(fullPath, "utf-8");
+      let modified = false;
+
+      // ── MÉTODOS DE AUTOCURACIÓN ESTÁNDAR ──
+
+      // 1. Corregir llaves/paréntesis sin cerrar simples al final de archivos JS/TS
+      if (args.errorLogs.includes("Unexpected end of input") || args.errorLogs.includes("Unclosed")) {
+        const openBraces = (content.match(/\{/g) || []).length;
+        const closeBraces = (content.match(/\}/g) || []).length;
+        if (openBraces > closeBraces) {
+          content += "\n" + "}".repeat(openBraces - closeBraces);
+          report.push(`✓ Autocurado: Se añadieron ${openBraces - closeBraces} llaves '}' faltantes al final del archivo.`);
+          modified = true;
+        }
+
+        const openParens = (content.match(/\(/g) || []).length;
+        const closeParens = (content.match(/\)/g) || []).length;
+        if (openParens > closeParens) {
+          content += "\n" + ")".repeat(openParens - closeParens);
+          report.push(`✓ Autocurado: Se añadieron ${openParens - closeParens} paréntesis ')' faltantes al final del archivo.`);
+          modified = true;
+        }
+      }
+
+      // 2. Resolver imports duplicados simples
+      if (args.errorLogs.includes("has already been declared") || args.errorLogs.includes("Duplicate identifier")) {
+        const lines = content.split("\n");
+        const seenImports = new Set<string>();
+        const cleanedLines = lines.filter(line => {
+          if (line.trim().startsWith("import ")) {
+            if (seenImports.has(line.trim())) {
+              report.push(`✓ Autocurado: Import duplicado eliminado de raíz: '${line.trim()}'`);
+              modified = true;
+              return false;
+            }
+            seenImports.add(line.trim());
+          }
+          return true;
+        });
+        if (modified) {
+          content = cleanedLines.join("\n");
+        }
+      }
+
+      // 3. Corregir punto y coma faltante o errores de formato de JSON simples
+      if (detectedFile.endsWith(".json") && (args.errorLogs.includes("JSON") || args.errorLogs.includes("Unexpected token"))) {
+        // Eliminar comas colgantes simples al final de objetos JSON (trailing commas)
+        const repaired = content.replace(/,(\s*[\]}])/g, "$1");
+        if (repaired !== content) {
+          content = repaired;
+          report.push(`✓ Autocurado: Se removió una coma colgante en el archivo JSON.`);
+          modified = true;
+        }
+      }
+
+      // 4. Guardar archivo si fue modificado
+      if (modified) {
+        fs.writeFileSync(fullPath, content, "utf-8");
+        report.push(`✓ Archivo '${detectedFile}' guardado y reparado de manera autónoma.`);
+        return report.join("\n");
+      }
+
+      return `[SDD AutoHealer] No se pudo encontrar un patrón de error auto-curable conocido para '${detectedFile}'.`;
+    } catch (e: any) {
+      return `[SDD AutoHealer] Error intentando auto-curar archivo: ${e.message || e}`;
+    }
+  }
+})

package/tools/sdd_transition.ts

@@ -358,6 +358,74 @@ export default tool({
           }
         };
         fs.appendFileSync(historyPath, JSON.stringify(logEntry) + "\n", "utf-8");
+
+        // GENERACIÓN AUTOMÁTICA DEL DASHBOARD DE ANALÍTICAS
+        try {
+          const lines = fs.readFileSync(historyPath, "utf-8").split("\n").filter(Boolean);
+          const historyEntries = lines.map(l => JSON.parse(l));
+          
+          let totalCost = 0;
+          let totalInputTokens = 0;
+          let totalOutputTokens = 0;
+          const allModels = new Set<string>();
+          const phaseCounts: { [key: number]: number } = {};
+          
+          historyEntries.forEach(entry => {
+            if (entry.analytics) {
+              totalCost = Math.max(totalCost, entry.analytics.cumulative_cost_usd || 0);
+              totalInputTokens = Math.max(totalInputTokens, entry.analytics.cumulative_tokens_input || 0);
+              totalOutputTokens = Math.max(totalOutputTokens, entry.analytics.cumulative_tokens_output || 0);
+              if (Array.isArray(entry.analytics.models_used)) {
+                entry.analytics.models_used.forEach((m: string) => allModels.add(m));
+              }
+            }
+            phaseCounts[entry.phase] = (phaseCounts[entry.phase] || 0) + 1;
+          });
+
+          // Crear barras visuales estéticas en consola Markdown
+          const budgetLimit = 2.00; // Presupuesto sugerido de $2.00 USD
+          const costPercentage = Math.min(100, Math.round((totalCost / budgetLimit) * 100));
+          const barLength = 20;
+          const filledLength = Math.round((costPercentage / 100) * barLength);
+          const emptyLength = barLength - filledLength;
+          const progressBar = "█".repeat(filledLength) + "░".repeat(emptyLength);
+
+          const analyticsMarkdown = `# 📊 Tablero de Analíticas del Swarm: ${lockfile.change_name}
+
+Este reporte es generado de forma autónoma por la herramienta **sdd_transition** al cierre de cada fase para auditar la economía de tokens, presupuestos y eficiencia del enjambre multi-agente.
+
+> [!NOTE]
+> **Resumen Financiero de la Sesión:**
+> - **Presupuesto Consumido:** $${totalCost.toFixed(4)} USD
+> - **Límite de Presupuesto:** $${budgetLimit.toFixed(2)} USD
+> - **Eficiencia de Tokens:** Entrada: ${totalInputTokens.toLocaleString()} | Salida: ${totalOutputTokens.toLocaleString()}
+> - **Modelos Utilizados:** ${Array.from(allModels).join(", ") || "Ninguno registrado"}
+
+### 💳 Control de Presupuesto Consumido ($${totalCost.toFixed(4)} / $${budgetLimit.toFixed(2)})
+\`\`\`text
+[${progressBar}] ${costPercentage}% de límite
+\`\`\`
+
+## 🔄 Historial Completo del Swarm (Fases e Iteraciones)
+
+| Marca de Tiempo | Fase | Subagente | Estado | Iteración | Motivo |
+| :--- | :--- | :--- | :--- | :--- | :--- |
+${historyEntries.map(e => `| ${e.timestamp.split("T")[1].substring(0, 8)} | F${e.phase} | \`@${e.subagent}\` | \`${e.status}\` | ${e.iteration} | ${e.reason} |`).join("\n")}
+
+---
+
+## 📈 Estadísticas de Frecuencia de Fases
+- **Fase 0 (Explorer):** ${phaseCounts[0] || 0} visitas.
+- **Fase 1 (Planner):** ${phaseCounts[1] || 0} visitas.
+- **Fase 2 (Builder):** ${phaseCounts[2] || 0} visitas.
+- **Fase 3 (Tester):** ${phaseCounts[3] || 0} visitas.
+- **Fase 4 (Deployer):** ${phaseCounts[4] || 0} visitas.
+- **Fase 5 (Archiver):** ${phaseCounts[5] || 0} visitas.
+
+*Nota: Múltiples visitas a una misma fase indican reintentos o ciclos correctivos activos.*
+`;
+          fs.writeFileSync(path.join(projectRoot, ".openspec/analytics.md"), analyticsMarkdown, "utf-8");
+        } catch (err) {}
       }
     }