@iaforged/context-code 1.0.69 → 1.0.71

package/README.md

@@ -85,11 +85,21 @@ El comando `/provider` ahora sirve para cambiar de proveedor y tambien para acti
 
 ```sh
 /provider
+/provider list
 /provider ollama
 /provider zai profile main
 /provider ollama profile local
 ```
 
+Comportamiento de `/provider`:
+
+- `/provider` (sin argumentos) abre el selector interactivo de proveedores.
+- `/provider list` muestra una tabla detallada con todos tus proveedores, perfiles guardados, estado de conexión (Conectado/Desconectado) y perfiles activos.
+- `/provider <proveedor>` cambia al proveedor especificado.
+- `/provider <proveedor> profile <nombre>` activa (o crea) un perfil específico para ese proveedor.
+- `/provider <proveedor> <URL>` cambia la Base URL del proveedor (ej. `/provider ollama http://localhost:11434/v1`).
+- `/provider <proveedor> clear` restaura la URL por defecto del proveedor.
+
 Tambien existe `/profile` para inspeccionar y navegar perfiles ya guardados:
 
 ```sh
@@ -138,9 +148,23 @@ Despues de activar un perfil, puedes seguir ajustando sus valores con los comand
 ```sh
 /provider ollama http://localhost:11434/v1
 /provider ollama clear
