zugzbot 1.5.0 → 1.6.0

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)

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_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/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,6 @@
 {
   "name": "zugzbot",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Fácil instalador del arnés SDD de Zugzbot para proyectos OpenCode",
   "type": "module",
   "bin": {