zugzbot 1.0.18 → 1.0.20

package/.opencode/tools/sdd_network.ts

@@ -0,0 +1,152 @@
+import { tool } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+import { execSync, spawn } from "child_process"
+
+// Helper to safely resolve root directory (avoiding OpenCode bug where worktree is '/' in non-git repos)
+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();
+};
+
+// Helper to get PID file path
+const getPidFilePath = (root: string) => {
+  return path.resolve(root, ".openspec/dev_server.pid")
+}
+
+// Tool: sdd_free_port
+export const free_port = tool({
+  description: "Busca y termina de manera forzada cualquier proceso que esté escuchando en un puerto específico",
+  args: {
+    port: tool.schema.number().describe("El puerto a liberar (ej. 3000 o 8000)")
+  },
+  async execute(args, context) {
+    const port = args.port
+    try {
+      const pid = execSync(`lsof -t -i :${port}`).toString().trim()
+      if (pid) {
+        execSync(`kill -9 ${pid.split('\n').join(' ')}`)
+        return JSON.stringify({
+          status: "SUCCESS",
+          message: `Puerto ${port} liberado. Procesos terminados: ${pid.split('\n').join(', ')}`
+        }, null, 2)
+      }
+      return JSON.stringify({
+        status: "SUCCESS",
+        message: `Puerto ${port} ya estaba libre (no se encontraron procesos)`
+      }, null, 2)
+    } catch (e) {
+      return JSON.stringify({
+        status: "SUCCESS",
+        message: `Puerto ${port} está libre`
+      }, null, 2)
+    }
+  }
+})
+
+// Tool: sdd_start_server
+export const start_server = tool({
+  description: "Inicia un servidor de desarrollo o producción en segundo plano y registra su PID para limpieza posterior",
+  args: {
+    command: tool.schema.string().describe("Comando para iniciar el servidor (ej. 'yarn dev' o 'npm run dev')"),
+    port: tool.schema.number().optional().default(3000).describe("Puerto esperado del servidor (default: 3000)"),
+    cwd: tool.schema.string().optional().describe("Directorio de trabajo para ejecutar el comando")
+  },
+  async execute(args, context) {
+    const root = getRoot(context)
+    const targetCwd = args.cwd ? path.resolve(root, args.cwd) : root
+    const pidFile = getPidFilePath(root)
+
+    try {
+      const existingPid = execSync(`lsof -t -i :${args.port}`).toString().trim()
+      if (existingPid) {
+        execSync(`kill -9 ${existingPid.split('\n').join(' ')}`)
+      }
+    } catch (e) {
+      // ignore
+    }
+
+    const parts = args.command.split(" ")
+    const cmd = parts[0]
+    const cmdArgs = parts.slice(1)
+
+    const child = spawn(cmd, cmdArgs, {
+      cwd: targetCwd,
+      detached: true,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        PORT: String(args.port)
+      }
+    })
+
+    child.unref()
+
+    const pid = child.pid
+    if (pid) {
+      const dir = path.dirname(pidFile)
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true })
+      }
+      fs.writeFileSync(pidFile, String(pid), "utf8")
+
+      await new Promise(resolve => setTimeout(resolve, 3000))
+
+      return JSON.stringify({
+        status: "SUCCESS",
+        message: `Servidor iniciado con PID ${pid} ejecutando '${args.command}' en puerto ${args.port}`,
+        pid
+      }, null, 2)
+    }
+
+    return JSON.stringify({
+      status: "ERROR",
+      message: `No se pudo obtener el PID del proceso para el comando '${args.command}'`
+    }, null, 2)
+  }
+})
+
+// Tool: sdd_stop_server
+export const stop_server = tool({
+  description: "Detiene el servidor en segundo plano usando el PID registrado",
+  args: {},
+  async execute(args, context) {
+    const root = getRoot(context)
+    const pidFile = getPidFilePath(root)
+
+    if (fs.existsSync(pidFile)) {
+      try {
+        const pidStr = fs.readFileSync(pidFile, "utf8").trim()
+        const pid = parseInt(pidStr, 10)
+        if (!isNaN(pid)) {
+          try {
+            process.kill(-pid, "SIGKILL")
+          } catch (err) {
+            try {
+              process.kill(pid, "SIGKILL")
+            } catch (err2) {
+              // ignore
+            }
+          }
+          fs.unlinkSync(pidFile)
+          return JSON.stringify({
+            status: "SUCCESS",
+            message: `Servidor con PID ${pid} terminado exitosamente`
+          }, null, 2)
+        }
+      } catch (e) {
+        return JSON.stringify({
+          status: "ERROR",
+          message: `Error al intentar detener el servidor: ${(e as Error).message}`
+        }, null, 2)
+      }
+    }
+
+    return JSON.stringify({
+      status: "SUCCESS",
+      message: "No hay ningún servidor registrado activo"
+    }, null, 2)
+  }
+})

