zugzbot 1.5.0 → 1.7.0

package/.opencode/agents/sdd-tester.md

@@ -68,12 +68,7 @@ Eres el Validador de Contratos (sdd-tester) del flujo SDD. Tu trabajo es ejecuta
 - **Auto-generación de Plantillas (OBLIGATORIO)**: Al comenzar, ejecuta obligatoriamente `sdd_generate_tests` para autogenerar las plantillas a partir de los `test_scenarios` del contrato. Las plantillas ya incluyen imports reales, mocks estándar (Proxy lucide-react, mock reactivo next-themes), y assertions significativas basadas en el `then` de cada escenario. NO las reescribas desde cero.
 - **NO explorar el código**: Tu brief ya contiene los archivos de producción a testear y los patrones de mock pre-armados. NO hagas `read` masivos de componentes, NO hagas `glob` ciegos. Solo lee el archivo de test específico que estés arreglando.
 - **Preparación de Puerto**: Llama proactivamente a `sdd_free_port` para liberar el puerto de pruebas.
-- **Ejecución Incremental/Dirigida**: Ejecuta la suite de pruebas de forma focalizada apuntando únicamente a los archivos de test específicos relacionados con la funcionalidad modificada (ej. `npx vitest run src/__tests__/<test_name>.test.tsx` o `pytest tests/unit/<test_name>.py` en lugar de correr toda la base de pruebas), acelerando exponencialmente los tiempos de espera.
-- **Timeout duro OBLIGATORIO**: SIEMPRE ejecuta vitest con `--testTimeout=10000 --bail=1` para fallar rápido en el primer error. NUNCA ejecutes `vitest` sin estos flags. Esto previene cuelgues infinitos por imports circulares o chains de Providers que happy-dom no puede resolver.
-  ```bash
-  npx vitest run --testTimeout=10000 --bail=1 --reporter=verbose src/__tests__/<file>.test.tsx
-  ```
-  Si el comando excede 60 segundos, ABORTA inmediatamente y reporta el cuelgue. NO esperes más de 1 minuto bajo ninguna circunstancia.
+- **Ejecución Incremental/Dirigida (Uso Mandatorio de Tool de Tests)**: Para ejecutar la suite de pruebas de forma focalizada ahorrando una enorme cantidad de tokens de logs de consola, **DEBES** utilizar la herramienta `sdd_run_tests({ file: "src/__tests__/<test_name>.test.tsx" })` (o la ruta correspondiente en pytest). Solo utiliza comandos `bash` directos (como `npx vitest run --testTimeout=10000 --bail=1 --reporter=verbose ...`) si la herramienta `sdd_run_tests` reporta un fallo de entorno o si necesitas depurar localmente. Si un comando de tests excede 60 segundos, ABORTA de inmediato y reporta el cuelgue.
 - **Si el test runner se cuelga**: Antes de reintentar, ejecuta `npx tsc --noEmit` y `npm run build` para validar la compilación. Si ambos pasan, el problema es del test runner mismo (happy-dom + componente complejo). Reporta al orquestador como "rollback evitable" — el código de producción es válido.
 - **Linter Focalizado**: Ejecuta `npx eslint` apuntando específicamente a los archivos de producción modificados listados en `files_affected` del brief y a tus archivos de test (ej. `npx eslint src/components/blocks/MyBlock.tsx src/__tests__/MyBlock.test.tsx`), optimizando el análisis estático.
 - **Resolución Proactiva de Fallas**: Si los tests fallan debido a problemas menores de mocking, importaciones incorrectas, llaves duplicadas en React o configuraciones de test, **tienes autorización total para editarlos y repararlos tú mismo** dentro de `tests/` o `src/__tests__/`. Solo si el error es un fallo lógico en el código de producción de la aplicación (el cual tienes prohibido modificar), debes reportar un rollback a `F2_IMPLEMENTATION`.

package/.opencode/commands/cost.md