+/provider list
 /model
 ```
 
+### Soporte Multi-cuenta real
+
+Context Code permite gestionar múltiples cuentas del mismo proveedor (como varias cuentas de Claude o OpenAI) de forma independiente.
+
+```sh
+/login --profile personal
+/login --profile trabajo
+```
+
+- Al usar el flag `--profile` (o `-p`), las credenciales se guardan específicamente en ese perfil.
+- El sistema detecta automáticamente si el perfil ya existe o crea uno nuevo.
+- Puedes saltar entre cuentas fácilmente usando `/provider claude profile personal` o listarlas todas con `/provider list`.
+
 ### Persistencia por perfil
 
 La persistencia queda separada por perfil cuando el proveedor lo soporta.
@@ -216,8 +240,17 @@ Esta parte permite usar varios proveedores como si fueran un equipo de trabajo.
 - `workspace`: representa un proveedor dentro del sistema de equipos, por ejemplo `claude`, `openai`, `minimax` u `ollama`.
 - `agent`: es un perfil operativo dentro de un proveedor. Ejemplo: `claude/frontend-lead` o `openai/backend-lead`.
 - `team`: es el equipo completo para un objetivo. Ejemplo: `core-dev`.
+- `domain` (o `dominio`): es un area de trabajo dentro del team. Ejemplos: `frontend`, `backend`, `docs`, `planning`, `tests`, `review`, `database`. Cuando creas un team con `/workspace setup`, el sistema arma 4 dominios por defecto (`frontend`, `backend`, `docs`, `planning`); los que no asignes a un agente quedaran como warnings al ejecutar.
 - `run`: es una ejecucion guardada de un objetivo. Tiene tareas, mensajes, resultados y estado.
 
+Mini glosario para no confundirse con los roles internos:
+
+- `orquestador global`: el agente que coordina todo el team. Lee el objetivo del usuario, lo descompone, asigna trabajo a cada dominio y consolida los reportes finales para entregartelos a ti.
+- `orquestador local`: por dominio. Recibe la parte del objetivo que le toca, decide como dividirla entre los miembros del dominio (o como hacerla solo en `modo autonomo`) y reporta de vuelta al orquestador global.
+- `lead`: el agente principal de un dominio. En la mayoria de los flujos, el `orquestador local` y el `lead` son el mismo agente.
+- `modo autonomo`: cuando un dominio no tiene miembros extra, el orquestador local asume internamente los roles que necesite (planner, executor, reviewer, etc.) sin necesitar mas agentes configurados.
+- `global-plan` / `squad-plan` / `domain-report` / `run-report`: tipos de mensajes que se guardan en la run. El primero lo emite el orquestador global al planear, el segundo cada orquestador local cuando recibe su tarea, y los reportes son lo que devuelven cuando terminan. Los puedes ver con `/run messages <run-id>`.
+
 Orden normal de uso:
 
 1. Configuras un proveedor y un perfil con `/provider`, `/login` y `/model`.
@@ -315,6 +348,28 @@ Cuando usarlo:
 - si quieres confirmar que el sistema reconoce un proveedor antes de crear agentes
 - si quieres armar un equipo rapido sin recordar `/agent` y `/team`
 
+### `/team-auto` — wizard automatico
+
+Si todavia no sabes que dominio asignar a cada proveedor, `/team-auto` lo decide por ti. Detecta los perfiles ya logueados y arma un team con dominios estandar (`frontend`, `backend`, `docs`, `planning`):
+
+```sh
+/team-auto              # crea un team llamado "default-team"
+/team-auto core-dev     # crea (o actualiza) un team llamado "core-dev"
+```
+
+Que pasa al ejecutarlo:
+
+1. Detecta los `provider profile` activos (los que ya tienen credencial).
+2. Aplica una heuristica de reparto: Claude -> `frontend`, OpenAI -> `backend`, MiniMax/Z.AI -> `docs`, Ollama/OpenRouter -> `planning`. Si solo tienes 1 proveedor, ese hace TODOS los dominios en `modo autonomo`.
+3. Te muestra el plan en pantalla (que dominios va a crear, que agentes va a reusar, quien sera el orquestador global).
+4. Pulsas `Enter` y aplica los cambios, o `Esc` y cancela sin tocar nada.
+
+Cuando un dominio queda sin agente compatible (por ejemplo no tienes ningun proveedor que mapee a `docs`), se reporta `sin asignar` en el plan y queda como warning. Despues puedes asignarlo manualmente con `/team domain <team> docs <provider>/<agent>`.
+
+Si el team ya existe, `/team-auto` solo lo actualiza: no borra agentes ni miembros que ya tuvieras.
+
+Cuando quieras configurarlo todo a mano, sigue habiendo `/workspace setup` (wizard guiado, mas detallado) o el formato corto `/workspace setup <team> orchestrator=... <provider/profile:dominio>...`.
+
 ### `/agent`
 
 `/agent` crea nombres de trabajo dentro de cada proveedor. Un agente siempre apunta a un provider profile real.
@@ -404,28 +459,28 @@ Una `run` es una ejecucion guardada de un objetivo. Por ejemplo: "crear login co
 
 ### `/orchestrate`
 
-`/orchestrate` toma un team y crea tareas iniciales para cada dominio.
+`/orchestrate` toma un team y un objetivo, planifica el trabajo, **te muestra el plan en pantalla** y te pregunta si quieres ejecutarlo ya:
 
 ```sh
 /orchestrate core-dev crear endpoint de login y UI de acceso
 ```
 
-Que hace:
+Que pasa cuando lo ejecutas:
 
-- revisa que el team exista
-- revisa que tenga coordinador principal
-- revisa que cada dominio tenga agente responsable
-- crea una `orchestration_run`
-- crea tareas en `orchestration_tasks`
-- crea mensajes de planeacion en `orchestration_messages`
-- deja cada tarea como `ready` si puede ejecutarse o `blocked` si falta configuracion
+1. El sistema valida el team, el orquestador global y los dominios.
+2. Crea la `run` y todas sus `tasks` en estado `ready` o `blocked` segun la configuracion del dominio.
+3. **Te muestra el plan**: tareas por dominio, agentes asignados, advertencias de configuracion.
+4. Te ofrece dos teclas:
+   - **`Enter`**: ejecuta inmediatamente las tareas `ready`. Veras progreso en vivo (dominio que esta trabajando, agente activo, fase) y al final un reporte consolidado.
+   - **`Esc`**: deja la run en `planned`. Puedes revisar con `/run show <run-id>` o ejecutar mas tarde con `/run resume <run-id>`.
 
-Despues de usar `/orchestrate`, normalmente sigues con:
+Cuando confirmas con Enter, el flujo interno es: orquestador global delega a cada orquestador local -> cada orquestador local ejecuta o subdelega en `modo autonomo` -> cada uno devuelve un `domain-report` -> el orquestador global consolida y emite el `run-report` final que ves tu.
+
+Si pulsas Esc o no hay tareas `ready` (todo quedo bloqueado), la corrida se queda en estado `planned` y el comando termina mostrando los siguientes pasos sugeridos. En ese caso normalmente sigues con:
 
 ```sh
-/run list
-/run show <run-id>
-/run resume <run-id>
+/run show <run-id>     # revisar el plan en detalle
+/run resume <run-id>   # ejecutar despues
 ```
 
 ### `/run`
@@ -489,6 +544,7 @@ Estados de una tarea:
 ### Ejemplo completo
 
 ```sh
+# 1. Configurar dos proveedores y sus perfiles
 /provider claude profile main
 /login
 /model
@@ -497,16 +553,26 @@ Estados de una tarea:
 /login
 /model
 
+# 2. Crear el team con frontend en Claude y backend en OpenAI
 /workspace setup core-dev orchestrator=backend claude/main:frontend openai/work:backend
 /team show core-dev
 
