zugzbot-sdd 1.5.13 → 1.5.15

package/.opencode/plugins/plugin_sdd_core.ts

@@ -0,0 +1,54 @@
+import type { Plugin } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+
+export const SddCorePlugin: Plugin = async ({ project, client, $, directory, worktree }) => {
+  return {
+    "experimental.session.compacting": async (input, output) => {
+      const projectRoot = worktree || directory;
+      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);
+
+      let lockInfo = "No active change or SDD phase detected.";
+      let amnesiaInstruction = "";
+
+      if (activeLockPath) {
+        try {
+          const lockObj = JSON.parse(fs.readFileSync(activeLockPath, "utf-8"));
+          lockInfo = `
+### SDD SWARM ACTIVE STATUS (DO NOT FORGET)
+- Active Change: \`${lockObj.change_name || "Ninguno"}\`
+- Active Phase: \`${lockObj.active_phase ?? 0}\` (@${lockObj.active_subagent || "sdd-planner"})
+- Status: \`${lockObj.status || "idle"}\`
+- Iteration: \`${lockObj.iteration || 0}\`
+- Last Updated: \`${lockObj.last_updated || ""}\`
+- Complexity: \`${lockObj.complexity || "high"}\`
+`;
+
+          // Si ya estamos en Fase 2 (Construcción) o posterior, instruimos al compactador a purgar todo el chat del planner anterior
+          if (lockObj.active_phase >= 2) {
+            amnesiaInstruction = `
+5. AMNESIA DE PLANIFICACIÓN [CRÍTICO]: Since we are already in Phase ${lockObj.active_phase} (Implementation/Closure) and the technical spec is approved, you MUST completely purge all conversational Q&A and planning discussions from Phase 1. Condense all Phase 1 conversations into a single high-density status line (e.g. "[Phase 1 Q&A resolved. Spec approved: see specs/spec.md]"). Focus 100% of the active context on code files, logical edits, and test validation logs.`;
+          }
+        } catch (e) {}
+      }
+
+      // 1. Inyectar estado activo en el contexto de compactación para preservar memoria metodológica
+      output.context.push(lockInfo);
+
+      // 2. Personalizar el prompt de compactación para recortar logs redundantes de terminal y discusiones previas de planificación
+      output.prompt = `
+You are generating a highly condensed continuation prompt for an active Spec-Driven Development (SDD) multi-agent session.
+
+To maximize token savings and avoid long latency, you MUST:
+1. Summarize any long command terminal output, compiler errors, or test logs into a single high-density line (e.g., "[Linter: 3 syntax errors resolved in auth.ts]" or "[Vitest: 12 tests passed, 0 failed in 1.2s]"). Do NOT repeat full traceback logs.
+2. Keep the current task status, active file modifications, and direct goals in a concise, bulleted list.
+3. Keep the active SDD phase and change name verbatim.
+4. Keep the overall continuation prompt extremely brief (under 15 lines if possible).${amnesiaInstruction}
+`;
+    }
+  }
+}
+
+export default SddCorePlugin;

package/.opencode/plugins/plugin_tui.tsx

