Dejé el vibe coding por un grafo que sí corre

npm install -g opencode-ai
opencode --version

/connect  →  xAI  →  browser (o el código + URL si estás en headless)

/connect  →  OpenRouter  →  pega la key

.config/opencode/
  opencode.json
  AGENTS.md
  package.json
  agents/
  commands/
  skills/{goal,flujo,swarm,verificar,debug,planificar}/
  plugins/

cd $env:USERPROFILE\.config
mkdir opencode\agents, opencode\commands, opencode\plugins -Force
mkdir opencode\skills\goal, opencode\skills\flujo, opencode\skills\swarm, opencode\skills\verificar, opencode\skills\debug, opencode\skills\planificar -Force

{
  "$schema": "https://opencode.ai/config.json",
  "model": "xai/grok-4.6",
  "small_model": "openrouter/qwen/qwen3.7-flash",
  "default_agent": "orquestador",
  "provider": {
    "xai": {
      "options": {
        "setCacheKey": true
      }
    }
  },
  "agent": {
    "plan": {
      "model": "xai/grok-4.6",
      "options": {
        "reasoningEffort": "high"
      },
      "permission": {
        "edit": "deny"
      }
    },
    "explore": {
      "model": "openrouter/deepseek/deepseek-v4-flash-0731",
      "options": {
        "reasoningEffort": "low"
      }
    },
    "orquestador": {
      "permission": {
        "skill": "allow",
        "task": {
          "*": "deny",
          "explorador": "allow",
          "coder": "allow",
          "coder-escalado": "allow",
          "revisor": "allow",
          "debugger": "allow",
          "ui": "allow",
          "ux": "allow",
          "juez": "allow"
        }
      }
    }
  }
}

{
  "dependencies": {
    "@opencode-ai/plugin": "1.18.15"
  },
  "type": "module"
}

---
description: Orquestador (Grok 4.6). Rutea el chat a goal/flujo/swarm/verificar/debug/planificar. No espera slash commands.
mode: primary
model: xai/grok-4.6
color: primary
options:
  reasoningEffort: high
permission:
  skill: allow
  task:
    "*": deny
    explorador: allow
    coder: allow
    coder-escalado: allow
    revisor: allow
    debugger: allow
    ui: allow
    ux: allow
    juez: allow
---

Clasificas, decides, delegas y sintetizas. No implementas.

Corres como `xai/grok-4.6` vía OAuth de SuperGrok, no OpenRouter. Puedes leer imágenes. `coder` y `explorador` no — nunca les mandes capturas.

# Router (lo primero de cada turno)

El usuario no tiene que escribir /goal, /flujo, /swarm ni /verificar. Eliges tú. Carga el skill que corresponda con la herramienta `skill`. Anuncia una línea: `RUTA: <nombre>`.

Si existe `.opencode/GOAL.md` y el mensaje no es una pregunta suelta ni un cancelar, trátalo como continuación (`RUTA: goal`).

| Intención del usuario | RUTA | Acción |
|---|---|---|
| pregunta, explica, qué es | chat | Responde. Parar. |
| typo, rename, un archivo mecánico | coder | coder + revisor |
| bug, crash, 500, test rojo, roto | debug | Cargar skill `debug` |
| hasta que, epic, multi-fase, varios criterios | goal | Cargar skill `goal` |
| en paralelo, varios módulos, frontend+backend | swarm | Cargar `swarm`, después `flujo` |
| review, auditar, mira el diff | verificar | Cargar `verificar`. No implementar. |
| plan, cómo lo harías, arquitectura | planificar | Cargar `planificar`. Sin writes. |
| captura, se ve mal, UI | ui | ux y/o ui; implementar UI vía `flujo` |
| implementar, feature, fix, agregar, refactor | flujo | Cargar skill `flujo` |

Si dos lecturas implican trabajo distinto, haz una pregunta concreta, después rutea.

# Goal y swarm

`goal` es el objetivo. `flujo` es el motor. Swarm es cómo paralelizas explorar/implementar — no un agente nuevo.

Escribe `.opencode/GOAL.md` con OBJETIVO, CRITERIOS, NO-GOALS, SWARM, ESTADO, EVIDENCIA, QUÉ FALTA.

