openteam

openteam — plugin de opencode con routing coste-consciente local-first, fallback FRONTIER cheapest-capable y orquestación multiagente tipo Squad.

Tabla de contenidos

• Qué es y por qué existe
• Características
• Requisitos
• Instalación
• Quickstart: openteam setup
• Probar en otra máquina
• Actualizar openteam
• Configuración
• Uso
• Ejemplos en Windows
• Privacidad
• Calidad
• Compatibilidad
• Roadmap
• Licencia

Qué es y por qué existe

openteam añade a opencode una capa de routing y orquestación para ahorrar tokens y coste frontier sin perder calidad ni privacidad. La estrategia por defecto es local-first: tareas triviales, resúmenes, documentación sencilla y diffs pequeños intentan usar runtimes locales; tareas de arquitectura, seguridad, refactors multiarchivo, tool calling crítico o debugging ambiguo escalan a FRONTIER cheapest-capable.

El router mantiene una garantía de privacidad: con privacyMode: "forceLocalOnSensitive", una tarea marcada como privacySensitive no escala a frontier.

Características

• Routing por turno desde el hook chat.message, mutando output.message.model antes de que opencode persista el mensaje.
• Registro de runtimes locales OpenAI-compatible: Ollama, LM Studio y Foundry Local.
• Clasificador local JSON con fallback heurístico determinista.
• Perfiles de capacidad desde Models.dev, con cache y fallback curado cuando el catálogo no está disponible.
• Selección frontier cheapest-capable por coste blended 0.75 * inputUSD + 0.25 * outputUSD.
• Presupuestos por sesión, mes y tokens frontier por sesión.
• Telemetría CostRecord JSONL hash-only: guarda promptHash, métricas de coste y decisión, nunca prompts crudos.
• Orquestación Squad con runRoleTask / runRoleTasks, subsesiones SDK y modelo explícito en client.session.prompt({ body: { model } }).
• Refresh de disponibilidad local al arrancar y en eventos session.created / session.idle.

Requisitos

• opencode compatible con @opencode-ai/plugin 1.17.13.
• Bun >=1.3 para desarrollo y tests.
• Runtimes locales opcionales:
  • Ollama en http://localhost:11434/v1.
  • LM Studio en http://localhost:1234/v1.
  • Foundry Local con puerto dinámico descubierto por CLI en Windows.

Instalación

Opción A: paquete npm

El paquete se publica como @jmanuelcorral/openteam. opencode instala los plugins declarados en el array plugin de opencode.json; basta con referenciar el nombre del paquete:

{
  "$schema": "https://opencode.ai/config.json",
  "model": "anthropic/claude-sonnet-4-5",
  "small_model": "ollama/qwen3:8b",
  "plugin": [
    [
      "@jmanuelcorral/openteam",
      {
        "baseline": {
          "mode": "auto",
          "pinnedModel": null,
          "hardDefault": {
            "providerID": "anthropic",
            "modelID": "claude-sonnet-4-5"
          }
        },
        "router": {
          "mode": "balanced",
          "localDefault": {
            "providerID": "ollama",
            "modelID": "qwen3:8b"
          },
          "trivialPromptMaxChars": 280,
          "frontierPromptMinChars": 2000
        },
        "local": {
          "runtimes": [
            {
              "id": "ollama",
              "enabled": true,
              "baseURL": "http://localhost:11434/v1",
              "defaultModel": {
                "providerID": "ollama",
                "modelID": "qwen3:8b"
              }
            },
            {
              "id": "lmstudio",
              "enabled": true,
              "baseURL": "http://localhost:1234/v1",
              "defaultModel": {
                "providerID": "lmstudio",
                "modelID": "qwen2.5-coder-local"
              }
            }
          ]
        },
        "budgets": {
          "sessionUSD": 2,
          "monthlyUSD": 30,
          "frontierTokensPerSession": 250000,
          "hardStopOnBudgetExhaustion": false
        },
        "privacyMode": "forceLocalOnSensitive",
        "telemetry": {
          "enabled": true,
          "path": ".opencode/openteam-telemetry.jsonl"
        }
      }
    ]
  ],
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama (local)",
      "options": {
        "baseURL": "http://localhost:11434/v1",
        "apiKey": "ollama",
        "chunkTimeout": 60000
      },
      "models": {
        "qwen3:8b": {
          "name": "Qwen3 8B (Ollama)",
          "tool_call": true,
          "limit": { "context": 32768, "output": 8192 }
        }
      }
    },
    "lmstudio": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "LM Studio (local)",
      "options": {
        "baseURL": "http://localhost:1234/v1",
        "apiKey": "lm-studio"
      },
      "models": {
        "qwen2.5-coder-local": {
          "name": "Qwen2.5 Coder Local",
          "tool_call": true,
          "limit": { "context": 32768, "output": 8192 }
        }
      }
    }
  }
}