@@ -0,0 +1,93 @@
+---
+description: Muestra el desglose de costos, tokens y archivos cambiados de la sesion actual y los ultimos comandos
+---
+
+# /cost — Desglose de consumo y productividad
+
+Has sido invocado con el comando `/cost`. Muestra al usuario de forma directa y visual:
+
+## 1. Sesion actual (live)
+
+```json
+!`node -e "
+const fs = require('fs');
+const path = require('path');
+const metricsPath = path.resolve('.openspec/.sdd_session_metrics.json');
+const statePath = path.resolve('.openspec/sdd_state.json');
+if (!fs.existsSync(metricsPath)) { console.log(JSON.stringify({status: 'NO_SESSION', message: 'No hay sesion activa o no se ha registrado consumo.'})); process.exit(0); }
+const m = JSON.parse(fs.readFileSync(metricsPath, 'utf8'));
+const s = fs.existsSync(statePath) ? JSON.parse(fs.readFileSync(statePath, 'utf8')) : {};
+const startedAt = m.startedAt || '';
+const lastUpdated = m.lastUpdatedAt || '';
+const durationMs = startedAt && lastUpdated ? Math.max(0, Date.parse(lastUpdated) - Date.parse(startedAt)) : 0;
+const fmtDur = (ms) => { const s = Math.floor(ms/1000); const m = Math.floor(s/60); return m + 'm ' + (s%60) + 's'; };
+const fmtCost = (n) => n < 0.001 ? '$' + n.toFixed(5) : n < 1 ? '$' + n.toFixed(4) : '$' + n.toFixed(3);
+const fmtInt = (n) => Math.round(n).toLocaleString('en-US');
+const out = {
+  status: 'ACTIVE',
+  contract: m.contractName || 'fast-track',
+  sessionId: m.sessionId || 'n/a',
+  phase: s.phase || 'unknown',
+  startedAt,
+  lastUpdated,
+  duration: fmtDur(durationMs),
+  totals: {
+    cost: fmtCost(m.totals.cost || 0),
+    tokensIn: fmtInt(m.totals.tokensIn || 0),
+    tokensOut: fmtInt(m.totals.tokensOutput || 0),
+    messages: fmtInt(m.totals.messages || 0)
+  },
+  byAgent: Object.entries(m.byAgent || {}).sort((a,b) => (b[1].cost||0)-(a[1].cost||0)).map(([k,v]) => ({agent: k, cost: fmtCost(v.cost||0), tokensIn: fmtInt(v.tokensIn||0), tokensOut: fmtInt(v.tokensOut||0), messages: fmtInt(v.messages||0)}))
+};
+console.log(JSON.stringify(out, null, 2));
+"`
+```
+
+## 2. Ultimos 10 changelogs (historial de comandos)
+
+```json
+!`node -e "
+const fs = require('fs');
+const path = require('path');
+const idxPath = path.resolve('.openspec/changelog/INDEX.md');
+if (!fs.existsSync(idxPath)) { console.log(JSON.stringify({status: 'NO_CHANGELOGS', message: 'Aun no hay changelogs registrados. Corre un /fast o cierra un ciclo SDD.'})); process.exit(0); }
+const content = fs.readFileSync(idxPath, 'utf8');
+const lines = content.split('\n').filter(l => l.trim().startsWith('|') && !l.startsWith('|---') && !l.startsWith('| Timestamp'));
+const entries = lines.slice(0, 10).map(l => {
+  const cells = l.split('|').map(c => c.trim()).filter(Boolean);
+  return { timestamp: cells[0], command: cells[1], cost: cells[2], files: cells[3], diff: cells[4] };
+});
+console.log(JSON.stringify({status: 'OK', count: entries.length, entries}, null, 2));
+"`
+```
+
+## 3. Historial agregado (todas las sesiones cerradas)
+
+```json
+!`node -e "
+const fs = require('fs');
+const path = require('path');
+const logPath = path.resolve('.openspec/archive/_sessions.jsonl');
+if (!fs.existsSync(logPath)) { console.log(JSON.stringify({status: 'NO_HISTORY', message: 'Aun no hay sesiones cerradas en el archivo de historial.'})); process.exit(0); }
+const lines = fs.readFileSync(logPath, 'utf8').split('\n').filter(l => l.trim());
+const fmtCost = (n) => n < 0.001 ? '$' + n.toFixed(5) : n < 1 ? '$' + n.toFixed(4) : '$' + n.toFixed(3);
+const fmtInt = (n) => Math.round(n).toLocaleString('en-US');
+const sessions = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+const totals = sessions.reduce((acc, s) => ({
+  cost: acc.cost + (s.cost || 0),
+  tokensIn: acc.tokensIn + (s.tokensIn || 0),
+  tokensOutput: acc.tokensOutput + (s.tokensOutput || 0),
+  messages: acc.messages + (s.messages || 0)
+}), {cost:0, tokensIn:0, tokensOutput:0, messages:0});
+const top5 = sessions.sort((a,b) => (b.cost||0) - (a.cost||0)).slice(0,5).map(s => ({contract: s.contractName, cost: fmtCost(s.cost||0), messages: fmtInt(s.messages||0), startedAt: s.startedAt}));
+console.log(JSON.stringify({status: 'OK', sessionCount: sessions.length, totals: { cost: fmtCost(totals.cost), tokensIn: fmtInt(totals.tokensIn), tokensOutput: fmtInt(totals.tokensOutput), messages: fmtInt(totals.messages) }, top5}, null, 2));
+"`
+```
+
+## Instrucciones de presentacion
+
+1. **Sesion actual**: muestra el JSON en una tabla markdown clara. Incluye duracion, costo, tokens y mensajes.
+2. **Ultimos changelogs**: si hay, muestra una tabla con timestamp, comando, costo, archivos y +/- . Si no hay, indica que aun no hay historial.
+3. **Historial agregado**: muestra el top 5 de specs mas caros y los totales historicos.
+4. **Veredicto**: cierra con una linea resumida como "Llevas $X.XX gastados en Y sesiones. El comando mas caro fue `<nombre>` ($X.XX).".
+5. **Tip pro**: si el usuario lo invoca seguido, sugiere correr `/reset` para limpiar el contexto y empezar fresco sin perder el changelog (que ya esta persistido en `.openspec/changelog/`).

package/.opencode/plugins/sdd-bridge.ts

@@ -1,6 +1,7 @@
 import { type Plugin } from "@opencode-ai/plugin"
 import fs from "fs"
 import path from "path"
+import { write_changelog } from "../tools/sdd_changelog.ts"
 
 type AgentMetrics = {
   cost: number
@@ -373,6 +374,48 @@ export const SddBridgePlugin: Plugin = async ({ project, client, $, directory, w
           if (newState.phase === "F0_DETECT") {
             try {
               const openspecDir = path.resolve(projectRoot, ".openspec")
+
+              // 0. Changelog capture (BEFORE GC clears metrics) - records the cycle
+              try {
+                const lastMetrics = readMetrics()
+                if (lastMetrics && (lastMetrics.totals?.cost > 0 || lastMetrics.totals?.messages > 0)) {
+                  const derivedCommand = lastMetrics.contractName || "sdd-cycle"
+                  await write_changelog
+                    .execute(
+                      {
+                        command: derivedCommand,
+                        prompt:
+                          "(prompt no capturado automaticamente por el bridge - edita el changelog para anadirlo si lo necesitas)",
+                      },
+                      {
+                        sessionID: "",
+                        messageID: "",
+                        agent: "sdd-bridge",
+                        directory: projectRoot,
+                        worktree: projectRoot,
+                        abort: new AbortController().signal,
+                        metadata: () => {},
+                        ask: async () => {},
+                      } as any
+                    )
+                    .catch(() => {})
+
+                  // Notify via toast
+                  if (client?.tui?.showToast) {
+                    await client.tui
+                      .showToast({
+                        body: {
+                          message: `📝 Changelog capturado en .openspec/changelog/ (costo: $${(lastMetrics.totals?.cost || 0).toFixed(4)})`,
+                          variant: "info",
+                        },
+                      })
+                      .catch(() => {})
+                  }
+                }
+              } catch (e) {
+                // best-effort: never let changelog failure block GC
+              }
+
               const cleanScreenshots = (dir: string) => {
                 if (fs.existsSync(dir)) {
                   const files = fs.readdirSync(dir)
@@ -393,6 +436,12 @@ export const SddBridgePlugin: Plugin = async ({ project, client, $, directory, w
                 try { fs.rmSync(playwrightTmpDir, { recursive: true, force: true }) } catch (e) {}
               }
 
+              // 2.5 Clear ZCS raw_context cache
+              const rawContextDir = path.resolve(openspecDir, ".raw_context")
+              if (fs.existsSync(rawContextDir)) {
+                try { fs.rmSync(rawContextDir, { recursive: true, force: true }) } catch (e) {}
+              }
+
               // 3. Clear transient metrics file
               const metricsPath = path.resolve(openspecDir, ".sdd_session_metrics.json")
               if (fs.existsSync(metricsPath)) {

package/.opencode/rules/sdd-global.md

@@ -96,3 +96,9 @@ Para evitar que los subagentes se queden sin pasos (step/token exhaustion) o acu
 - **Compilación Atómica:** El Coder **debe** implementar y compilar exitosamente cada archivo de forma individual antes de escribir el siguiente. Está estrictamente prohibido escribir todos los componentes de golpe sin ejecutar validaciones intermedias de TypeScript (`tsc --noEmit`).
 - **Verificación Temprana de Dependencias:** El Coder **debe** comprobar en el primer paso de F2 que dependencias de pruebas críticas como `@testing-library/dom` estén correctamente instaladas en proyectos React 19 para evitar fallos intermitentes de tipado en Vitest.
 - **PROHIBICIÓN ESTRICTA DE `todowrite` en Coder/Tester/Deployer/Spec-Writer:** Estas herramientas **no deben invocar** `todowrite` en ningún momento de su sesión. El seguimiento de fases está centralizado en el Orquestador. Inyectar TODOs en subagentes satura su contexto y agota pasos de LLM innecesariamente. El Orquestador solo debe usar `todowrite` **2 veces máximo por sesión**: una al inicio (lista de fases) y otra al final (marcar todas completadas).
+
+## 10. Compresión y Recuperación de Contexto (ZCS)
+Para maximizar la eficiencia en el uso de la ventana de contexto y ahorrar tokens de API, el arnés implementa Zugzbot Context Shaper (ZCS) con un esquema de recuperación reversible (CCR):
+- **Placeholders de Compresión:** Si detectas bloques de texto en el brief o en los logs de error con la estructura `[CONTEXTO_COMPRIMIDO: hash (Tipo: Categoria, Líneas: N)]`, significa que el contenido original ha sido archivado localmente para no saturar tu contexto.
+- **Recuperación bajo demanda (MANDATORIO):** Si necesitas ver el contenido completo y exacto sin comprimir (por ejemplo, para depurar un stack trace de error largo o leer patrones de mock enteros), debes invocar obligatoriamente la herramienta `sdd_retrieve_raw({ hash: "hash_identificador" })`. No asumas ni inventes código o logs que estén comprimidos; recupéralos de forma dirigida.
+

package/.opencode/tools/sdd_changelog.ts

@@ -0,0 +1,348 @@
+import { tool } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+import { execSync } from "child_process"
+
+// ============================================================================
+// SDD Changelog Tool
+// ============================================================================
+//
+// Escribe un changelog markdown estructurado por cada comando significativo
+// (/fast, /loop, sprint de F2, fin de contrato). Cada entrada incluye:
+//   - Prompt literal del usuario
+//   - Diff stats (archivos tocados, lineas +/-)
+//   - Costo y duracion de la sesion actual
+//   - Output resumido (provisto por el agente o el bridge)
+//   - Timestamp ISO + comando que lo origino
+//
+// Adicionalmente mantiene un INDEX.md con una linea por entrada para poder
+// escanear toda la historia de un vistazo (alimenta el comando /cost).
+// ============================================================================
+
+const getRoot = (context: any): string => {
+  if (context?.directory && context.directory !== "/") return context.directory
+  if (context?.worktree && context.worktree !== "/") return context.worktree
+  return process.cwd()
+}
+
+const getMetricsPath = (root: string) => path.resolve(root, ".openspec/.sdd_session_metrics.json")
+const getStatePath = (root: string) => path.resolve(root, ".openspec/sdd_state.json")
+const getChangelogDir = (root: string) => path.resolve(root, ".openspec/changelog")
+const getIndexPath = (root: string) => path.resolve(root, ".openspec/changelog/INDEX.md")
+
+const safeExec = (cmd: string, cwd: string): string | null => {
+  try {
+    return execSync(cmd, { cwd, stdio: "pipe", encoding: "utf8" }).toString()
+  } catch {
+    return null
+  }
+}
+
+const formatCost = (cost: number): string => {
+  if (typeof cost !== "number" || !Number.isFinite(cost)) return "$0.00"
+  if (cost < 0.001) return `$${cost.toFixed(5)}`
+  if (cost < 1) return `$${cost.toFixed(4)}`
+  return `$${cost.toFixed(3)}`
+}
+
+const formatDuration = (ms: number): string => {
+  if (!ms || ms < 0) return "0s"
+  const totalSeconds = Math.floor(ms / 1000)
+  const minutes = Math.floor(totalSeconds / 60)
+  const seconds = totalSeconds % 60
+  if (minutes === 0) return `${seconds}s`
+  if (seconds === 0) return `${minutes}m`
+  return `${minutes}m ${seconds}s`
+}
+
+const formatInt = (n: number): string => {
+  if (typeof n !== "number" || !Number.isFinite(n)) return "0"
+  return Math.round(n).toLocaleString("en-US")
+}
+
+const slugify = (s: string): string => {
+  return s
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 60)
+    || "unnamed"
+}
+
+const readMetrics = (root: string): any => {
+  const p = getMetricsPath(root)
+  if (!fs.existsSync(p)) return null
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"))
+  } catch {
+    return null
+  }
+}
+
+const readState = (root: string): any => {
+  const p = getStatePath(root)
+  if (!fs.existsSync(p)) return null
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"))
+  } catch {
+    return null
+  }
+}
+
+const captureDiffStats = (root: string): any => {
+  // Inline minimal version (no recursion into sdd_diff_capture to avoid tool-of-tool deps).
+  const numstatOut = safeExec("git diff --numstat HEAD", root) || ""
+  const nameStatusOut = safeExec("git diff --name-status HEAD", root) || ""
+  const untrackedOut = safeExec("git ls-files --others --exclude-standard", root) || ""
+
+  const statusMap = new Map<string, string>()
+  for (const line of nameStatusOut.split("\n")) {
+    const t = line.trim()
+    if (!t) continue
+    const parts = t.split("\t")
+    if (parts.length < 2) continue
+    statusMap.set(parts[parts.length - 1], parts[0].charAt(0))
+  }
+
+  const files: Array<{ path: string; status: string; added: number; removed: number; binary: boolean }> = []
+  let totalAdded = 0
+  let totalRemoved = 0
+
+  for (const line of numstatOut.split("\n")) {
+    const t = line.trim()
+    if (!t) continue
+    const parts = t.split("\t")
+    if (parts.length < 3) continue
+    const isBinary = parts[0] === "-" && parts[1] === "-"
+    const added = isBinary ? 0 : parseInt(parts[0], 10) || 0
+    const removed = isBinary ? 0 : parseInt(parts[1], 10) || 0
+    const filePath = parts.slice(2).join("\t")
+    files.push({ path: filePath, status: statusMap.get(filePath) || "M", added, removed, binary: isBinary })
+    totalAdded += added
+    totalRemoved += removed
+  }
+
+  for (const line of untrackedOut.split("\n")) {
+    const p = line.trim()
+    if (!p) continue
+    let added = 0
+    try {
+      const content = fs.readFileSync(`${root}/${p}`, "utf8")
+      added = content.split("\n").length
+    } catch {
+      added = 0
+    }
+    files.push({ path: p, status: "?", added, removed: 0, binary: false })
+    totalAdded += added
+  }
+
+  return { files, totalAdded, totalRemoved, fileCount: files.length }
+}
+
+const buildMarkdown = (params: {
+  command: string
+  prompt: string
+  outputSummary?: string
+  metrics: any
+  state: any
+  diff: any
+  timestamp: string
+  closedAt?: string
+}): string => {
+  const { command, prompt, outputSummary, metrics, state, diff, timestamp, closedAt } = params
+
+  const durationMs = metrics?.startedAt && closedAt
+    ? Math.max(0, Date.parse(closedAt) - Date.parse(metrics.startedAt))
+    : 0
+
+  const totals = metrics?.totals || { cost: 0, tokensIn: 0, tokensOutput: 0, messages: 0 }
+  const phase = state?.phase || "F0_DETECT"
+  const contract = state?.activeContract || metrics?.contractName || "fast-track"
+
+  let md = `# ${command} · ${timestamp}\n\n`
+
+  md += `## Contexto\n`
+  md += `- **Comando**: \`${command}\`\n`
+  md += `- **Contrato**: \`${contract}\`\n`
+  md += `- **Fase final**: \`${phase}\`\n`
+  md += `- **Sesion**: \`${metrics?.sessionId || "n/a"}\`\n`
+  md += `- **Duracion**: ${formatDuration(durationMs)}\n\n`
+
+  md += `## Prompt\n`
+  md += `> ${prompt.replace(/\n/g, "\n> ")}\n\n`
+
+  md += `## Costo y tokens\n`
+  md += `| Metrica | Valor |\n|---|---|\n`
+  md += `| Costo total | ${formatCost(totals.cost)} |\n`
+  md += `| Tokens entrada | ${formatInt(totals.tokensIn)} |\n`
+  md += `| Tokens salida | ${formatInt(totals.tokensOutput)} |\n`
+  md += `| Mensajes | ${formatInt(totals.messages)} |\n\n`
+
+  if (metrics?.byAgent && Object.keys(metrics.byAgent).length > 0) {
+    md += `### Desglose por agente\n`
+    md += `| Agente | Costo | Tokens in | Tokens out | Mensajes |\n|---|---|---|---|---|\n`
+    const sorted = Object.entries(metrics.byAgent).sort(
+      (a: any, b: any) => (b[1].cost || 0) - (a[1].cost || 0)
+    )
+    for (const [agent, m] of sorted as any) {
+      md += `| \`${agent}\` | ${formatCost(m.cost)} | ${formatInt(m.tokensIn)} | ${formatInt(m.tokensOutput)} | ${formatInt(m.messages)} |\n`
+    }
+    md += `\n`
+  }
+
+  md += `## Diff capturado\n`
+  if (!diff || diff.fileCount === 0) {
+    md += `_No se detectaron cambios en el working tree._\n\n`
+  } else {
+    md += `- **Archivos tocados**: ${diff.fileCount}\n`
+    md += `- **Lineas agregadas**: +${formatInt(diff.totalAdded)}\n`
+    md += `- **Lineas removidas**: -${formatInt(diff.totalRemoved)}\n\n`
+    md += `| Archivo | Status | +/- |\n|---|---|---|\n`
+    for (const f of diff.files.slice(0, 50)) {
+      const diffStr = f.binary ? "(binario)" : `+${f.added} / -${f.removed}`
+      const statusBadge = {
+        A: "añadido",
+        M: "modificado",
+        D: "eliminado",
+        R: "renombrado",
+        C: "copiado",
+        "?": "untracked",
+      }[f.status as string] || f.status
+      md += `| \`${f.path}\` | ${statusBadge} | ${diffStr} |\n`
+    }
+    if (diff.files.length > 50) {
+      md += `| _... y ${diff.files.length - 50} archivos mas_ | | |\n`
+    }
+    md += `\n`
+  }
+
+  if (outputSummary && outputSummary.trim().length > 0) {
+    md += `## Output del agente\n`
+    md += `${outputSummary.trim()}\n\n`
+  }
+
+  md += `---\n`
+  md += `_Changelog autogenerado por sdd_changelog el ${timestamp}._\n`
+
+  return md
+}
+
+const appendToIndex = (indexPath: string, entry: { file: string; command: string; timestamp: string; cost: number; files: number; linesAdded: number; linesRemoved: number }) => {
+  let content = "# SDD Changelog Index\n\n"
+  content += "Lista cronologica (mas reciente primero) de todos los comandos que dejaron rastro.\n\n"
+  content += "| Timestamp | Comando | Costo | Archivos | +/- |\n|---|---|---|---|---|\n"
+
+  const newLine = `| ${entry.timestamp} | [${entry.command}](./${path.basename(entry.file)}) | ${formatCost(entry.cost)} | ${entry.files} | +${formatInt(entry.linesAdded)} / -${formatInt(entry.linesRemoved)} |`
+
+  let existingLines: string[] = []
+  if (fs.existsSync(indexPath)) {
+    const current = fs.readFileSync(indexPath, "utf8")
+    const lines = current.split("\n")
+    // Strip header (keep header + table header)
+    const headerEnd = lines.findIndex((l) => l.startsWith("|---"))
+    if (headerEnd > 0 && lines[headerEnd + 1]) {
+      existingLines = lines.slice(headerEnd + 1).filter((l) => l.trim().startsWith("|"))
+    }
+  }
+
+  const updated = [newLine, ...existingLines].slice(0, 200) // cap at 200 entries
+  fs.writeFileSync(indexPath, content + updated.join("\n") + "\n", "utf8")
+}
+
+export const write_changelog = tool({
+  description:
+    "Escribe un changelog markdown estructurado en .openspec/changelog/<command>-<timestamp>.md " +
+    "con prompt, diff stats, costo y duracion de la sesion actual. Tambien actualiza " +
+    ".openspec/changelog/INDEX.md con una linea resumen. Usado por el hook del sdd-bridge " +
+    "en transiciones de fase y por comandos /fast, /loop al finalizar.",
+  args: {
+    command: tool.schema
+      .string()
+      .describe("Nombre del comando que origina el changelog (ej: 'fast', 'loop', 'sprint-1', 'fast-track')."),
+    prompt: tool.schema
+      .string()
+      .describe("Prompt literal que el usuario escribio para este comando."),
+    outputSummary: tool.schema
+      .string()
+      .optional()
+      .describe("Resumen corto (3-5 lineas) del output del subagente. Opcional pero recomendado."),
+    closedAt: tool.schema
+      .string()
+      .optional()
+      .describe("ISO timestamp de cierre del comando. Default: ahora."),
+  },
+  async execute(args, context) {
+    const root = getRoot(context)
+    const command = slugify(args.command || "unnamed")
+    const timestamp = new Date().toISOString().replace(/\.\d{3}Z$/, "Z")
+    const closedAt = args.closedAt || timestamp
+
+    const metrics = readMetrics(root)
+    const state = readState(root)
+    const diff = captureDiffStats(root)
+
+    const filename = `${command}-${timestamp.replace(/[:.]/g, "-")}.md`
+    const changelogDir = getChangelogDir(root)
+    if (!fs.existsSync(changelogDir)) fs.mkdirSync(changelogDir, { recursive: true })
+
+    const filepath = path.join(changelogDir, filename)
+    const markdown = buildMarkdown({
+      command: args.command,
+      prompt: args.prompt || "(sin prompt registrado)",
+      outputSummary: args.outputSummary,
+      metrics,
+      state,
+      diff,
+      timestamp,
+      closedAt,
+    })
+
+    try {
+      fs.writeFileSync(filepath, markdown, "utf8")
+    } catch (e: any) {
+      return JSON.stringify(
+        {
+          status: "ERROR",
+          message: `No se pudo escribir el changelog: ${e?.message || "unknown"}`,
+          path: filepath,
+        },
+        null,
+        2
+      )
+    }
+
+    try {
+      appendToIndex(getIndexPath(root), {
+        file: filename,
+        command: args.command,
+        timestamp,
+        cost: metrics?.totals?.cost || 0,
+        files: diff.fileCount,
+        linesAdded: diff.totalAdded,
+        linesRemoved: diff.totalRemoved,
+      })
+    } catch {
+      // index failure is non-blocking
+    }
+
+    return JSON.stringify(
+      {
+        status: "SUCCESS",
+        path: filepath,
+        filename,
+        command: args.command,
+        timestamp,
+        summary: {
+          cost: metrics?.totals?.cost || 0,
+          filesChanged: diff.fileCount,
+          linesAdded: diff.totalAdded,
+          linesRemoved: diff.totalRemoved,
+          messages: metrics?.totals?.messages || 0,
+        },
+        relativePath: `.openspec/changelog/${filename}`,
+      },
+      null,
+      2
+    )
+  }
+})