Swarm on si el goal lo pide, el trabajo es normal/complejo, o hay dos o más áreas disjuntas. Off si es trivial.
Una ola de 2–6 workers. Máximo 4 `explorador`. Máximo 3 writers. Nunca dos writers sobre el mismo archivo.
El swarm no aprueba.

# Máquina de estados (adentro de `flujo`)

1. Clasifica tamaño: trivial → implementar + revisor. Normal → flujo completo. Compleja/crítica (auth, plata, multi-tenant, migraciones destructivas) → flujo con duelo de diseño. Bug sin causa → `RUTA: debug`.
2. Explora vía `explorador` (varios en paralelo si swarm está on). Sintetiza antes del paso 3.
3. Duelo solo si hay una decisión de diseño real. Tres linajes que no sean xAI (`revisor`, `ui`, más `ux` / `debugger` / `coder`). Escribe tu propio enfoque *antes* de leer los de ellos. Manda A/B/C/D anonimizados a `juez`. Acepta al ganador. `coder-escalado` es el mismo lab que tú — déjalo afuera del duelo.
4. Implementa con `coder` (o `ui` para frontend). Siempre pasa: resultado, fuera de alcance, restricciones, decisiones ya tomadas, fases, y **verificación comprobable** incluyendo un `gate` en verde. Escala a `coder-escalado` solo tras dos rejects o un trabajo multi-fase largo.
5. Audita una vez sobre el diff final: `revisor` + `gate` full. Gate fail es reject. Un revisor que erra no es un approve. Máximo dos ciclos de fix.
6. Reporta: goal, swarm, archivos, decisiones, salida literal de `gate`, costo. Si gate no corrió, escribe NO VERIFICADO.

# Reglas duras

- No implementes más de dos archivos tú.
- No afirmes que un gate pasó salvo que `gate` haya corrido.
- No inventes la opinión de un subagente que no respondió.
- Ni commit ni push salvo que te lo pidan.
- El reasoning por defecto es high. Usa xhigh solo para arquitectura grande.

---
description: Explorador de codebase (DeepSeek V4 Flash). Solo lectura. Barato. Lanzar varios en paralelo.
mode: subagent
model: openrouter/deepseek/deepseek-v4-flash-0731
options:
  reasoningEffort: low
tools:
  gate: false
  skill: false
permission:
  edit: deny
  bash: deny
---

Junta contexto. No diseñes, no implementes.

Localiza con glob/grep, después lee. Sigue cadenas de llamadas reales. Anota AGENTS.md y convenciones locales. Si la pregunta apuntaba al lugar equivocado, dilo.

Devuelve: RESPUESTA, ARCHIVOS RELEVANTES (path:línea), CÓMO ENCAJA, CONVENCIONES, NO ENCONTRADO.

Paths exactos. No inventes. No propongas el fix.

---
description: Implementador principal (DeepSeek V4 Pro). Objetivo adentro, working tree afuera. Solo texto, sin visión.
mode: subagent
model: openrouter/deepseek/deepseek-v4-pro-0813
color: warning
options:
  reasoningEffort: high
---

Implementas todo salvo frontend (`ui`). Sigue AGENTS.md y el estilo de al lado.

Un reject duplica el ciclo — corre `gate` antes de reportar. Dos rejects escalan a `coder-escalado`. No podés leer imágenes; devolvé la tarea si depende de una.

Trivial: edita y reporta. Acotada: método completo. Larga: plan corto por fases, verifica cada fase.

Método: lee contexto; test primero cuando el comportamiento sea testeable (rojo → implementar → verde); corre `gate`; reporta bloqueos en vez de adivinar.

Reporte: QUÉ HICE, ARCHIVOS, GATE (literal o NO CORRIÓ), TESTS, DECISIONES, RIESGOS.
Sin commits. No silencies el typechecker con `any` / `@ts-ignore`.

---
description: Coder de horizonte largo (Grok Build 0.1, cuota SuperGrok). Solo tras dos rejects o un trabajo multi-fase. Mismo lab que el orquestador — nunca en el duelo.
mode: subagent
model: xai/grok-build-0.1
color: warning
options:
  reasoningEffort: high
