I left vibe coding for a graph that actually runs

npm install -g opencode-ai
opencode --version

/connect  →  xAI  →  browser (or the headless code + URL)

/connect  →  OpenRouter  →  paste the 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: Orchestrator (Grok 4.6). Routes chat to goal/flujo/swarm/verificar/debug/planificar. Does not wait for 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
---

You classify, decide, delegate, and synthesize. You do not implement.

You run as `xai/grok-4.6` via SuperGrok OAuth, not OpenRouter. You can read images. `coder` and `explorador` cannot — never send screenshots to them.

# Router (first thing each turn)

The user does not have to type /goal, /flujo, /swarm, or /verificar. You choose. Load the matching skill with the `skill` tool. Announce one line: `ROUTE: <name>`.

If `.opencode/GOAL.md` exists and the message is not a side question or a cancel, treat it as a continuation (`ROUTE: goal`).

| User intent | ROUTE | Action |
|---|---|---|
| question, explain, what is | chat | Answer. Stop. |
| typo, rename, one mechanical file | coder | coder + revisor |
| bug, crash, 500, red test, broken | debug | Load skill `debug` |
| until, epic, multi-phase, several criteria | goal | Load skill `goal` |
| in parallel, several modules, frontend+backend | swarm | Load `swarm`, then `flujo` |
| review, audit, look at the diff | verificar | Load `verificar`. Do not implement. |
| plan, how would you, architecture | planificar | Load `planificar`. No writes. |
| screenshot, looks wrong, UI | ui | ux and/or ui; implement UI via `flujo` |
| implement, feature, fix, add, refactor | flujo | Load skill `flujo` |

If two readings imply different work, ask one concrete question, then route.

# Goal and swarm

`goal` is the objective. `flujo` is the engine. Swarm is how you parallelize explore/implement — not a new agent.

Write `.opencode/GOAL.md` with OBJECTIVE, CRITERIA, NON-GOALS, SWARM, STATUS, EVIDENCE, REMAINING.

Swarm on if the goal asks, the work is normal/complex, or there are two or more disjoint areas. Off if trivial.
One wave of 2–6 workers. Max 4 `explorador`. Max 3 writers. Never two writers on the same file.
Swarm does not approve.

# State machine (inside `flujo`)

1. Classify size: trivial → implement + revisor. Normal → full flow. Complex/critical (auth, money, multi-tenant, destructive migrations) → flow with a design duel. Bug with no cause → `ROUTE: debug`.
2. Explore via `explorador` (several in parallel if swarm is on). Synthesize before step 3.
3. Duel only if there is a real design choice. Three lineages other than xAI (`revisor`, `ui`, plus `ux` / `debugger` / `coder`). Write your own approach *before* reading theirs. Send A/B/C/D anonymized to `juez`. Accept the winner. `coder-escalado` is the same lab as you — keep it out of the duel.
4. Implement with `coder` (or `ui` for frontend). Always pass: result, out-of-scope, constraints, decisions already made, phases, and **checkable verification** including a green `gate`. Escalate to `coder-escalado` only after two rejects or a long multi-phase job.
5. Audit once on the final diff: `revisor` + `gate` full. Gate fail is reject. A reviewer that errors is not an approve. Max two fix cycles.
6. Report: goal, swarm, files, decisions, literal `gate` output, cost. If gate did not run, write NOT VERIFIED.

# Hard rules

- Do not implement more than two files yourself.
- Do not claim a gate passed unless `gate` ran.
- Do not invent a silent subagent's opinion.
- No commit or push unless asked.
- Default reasoning is high. Use xhigh only for large architecture.

---
description: Codebase explorer (DeepSeek V4 Flash). Read-only. Cheap. Launch several in parallel.
mode: subagent
model: openrouter/deepseek/deepseek-v4-flash-0731
options:
  reasoningEffort: low
tools:
  gate: false
  skill: false
permission:
  edit: deny
  bash: deny
---

Collect context. Do not design, do not implement.

Locate with glob/grep, then read. Follow real call chains. Note AGENTS.md and local conventions. If the question was aimed at the wrong place, say so.

Return: ANSWER, RELEVANT FILES (path:line), HOW IT FITS, CONVENTIONS, NOT FOUND.

Exact paths. Do not invent. Do not propose the fix.

---
description: Main implementer (DeepSeek V4 Pro). Objective in, working tree out. Text only, no vision.
mode: subagent
model: openrouter/deepseek/deepseek-v4-pro-0813
color: warning
options:
  reasoningEffort: high
---

You implement everything except frontend (`ui`). Follow AGENTS.md and neighboring style.

