alegra-data-agent 0.7.1 → 0.7.2

package/README.md

@@ -1,445 +1,21 @@
-# Data Agent Self Service
+# alegra-data-agent
 
-> **Cómo se llama cada cosa.** El producto es **Data Agent Self Service** — así aparece en el
-> gateway y en el login. El repositorio es `Alegra-Team/data-agent-selfservice` y el paquete npm
-> es `alegra-data-agent`: son tres registros independientes y no tienen por qué coincidir.
->
-> El paquete **no se renombra**: su nombre está incrustado en el hook de arranque de cada máquina
-> ya instalada, así que cambiarlo obligaría a migrar a todo el mundo a mano. Lo mismo vale para
-> el `ISSUER`/`AUDIENCE` de los JWT (`gateway/lib/jwt.ts`) — tocarlos invalidaría los tokens ya
-> emitidos.
-
-Agente de Data interno de Alegra. Una línea instala las skills + MCPs del equipo BI Data en tu herramienta de IA (Claude Code, Cursor, OpenCode, Antigravity, Codex, Hermes), gated por OAuth `@alegra.com`.
-
-> Uso interno de Alegra. No publicar, no promocionar, no contribuciones externas.
-
-## Estado
-
-- **CLI**: [`alegra-data-agent`](https://www.npmjs.com/package/alegra-data-agent) en npmjs.com.
-- **Gateway en producción**: [https://alegra-data-agent.vercel.app](https://alegra-data-agent.vercel.app).
-- **Healthcheck**: `https://alegra-data-agent.vercel.app/api/health`.
-- **Guía de uso y documentación**: [wiki del agente](https://wiki.alegra.com/doc/alegra-data-agent-DKiPc9cvFS) — empezar, cómo preguntar, qué responde, problemas comunes, [arquitectura y seguridad](https://wiki.alegra.com/doc/arquitectura-y-seguridad-vWfNc90Myy) e [historial de cambios](https://wiki.alegra.com/doc/historial-de-cambios-J8uMHq1sfd). La página de entrada del gateway enlaza a todas.
-
-## Compatibilidad
-
-| Sistema operativo | ✓ |
-|---|---|
-| macOS (Intel + Apple Silicon) | ✅ |
-| Ubuntu / Debian / Linux | ✅ |
-| WSL (Windows Subsystem for Linux) | ✅ |
-| Windows 10/11 nativo | ✅ |
-
-| Cliente AI | ✓ |
-|---|---|
-| [Claude Code](https://claude.com/claude-code) | ✅ |
-| [Cursor](https://cursor.com) | ✅ |
-| [OpenCode](https://opencode.ai) | ✅ |
-| [Antigravity](https://antigravity.dev) | ✅ |
-| [Codex](https://developers.openai.com/codex) | ✅ |
-| [Hermes Agent](https://hermes-agent.nousresearch.com) | ✅ |
-
-Si no tenés ningún cliente instalado, el bootstrap te instala Claude Code automáticamente.
-
-### Si no usás terminal
-
-El comando de arriba es para clientes CLI/IDE. En **claude.ai, Claude Desktop, Cowork y móvil**
-el agente llega sin instalar nada:
-
-| | Cómo |
-|---|---|
-| MCPs | Configuración → **Conectores**. En Team/Enterprise el owner los agrega en *Organization settings* y le quedan disponibles a toda Alegra. |
-| Skills | Configuración → **Habilidades** → subir el `.zip`. El owner puede provisionarlas para toda la organización y **aparecen solas**, sin que nadie suba nada. |
-
-Los ZIP se generan con `pnpm run pack:web` (uno por skill, en `dist/skills-web/`).
-
-Dos cosas que conviene saber:
-
-- Un conector de la cuenta se sirve a **todas** las superficies, **Claude Code incluido** — ahí
-  aparecen en `/mcp` bajo `claude.ai`. Si ya tenés el MCP como server local, el conector queda
-  oculto por URL duplicada; el propio `/mcp` te dice cómo cambiar de uno al otro.
-- Los ZIP subidos **no se auto-actualizan**, y no hay API para subirlos. El CLI sí (manifest
-  firmado). Después de un release, `pnpm run pack:web` dice cuáles cambiaron: solo esos se
-  vuelven a subir (paso 5 del «Flujo de release»).
-
-Detalle y el porqué en [ADR-0010](./docs/adr/0010-superficies-no-code.md).
+Agente de Data interno de Alegra. Instala skills + MCPs en tu cliente de IA con un comando.
 
 ## Instalación
 
-**El comando único es:**
-
 ```sh
 pnpm dlx alegra-data-agent
 ```
 
-Funciona en cualquier terminal (macOS Terminal, GNOME Terminal, WSL, PowerShell) y desde la terminal embebida de cualquier cliente AI (Claude Code, Cursor, OpenCode, Antigravity, Codex, Hermes).
-
-### Si no tenés Node o pnpm
-
-Si al correr `pnpm dlx alegra-data-agent` te dice `pnpm: command not found`, primero corré el bootstrap que te instala Node 22+ y pnpm 11+ automáticamente:
-
-**macOS / Linux / WSL** — en cualquier terminal:
-
-```sh
-curl -fsSL https://alegra-data-agent.vercel.app/install.sh | bash
-```
-
-**Windows nativo** — en PowerShell (sin admin):
-
-```powershell
-irm https://alegra-data-agent.vercel.app/install.ps1 | iex
-```
-
-El bootstrap deja Node + pnpm + git + Claude Code listos, y al final corre `pnpm dlx alegra-data-agent` por vos. Después de eso, el comando único es siempre `pnpm dlx alegra-data-agent`.
-
-### Después del install
-
-1. **Reiniciá tu cliente AI** (Claude Code / Cursor / OpenCode / Antigravity / Codex / Hermes).
-2. **Hacé tu primera pregunta** en español. Ejemplo: *"cuántos nuevos clientes en mayo en Colombia"*.
-3. **La primera vez** que el agente use un servicio (Metabase, Amplitude, Wiki) te va a pedir 1 click con tu cuenta `@alegra.com`. Después no te pide nada más.
-
-> El agente nunca te va a pedir API keys, tokens, ni variables de entorno. Todo es OAuth `@alegra.com` automático.
-
-> **HubSpot es la excepción: no lo instala el CLI, se habilita como conector de la cuenta.** El
-> servidor de HubSpot no soporta el registro automático que usan los clientes AI, así que una entry
-> local nunca autentica. El conector oficial sí funciona: Configuración → Conectores → HubSpot →
-> Conectar, y queda disponible en Claude Code, Claude Desktop y claude.ai. En Cursor, OpenCode y
-> Codex hoy no hay ruta. Detalle en [`agent/mcps/hubspot/README.md`](./agent/mcps/hubspot/README.md).
+Solo accesible para cuentas `@alegra.com` (OAuth Google). El CLI te abre el navegador para iniciar sesión.
 
 ## Requisitos
 
-- Cuenta Google `@alegra.com` verificada (lo único que sí tenés que tener antes).
-- Node ≥ 22.6.0 — instala el bootstrap si te falta.
-- pnpm ≥ 11.1.2 — instala el bootstrap si te falta.
-- Un cliente AI compatible — el bootstrap instala Claude Code si no detecta ninguno.
-
-## Qué se instala
-
-| Herramienta | Skills | Configuración MCP |
-|---|---|---|
-| Claude Code | `~/.claude/skills/<n>/` (carpeta) | `~/.claude.json` → `mcpServers` |
-| Cursor | `~/.cursor/skills/<n>/` (carpeta) | `~/.cursor/mcp.json` → `mcpServers` |
-| OpenCode | `~/.config/opencode/skills/<n>/` (carpeta) | `~/.config/opencode/opencode.json` → `mcp` |
-| Antigravity | `~/.gemini/skills/<n>/` (carpeta) | `~/.gemini/config/mcp_config.json` → `mcpServers` |
-| Codex | `~/.agents/skills/<n>/` (carpeta) | `~/.codex/config.toml` → `[mcp_servers.<n>]` |
-
-### Acotar los MCPs a una carpeta (opcional)
-
-Por defecto los MCPs se instalan a nivel usuario: quedan disponibles en toda sesión, de
-cualquier carpeta. Si en la misma máquina separás contextos —trabajo de Alegra, proyectos
-propios, trabajo de un cliente— podés acotarlos a una sola carpeta:
-
-```bash
-mkdir -p ~/.alegra
-echo 'MCP_DIR=~/trabajo/alegra' >> ~/.alegra/agent.conf
-pnpm dlx alegra-data-agent install --yes
-```
-
-Los MCPs pasan a `~/trabajo/alegra/.mcp.json`, que Claude Code resuelve subiendo desde el
-directorio actual: **cascadea a todo lo que esté dentro de esa carpeta y es invisible fuera
-de ella**. Se pre-aprueban solos, así que no hay que aceptarlos repo por repo.
-
-También funciona como env var (`ALEGRA_DATA_AGENT_MCP_DIR`, le gana al archivo), pero el
-archivo es lo recomendado: el hook de auto-update corre en un shell no interactivo y no ve
-lo que exportes en tu `.bashrc`, así que reinstalaría a nivel usuario.
-
-**Qué clientes lo respetan.** Claude Code y Cursor pueden acotar un MCP a una carpeta, así
-que con `MCP_DIR` los MCPs van solo a esos dos. OpenCode, Hermes, Codex y Antigravity no
-pueden: OpenCode busca su config de proyecto solo hasta la raíz del repo git, y Hermes guarda
-los MCPs por perfil. Ahí los MCPs quedarían globales, así que no se instalan y se retiran los
-que ya tuvieran. Las skills sí se instalan en todos. Para consultar datos de Alegra, usá
-Claude Code o Cursor dentro de la carpeta.
-
-**Se corrige solo.** Cada arranque compara dónde debería estar cada MCP con dónde está y
-retira lo que sobra, siempre que sea nuestro: una copia en `~/.claude.json` de antes de
-configurar `MCP_DIR`, la de una carpeta vieja si lo cambiaste o lo sacaste, o la de un cliente
-que no corresponde. Un server tuyo con el mismo nombre y otra configuración no se toca.
-`alegra-data-agent status` te dice en qué archivo quedaron y avisa si ve algo fuera de lugar.
-
-Detalle completo en [ADR-0012](docs/adr/0012-mcp-scope-por-workspace.md).
-
-### Dónde quedan los archivos que genera el agente
-
-Cuando pedís un CSV, un Excel o un gráfico, el agente lo guarda en `alegra-data/` dentro de
-la carpeta donde abriste la sesión, y te dice la ruta al terminar (en WSL, también la de
-Windows). Nunca en los temporales del cliente. Para que vaya siempre a la misma carpeta:
-
-```bash
-mkdir -p ~/.alegra
-echo "OUTPUT_DIR=$HOME/Documentos/alegra-data" >> ~/.alegra/agent.conf
-```
-
-Lo lee el agente, no el CLI, así que aplica desde la siguiente pregunta, sin reinstalar. En
-claude.ai, Desktop y Cowork el archivo aparece para descargar en el chat.
-
-El CLI:
-
-1. Verifica auth contra el gateway (OAuth Google `hd=alegra.com`).
-2. Descarga el manifest firmado Ed25519 y verifica firma antes de tocar disco.
-3. Verifica SHA-256 por archivo antes de escribirlo.
-4. Escribe atómicamente (tmp + rename) los configs JSON y respalda lo que ya existía (`*.bak-<ts>`).
-5. Registra en `~/.config/alegra-data-agent/lock.json` qué quedó instalado por target.
-6. Configura **auto-update en cada cliente instalado** (los 5, no solo Claude Code): Claude Code y Codex vía hook `SessionStart`, Cursor vía `workspaceOpen`, Antigravity vía `SessionStart` (Gemini), OpenCode vía plugin. Al abrir el cliente, el contenido se actualiza solo.
-
-## Comandos
-
-```sh
-pnpm dlx alegra-data-agent                       # instala / actualiza todo (default)
-pnpm dlx alegra-data-agent --target=claude-code,cursor
-pnpm dlx alegra-data-agent --only=alegra-sales,alegra-growth
-pnpm dlx alegra-data-agent --dry-run
-
-pnpm dlx alegra-data-agent update                # re-descarga lo que cambió
-pnpm dlx alegra-data-agent status                # estado actual + drift
-pnpm dlx alegra-data-agent list                  # catálogo del gateway
-pnpm dlx alegra-data-agent uninstall
-
-pnpm dlx alegra-data-agent login
-pnpm dlx alegra-data-agent logout
-pnpm dlx alegra-data-agent whoami
-```
-
-Ayuda completa: `pnpm dlx alegra-data-agent help`.
-
-> El CLI siempre termina ejecutando la última versión publicada: si pnpm sirve una anterior (cooldown de 24h de pnpm 11), el comando detecta la nueva en el registry y se re-ejecuta solo con ella (self-bounce).
-
-## Skills
-
-16 skills. Cada equipo dueño mantiene la suya; BI Data mantiene la infraestructura y las skills horizontales.
-
-| Skill | Dueño | Tipo |
-|---|---|---|
-| `alegra-bi` (router) | BI Data | Router |
-| `alegra-strategic` | Strategic | Dominio |
-| `alegra-product` | Producto | Dominio |
-| `alegra-sales` | Sales | Dominio |
-| `alegra-accountant` | Programa Contadores | Dominio |
-| `alegra-cx` | Customer Experience | Dominio |
-| `alegra-growth` | Growth | Dominio |
-| `alegra-alanube` | Alanube | Dominio |
-| `alegra-collection` | Collection | Dominio |
-| `alegra-sr` | Strategic Relationships | Dominio |
-| `alegra-board` | BI Data | Dominio |
-| `dashboard-auditor` | BI Data | Horizontal (review) |
-| `dataviz-reviewer` | BI Data | Horizontal (review) |
-| `presentation-coach` | BI Data | Horizontal (coach) |
-| `launch-measurement` | BI Data | Horizontal (proceso) |
-| `agent-onboarding` | BI Data | Soporte |
-
-Arquitectura: [`docs/skills-architecture.md`](./docs/skills-architecture.md). Contrato de ejecución (MBQL por defecto, SQL nativo de fallback, acceso MCP-first sin tokens): [`agent/skills/SKILL_STANDARD.md`](./agent/skills/SKILL_STANDARD.md) §3.1.
-
-### Cómo responde el agente
-
-Tres reglas transversales que heredan todas las skills de dominio (detalle en [`agent/skills/SKILL_STANDARD.md`](./agent/skills/SKILL_STANDARD.md)):
-
-- **Pregunta la población, asume los defaults.** Si falta el período, el país o el segmento, elige el más útil y lo avisa en una línea. Si no está claro **qué se cuenta** — "nuevos usuarios" puede ser signups (se registraron) o new logos (empezaron a pagar), que difieren en un orden de magnitud — pregunta antes de consultar. El vocabulario de poblaciones vive en el router (`alegra-bi`, sección «Vocabulario»).
-- **La respuesta dice de dónde sale el número.** `New logos (empezaron a pagar · fact_customers_mrr) | 71`, no `Nuevos | 71`. Una cifra sin procedencia no se puede auditar, y las mismas palabras nombran poblaciones distintas según la tabla.
-- **Una pregunta = una consulta.** Dos si hace falta una semilla o un delta. MBQL por defecto; cuando MBQL no lo expresa (CTEs, subqueries, window functions) va SQL nativo por `execute_sql` en una llamada, en vez de partirlo en varias.
-
-**Fuentes de verdad, cuando dos tablas dan números distintos:** `dm_strategic.fact_customers_mrr` manda para todo lo que sea quién paga, quién empezó y quién dejó de pagar. `dm_sales.fact_closed_deals` es su vista comercial (quién cerró, contra qué meta), conectada por `id_company`. Para eventos de uso de producto, `amplitude_events_enriched` en Metabase — no el MCP de Amplitude, no las columnas `*_m` de retención.
-
-## MCPs
-
-Los remotos van vía OAuth — el cliente abre el flow en el primer uso, **cero tokens manuales, cero env vars con secretos**. `salesforce` es la excepción: MCP stdio local del vendor, auth por la Salesforce CLI (`sf org login web --set-default`, requiere Node ≥ 22), solo lectura, para casos puntuales fuera del mirror de Metabase. No se autentica desde `/mcp` — soporte en el Caso 11 de `agent-onboarding`.
-
-| MCP | Backend | Transporte | Auth |
-|---|---|---|---|
-| `amplitude` | Amplitude SaaS | remoto (http) | OAuth |
-| `hubspot` | HubSpot SaaS | conector de cuenta | OAuth — **no se instala**: se habilita en Configuración → Conectores ([por qué](./agent/mcps/hubspot/README.md)) |
-| `metabase` | Metabase self-hosted | remoto (http) | OAuth corporativo |
-| `salesforce` | Salesforce DX (solo lectura) | stdio local | Salesforce CLI (`sf org login web`) — no por `/mcp` |
-| `wiki-alegra` | Wiki self-hosted | remoto (http) | OAuth corporativo |
-
-Llave universal para joins: `id_company`. Detalles en [`docs/joining-data-sources.md`](./docs/joining-data-sources.md).
-
-## Para mantenedores
-
-Skills viven en `agent/skills/<name>/SKILL.md` (+ anexos). MCPs en `agent/mcps/<name>/config.example.json`. El manifest firmado se regenera cuando esos paths cambian — **hoy en local**, porque Actions está apagado (ver «Release sin Actions» más abajo).
-
-### Flujo de release
-
-> Los pasos 1 y 2 describen el flujo **con CI**. Mientras Actions siga apagado, la validación y la firma van en local: ver «Release sin Actions» justo abajo.
-
-1. PR `<rama>-changes` o `feature/* → testing` modificando `agent/skills/**` o `agent/mcps/**` (CI valida standards, scan y frescura del manifest).
-2. PR `testing → main`: el workflow `sign-manifest.yml` se dispara en el PR (toca esos paths), regenera el manifest, lo escanea, lo firma con `ALEGRA_SIGNING_KEY` y commitea el manifest firmado de vuelta al branch del PR vía la REST API de GitHub (queda Verified, server-side). Al mergear, `main` ya tiene el manifest correcto.
-3. Gateway en Vercel se redespliega manualmente con `pnpm run deploy` desde `gateway/` (corre `prepare:skills`, que verifica firma y sha256, y después `vercel --prod`; nunca `vercel --prod` a secas). La integración Vercel ↔ GitHub no está habilitada: el proyecto de Vercel vive en su propio team y no depende de la organización de GitHub.
-4. Próximo `update` de cualquier alegrito trae los cambios — sin republicar el CLI a npm.
-5. **Superficies no-code (claude.ai, Desktop, Cowork).** Los pasos anteriores no llegan ahí: esos
-   ZIP se suben a mano y no hay API para automatizarlo (ADR-0010). `pnpm run pack:web` lista
-   exactamente cuáles cambiaron respecto de lo que ya está en la organización. Se suben esos, y
-   después `pnpm run pack:web -- --mark-published <skills>` registra lo subido en
-   `agent/web-published.json`, que se commitea. Sin este paso, quien usa Desktop sigue con las
-   definiciones viejas sin saberlo.
-
-### Release sin Actions
-
-Con los workflows apagados, los dos pasos que hacía el CI se hacen en local. Requieren la clave
-privada de firma (gestor del equipo) y el token de npm.
-
-```sh
-# 1. Validar, escanear, regenerar y FIRMAR el manifest
-ALEGRA_SIGNING_KEY="$(cat /ruta/a/la/clave)" pnpm run manifest
-
-# 2. Verificar que el manifest quedó firmado y válido antes de commitear
-node --experimental-strip-types -e "import('./src/signature.ts').then(async m => {
-  const man = JSON.parse((await import('node:fs')).readFileSync('agent/skills/index.json','utf-8'));
-  const r = m.verifyManifestSignature(man);
-  console.log(r.ok ? 'firma válida — ' + man.signature.keyId : 'INVÁLIDA: ' + r.reason);
-})"
-
-# 3. Publicar a npm: DESPUÉS del merge a main, del deploy del gateway verificado en producción
-#    con una sesión real (manifest nuevo, firma válida, update instala) y del tag. Lección de la 0.5.0.
-pnpm run prepublishOnly && cp .github/README-npm.md README.md && pnpm publish --access public --no-git-checks
-git checkout README.md   # devolver el README completo al repo
-```
-
-> `--no-git-checks` es obligatorio acá, no opcional: el swap del paso anterior deja el working tree
-> "sucio" a propósito (es exactamente lo que hace `publish.yml` en `Swap to minimal README for npm
-> tarball` + `--no-git-checks` en su paso `Publish`). Sin el flag, `pnpm publish` rechaza con
-> `ERR_PNPM_GIT_UNCLEAN` — no es una falla real, es el propio swap documentado arriba.
-
-El manifest firmado se commitea en el PR, en vez de que el bot lo commitee al branch. Todo lo
-demás del flujo no cambia.
-
-**Después de publicar, la wiki.** Copiar la entrada nueva del `CHANGELOG.md` **arriba** de la
-página hija [Historial de cambios](https://wiki.alegra.com/doc/historial-de-cambios-J8uMHq1sfd) y
-actualizar la línea **Estado** del home de la wiki (versión, skills, fecha). El home no lleva
-historial: solo el enlace a esa página, para que no crezca con cada release. El CHANGELOG del repo
-es la fuente; la wiki lo copia, nunca al revés.
-
-### Publicación de nueva versión del CLI
-
-1. Bump `version` en `package.json` y `gateway/package.json` + entrada en `CHANGELOG.md` + regenerar el manifest con **`pnpm run manifest`** (el pipeline completo: `validate` → `scan` → `generate` → `sign`; el `productVersion` sale de package.json). Todo dentro del mismo PR del release.
-2. Tras el merge a main, tag sobre el merge commit: `git tag -s vX.Y.Z && git push origin vX.Y.Z`.
-3. **Con Actions apagado este paso no ocurre:** el tag no publica nada y el publish se hace a mano (ver «Release sin Actions»). Cuando Actions vuelva, el workflow `publish.yml` valida que `package.json` coincida con el tag, corre los gates (validate → scan → tests) y publica: build → swap a `.github/README-npm.md` (README mínimo del tarball) → `pnpm publish --access public`. Requiere el secret `NPM_TOKEN` configurado.
-
-> ⚠️ **Nunca corras `manifest:generate` solo.** Borra el bloque `signature` de
-> `agent/skills/index.json`, y `verifyManifestSignature` es hard-fail: un manifest sin firma hace
-> que el CLI rechace **toda** instalación y update, no solo la skill que tocaste. Siempre
-> `pnpm run manifest`, que firma al final. `tests/security/manifest-committed.test.mjs` lo caza en
-> local si se te pasa.
-
-**Si el release sale mal:** mover el dist-tag `latest` hacia atrás **no revierte a nadie** — el
-hook resuelve por rango semver y los tags no participan. El procedimiento real está en
-[`docs/rollback.md`](./docs/rollback.md).
-
-### Local
-
-```sh
-pnpm run manifest:scan         # buscar prompt-injection / credenciales
-pnpm run manifest:generate     # regenera agent/skills/index.json
-pnpm run manifest:sign         # firma (requiere ALEGRA_SIGNING_KEY)
-pnpm run manifest               # los cuatro en orden (validate → scan → generate → sign)
-
-pnpm install
-pnpm typecheck
-pnpm build                     # → dist/
-
-pnpm test                      # Fase 1: SOLO valida el schema de los evals — no
-                               # ejecuta ningún agente
-pnpm test:security             # la suite real: firma, paths, clientes, drift de MCPs
-pnpm test:all                  # ambos
-
-pnpm run eval:run -- --local   # Fase 2: ejecuta los evals de verdad contra las skills
-                               # del repo. Cuesta tokens y tarda horas (116 casos); para
-                               # un caso puntual: --only <nombre-del-caso>
-
-pnpm run verify:clients        # E2E: instala en un HOME temporal con 5 de los 6 clientes
-                               # simulados (Hermes aún no está cubierto) y verifica rutas, shapes de MCP, hooks
-                               # e idempotencia (requiere sesión y red)
-```
-
-> **`test:all` en verde no dice que las skills respondan bien.** La Fase 1 solo lee los YAML;
-> si tardó un segundo, no ejecutó nada. Medir routing, tablas y números es `eval:run`: corre cada
-> caso aislado (sin el repo ni la memoria del dev a la vista) y consulta Metabase de verdad.
-> Detalle en [`docs/evals.md`](./docs/evals.md).
-
-El grueso de la verificación corre en local, no en CI: la organización está en plan Free y el
-pool de minutos de Actions es compartido. `pre-commit install && pre-commit install --hook-type
-pre-push` deja los mismos gates enganchados a los commits.
-
-### Keypair de firma
-
-```sh
-pnpm run signing-key:generate      # escribe la privada a un archivo 600; NO la imprime
-```
-
-La pública va en `TRUSTED_KEYS` (`src/signature.ts`); la privada, **en dos lugares**: el gestor
-de contraseñas del equipo y el secret `ALEGRA_SIGNING_KEY` del repo. Un secret de GitHub no se
-puede leer: si es la única copia, se pierde en cuanto haga falta usarla en otro lado — pasó con
-la clave v1 y obligó a rotar.
-
-El CLI acepta **varias claves a la vez**, que es lo que permite rotar sin ventana de rotura: con
-una sola, el CLI nuevo rechaza el manifest viejo *y* el viejo rechaza el nuevo. Procedimiento
-completo en [SECURITY.md](SECURITY.md#custodia-y-rotación-de-la-clave-de-firma).
-
-## Estructura del repo
-
-```
-data-agent-selfservice/
-├── src/                # CLI TypeScript (publicado a npm como dist/)
-├── scripts/            # generate-manifest, sign-manifest, scan-skills, generate-signing-key, verify-clients
-├── agent/
-│   ├── skills/         # SKILL.md + anexos, agrupados por dueño
-│   └── mcps/           # config.example.json por MCP
-├── gateway/            # Next.js en Vercel — OAuth + manifest firmado + skills
-├── docs/               # ADRs + guías
-├── tests/              # evals + security tests
-├── install.sh          # bootstrap para macOS/Linux/WSL (servido por gateway)
-└── install.ps1         # bootstrap para Windows (servido por gateway)
-```
-
-## Troubleshooting
-
-| Síntoma | Probable causa | Fix |
-|---|---|---|
-| `pnpm: command not found` | pnpm no instalado | `corepack enable && corepack prepare pnpm@11.1.2 --activate` |
-| `Node.js >= 22.6.0` requerido | Node viejo | `nvm install 22` o reinstala desde nodejs.org |
-| `Solo cuentas @alegra.com` | OAuth con cuenta personal | Login con tu cuenta corporativa |
-| El cliente no ve los MCPs | Cambio de config no recargado | Reinicia el cliente |
-| `keyId no reconocido` | El CLI no conoce la clave con la que se firmó el manifest (rotación en curso y CLI viejo) | `pnpm dlx alegra-data-agent@latest`. Durante una rotación el CLI acepta la clave nueva y la anterior, así que esto solo aparece en versiones muy atrasadas |
-| Una versión recién publicada no se instala / no actualiza | Cooldown de pnpm 11 (`minimumReleaseAge`, ~24h) sobre versiones de <24h | Desde 0.2.2 el CLI hace self-bounce: aunque pnpm sirva una versión anterior, el comando detecta la última en el registry y se re-ejecuta con ella solo. El self-update (hook) y el bootstrap además corren con `--config.minimumReleaseAge=0`. Para forzarlo a mano: `pnpm dlx alegra-data-agent@<versión>` (pin exacto) |
-
-Si nada funciona: la skill `agent-onboarding` (instalada por defecto) tiene una guía paso a paso de troubleshooting que el modelo puede correr contigo.
-
-## Branching
-
-`<nombre>-changes → testing → main`. Cada quien trabaja en su rama personal (`jhon-changes`,
-`luis-changes`…) y llega por PR: primero a `testing`, después a `main`. Nada entra directo a
-`main`, y **el PR a `main` lo aprueba y mergea otra persona** — nadie mergea el suyo. Detalle en
-[CONTRIBUTING.md](CONTRIBUTING.md).
-
-Cambios a `agent/skills/**` o `agent/mcps/**` disparan el workflow de firma en el PR hacia `main`
-(el manifest firmado se commitea al branch del PR antes del merge). Cambios a `scripts/**.mjs`
-requieren review humano: no autoejecutan la firma, para que un PR a los scripts no pueda
-exfiltrar la clave.
-
-> En plan Free los repos privados no tienen rulesets, así que esto es **un acuerdo del equipo,
-> no un candado técnico**. Lo mismo vale para los commits firmados. Ver
-> [Cómo trabajamos en GitHub (Alegra-Team)](https://wiki.alegra.com/doc/como-trabajamos-en-github-alegra-team-2WuRXpYEmg).
-
-## CI / Workflows
-
-> ⚠️ **Hoy Actions está deshabilitado en este repo.** La organización agotó su presupuesto
-> (`the job was not started because recent account payments have failed or your spending limit
-> needs to be increased`), así que ningún workflow puede correr y dejarlos activos solo llenaría
-> los PRs de checks rojos que no dicen nada del código. **Mientras dure, todo es local**: la
-> validación con pre-commit/pre-push, y la firma del manifest y la publicación a npm a mano —
-> ver «Release sin Actions» abajo. Para reactivarlos cuando haya presupuesto:
-> `gh api -X PUT /repos/Alegra-Team/data-agent-selfservice/actions/permissions -F enabled=true`.
-
-Cuatro workflows, y solo uno corre por PR. El pool de minutos de Actions es compartido entre
-todos los repos de la organización (plan Free), así que en GitHub queda únicamente lo que no se
-puede garantizar en la máquina del autor; el resto vive en `.pre-commit-config.yaml`.
-
-| Workflow | Cuándo dispara | Qué hace |
-|---|---|---|
-| `pr.yml` | PRs a `testing` y a `main` (`paths-ignore` docs-only) | **Un solo job**: gates pnpm-only, standards de skills/MCPs (strict), scan de secretos y prompt injection, frescura del manifest, typecheck y tests. El typecheck del gateway solo si el PR toca `gateway/` |
-| `sign-manifest.yml` | PRs a `main` que tocan `agent/skills/**` o `agent/mcps/**` | Regenera + escanea + firma el manifest y lo commitea al branch del PR vía REST API de GitHub, no con `git push`: así queda firmado server-side y Verified. Necesita el secret `ALEGRA_SIGNING_KEY` |
-| `security.yml` | Schedule semanal + `workflow_dispatch` | Gitleaks + OSV + Trivy + pnpm audit. CodeQL solo bajo dispatch explícito (es el job más caro). No corre por push ni por PR |
-| `publish.yml` | Tag `v*.*.*` | Valida versión == tag + gates + publica el CLI a npmjs.com. Necesita el secret `NPM_TOKEN` |
+- Node ≥ 22.6.0
+- pnpm ≥ 11.1.2
+- Uno de: Claude Code, Cursor, OpenCode, Antigravity, Codex, Hermes Agent
 
-Por qué un solo job y no varios: GitHub factura por job con un mínimo de un minuto, así que
-partir la validación en cuatro costaba cuatro minutos aunque dos de ellos fueran un `grep` de
-tres segundos.
+## Soporte
 
-Dependabot apunta a `testing` como cualquier otro cambio, no directo a main).
+Guía de uso, documentación y soporte para el equipo de Alegra: entra a https://alegra-data-agent.vercel.app con tu cuenta `@alegra.com`.

package/dist/autoupdate.js

@@ -4,7 +4,7 @@ import { logWarn } from "./colors.js";
 import { hookCommandFor, runHookInstall, runHookUninstall, } from "./commands/hook.js";
 import { HERMES_PLUGIN_NAME, hermesPluginManifest, hermesPluginModule } from "./hermes-plugin.js";
 import { runHermesCliAt } from "./installer.js";
-import { COMMAND_NAME, getClaudeSettingsPath, getCodexHooksPath, getCursorHooksPath, getGeminiSettingsPath, getHermesHome, getHermesPluginsDir, getOpenCodePluginPath, readLockFile, } from "./lib.js";
+import { COMMAND_NAME, getAntigravityHooksPath, getClaudeSettingsPath, getCodexHooksPath, getCursorHooksPath, getGeminiSettingsPath, getHermesHome, getHermesPluginsDir, getOpenCodePluginPath, readLockFile, } from "./lib.js";
 function readJsonSafe(path) {
     if (!existsSync(path))
         return {};
@@ -60,6 +60,7 @@ export function guiResilientCommand(base, opts) {
         `else mkdir -p "$(dirname ${logFile})" && ` +
         `echo "$(date '+%Y-%m-%d %H:%M:%S') [${opts.client}] pnpm no esta en el PATH del cliente; auto-update omitido" >> ${logFile}; fi`);
 }
+const CURSOR_HOOK_EVENTS = ["workspaceOpen", "sessionStart"];
 function installCursor(command) {
     const path = getCursorHooksPath();
     const cfg = readJsonSafe(path);
@@ -69,9 +70,11 @@ function installCursor(command) {
     }
     if (typeof cfg.version !== "number")
         cfg.version = 1;
-    const list = freshHookList(cfg, "workspaceOpen");
-    list.push({ command });
-    cfg.hooks.workspaceOpen = list;
+    for (const event of CURSOR_HOOK_EVENTS) {
+        const list = freshHookList(cfg, event);
+        list.push({ command, timeout: 120 });
+        cfg.hooks[event] = list;
+    }
     writeJson(path, cfg);
 }
 function installCodex(command) {
@@ -81,34 +84,74 @@ function installCodex(command) {
         logWarn(`${path} no es JSON válido; salteo el auto-update de Codex.`);
         return;
     }
+    const before = JSON.stringify(cfg);
     const list = freshHookList(cfg, "SessionStart");
     list.push({ matcher: "startup|resume", hooks: [{ type: "command", command }] });
     cfg.hooks.SessionStart = list;
+    if (JSON.stringify(cfg) === before)
+        return;
     writeJson(path, cfg);
 }
+const ANTIGRAVITY_HOOK_NAME = "alegra-data-agent-autoupdate";
+export function antigravityHookCommand(resilient, platform = process.platform) {
+    if (platform === "win32")
+        return resilient;
+    return `(${resilient}) </dev/null >/dev/null 2>&1 & echo '{}'`;
+}
 function installAntigravity(command) {
-    const path = getGeminiSettingsPath();
+    const path = getAntigravityHooksPath();
     const cfg = readJsonSafe(path);
     if (cfg === null) {
         logWarn(`${path} no es JSON válido; salteo el auto-update de Antigravity.`);
         return;
     }
-    const list = freshHookList(cfg, "SessionStart");
-    list.push({ hooks: [{ type: "command", command }] });
-    cfg.hooks.SessionStart = list;
+    cfg[ANTIGRAVITY_HOOK_NAME] = {
+        SessionStart: [{ type: "command", command, timeout: 120 }],
+    };
     writeJson(path, cfg);
+    removeJsonHook(getGeminiSettingsPath(), "SessionStart");
+}
+function removeAntigravityHook() {
+    const path = getAntigravityHooksPath();
+    const cfg = readJsonSafe(path);
+    if (cfg && ANTIGRAVITY_HOOK_NAME in cfg) {
+        delete cfg[ANTIGRAVITY_HOOK_NAME];
+        writeJson(path, cfg);
+    }
+    removeJsonHook(getGeminiSettingsPath(), "SessionStart");
+}
+function antigravityHookIsOurs() {
+    const cfg = readJsonSafe(getAntigravityHooksPath());
+    return Boolean(cfg && ANTIGRAVITY_HOOK_NAME in cfg);
 }
 function installOpenCode(command) {
     const path = getOpenCodePluginPath();
     mkdirSync(dirname(path), { recursive: true });
     const plugin = `// alegra-data-agent: auto-update al iniciar OpenCode. Generado por el instalador.
 // Borrar este archivo desactiva el auto-update. No editar a mano.
-export const AlegraDataAgentAutoUpdate = async ({ $ }) => {
-  if (!$) return {}
+import { spawn } from "node:child_process"
+
+const COMMAND = ${JSON.stringify(command)}
+
+function runUpdate() {
   try {
-    $\`${command}\`.quiet().nothrow().catch(() => {})
+    const child = spawn(COMMAND, { shell: true, detached: true, stdio: "ignore", windowsHide: true })
+    child.on("error", () => {})
+    child.unref()
   } catch (_e) {}
-  return {}
+}
+
+export default {
+  id: "alegra-data-agent-autoupdate",
+  // OpenCode 1.x
+  server: async () => {
+    runUpdate()
+    return {}
+  },
+  // OpenCode 2.x
+  setup: async () => {
+    runUpdate()
+  },
 }
 `;
     writeFileSync(path, plugin, "utf-8");
@@ -187,7 +230,10 @@ export function installAutoUpdate(target, mode = "auto") {
                 installCodex(hookCommandFor(effective));
                 break;
             case "antigravity":
-                installAntigravity(guiResilientCommand(hookCommandFor(effective), { client: "antigravity", silence: true }));
+                installAntigravity(antigravityHookCommand(guiResilientCommand(hookCommandFor(effective), {
+                    client: "antigravity",
+                    silence: true,
+                })));
                 break;
             case "opencode":
                 installOpenCode(hookCommandFor(effective));
@@ -208,13 +254,14 @@ export function removeAutoUpdate(target) {
                 runHookUninstall({ quiet: true });
                 break;
             case "cursor":
-                removeJsonHook(getCursorHooksPath(), "workspaceOpen");
+                for (const event of CURSOR_HOOK_EVENTS)
+                    removeJsonHook(getCursorHooksPath(), event);
                 break;
             case "codex":
                 removeJsonHook(getCodexHooksPath(), "SessionStart");
                 break;
             case "antigravity":
-                removeJsonHook(getGeminiSettingsPath(), "SessionStart");
+                removeAntigravityHook();
                 break;
             case "opencode": {
                 const p = getOpenCodePluginPath();
@@ -243,11 +290,11 @@ export function hasAutoUpdate(target) {
         case "claude-code":
             return jsonHookHasOurs(getClaudeSettingsPath(), "SessionStart");
         case "cursor":
-            return jsonHookHasOurs(getCursorHooksPath(), "workspaceOpen");
+            return CURSOR_HOOK_EVENTS.some((event) => jsonHookHasOurs(getCursorHooksPath(), event));
         case "codex":
             return jsonHookHasOurs(getCodexHooksPath(), "SessionStart");
         case "antigravity":
-            return jsonHookHasOurs(getGeminiSettingsPath(), "SessionStart");
+            return antigravityHookIsOurs() || jsonHookHasOurs(getGeminiSettingsPath(), "SessionStart");
         case "opencode":
             return existsSync(getOpenCodePluginPath());
         case "hermes": {

package/dist/codex-trust.js

@@ -0,0 +1,128 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { createInterface } from "node:readline";
+import { COMMAND_NAME, getConfigDir } from "./lib.js";
+function consentPath() {
+    return join(getConfigDir(), "codex-hook-trust.json");
+}
+export function hasCodexTrustConsent() {
+    return existsSync(consentPath());
+}
+export function saveCodexTrustConsent() {
+    const path = consentPath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify({ consented: true, at: new Date().toISOString() })}\n`);
+}
+function codexBin() {
+    const bin = process.env.CODEX_BIN;
+    return bin && bin.length > 0 ? bin : "codex";
+}
+async function withAppServer(fn, timeoutMs) {
+    const child = spawn(codexBin(), ["app-server"], {
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true,
+        shell: process.platform === "win32",
+    });
+    const pending = new Map();
+    let nextId = 0;
+    const fail = (err) => {
+        for (const p of pending.values())
+            p.reject(err);
+        pending.clear();
+    };
+    child.on("error", (err) => fail(err));
+    child.on("exit", () => fail(new Error("codex app-server terminó antes de responder")));
+    child.stdin.on("error", (err) => fail(err));
+    const rl = createInterface({ input: child.stdout });
+    rl.on("line", (line) => {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (typeof msg.id !== "number")
+            return;
+        const p = pending.get(msg.id);
+        if (!p)
+            return;
+        pending.delete(msg.id);
+        if (msg.error)
+            p.reject(new Error(msg.error.message ?? "error de codex app-server"));
+        else
+            p.resolve(msg.result);
+    });
+    const req = (method, params) => new Promise((resolve, reject) => {
+        const id = ++nextId;
+        pending.set(id, { resolve, reject });
+        child.stdin.write(`${JSON.stringify({ id, method, params })}\n`);
+    });
+    const timer = setTimeout(() => fail(new Error("codex app-server no respondió a tiempo")), timeoutMs);
+    try {
+        await req("initialize", {
+            clientInfo: { name: COMMAND_NAME, version: "1" },
+            capabilities: { experimentalApi: true },
+        });
+        child.stdin.write(`${JSON.stringify({ method: "initialized" })}\n`);
+        return await fn(req);
+    }
+    finally {
+        clearTimeout(timer);
+        rl.close();
+        child.stdout.destroy();
+        child.kill();
+        const force = setTimeout(() => child.kill("SIGKILL"), 2_000);
+        force.unref();
+        child.unref();
+    }
+}
+function isOurCommand(command) {
+    return new RegExp(`${COMMAND_NAME}@\\S+ update\\b`).test(command);
+}
+async function ourHooks(req) {
+    const res = (await req("hooks/list", { cwds: [homedir()] }));
+    return (res.data ?? [])
+        .flatMap((d) => d.hooks ?? [])
+        .filter((h) => h.source === "user" && isOurCommand(h.command ?? ""));
+}
+export async function approveCodexHook(timeoutMs = 20_000) {
+    try {
+        return await withAppServer(async (req) => {
+            const needs = (await ourHooks(req)).filter((h) => h.trustStatus !== "trusted" && h.trustStatus !== "managed" && h.currentHash);
+            if (needs.length > 0) {
+                await req("config/batchWrite", {
+                    edits: [
+                        {
+                            keyPath: "hooks.state",
+                            value: Object.fromEntries(needs.map((h) => [h.key, { trusted_hash: h.currentHash }])),
+                            mergeStrategy: "upsert",
+                        },
+                    ],
+                    reloadUserConfig: true,
+                });
+            }
+            const after = await ourHooks(req);
+            const pending = after.filter((h) => h.trustStatus !== "trusted" && h.trustStatus !== "managed").length;
+            return { ok: pending === 0 && after.length > 0, approved: needs.length, pending };
+        }, timeoutMs);
+    }
+    catch (err) {
+        return {
+            ok: false,
+            approved: 0,
+            pending: 0,
+            detail: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export async function codexHookTrustStatus(timeoutMs = 20_000) {
+    try {
+        return await withAppServer(async (req) => (await ourHooks(req)).map((h) => h.trustStatus ?? "unknown"), timeoutMs);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/commands/install.js

@@ -1,9 +1,11 @@
 import { AuthRequiredError } from "../api.js";
 import { hasValidAuth, readAuth } from "../auth.js";
 import { installAutoUpdate } from "../autoupdate.js";
+import { approveCodexHook, hasCodexTrustConsent, saveCodexTrustConsent } from "../codex-trust.js";
 import { bold, cyan, dim, gray, green, log, logError, red, yellow } from "../colors.js";
 import { installAll } from "../installer.js";
 import { COMMAND_NAME, formatBytes, getPackageVersion, getTargetSkillsDir } from "../lib.js";
+import { confirm } from "../ui.js";
 import { runLogin } from "./login.js";
 const BANNER_WIDTH = 58;
 const SHORT_DESCRIPTIONS = {
@@ -147,6 +149,37 @@ function printNextSteps(noHook) {
 function isClaudeCode() {
     return process.env.CLAUDECODE === "1" || process.env.CLAUDE_CODE === "1";
 }
+async function setUpCodex(manifest, results, opts) {
+    if (!opts.noHook) {
+        let consent = hasCodexTrustConsent();
+        if (!consent && !opts.yes && process.stdin.isTTY && process.stdout.isTTY) {
+            log(`  ${bold("Codex")} pide aprobar cada hook antes de ejecutarlo. El nuestro solo corre ${cyan(`${COMMAND_NAME} update`)} al abrir una sesión.`);
+            consent = await confirm("  ¿Lo apruebo para que el auto-update funcione en Codex?", true);
+            if (consent)
+                saveCodexTrustConsent();
+        }
+        const res = consent ? await approveCodexHook() : null;
+        if (res?.ok) {
+            log(`  ${green("✓")} Codex: auto-update aprobado.`);
+        }
+        else {
+            if (res?.detail)
+                log(`  ${gray(`(no pude aprobarlo solo: ${res.detail})`)}`);
+            log(`  ${bold(yellow("Codex:"))} al abrirlo elegí ${bold("«Trust all and continue»")} ${gray("(o /hooks)")} para activar el auto-update.`);
+        }
+    }
+    const installedMcps = new Set(results.filter((r) => r.kind === "mcp" && r.status !== "failed").map((r) => r.name));
+    const remotes = Object.entries(manifest.mcps ?? {})
+        .filter(([name, m]) => m.url && installedMcps.has(name))
+        .map(([name]) => name)
+        .sort();
+    if (remotes.length > 0) {
+        log(`  ${gray("Conectá cada MCP de Codex una vez:")}`);
+        for (const name of remotes)
+            log(`    ${cyan(`codex mcp login ${name}`)}`);
+    }
+    log("");
+}
 export async function runInstall(opts = {}) {
     const compact = isClaudeCode();
     if (!compact)
@@ -243,6 +276,8 @@ export async function runInstall(opts = {}) {
         if (!compact)
             log("");
     }
+    if (result.targets.includes("codex"))
+        await setUpCodex(result.manifest, result.results, opts);
     if (hasFails)
         return 1;
     if (!compact) {

package/dist/commands/status.js

@@ -3,6 +3,8 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { AuthRequiredError, fetchManifest } from "../api.js";
 import { readAuth } from "../auth.js";
+import { hasAutoUpdate } from "../autoupdate.js";
+import { codexHookTrustStatus } from "../codex-trust.js";
 import { bold, cyan, dim, gray, green, log, logError, logWarn, yellow } from "../colors.js";
 import { detectDrift, findMisplacedMcps, inspectMcpInTarget } from "../installer.js";
 import { COMMAND_NAME, GATEWAY_URL, getAutoUpdateLogPath, getClaudeJsonPath, getClaudeSkillsDir, getLockFilePath, getMcpScopeDir, getMcpScopeWarning, getPackageVersion, getTargetSkillsDir, readLockFile, } from "../lib.js";
@@ -27,6 +29,13 @@ function reportAutoUpdateLog() {
     catch {
     }
 }
+async function reportCodexHookTrust() {
+    const states = await codexHookTrustStatus();
+    if (!states || states.every((s) => s === "trusted" || s === "managed"))
+        return;
+    logWarn(`El auto-update de Codex está sin aprobar (${states.join(", ")}): Codex no lo ejecuta. Abrí Codex y elegí «Trust all and continue» (o /hooks), o corré ${bold(`${COMMAND_NAME} install --target=codex`)} y aceptá la aprobación.`);
+    log("");
+}
 function reportSkillBackups() {
     const backupsLog = join(dirname(getAutoUpdateLogPath()), "backups", "backups.log");
     if (!existsSync(backupsLog))
@@ -309,6 +318,8 @@ export async function runStatus() {
     log("");
     reportAutoUpdateLog();
     reportSkillBackups();
+    if (installedTargets.includes("codex") && hasAutoUpdate("codex"))
+        await reportCodexHookTrust();
     if (!auth) {
         logWarn(`Inicia sesión con: ${bold(`${COMMAND_NAME} login`)}`);
         log("");

package/dist/commands/update.js

@@ -2,7 +2,8 @@ import { appendFileSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "
 import { dirname } from "node:path";
 import { AuthRequiredError, ensureFreshAuth, fetchManifest } from "../api.js";
 import { hasValidAuth } from "../auth.js";
-import { refreshAutoUpdate } from "../autoupdate.js";
+import { hasAutoUpdate, refreshAutoUpdate } from "../autoupdate.js";
+import { approveCodexHook, hasCodexTrustConsent } from "../codex-trust.js";
 import { cyan, dim, gray, green, log, logError, yellow } from "../colors.js";
 import { detectDrift, installAll, summarize } from "../installer.js";
 import { COMMAND_NAME, getAutoUpdateLogPath, getLastCheckPath, getPackageVersion, } from "../lib.js";
@@ -123,6 +124,11 @@ export async function runUpdate(opts = {}) {
         }
     }
 }
+async function reapproveCodexHook() {
+    if (!hasCodexTrustConsent() || !hasAutoUpdate("codex"))
+        return;
+    await approveCodexHook();
+}
 async function runUpdateOnce(opts) {
     const manifest = await fetchManifest();
     if (!manifest) {
@@ -142,6 +148,7 @@ async function runUpdateOnce(opts) {
             markChecked();
         if (!opts.dryRun) {
             refreshAutoUpdate();
+            await reapproveCodexHook();
             clearAutoUpdateLog();
         }
         return 0;
@@ -173,6 +180,7 @@ async function runUpdateOnce(opts) {
     }
     summarize(result.results);
     refreshAutoUpdate();
+    await reapproveCodexHook();
     const failed = result.results.some((r) => r.status === "failed");
     if (!failed) {
         clearAutoUpdateLog();

package/dist/installer.js

@@ -5,7 +5,7 @@ import { basename, dirname, join, resolve, sep } from "node:path";
 import { AuthRequiredError, fetchManifest, fetchSkillFile, recordManifestFloor } from "./api.js";
 import { dim, gray, green, logError, logWarn, red, yellow } from "./colors.js";
 import { ensureLazyProxy, lazyMcpDir, lazyProxyPath, lazyToolsPath, stdioLaunch, } from "./lazy-mcp.js";
-import { computeBundleHash, ensureDir, getAntigravityGeminiLegacyMcpConfigPath, getAntigravityGeminiLegacySkillsDir, getAntigravityLegacyMcpConfigPath, getAntigravityLegacySkillsDir, getClaudeSettingsPath, getConfigDir, getCursorLegacyRulesDir, getHermesBin, getLockFilePath, getMcpScopeDir, getMcpScopeWarning, getOpenCodeLegacyPromptsDir, getPackageVersion, getUserScopeMcpConfigPath, isMcpScopeEnvOverride, readLockFile, sha256File, walkSkillFiles, writeLockFile, } from "./lib.js";
+import { computeBundleHash, ensureDir, getAntigravityGeminiLegacyMcpConfigPath, getAntigravityGeminiLegacySkillsDir, getAntigravityGeminiSkillsDir, getAntigravityLegacyMcpConfigPath, getAntigravityLegacySkillsDir, getClaudeSettingsPath, getConfigDir, getCursorLegacyRulesDir, getHermesBin, getLockFilePath, getMcpScopeDir, getMcpScopeWarning, getOpenCodeLegacyPromptsDir, getPackageVersion, getUserScopeMcpConfigPath, isMcpScopeEnvOverride, readLockFile, sha256File, walkSkillFiles, writeLockFile, } from "./lib.js";
 import { renderHermesMcpOps, renderMcpForTarget } from "./render.js";
 import { TARGETS, detectInstalledTargets } from "./targets.js";
 const SKILL_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
@@ -686,15 +686,65 @@ function tomlMarkers(name) {
         end: `# <<< alegra-data-agent:${name} <<<`,
     };
 }
+function splitTomlBlock(inner, name) {
+    const lines = inner.split("\n");
+    const isOurs = (h) => h === `[mcp_servers.${name}]` || h === `[mcp_servers.${name}.env]`;
+    const at = lines.findIndex((l) => {
+        const t = l.trim();
+        return t.startsWith("[") && !isOurs(tomlHeader(t));
+    });
+    if (at === -1)
+        return { ours: inner, foreign: "" };
+    return {
+        ours: lines.slice(0, at).join("\n").replace(/\n+$/, ""),
+        foreign: lines.slice(at).join("\n").replace(/\n+$/, ""),
+    };
+}
+function tomlHeader(line) {
+    return line.replace(/\]\s*#.*$/, "]");
+}
+function dropServerSubtables(content, name) {
+    const prefix = `[mcp_servers.${name}.`;
+    const out = [];
+    let skipping = false;
+    let dropped = false;
+    for (const line of content.split("\n")) {
+        const t = line.trim();
+        const isMarker = t.startsWith("# >>> alegra-data-agent:") || t.startsWith("# <<< alegra-data-agent:");
+        if (t.startsWith("[") || isMarker)
+            skipping = !isMarker && tomlHeader(t).startsWith(prefix);
+        if (skipping)
+            dropped = true;
+        else
+            out.push(line);
+    }
+    return dropped ? out.join("\n").replace(/\n{3,}/g, "\n\n") : content;
+}
+function findTomlBlock(content, name) {
+    const { begin, end } = tomlMarkers(name);
+    const bi = content.indexOf(begin);
+    if (bi === -1)
+        return null;
+    const ei = content.indexOf(end, bi);
+    if (ei === -1)
+        return null;
+    return {
+        start: bi,
+        stop: ei + end.length,
+        inner: content
+            .slice(bi + begin.length, ei)
+            .replace(/^\n/, "")
+            .replace(/\n$/, ""),
+    };
+}
 export function upsertTomlBlock(content, name, block) {
     const { begin, end } = tomlMarkers(name);
     const fenced = `${begin}\n${block}\n${end}`;
-    const bi = content.indexOf(begin);
-    if (bi !== -1) {
-        const ei = content.indexOf(end, bi);
-        if (ei !== -1) {
-            return content.slice(0, bi) + fenced + content.slice(ei + end.length);
-        }
+    const found = findTomlBlock(content, name);
+    if (found) {
+        const { foreign } = splitTomlBlock(found.inner, name);
+        const moved = foreign ? `\n\n${foreign}` : "";
+        return content.slice(0, found.start) + fenced + moved + content.slice(found.stop);
     }
     if (content.length === 0)
         return `${fenced}\n`;
@@ -702,33 +752,24 @@ export function upsertTomlBlock(content, name, block) {
     return `${content}${sep}${fenced}\n`;
 }
 export function extractTomlBlock(content, name) {
-    const { begin, end } = tomlMarkers(name);
-    const bi = content.indexOf(begin);
-    if (bi === -1)
-        return null;
-    const ei = content.indexOf(end, bi);
-    if (ei === -1)
-        return null;
-    return content
-        .slice(bi + begin.length, ei)
-        .replace(/^\n/, "")
-        .replace(/\n$/, "");
+    const found = findTomlBlock(content, name);
+    return found ? splitTomlBlock(found.inner, name).ours : null;
 }
 export function removeTomlBlock(content, name) {
-    const { begin, end } = tomlMarkers(name);
-    const bi = content.indexOf(begin);
-    if (bi === -1)
+    const found = findTomlBlock(content, name);
+    if (!found)
         return content;
-    const ei = content.indexOf(end, bi);
-    if (ei === -1)
-        return content;
-    let start = bi;
-    let stop = ei + end.length;
+    const { foreign } = splitTomlBlock(found.inner, name);
+    if (foreign) {
+        return dropServerSubtables(content.slice(0, found.start) + foreign + content.slice(found.stop), name);
+    }
+    let start = found.start;
+    let stop = found.stop;
     if (content[stop] === "\n")
         stop++;
     if (start > 0 && content[start - 1] === "\n")
         start--;
-    return content.slice(0, start) + content.slice(stop);
+    return dropServerSubtables(content.slice(0, start) + content.slice(stop), name);
 }
 function registerMcpInTomlBlock(mcp, spec) {
     const existing = existsSync(spec.mcpConfigPath) ? readFileSync(spec.mcpConfigPath, "utf-8") : "";
@@ -891,6 +932,7 @@ function cleanupLegacySkillArtifacts(spec) {
             const legacySkillDirs = [
                 getAntigravityLegacySkillsDir(),
                 getAntigravityGeminiLegacySkillsDir(),
+                getAntigravityGeminiSkillsDir(),
             ];
             for (const base of legacySkillDirs) {
                 for (const name of [...Object.keys(lock.skills), ...LEGACY_RENAMED_SKILLS]) {
@@ -1309,10 +1351,6 @@ export function uninstallMcp(name, opts = {}) {
 export function uninstallAll(opts = {}) {
     const lock = readLockFile();
     const results = [];
-    for (const name of Object.keys(lock.skills))
-        results.push(uninstallSkill(name, opts));
-    for (const name of Object.keys(lock.mcps ?? {}))
-        results.push(uninstallMcp(name, opts));
     if (!opts.dryRun) {
         for (const spec of Object.values(TARGETS)) {
             try {
@@ -1321,6 +1359,12 @@ export function uninstallAll(opts = {}) {
             catch {
             }
         }
+    }
+    for (const name of Object.keys(lock.skills))
+        results.push(uninstallSkill(name, opts));
+    for (const name of Object.keys(lock.mcps ?? {}))
+        results.push(uninstallMcp(name, opts));
+    if (!opts.dryRun) {
         if (Object.keys(readLockFile().mcps ?? {}).length === 0) {
             try {
                 rmSync(lazyMcpDir(), { recursive: true, force: true });

package/dist/lib.js

@@ -174,6 +174,9 @@ export function getOpenCodeConfigPath() {
 export function getAntigravitySkillsDir() {
     return join(homedir(), ".gemini", "antigravity-cli", "skills");
 }
+export function getAntigravityConfigSkillsDir() {
+    return join(homedir(), ".gemini", "config", "skills");
+}
 export function getAntigravityGeminiSkillsDir() {
     return join(homedir(), ".gemini", "skills");
 }
@@ -183,6 +186,9 @@ export function getAntigravityMcpConfigPath() {
 export function getGeminiSettingsPath() {
     return join(homedir(), ".gemini", "settings.json");
 }
+export function getAntigravityHooksPath() {
+    return join(homedir(), ".gemini", "config", "hooks.json");
+}
 export function getAntigravityLegacySkillsDir() {
     return join(homedir(), ".antigravity", "skills");
 }

package/dist/main.js

@@ -43,6 +43,7 @@ async function main() {
                 only: args.only.length > 0 ? args.only : undefined,
                 targets: args.targets.length > 0 ? args.targets : undefined,
                 noHook: args.flags.noHook,
+                yes: args.flags.yes,
                 hookMode: "auto",
             });
             break;

package/dist/targets.js

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { getAntigravityGeminiSkillsDir, getAntigravityMcpConfigPath, getAntigravitySkillsDir, getClaudeMcpConfigPath, getClaudeSkillsDir, getCodexConfigPath, getCodexSkillsDir, getCursorMcpPath, getCursorSkillsDir, getHermesConfigPath, getHermesHome, getHermesSkillsDir, getOpenCodeConfigPath, getOpenCodeSkillsDir, } from "./lib.js";
+import { getAntigravityConfigSkillsDir, getAntigravityMcpConfigPath, getAntigravitySkillsDir, getClaudeMcpConfigPath, getClaudeSkillsDir, getCodexConfigPath, getCodexSkillsDir, getCursorMcpPath, getCursorSkillsDir, getHermesConfigPath, getHermesHome, getHermesSkillsDir, getOpenCodeConfigPath, getOpenCodeSkillsDir, } from "./lib.js";
 export const TARGETS = {
     "claude-code": {
         id: "claude-code",
@@ -37,7 +37,7 @@ export const TARGETS = {
         id: "antigravity",
         label: "Antigravity",
         skillsDir: getAntigravitySkillsDir(),
-        mirrorSkillsDirs: [getAntigravityGeminiSkillsDir()],
+        mirrorSkillsDirs: [getAntigravityConfigSkillsDir()],
         skillFormat: "folder",
         mcpConfigPath: getAntigravityMcpConfigPath(),
         mcpRootKey: "mcpServers",
@@ -76,7 +76,11 @@ export function detectInstalledTargets() {
         "claude-code": [join(home, ".claude")],
         cursor: [join(home, ".cursor")],
         opencode: [join(xdgConfig, "opencode")],
-        antigravity: [join(home, ".gemini", "antigravity-cli"), join(home, ".gemini", "antigravity")],
+        antigravity: [
+            join(home, ".gemini", "antigravity-cli"),
+            join(home, ".gemini", "antigravity"),
+            join(home, ".gemini", "antigravity-ide"),
+        ],
         codex: [codexHome],
         hermes: [getHermesHome()],
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alegra-data-agent",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "private": false,
   "description": "Agente de Data interno de Alegra. Instala skills + MCPs en tu cliente de IA con un comando.",
   "license": "UNLICENSED",