Opción B: ruta de desarrollo

Durante desarrollo puedes cargar un plugin local desde .opencode/plugins/openteam.ts:

{
  "$schema": "https://opencode.ai/config.json",
  "plugin": [
    [
      "./.opencode/plugins/openteam.ts",
      {
        "router": {
          "mode": "balanced",
          "localDefault": {
            "providerID": "ollama",
            "modelID": "qwen3:8b"
          }
        },
        "telemetry": {
          "path": ".opencode/openteam-telemetry.jsonl"
        }
      }
    ]
  ]
}

Quickstart: openteam setup

La forma más rápida de dejar un repositorio listo para opencode + openteam es el comando interactivo openteam setup. Detecta los runtimes locales instalados (Ollama, LM Studio, Foundry Local), te deja elegir los modelos locales y el modelo frontier baseline (ordenados de más barato-capaz a más caro), y genera tres ficheros:

• opencode.json en la raíz: declara el plugin @jmanuelcorral/openteam, los provider locales OpenAI-compatible, el model frontier y el small_model local.
• .opencode/openteam.json: la configuración runtime validada de openteam (baseline, routing, runtimes locales y privacidad).
• .opencode/agent/openteam.md: el agente primario openteam (estilo Squad), visible en el Tab-switcher.

# Con el paquete instalado como dependencia del proyecto
bunx openteam setup
# o, si lo tienes global
openteam setup

El antiguo comando openteam init sigue funcionando como alias obsoleto de openteam setup.

El asistente:

1. Sondea los runtimes locales y marca los detectados.
2. Te deja habilitar runtimes y elegir el modelo por defecto de cada uno (o escribirlo si no se detectan modelos).
3. Ofrece el modelo frontier baseline a partir del catálogo completo de Models.dev que openteam ya integra: una lista rápida con los más baratos-capaces primero (incluidos los gratuitos, etiquetados como gratis), una opción «Ver todos los modelos por proveedor…» para navegar el catálogo completo, y «Otro (custom)» para escribir un provider/model. Si el catálogo no se puede cargar (offline), cae a la lista curada.
4. Pregunta el modo de routing (balanced/economy/quality), la política de privacidad y si quieres activar el modo YOLO (auto-aprobar permisos de opencode).
5. Si ya existe opencode.json o .opencode/openteam.json, pide confirmación antes de sobrescribir.

Tras init, autentica el provider frontier (opencode auth login), arranca tu runtime local si no estaba activo y abre opencode en el repositorio: openteam enruta local-first automáticamente. Puedes reajustar el baseline después con openteam baseline set <provider/model> o openteam baseline auto.

El agente openteam (estilo Squad)

openteam setup genera un único agente primario llamado openteam (.opencode/agent/openteam.md). Pulsa Tab en opencode para seleccionarlo: así sabes explícitamente que estás en modo openteam, mientras el plugin sigue optimizando el modelo por debajo.

