ozali 0.4.0 → 0.5.0

package/cli/lib/detect.mjs

@@ -1,7 +1,7 @@
 // detect.mjs — detección read-only del entorno del proyecto destino.
 import fs from "node:fs";
 import path from "node:path";
-import { exists, which, gitInfo, nodeMajor, HOME } from "./util.mjs";
+import { exists, which, gitInfo, nodeMajor, HOME, readJSON } from "./util.mjs";
 
 /** Variante de fuente de verdad: {found, doc, dir, variant} */
 export function detectSourceOfTruth(cwd) {
@@ -47,6 +47,13 @@ export function detectEngram() {
   return { available: !!bin, bin: bin || null };
 }
 
+/** Metadatos compartibles de Engram Cloud del proyecto (sin secretos). */
+export function detectCloud(cwd) {
+  const metaPath = path.join(cwd, ".ozali", "cloud.json");
+  const meta = readJSON(metaPath);
+  return { present: !!meta, path: metaPath, meta: meta || null };
+}
+
 /**
  * Capacidades de testing (heurística read-only). Devuelve runner(s), comando y
  * un conteo aproximado de archivos de prueba. NO resuelve strict_tdd (eso lo
@@ -98,6 +105,7 @@ export function detectAll(cwd) {
     agents: detectAgents(cwd),
     skill: detectInstalledSkill(cwd),
     engram: detectEngram(),
+    cloud: detectCloud(cwd),
     testing: detectTesting(cwd),
   };
 }

package/cli/lib/util.mjs

@@ -21,6 +21,21 @@ export function pkgVersion() {
   }
 }
 
+/**
+ * Nombre del asset de release de Engram para un SO/arch/versión dados.
+ * Convención oficial: engram_<version>_<os>_<arch>.<ext> (.tar.gz en linux/darwin, .zip en windows).
+ * Devuelve null si el SO o la arquitectura no están soportados. Función pura (sin red).
+ */
+export function engramAssetName(platform, arch, version) {
+  const osMap = { darwin: "darwin", linux: "linux", win32: "windows" };
+  const archMap = { x64: "amd64", arm64: "arm64" };
+  const os = osMap[platform];
+  const a = archMap[arch];
+  if (!os || !a) return null;
+  const ext = platform === "win32" ? "zip" : "tar.gz";
+  return `engram_${version}_${os}_${a}.${ext}`;
+}
+
 // ---- colores (sin deps; respeta NO_COLOR y no-TTY) --------------------------
 const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
 const wrap = (code) => (s) => (useColor ? `\x1b[${code}m${s}\x1b[0m` : String(s));
@@ -70,6 +85,14 @@ export function writeJSON(p, obj) {
   fs.writeFileSync(p, JSON.stringify(obj, null, 2) + "\n");
 }
 
+/** Abre una URL en el navegador por defecto. Devuelve true si pudo lanzar el comando. */
+export function openURL(url) {
+  if (!url) return false;
+  if (process.platform === "darwin") return spawnCmd("open", [url]) === 0;
+  if (process.platform === "win32") return spawnCmd("cmd", ["/c", "start", "", url]) === 0;
+  return spawnCmd("xdg-open", [url]) === 0;
+}
+
 // ---- ejecución de comandos (read-only / git) --------------------------------
 /** Ejecuta un binario y devuelve stdout recortado, o null si falla. */
 export function tryExec(cmd, args = [], opts = {}) {

package/cli/test/smoke.test.mjs

@@ -6,6 +6,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { engramAssetName } from "../lib/util.mjs";
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const BIN = path.resolve(HERE, "..", "bin", "ozali.mjs");
@@ -118,6 +119,20 @@ test("init opencode crea jarvis (AGENTS.md + agente + plugin)", () => {
   }
 });
 
+test("update agrega ozali-jarvis en un repo que no lo tenía", () => {
+  const dir = tmpProject();
+  try {
+    run(["init", "--yes", "--no-engram", "--no-trust", "--no-jarvis", "--agent", "claude-code", "--scope", "project", "--knowledge-repo", path.join(dir, ".k")], dir);
+    assert.ok(!fs.existsSync(path.join(dir, ".claude", "agents", "ozali-jarvis.md")), "precondición: sin jarvis");
+    run(["update"], dir);
+    assert.ok(fs.existsSync(path.join(dir, ".claude", "agents", "ozali-jarvis.md")), "update crea subagente jarvis");
+    assert.match(fs.readFileSync(path.join(dir, "CLAUDE.md"), "utf8"), /ozali-jarvis:start/, "update crea bloque jarvis");
+    assert.ok(fs.existsSync(path.join(dir, ".engram", "config.json")), "update fija .engram/config.json");
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test("init --dry-run no escribe nada", () => {
   const dir = tmpProject();
   try {
@@ -136,3 +151,52 @@ test("el paquete NO tiene dependencias ni lifecycle scripts (seguridad)", () =>
     assert.ok(!(pkg.scripts && pkg.scripts[s]), `sin script de ciclo de vida: ${s}`);
   }
 });
+
+test("--help menciona el comando cloud", () => {
+  const { stdout } = run(["--help"]);
+  assert.match(stdout, /cloud/, "help debe mencionar cloud");
+  assert.match(stdout, /--dashboard/, "help debe mencionar --dashboard");
+  assert.match(stdout, /--conflicts/, "help debe mencionar --conflicts");
+});
+
+test("cloud status imprime cabecera y no rompe", () => {
+  const dir = tmpProject();
+  try {
+    const { code, stdout } = run(["cloud", "status"], dir, true);
+    assert.match(stdout, /ozali cloud status/, "debe imprimir cabecera de cloud status");
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("cloud con subcomando desconocido sale con código 1", () => {
+  const dir = tmpProject();
+  try {
+    const { code, stdout } = run(["cloud", "frobnicate"], dir, true);
+    assert.equal(code, 1, "debe salir con código 1");
+    assert.match(stdout, /Subcomando desconocido/, "debe indicar subcomando desconocido");
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test(".gitignore del repo destino permite .ozali/cloud.json (commiteable)", () => {
+  const dir = tmpProject();
+  try {
+    run(["init", "--yes", "--no-engram", "--no-trust", "--no-jarvis", "--agent", "claude-code", "--scope", "project", "--knowledge-repo", path.join(dir, ".k")], dir);
+    const gi = fs.readFileSync(path.join(dir, ".gitignore"), "utf8");
+    assert.match(gi, /\.ozali\/\*/, "debe ignorar .ozali/*");
+    assert.match(gi, /!\.ozali\/cloud\.json/, "debe permitir .ozali/cloud.json");
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("engramAssetName respeta la convención de release por SO/arch", () => {
+  assert.equal(engramAssetName("linux", "x64", "1.17.0"), "engram_1.17.0_linux_amd64.tar.gz");
+  assert.equal(engramAssetName("linux", "arm64", "1.17.0"), "engram_1.17.0_linux_arm64.tar.gz");
+  assert.equal(engramAssetName("darwin", "arm64", "1.17.0"), "engram_1.17.0_darwin_arm64.tar.gz");
+  assert.equal(engramAssetName("win32", "x64", "1.17.0"), "engram_1.17.0_windows_amd64.zip");
+  assert.equal(engramAssetName("linux", "ia32", "1.17.0"), null, "arch no soportada → null");
+  assert.equal(engramAssetName("freebsd", "x64", "1.17.0"), null, "SO no soportado → null");
+});

package/docs/deploy-cloud-gcloud.md

@@ -0,0 +1,149 @@
+# Desplegar Engram Cloud en Google Cloud
+
+← [README](../README.md)
+
+Dos opciones para desplegar el **servidor de Engram Cloud** en Google Cloud Platform, según el
+perfil de carga y mantenimiento que prefieras.
+
+## Opción A: Cloud Run + Cloud SQL (serverless, managed)
+
+La opción más **hands-off**: Postgres gestionado por Google, Engram en Cloud Run (serverless,
+escala a cero). Ideal si no quieres mantener VMs.
+
+### Componentes
+
+| Servicio | Qué hace | Coste aprox. |
+|---|---|---|
+| Cloud SQL (Postgres 16) | Base de datos gestionada | ~$15-30/mes (db-f1-micro) |
+| Cloud Run | Ejecuta el servidor Engram | $0 por inactivo + por uso |
+| Secret Manager | Guarda el token y DB URL | gratis hasta 6 secretos |
+| Artifact Registry | Imagen Docker de Engram | gratis hasta 0.5 GB |
+
+### Pasos
+
+1. **Crear instancia de Cloud SQL:**
+   ```bash
+   gcloud sql instances create engram-db \
+     --database-version=POSTGRES_16 \
+     --tier=db-f1-micro \
+     --region=us-central1 \
+     --root-password=$(openssl rand -hex 32)
+   ```
+
+2. **Crear base de datos y usuario:**
+   ```bash
+   gcloud sql databases create engram --instance=engram-db
+   gcloud sql users create engram --instance=engram-db --password=$(openssl rand -hex 16)
+   ```
+
+3. **Subir la imagen a Artifact Registry:**
+   ```bash
+   gcloud artifacts repositories create engram --repository-format=docker --location=us-central1
+   docker pull ghcr.io/gentleman-programming/engram:latest
+   docker tag ghcr.io/gentleman-programming/engram:latest \
+     us-central1-docker.pkg.dev/$PROJECT_ID/engram/cloud:latest
+   docker push us-central1-docker.pkg.dev/$PROJECT_ID/engram/cloud:latest
+   ```
+
+4. **Crear secretos en Secret Manager:**
+   ```bash
+   echo -n "postgres://engram:...@/engram?cloudsql=/cloudsql/$PROJECT_ID:us-central1:engram-db" \
+     | gcloud secrets create ENGRAM_CLOUD_DATABASE_URL --data-file=-
+   echo -n "$(openssl rand -hex 32)" \
+     | gcloud secrets create ENGRAM_CLOUD_TOKEN --data-file=-
+   ```
+
+5. **Desplegar en Cloud Run:**
+   ```bash
+   gcloud run deploy engram-cloud \
+     --image=us-central1-docker.pkg.dev/$PROJECT_ID/engram/cloud:latest \
+     --region=us-central1 \
+     --port=18080 \
+     --no-allow-unauthenticated \
+     --add-cloudsql-instances=$PROJECT_ID:us-central1:engram-db \
+     --set-secrets="ENGRAM_CLOUD_DATABASE_URL=ENGRAM_CLOUD_DATABASE_URL:latest" \
+     --set-secrets="ENGRAM_CLOUD_TOKEN=ENGRAM_CLOUD_TOKEN:latest" \
+     --set-env-vars="ENGRAM_CLOUD_DASHBOARD=true"
+   ```
+
+6. **IAM — quién puede acceder:**
+   - Los devs no acceden a Cloud Run directamente; lo hace el CLI de Engram.
+   - Si Cloud Run está `--no-allow-unauthenticated`, configura un endpoint público con
+     Cloud Armor (IP allowlist) o un Identity-Aware Proxy (IAP).
+
+7. **VPC connector para Cloud SQL:**
+   Si Cloud SQL tiene IP privada (recomendado), crea un Serverless VPC connector:
+   ```bash
+   gcloud compute networks vpc-access connectors create engram-conn \
+     --network=default --region=us-central1 --range=10.8.0.0/28
+   ```
+   Y en el deploy de Cloud Run añade `--vpc-connector=engram-conn`.
+
+### Verificar
+   ```bash
+   gcloud run services describe engram-cloud --region=us-central1 --format='value(status.url)'
+   curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
+     https://engram-cloud-xxxx-uc.a.run.app/health
+   ```
+
+## Opción B: GCE VM + docker-compose (similar al VPS)
+
+Si prefieres control total (equivalente al [despliegue VPS](deploy-cloud-vps.md) pero en GCE):
+
+1. **Crear VM:**
+   ```bash
+   gcloud compute instances create engram-cloud \
+     --machine-type=e2-small \
+     --zone=us-central1-a \
+     --image-family=ubuntu-2204-lts \
+     --image-project=ubuntu-os-cloud \
+     --boot-disk-size=30GB \
+     --tags=engram-cloud
+   ```
+
+2. **Firewall (solo HTTP/HTTPS + SSH):**
+   ```bash
+   gcloud compute firewall-rules create engram-allow-http \
+     --allow=tcp:80,tcp:443 --target-tags=engram-cloud
+   ```
+
+3. **SSH e instalar Docker:**
+   ```bash
+   gcloud compute ssh engram-cloud --zone=us-central1-a
+   # dentro de la VM:
+   sudo apt update && sudo apt install -y docker.io docker-compose-v2 nginx certbot python3-certbot-nginx
+   sudo usermod -aG docker $USER
+   ```
+
+4. **Desplegar igual que el VPS:**
+   - Copia `docker-compose.yml` y `.env` (ver [deploy-cloud-vps.md](deploy-cloud-vps.md))
+   - Configura nginx + Let's Encrypt
+   - Configura systemd para auto-start
+
+### Ventajas de GCE vs VPS genérico
+- **Secret Manager:** los secretos viven en GCP, no en un `.env` en disco
+- **Snapshots programados** del disco para backups
+- **Cloud Logging** centralizado
+- **MIG (Managed Instance Group)** si necesitas HA
+
+## Comparación rápida
+
+| | Opción A (Cloud Run) | Opción B (GCE VM) |
+|---|---|---|
+| Mantenimiento | Mínimo (serverless) | Medio (gestionas la VM) |
+| Coste en reposo | ~$0 (Cloud Run escala a 0) | ~$13/mes (e2-small) |
+| Cold start | Sí (1-3s tras inactividad) | No |
+| Control | Limitado | Total |
+| Backups | Automáticos (Cloud SQL) | Manuales (snapshots) |
+| Recomendado para | Equipos pequeños/medianos | Equipos con carga constante o compliance estricto |
+
+## Conectar los devs
+
+Independiente de la opción elegida, cada dev conecta con:
+
+```bash
+ozali init
+# → "¿Habilitar Engram Cloud?" → sí
+# → URL: https://engram-cloud-xxxx.a.run.app  (A) o https://engram.mi-empresa.com (B)
+# → Token: <ENGRAM_CLOUD_TOKEN>
+```

package/docs/deploy-cloud-vps.md

@@ -0,0 +1,174 @@
+# Desplegar Engram Cloud en un VPS
+
+← [README](../README.md)
+
+Guía para desplegar el **servidor de Engram Cloud** en un VPS genérico (DigitalOcean, Hetzner,
+Linode, AWS EC2, etc.). El servidor centraliza la memoria de equipo: los devs replican a él
+con `ozali sync --cloud` (o automáticamente con autosync).
+
+## Requisitos
+
+- VPS con Linux (Ubuntu 22.04+ recomendado) y acceso SSH
+- Docker Engine + Docker Compose v2
+- Un dominio (o subdominio) apuntando al VPS
+- Puertos: 80/443 (nginx) abiertos al público; 18080 solo localhost
+
+## 1. docker-compose.yml
+
+```yaml
+services:
+  postgres:
+    image: postgres:16-alpine
+    restart: unless-stopped
+    env_file: .env
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U engram"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+
+  cloud:
+    image: ghcr.io/gentleman-programming/engram:latest
+    restart: unless-stopped
+    depends_on:
+      postgres:
+        condition: service_healthy
+    env_file: .env
+    ports:
+      - "127.0.0.1:18080:18080"  # solo localhost; nginx expone al exterior
+
+volumes:
+  pgdata:
+```
+
+> El `cloud` escucha en `127.0.0.1:18080` (no `0.0.0.0`): nginx hace de reverse proxy con TLS
+> y es el único expuesto al público.
+
+## 2. .env (secretos fuertes)
+
+```bash
+# Postgres
+POSTGRES_USER=engram
+POSTGRES_PASSWORD=<genera un secreto fuerte: openssl rand -hex 32>
+POSTGRES_DB=engram
+
+# Engram Cloud
+ENGRAM_CLOUD_DATABASE_URL=postgres://engram:<PASSWORD>@postgres:5432/engram?sslmode=disable
+ENGRAM_CLOUD_TOKEN=<genera otro secreto fuerte: openssl rand -hex 32>
+ENGRAM_CLOUD_DASHBOARD=true
+```
+
+> **El `ENGRAM_CLOUD_TOKEN` es lo que pide `ozali init` a cada dev.** Compártelo por canal
+> seguro (1Password, Bitwarden, Signal), nunca por email/chat del repo.
+
+## 3. Hardening
+
+### 3.1 Firewall (ufw)
+
+```bash
+sudo ufw default deny incoming
+sudo ufw default allow outgoing
+sudo ufw allow 22/tcp      # SSH (considera cambiar el puerto)
+sudo ufw allow 80/tcp      # HTTP (nginx → redirige a HTTPS)
+sudo ufw allow 443/tcp     # HTTPS (nginx)
+sudo ufw enable
+```
+
+### 3.2 nginx reverse proxy con SSL (Let's Encrypt)
+
+```nginx
+server {
+    listen 80;
+    server_name engram.mi-empresa.com;
+    return 301 https://$host$request_uri;
+}
+
+server {
+    listen 443 ssl http2;
+    server_name engram.mi-empresa.com;
+
+    ssl_certificate     /etc/letsencrypt/live/engram.mi-empresa.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/engram.mi-empresa.com/privkey.pem;
+    ssl_protocols       TLSv1.2 TLSv1.3;
+    ssl_ciphers         HIGH:!aNULL:!MD5;
+
+    location / {
+        proxy_pass         http://127.0.0.1:18080;
+        proxy_set_header   Host $host;
+        proxy_set_header   X-Real-IP $remote_addr;
+        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header   X-Forwarded-Proto $scheme;
+    }
+}
+```
+
+Certbot para el certificado:
+
+```bash
+sudo certbot --nginx -d engram.mi-empresa.com
+```
+
+### 3.3 systemd para auto-start
+
+```ini
+# /etc/systemd/system/engram-cloud.service
+[Unit]
+Description=Engram Cloud (Docker Compose)
+After=docker.service
+Requires=docker.service
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+WorkingDirectory=/opt/engram-cloud
+ExecStart=/usr/bin/docker compose up -d
+ExecStop=/usr/bin/docker compose down
+TimeoutStartSec=0
+
+[Install]
+WantedBy=multi-user.target
+```
+
+```bash
+sudo systemctl enable --now engram-cloud
+```
+
+## 4. Verificar
+
+```bash
+# En el VPS:
+docker compose ps              # ambos servicios "healthy"
+curl http://127.0.0.1:18080/health  # debería responder OK
+
+# Desde fuera:
+curl https://engram.mi-empresa.com/health
+```
+
+## 5. Conectar los devs
+
+Cada dev en su repo:
+
+```bash
+ozali init
+# → "¿Habilitar Engram Cloud?" → sí
+# → URL: https://engram.mi-empresa.com
+# → Token: <el ENGRAM_CLOUD_TOKEN del .env>
+# → autosync activo
+```
+
+Si el servidor requiere upgrade de esquema:
+
+```bash
+ozali cloud upgrade   # doctor → repair → bootstrap
+```
+
+## Backups
+
+```bash
+# Dump de Postgres (cron diario):
+docker exec engram-cloud-postgres-1 pg_dump -U engram engram | gzip > /backups/engram-$(date +%F).sql.gz
+```
+
+Mantén los backups fuera del VPS (S3, GCS, almacenamiento externo).

package/docs/guia-de-uso.md

@@ -82,7 +82,7 @@ Lleva el histórico y la memoria al repo de conocimiento del equipo. Tus compañ
 |---|---|
 | `ozali init` | Prepara el proyecto (lo corres una vez por repo). |
 | `ozali doctor` | Revisa que todo esté bien. Es solo lectura, no cambia nada. |
-| `ozali update` | Actualiza la skill a la última versión. |
+| `ozali update` | Actualiza skill ozali + ozali-jarvis + permisos (y guía cómo regenerar cdk). |
 | `ozali sync` | Sube el histórico/memoria al repo de equipo. |
 | `ozali sync --import` | Baja lo que el equipo ya guardó. |
 | `ozali audit` | Navega/audita la memoria de Engram (qué se ha hecho). |
@@ -190,6 +190,11 @@ Es el aviso de seguridad de Claude Code: ignora los permisos del proyecto hasta
 Deja que `init` lo marque como confiable, o abre Claude Code en la carpeta y acepta el diálogo una
 vez. Tras eso, el aviso desaparece y los permisos surten efecto.
 
+**Actualicé ozali pero no veo ozali-jarvis (o cdk quedó viejo).**
+Corre `ozali update` en el repo: refresca la skill ozali, los permisos y **crea/actualiza
+ozali-jarvis**. La skill `cdk` la regenera tu agente: tras `ozali update`, abre el agente y vuelve a
+correr la skill `ozali` para regenerar `cdk` con lo nuevo (tus docs por hito y el plan se conservan).
+
 **¿Funciona en Windows?**
 Sí. Los permisos base incluyen variantes PowerShell, y Engram se instala con `go install` o un
 binario descargable.

package/docs/ideas/postgres-vs-mysql-engram-cloud.md

@@ -0,0 +1,137 @@
+# PostgreSQL 16 vs MySQL 8.x para Engram Cloud
+
+← [README](../README.md)
+
+Guía comparativa para adaptar el despliegue de Engram Cloud de PostgreSQL a MySQL 8.x.
+
+## Cambios necesarios en `docker-compose.yml`
+
+### PostgreSQL 16 (actual — ver [deploy-cloud-vps.md](deploy-cloud-vps.md))
+
+```yaml
+services:
+  postgres:
+    image: postgres:16-alpine
+    restart: unless-stopped
+    env_file: .env
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U engram"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+
+  cloud:
+    image: ghcr.io/gentleman-programming/engram:latest
+    restart: unless-stopped
+    depends_on:
+      postgres:
+        condition: service_healthy
+    env_file: .env
+    ports:
+      - "127.0.0.1:18080:18080"
+
+volumes:
+  pgdata:
+```
+
+### MySQL 8.x (propuesto)
+
+```yaml
+services:
+  mysql:
+    image: mysql:8.0
+    restart: unless-stopped
+    env_file: .env
+    volumes:
+      - mysqldata:/var/lib/mysql
+    healthcheck:
+      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+
+  cloud:
+    image: ghcr.io/gentleman-programming/engram:latest
+    restart: unless-stopped
+    depends_on:
+      mysql:
+        condition: service_healthy
+    env_file: .env
+    ports:
+      - "127.0.0.1:18080:18080"
+
+volumes:
+  mysqldata:
+```
+
+## Cambios en `.env`
+
+| Variable | PostgreSQL | MySQL 8.x |
+|---|---|---|
+| DB user/pass | `POSTGRES_USER`, `POSTGRES_PASSWORD`, `POSTGRES_DB` | `MYSQL_ROOT_PASSWORD`, `MYSQL_DATABASE`, `MYSQL_USER`, `MYSQL_PASSWORD` |
+| Connection string | `postgres://engram:pass@postgres:5432/engram?sslmode=disable` | `engram:pass@tcp(mysql:3306)/engram?charset=utf8mb4&parseTime=True&loc=Local` |
+
+### `.env` para MySQL 8.x
+
+```bash
+# MySQL
+MYSQL_ROOT_PASSWORD=<genera un secreto fuerte: openssl rand -hex 32>
+MYSQL_DATABASE=engram
+MYSQL_USER=engram
+MYSQL_PASSWORD=<genera otro secreto fuerte>
+
+# Engram Cloud
+ENGRAM_CLOUD_DATABASE_URL=engram:<PASSWORD>@tcp(mysql:3306)/engram?charset=utf8mb4&parseTime=True&loc=Local
+ENGRAM_CLOUD_TOKEN=<genera otro secreto fuerte: openssl rand -hex 32>
+ENGRAM_CLOUD_DASHBOARD=true
+```
+
+## Tabla comparativa
+
+| Aspecto | PostgreSQL 16 | MySQL 8.x |
+|---|---|---|
+| Imagen Docker | `postgres:16-alpine` (~80MB) | `mysql:8.0` (~450MB) |
+| Healthcheck | `pg_isready -U engram` | `mysqladmin ping -h localhost` |
+| Volúmenes | `/var/lib/postgresql/data` | `/var/lib/mysql` |
+| Driver Go | `lib/pq` o `pgx` | `go-sql-driver/mysql` |
+| Connection string | `postgres://` | `user:pass@tcp(host:port)/db?...` |
+| JSON nativo | `JSONB` (índices GIN) | `JSON` + funciones |
+| Arrays nativos | Sí (`text[]`, `int[]`) | No (usa tablas relacionales) |
+| Full-text search | `tsvector`/`tsquery` | `FULLTEXT` indexes |
+| Concurrency | MVCC sin locks de lectura | MVCC con read locks en algunos casos |
+| Backup | `pg_dump` | `mysqldump` |
+
+## Bloqueador: ¿Engram soporta MySQL?
+
+Depende del código fuente de [github.com/Gentleman-Programming/engram](https://github.com/Gentleman-Programming/engram):
+
+- **Si usa GORM**: con cambiar el driver (`postgres` → `mysql`) y el DSN, funcionaría.
+- **Si usa SQL nativo con funciones Postgres** (`JSONB`, `NOW()`, `ARRAY`, `ILIKE`, `RETURNING`): requiere tocar el código de Engram.
+
+### Para verificar rápido
+
+```bash
+# 1. Desplegar con MySQL (docker-compose arriba)
+docker compose up -d
+
+# 2. Ver logs del contenedor cloud:
+docker logs engram-cloud-cloud-1
+# Si falla con "unsupported driver" o "syntax error", no hay soporte MySQL.
+
+# 3. Si conecta, verificar health:
+curl http://127.0.0.1:18080/health
+```
+
+## Backup con MySQL
+
+```bash
+# Dump de MySQL (cron diario):
+docker exec engram-cloud-mysql-1 mysqldump -u engram -p<PASSWORD> engram | gzip > /backups/engram-$(date +%F).sql.gz
+```
+
+## Recomendación
+
+- **Mantener PostgreSQL** si no hay requisito específico de MySQL. Es lo que Engram espera.
+- **Migrar a MySQL** solo si el equipo ya tiene infra MySQL operativa (DBA, backups, monitoreo) y se confirma que Engram tiene driver MySQL compilado.

package/docs/team-history.md

@@ -64,3 +64,55 @@ histórico apunta a un commit exacto.
 
 El contrato concreto de qué se espeja a Engram, cuándo, y el algoritmo de `ozali sync` está en
 [skill/references/engram-convention.md](../skill/references/engram-convention.md) (§3 y §6).
+
+## Engram Cloud: réplica en tiempo real (opt-in)
+
+Además del git-sync, ozali soporta **Engram Cloud** — un servidor central que replica la memoria
+del equipo **en tiempo real** (autosync), sin necesidad de commit/push manual.
+
+### Modelo: cloud-first, git-sync como backup
+
+```
+dev A guarda memoria → autosync → cloud → dev B (autosync recibe)
+                                ↕
+                    git-sync (backup/secondary, repos de conocimiento)
+```
+
+- **Cloud-first**: la réplica es automática e invisible. El repo de conocimiento sigue siendo
+  el backup offline y el canal para docs (que no van a cloud).
+- **Sin cloud**: todo funciona igual con git-sync manual (`ozali sync` + `--push`/`--import`).
+
+### Onboarding de equipo (un dev nuevo en 1 paso)
+
+Cuando un dev nuevo hace `ozali init` en un repo que ya tiene `.ozali/cloud.json` (commiteable,
+sin secretos), el CLI detecta la cloud del equipo y ofrece conectarse automáticamente:
+
+```
+$ ozali init
+✓ Engram Cloud del equipo detectado (servidor: https://engram.mi-empresa.com)
+  → Proyecto: "ozali"
+  → ¿Conectarte a la memoria del equipo? [sí/no]
+  → token: ****
+  → Recibiendo memoria del equipo…
+  → autosync activo (invisible)
+  → Listo.
+```
+
+### Despliegue del servidor
+
+Ver [docs/deploy-cloud-vps.md](deploy-cloud-vps.md) (VPS genérico con docker-compose) y
+[docs/deploy-cloud-gcloud.md](deploy-cloud-gcloud.md) (Google Cloud: Cloud Run o GCE VM).
+
+### Comandos cloud
+
+| Comando | Qué hace |
+|---|---|
+| `ozali sync --cloud` | Push manual a cloud |
+| `ozali sync --cloud --import` | Pull desde cloud (onboarding inverso) |
+| `ozali cloud status` | Estado + último sync + upgrade |
+| `ozali cloud upgrade` | doctor → repair → bootstrap |
+| `ozali cloud dashboard` | Abre el dashboard web |
+| `ozali cloud config` | Re-configura servidor/token |
+
+Detalle del contrato de memoria cloud (scope, idioma, conflictos, troubleshooting) en
+[skill/references/engram-convention.md](../skill/references/engram-convention.md) §8.