package/.opencode/tools/sdd_compress.ts

@@ -0,0 +1,242 @@
+import { tool } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+import crypto from "crypto"
+
+// Helper to safely resolve root directory
+const getRoot = (context: any) => {
+  if (context?.directory && context.directory !== "/") return context.directory;
+  if (context?.worktree && context.worktree !== "/") return context.worktree;
+  if (context?.cwd && context.cwd !== "/") return context.cwd;
+  return process.cwd();
+};
+
+/**
+ * Comprime código fuente eliminando comentarios, docstrings y líneas vacías.
+ */
+export function compressCode(code: string, commentStyle: "slash" | "hash" = "slash"): string {
+  if (!code) return ""
+  
+  let inString: string | null = null
+  let inComment: "single" | "multi" | null = null
+  let result = ""
+  
+  for (let i = 0; i < code.length; i++) {
+    const char = code[i]
+    const nextChar = code[i + 1] || ""
+    
+    if (inComment === "multi") {
+      if (char === "*" && nextChar === "/") {
+        inComment = null
+        i++ // Skip '/'
+      }
+      continue
+    }
+    
+    if (inComment === "single") {
+      if (char === "\n" || char === "\r") {
+        inComment = null
+        result += char
+      }
+      continue
+    }
+    
+    if (inString) {
+      if (char === inString && code[i - 1] !== "\\") {
+        inString = null
+      }
+      result += char
+      continue
+    }
+    
+    // Check for comments based on style
+    if (commentStyle === "slash") {
+      if (char === "/" && nextChar === "*") {
+        inComment = "multi"
+        i++
+        continue
+      }
+      if (char === "/" && nextChar === "/") {
+        inComment = "single"
+        i++
+        continue
+      }
+    } else if (commentStyle === "hash") {
+      if (char === "#") {
+        inComment = "single"
+        continue
+      }
+    }
+    
+    // Check for string start
+    if (char === "'" || char === '"' || char === "`") {
+      inString = char
+    }
+    
+    result += char
+  }
+  
+  // Clean up empty lines
+  return result
+    .split(/\r?\n/)
+    .filter(line => line.trim().length > 0)
+    .join("\n")
+}
+
+/**
+ * Comprime cadenas JSON grandes recortando arrays a un tamaño máximo.
+ */
+export function compressJson(jsonStr: string, maxItems = 3): string {
+  if (!jsonStr) return ""
+  try {
+    const obj = JSON.parse(jsonStr)
+    
+    const prune = (o: any): any => {
+      if (Array.isArray(o)) {
+        if (o.length > maxItems) {
+          const sliced = o.slice(0, maxItems).map(prune)
+          sliced.push(`... [ZCS: ${o.length - maxItems} elementos omitidos]`)
+          return sliced
+        }
+        return o.map(prune)
+      } else if (o !== null && typeof o === "object") {
+        const res: any = {}
+        for (const k of Object.keys(o)) {
+          res[k] = prune(o[k])
+        }
+        return res
+      }
+      return o
+    }
+    
+    return JSON.stringify(prune(obj), null, 2)
+  } catch (e) {
+    // Si no es JSON válido, devolver el texto original
+    return jsonStr
+  }
+}
+
+/**
+ * Comprime logs de consola de tests unitarios (Vitest/pytest),
+ * preservando los fallos, errores y resúmenes de suites.
+ */
+export function compressTestLogs(logs: string): string {
+  if (!logs) return ""
+  const lines = logs.split(/\r?\n/)
+  const result: string[] = []
+  
+  let recordingError = false
+  let errorLinesCount = 0
+  
+  for (const line of lines) {
+    const upper = line.toUpperCase()
+    
+    // Detectar inicio de fallos o errores
+    const isErrorIndicator = 
+      line.includes("FAIL") || 
+      line.includes("Error:") || 
+      line.includes("AssertionError") || 
+      line.includes("❌") || 
+      upper.includes("EXCEPTION") || 
+      upper.includes("FAILED")
+      
+    if (isErrorIndicator) {
+      recordingError = true
+      errorLinesCount = 0
+      result.push(line)
+      continue
+    }
+    
+    if (recordingError) {
+      // Guardar las primeras 8 líneas del error/stack trace
+      if (errorLinesCount < 8) {
+        result.push(line)
+        errorLinesCount++
+      } else {
+        // Truncar stack traces largos del framework (node_modules/vitest, etc.)
+        if (line.trim() === "" || line.includes("PASS") || line.includes("Test Suites:")) {
+          recordingError = false
+          result.push("   [... ZCS: stack trace del framework omitido para ahorrar tokens ...]")
+          result.push(line)
+        }
+      }
+    } else {
+      // Siempre conservar resúmenes e información de suites exitosas
+      const isSummaryIndicator = 
+        line.includes("PASS") || 
+        line.includes("Summary") || 
+        line.includes("Test Suites:") || 
+        line.includes("Tests:") || 
+        line.includes("Snapshots:") || 
+        line.includes("Time:") || 
+        line.includes("Ran all test suites")
+        
+      if (isSummaryIndicator || line.trim().startsWith("✓")) {
+        result.push(line)
+      }
+    }
+  }
+  
+  // Si no se capturaron líneas o todo pasó muy rápido, retornar resumido
+  if (result.length === 0) {
+    return logs.length > 500 ? `${logs.slice(0, 500)}\n... [ZCS: truncado por longitud]` : logs
+  }
+  
+  return result.join("\n")
+}
+
+/**
+ * Registra el contenido crudo en disco (CCR) y devuelve un placeholder comprimido.
+ */
+export function ccrCompress(content: string, category: string, context: any): string {
+  if (!content) return ""
+  
+  const root = getRoot(context)
+  const rawContextDir = path.resolve(root, ".openspec/.raw_context")
+  
+  if (!fs.existsSync(rawContextDir)) {
+    fs.mkdirSync(rawContextDir, { recursive: true })
+  }
+  
+  // Calcular hash del contenido para evitar duplicados
+  const hash = crypto.createHash("sha256").update(content).digest("hex").slice(0, 12)
+  const destFile = path.join(rawContextDir, `${hash}.txt`)
+  
+  // Escribir solo si no existe ya
+  if (!fs.existsSync(destFile)) {
+    fs.writeFileSync(destFile, content, "utf8")
+  }
+  
+  const lineCount = content.split(/\r?\n/).length
+  return `[CONTEXTO_COMPRIMIDO: ${hash} (Tipo: ${category}, Líneas: ${lineCount}). Si necesitas ver el contenido completo sin compresión para editar o depurar, ejecuta la herramienta sdd_retrieve_raw({ hash: "${hash}" })]`
+}
+
+// Tool: sdd_retrieve_raw
+export const retrieve_raw = tool({
+  description: "Recupera un bloque de contexto original sin comprimir (logs, código, JSON) a partir de su hash identificador.",
+  args: {
+    hash: tool.schema.string().describe("El hash de 12 caracteres del contexto que deseas recuperar (ej. 'a1b2c3d4e5f6').")
+  },
+  async execute(args, context) {
+    try {
+      const root = getRoot(context)
+      const hash = args.hash.trim()
+      const rawPath = path.resolve(root, `.openspec/.raw_context/${hash}.txt`)
+      
+      if (!fs.existsSync(rawPath)) {
+        return JSON.stringify({
+          success: false,
+          message: `No se encontró el contexto original para el hash '${hash}'. El caché podría haber sido purgado.`
+        }, null, 2)
+      }
+      
+      const content = fs.readFileSync(rawPath, "utf8")
+      return content
+    } catch (e: any) {
+      return JSON.stringify({
+        success: false,
+        message: `Error al recuperar contexto crudo: ${e.message || e}`
+      }, null, 2)
+    }
+  }
+})