Ese orquestador funciona al estilo Squad: no trae subagentes precreados. En cada petición su primera acción es comprobar si ya existe equipo (.opencode/openteam-roster.md + subagentes en .opencode/agent/). Si existe, reparte el trabajo entre los especialistas adecuados; si no existe, entiende las tareas que implica tu petición, diseña el equipo mínimo y lo crea a demanda —sin que tengas que pedírselo explícitamente— antes de pasarle esas tareas (escribiendo .opencode/agent/<nombre>.md con mode: subagent), reutilizando los existentes antes de crear nuevos. Los roles mecánicos/bulk se dejan enrutar a modelos locales y solo se escala a frontier para arquitectura, seguridad o debugging ambiguo.

Como Squad, el equipo tiene identidad temática: el orquestador elige (o te pregunta) un universo y nombra a cada agente con un personaje de ese universo, registrando el reparto en .opencode/openteam-roster.md (fuera de .opencode/agent/, para que opencode no lo cargue como un agente fantasma) para que los nombres persistan entre sesiones. Además de los roles específicos del proyecto, contempla tres roles estándar creados a demanda:

• scribe — memoria silenciosa: registra decisiones y aprendizajes en .opencode/openteam-decisions.md sin tocar el código (modelo local).
• ralph — automatización y triage: monitoriza el trabajo pendiente, lo prioriza, coordina la ejecución y escala al humano ante bloqueos o aprobaciones.
• guardian — seguridad y privacidad: detecta y enmascara datos sensibles (PII, secretos, API keys, tokens) antes de que salgan a frontier y hace revisión de seguridad; corre siempre en local y respeta forceLocalOnSensitive.

Antes de delegar, el orquestador planifica dependencias y paraleliza: descompone la petición en tareas, y como opencode ejecuta en paralelo todas las llamadas task emitidas en un mismo turno (Vercel AI SDK), lanza a la vez las tareas independientes y secuencia por olas solo las que dependen de un resultado previo. El trabajo que colisiona sobre los mismos ficheros se separa en olas distintas para evitar conflictos.

En la lista de tareas (todowrite, la que ves en el todo general de opencode) cada entrada lleva visible el responsable. opencode no tiene un campo de "agente" en sus todos (solo content/status/priority, y la lista es por sesión), así que el orquestador usa una convención en el texto: prefija cada tarea con el nombre del casting, p. ej. [@Basher] Implementar el router o [@openteam] Sintetizar resultados. Así, de un vistazo, sabes quién es responsable de cada tarea.

Probar en otra máquina

Para instalar y probar openteam en otro equipo que ya tenga opencode y Bun:

1. Instala el paquete. Global o como dependencia de desarrollo del repo que quieras usar:

   # Opción global (deja el comando `openteam` en el PATH)
   npm install -g @jmanuelcorral/openteam
   
   # …o como dependencia de desarrollo del proyecto
   bun add -d @jmanuelcorral/openteam   # (o: npm install -D @jmanuelcorral/openteam)

2. Inicializa el repositorio donde vayas a trabajar. Genera opencode.json, .opencode/openteam.json y .opencode/agent/openteam.md:

   cd C:\ruta\a\tu\repo
   openteam setup          # global
   # …o, si lo instalaste como dependencia del proyecto:
   bunx openteam setup

   El asistente detecta Ollama / LM Studio / Foundry Local, te deja elegir los modelos locales y el frontier baseline, y escribe la configuración.

3. Autentica el provider frontier que hayas elegido:

   opencode auth login

4. Arranca tu runtime local si no estaba activo (p. ej. ollama serve, o abre LM Studio / Foundry Local).

5. Abre opencode en el repo, pulsa Tab y elige el agente openteam. Dale el primer prompt: creará el equipo de subagentes a demanda y enrutará local-first automáticamente.

Comprueba el estado con openteam doctor (runtimes + config) y el ahorro con openteam report.

Actualizar openteam