+# 3. Pedir el objetivo. /orchestrate planifica, muestra el plan
+#    en pantalla y pregunta si ejecutar ya:
+#    [Enter] = ejecuta y veras progreso + reporte final
+#    [Esc]   = solo planifica, queda en estado 'planned'
 /orchestrate core-dev crear login con UI y API
+
+# 4. (Opcional) revisar la bitacora completa de mensajes
 /run list
-/run show <run-id>
-/run resume <run-id>
 /run messages <run-id>
 ```
 
+Notas importantes:
+
+- Si `/workspace setup` solo asigno agente a `frontend` y `backend`, los dominios `docs` y `planning` apareceran como `blocked` con warnings al planear. **No es un error**: las tareas ready se ejecutan igual al pulsar Enter, y las bloqueadas las puedes asignar despues con `/team domain core-dev docs <provider>/<agent>` y reintentar con `/run retry <run-id>`.
+- El reporte final que ves al terminar viene del orquestador global. Si quieres ver lo que cada orquestador local respondio, usa `/run messages <run-id>` o `/run domain <run-id> <dominio>`.
+
 ## Seleccion automatica y fallback
 
 La seleccion automatica permite que Context Code recomiende o aplique que agente debe tomar una tarea. El fallback permite cambiar una tarea fallida o bloqueada a otro agente compatible.
@@ -768,21 +834,39 @@ En este ejemplo:
 
 Si quieres hacerlo a mano, todavia puedes usar `/workspace enable`, `/agent create`, `/agent set-role`, `/team create`, `/team orchestrator` y `/team domain`. El wizard solo junta esos pasos para evitar errores.
 
-### 4. Crear una corrida de trabajo
+### 4. Crear una corrida y revisar el plan en pantalla
 
 ```sh
 /orchestrate core-dev crear login con UI y API
 ```
 
-Luego busca el identificador de la corrida:
+A diferencia de versiones anteriores, **`/orchestrate` no se queda en silencio**: te muestra una vista resumen con la run creada, las tareas por dominio, advertencias y un prompt:
 
-```sh
-/run list
+```text
+Plan listo para core-dev
+Run: 1b4fb901-...
+Objetivo: crear login con UI y API
+Orquestador global: openai/backend-lead
+
+Tareas por dominio
+- backend  -> ready   | assigned=openai/backend-lead
+- docs     -> blocked | assigned=sin asignar
+- frontend -> ready   | assigned=claude/frontend-lead
+- planning -> blocked | assigned=sin asignar
+
+Listas: 2 | Bloqueadas: 2
+
+Advertencias
+- docs: warning -> No hay agente asignable para este dominio.
+- planning: warning -> No hay agente asignable para este dominio.
+
+[Enter] Ejecutar ahora (las bloqueadas se omiten)  |  [Esc] Solo planificar
 ```
 
-Usa el `run-id` que aparezca en los siguientes comandos.
+### 5. Decidir: ejecutar ya, o revisar y ejecutar despues
 
-### 5. Revisar antes de ejecutar
+- **Pulsa `Enter`** y empezara la ejecucion al instante. Solo se disparan las tareas `ready`. Mientras corren, veras lineas de progreso por dominio. Al final llega el reporte consolidado.
+- **Pulsa `Esc`** si prefieres revisar antes. La run queda en `planned`. Despues puedes inspeccionarla con:
 
 ```sh
 /run show <run-id>
@@ -791,9 +875,9 @@ Usa el `run-id` que aparezca en los siguientes comandos.
 /run domain <run-id> backend
 ```
 
-Antes de ejecutar, revisa que las tareas esten en `ready`. Si alguna aparece `blocked`, normalmente falta agente, perfil, modelo o credencial.
+Si una tarea aparece `blocked`, normalmente falta agente, workspace, perfil, modelo o credencial. Asigna lo que falte y vuelve.
 