package/.opencode/tools/sdd_testing.ts

@@ -0,0 +1,362 @@
+import { tool } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+import { execSync } from "child_process"
+
+// Helper to safely resolve root directory (avoiding OpenCode bug where worktree is '/' in non-git repos)
+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();
+};
+
+// Helper to parse semantic errors from compiler and linter outputs (reducing raw trace log bloat for the LLM)
+const parseSemanticErrors = (rawOutput: string, type: "eslint" | "tsc"): any[] => {
+  const parsed: any[] = []
+  if (type === "eslint") {
+    const lines = rawOutput.split("\n")
+    for (const line of lines) {
+      const match = line.match(/^([^:]+):line\s+(\d+),\s+col\s+(\d+),\s+(.+)$/i) || line.match(/^([^\s]+):(\d+):(\d+):\s+(.+)$/)
+      if (match) {
+        parsed.push({
+          file: match[1].trim(),
+          line: parseInt(match[2], 10),
+          column: parseInt(match[3], 10),
+          error: match[4].trim()
+        })
+      } else if (line.includes("error") && line.trim().length > 0) {
+        parsed.push({ raw: line.trim() })
+      }
+    }
+  } else if (type === "tsc") {
+    const lines = rawOutput.split("\n")
+    for (const line of lines) {
+      const match = line.match(/^([^(]+)\((\d+),(\d+)\):\s+(error\s+TS\d+:\s+.+)$/)
+      if (match) {
+        parsed.push({
+          file: match[1].trim(),
+          line: parseInt(match[2], 10),
+          column: parseInt(match[3], 10),
+          error: match[4].trim()
+        })
+      } else if (line.includes("error TS") && line.trim().length > 0) {
+        parsed.push({ raw: line.trim() })
+      }
+    }
+  }
+  return parsed.length > 0 ? parsed : [{ raw: rawOutput.slice(0, 1500) }]
+}
+
+// Tool: sdd_quick_lint
+export const quick_lint = tool({
+  description: "Ejecuta el linter del proyecto (eslint) restringido a src/. Devuelve exit code y warnings. Usado como gate automático antes de transicionar a F3.",
+  args: {},
+  async execute(args, context) {
+    const root = getRoot(context)
+
+    const pkgPath = path.resolve(root, "package.json")
+    if (!fs.existsSync(pkgPath)) {
+      return JSON.stringify({
+        status: "ERROR",
+        message: "No se encontró package.json. ¿Estás en un proyecto Next.js?",
+      }, null, 2)
+    }
+
+    let eslintFiles = "src/"
+    try {
+      const stateFile = path.resolve(root, ".openspec/sdd_state.json")
+      if (fs.existsSync(stateFile)) {
+        const state = JSON.parse(fs.readFileSync(stateFile, "utf8"))
+        if (state.activeContract) {
+          const contractPath = path.resolve(root, state.activeContract)
+          if (fs.existsSync(contractPath)) {
+            const contract = JSON.parse(fs.readFileSync(contractPath, "utf8"))
+            if (contract && Array.isArray(contract.files_affected) && contract.files_affected.length > 0) {
+              const existingFiles = contract.files_affected.filter((f: string) => fs.existsSync(path.resolve(root, f)))
+              if (existingFiles.length > 0) {
+                eslintFiles = existingFiles.join(" ")
+              }
+            }
+          }
+        }
+      }
+    } catch (e) {
+      // ignore
+    }
+
+    try {
+      const out = execSync(`npx eslint ${eslintFiles} --quiet --max-warnings 0 2>&1 || true`, {
+        cwd: root,
+        encoding: "utf8",
+        timeout: 120_000,
+      })
+      const hasErrors = out.toLowerCase().includes("error") || out.trim().length > 0
+      return JSON.stringify({
+        status: hasErrors ? "FAIL" : "SUCCESS",
+        message: hasErrors ? `Lint encontró errores en: ${eslintFiles}. Corrígelos antes de transicionar a F3.` : "Lint limpio.",
+        output: out.slice(0, 2000),
+      }, null, 2)
+    } catch (e: any) {
+      return JSON.stringify({
+        status: "FAIL",
+        message: `Lint falló: ${e.message?.slice(0, 500) || "unknown error"}`,
+      }, null, 2)
+    }
+  }
+})
+
+// Tool: sdd_shift_left_verify
+export const shift_left_verify = tool({
+  description: "Ejecuta validaciones estáticas Shift-Left completas en el proyecto: ejecuta el compilador de TypeScript (tsc) y el linter (eslint) de manera combinada. Limpia y parsea semánticamente los stack traces y logs de error crudos, devolviendo un JSON limpio y estructurado de errores que el LLM puede digerir y solucionar de inmediato sin perder atención.",
+  args: {},
+  async execute(args, context) {
+    const root = getRoot(context)
+    const result: { tsc: { status: string, errors?: any[] }, eslint: { status: string, errors?: any[] } } = {
+      tsc: { status: "SUCCESS" },
+      eslint: { status: "SUCCESS" }
+    }
+
+    // 1. Run tsc --noEmit
+    try {
+      execSync("npx tsc --noEmit", { cwd: root, stdio: "pipe", timeout: 60000 })
+    } catch (e: any) {
+      const rawOutput = e.stdout?.toString() || e.stderr?.toString() || ""
+      const errors = parseSemanticErrors(rawOutput, "tsc")
+      result.tsc = {
+        status: "FAIL",
+        errors
+      }
+    }
+
+    // 2. Run eslint targeting modified files dynamically
+    let eslintFiles = "src/"
+    try {
+      const stateFile = path.resolve(root, ".openspec/sdd_state.json")
+      if (fs.existsSync(stateFile)) {
+        const state = JSON.parse(fs.readFileSync(stateFile, "utf8"))
+        if (state.activeContract) {
+          const contractPath = path.resolve(root, state.activeContract)
+          if (fs.existsSync(contractPath)) {
+            const contract = JSON.parse(fs.readFileSync(contractPath, "utf8"))
+            if (contract && Array.isArray(contract.files_affected) && contract.files_affected.length > 0) {
+              const existingFiles = contract.files_affected.filter((f: string) => fs.existsSync(path.resolve(root, f)))
+              if (existingFiles.length > 0) {
+                eslintFiles = existingFiles.join(" ")
+              }
+            }
+          }
+        }
+      }
+    } catch (e) {
+      // ignore
+    }
+
+    try {
+      const out = execSync(`npx eslint ${eslintFiles} --quiet 2>&1 || true`, {
+        cwd: root,
+        encoding: "utf8",
+        timeout: 60000,
+      })
+      const isCircularError = out.toLowerCase().includes("converting circular structure")
+      if ((out.toLowerCase().includes("error") || out.trim().length > 0) && !isCircularError) {
+        const errors = parseSemanticErrors(out, "eslint")
+        result.eslint = {
+          status: "FAIL",
+          errors
+        }
+      }
+    } catch (e: any) {
+      result.eslint = {
+        status: "FAIL",
+        errors: [{ raw: e.message || "Eslint execution error" }]
+      }
+    }
+
+    const overallSuccess = result.tsc.status === "SUCCESS" && result.eslint.status === "SUCCESS"
+
+    return JSON.stringify({
+      status: overallSuccess ? "SUCCESS" : "FAIL",
+      message: overallSuccess ? "Shift-Left Verification exitosa: Cero errores de compilación y cero errores de lint." : "Validación fallida: Se encontraron errores estáticos.",
+      verification: result
+    }, null, 2)
+  }
+})
+
+// Tool: sdd_generate_tests
+export const generate_tests = tool({
+  description: "Autogenera plantillas de pruebas unitarias/integración en tests/unit/ a partir de los escenarios de prueba descritos en el contrato activo de sdd_state.json. No pisa archivos de pruebas existentes.",
+  args: {},
+  async execute(args, context) {
+    const root = getRoot(context)
+    const stateFile = path.resolve(root, ".openspec/sdd_state.json")
+    if (!fs.existsSync(stateFile)) {
+      return JSON.stringify({ success: false, error: "sdd_state.json no existe. Inicia una sesión SDD primero." }, null, 2)
+    }
+    const state = JSON.parse(fs.readFileSync(stateFile, "utf8"))
+    const activeContract = state.activeContract
+    if (!activeContract) {
+      return JSON.stringify({ success: false, error: "El estado activo no tiene un activeContract. El orquestador debe fijar la sesión." }, null, 2)
+    }
+    const contractPath = path.resolve(root, activeContract)
+    if (!fs.existsSync(contractPath)) {
+      return JSON.stringify({ success: false, error: `El archivo del contrato '${contractPath}' no existe.` }, null, 2)
+    }
+    const contract = JSON.parse(fs.readFileSync(contractPath, "utf8"))
+    const test_scenarios = contract.test_scenarios || []
+    if (test_scenarios.length === 0) {
+      return JSON.stringify({ success: true, message: "No se encontraron test_scenarios en el contrato. No hay plantillas que generar." }, null, 2)
+    }
+    
+    const grouped_tests: Record<string, any[]> = {}
+    for (const ts of test_scenarios) {
+      const feature = ts.feature_ref || "general"
+      if (!grouped_tests[feature]) grouped_tests[feature] = []
+      grouped_tests[feature].push(ts)
+    }
+    
+    const created: string[] = []
+    const skipped: string[] = []
+    
+    for (const [feature, scenarios] of Object.entries(grouped_tests)) {
+      const clean_feature = feature.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "")
+      const hasReact = scenarios.some(s => s.type === "unit" || s.type === "visual")
+      const ext = hasReact ? "tsx" : "ts"
+      const test_dir = path.resolve(root, "tests", "unit")
+      if (!fs.existsSync(test_dir)) {
+        fs.mkdirSync(test_dir, { recursive: true })
+      }
+      const test_file = path.join(test_dir, `${clean_feature}.test.${ext}`)
+      
+      if (fs.existsSync(test_file)) {
+        skipped.push(`tests/unit/${clean_feature}.test.${ext}`)
+        continue
+      }
+      
+      const lines: string[] = []
+      lines.push('import { describe, it, expect } from "vitest";')
+      if (hasReact) {
+        lines.push('import { render, screen } from "@testing-library/react";')
+        lines.push('import userEvent from "@testing-library/user-event";')
+        lines.push(`// import ${feature} from "@/components/blocks/${clean_feature}";`)
+      }
+      lines.push("")
+      lines.push(`describe("${feature} Tests (Contract Scenarios)", () => {`)
+      
+      for (const s of scenarios) {
+        const tid = s.id || "TS-XX"
+        const name = s.name || "Test case"
+        lines.push(`  // ${tid}: ${name}`)
+        lines.push(`  // Given: ${s.given || ""}`)
+        lines.push(`  // When: ${s.when || ""}`)
+        lines.push(`  // Then: ${s.then || ""}`)
+        lines.push(`  it("${tid}: ${name}", async () => {`)
+        lines.push('    // TODO: Implement actual contract assertions')
+        lines.push('    expect(true).toBe(true);')
+        lines.push('  });')
+        lines.push("")
+      }
+      lines.push("});")
+      
+      fs.writeFileSync(test_file, lines.join("\n").trim() + "\n", "utf8")
+      created.push(`tests/unit/${clean_feature}.test.${ext}`)
+    }
+    
+    return JSON.stringify({
+      status: "SUCCESS",
+      message: "Generación de plantillas de prueba completada.",
+      created,
+      skipped
+    }, null, 2)
+  }
+})
+
+// Tool: sdd_save_playwright_artifacts
+export const save_playwright_artifacts = tool({
+  description: "Promueve y archiva los artefactos de captura visual/videos (.openspec/.playwright/) generados por Playwright a la carpeta del spec/contrato activo de forma ordenada, evitando ensuciar la raíz.",
+  args: {
+    callId: tool.schema.string().optional().describe("ID de llamada de Playwright MCP específica. Si no se pasa, toma la última ejecución de forma automática."),
+    move: tool.schema.boolean().default(false).describe("Si true, mueve los archivos en lugar de copiarlos.")
+  },
+  async execute(args, context) {
+    const root = getRoot(context)
+    const stateFile = path.resolve(root, ".openspec/sdd_state.json")
+    if (!fs.existsSync(stateFile)) {
+      return JSON.stringify({ success: false, error: "sdd_state.json no existe. Inicia una sesión SDD primero." }, null, 2)
+    }
+    const state = JSON.parse(fs.readFileSync(stateFile, "utf8"))
+    const activeContract = state.activeContract
+    if (!activeContract) {
+      return JSON.stringify({ success: false, error: "El estado activo no tiene un activeContract. El orquestador debe fijar la sesión." }, null, 2)
+    }
+    const contractPath = path.resolve(root, activeContract)
+    if (!fs.existsSync(contractPath)) {
+      return JSON.stringify({ success: false, error: `El archivo del contrato '${contractPath}' no existe.` }, null, 2)
+    }
+    const activeDir = path.dirname(contractPath)
+    const sourceBase = path.resolve(root, ".openspec/.playwright")
+    if (!fs.existsSync(sourceBase)) {
+      return JSON.stringify({ success: true, message: "No existen carpetas de Playwright para archivar en .openspec/.playwright." }, null, 2)
+    }
+    
+    let callId = args.callId
+    if (!callId) {
+      const files = fs.readdirSync(sourceBase).filter(f => fs.statSync(path.join(sourceBase, f)).isDirectory())
+      if (files.length === 0) {
+        return JSON.stringify({ success: true, message: "No hay carpetas de artefactos de Playwright disponibles en .openspec/.playwright" }, null, 2)
+      }
+      // sort by mtime descending to get the newest
+      files.sort((a, b) => {
+        return fs.statSync(path.join(sourceBase, b)).mtimeMs - fs.statSync(path.join(sourceBase, a)).mtimeMs
+      })
+      callId = files[0]
+    }
+    
+    const sourceDir = path.join(sourceBase, callId)
+    if (!fs.existsSync(sourceDir)) {
+      return JSON.stringify({ success: false, error: `La ruta de origen '${sourceDir}' no existe.` }, null, 2)
+    }
+    
+    const destDir = path.join(activeDir, "playwright", callId)
+    if (!fs.existsSync(destDir)) {
+      fs.mkdirSync(destDir, { recursive: true })
+    }
+    
+    const copyRecursiveSync = (src: string, dest: string, moveMode: boolean) => {
+      const exists = fs.existsSync(src)
+      const stats = exists ? fs.statSync(src) : null
+      const isDirectory = stats ? stats.isDirectory() : false
+      if (isDirectory) {
+        if (!fs.existsSync(dest)) {
+          fs.mkdirSync(dest, { recursive: true })
+        }
+        fs.readdirSync(src).forEach((childItemName) => {
+          copyRecursiveSync(path.join(src, childItemName), path.join(dest, childItemName), moveMode)
+        })
+        if (moveMode) {
+          fs.rmdirSync(src)
+        }
+      } else {
+        fs.copyFileSync(src, dest)
+        if (moveMode) {
+          fs.unlinkSync(src)
+        }
+      }
+    }
+    
+    try {
+      copyRecursiveSync(sourceDir, destDir, args.move)
+      return JSON.stringify({
+        status: "SUCCESS",
+        message: `Artefactos archivados con éxito en la sesión activa.`,
+        callId,
+        destination: destDir
+      }, null, 2)
+    } catch (e: any) {
+      return JSON.stringify({
+        status: "ERROR",
+        error: e.message
+      }, null, 2)
+    }
+  }
+})