openteam se publica en npm de forma continua; cada push a master publica un nuevo patch. Para traer la última versión:

# Instalación global
npm install -g @jmanuelcorral/openteam@latest

# Dependencia de desarrollo del proyecto
bun add -d @jmanuelcorral/openteam@latest   # (o: npm install -D @jmanuelcorral/openteam@latest)

Comprobar versiones:

npm view @jmanuelcorral/openteam version   # última publicada en npm
npm ls -g @jmanuelcorral/openteam          # instalada globalmente (o `npm ls …` en el repo)

Notas al actualizar:

• No necesitas volver a ejecutar openteam setup para actualizar el plugin: opencode resuelve el paquete @jmanuelcorral/openteam declarado en opencode.json a la versión instalada. Reinicia opencode para que recargue el plugin.
• Vuelve a ejecutar openteam setup solo si quieres regenerar la configuración (cambiar runtimes, modelos o baseline). Pedirá confirmación antes de sobrescribir opencode.json, .opencode/openteam.json o .opencode/agent/openteam.md; no toca los subagentes que el orquestador haya creado a demanda.
• Ajustes puntuales sin reinit: openteam baseline set <provider/model> o openteam baseline auto.

Configuración

La configuración runtime canónica vive en .opencode/openteam.json; este repositorio incluye .opencode/openteam.example.json como ejemplo completo. La forma validada por Zod es la de src/config/schema.ts. telemetry es una opción del plugin leída por src/index.ts, no parte del objeto OpenTeamConfig persistido.

| Key | Tipo | Default | Descripción | | --- | --- | --- | --- | | baseline.mode | "auto" \| "pinned" | "auto" | En auto, usa perfiles frontier cheapest-capable cuando se pasan al router; en pinned, usa baseline.pinnedModel si existe. | | baseline.pinnedModel | ModelRef \| null | null | Modelo frontier fijado explícitamente. ModelRef usa { "providerID": string, "modelID": string }. | | baseline.hardDefault | ModelRef | { "providerID": "anthropic", "modelID": "claude-sonnet-4-5" } | Fallback frontier si no hay perfiles cheapest-capable o pin válido. | | router.mode | "economy" \| "balanced" \| "quality" | "balanced" | Modo de routing validado y reservado para política. | | router.localDefault | ModelRef | { "providerID": "ollama", "modelID": "qwen3:8b" } | Modelo local principal. | | router.trivialPromptMaxChars | number entero positivo | 280 | Prompts sin código hasta este tamaño prefieren local. | | router.frontierPromptMinChars | number entero positivo | 2000 | Prompts desde este tamaño se tratan como candidatos a frontier si no aplican guards. | | local.runtimes | LocalRuntime[] | Ollama enabled en http://localhost:11434/v1 con qwen3:8b | Lista mínima de un runtime local. | | local.runtimes[].id | "ollama" \| "lmstudio" \| "foundry-local" | requerido | Runtime local. | | local.runtimes[].enabled | boolean | true | Habilita o deshabilita ese runtime. | | local.runtimes[].baseURL | URL opcional | según runtime/config | Endpoint OpenAI-compatible /v1; Foundry Local puede omitirlo si usa discovery. | | local.runtimes[].discovery | "cli" \| "sdk" \| "manual" opcional | sin default por item | Discovery de Foundry Local; el registry usa CLI si está configurado y no es manual. | | local.runtimes[].defaultModel | ModelRef | requerido | Modelo por defecto de ese runtime. | | budgets.sessionUSD | number positivo opcional | sin límite | Presupuesto frontier por sesión. | | budgets.monthlyUSD | number positivo opcional | sin límite | Presupuesto frontier mensual. | | budgets.frontierTokensPerSession | number entero positivo opcional | sin límite | Límite de tokens frontier por sesión. | | budgets.hardStopOnBudgetExhaustion | boolean | false | Si es true, agotar presupuesto devuelve blockFrontier; si es false, fuerza local. | | privacyMode | "forceLocalOnSensitive" \| "consentBeforeFrontier" \| "off" | "forceLocalOnSensitive" | Política de privacidad para tareas sensibles. | | telemetry.enabled | boolean plugin option | true | Activa/desactiva escritura JSONL. | | telemetry.path | string plugin option | .opencode/openteam-telemetry.jsonl | Ruta del log CostRecord JSONL. |