-### 6. Ejecutar la corrida
+### 6. Ejecutar manualmente cuando hayas pulsado Esc
 
 ```sh
 /run resume <run-id>
@@ -891,10 +975,167 @@ Si necesitas detener la corrida:
 /team show core-dev
 
 /orchestrate core-dev crear login con UI y API
-/run list
-/run show <run-id>
+# Aqui ves el plan en pantalla.
+# [Enter] ejecuta ya y muestra el reporte final.
+# [Esc]   te deja la run en 'planned'; ejecuta despues con /run resume <run-id>.
+
+/run messages <run-id>   # bitacora completa cuando quieras revisarla
+```
+
+## Cuando algo no avanza
+
+Sintomas comunes despues de `/orchestrate` o `/run resume`, y como salir de cada uno.
+
+### "El plan se quedo en `planned` y no pasa nada"
+
+Pulsaste `Esc` (o cerraste la vista) en lugar de `Enter`. La run existe pero no se ejecuto. Reanuda cuando quieras:
+
+```sh
 /run resume <run-id>
+```
+
+### "Aparecen dominios `blocked` que yo no pedi"
+
+Cuando creas un team con `/workspace setup` y solo das agente a algunos dominios (por ejemplo `frontend` y `backend`), los demas (`docs`, `planning`, etc.) se crean igual y quedan sin asignar. Al planear se reportan como `blocked` con el warning `No hay agente asignable para este dominio.`. Tienes dos salidas:
+
+- **Ignorarlos**: pulsas Enter, las tareas `ready` se ejecutan y las `blocked` se quedan asi. La run se reporta como `failed` o `completed` segun lo que avance.
+- **Asignar agente y reintentar**:
+  ```sh
+  /team domain <team> docs <provider>/<agent>
+  /team domain <team> planning <provider>/<agent>
+  /run retry <run-id>
+  ```
+
+### "Mi proveedor devolvio `usage_limit_reached` o `rate_limit`"
+
+Pasa cuando un proveedor alcanza el limite de tokens/segundo o de plan. La tarea afectada queda `failed`. Opciones:
+
+- Cambiar de perfil del mismo proveedor con `/profile use <proveedor> <otro-perfil>` y reintentar.
+- Reasignar la tarea a otro agente:
+  ```sh
+  /run reassign <task-id> <provider>/<agent>
+  /run resume <run-id>
+  ```
+- Pedir al sistema que busque un agente alterno:
+  ```sh
+  /run fallback <run-id> <task-id> score-with-fallback:resilience
+  /run resume <run-id>
+  ```
+
+### "Faltan credenciales o el modelo no esta configurado"
+
+Verifica el estado del perfil:
+
+```sh
+/status
+```
+
+Si falta token, modelo o base URL, vuelve a `/login` y `/model` para ese perfil. La tarea queda `blocked` hasta que el agente tenga todo lo que necesita.
+
+### "Quiero detener una corrida en marcha"
+
+```sh
+/run cancel <run-id>
+```
+
+### "Quiero ver que dijo cada orquestador local antes del reporte final"
+
+```sh
 /run messages <run-id>
+/run domain <run-id> <dominio>
+/run task <task-id>
+```
+
+`/run messages` te lista en orden cronologico todos los `global-plan`, `squad-plan`, `domain-report`, `run-report` y eventos de policy de la corrida.
+
+## Servidores MCP externos
+
+Context Code soporta el [Model Context Protocol](https://modelcontextprotocol.io). Puedes conectar servidores MCP de terceros para dar a los agentes herramientas extra: leer una base de datos, consultar Sentry, hablar con tu wiki interna, etc.
+
+Comandos:
+
+```sh
+/mcp                                           # abre el panel de servidores configurados
+/mcp add <name> -- <command> [args...]         # registra un servidor stdio
+/mcp add --transport http <name> <url>         # registra un servidor HTTP
+/mcp add --transport sse <name> <url>          # registra un servidor SSE
+```
+
+Tambien puedes registrar servidores con `--scope project` (escribe en `.mcp.json` del proyecto) o `--scope user` (queda solo para tu usuario). El default es `project` cuando estas dentro de un repo y `user` cuando no.
+
+### Ejemplo: conectar una base de datos SQLite
+
+Existen servidores MCP listos para hablar con bases de datos. El mas conocido es `mcp-server-sqlite`. Lo instalas y lo registras:
+
+```sh
+# 1. Instalar el servidor (o usar npx para no instalar)
+pip install mcp-server-sqlite
+
+# 2. Registrarlo en Context Code apuntando a tu DB
+/mcp add sqlite-local -- mcp-server-sqlite --db-path ./data/app.sqlite
+```
+
+A partir de ese momento, los agentes que ejecuten en este proyecto pueden listar tablas, hacer SELECT y describir el esquema sin que tu tengas que escribir SQL ni copiar/pegar resultados.
+
+### Ejemplo: conectar Postgres
+
+```sh
+# Con uvx (recomendado, sin instalacion previa)
+/mcp add postgres-prod --transport stdio -- uvx mcp-server-postgres \
+  --connection-string "postgres://user:pass@localhost:5432/mydb"
+
+# O con un servidor HTTP ya desplegado
+/mcp add postgres-prod --transport http https://mcp.midominio.com/postgres \
+  --header "Authorization: Bearer $TOKEN"
+```
+
+Pasos a tener en cuenta:
+
+- Los servidores MCP corren con tus permisos. Si conectas a una DB de produccion, considera dar al servidor solo credenciales de lectura.
+- Variables sensibles: usa `-e VAR=valor` al registrar el server stdio para inyectar tokens sin que queden en el comando visible.
+- Las herramientas MCP aparecen en los agentes con prefijo `mcp__<name>__<tool>`. Puedes restringir cuales se autorizan con `--allowedTools` al iniciar la sesion.
+- Si un dominio (`database`, por ejemplo) tendria que usar este MCP, asignale un agente con `/team domain <team> database <provider>/<agent>` y el orquestador local lo invocara cuando el plan lo requiera.
+
+### Diferencia con el storage interno
+
+El archivo `~/.context/provider-state.sqlite3` es persistencia interna del CLI (perfiles, runs, credenciales). **No es un MCP** y los agentes no lo consultan directamente; solo el runtime lo lee/escribe. Si quieres exponer datos de una base **a los agentes**, registra un servidor MCP como en los ejemplos de arriba.
+
+## Limites y uso por proveedor
+
+`/limites` (alias `/limits`) consulta cada proveedor configurado y te muestra cuanto has consumido, cuanto te queda y los limites de tu plan, en una sola vista.
+
+```sh
+/limites
+```
+
+Que hace:
+
+1. Itera sobre todos los `provider profile` que tienes guardados.
+2. Para cada uno, si hay un adapter implementado, llama a su API real en paralelo (con timeout).
+3. Suma a la respuesta el contador local de tokens del CLI: cuantos tokens ha consumido este perfil en la sesion actual y en el historico persistido en SQLite.
+
+Estado de cada proveedor:
+
+| Proveedor      | Que se consulta                                                                                                       |
+|----------------|-----------------------------------------------------------------------------------------------------------------------|
+| Claude (OAuth) | `GET /api/oauth/usage` -> ventanas (5h/7d/Opus/Sonnet) y extra usage. Reusa el cliente que alimenta a `/usage`         |
+| Anthropic API  | `no-data` — solo headers `anthropic-ratelimit-*` por llamada                                                          |
+| OpenAI OAuth   | `no-data` — Codex/ChatGPT solo exponen rate limits dentro del `TokenCountEvent` de cada respuesta del modelo          |
+| OpenAI API     | `GET /v1/usage` (requiere admin key); si la key no tiene permiso, `no-data`                                           |
+| OpenRouter     | `GET /api/v1/auth/key` -> creditos, limite, rate limit                                                                |
+| MiniMax        | `GET /v1/token_plan/remains` -> uso por modelo (endpoint reverse-engineered desde MiniMax-AI/cli `mmx quota show`)    |
+| Z.AI           | `GET /api/monitor/usage/quota/limit` -> tokens usados/limite del coding plan                                          |
+| Ollama local   | Siempre `ok` (ilimitado, corre en tu maquina); cuenta modelos disponibles                                             |
+| Ollama Cloud   | `no-data` salvo localhost                                                                                             |
+
+El contador local de tokens funciona para todos los proveedores por igual: se persiste en `~/.context/provider-state.sqlite3` y te permite saber cuanto has gastado aunque el proveedor no exponga API. La cuenta empieza en cero la primera vez que ejecutas `/limites` despues de instalar.
+
+Comandos relacionados:
+
+```sh
+/limites          # vista interactiva por proveedor
+/usage            # solo Claude: limites del plan vistos por Settings
+/cost             # costo de la sesion actual
 ```
 
 ## Reporte de errores

package/package.json

@@ -1,169 +1,142 @@
-{
-  "name": "@iaforged/context-code",
-  "version": "1.0.69",
-  "bin": {
-    "context": "context-bootstrap.js",
-    "context-recovery": "context-bootstrap.js"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "type": "module",
-  "author": "Context AI",
-  "license": "MIT",
-  "description": "Context Code es un asistente de desarrollo para la terminal. Puede revisar tu proyecto, editar archivos, ejecutar comandos y apoyarte en tareas reales de programacion.",
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "files": [
-    "context-bootstrap.js",
-    "cli.js",
-    "README.md",
-    "LICENSE.md"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json && node ./scripts/postprocess-build.mjs",
-    "dev:build": "npm run build",
-    "dev:watch": "tsc -p tsconfig.json --watch --preserveWatchOutput",
-    "dev:run": "node ./dist/src/entrypoints/cli.js",
-    "dev:version": "npm run build && node ./dist/src/entrypoints/cli.js --version",
-    "dev:help": "npm run build && node ./dist/src/entrypoints/cli.js --help",
-    "start": "node ./scripts/run.mjs",
-    "package": "npm run build && node ./scripts/package-build.mjs",
-    "install:global": "npm install -g .",
-    "uninstall:global": "npm uninstall -g @iaforged/context-code",
-    "typecheck": "tsc -p tsconfig.typecheck.json",
-    "build:recovery": "npm run build",
-    "start:recovery": "npm run start",
-    "recovery": "npm run build && npm run start",
-    "package:recovery": "npm run package",
-    "prepublishOnly": "node -e \"if (!process.env.AUTHORIZED) { console.error('ERROR: Direct publishing is not allowed.\\nPlease see the release workflow documentation to publish this package.'); process.exit(1); }\"",
-    "publish:package": "powershell -ExecutionPolicy Bypass -File ./publish-package.ps1",
-    "pubpackages": "bash ./scripts/pubpackages.sh",
-    "instalar": "bash -lc 'AUTHORIZED=1 npm install -g . --prefix \"$HOME/.context/local\" --force'",
-    "publicar": "bash -lc 'AUTHORIZED=1 npm publish'"
-  },
-  "optionalDependencies": {
-    "@img/sharp-darwin-arm64": "^0.34.2",
-    "@img/sharp-darwin-x64": "^0.34.2",
-    "@img/sharp-linux-arm": "^0.34.2",
-    "@img/sharp-linux-arm64": "^0.34.2",
-    "@img/sharp-linux-x64": "^0.34.2",
-    "@img/sharp-linuxmusl-arm64": "^0.34.2",
-    "@img/sharp-linuxmusl-x64": "^0.34.2",
-    "@img/sharp-win32-arm64": "^0.34.2",
-    "@img/sharp-win32-x64": "^0.34.2",
-    "@whiskeysockets/baileys": "7.0.0-rc.9"
-  },
-  "devDependencies": {
-    "@types/bun": "^1.3.11",
-    "@types/node": "^25.5.2",
-    "@types/react": "^19.2.14",
-    "@types/ws": "^8.18.1",
-    "type-fest": "^5.5.0",
-    "typescript": "^6.0.2"
-  },
-  "dependencies": {
-    "@alcalzone/ansi-tokenize": "^0.3.0",
-    "@anthropic-ai/bedrock-sdk": "^0.27.0",
-    "@anthropic-ai/claude-agent-sdk": "^0.2.92",
-    "@anthropic-ai/foundry-sdk": "^0.2.3",
-    "@anthropic-ai/mcpb": "^2.1.2",
-    "@anthropic-ai/sandbox-runtime": "^0.0.49",
-    "@anthropic-ai/sdk": "^0.82.0",
-    "@anthropic-ai/vertex-sdk": "^0.14.4",
-    "@aws-sdk/client-bedrock": "^3.1025.0",
-    "@aws-sdk/client-bedrock-runtime": "^3.1025.0",
-    "@aws-sdk/client-sts": "^3.1025.0",
-    "@aws-sdk/credential-provider-node": "^3.972.29",
-    "@aws-sdk/credential-providers": "^3.1025.0",
-    "@azure/identity": "^4.13.1",
-    "@commander-js/extra-typings": "^14.0.0",
-    "@growthbook/growthbook": "^1.6.5",
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@opentelemetry/api": "^1.9.1",
-    "@opentelemetry/api-logs": "^0.214.0",
-    "@opentelemetry/core": "^2.6.1",
-    "@opentelemetry/exporter-logs-otlp-grpc": "^0.214.0",
-    "@opentelemetry/exporter-logs-otlp-http": "^0.214.0",
-    "@opentelemetry/exporter-logs-otlp-proto": "^0.214.0",
-    "@opentelemetry/exporter-metrics-otlp-grpc": "^0.214.0",
-    "@opentelemetry/exporter-metrics-otlp-http": "^0.214.0",
-    "@opentelemetry/exporter-metrics-otlp-proto": "^0.214.0",
-    "@opentelemetry/exporter-prometheus": "^0.214.0",
-    "@opentelemetry/exporter-trace-otlp-grpc": "^0.214.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.214.0",
-    "@opentelemetry/exporter-trace-otlp-proto": "^0.214.0",
-    "@opentelemetry/resources": "^2.6.1",
-    "@opentelemetry/sdk-logs": "^0.214.0",
-    "@opentelemetry/sdk-metrics": "^2.6.1",
-    "@opentelemetry/sdk-trace-base": "^2.6.1",
-    "@opentelemetry/semantic-conventions": "^1.40.0",
-    "@smithy/core": "^3.23.14",
-    "@smithy/node-http-handler": "^4.5.2",
-    "ajv": "^8.18.0",
-    "ajv-formats": "^3.0.1",
-    "asciichart": "^1.5.25",
-    "auto-bind": "^5.0.1",
-    "axios": "^1.14.0",
-    "bidi-js": "^1.0.3",
-    "cacache": "^20.0.4",
-    "chalk": "^5.6.2",
-    "chokidar": "^5.0.0",
-    "cli-boxes": "^4.0.1",
-    "cli-highlight": "^2.1.11",
-    "code-excerpt": "^4.0.0",
-    "diff": "^8.0.4",
-    "emoji-regex": "^10.6.0",
-    "env-paths": "^4.0.0",
-    "execa": "^9.6.1",
-    "fflate": "^0.8.2",
-    "figures": "^6.1.0",
-    "fuse.js": "^7.3.0",
-    "get-east-asian-width": "^1.5.0",
-    "google-auth-library": "^10.6.2",
-    "grammy": "^1.42.0",
-    "highlight.js": "^11.11.1",
-    "https-proxy-agent": "^9.0.0",
-    "ignore": "^7.0.5",
-    "indent-string": "^5.0.0",
-    "ink": "^6.8.0",
-    "jsonc-parser": "^3.3.1",
-    "lodash-es": "^4.18.1",
-    "lru-cache": "^11.3.2",
-    "marked": "^18.0.0",
-    "mssql": "^10.0.2",
-    "mysql2": "^3.6.5",
-    "node-fetch": "^3.3.2",
-    "node-forge": "^1.4.0",
-    "oracledb": "^6.3.0",
-    "p-map": "^7.0.4",
-    "pg": "^8.11.3",
-    "picomatch": "^4.0.4",
-    "plist": "^3.1.0",
-    "proper-lockfile": "^4.1.2",
-    "qrcode": "^1.5.4",
-    "react": "^19.2.4",
-    "react-reconciler": "^0.33.0",
-    "semver": "^7.7.4",
-    "sharp": "^0.34.5",
-    "shell-quote": "^1.8.3",
-    "signal-exit": "^4.1.0",
-    "stack-utils": "^2.0.6",
-    "strip-ansi": "^7.2.0",
-    "supports-hyperlinks": "^4.4.0",
-    "tree-kill": "^1.2.2",
-    "turndown": "^7.2.4",
-    "usehooks-ts": "^3.1.1",
-    "vscode-jsonrpc": "^8.2.1",
-    "vscode-languageserver-protocol": "^3.17.5",
-    "vscode-languageserver-types": "^3.17.5",
-    "wrap-ansi": "^10.0.0",
-    "ws": "^8.20.0",
-    "xss": "^1.0.15",
-    "yaml": "^2.8.3",
-    "zod": "^4.3.6",
-    "zod-to-json-schema": "^3.25.2"
-  }
-}
+{
+  "name": "@iaforged/context-code",
+  "version": "1.0.71",
+  "description": "Context Code es un asistente de desarrollo para la terminal. Puede revisar tu proyecto, editar archivos, ejecutar comandos y apoyarte en tareas reales de programacion.",
+  "author": "Context AI",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "context": "context-bootstrap.js",
+    "context-recovery": "context-bootstrap.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "context-bootstrap.js",
+    "cli.js",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@alcalzone/ansi-tokenize": "^0.3.0",
+    "@anthropic-ai/bedrock-sdk": "^0.27.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.92",
+    "@anthropic-ai/foundry-sdk": "^0.2.3",
+    "@anthropic-ai/mcpb": "^2.1.2",
+    "@anthropic-ai/sandbox-runtime": "^0.0.49",
+    "@anthropic-ai/sdk": "^0.82.0",
+    "@anthropic-ai/vertex-sdk": "^0.14.4",
+    "@aws-sdk/client-bedrock": "^3.1025.0",
+    "@aws-sdk/client-bedrock-runtime": "^3.1025.0",
+    "@aws-sdk/client-sts": "^3.1025.0",
+    "@aws-sdk/credential-provider-node": "^3.972.29",
+    "@aws-sdk/credential-providers": "^3.1025.0",
+    "@azure/identity": "^4.13.1",
+    "@commander-js/extra-typings": "^14.0.0",
+    "@growthbook/growthbook": "^1.6.5",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/api-logs": "^0.214.0",
+    "@opentelemetry/core": "^2.6.1",
+    "@opentelemetry/exporter-logs-otlp-grpc": "^0.214.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.214.0",
+    "@opentelemetry/exporter-logs-otlp-proto": "^0.214.0",
+    "@opentelemetry/exporter-metrics-otlp-grpc": "^0.214.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.214.0",
+    "@opentelemetry/exporter-metrics-otlp-proto": "^0.214.0",
+    "@opentelemetry/exporter-prometheus": "^0.214.0",
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0.214.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.214.0",
+    "@opentelemetry/exporter-trace-otlp-proto": "^0.214.0",
+    "@opentelemetry/resources": "^2.6.1",
+    "@opentelemetry/sdk-logs": "^0.214.0",
+    "@opentelemetry/sdk-metrics": "^2.6.1",
+    "@opentelemetry/sdk-trace-base": "^2.6.1",
+    "@opentelemetry/semantic-conventions": "^1.40.0",
+    "@smithy/core": "^3.23.14",
+    "@smithy/node-http-handler": "^4.5.2",
+    "ajv": "^8.18.0",
+    "ajv-formats": "^3.0.1",
+    "asciichart": "^1.5.25",
+    "auto-bind": "^5.0.1",
+    "axios": "^1.14.0",
+    "bidi-js": "^1.0.3",
+    "cacache": "^20.0.4",
+    "chalk": "^5.6.2",
+    "chokidar": "^5.0.0",
+    "cli-boxes": "^4.0.1",
+    "cli-highlight": "^2.1.11",
+    "code-excerpt": "^4.0.0",
+    "diff": "^8.0.4",
+    "emoji-regex": "^10.6.0",
+    "env-paths": "^4.0.0",
+    "execa": "^9.6.1",
+    "fflate": "^0.8.2",
+    "figures": "^6.1.0",
+    "fuse.js": "^7.3.0",
+    "get-east-asian-width": "^1.5.0",
+    "google-auth-library": "^10.6.2",
+    "grammy": "^1.42.0",
+    "highlight.js": "^11.11.1",
+    "https-proxy-agent": "^9.0.0",
+    "ignore": "^7.0.5",
+    "indent-string": "^5.0.0",
+    "ink": "^6.8.0",
+    "jsonc-parser": "^3.3.1",
+    "lodash-es": "^4.18.1",
+    "lru-cache": "^11.3.2",
+    "marked": "^18.0.0",
+    "mssql": "^10.0.2",
+    "mysql2": "^3.6.5",
+    "node-fetch": "^3.3.2",
+    "node-forge": "^1.4.0",
+    "oracledb": "^6.3.0",
+    "p-map": "^7.0.4",
+    "pg": "^8.11.3",
+    "picomatch": "^4.0.4",
+    "plist": "^3.1.0",
+    "proper-lockfile": "^4.1.2",
+    "qrcode": "^1.5.4",
+    "react": "^19.2.4",
+    "react-reconciler": "^0.33.0",
+    "semver": "^7.7.4",
+    "sharp": "^0.34.5",
+    "shell-quote": "^1.8.3",
+    "signal-exit": "^4.1.0",
+    "stack-utils": "^2.0.6",
+    "strip-ansi": "^7.2.0",
+    "supports-hyperlinks": "^4.4.0",
+    "tree-kill": "^1.2.2",
+    "turndown": "^7.2.4",
+    "usehooks-ts": "^3.1.1",
+    "vscode-jsonrpc": "^8.2.1",
+    "vscode-languageserver-protocol": "^3.17.5",
+    "vscode-languageserver-types": "^3.17.5",
+    "wrap-ansi": "^10.0.0",
+    "ws": "^8.20.0",
+    "xss": "^1.0.15",
+    "yaml": "^2.8.3",
+    "zod": "^4.3.6",
+    "zod-to-json-schema": "^3.25.2"
+  },
+  "optionalDependencies": {
+    "@img/sharp-darwin-arm64": "^0.34.2",
+    "@img/sharp-darwin-x64": "^0.34.2",
+    "@img/sharp-linux-arm": "^0.34.2",
+    "@img/sharp-linux-arm64": "^0.34.2",
+    "@img/sharp-linux-x64": "^0.34.2",
+    "@img/sharp-linuxmusl-arm64": "^0.34.2",
+    "@img/sharp-linuxmusl-x64": "^0.34.2",
+    "@img/sharp-win32-arm64": "^0.34.2",
+    "@img/sharp-win32-x64": "^0.34.2",
+    "@whiskeysockets/baileys": "7.0.0-rc.9"
+  },
+  "scripts": {
+    "prepublishOnly": "node -e \"if (!process.env.AUTHORIZED) { console.error('ERROR: Direct publishing is not allowed.\\nPlease see the release workflow documentation to publish this package.'); process.exit(1); }\""
+  }
+}