@@ -0,0 +1,319 @@
+/** @jsxImportSource @opentui/solid */
+import type { TuiPlugin, TuiPluginModule } from "@opencode-ai/plugin/tui"
+import { createSignal, onCleanup } from "solid-js"
+import fs from "fs"
+import path from "path"
+
+const PluginTuiSidebar: TuiPlugin = async (api) => {
+  api.slots.register({
+    order: 100,
+    slots: {
+      sidebar_content(_ctx, props: { session_id: string; children?: any }) {
+        // --- Estado reactivo y Polling de IDs de Sesión ---
+        const [sessionIds, setSessionIds] = createSignal<string[]>([props.session_id])
+
+        // --- Helper para leer el progreso SDD ---
+        const getSddProgress = () => {
+          try {
+            const lockPath = path.join(process.cwd(), ".openspec/sdd-lock.json")
+            const altPath = path.join(process.cwd(), "openspec/sdd-lock.json")
+            const actualPath = fs.existsSync(lockPath) ? lockPath : (fs.existsSync(altPath) ? altPath : null)
+            
+            if (actualPath) {
+              const data = JSON.parse(fs.readFileSync(actualPath, "utf-8"))
+              return {
+                changeName: data.change_name || "Ninguno",
+                activePhase: typeof data.active_phase === "number" ? data.active_phase : 0,
+                status: data.status || "idle",
+              }
+            }
+          } catch (e) { }
+          return null
+        }
+
+        // Función para actualizar recursivamente la lista de sesión IDs usando api.client
+        const updateSessionIds = async () => {
+          try {
+            const results: string[] = []
+            const visited = new Set<string>()
+
+            async function traverse(sid: string) {
+              if (!sid || visited.has(sid)) return
+              visited.add(sid)
+              results.push(sid)
+
+              try {
+                const response = await api.client.session.children({ sessionID: sid })
+                const children = Array.isArray(response) ? response : (response?.data || [])
+                for (const child of children) {
+                  const childId = child?.id
+                  if (childId) {
+                    await traverse(childId)
+                  }
+                }
+              } catch { }
+            }
+
+            await traverse(props.session_id)
+
+            // Solo actualizamos el signal si el conjunto de IDs cambió, para evitar re-renderizados innecesarios
+            if (JSON.stringify(results) !== JSON.stringify(sessionIds())) {
+              setSessionIds(results)
+            }
+          } catch { }
+        }
+
+        function extractAgentName(messages: any[], sessionInfo: any, sessionId: string): string {
+          const userMsg = messages.find((m) => m.role === "user")
+          if (userMsg && "agent" in userMsg && userMsg.agent) {
+            return userMsg.agent
+          }
+          if (sessionInfo?.title) {
+            return sessionInfo.title
+          }
+          return `Sesión ${sessionId.slice(0, 4)}`
+        }
+
+        function formatCost(cost: number): string {
+          if (cost === 0) return "$0"
+          if (cost < 0.001) return "$" + cost.toFixed(4)
+          return "$" + cost.toFixed(3)
+        }
+
+        function formatTokens(num: number): string {
+          if (num >= 1000000) return Math.round(num / 1000000) + "M"
+          if (num >= 1000) return Math.round(num / 1000) + "k"
+          return num.toString()
+        }
+
+        interface AgentMetrics {
+          name: string
+          cost: number
+          tokensInput: number
+          tokensOutput: number
+          isSubagent: boolean
+        }
+
+        interface TotalMetrics {
+          agents: AgentMetrics[]
+          totalCost: number
+          totalInput: number
+          totalOutput: number
+        }
+
+        function getMetrics(currentSessionIds: string[]): TotalMetrics {
+          let totalCost = 0
+          let totalInput = 0
+          let totalOutput = 0
+
+          const agentMap: Record<string, AgentMetrics> = {}
+
+          for (const sid of currentSessionIds) {
+            const isSubagent = sid !== props.session_id
+            let messages: any[] = []
+            try {
+              messages = api.state.session.messages(sid) || []
+            } catch { }
+
+            let sessionInfo: any = null
+            try {
+              sessionInfo = api.state.session.get?.(sid)
+            } catch { }
+
+            const defaultAgentName = extractAgentName(messages, sessionInfo, sid)
+
+            for (let i = 0; i < messages.length; i++) {
+              const msg = messages[i]
+              if (msg.role === "assistant" && "cost" in msg) {
+                const cost = typeof msg.cost === "number" && Number.isFinite(msg.cost) ? msg.cost : 0
+                const input = msg.tokens?.input ?? 0
+                const output = msg.tokens?.output ?? 0
+
+                totalCost += cost
+                totalInput += input
+                totalOutput += output
+
+                let agentName = ""
+                if (msg.agent) {
+                  agentName = msg.agent
+                } else {
+                  for (let j = i; j >= 0; j--) {
+                    if (messages[j]?.agent) {
+                      agentName = messages[j].agent
+                      break
+                    }
+                  }
+                }
+
+                if (!agentName) {
+                  agentName = defaultAgentName
+                }
+
+                if (!agentMap[agentName]) {
+                  agentMap[agentName] = {
+                    name: agentName,
+                    cost: 0,
+                    tokensInput: 0,
+                    tokensOutput: 0,
+                    isSubagent: isSubagent,
+                  }
+                }
+
+                agentMap[agentName].cost += cost
+                agentMap[agentName].tokensInput += input
+                agentMap[agentName].tokensOutput += output
+              }
+            }
+
+            if (!agentMap[defaultAgentName]) {
+              agentMap[defaultAgentName] = {
+                name: defaultAgentName,
+                cost: 0,
+                tokensInput: 0,
+                tokensOutput: 0,
+                isSubagent: isSubagent,
+              }
+            }
+          }
+
+          const agents = Object.values(agentMap)
+
+          return {
+            agents,
+            totalCost,
+            totalInput,
+            totalOutput,
+          }
+        }
+
+        // --- Estado reactivo y Polling ---
+        const [metrics, setMetrics] = createSignal<TotalMetrics>(getMetrics([props.session_id]))
+        const [sddProgress, setSddProgress] = createSignal<{ changeName: string; activePhase: number; status: string } | null>(getSddProgress())
+        const [colorIndex, setColorIndex] = createSignal(0)
+
+        // Actualizamos los IDs de las sesiones cada 2 segundos
+        const idsInterval = setInterval(() => {
+          updateSessionIds()
+          setSddProgress(getSddProgress())
+        }, 2000)
+
+        // Actualizamos las métricas cada segundo basadas en el signal de sesión IDs
+        const metricsInterval = setInterval(() => {
+          setMetrics(getMetrics(sessionIds()))
+        }, 1000)
+
+        // Ticker lento para una animación de ola vertical suave
+        const colorInterval = setInterval(() => {
+          setColorIndex((prev) => (prev + 1) % 100)
+        }, 500)
+
+        // Paleta premium de naranjas fuertes, ámbar y cobrizos
+        const orangePalette = [
+          "#E04F00", // Naranjo oscuro / Fuego
+          "#FF7300", // Naranjo brillante / Ámbar
+          "#B33600", // Siena tostado / Óxido
+          "#FF8C00", // Ámbar oscuro
+        ]
+
+        const getLineColor = (lineIdx: number) => {
+          const targetIndex = (colorIndex() + lineIdx) % orangePalette.length
+          return orangePalette[targetIndex]
+        }
+
+        const logoLines = [
+          "███████╗██╗   ██╗ ██████╗ ███████╗",
+          "╚══███╔╝██║   ██║██╔════╝ ╚══███╔╝",
+          "  ███╔╝ ██║   ██║██║  ███╗  ███╔╝ ",
+          " ███╔╝  ██║   ██║██║   ██║ ███╔╝  ",
+          "███████╗╚██████╔╝╚██████╔╝███████╗",
+          "╚══════╝ ╚═════╝  ╚═════╝ ╚══════╝"
+        ]
+
+        // Ejecutar inmediatamente al inicio
+        updateSessionIds()
+        setSddProgress(getSddProgress())
+
+        onCleanup(() => {
+          clearInterval(idsInterval)
+          clearInterval(metricsInterval)
+          clearInterval(colorInterval)
+        })
+
+        return (
+          <box gap={0}>
+            {/* Cabecera Logo ZUGZ con Efecto Ola Vertical Naranja */}
+            <box gap={0} paddingTop={1} paddingLeft={1}>
+              {logoLines.map((line, idx) => (
+                <text fg={getLineColor(idx)}>
+                  {line}
+                </text>
+              ))}
+            </box>
+
+            {/* Componente Visual de Progreso SDD de 3 Fases */}
+            {sddProgress() && (
+              <box gap={0} paddingLeft={1} paddingTop={1} paddingBottom={0}>
+                <text fg="#FF7300">
+                  {`SDD: ${sddProgress()?.changeName ?? ""}`}
+                </text>
+                <box gap={0} paddingTop={1}>
+                  {[
+                    { id: 0, name: "F0 Exploración", agent: "@sdd-explorer" },
+                    { id: 1, name: "F1 Planificación", agent: "@sdd-planner" },
+                    { id: 2, name: "F2 Construcción", agent: "@sdd-builder" },
+                    { id: 3, name: "F3 Pruebas", agent: "@sdd-tester" },
+                    { id: 4, name: "F4 Deploy", agent: "@sdd-deployer" },
+                    { id: 5, name: "F5 Cierre", agent: "@sdd-archiver" }
+                  ].map((ph) => {
+                    const isActive = sddProgress()?.activePhase === ph.id
+                    const isCompleted = (sddProgress()?.activePhase ?? 0) > ph.id
+                    
+                    let prefix = "  ○ "
+                    let fgColor = api.theme.current.textMuted
+                    
+                    if (isCompleted) {
+                      prefix = "  ✓ "
+                      fgColor = api.theme.current.success
+                    } else if (isActive) {
+                      prefix = "  ⚡ "
+                      fgColor = "#FF7300"
+                    }
+                    
+                    return (
+                      <text fg={fgColor}>
+                        {`${prefix}${ph.name} ${ph.agent}`}
+                      </text>
+                    )
+                  })}
+                </box>
+                <text fg={api.theme.current.borderSubtle} paddingTop={1}>
+                  {"────────────────────────────────────"}
+                </text>
+              </box>
+            )}
+
+            {/* Monitor de Agentes Compacto y Plano (Efecto Sándwich) */}
+            <box gap={0} paddingLeft={1} paddingTop={1} paddingBottom={0}>
+              {metrics().agents.map((agent) => (
+                <text fg={agent.isSubagent ? api.theme.current.textMuted : api.theme.current.text}>
+                  {`${agent.isSubagent ? "  " : ""}${agent.name}: ${formatCost(agent.cost)} (${formatTokens(agent.tokensInput)}/${formatTokens(agent.tokensOutput)})`}
+                </text>
+              ))}
+              <text fg={api.theme.current.borderSubtle}>
+                {"────────────────────────────────────"}
+              </text>
+              <text fg={api.theme.current.success}>
+                {`Total: ${formatCost(metrics().totalCost)} (${formatTokens(metrics().totalInput)}/${formatTokens(metrics().totalOutput)})`}
+              </text>
+            </box>
+
+            {/* Chat original de OpenCode */}
+            {props.children}
+          </box>
+        )
+      }
+    }
+  })
+}
+
+export default { id: "plugin_tui", tui: PluginTuiSidebar } satisfies TuiPluginModule & { id: string }