Uso

En cada turno, openteam deriva señales del prompt (promptChars, hasCode, privacySensitive, requiresTools y override de modelo si existe), ejecuta chooseModel y asigna output.message.model.

La orquestación Squad usa roles estáticos y subsesiones opencode:

| Rol | Agent opencode | Tier base | Política | | --- | --- | --- | --- | | rusty | architect | hard | Arquitectura y decisiones de alto riesgo; frontier auto. | | livingston | integration | moderate | Integración TS/opencode; tool calling por defecto. | | yen | local-runtime | moderate | Runtimes locales; local-first con fallback frontier. | | basher | routing-cost | moderate | Router, coste y presupuesto; local-first. | | scribe | scribe | trivial | Documentación y resúmenes; local-first. | | linus | tester | simple | Tests y contratos; local-first con tools. |

runRoleTask ejecuta una subsesión; runRoleTasks ejecuta varias con batchID. Los roles con destructive o multiFileEdit elevan el tier antes de elegir modelo.

Para ver ahorro y decisiones, revisa el JSONL de telemetría. Campos clave: promptHash, promptChars, tier, routeKind, selected, rationale, estimatedCostUSD, baselineCostUSD, estimatedSavingsUSD, budgetAction, tokensIn y tokensOut.

Comandos runtime

openteam expone comandos para inspeccionar y cambiar el routing sin editar JSON a mano. Hay tres superficies equivalentes:

1. Tool en la conversación

El plugin registra la herramienta openteam. Pídele al agente que la use, o instala el comando /openteam (ver más abajo). Acciones:

• show — muestra el baseline efectivo.
• set (con model en formato provider/model) — fija el baseline (modo pinned).
• auto — vuelve a cheapest-capable (modo auto).
• doctor — diagnóstico de runtimes locales, privacidad y telemetría.
• report — resumen de coste y ahorro desde la telemetría.

Los cambios de set/auto se persisten en .opencode/openteam.json y aplican en el siguiente arranque del plugin.

2. Slash command /openteam

openteam setup genera automáticamente .opencode/command/openteam.md, así que el comando /openteam aparece en opencode sin pasos manuales. (Si vienes de una versión anterior, vuelve a ejecutar openteam setup para crearlo, o cópialo a mano a tu proyecto o a ~/.config/opencode/command/.) Después:

/openteam baseline show
/openteam baseline set anthropic/claude-sonnet-4-5
/openteam baseline auto
/openteam doctor
/openteam agents
/openteam dashboard
/openteam report

¿No ves /openteam en opencode? Asegúrate de que existe .opencode/command/openteam.md (lo crea openteam setup) y reinicia/recarga opencode para que descubra el comando.

3. CLI (bin)

El paquete expone el binario openteam. Con instalación global:

npm i -g @jmanuelcorral/openteam
openteam baseline show
openteam baseline set openai/gpt-5-mini
openteam doctor --config .opencode/openteam.json
openteam agents
openteam dashboard
openteam report --telemetry .opencode/openteam-telemetry.jsonl
openteam yolo status
openteam yolo on

Flags: --config <path> y --telemetry <path> sobrescriben las rutas por defecto; --opencode <path> apunta el comando yolo a un opencode.json concreto.

Ver el LLM de cada agente: openteam agents