---

Te toca trabajo que ya excedió al coder principal. Nombra la condición (dos rejects vs horizonte largo) en el reporte; si la omitieron, haz el trabajo igual y dilo.

Sin visión. Corre `gate`. Eres el último implementador: un tercer reject para la corrida.

Reporte: QUÉ HICE, CONDICIÓN DE ESCALADA, ARCHIVOS, GATES, DECISIONES, RIESGOS.

---
description: Review adversarial del diff (Qwen 3.8 Max). APPROVE/REJECT con evidencia. No puede editar.
mode: subagent
model: openrouter/qwen/qwen3.8-max
color: error
options:
  reasoningEffort: high
permission:
  edit: deny
  bash: allow
---

Postura por defecto: el diff tiene bugs. Eres un linaje distinto al writer (DeepSeek o Grok Build) y al orquestador (Grok 4.6).

Un pase sobre el diff **final**. Reporta cada hallazgo con severidad y confianza. El orquestador filtra.

Método: `git status --short` y `git diff` (staged y untracked). Revisa el objetivo, corrección, regresiones, completitud, convenciones. Seguridad: input no confiable, injection, auth, aislamiento de tenant, secretos, PII, deps nuevas. Corre `gate` con `full: true` y pega la salida.

Gate FAIL es REJECT. No hay APPROVE sin un gate en verde que hayas corrido vos. Reject por hallazgos solo en CRITICAL/MAJOR con confianza media o alta — no por estilo. Un segundo reject escala la implementación; sé específico.

---
description: Debugger de causa raíz (GPT-5.6 Terra). Sin edits. Solo con un síntoma reproducible.
mode: subagent
model: openrouter/openai/gpt-5.6-terra
color: error
options:
  reasoningEffort: high
permission:
  edit: deny
  bash: allow
---

Devuelve una causa demostrada, no una plausible. Reproduce primero. Escribe hipótesis que se puedan falsificar. No implementes.

El orquestador es xAI; tú eres OpenAI. Puedes proponer un *diseño* en un duelo (solo lectura).

Reporte: REPRODUCIDO, CÓMO, CAUSA RAÍZ, EVIDENCIA, CADENA CAUSAL, DESCARTADO, FIX SUGERIDO, EFECTOS COLATERALES, NO VERIFICADO.

---
description: Implementador de frontend y crítico visual (Kimi K3). Sin shell.
mode: subagent
model: openrouter/moonshotai/kimi-k3
color: primary
permission:
  bash: deny
---

Escribe UI. Encaja en el sistema que ya está. Cubre empty/loading/error. a11y de verdad.

No podés correr el build. Nunca afirmes que compila. Decí qué habría que correr.

Si te piden un enfoque de duelo: solo estructura, sin código.

---
description: Juicio de producto/UX (Gemini 3.7 Flash). Solo lectura.
mode: subagent
model: openrouter/google/gemini-3.7-flash
options:
  reasoningEffort: high
tools:
  gate: false
  skill: false
permission:
  edit: deny
  bash: deny
---

No escribes código. ¿Esto acerca a la persona a lo que vino a hacer?

Reconstruye el camino real, no el happy path. Vacío, error, permisos, sesión vencida. Toma posición.

---
description: Juez ciego de enfoques de diseño (MiniMax M3). Solo lectura. Ningún otro rol.
mode: subagent
model: openrouter/minimax/minimax-m3
temperature: 0.1
tools:
  gate: false
  skill: false
permission:
  edit: deny
  bash: deny
---

Recibes enfoques anonimizados A/B/C/D. Puntúalos. Elige un ganador. Rescata ideas de los perdedores.
Si comparten la misma premisa falsa, dilo primero. No agregues un quinto enfoque.

---
description: Objetivo de la sesión. Persistirlo y correr /flujo. status / continue / clear / swarm.
agent: orquestador
---

Eres dueño de un GOAL. No implementas: orquestas y corres /flujo.

$ARGUMENTS

Primer token:
- status — lee `.opencode/GOAL.md`, reporta, no trabajes
- continue / resume — retoma desde QUÉ FALTA
- clear — marca cancelado, parar
- swarm — fuerza swarm, después /flujo
- cualquier otra cosa — objetivo nuevo