package/.opencode/skills/sdd-dependency-cooldown/SKILL.md

@@ -0,0 +1,40 @@
+# Skill: Dependency Cooldown Checker
+
+Verifica que las dependencias tengan al menos **3 días** de publicadas antes de ser importadas.
+
+## Trigger
+
+Cuando se requiera agregar una nueva dependencia npm, antes de cualquier `import` o `require`.
+
+## Uso
+
+```bash
+npx -y npm-check-updates <package-name> --dep prod
+# o verificar en https://www.npmjs.com/package/<package-name>
+```
+
+## Regla SDD Cooldown
+
+| Tipo | Tiempo mínimo |
+|:---|:---|
+| Dependencias nuevas | 3 días desde publicación |
+| Updates mayores (major) | 7 días |
+| Dependencias критични (security) | Sin cooldown |
+
+## Verificación Manual
+
+1. Ir a https://www.npmjs.com/package/<nombre-paquete>
+2. Buscar "Published" en la sección de metadata
+3. Calcular días desde publicación
+4. Si >= 3 días, APPROVED
+5. Si < 3 días, WAIT con fecha de aprobación
+
+## Criterios de Bloqueo
+
+- ❌ Paquetes con < 3 días
+- ❌ Paquetes sin downloads recientes (posible abandonware)
+- ❌ Paquetes con vulnerabilities conocidas sin fix
+
+## Tags
+
+#sdd #dependency #npm #cooldown