package/.opencode/tools/sdd_core.ts

@@ -2,6 +2,7 @@ import { tool } from "@opencode-ai/plugin"
 import fs from "fs"
 import path from "path"
 import { execSync } from "child_process"
+import { ccrCompress } from "./sdd_compress.ts"
 
 // Helper to safely resolve root directory (avoiding OpenCode bug where worktree is '/' in non-git repos)
 const getRoot = (context: any) => {
@@ -362,6 +363,15 @@ export const set_phase = tool({
         currentState.loopTargetIterations = 1
         currentState.loopCurrentIteration = 1
       }
+      // Clean up raw_context files (ZCS)
+      try {
+        const rawContextDir = path.resolve(root, ".openspec/.raw_context")
+        if (fs.existsSync(rawContextDir)) {
+          fs.rmSync(rawContextDir, { recursive: true, force: true })
+        }
+      } catch (e) {
+        // ignore
+      }
       // Clean up running servers
       const pidFile = getPidFilePath(root)
       if (fs.existsSync(pidFile)) {
@@ -624,16 +634,17 @@ export const save_active_brief = tool({
         const errors = last("errors", 5)
         const design = last("design", 3)
 
-        if (learnings || errors || design) {
+        let brainMemoryStr = ""
+        if (design) brainMemoryStr += `\n### Design (aplicar en estilo):\n${design}\n`
+        if (learnings) brainMemoryStr += `\n### Learnings (patrones validados):\n${learnings}\n`
+        if (errors) brainMemoryStr += `\n### Errors / Regresiones (evitar repetir):\n${errors}\n`
+
+        if (brainMemoryStr) {
           enrichedBrief += `\n\n## [AUTO-INJECTED] Brain Memory (lecciones de sesiones previas)\n`
-          if (design) {
-            enrichedBrief += `\n### Design (aplicar en estilo):\n${design}\n`
-          }
-          if (learnings) {
-            enrichedBrief += `\n### Learnings (patrones validados):\n${learnings}\n`
-          }
-          if (errors) {
-            enrichedBrief += `\n### Errors / Regresiones (evitar repetir):\n${errors}\n`
+          if (brainMemoryStr.length > 1500) {
+            enrichedBrief += ccrCompress(brainMemoryStr, "Brain Memory", context) + "\n"
+          } else {
+            enrichedBrief += brainMemoryStr
           }
         }
       }
@@ -645,31 +656,35 @@ export const save_active_brief = tool({
     try {
       const isNext = contract?.stack?.core?.some((c: string) => /next\.?js/i.test(c))
       if (isNext) {
+        let mockPatterns = `// Mock dinámico de lucide-react (cualquier icono)\n`
+        mockPatterns += `vi.mock("lucide-react", () => new Proxy({}, {\n`
+        mockPatterns += `  get: (_t, prop) => {\n`
+        mockPatterns += `    const Icon = (props: any) => null;\n`
+        mockPatterns += `    Icon.displayName = String(prop);\n`
+        mockPatterns += `    return Icon;\n`
+        mockPatterns += `  },\n`
+        mockPatterns += `}));\n\n`
+        mockPatterns += `// Mock reactivo de next-themes para ThemeToggle\n`
+        mockPatterns += `let theme = "light";\n`
+        mockPatterns += `vi.mock("next-themes", () => ({\n`
+        mockPatterns += `  useTheme: () => ({\n`
+        mockPatterns += `    get theme() { return theme; },\n`
+        mockPatterns += `    setTheme: (t: string) => { theme = t; },\n`
+        mockPatterns += `    get resolvedTheme() { return theme; },\n`
+        mockPatterns += `  }),\n`
+        mockPatterns += `}));\n\n`
+        mockPatterns += `// Mock de next/navigation\n`
+        mockPatterns += `vi.mock("next/navigation", () => ({\n`
+        mockPatterns += `  useRouter: () => ({ push: vi.fn(), replace: vi.fn(), prefetch: vi.fn() }),\n`
+        mockPatterns += `  usePathname: () => "/",\n`
+        mockPatterns += `}));\n`
+
         enrichedBrief += `\n\n## [AUTO-INJECTED] Mock Patterns (Vitest + Testing Library)\n`
-        enrichedBrief += `\`\`\`typescript\n`
-        enrichedBrief += `// Mock dinámico de lucide-react (cualquier icono)\n`
-        enrichedBrief += `vi.mock("lucide-react", () => new Proxy({}, {\n`
-        enrichedBrief += `  get: (_t, prop) => {\n`
-        enrichedBrief += `    const Icon = (props: any) => null;\n`
-        enrichedBrief += `    Icon.displayName = String(prop);\n`
-        enrichedBrief += `    return Icon;\n`
-        enrichedBrief += `  },\n`
-        enrichedBrief += `}));\n\n`
-        enrichedBrief += `// Mock reactivo de next-themes para ThemeToggle\n`
-        enrichedBrief += `let theme = "light";\n`
-        enrichedBrief += `vi.mock("next-themes", () => ({\n`
-        enrichedBrief += `  useTheme: () => ({\n`
-        enrichedBrief += `    get theme() { return theme; },\n`
-        enrichedBrief += `    setTheme: (t: string) => { theme = t; },\n`
-        enrichedBrief += `    get resolvedTheme() { return theme; },\n`
-        enrichedBrief += `  }),\n`
-        enrichedBrief += `}));\n\n`
-        enrichedBrief += `// Mock de next/navigation\n`
-        enrichedBrief += `vi.mock("next/navigation", () => ({\n`
-        enrichedBrief += `  useRouter: () => ({ push: vi.fn(), replace: vi.fn(), prefetch: vi.fn() }),\n`
-        enrichedBrief += `  usePathname: () => "/",\n`
-        enrichedBrief += `}));\n`
-        enrichedBrief += `\`\`\`\n`
+        if (mockPatterns.length > 1000) {
+          enrichedBrief += ccrCompress(mockPatterns, "Mock Patterns", context) + "\n"
+        } else {
+          enrichedBrief += `\`\`\`typescript\n${mockPatterns}\`\`\`\n`
+        }
       }
     } catch (e) {
       // ignore

package/.opencode/tools/sdd_diff_capture.ts

@@ -0,0 +1,200 @@
+import { tool } from "@opencode-ai/plugin"
+import { execSync } from "child_process"
+
+// ============================================================================
+// SDD Diff Capture Tool
+// ============================================================================
+//
+// Captura estadisticas de `git diff` (numstat + name-status) para alimentar el
+// changelog granular de cada comando /fast, /loop, o sprint de F2. Se mantiene
+// como tool independiente (no embebida en sdd-bridge.ts) para que sea
+// reutilizable desde agentes, desde el hook del bridge y desde /cost.
+//
+// Comportamiento:
+//   - Si no hay repo git, devuelve { available: false } sin crashear.
+//   - Si hay cambios sin commitear, los captura contra HEAD (default).
+//   - Si se pasa `since`, compara ese ref contra HEAD.
+//   - Maneja archivos binarios y renames de forma best-effort.
+// ============================================================================
+
+const getRoot = (context: any): string => {
+  if (context?.directory && context.directory !== "/") return context.directory
+  if (context?.worktree && context.worktree !== "/") return context.worktree
+  return process.cwd()
+}
+
+const safeExec = (cmd: string, cwd: string): string | null => {
+  try {
+    return execSync(cmd, { cwd, stdio: "pipe", encoding: "utf8" }).toString()
+  } catch {
+    return null
+  }
+}
+
+const isGitRepo = (cwd: string): boolean => {
+  const out = safeExec("git rev-parse --is-inside-work-tree", cwd)
+  return out?.trim() === "true"
+}
+
+export const capture_diff = tool({
+  description:
+    "Captura estadisticas de git diff (archivos tocados, lineas agregadas/removidas, " +
+    "renames). Usado por /fast, /loop y el hook del sdd-bridge para alimentar el " +
+    "changelog granular. Si no hay repo git, devuelve { available: false } sin error.",
+  args: {
+    since: tool.schema
+      .string()
+      .optional()
+      .describe("Ref base para comparar (ej: 'HEAD~1', commit hash, branch). Default: HEAD (cambios sin commitear)."),
+    until: tool.schema
+      .string()
+      .optional()
+      .describe("Ref final para comparar. Default: working tree (incluye uncommitted)."),
+    pathspec: tool.schema
+      .string()
+      .optional()
+      .describe("Filtro opcional tipo git pathspec (ej: 'src/' para limitar a src/)."),
+  },
+  async execute(args, context) {
+    const root = getRoot(context)
+
+    if (!isGitRepo(root)) {
+      return JSON.stringify(
+        {
+          status: "NO_GIT",
+          available: false,
+          message: "No se detecto un repositorio git en la raiz del proyecto.",
+          files: [],
+          totalAdded: 0,
+          totalRemoved: 0,
+        },
+        null,
+        2
+      )
+    }
+
+    const since = args.since?.trim() || "HEAD"
+    const until = args.until?.trim() || ""
+    const pathspec = args.pathspec?.trim() || ""
+
+    // Build range. Format: <since>..<until> (if until) or <since> (diff vs working tree)
+    const range = until ? `${since}..${until}` : since
+    const pathArg = pathspec ? `-- '${pathspec.replace(/'/g, "'\\''")}'` : ""
+
+    // 1. numstat: lines added/removed per file (binary shows as -\t-)
+    const numstatCmd = `git diff --numstat ${range}${pathArg}`
+    const numstatOut = safeExec(numstatCmd, root) || ""
+
+    // 2. name-status: A=added, M=modified, D=deleted, R=renamed, C=copied
+    const nameStatusCmd = `git diff --name-status ${range}${pathArg}`
+    const nameStatusOut = safeExec(nameStatusCmd, root) || ""
+
+    const files: Array<{
+      path: string
+      status: string
+      added: number
+      removed: number
+      binary: boolean
+    }> = []
+
+    let totalAdded = 0
+    let totalRemoved = 0
+    let binaryCount = 0
+
+    // Parse name-status first (gives status including R/C codes)
+    const statusMap = new Map<string, string>()
+    for (const line of nameStatusOut.split("\n")) {
+      const trimmed = line.trim()
+      if (!trimmed) continue
+      const parts = trimmed.split("\t")
+      if (parts.length < 2) continue
+      const status = parts[0]
+      const path = parts[parts.length - 1] // for renames, last col is the new path
+      statusMap.set(path, status.charAt(0)) // R100 -> R, C075 -> C
+    }
+
+    // Parse numstat
+    for (const line of numstatOut.split("\n")) {
+      const trimmed = line.trim()
+      if (!trimmed) continue
+      const parts = trimmed.split("\t")
+      if (parts.length < 3) continue
+      const addedStr = parts[0]
+      const removedStr = parts[1]
+      const path = parts.slice(2).join("\t") // paths with spaces may have been joined
+
+      const isBinary = addedStr === "-" && removedStr === "-"
+      const added = isBinary ? 0 : parseInt(addedStr, 10) || 0
+      const removed = isBinary ? 0 : parseInt(removedStr, 10) || 0
+
+      const status = statusMap.get(path) || (isBinary ? "M" : "M")
+
+      files.push({
+        path,
+        status,
+        added,
+        removed,
+        binary: isBinary,
+      })
+
+      totalAdded += added
+      totalRemoved += removed
+      if (isBinary) binaryCount++
+    }
+
+    // 3. Detect untracked files (only when diffing vs HEAD with no until)
+    let untrackedCount = 0
+    if (!args.until) {
+      const untrackedOut = safeExec("git ls-files --others --exclude-standard", root) || ""
+      for (const line of untrackedOut.split("\n")) {
+        const p = line.trim()
+        if (!p) continue
+        if (pathspec && !p.startsWith(pathspec.replace(/\/$/, ""))) continue
+        // Count lines for untracked files (best-effort)
+        let added = 0
+        try {
+          const absPath = `${root}/${p}`
+          const content = require("fs").readFileSync(absPath, "utf8")
+          added = content.split("\n").length
+        } catch {
+          added = 0
+        }
+        files.push({
+          path: p,
+          status: "?",
+          added,
+          removed: 0,
+          binary: false,
+        })
+        totalAdded += added
+        untrackedCount++
+      }
+    }
+
+    // 4. Staged changes if comparing against HEAD (working tree may have staged)
+    let stagedOnly = false
+    if (!args.until) {
+      const stagedOut = safeExec("git diff --cached --numstat", root) || ""
+      if (stagedOut.trim()) stagedOnly = true
+    }
+
+    return JSON.stringify(
+      {
+        status: "SUCCESS",
+        available: true,
+        range: { since, until: until || "working-tree" },
+        pathspec: pathspec || null,
+        files,
+        totalAdded,
+        totalRemoved,
+        fileCount: files.length,
+        binaryCount,
+        untrackedCount,
+        stagedOnly,
+        capturedAt: new Date().toISOString(),
+      },
+      null,
+      2
+    )
+  }
+})

package/.opencode/tools/sdd_testing.ts

@@ -2,6 +2,7 @@ import { tool } from "@opencode-ai/plugin"
 import fs from "fs"
 import path from "path"
 import { execSync } from "child_process"
+import { compressTestLogs, ccrCompress } from "./sdd_compress.ts"
 
 // Helper to safely resolve root directory (avoiding OpenCode bug where worktree is '/' in non-git repos)
 const getRoot = (context: any) => {
@@ -669,3 +670,62 @@ export const save_playwright_artifacts = tool({
     }
   }
 })
+
+// Tool: sdd_run_tests
+export const run_tests = tool({
+  description: "Ejecuta las pruebas unitarias y de integración del proyecto (Vitest o pytest), comprimiendo la salida para ahorrar tokens.",
+  args: {
+    file: tool.schema.string().optional().describe("La ruta específica del archivo de test a ejecutar (relativa al root). Si no se pasa, corre todos los tests."),
+    timeout: tool.schema.number().optional().default(10000).describe("Timeout en milisegundos para la ejecución de cada test (solo aplicable a Vitest). Default: 10000.")
+  },
+  async execute(args, context) {
+    const root = getRoot(context)
+    const targetDir = getTargetDir(root)
+    const targetPath = targetDir === "." ? root : path.resolve(root, targetDir)
+
+    // Detectar si es un proyecto Python
+    const isPython = fs.existsSync(path.resolve(targetPath, "requirements.txt")) || fs.existsSync(path.resolve(targetPath, "pyproject.toml"))
+
+    // Obtener ruta del archivo relativa al directorio de destino si aplica
+    let testPathArg = ""
+    if (args.file) {
+      const fullPath = path.resolve(root, args.file)
+      testPathArg = path.relative(targetPath, fullPath)
+    }
+
+    let cmd = ""
+    if (isPython) {
+      cmd = `pytest ${testPathArg || "tests/"}`
+    } else {
+      const testTimeout = args.timeout ?? 10000
+      cmd = `npx vitest run --testTimeout=${testTimeout} --bail=1 --reporter=verbose ${testPathArg}`
+    }
+
+    try {
+      const out = execSync(cmd, {
+        cwd: targetPath,
+        encoding: "utf8",
+        timeout: 120_000, // timeout global del proceso de 2 minutos
+        stdio: "pipe"
+      })
+      
+      const compressed = compressTestLogs(out)
+      
+      return JSON.stringify({
+        status: "SUCCESS",
+        message: "Las pruebas se ejecutaron y pasaron exitosamente.",
+        output: compressed.length > 1500 ? ccrCompress(out, "Test Success Output", context) : compressed
+      }, null, 2)
+    } catch (e: any) {
+      const rawOutput = e.stdout?.toString() || e.stderr?.toString() || e.message || ""
+      const compressed = compressTestLogs(rawOutput)
+      
+      return JSON.stringify({
+        status: "FAIL",
+        message: "La ejecución de pruebas falló. Corrige los errores mostrados abajo.",
+        output: compressed.length > 1500 ? ccrCompress(rawOutput, "Test Failure Output", context) : compressed
+      }, null, 2)
+    }
+  }
+})
+

package/README.md

@@ -18,7 +18,7 @@ npx zugzbot@latest
 
 ¡Eso es todo! El instalador automatizado copiará de forma no destructiva y fusionará los siguientes recursos en tu proyecto:
 
-*   📁 **`.opencode/`** — El núcleo del sistema: agentes, comandos, skills y herramientas personalizadas (incluyendo el catálogo offline de **Oh My Design** con 246 marcas).
+*   📁 **`.opencode/`** — El núcleo del sistema: agentes, comandos, skills y herramientas personalizadas (incluyendo el catálogo unificado de **Shadcn UI** con 4 registries: `shadcn`, `basecn`, `reactbits` y `blocks-so`).
 *   ⚙️ **`opencode.json`** — La configuración maestra de seguridad, variables de entorno, plugins y servidores MCP de tu bot.
 *   🖥️ **`tui.json`** — Configuración personalizada para la interfaz interactiva de terminal (TUI).
 
@@ -167,6 +167,30 @@ Para publicar una nueva versión de Zugzbot en el registro público de NPM:
 
 ---
 
+## 📝 Tracking Granular de Cambios y Costos (v1.6.0+)
+
+Desde la versión **1.6.0**, cada vez que el arnés cierra un ciclo (transición a `F0_DETECT`), el plugin `sdd-bridge` captura automáticamente un **changelog markdown estructurado** en `.openspec/changelog/<command>-<timestamp>.md` con:
+
+- Prompt literal del usuario
+- Costo exacto, tokens entrada/salida y duración
+- Breakdown por agente (`plan`, `build`, `sdd-coder`, etc.)
+- Diff completo (archivos tocados, líneas +/-) capturado vía `git diff`
+
+El comando **`/cost`** (incluido desde 1.6.0) muestra en cualquier momento:
+- Sesión activa con totales en vivo
+- Últimos 10 changelogs del proyecto
+- Top 5 specs más caros desde el historial agregado
+
+**Tres piezas clave del sistema:**
+
+| Archivo | Rol |
+|---|---|
+| `.opencode/tools/sdd_diff_capture.ts` | Tool MCP que ejecuta `git diff --numstat` + `--name-status` + `ls-files --others` |
+| `.opencode/tools/sdd_changelog.ts` | Tool MCP que escribe `.openspec/changelog/<command>-<ts>.md` + actualiza `INDEX.md` |
+| `.opencode/commands/cost.md` | Comando `/cost` con 3 secciones (sesión, changelogs, histórico) |
+
+---
+
 ## 📄 Licencia
 
 Este proyecto se distribuye bajo la licencia **MIT**. Siéntete libre de clonarlo, modificarlo y adaptarlo para construir tus propios equipos de agentes automatizados.

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "zugzbot",
-  "version": "1.5.0",
+  "version": "1.7.0",
+
   "description": "Fácil instalador del arnés SDD de Zugzbot para proyectos OpenCode",
   "type": "module",
   "bin": {