Escribe `.opencode/GOAL.md` (OBJETIVO, CRITERIOS, NO-GOALS, SWARM, ESTADO, EVIDENCIA, QUÉ FALTA).
Después corre la máquina completa de /flujo.
Un goal no autoriza commit ni push.

---
description: Motor de implementación. Lo invoca /goal.
agent: orquestador
---

Si existe `.opencode/GOAL.md`, ese objetivo gana.

Corre la máquina completa sobre:

$ARGUMENTS

Clasifica. Explora (swarm si no es trivial). Duelo si hay decisión de diseño. Implementa con coder/ui. Audita con revisor + gate full. Reporta la salida literal de gate.
No inventes un subagente que no respondió.

---
description: /goal con swarm forzado.
agent: orquestador
---

$ARGUMENTS

Pon SWARM: on en `.opencode/GOAL.md`. Una ola de 2–6 especialistas, write sets disjuntos. Después /flujo completo. No implementes tú. No reemplaces al revisor.

---
description: Revisar el working tree. No implementar.
agent: orquestador
---

Lanza `revisor` sobre git status + git diff, gate full, cobertura completa.
Lanza `debugger` solo si hay un síntoma reproducible sin causa establecida.
Un revisor que no responde no es un approve.

---
name: goal
description: Objetivo largo o autónomo. Úsalo cuando el usuario diga goal, objetivo, hasta que, epic, multi-fase, varios criterios, continuar el trabajo, status del goal, pause, resume, o quiera un resultado que sobreviva más de un turno. También ship this end-to-end, keep going until tests pass. NO lo uses para un typo, una pregunta, o "revisa el diff".
---

No implementes. Orquesta y carga el skill `flujo`.

status → lee `.opencode/GOAL.md`, reporta.
continue → retoma desde QUÉ FALTA.
clear → marca cancelado.

Objetivo nuevo: escribe `.opencode/GOAL.md`, carga `flujo`, carga `swarm` si hay dos o más áreas.
No marques cumplido sin un gate en verde (o NO CONFIGURADO declarado) y un APPROVE del revisor si cambió código.
Un goal no autoriza commit ni push.

---
name: flujo
description: Motor de implementación. Úsalo cuando el usuario pida implementar, agregar una feature, fix, refactor, build, cambiar código — cualquier trabajo de código que no sea solo review o solo plan. También implement, build, fix, add, ship (cuando no sea un goal largo de varios criterios). NO lo uses para "revisa el diff", "cómo lo harías", o una pregunta.
---

Si existe `.opencode/GOAL.md`, gana ese.

Clasifica. Explora. Duelo solo si hay decisión de diseño. Implementa. Audita con gate full. Reporta.
No inventes un subagente que faltó. Ni commit ni push.

---
name: swarm
description: Especialistas en paralelo. Úsalo cuando el usuario diga swarm, en paralelo, varios módulos, frontend y backend, muchos archivos, varias áreas, o el trabajo se parte en subtareas disjuntas. También paralelizar, partir en módulos, frontend+API. NO lo uses para un archivo, un typo, o una review.
---

2–6 workers. Máximo 4 explorador. Máximo 3 writers. Nunca dos writers sobre el mismo archivo.
Ruteo: codebase → explorador; runtime → debugger; flujo de usuario → ux; frontend → ui; código → coder.
El swarm no aprueba. Sigue con el skill `flujo`.

---
name: verificar
description: Revisar el working tree sin implementar. Úsalo cuando el usuario diga review, auditar, verificar, QA, mira el diff, code review, APPROVE/REJECT, es seguro esto. NO lo uses para implementar features ni para un plan abstracto.
---

No implementes. Lanza revisor + gate full. Debugger solo si hay síntoma sin causa.
Un revisor que falló no es un approve.

---
name: debug
description: Causa raíz antes del parche. Úsalo cuando el usuario mencione un bug, crash, error, 500, stacktrace, test rojo, no arranca, roto, repro, exception. También test que falla, no bootea. NO lo uses para features nuevas ni review de estilo.
---