package/opencode.json

@@ -1,6 +1,5 @@
 {
   "$schema": "https://opencode.ai/config.json",
-  "theme": "tokyonight",
   "permission": {
     "*": "allow",
     "skill": {
@@ -92,112 +91,5 @@
       "enabled": true,
       "purpose": "Permite buscar, filtrar y obtener ejemplos de uso JSX de más de 1,500 iconos de Lucide React de forma exacta mediante herramientas del MCP."
     }
-  },
-  "agent": {
-    "sdd-orchestrator": {
-      "description": "Coordinador principal del flujo SDD y del stack cerrado",
-      "mode": "primary",
-      "model": "deepseek/deepseek-v4-flash",
-      "prompt": "{file:./.opencode/rules/sdd-global.md}\n\n{file:./.opencode/agents/sdd-orchestrator.md}",
-      "permission": {
-        "*": "allow",
-        "write": {
-          ".openspec/*": "allow",
-          ".openspec/**": "allow",
-          ".opencode/*": "allow",
-          ".opencode/**": "allow",
-          "*": "deny"
-        },
-        "edit": "deny",
-        "bash": "deny",
-        "task": {
-          "*": "deny",
-          "sdd-*": "allow"
-        }
-      }
-    },
-    "sdd-spec-writer": {
-      "description": "Redacta y valida contratos OpenAPI e interfaces en specs/",
-      "mode": "subagent",
-      "hidden": true,
-      "model": "deepseek/deepseek-v4-flash",
-      "prompt": "{file:./.opencode/rules/sdd-global.md}\n\n{file:./.opencode/agents/sdd-spec-writer.md}",
-      "permission": {
-        "*": "allow",
-        "bash": "deny"
-      }
-    },
-    "sdd-coder": {
-      "description": "Implementa código ajustándose estrictamente a los contratos en specs/",
-      "mode": "subagent",
-      "hidden": true,
-      "steps": 10,
-      "model": "deepseek/deepseek-v4-flash",
-      "temperature": 0.35,
-      "frequency_penalty": 0.5,
-      "presence_penalty": 0.2,
-      "prompt": "{file:./.opencode/rules/sdd-global.md}\n\n{file:./.opencode/agents/sdd-coder.md}",
-      "permission": {
-        "*": "allow",
-        "bash": {
-          "*": "ask",
-          "npm *": "allow",
-          "pnpm *": "allow",
-          "yarn *": "allow",
-          "vitest *": "allow",
-          "npx eslint *": "allow",
-          "eslint *": "allow",
-          "pytest *": "allow",
-          "python3 *": "allow",
-          "python *": "allow",
-          "uv *": "allow",
-          "pip *": "allow",
-          "npx *": "allow",
-          "npx shadcn*": "allow",
-          "cat *": "allow"
-        }
-      }
-    },
-    "sdd-tester": {
-      "description": "Diseña y corre pruebas unitarias, integración y visuales (Playwright)",
-      "mode": "subagent",
-      "hidden": true,
-      "steps": 15,
-      "model": "deepseek/deepseek-v4-flash",
-      "temperature": 0.35,
-      "frequency_penalty": 0.5,
-      "presence_penalty": 0.2,
-      "prompt": "{file:./.opencode/rules/sdd-global.md}\n\n{file:./.opencode/agents/sdd-tester.md}",
-      "permission": {
-        "*": "allow",
-        "bash": {
-          "*": "ask",
-          "npm *": "allow",
-          "pnpm *": "allow",
-          "yarn *": "allow",
-          "vitest *": "allow",
-          "npx eslint *": "allow",
-          "eslint *": "allow",
-          "pytest *": "allow",
-          "python3 *": "allow",
-          "python *": "allow",
-          "uv *": "allow",
-          "pip *": "allow",
-          "npx *": "allow",
-          "npx shadcn*": "allow",
-          "cat *": "allow"
-        }
-      }
-    },
-    "sdd-deployer": {
-      "description": "Limpia Docker y realiza el despliegue local del sistema",
-      "mode": "subagent",
-      "hidden": true,
-      "model": "deepseek/deepseek-v4-flash",
-      "prompt": "{file:./.opencode/agents/sdd-deployer.md}",
-      "permission": {
-        "*": "allow"
-      }
-    }
   }
 }

package/package.json

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

package/tui.json

@@ -1,6 +1,14 @@
 {
   "$schema": "https://opencode.ai/tui.json",
+  "theme": "tokyonight",
   "plugin": [
     "./.opencode/plugins/plugin_tui.tsx"
-  ]
+  ],
+  "keybinds": {
+    "leader": "ctrl+x",
+    "sidebar_toggle": "leader,b",
+    "theme_list": "leader,t",
+    "session_list": "leader,l",
+    "editor_open": "leader,e"
+  }
 }