@jmanuelcorral/openteam 0.1.38 → 0.1.41

package/README.md

@@ -1,57 +1,79 @@
 # openteam
 
-**openteam — plugin de opencode con routing coste-consciente local-first, fallback FRONTIER cheapest-capable y orquestación multiagente tipo Squad.**
+> 🌐 **Language / Idioma:** **English** (this document) · [Español](README.es.md)
 
-## Tabla de contenidos
+**openteam — a cost-aware, local-first routing plugin for [opencode](https://opencode.ai) with cheapest-capable FRONTIER fallback and on-demand multi-agent orchestration.**
 
-- [Qué es y por qué existe](#qué-es-y-por-qué-existe)
-- [Características](#características)
-- [Requisitos](#requisitos)
-- [Instalación](#instalación)
+[![CI](https://github.com/jmanuelcorral/openteam/actions/workflows/ci.yml/badge.svg)](https://github.com/jmanuelcorral/openteam/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/@jmanuelcorral/openteam.svg)](https://www.npmjs.com/package/@jmanuelcorral/openteam)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Runtime: Bun](https://img.shields.io/badge/toolchain-bun%201.3.14-black.svg)](https://bun.sh)
+
+> 📖 **Documentation site:** <https://jmanuelcorral.github.io/openteam/> (also available in [Español](https://jmanuelcorral.github.io/openteam/es/))
+
+## Table of contents
+
+- [What it is and why it exists](#what-it-is-and-why-it-exists)
+- [Features](#features)
+- [Requirements](#requirements)
+- [Installation](#installation)
 - [Quickstart: `openteam setup`](#quickstart-openteam-setup)
-- [Probar en otra máquina](#probar-en-otra-máquina)
-- [Actualizar openteam](#actualizar-openteam)
-- [Configuración](#configuración)
-- [Uso](#uso)
-- [Ejemplos en Windows](#ejemplos-en-windows)
-- [Privacidad](#privacidad)
-- [Calidad](#calidad)
-- [Compatibilidad](#compatibilidad)
+- [The `openteam` agent](#the-openteam-agent)
+- [Runtime commands](#runtime-commands)
+- [Configuration](#configuration)
+- [Privacy](#privacy)
+- [Quality](#quality)
+- [Compatibility](#compatibility)
+- [Contributing](#contributing)
 - [Roadmap](#roadmap)
-- [Licencia](#licencia)
+- [License](#license)
+- [Acknowledgements](#acknowledgements)
+
+## What it is and why it exists
 
-## Qué es y por qué existe
+openteam adds a routing and orchestration layer to opencode to **save frontier tokens and cost without sacrificing quality or privacy**. The default strategy is **local-first**: trivial tasks, summaries, simple docs and small diffs try local runtimes first; architecture, security, multi-file refactors, critical tool calling and ambiguous debugging escalate to **cheapest-capable FRONTIER**.
 
-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**.
+The router keeps a privacy guarantee: with `privacyMode: "forceLocalOnSensitive"`, a task flagged as `privacySensitive` never escalates to frontier.
 
-El router mantiene una garantía de privacidad: con `privacyMode: "forceLocalOnSensitive"`, una tarea marcada como `privacySensitive` no escala a frontier.
+## Features
 
-## Características
+- Per-turn routing from the `chat.message` hook, mutating `output.message.model` before opencode persists the message.
+- Registration of OpenAI-compatible local runtimes: **Ollama**, **LM Studio** and **Foundry Local**.
+- Local JSON classifier with a deterministic heuristic fallback.
+- Capability profiles from [Models.dev](https://models.dev), with cache and a curated fallback when the catalog is unavailable.
+- **Cheapest-capable** frontier selection by blended cost `0.75 * inputUSD + 0.25 * outputUSD`.
+- Budgets per session, per month and per frontier tokens per session.
+- Hash-only `CostRecord` JSONL telemetry: stores `promptHash`, cost/decision metrics — **never raw prompts**.
+- Multi-agent orchestration with `runRoleTask` / `runRoleTasks`, SDK child sessions and an explicit model in `client.session.prompt({ body: { model } })`.
+- Local availability refresh at startup and on `session.created` / `session.idle` events.
+- A local web **Console** aggregating every opencode session (cost, tokens, tool calls, routing, decisions) — redacted, loopback-only. **(alpha — see note below)**
+- A read-only **MCP server** exposing aggregated team memory, plus opt-in semantic recall.
 
-- 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`.
+## Requirements
 
-## Requisitos
+- opencode compatible with `@opencode-ai/plugin` `1.17.13`.
+- [Bun](https://bun.sh) `1.3.14` for reproducible installs, development, and tests.
+- Node.js `^22.22.2 || ^24.15.0 || >=26.0.0` for the published CLI/plugin.
+- Optional local runtimes:
+  - Ollama at `http://localhost:11434/v1`.
+  - LM Studio at `http://localhost:1234/v1`.
+  - Foundry Local with a dynamic port discovered via CLI on Windows.
 
-- 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.
+> Local runtimes are **optional**. You can run openteam **frontier-only**, or point it at an Ollama / LM Studio running on **another machine on your LAN**.
 
-## Instalación
+## Installation
 
-### Opción A: paquete npm
+The package is published as [`@jmanuelcorral/openteam`](https://www.npmjs.com/package/@jmanuelcorral/openteam). These are the supported installation paths:
 
-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:
+| Need | Supported method |
+| --- | --- |
+| Load the plugin in opencode | Add `@jmanuelcorral/openteam` to the `plugin` array in `opencode.json`. opencode resolves the package; no global CLI install is required. |
+| Run setup once | `bunx --package @jmanuelcorral/openteam@latest openteam setup` |
+| Keep the `openteam` CLI on `PATH` | `bun add --global @jmanuelcorral/openteam@latest`, then `openteam setup` |
+
+Global installation with npm is **not supported**. Bun is the only supported package installer. Node.js runs the published CLI/plugin within the declared engine range; npm is limited to maintainer-only `pack`, Trusted Publishing, and `link:local` operations.
+
+For direct opencode loading, reference the package name:
 
 ```jsonc
 {
@@ -65,17 +87,11 @@ El paquete se publica como `@jmanuelcorral/openteam`. opencode instala los plugi
         "baseline": {
           "mode": "auto",
           "pinnedModel": null,
-          "hardDefault": {
-            "providerID": "anthropic",
-            "modelID": "claude-sonnet-4-5"
-          }
+          "hardDefault": { "providerID": "anthropic", "modelID": "claude-sonnet-4-5" }
         },
         "router": {
           "mode": "balanced",
-          "localDefault": {
-            "providerID": "ollama",
-            "modelID": "qwen3:8b"
-          },
+          "localDefault": { "providerID": "ollama", "modelID": "qwen3:8b" },
           "trivialPromptMaxChars": 280,
           "frontierPromptMinChars": 2000
         },
@@ -85,19 +101,7 @@ El paquete se publica como `@jmanuelcorral/openteam`. opencode instala los plugi
               "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"
-              }
+              "defaultModel": { "providerID": "ollama", "modelID": "qwen3:8b" }
             }
           ]
         },
@@ -108,246 +112,75 @@ El paquete se publica como `@jmanuelcorral/openteam`. opencode instala los plugi
           "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`:
-
-```jsonc
-{
-  "$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"
-        }
+        "telemetry": { "enabled": true, "path": ".opencode/openteam-telemetry.jsonl" }
       }
     ]
   ]
 }
 ```
 
+The fastest way to get a repository ready is the interactive `openteam setup` command (below), which generates this configuration for you.
+
 ## 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) —que son **opcionales**: puedes usar openteam **solo con frontier**, o apuntar a un Ollama/LM Studio que corra en **otra máquina de la red 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:
+`openteam setup` detects the installed local runtimes (Ollama, LM Studio, Foundry Local — all optional), lets you pick the local models and the **frontier baseline** model (sorted cheapest-capable first), and writes three files:
 
-- `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.
+- `opencode.json` at the repo root: declares the `@jmanuelcorral/openteam` plugin, the OpenAI-compatible local `provider`s, the frontier `model` and the local `small_model`.
+- `.opencode/openteam.json`: openteam's validated runtime configuration (baseline, routing, local runtimes and privacy).
+- `.opencode/agent/openteam.md`: the **primary `openteam` agent**, visible in the Tab switcher.
 
 ```powershell
-# Con el paquete instalado como dependencia del proyecto
-bunx openteam setup
-# o, si lo tienes global
+# One-off, without a global install
+bunx --package @jmanuelcorral/openteam@latest openteam setup
+# Or, after the supported global Bun install
 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 (o **ninguno**: puedes usar openteam **solo con modelos frontier**) y, por cada runtime que habilites, elegir si corre **en esta máquina** o **en otra máquina de la red local** (introduciendo su URL, p. ej. `http://192.168.1.50:11434/v1`); luego eliges el modelo por defecto de cada uno (o lo escribes si no se detectan modelos).
-3. Ofrece el modelo frontier baseline a partir del **catálogo completo de [Models.dev](https://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). Si no habilitas ningún runtime local, avisa de que estás en **modo solo frontier** y recomienda `consentBeforeFrontier` (porque `forceLocalOnSensitive` no tendría destino local).
-5. Si ya existe `opencode.json` o `.opencode/openteam.json`, pide confirmación antes de sobrescribir.
-
-Tras `setup`, autentica el provider frontier (`opencode auth login`), asegúrate de que tu runtime local (en esta máquina o en la red) esté accesible si lo habilitaste, 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`.
+> The old `openteam init` command still works as a **deprecated alias** of `openteam setup`.
 
-### El agente `openteam` (estilo Squad)
+The wizard:
 
-`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.
+1. Probes local runtimes and marks the detected ones.
+2. Lets you enable runtimes (or **none** — frontier-only) and, per enabled runtime, choose whether it runs **on this machine** or **on another machine on the LAN** (by entering its URL, e.g. `http://192.168.1.50:11434/v1`), then pick each default model.
+3. Offers the frontier baseline from the **full [Models.dev](https://models.dev) catalog** that openteam integrates: a quick list with the **cheapest-capable first** (including **free** models, tagged `free`), a "Browse all models by provider…" option, and "Other (custom)" to type a `provider/model`. If the catalog can't be loaded (offline), it falls back to the curated list.
+4. Asks for the routing mode (`balanced` / `economy` / `quality`), the privacy policy, and whether to enable **YOLO mode** (auto-approve opencode permissions). If you enable no local runtime, it warns you are in **frontier-only mode** and recommends `consentBeforeFrontier`.
+5. If `opencode.json` or `.opencode/openteam.json` already exist, it asks for confirmation before overwriting.
 
-Ese orquestador funciona al estilo [Squad](https://bradygaster.github.io/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.
+After `setup`, authenticate the frontier provider (`opencode auth login`), make sure your local runtime is reachable if you enabled one, and open opencode in the repo: openteam routes local-first automatically. Re-tune the baseline later with `openteam baseline set <provider/model>` or `openteam baseline auto`.
 
-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:
+## The `openteam` agent
 
-- **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`.
+`openteam setup` generates a single **primary agent** named `openteam`. Press **Tab** in opencode to select it: you explicitly know you are in openteam mode while the plugin keeps optimizing the model underneath.
 
-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.
+That orchestrator ships **no pre-created subagents**. On **every request** its first action is to check whether a team already exists (`.opencode/openteam-roster.md` + subagents in `.opencode/agent/`). If it does, it hands work to the right specialists; if not, it understands the tasks your request implies, designs the minimal team and **creates it on demand** (writing `.opencode/agent/<name>.md` with `mode: subagent`), reusing existing agents before creating new ones. Mechanical/bulk roles are left to route to local models; only architecture, security or ambiguous debugging escalate to frontier. (This on-demand, themed-team model is inspired by [Squad](https://bradygaster.github.io/squad/) — see [Acknowledgements](#acknowledgements).)
 
-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.
+The team has a **themed identity**: the orchestrator picks (or asks for) a **universe** and names each agent after a character, recording the cast in `.opencode/openteam-roster.md` so names **persist** across sessions. Besides project-specific roles, it plans three **standard roles** created on demand:
 
-## Probar en otra máquina
+- **scribe** — silent memory: logs decisions and learnings to `.opencode/openteam-decisions.md` without touching code (local model).
+- **ralph** — automation and triage: monitors the backlog, prioritizes, coordinates execution and **escalates to the human** on blockers or approvals.
+- **guardian** — security and privacy: **detects and masks sensitive data** (PII, secrets, API keys, tokens) before it reaches frontier; always runs locally and respects `forceLocalOnSensitive`.
 
-Para instalar y probar openteam en otro equipo que ya tenga [opencode](https://opencode.ai) y [Bun](https://bun.sh):
+Before delegating, the orchestrator **plans dependencies and parallelizes**: it splits the request into tasks and, since opencode runs all `task` calls emitted in a single turn in parallel (Vercel AI SDK), it launches independent tasks together and sequences only the dependent ones into waves. Work that collides on the same files is separated into distinct waves to avoid conflicts. In the **todo list** each entry shows the responsible agent via a name prefix, e.g. `[@Basher] Implement the router`.
 
-1. **Instala el paquete.** Global o como dependencia de desarrollo del repo que quieras usar:
+## Runtime commands
 
-   ```powershell
-   # Opción global (deja el comando `openteam` en el PATH)
-   npm install -g @jmanuelcorral/openteam
+openteam exposes commands to inspect and change routing without editing JSON by hand, over three equivalent surfaces.
 
-   # …o como dependencia de desarrollo del proyecto
-   bun add -d @jmanuelcorral/openteam   # (o: npm install -D @jmanuelcorral/openteam)
-   ```
+### 1. In-conversation tool
 
-2. **Inicializa el repositorio** donde vayas a trabajar. Genera `opencode.json`, `.opencode/openteam.json` y `.opencode/agent/openteam.md`:
+The plugin registers the `openteam` tool. Ask the agent to use it, or install the `/openteam` command. Actions:
 
-   ```powershell
-   cd C:\ruta\a\tu\repo
-   openteam setup          # global
-   # …o, si lo instalaste como dependencia del proyecto:
-   bunx openteam setup
-   ```
+- `show` — show the effective baseline.
+- `set` (with `model` as `provider/model`) — pin the baseline (`pinned` mode).
+- `auto` — return to cheapest-capable (`auto` mode).
+- `doctor` — diagnostics for local runtimes, privacy and telemetry.
+- `report` — cost and savings summary from telemetry.
 
-   El asistente detecta Ollama / LM Studio / Foundry Local, te deja elegir los modelos locales (locales o en otra máquina de la red) o **ninguno** para funcionar solo con frontier, y el frontier baseline, y escribe la configuración.
-
-3. **Autentica el provider frontier** que hayas elegido:
-
-   ```powershell
-   opencode auth login
-   ```
-
-4. **Arranca tu runtime local** si lo habilitaste y no estaba activo (p. ej. `ollama serve`, o abre LM Studio / Foundry Local). Si apuntaste a un runtime en **otra máquina de la red**, asegúrate de que sea accesible desde este equipo (host expuesto y puerto abierto); para Ollama esto normalmente implica arrancarlo con `OLLAMA_HOST=0.0.0.0 ollama serve` en la máquina remota. Si configuraste **solo frontier**, sáltate este paso.
-
-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:
-
-```powershell
-# 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:
-
-```powershell
-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.
+`set` / `auto` changes are persisted to `.opencode/openteam.json` and apply on the next plugin start.
 
 ### 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 setup` **automatically generates** `.opencode/command/openteam.md`, so `/openteam` appears in opencode with no manual steps:
 
 ```text
 /openteam baseline show
@@ -359,14 +192,14 @@ Los cambios de `set`/`auto` se persisten en `.opencode/openteam.json` y aplican
 /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.
+> Don't see `/openteam`? Make sure `.opencode/command/openteam.md` exists (created by `openteam setup`) and **restart/reload opencode** to discover it.
 
 ### 3. CLI (`bin`)
 
-El paquete expone el binario `openteam`. Con instalación global:
+The package exposes the `openteam` binary. With a global install:
 
 ```powershell
-npm i -g @jmanuelcorral/openteam
+bun add --global @jmanuelcorral/openteam@latest
 openteam baseline show
 openteam baseline set openai/gpt-5-mini
 openteam doctor --config .opencode/openteam.json
@@ -374,275 +207,175 @@ openteam agents
 openteam console
 openteam report --telemetry .opencode/openteam-telemetry.jsonl
 openteam yolo status
-openteam yolo on
 openteam local status
-openteam local off
 ```
 
-Flags: `--config <path>` y `--telemetry <path>` sobrescriben las rutas por defecto; `--opencode <path>` apunta el comando `yolo` a un `opencode.json` concreto.
+Flags: `--config <path>` and `--telemetry <path>` override the default paths; `--opencode <path>` points the `yolo` command at a specific `opencode.json`.
 
-### Ver el LLM de cada agente: `openteam agents`
+### See each agent's LLM: `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).
-
-```powershell
-openteam agents
-```
-
-```text
-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.
+Lists the agents in `.opencode/agent/`, showing **which LLM each one uses**: whether it is **local** (Ollama/LM Studio/Foundry, no token cost) or **frontier** (consumes your subscription), and the provider. Agents without their own `model` **inherit** the `opencode.json` default (which openteam routes local-first per message).
 
+### YOLO mode (auto-approve permissions)
 
-### 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:
+**YOLO mode** makes opencode auto-approve **all** permissions (like the native `opencode --auto` flag, but persistent). It writes the global rule `permission: { "*": "allow" }` to `opencode.json` and **regenerates the `openteam` agent** with the same wildcard:
 
 ```powershell
-openteam yolo status   # ¿está activo?
-openteam yolo on       # activa YOLO
-openteam yolo off      # desactiva YOLO
+openteam yolo status   # is it active?
+openteam yolo on       # enable YOLO
+openteam yolo off      # disable 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).
+> **The agent permission overrides the global one.** opencode merges each agent's frontmatter permission **after** the global one and the last matching rule wins, so `openteam yolo on/off` regenerates `.opencode/agent/openteam.md` to keep its `permission` in sync. After changing mode, **restart or reload opencode**.
 
-> **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).
+> **YOLO does not disable openteam privacy.** It only affects opencode permission approvals; with `privacyMode: "forceLocalOnSensitive"`, sensitive prompts still never leave for frontier. Use it only in trusted environments.
 
-### Solo frontier (sin runtime local): `openteam local`
+### Frontier-only (no local runtime): `openteam local`
 
-Si **no tienes ningún runtime local** (Ollama/LM Studio/Foundry Local) o prefieres no usarlo, puedes forzar que openteam enrute **siempre a modelos frontier**. `openteam setup` ya activa este modo automáticamente cuando no habilitas ningún runtime, pero puedes alternarlo en cualquier momento sin repetir el setup:
+If you have **no local runtime** or prefer not to use one, you can force openteam to route **always to frontier models**:
 
 ```powershell
-openteam local status   # ¿local-first o solo frontier? + runtimes configurados
-openteam local off      # solo frontier (desactiva el routing local-first)
-openteam local on       # vuelve al routing local-first
+openteam local status   # local-first or frontier-only? + configured runtimes
+openteam local off      # frontier-only (disable local-first routing)
+openteam local on       # back to local-first routing
 ```
 
-Esto persiste el flag `router.frontierOnly` en `.opencode/openteam.json`. Con `frontierOnly` activo, el router escoge el **frontier cheapest-capable** en lugar de la heurística local-first, pero **respeta la privacidad, los presupuestos y los overrides explícitos por tarea**: los prompts sensibles con `forceLocalOnSensitive` no salen a frontier, y `local off` degrada esa política a `consentBeforeFrontier` (imposible forzar local sin runtime) informándote del cambio.
-
-### 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](docs/loop.md)**.
+This persists the `router.frontierOnly` flag in `.opencode/openteam.json`. With `frontierOnly` active the router picks the **cheapest-capable frontier**, but still **respects privacy, budgets and explicit per-task overrides**. Sensitive prompts with `forceLocalOnSensitive` don't leave for frontier; `local off` degrades that policy to `consentBeforeFrontier` (local can't be forced without a runtime) and tells you about the change.
 
-### Console web multi-sesión (se lanza desde la CLI)
+### Multi-session web Console: `openteam console` (alpha)
 
-openteam expone una **Console web local** que **lanzas tú desde la CLI** con
-`openteam console`.
-Agrega **todas** las sesiones de opencode a la vez: puedes tener varias pestañas
-de opencode abiertas y todas aparecen en la **misma** Console, con una pestaña por
-sesión (más "Todas"), porque cada plugin **escribe eventos redactados** en logs
-JSONL por sesión y la Console los vigila (`fs.watch`) y **agrega**.
+> ⚠️ **Alpha — not finished.** The Console (and the `tunnel` command below) is an
+> early, experimental feature that may still be **reworked or rebuilt**, with
+> breaking changes to its UI, endpoints, config (`console` block) and event
+> format. The routing, budgets, telemetry and memory core are stable; the web
+> surface is not yet. Use it for local observation, not as a stable API.
 
-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).
+openteam exposes a **local web Console** you launch from the CLI with `openteam console`. It aggregates **all** opencode sessions at once (one tab per session, plus "All"), because each plugin **writes redacted events** to per-session JSONL logs that the Console watches (`fs.watch`) and aggregates.
 
-Cada pestaña de sesión incluye además una **vista "Sesión"**: una consola por la
-que puedes **ver la salida en vivo** (SSE) y **enviar prompts** o **responder
-permisos** a esa sesión de opencode, autenticada con un **token efímero** por
-arranque. Opcionalmente, con el flag `terminal.pty`, una **vista "Terminal"** abre
-una **shell real** en el workspace vía la API de PTY de opencode (sin `node-pty`).
-
-Lánzala contra el repo actual; escucha en loopback y corre hasta **Ctrl+C**:
+It shows live: **real cost and tokens per message** (input/output/reasoning/cache), **tool calls with duration** and ok/fail, recent routing (cost/savings and chosen model — **prompt hashes only, never text**), agent **decisions** (scribe) and **meetings** (multi-agent batches), loop backlog progress, the agent team and latest commits. It updates over **SSE** (with polling fallback).
 
 ```powershell
-openteam console          # imprime la URL y sirve la Console multi-sesión
-openteam console --open   # además abre el navegador
-openteam console --status # solo imprime la config (no lanza el servidor)
-```
-
-Las sesiones se leen de:
-
-```text
-.opencode/openteam/sessions/*.jsonl
+openteam console          # print the URL and serve the multi-session Console
+openteam console --open   # also open the browser
+openteam console --status # print the config only (don't launch the server)
 ```
 
-Puedes ajustar host/puerto y la terminal en `.opencode/openteam.json` (bloque
-`console`):
-
-```json
-{
-  "console": {
-    "host": "127.0.0.1",
-    "port": 4599,
-    "autoPortFallback": true,
-    "refreshMs": 2000,
-    "recentRoutes": 50,
-    "openBrowser": false,
-    "terminal": { "enabled": true, "pty": false }
-  }
-}
-```
+> **Security**: the server listens **on loopback only** (`127.0.0.1`/`localhost`, Zod-validated) and **never exposes prompts** (only `promptHash`), tool-call args or message content — only counters, costs and redacted summaries. The "Session"/"Terminal" view requires the ephemeral token.
 
-> **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. La vista "Sesión"/"Terminal" exige el token efímero. Si el puerto está ocupado y `autoPortFallback` es `true`, prueba el siguiente libre.
+### Secure remote access: `openteam tunnel` (alpha)
 
-### Acceso remoto seguro: `openteam tunnel`
+> ⚠️ **Alpha — not finished.** Like the Console, `tunnel` is experimental and may
+> be reworked or rebuilt. Treat its flags and behavior as unstable.
 
-Para acceder a la Console (y, opcionalmente, operar la terminal) **desde fuera**,
-`openteam tunnel` la expone vía **Microsoft Dev Tunnels** en lugar de bindear a
-`0.0.0.0`. Comprueba que `devtunnel` esté instalado y con sesión iniciada,
-hospeda el puerto de la Console e imprime la URL pública hasta **Ctrl+C**:
+To reach the Console (and optionally operate the terminal) **from outside**, `openteam tunnel` exposes it via **Microsoft Dev Tunnels** instead of binding to `0.0.0.0`:
 
 ```powershell
-openteam tunnel                    # expone solo la Console (observación), autenticado
-openteam tunnel --terminal         # además expone opencode para la terminal remota
-openteam tunnel --allow-anonymous --yes  # túnel anónimo (requiere doble confirmación)
+openteam tunnel                    # expose only the Console (observation), authenticated
+openteam tunnel --terminal         # also expose opencode for the remote terminal
+openteam tunnel --allow-anonymous --yes  # anonymous tunnel (requires double confirmation)
 ```
 
-> **Seguridad del túnel**: autenticado por defecto. La **terminal remota** exige
-> `OPENCODE_SERVER_PASSWORD` definido; sin ella, `--terminal` se ignora y solo se
-> expone la Console (observación). El túnel **anónimo** requiere `--yes` (doble
-> confirmación) y avisa de que opencode puede ejecutar comandos y editar ficheros.
-> Instala devtunnel con `winget install Microsoft.devtunnel` e inicia sesión con
-> `devtunnel user login`.
+> **Tunnel security**: authenticated by default. The **remote terminal** requires `OPENCODE_SERVER_PASSWORD` to be set; without it, `--terminal` is ignored. Install devtunnel with `winget install Microsoft.devtunnel` and sign in with `devtunnel user login`.
 
-### Memoria del equipo por MCP (solo lectura): `openteam mcp`
+### Team memory over MCP (read-only): `openteam mcp`
 
-`openteam mcp` arranca un **servidor MCP de solo lectura** (JSON-RPC 2.0 sobre
-stdio, sin dependencias) que expone la memoria del equipo agregada desde los
-eventos por sesión para que agentes/herramientas la consulten. Se apoya en el
-mismo `StorageProvider` que la Console y **nunca** expone prompts crudos, solo el
-estado ya redactado. Tools disponibles: `list_decisions` (filtrable por
-`agent`/`tag`), `list_meetings`, `list_sessions` y `cost_summary` (coste/tokens
-reales + ahorro estimado vs baseline all-frontier).
+`openteam mcp` starts a **read-only MCP server** (JSON-RPC 2.0 over stdio, no dependencies) that exposes the team memory aggregated from per-session events. It uses the same `StorageProvider` as the Console and **never** exposes raw prompts. Tools: `list_decisions` (filterable by `agent`/`tag`), `list_meetings`, `list_sessions` and `cost_summary`.
 
-Regístralo en `opencode.json` como cualquier MCP server local:
+Register it in `opencode.json` like any local MCP server:
 
 ```json
 {
   "mcp": {
-    "openteam-memory": {
-      "type": "local",
-      "command": ["openteam", "mcp"]
-    }
+    "openteam-memory": { "type": "local", "command": ["openteam", "mcp"] }
   }
 }
 ```
 
+Opt-in **semantic recall** (`recall_facts`, `recall_preferences`, `similar_tasks`) is available via the `memory.semantic` block in `.opencode/openteam.json`; queries are embedded **locally** (never leave for frontier). See [docs/architecture.md](docs/architecture.md) and the Spanish [README.es.md](README.es.md) for full details.
 
+## Configuration
 
-### Ollama
-
-```powershell
-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`.
-
-```powershell
-Invoke-RestMethod -Uri "http://localhost:1234/v1/models" -Method Get
-```
-
-### Foundry Local
+The canonical runtime configuration lives in `.opencode/openteam.json`; this repo ships `.opencode/openteam.example.json` as a complete example. The Zod-validated shape is in `src/config/schema.ts`. `telemetry` is a plugin option read by `src/index.ts`, not part of the persisted `OpenTeamConfig`.
 
-```powershell
-foundry service status
-```
-
-openteam extrae el puerto de la salida del CLI y normaliza el endpoint a `http://localhost:<PORT>/v1`.
-
-### Telemetría
-
-```powershell
-$telemetryPath = "C:\gitrepos\openteam\.opencode\openteam-telemetry.jsonl"
-Get-Content -Path $telemetryPath -Tail 5
-```
-
-### Verificación local
-
-```powershell
-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
-```
-
-### Desarrollo local en modo dev (sin registry)
-
-Para que la CLI global `openteam` y opencode usen la build local de este repo en
-lugar de la versión publicada (sin pasar por ningún registry), se enlaza el
-paquete con un symlink global:
-
-```powershell
-Set-Location -Path "C:\gitrepos\openteam"
-bun run link:local   # = bun run build && npm link
-```
-
-`npm link` crea un enlace global (junction/symlink) hacia este repo, así que tras
-cada `bun run build` la CLI global refleja el código local.
-
-Un hook `pre-push` versionado (`.githooks/pre-push`) ejecuta `bun run link:local`
-automáticamente antes de cada `git push`, manteniendo la instalación local al día.
-El hook se activa vía `core.hooksPath=.githooks`, que el script `prepare` configura
-automáticamente al ejecutar `bun install` en el repo. Es best-effort: si el build o
-el link fallan, avisa pero **no bloquea** el push.
-
-## 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:
+| Key | Type | Default | Description |
+| --- | --- | --- | --- |
+| `baseline.mode` | `"auto" \| "pinned"` | `"auto"` | In `auto`, uses cheapest-capable frontier profiles when passed to the router; in `pinned`, uses `baseline.pinnedModel` if set. |
+| `baseline.pinnedModel` | `ModelRef \| null` | `null` | Explicitly pinned frontier model. `ModelRef` is `{ "providerID": string, "modelID": string }`. |
+| `baseline.hardDefault` | `ModelRef` | `{ "providerID": "anthropic", "modelID": "claude-sonnet-4-5" }` | Frontier fallback when there are no cheapest-capable profiles or a valid pin. |
+| `router.mode` | `"economy" \| "balanced" \| "quality"` | `"balanced"` | Validated routing mode reserved for policy. |
+| `router.localDefault` | `ModelRef` | `{ "providerID": "ollama", "modelID": "qwen3:8b" }` | Primary local model. |
+| `router.trivialPromptMaxChars` | positive integer | `280` | Code-free prompts up to this size prefer local. |
+| `router.frontierPromptMinChars` | positive integer | `2000` | Prompts from this size are frontier candidates if no guards apply. |
+| `local.runtimes` | `LocalRuntime[]` | Ollama enabled at `http://localhost:11434/v1` with `qwen3:8b` | Minimal list of one local runtime. |
+| `local.runtimes[].id` | `"ollama" \| "lmstudio" \| "foundry-local"` | required | Local runtime. |
+| `local.runtimes[].enabled` | `boolean` | `true` | Enable or disable that runtime. |
+| `local.runtimes[].baseURL` | optional URL | per runtime/config | OpenAI-compatible `/v1` endpoint; Foundry Local may omit it when using discovery. |
+| `local.runtimes[].discovery` | `"cli" \| "sdk" \| "manual"` optional | none per item | Foundry Local discovery; the registry uses CLI when configured and not `manual`. |
+| `local.runtimes[].defaultModel` | `ModelRef` | required | Default model for that runtime. |
+| `budgets.sessionUSD` | positive number, optional | unlimited | Frontier budget per session. |
+| `budgets.monthlyUSD` | positive number, optional | unlimited | Monthly frontier budget. |
+| `budgets.frontierTokensPerSession` | positive integer, optional | unlimited | Frontier token limit per session. |
+| `budgets.hardStopOnBudgetExhaustion` | `boolean` | `false` | If `true`, an exhausted budget returns `blockFrontier`; if `false`, it forces local. |
+| `privacyMode` | `"forceLocalOnSensitive" \| "consentBeforeFrontier" \| "off"` | `"forceLocalOnSensitive"` | Privacy policy for sensitive tasks. |
+| `telemetry.enabled` | `boolean` (plugin option) | `true` | Enable/disable JSONL writing. |
+| `telemetry.path` | `string` (plugin option) | `.opencode/openteam-telemetry.jsonl` | Path of the `CostRecord` JSONL log. |
+
+## Privacy
+
+With `privacyMode: "forceLocalOnSensitive"`, if `TaskSignals.privacySensitive` is `true`, `chooseModel` uses local and does not allow frontier fallback. If no usable local runtime exists, the decision keeps the local route and records the reason in `rationale`.
+
+Telemetry uses `hashPrompt` (currently `fnv1a32:<hash>`) and never serializes the full prompt. See [SECURITY.md](SECURITY.md) for the full privacy stance and how to report vulnerabilities.
+
+## Quality
+
+Non-negotiable gates (see [docs/testing-and-quality.md](docs/testing-and-quality.md)):
 
 - `bun test`
-- Coverage global: líneas `>= 85%`, branches `>= 80%`.
-- Coverage de `src/router/**`: `100%` lines, branches, statements y functions.
+- Global coverage: lines `>= 85%`, branches `>= 80%`.
+- Coverage of `src/router/**` and `src/memory/**`: `100%` lines and functions (enforced by `bun run coverage:check`).
 - `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.
+- `biome check .` (or `bun run lint` + `bun run format:check`)
+- Router determinism test.
+- Contract tests when opencode hooks, agents, commands, providers or the SDK change.
 
-Estado actual de Fases 0-3: **202 tests verdes**.
+## Compatibility
 
-## Compatibilidad
+See [docs/compatibility.md](docs/compatibility.md). Verified summary as of `2026-08-19`:
 
-Consulta [docs/compatibility.md](docs/compatibility.md). Resumen verificado el `2026-07-06`:
-
-| Superficie | Versión / contrato |
+| Surface | Version / contract |
 | --- | --- |
-| openteam | `0.1.0` para Fase 4 npm + docs |
+| openteam | `0.1.41`; current package version |
 | `@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 } })` |
+| Routing hook | `chat.message`; not `chat.params` for model changes |
+| Child sessions | `client.session.create` + `client.session.prompt({ body: { model } })` |
+
+## Contributing
+
+Contributions are welcome. Please read [CONTRIBUTING.md](CONTRIBUTING.md) for the development setup (Bun), the non-negotiable quality gates, the module boundaries (`router/` is pure — no I/O, clock, randomness or logging) and the pull-request process. By participating you agree to abide by our [Code of Conduct](CODE_OF_CONDUCT.md).
 
 ## Roadmap
 
-| Fase | Estado | Entregables |
+| Phase | Status | Deliverables |
 | --- | --- | --- |
-| 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`. |
+| 0. Scaffold / PoC | Done | TS/Bun, minimal plugin, `chat.message` hook. |
+| 1. Local registry + heuristic router | Done | Ollama/LM Studio/Foundry, probes and deterministic `chooseModel`. |
+| 2. Classifier + profiles + budget + telemetry | Done | Local classifier, `ModelCapabilityProfile`, budgets and `CostRecord`. |
+| 3. Multi-agent orchestration | Done | Coordinator, roles, child sessions and permissions. |
+| 4. npm packaging + docs | Done | Exportable package, README, Windows examples and compatibility matrix. |
+| 5. Runtime commands | Done | `baseline show/set/auto`, `doctor` and `report` via tool, `/openteam` and CLI `bin`. |
+| 6. Web Console + MCP memory | Done (Console/tunnel **alpha**) | Multi-session Console and `tunnel` are experimental and may be reworked; read-only MCP server and semantic recall are stable. |
+
+## License
+
+[MIT](LICENSE) © Jose Manuel Corral ([@jmanuelcorral](https://github.com/jmanuelcorral)).
+
+## Acknowledgements
+
+openteam stands on the shoulders of prior work. These projects shaped its design — we took inspiration from them, adapted the ideas to opencode and reimplemented them from scratch in TypeScript:
 
-## Licencia
+- **[Squad](https://bradygaster.github.io/squad/)** ([bradygaster/squad](https://github.com/bradygaster/squad)) — the on-demand, themed multi-agent team model: a single orchestrator that casts specialist subagents as the work requires them. It inspired openteam's `openteam` orchestrator agent and the team/roster convention.
+- **[Superpowers](https://github.com/obra/superpowers)** by Jesse Vincent — a composable, skill-driven methodology for coding agents. It inspired openteam's skill-based agent conventions and the spec-first / subagent-driven workflow.
+- **[agent-memory-dotnet](https://github.com/joslat/agent-memory-dotnet)** by José Luis Latorre — a semantic long-term memory model for agents. It inspired openteam's memory subsystem (extract → rank → consolidate → recall) with local-first, hash-redacted storage.
 
-MIT. Consulta [LICENSE](LICENSE).
+All trademarks and project names belong to their respective owners; the links above are provided for attribution and are not endorsements.