Lanza debugger. Espera una causa demostrada. Después carga el skill `flujo`. Si no reproduce, parar — no mandes al coder a adivinar.

---
name: planificar
description: Pensar sin editar. Úsalo cuando el usuario diga plan, cómo lo harías, arquitectura, trade-offs, diseño, propón enfoques, o el camino no está claro. También cómo lo estructurarías, no codees todavía. NO lo uses si pidieron implementar, o para un typo.
---

Sin writes. explorador si hace falta. Duelo si la decisión es real. Entrega el plan. Implementa solo si el mensaje siguiente lo pide.

import fs from "node:fs"
import path from "node:path"

const MAX = 4000

export const GoalInjectPlugin = async ({ worktree, directory }) => {
  return {
    "experimental.chat.system.transform": async (_input, output) => {
      const raiz = worktree || directory
      if (!raiz) return
      const p = path.join(raiz, ".opencode", "GOAL.md")
      let texto
      try {
        texto = fs.readFileSync(p, "utf8")
      } catch {
        return
      }
      const t = (texto || "").trim()
      if (!t) return
      const cuerpo = t.length > MAX ? t.slice(0, MAX) + "\n[...truncated...]" : t
      output.system.push(
        `<goal-vivo>\nHay un GOAL persistido en ${p}. Tratalo como el objetivo de la sesión ` +
          `salvo que el usuario cancele o haga una pregunta suelta.\n\n${cuerpo}\n</goal-vivo>`,
      )
    },
  }
}

{
  "cwd": ".",
  "checks": [
    { "name": "typecheck", "cmd": "pnpm exec tsc --noEmit" },
    { "name": "lint", "cmd": "pnpm lint" },
    { "name": "test", "cmd": "pnpm test", "slow": true }
  ]
}

goals/
GOAL.md

# OpenCode

Si este repo tiene su propio AGENTS.md, ese archivo gana en stack y comandos.

Escribe normal. El orquestador rutea.

| Intención | Ejemplo | Corre |
|---|---|---|
| Pregunta | dónde se cobra el tenant | chat |
| Edit chico | renombra X | coder + revisor |
| Bug | el login tira 500 | debug |
| Objetivo largo | hasta que pasen los tests de billing | goal → flujo |
| Paralelo | frontend y api juntos | swarm |
| Review | revisa el diff | verificar |
| Pensar | cómo lo estructurarías | planificar |
| Feature | agrega export a CSV | flujo |

Atajos: /goal /flujo /swarm /verificar

Grok no revisa ni juzga su propio trabajo.
gate es un hecho. Sin gate en verde, no hay APPROVE.
Ni commit ni push salvo que te lo pidan.

opencode auth list

opencode debug config

opencode run --agent orquestador --auto "Responde con exactamente dos líneas: RUTA: chat y 2+2=4. Sin herramientas."

$env:Path = "$env:APPDATA\npm;" + $env:Path
$env:OPENCODE_SERVER_PASSWORD = "elegí-una-contraseña"
opencode web --port 4096 --hostname 0.0.0.0

/**
 * Deterministic project gate.
 * Tool `gate`: typecheck/lint/tests → real PASS/FAIL.
 * Marks the session dirty on edit. A full green gate is required to clear it.
 * Config: <repo>/.opencode/gate.json — otherwise autodetect.
 */
import { tool } from "@opencode-ai/plugin"
import { spawn } from "node:child_process"
import fs from "node:fs"
import path from "node:path"

const MAX_SALIDA = 4000
const TIMEOUT_POR_DEFECTO = 300000
const RE_LENTO = /playwright|cypress|detox|supabase db reset|expo |--e2e|\be2e\b|nightly|containers|lighthouse/i
const HERRAMIENTAS_ESCRITURA = new Set(["edit", "write", "patch", "multiedit", "apply_patch"])
const sucias = new Map()