package/.opencode/skills/sdd-tree-generator/SKILL.md

@@ -0,0 +1,40 @@
+# Skill: SDD Tree Generator
+
+Genera un árbol de estructura del proyecto en milisegundos sin costo de tokens.
+
+## Trigger
+
+Cuando se requiera visualizar la estructura de archivos del proyecto.
+
+## Uso
+
+```bash
+node .opencode/tools/sdd_generate_tree.js
+```
+
+O desde OpenCode usando la herramienta `sdd_generate_tree`.
+
+## Output
+
+```
+proyecto/
+├── src/
+│   ├── components/
+│   │   └── Button.tsx
+│   └── index.ts
+├── tests/
+│   └── unit/
+├── package.json
+└── README.md
+```
+
+## Características
+
+- Profundidad máxima: 3 niveles
+- Ignora: node_modules, .git, archivos ocultos
+- Muestra tamaño de archivos
+- Ejecución en < 100ms
+
+## Tags
+
+#sdd #tooling #tree #structure

package/.opencode/tools/brain-utils.js

@@ -0,0 +1,112 @@
+import fs from "fs";
+import path from "path";
+export function today() {
+    return new Date().toISOString().split("T")[0];
+}
+export function nextId(entries) {
+    let max = 0;
+    for (const e of entries) {
+        const num = parseInt(e.id.substring(1), 10);
+        if (!isNaN(num) && num > max)
+            max = num;
+    }
+    return `L${String(max + 1).padStart(3, "0")}`;
+}
+export function parseEntries(content) {
+    const entries = [];
+    const blocks = content.split("\n### ");
+    for (const block of blocks) {
+        if (!block.trim())
+            continue;
+        const lines = block.split("\n");
+        const header = lines[0].trim();
+        const colonIdx = header.indexOf(": ");
+        if (colonIdx === -1)
+            continue;
+        const id = header.substring(0, colonIdx).trim();
+        if (!id || !/^L\d{3}$/.test(id))
+            continue;
+        const tag = header.substring(colonIdx + 2).trim();
+        if (!tag)
+            continue;
+        let category = "";
+        let problem = "";
+        let solution = "";
+        let date = "";
+        for (const line of lines) {
+            const t = line.trim();
+            if (t.startsWith("- **Tags**:")) {
+                const m = t.match(/#(\w+)/);
+                if (m)
+                    category = m[1];
+            }
+            else if (t.startsWith("- **Problema**:")) {
+                problem = t.substring("- **Problema**: ".length).trim();
+            }
+            else if (t.startsWith("- **Solución**:")) {
+                solution = t.substring("- **Solución**: ".length).trim();
+            }
+            else if (t.startsWith("- **Fecha**:")) {
+                date = t.substring("- **Fecha**: ".length).trim();
+            }
+        }
+        if (id && problem) {
+            entries.push({ id, category, tag, problem, solution, date: date || today() });
+        }
+    }
+    return entries;
+}
+export function buildIndex(entries) {
+    if (entries.length === 0)
+        return "_No hay lecciones registradas todavía._";
+    const header = "| ID | Categoría | Tag | Problema |\n| :--- | :--- | :--- | :--- |\n";
+    const rows = entries.map(e => {
+        const problemTrunc = e.problem.length > 55 ? e.problem.slice(0, 52) + "..." : e.problem;
+        return `| ${e.id} | ${e.category || "-"} | ${e.tag} | ${problemTrunc} |`;
+    }).join("\n");
+    return header + rows;
+}
+export function buildEntryBlock(e) {
+    const tags = `#${e.category || "general"} #${e.tag.replace(/[-\s]/g, "_")}`;
+    return [
+        `### ${e.id}: ${e.tag}`,
+        `- **Tags**: ${tags}`,
+        `- **Problema**: ${e.problem}`,
+        `- **Solución**: ${e.solution}`,
+        `- **Fecha**: ${e.date}`,
+    ].join("\n") + "\n";
+}
+export function buildFullBrain(entries) {
+    const lines = [
+        "# 🧠 Cerebro del Proyecto",
+        "",
+        "> Base de conocimiento técnico a largo plazo. Solo registra aprendizajes de alto valor y no triviales.",
+        "",
+        "## Índice",
+        "",
+        buildIndex(entries),
+        "",
+        "## Lecciones",
+        "",
+    ];
+    for (const e of entries) {
+        lines.push(buildEntryBlock(e));
+    }
+    return lines.join("\n");
+}
+export function readBrainFile(brainPath) {
+    if (!fs.existsSync(brainPath)) {
+        return { entries: [] };
+    }
+    const content = fs.readFileSync(brainPath, "utf-8");
+    const leccionesIdx = content.indexOf("## Lecciones");
+    const leccionesContent = leccionesIdx >= 0
+        ? content.substring(leccionesIdx)
+        : content;
+    const entries = parseEntries(leccionesContent);
+    return { entries };
+}
+export function writeBrainFile(brainPath, entries) {
+    fs.mkdirSync(path.dirname(brainPath), { recursive: true });
+    fs.writeFileSync(brainPath, buildFullBrain(entries), "utf-8");
+}

package/.opencode/tools/check_dependency_cooldown.js

@@ -0,0 +1,121 @@
+import { tool } from "@opencode-ai/plugin";
+export default tool({
+    description: "Audita programáticamente si una dependencia de terceros cumple con la regla de estabilidad y seguridad de cooldown (mínimo 3 días / 4320 minutos de antigüedad). Consulta APIs reales de NPM y PyPI.",
+    args: {
+        package: tool.schema.string().describe("Nombre del paquete o dependencia (ej: 'lodash', 'fastapi')"),
+        version: tool.schema.string().optional().describe("Versión del paquete a auditar. Si no se especifica, audita la última versión."),
+        ecosystem: tool.schema.enum(["npm", "pypi"]).optional().describe("El ecosistema del paquete. Por defecto se infiere del stack.")
+    },
+    async execute(args) {
+        const pkg = args.package;
+        let targetVersion = args.version;
+        let eco = args.ecosystem;
+        // Inferir ecosistema si no está presente
+        if (!eco) {
+            if (pkg.startsWith("@") || pkg.includes("/") || pkg === "lodash" || pkg === "axios" || pkg === "express") {
+                eco = "npm";
+            }
+            else {
+                // Enfoque por defecto: intentar NPM primero, luego PyPI
+                eco = "npm";
+            }
+        }
+        try {
+            if (eco === "npm") {
+                const url = `https://registry.npmjs.org/${encodeURIComponent(pkg)}`;
+                const res = await fetch(url);
+                if (!res.ok) {
+                    // Si falla NPM, chequear si es PyPI
+                    if (!args.ecosystem) {
+                        return await checkPyPI(pkg, targetVersion);
+                    }
+                    return `[Cooldown Blocked] Error: No se encontró el paquete '${pkg}' en NPM.`;
+                }
+                const data = await res.json();
+                // Obtener última versión si no se provee
+                if (!targetVersion) {
+                    targetVersion = data["dist-tags"]?.latest;
+                }
+                if (!targetVersion) {
+                    return `[Cooldown Blocked] Error: No se pudo resolver la versión para el paquete '${pkg}' en NPM.`;
+                }
+                const publishTimeString = data.time?.[targetVersion];
+                if (!publishTimeString) {
+                    return `[Cooldown Blocked] Error: No se encontró la versión '${targetVersion}' para '${pkg}' en NPM.`;
+                }
+                return evaluateCooldown(pkg, targetVersion, publishTimeString, "NPM");
+            }
+            else {
+                return await checkPyPI(pkg, targetVersion);
+            }
+        }
+        catch (e) {
+            return `[Cooldown Warning] Error al consultar la API de dependencias: ${e.message || e}. Por seguridad, verifica manualmente.`;
+        }
+    }
+});
+async function checkPyPI(pkg, targetVersion) {
+    try {
+        const url = `https://pypi.org/pypi/${encodeURIComponent(pkg)}/json`;
+        const res = await fetch(url);
+        if (!res.ok) {
+            return `[Cooldown Blocked] Error: No se encontró el paquete '${pkg}' en NPM ni PyPI.`;
+        }
+        const data = await res.json();
+        // Resolver versión
+        const version = targetVersion || data.info?.version;
+        if (!version) {
+            return `[Cooldown Blocked] Error: No se pudo resolver la versión para '${pkg}' en PyPI.`;
+        }
+        const releases = data.releases?.[version];
+        if (!releases || releases.length === 0) {
+            return `[Cooldown Blocked] Error: No se encontró la versión '${version}' para '${pkg}' en PyPI.`;
+        }
+        // PyPI expone fecha de subida del primer archivo
+        const uploadTime = releases[0]?.upload_time_iso_8601 || releases[0]?.upload_time;
+        if (!uploadTime) {
+            return `[Cooldown Blocked] Error: No se encontró fecha de publicación para '${pkg}@${version}' en PyPI.`;
+        }
+        return evaluateCooldown(pkg, version, uploadTime, "PyPI");
+    }
+    catch (e) {
+        return `[Cooldown Blocked] Error de conexión con PyPI: ${e.message || e}`;
+    }
+}
+function evaluateCooldown(pkg, version, publishTimeStr, registryName) {
+    const publishTime = new Date(publishTimeStr);
+    const now = new Date();
+    const diffMs = now.getTime() - publishTime.getTime();
+    const diffMinutes = Math.floor(diffMs / (1000 * 60));
+    const cooldownRequired = 4320; // 3 días en minutos
+    const publishDateStr = publishTime.toISOString().split('T')[0];
+    if (diffMinutes < cooldownRequired) {
+        const remainingMinutes = cooldownRequired - diffMinutes;
+        const remainingHours = Math.ceil(remainingMinutes / 60);
+        const remainingDays = (remainingMinutes / 1440).toFixed(1);
+        return JSON.stringify({
+            status: "BLOCKED",
+            package: pkg,
+            version: version,
+            registry: registryName,
+            publishDate: publishDateStr,
+            ageMinutes: diffMinutes,
+            ageDays: (diffMinutes / 1440).toFixed(1),
+            cooldownMinutesRequired: cooldownRequired,
+            message: `❌ COOLDOWN BLOQUEADO: El paquete '${pkg}@${version}' fue publicado hace solo ${(diffMinutes / 1440).toFixed(1)} días (${diffMinutes} minutos) el ${publishDateStr}. Requiere superar los 3 días de estabilidad. Faltan aproximadamente ${remainingDays} días (${remainingHours} horas) para que expire el cooldown.`
+        }, null, 2);
+    }
+    else {
+        return JSON.stringify({
+            status: "APPROVED",
+            package: pkg,
+            version: version,
+            registry: registryName,
+            publishDate: publishDateStr,
+            ageMinutes: diffMinutes,
+            ageDays: (diffMinutes / 1440).toFixed(1),
+            cooldownMinutesRequired: cooldownRequired,
+            message: `✅ COOLDOWN APROBADO: El paquete '${pkg}@${version}' fue publicado el ${publishDateStr} (hace ${(diffMinutes / 1440).toFixed(1)} días). Cumple plenamente con la regla de estabilidad mínima de 3 días.`
+        }, null, 2);
+    }
+}