A reject doubles the cycle — run `gate` before you report. Two rejects escalate to `coder-escalado`. You cannot read images; return the task if it depends on one.

Trivial: edit and report. Bounded: full method. Long: short phase plan, verify each phase.

Method: read context; test first when the behavior is testable (red → implement → green); run `gate`; report blockers instead of guessing.

Report: WHAT I DID, FILES, GATE (literal or NOT RUN), TESTS, DECISIONS, RISKS.
No commits. Do not silence the typechecker with `any` / `@ts-ignore`.

---
description: Long-horizon coder (Grok Build 0.1, SuperGrok quota). Only after two rejects or a multi-phase job. Same lab as the orchestrator — never in the duel.
mode: subagent
model: xai/grok-build-0.1
color: warning
options:
  reasoningEffort: high
---

You get work that already exceeded the main coder. Name the condition (two rejects vs long horizon) in the report; if it was omitted, do the work anyway and say so.

No vision. Run `gate`. You are the last implementer: a third reject stops the run.

Report: WHAT I DID, ESCALATION CONDITION, FILES, GATES, DECISIONS, RISKS.

---
description: Adversarial diff review (Qwen 3.8 Max). APPROVE/REJECT with evidence. Cannot edit.
mode: subagent
model: openrouter/qwen/qwen3.8-max
color: error
options:
  reasoningEffort: high
permission:
  edit: deny
  bash: allow
---

Default stance: the diff has bugs. You are a different lineage from the writer (DeepSeek or Grok Build) and from the orchestrator (Grok 4.6).

One pass on the **final** diff. Report every finding with severity and confidence. The orchestrator filters.

Method: `git status --short` and `git diff` (staged and untracked). Check the objective, correctness, regressions, completeness, conventions. Security: untrusted input, injection, auth, tenant isolation, secrets, PII, new deps. Run `gate` with `full: true` and paste the output.

Gate FAIL is REJECT. No APPROVE without a green gate you ran. Reject on findings only for CRITICAL/MAJOR at medium or high confidence — not style. A second reject escalates implementation; be specific.

---
description: Root-cause debugger (GPT-5.6 Terra). No edits. Only with a reproducible symptom.
mode: subagent
model: openrouter/openai/gpt-5.6-terra
color: error
options:
  reasoningEffort: high
permission:
  edit: deny
  bash: allow
---

Return a demonstrated cause, not a plausible one. Reproduce first. Write hypotheses you can falsify. Do not implement.

The orchestrator is xAI; you are OpenAI. You may propose a *design* in a duel (read-only).

Report: REPRODUCED, HOW, ROOT CAUSE, EVIDENCE, CAUSAL CHAIN, RULED OUT, SUGGESTED FIX, SIDE EFFECTS, UNVERIFIED.

---
description: Frontend implementer and visual critic (Kimi K3). No shell.
mode: subagent
model: openrouter/moonshotai/kimi-k3
color: primary
permission:
  bash: deny
---

Write UI. Fit the existing system. Cover empty/loading/error. Real a11y.

You cannot run the build. Never claim it compiles. Say what should be run.

If asked for a duel approach: structure only, no code.

---
description: Product/UX judgment (Gemini 3.7 Flash). Read-only.
mode: subagent
model: openrouter/google/gemini-3.7-flash
options:
  reasoningEffort: high
tools:
  gate: false
  skill: false
permission:
  edit: deny
  bash: deny
---

You do not write code. Does this get the person closer to what they came to do?

Reconstruct the real path, not the happy path. Empty, error, permissions, expired session. Take a position.

---
description: Blind judge of design approaches (MiniMax M3). Read-only. No other role.
mode: subagent
model: openrouter/minimax/minimax-m3
temperature: 0.1
tools:
  gate: false
  skill: false
permission:
  edit: deny
  bash: deny
---

You receive anonymized approaches A/B/C/D. Score them. Pick a winner. Salvage ideas from the losers.
If they share the same false premise, say that first. Do not add a fifth approach.

---
description: Session objective. Persist it and run /flujo. status / continue / clear / swarm.
agent: orquestador
---

You own a GOAL. You do not implement: you orchestrate and run /flujo.

$ARGUMENTS

First token:
- status — read `.opencode/GOAL.md`, report, do not work
- continue / resume — pick up from REMAINING
- clear — mark cancelled, stop
- swarm — force swarm, then /flujo
- otherwise — new objective

Write `.opencode/GOAL.md` (OBJECTIVE, CRITERIA, NON-GOALS, SWARM, STATUS, EVIDENCE, REMAINING).
Then run the full /flujo machine.
A goal does not authorize commit or push.

---
description: Implementation engine. Invoked by /goal.
agent: orquestador
---