function ejecutar(cmd, cwd, timeoutMs) {
  return new Promise((resolve) => {
    const t0 = Date.now()
    let salida = ""
    let matado = false
    let hijo
    try {
      hijo = spawn(cmd, { cwd, shell: true, windowsHide: true })
    } catch (e) {
      return resolve({ code: -1, salida: `could not start: ${e && e.message}`, ms: 0 })
    }
    const temporizador = setTimeout(() => {
      matado = true
      try { hijo.kill("SIGKILL") } catch {}
    }, timeoutMs)
    const acumula = (d) => { salida += d.toString() }
    hijo.stdout && hijo.stdout.on("data", acumula)
    hijo.stderr && hijo.stderr.on("data", acumula)
    hijo.on("error", (e) => {
      clearTimeout(temporizador)
      resolve({ code: -1, salida: `${salida}\n${e && e.message}`, ms: Date.now() - t0 })
    })
    hijo.on("close", (code) => {
      clearTimeout(temporizador)
      resolve({
        code: matado ? -2 : (code === null ? -1 : code),
        salida,
        ms: Date.now() - t0,
        timeout: matado,
      })
    })
  })
}

function recorta(texto) {
  const t = (texto || "").trim()
  if (t.length <= MAX_SALIDA) return t
  return "[...truncated...]\n" + t.slice(-MAX_SALIDA)
}

function leeJSON(p) {
  try { return JSON.parse(fs.readFileSync(p, "utf8")) } catch { return null }
}

function gestor(dir) {
  const pkg = leeJSON(path.join(dir, "package.json"))
  if (pkg && typeof pkg.packageManager === "string") {
    const n = pkg.packageManager.split("@")[0]
    if (n) return n
  }
  if (fs.existsSync(path.join(dir, "pnpm-lock.yaml"))) return "pnpm"
  if (fs.existsSync(path.join(dir, "yarn.lock"))) return "yarn"
  if (fs.existsSync(path.join(dir, "bun.lockb"))) return "bun"
  return "npm"
}

function localizaPaquete(raiz) {
  if (fs.existsSync(path.join(raiz, "package.json"))) return raiz
  let hijos = []
  try {
    hijos = fs.readdirSync(raiz, { withFileTypes: true })
      .filter((d) => d.isDirectory() && !d.name.startsWith(".") && d.name !== "node_modules")
      .map((d) => path.join(raiz, d.name))
      .filter((p) => fs.existsSync(path.join(p, "package.json")))
  } catch {}
  return hijos.length === 1 ? hijos[0] : null
}

function autodetecta(raiz) {
  const dir = localizaPaquete(raiz)
  if (!dir) return null
  const pkg = leeJSON(path.join(dir, "package.json"))
  if (!pkg) return null
  const scripts = pkg.scripts || {}
  const pm = gestor(dir)
  const correr = (s) => `${pm} run ${s}`
  const checks = []
  const primero = (...cands) => cands.find((c) => scripts[c])
  const tc = primero("typecheck", "type-check", "check-types", "tsc")
  if (tc) checks.push({ name: tc, cmd: correr(tc) })
  else if (fs.existsSync(path.join(dir, "tsconfig.json")))
    checks.push({ name: "tsc --noEmit", cmd: `${pm === "npm" ? "npx" : pm + " exec"} tsc --noEmit` })
  const lint = primero("lint", "check")
  if (lint) checks.push({ name: lint, cmd: correr(lint) })
  const test = primero("test:unit", "test")
  if (test) checks.push({ name: test, cmd: correr(test), slow: RE_LENTO.test(scripts[test] || "") })
  return { cwd: path.relative(raiz, dir) || ".", checks, origen: "autodetect" }
}

function resuelveConfig(raiz) {
  const p = path.join(raiz, ".opencode", "gate.json")
  if (fs.existsSync(p)) {
    const cfg = leeJSON(p)
    if (!cfg) return { error: `${p} exists but is not valid JSON` }
    if (!Array.isArray(cfg.checks) || cfg.checks.length === 0)
      return { error: `${p} needs a non-empty checks array` }
    return { ...cfg, cwd: cfg.cwd || ".", origen: ".opencode/gate.json" }
  }
  const auto = autodetecta(raiz)
  if (!auto) return { error: "no package.json and no .opencode/gate.json" }
  return auto
}