Lista los agentes de .opencode/agent/ indicando qué LLM usa cada uno: si es local (Ollama/LM Studio/Foundry, sin coste de tokens) o frontier (consume tu suscripción), y el proveedor (Anthropic, OpenAI, GitHub Copilot, Google…). Los agentes sin model propio heredan el default de opencode.json (que openteam enruta local-first por mensaje).

openteam agents

openteam agents — LLM por agente:

  ● openteam  [primary ]  frontier · Anthropic (consume tu suscripción) (anthropic/claude-sonnet-4-5)
  ○ basher    [subagent]  local · Ollama (sin coste de tokens) (ollama/qwen3:8b)
  ○ scribe    [subagent]  hereda default → frontier · Anthropic (consume tu suscripción) · openteam enruta local-first por mensaje

Default de opencode.json: anthropic/claude-sonnet-4-5 (frontier · Anthropic)
Leyenda: ● primary · ○ subagent · local = sin coste de tokens · frontier = consume tu suscripción.

También está disponible dentro de opencode: pídele a openteam la lista de agentes y ejecutará la acción agents de su herramienta de comandos.

Modo YOLO (auto-aprobar permisos)

El modo YOLO hace que opencode auto-apruebe todos los permisos (equivale al flag nativo opencode --auto, pero persistente). Escribe la regla global permission: { "*": "allow" } en opencode.json y regenera el agente openteam (.opencode/agent/openteam.md) con el mismo comodín, conservando el resto de tu configuración:

openteam yolo status   # ¿está activo?
openteam yolo on       # activa YOLO
openteam yolo off      # desactiva YOLO

También puedes activarlo durante openteam setup (te lo pregunta), o al vuelo con opencode --auto sin tocar la config.

Importante: el permiso del agente anula al global. opencode fusiona el permiso del frontmatter de cada agente después del global y gana la última regla que casa; por eso openteam yolo on/off regenera .opencode/agent/openteam.md para que su permission coincida con el estado YOLO. Sin esto, un bash: ask/external_directory: deny en el agente seguiría pidiendo confirmación aunque el global fuese "*": allow. Tras cambiar el modo, reinicia o recarga opencode para que los agentes tomen los nuevos permisos, y crea los subagentes con el mismo comodín cuando YOLO esté activo (el orquestador ya lo hace).

YOLO no desactiva la privacidad de openteam. Solo afecta a las aprobaciones de permisos de opencode; con privacyMode: "forceLocalOnSensitive", los prompts sensibles siguen sin salir a frontier. Úsalo solo en entornos de confianza: auto-aprueba también bash, escrituras y accesos fuera del workspace (salvo reglas deny explícitas).

Modo desatendido: openteam loop (patrón Ralph) 🎯 (diseño)

Segundo modo de operación: un bucle externo que invoca opencode run contra un backlog persistente hasta vaciarlo, con contexto fresco por iteración y topes de seguridad (presupuesto, máx. iteraciones, sin-progreso). Complementa al orquestador interactivo, no lo sustituye. Consulta el diseño y los ejemplos en docs/loop.md.

Dashboard web multi-sesión (se lanza desde la CLI)

openteam expone un panel web local que lanzas tú desde la CLI con openteam dashboard. Agrega todas las sesiones de opencode a la vez: puedes tener varias pestañas de opencode abiertas y todas aparecen en el mismo panel, porque cada plugin escribe eventos redactados en logs JSONL por sesión y el dashboard los vigila (fs.watch) y agrega.

Muestra en vivo: coste y tokens reales por mensaje (input/output/reasoning/ cache), toolcalls con duración y ok/fallo, ruteo reciente (coste/ahorro y modelo elegido, solo hashes de prompt, nunca el texto), decisiones de los agentes (scribe) y reuniones (batches multi-agente del orquestador), progreso del backlog del loop, el equipo de agentes (LLM local/frontier de cada uno) y últimos commits. Se actualiza por SSE (con polling de respaldo).

Lánzalo contra el repo actual; escucha en loopback y corre hasta Ctrl+C:

openteam dashboard          # imprime la URL y sirve el panel multi-sesión
openteam dashboard --open   # además abre el navegador
openteam dashboard --status # solo imprime la config (no lanza el servidor)

Las sesiones se leen de:

.opencode/openteam/sessions/*.jsonl

Puedes ajustar host/puerto y demás en .opencode/openteam.json:

{
  "dashboard": {
    "host": "127.0.0.1",
    "port": 4599,
    "autoPortFallback": true,
    "refreshMs": 2000,
    "recentRoutes": 50,
    "openBrowser": false
  }
}

Seguridad: el servidor escucha solo en loopback (127.0.0.1/localhost, validado por Zod) y nunca expone prompts (solo promptHash), args de toolcall ni contenido de mensajes: solo contadores, costes y resúmenes redactados. Si el puerto está ocupado y autoPortFallback es true, prueba el siguiente libre.

Ollama

ollama serve
ollama pull qwen3:8b
Invoke-RestMethod -Uri "http://localhost:11434/v1/models" -Method Get

LM Studio

1. Abre LM Studio.
2. Carga un modelo compatible.
3. Activa el servidor local OpenAI-compatible en el puerto 1234.

Invoke-RestMethod -Uri "http://localhost:1234/v1/models" -Method Get

Foundry Local

foundry service status

openteam extrae el puerto de la salida del CLI y normaliza el endpoint a http://localhost:<PORT>/v1.

Telemetría

$telemetryPath = "C:\gitrepos\openteam\.opencode\openteam-telemetry.jsonl"
Get-Content -Path $telemetryPath -Tail 5

Verificación local

Set-Location -Path "C:\gitrepos\openteam"
bun test
bun run typecheck
bun run lint
bun run format:check
# Cuando el empaquetado de Fase 4 exponga el script:
bun run build

Privacidad

Con privacyMode: "forceLocalOnSensitive", si TaskSignals.privacySensitive es true, chooseModel usa local y no permite fallback frontier. Si no hay local utilizable, la decisión conserva la ruta local y registra la razón en rationale.

La telemetría usa hashPrompt, actualmente fnv1a32:<hash>, y no serializa el prompt completo.

Calidad

Gates no negociables:

• bun test
• Coverage global: líneas >= 85%, branches >= 80%.
• Coverage de src/router/**: 100% lines, branches, statements y functions.
• bun run typecheck
• biome check . o bun run lint + bun run format:check
• Test de determinismo del router.
• Tests de contrato si cambian hooks opencode, agents, comandos, providers o SDK.

Estado actual de Fases 0-3: 202 tests verdes.

Compatibilidad

Consulta docs/compatibility.md. Resumen verificado el 2026-07-06:

| Superficie | Versión / contrato | | --- | --- | | openteam | 0.1.0 para Fase 4 npm + docs | | @opencode-ai/plugin | 1.17.13 | | @opencode-ai/sdk | 1.17.13 | | Hook de routing | chat.message; no chat.params para cambiar modelo | | Subsesiones | client.session.create + client.session.prompt({ body: { model } }) |

Roadmap

| Fase | Estado | Entregables | | --- | --- | --- | | 0. Scaffold/PoC | Hecha | TS/Bun, plugin mínimo, hook chat.message. | | 1. Local registry + router heurístico | Hecha | Ollama/LM Studio/Foundry, probes y chooseModel determinista. | | 2. Clasificador + perfiles + presupuesto + telemetría | Hecha | Clasificador local, ModelCapabilityProfile, budgets y CostRecord. | | 3. Orquestación multiagente | Hecha | Coordinator, roles, child sessions y permisos. | | 4. Empaquetado npm + docs | Hecha | Package exportable, README, ejemplos Windows y matriz de compatibilidad. | | 5. Comandos runtime | Hecha | baseline show/set/auto, doctor y report vía tool, /openteam y CLI bin. |

Licencia

MIT. Consulta LICENSE.