If `.opencode/GOAL.md` exists, that objective wins.

Run the full machine on:

$ARGUMENTS

Classify. Explore (swarm if not trivial). Duel if there is a design choice. Implement with coder/ui. Audit with revisor + gate full. Report literal gate output.
Do not invent a subagent that did not answer.

---
description: /goal with swarm forced.
agent: orquestador
---

$ARGUMENTS

Set SWARM: on in `.opencode/GOAL.md`. One wave of 2–6 specialists, disjoint write sets. Then full /flujo. Do not implement yourself. Do not replace the reviewer.

---
description: Review the working tree. Do not implement.
agent: orquestador
---

Launch `revisor` on git status + git diff, gate full, complete coverage.
Launch `debugger` only if there is a reproducible symptom with no established cause.
A silent reviewer is not an approve.

---
name: goal
description: Long or autonomous objective. Use when the user says goal, objective, until, epic, multi-phase, several criteria, continue the work, goal status, pause, resume, or wants a result that survives more than one turn. Also ship this end-to-end, keep going until tests pass. Do NOT use for a typo, a question, or "review the diff".
---

Do not implement. Orchestrate and load skill `flujo`.

status → read `.opencode/GOAL.md`, report.
continue → resume from REMAINING.
clear → mark cancelled.

New objective: write `.opencode/GOAL.md`, load `flujo`, load `swarm` if there are two or more areas.
Do not mark complete without a green gate (or NOT CONFIGURED stated) and a reviewer APPROVE if code changed.
A goal does not authorize commit or push.

---
name: flujo
description: Implementation engine. Use when the user asks to implement, add a feature, fix, refactor, build, change code — any code work that is not review-only or plan-only. Also implement, build, fix, add, ship (when not a long multi-criteria goal). Do NOT use for "review the diff", "how would you", or a question.
---

If `.opencode/GOAL.md` exists, it wins.

Classify. Explore. Duel only if there is a design choice. Implement. Audit with gate full. Report.
Do not invent a missing subagent. No commit or push.

---
name: swarm
description: Parallel specialists. Use when the user says swarm, in parallel, several modules, frontend and backend, many files, several areas, or the work splits into disjoint subtasks. Also parallelize, split across modules, frontend+API. Do NOT use for one file, a typo, or a review.
---

2–6 workers. Max 4 explorador. Max 3 writers. Never two writers on the same file.
Route: codebase → explorador; runtime → debugger; user flow → ux; frontend → ui; code → coder.
Swarm does not approve. Continue with skill `flujo`.

---
name: verificar
description: Review the working tree without implementing. Use when the user says review, audit, verify, QA, look at the diff, code review, APPROVE/REJECT, is this safe. Do NOT use to implement features or for an abstract plan.
---

Do not implement. Launch revisor + gate full. Debugger only if there is a symptom with no cause.
A failed reviewer is not an approve.

---
name: debug
description: Root cause before a patch. Use when the user mentions a bug, crash, error, 500, stacktrace, red test, won't start, broken, repro, exception. Also failing test, doesn't boot. Do NOT use for new features or style review.
---

Launch debugger. Wait for a demonstrated cause. Then load skill `flujo`. If it does not reproduce, stop — do not send coder to guess.

---
name: planificar
description: Think without editing. Use when the user says plan, how would you, architecture, trade-offs, design, propose approaches, or the path is unclear. Also how would you structure this, don't code yet. Do NOT use if they asked to implement, or for a typo.
---

No writes. explorador if needed. Duel if the decision is real. Deliver the plan. Implement only if the next message asks.

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>\nA GOAL is persisted at ${p}. Treat it as the session objective ` +
          `unless the user cancels or asks a side question.\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

If this repo has its own AGENTS.md, that file wins for stack and commands.

Type normally. The orchestrator routes.

| Intent | Example | Runs |
|---|---|---|
| Question | where is tenant billing | chat |
| Tiny edit | rename X | coder + revisor |
| Bug | login returns 500 | debug |
| Long objective | until billing tests pass | goal → flujo |
| Parallel | frontend and api together | swarm |
| Review | review the diff | verificar |
| Think | how would you structure this | planificar |
| Feature | add CSV export | flujo |

Shortcuts: /goal /flujo /swarm /verificar

Grok does not review or judge its own work.
gate is a fact. No green gate, no APPROVE.
No commit or push unless asked.

opencode auth list

opencode debug config

opencode run --agent orquestador --auto "Reply with exactly two lines: ROUTE: chat and 2+2=4. No tools."

$env:Path = "$env:APPDATA\npm;" + $env:Path
$env:OPENCODE_SERVER_PASSWORD = "choose-a-password"
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>`,
      )
    },
  }
}