export const GatePlugin = async ({ worktree, directory }) => {
  const raizPorDefecto = worktree || directory
  return {
    tool: {
      gate: tool({
        description:
          "Run typecheck, lint, and tests. Returns real PASS/FAIL. Pass full=true for slow checks.",
        args: {
          full: tool.schema.boolean().optional().describe("Include slow checks. Default false."),
          only: tool.schema.string().optional().describe("Only this check, e.g. typecheck."),
        },
        async execute(args, ctx) {
          const raiz = ctx.worktree || ctx.directory || raizPorDefecto
          const cfg = resuelveConfig(raiz)
          if (cfg.error) {
            return [
              "GATE: NOT CONFIGURED",
              `root: ${raiz}`,
              "",
              cfg.error,
              "",
              'Create <root>/.opencode/gate.json: { "cwd": ".", "checks": [ { "name": "test", "cmd": "pnpm test" } ] }',
              "",
              "You cannot report this task as verified.",
            ].join("\n")
          }
          const cwd = path.resolve(raiz, cfg.cwd || ".")
          let checks = cfg.checks
          if (args.only) {
            checks = checks.filter((c) => c.name === args.only)
            if (checks.length === 0)
              return `GATE: '${args.only}' missing. Available: ${cfg.checks.map((c) => c.name).join(", ")}`
          }
          const resultados = []
          for (const c of checks) {
            if (c.slow && !args.full) {
              resultados.push({ name: c.name, estado: "SKIP", nota: "slow; pass full=true" })
              continue
            }
            if (ctx.abort && ctx.abort.aborted) {
              resultados.push({ name: c.name, estado: "SKIP", nota: "aborted" })
              continue
            }
            const r = await ejecutar(c.cmd, cwd, c.timeoutMs || TIMEOUT_POR_DEFECTO)
            resultados.push({
              name: c.name,
              cmd: c.cmd,
              estado: r.timeout ? "TIMEOUT" : r.code === 0 ? "PASS" : "FAIL",
              code: r.code,
              ms: r.ms,
              salida: r.salida,
            })
          }
          const fallos = resultados.filter((r) => r.estado === "FAIL" || r.estado === "TIMEOUT")
          const corridos = resultados.filter((r) => r.estado !== "SKIP")
          const veredicto = corridos.length === 0 ? "NOTHING RAN" : fallos.length ? "FAIL" : "PASS"
          const completo = veredicto === "PASS" && args.full && !args.only
          if (completo) sucias.delete(ctx.sessionID)
          const lineas = [`GATE: ${veredicto}`, `root: ${raiz}  ·  cwd: ${cfg.cwd}  ·  config: ${cfg.origen}`, ""]
          for (const r of resultados) {
            const dur = r.ms == null ? "" : `${(r.ms / 1000).toFixed(1)}s`
            lineas.push(`  ${String(r.name).padEnd(16)} ${r.estado.padEnd(8)} ${dur.padStart(7)}  ${r.nota || r.cmd || ""}`)
          }
          for (const f of fallos) {
            lineas.push("", `--- ${f.name} (exit ${f.code}${f.estado === "TIMEOUT" ? ", TIMEOUT" : ""}) ---`)
            lineas.push(recorta(f.salida) || "(no output)")
          }
          if (veredicto === "FAIL")
            lineas.push("", "REJECT. Do not mark this task done until gate passes.")
          if (veredicto === "NOTHING RAN")
            lineas.push("", "This is not a PASS.")
          if (veredicto === "PASS" && !completo)
            lineas.push("", "PARTIAL PASS. APPROVE requires gate with full=true.")
          return { title: `gate ${veredicto.toLowerCase()}`, output: lineas.join("\n"), metadata: { veredicto } }
        },
      }),
    },
    "tool.execute.after": async (input) => {
      if (!HERRAMIENTAS_ESCRITURA.has(input.tool)) return
      sucias.set(input.sessionID, (sucias.get(input.sessionID) || 0) + 1)
    },
    "experimental.chat.system.transform": async (input, output) => {
      const n = input.sessionID ? sucias.get(input.sessionID) : 0
      if (!n) return
      output.system.push(
        `<gate-pendiente>\nThere are ${n} unverified edit(s). Run \`gate\` and quote its output. A gate that did not run is not a gate that passed.\n</gate-pendiente>`,
      )
    },
  }
}