ozali 0.7.1 → 0.9.0

package/cli/test/smoke.test.mjs

@@ -6,7 +6,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { engramAssetName, pickEngramAsset } from "../lib/util.mjs";
+import { engramAssetName, pickEngramAsset, toPortablePath, fromPortablePath } from "../lib/util.mjs";
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const BIN = path.resolve(HERE, "..", "bin", "ozali.mjs");
@@ -257,6 +257,8 @@ test("workspace escribe manifiesto + .code-workspace + jarvis y es idempotente",
     assert.ok(fs.existsSync(wsFile), ".code-workspace escrito");
     assert.equal(JSON.parse(fs.readFileSync(wsFile, "utf8")).folders.length, 2, "multi-root con 2 folders");
     assert.match(fs.readFileSync(path.join(root, "CLAUDE.md"), "utf8"), /ozali-workspace-jarvis:start/, "bloque jarvis en CLAUDE.md");
+    // Track 2: la skill ozali queda instalada en la raíz para calibrar miembros desde el workspace
+    assert.ok(fs.existsSync(path.join(root, ".claude", "skills", "ozali", "SKILL.md")), "skill ozali en la raíz");
 
     // idempotencia: re-correr no duplica
     run(["workspace", "--yes", "--no-trust"], root);
@@ -268,6 +270,51 @@ test("workspace escribe manifiesto + .code-workspace + jarvis y es idempotente",
   }
 });
 
+test("workspace --doctor revisa cada miembro y saca resumen consolidado", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ozali-ws-"));
+  try {
+    wsRepo(root, "api", { config: true, cdk: true, pkg: { name: "api", version: "1.0.0" } });
+    wsRepo(root, "web", { config: true, cdk: true, pkg: { name: "web" } });
+    const { stdout } = run(["workspace", "--doctor"], root, true); // exit 1 esperado (repos sin sot/engram)
+    assert.match(stdout, /health-check/i, "corre doctor por repo");
+    assert.match(stdout, /Resumen del workspace/, "imprime el resumen consolidado");
+    assert.match(stdout, /api/, "menciona el repo api en el resumen");
+    assert.match(stdout, /web/, "menciona el repo web en el resumen");
+    assert.ok(!fs.existsSync(path.join(root, "ozali-workspace.json")), "--doctor no escribe config");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("workspace --update actualiza cada miembro y salta los sin init", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ozali-ws-"));
+  try {
+    wsRepo(root, "api", { config: true, cdk: true, pkg: { name: "api", version: "1.0.0" } });
+    wsRepo(root, "bare", { pkg: { name: "bare" } }); // missing-init → se salta
+    const { stdout } = run(["workspace", "--update", "--yes", "--no-jarvis"], root);
+    assert.match(stdout, /Resumen del workspace/, "imprime el resumen consolidado");
+    assert.match(stdout, /Sin ozali init/, "salta el repo sin init");
+    assert.ok(!fs.existsSync(path.join(root, "ozali-workspace.json")), "--update no escribe config");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("workspace no trata subcarpetas de un repo como miembros (solo repos propios)", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ozali-ws-"));
+  try {
+    execFileSync("git", ["init", "-q"], { cwd: root }); // la raíz ES un repo git
+    fs.mkdirSync(path.join(root, "src"));                 // subcarpeta simple, NO repo propio
+    fs.writeFileSync(path.join(root, "src", "index.js"), "//\n");
+    wsRepo(root, "pkg", { config: true, cdk: true, pkg: { name: "pkg", version: "1.0.0" } }); // repo propio anidado
+    const { stdout } = run(["workspace", "--dry-run"], root);
+    assert.match(stdout, /\bpkg\b/, "incluye el repo propio anidado");
+    assert.doesNotMatch(stdout, /\bsrc\b/, "no incluye la subcarpeta que no es repo propio");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("init --dry-run no escribe nada", () => {
   const dir = tmpProject();
   try {
@@ -336,6 +383,49 @@ test("engramAssetName respeta la convención de release por SO/arch", () => {
   assert.equal(engramAssetName("freebsd", "x64", "1.17.0"), null, "SO no soportado → null");
 });
 
+test("toPortablePath convierte absolutos a ~ o relativo", () => {
+  const home = os.homedir();
+  const cwd = "/project";
+  assert.equal(toPortablePath(path.join(home, ".ozali", "knowledge"), cwd), "~/.ozali/knowledge");
+  assert.equal(toPortablePath("/project/.k", "/project"), ".k");
+  assert.equal(toPortablePath("/outside", "/project"), "/outside");
+});
+
+test("fromPortablePath expande ~ y resuelve relativos", () => {
+  const home = os.homedir();
+  const cwd = "/project";
+  assert.equal(fromPortablePath("~/.ozali/knowledge", cwd), path.join(home, ".ozali", "knowledge"));
+  assert.equal(fromPortablePath(".k", cwd), "/project/.k");
+  assert.equal(fromPortablePath("/abs", cwd), "/abs");
+});
+
+test("init guarda knowledgeRepo como path portable", () => {
+  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 cfg = JSON.parse(fs.readFileSync(path.join(dir, ".ozali", "config.json"), "utf8"));
+    assert.ok(cfg.knowledgeRepo, "config tiene knowledgeRepo");
+    assert.ok(!path.isAbsolute(cfg.knowledgeRepo), "knowledgeRepo NO debe ser absoluto");
+    assert.equal(cfg.knowledgeRepo, ".k", "knowledgeRepo debe ser relativo al proyecto");
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("sync resuelve knowledgeRepo portable correctamente", () => {
+  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);
+    // Crear algo en .ozali/docs/ para que sync tenga qué copiar
+    fs.mkdirSync(path.join(dir, ".ozali", "docs"), { recursive: true });
+    fs.writeFileSync(path.join(dir, ".ozali", "docs", "test.md"), "# test\n");
+    const { stdout } = run(["sync", "--yes"], dir);
+    assert.match(stdout, /copiados|Docs copiados/, "sync debe encontrar el repo de conocimiento");
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test("pickEngramAsset ignora tags no-semver sin binarios (pi-v*) y draft/prerelease", () => {
   // Shape real de la API de GitHub: el 'latest' es pi-v0.1.9 (0 assets); los binarios
   // viven en tags vX.Y.Z. Además metemos un prerelease más nuevo que debe saltarse.

package/docs/compilado-local.md

@@ -0,0 +1,182 @@
+# Compilado y uso local (para probar el repo clonado)
+
+← [README](../README.md)
+
+Guía para cuando **clonas este repositorio** y quieres compilarlo/empaquetarlo y **probarlo en local**
+antes de publicarlo o para desarrollar sobre él.
+
+> **Aclaración importante — no hay "compilación".** `ozali` es un CLI **Node de cero dependencias y
+> ESM puro** (solo usa módulos `node:*`). **No hay build step**, ni TypeScript que transpilar, ni
+> `dist/`. "Compilar" aquí significa una de dos cosas: (a) **correrlo tal cual** desde el fuente, o
+> (b) **empaquetar el artefacto distribuible** (`npm pack` → un `.tgz`, el "archivo base") para
+> instalarlo y probarlo como lo haría un usuario final.
+
+---
+
+## Requisitos
+
+- **Node ≥ 16** (`node --version`). Es lo único imprescindible.
+- **git** (el CLI lee identidad/estado del repo).
+- **pnpm** o **npm** (opcional; solo para `test`, `pack`, `link` o instalación global). No hay `npm
+  install` que correr: **el repo no tiene dependencias**.
+
+```bash
+git clone https://github.com/jimmybathrooms/ozali.git
+cd ozali
+```
+
+---
+
+## 1. Correr desde el fuente (sin instalar nada)
+
+Como no hay dependencias ni build, el CLI corre directo:
+
+```bash
+node cli/bin/ozali.mjs --version     # imprime la versión de package.json (p. ej. 0.8.0)
+node cli/bin/ozali.mjs --help        # lista de comandos
+node cli/bin/ozali.mjs doctor        # health-check en el cwd
+```
+
+Esta es la forma **más auditable**: ejecutas exactamente el código que ves, sin capa de instalación.
+
+---
+
+## 2. Correr la batería de pruebas
+
+```bash
+npm test        # (o: pnpm test)  → node --test cli/test/*.test.mjs
+```
+
+Debe salir todo en verde. Los tests son `node:test` puro (sin dependencias) y cubren init, doctor,
+update, workspace, seguridad del paquete y los helpers de release de Engram.
+
+---
+
+## 3. Empaquetar el "archivo base" (tarball distribuible)
+
+El artefacto que se publicaría en npm es un tarball `.tgz`. Se genera con:
+
+```bash
+npm pack                 # (o: pnpm pack)
+# → crea  ozali-<version>.tgz  en la raíz del repo (el cwd)
+```
+
+Para tu versión actual produce, por ejemplo, **`ozali-0.8.0.tgz`**. Es **idéntico** a lo que recibiría
+un usuario desde npm: incluye solo lo declarado en `package.json > files` (`cli/`, `skill/`,
+`skill-commit/`, `templates/`, `docs/`, `README.md`, `LICENSE`).
+
+Para **ver qué contiene sin generar el archivo**:
+
+```bash
+npm pack --dry-run       # lista archivos, tamaño y nombre del tarball, sin escribir nada
+```
+
+> El `.tgz` es un artefacto temporal: **no lo commitees**. Bórralo tras probar (o añádelo a
+> `.gitignore` como `ozali-*.tgz`).
+
+### Extraer / inspeccionar el tarball
+
+El tarball es un `.tar.gz` estándar. Para extraerlo y revisar el "archivo base" tal como quedaría
+instalado:
+
+```bash
+tar -xzf ozali-0.8.0.tgz      # crea una carpeta  package/  con el contenido publicable
+ls -R package                 # inspecciona la estructura
+tar -tzf ozali-0.8.0.tgz      # o solo LISTA el contenido, sin extraer
+```
+
+La carpeta `package/` es exactamente lo que npm coloca en `node_modules/ozali` al instalar.
+
+---
+
+## 4. Usarlo en local para pruebas
+
+Tres formas, de la más cómoda para desarrollar a la más fiel al usuario final:
+
+### a) `npm link` — bucle de desarrollo (refleja tus cambios al instante)
+
+```bash
+npm link                 # (o: pnpm link --global)
+# ahora 'ozali' está en tu PATH, apuntando al clon local
+ozali --version
+ozali doctor
+```
+
+Como es un symlink al repo, cualquier edición que hagas en `cli/` se ve de inmediato (no hace falta
+re-linkear). Para deshacer: `npm unlink -g ozali` (o `npm rm -g ozali`).
+
+### b) Instalar el tarball global — prueba el artefacto real
+
+Instala el `.tgz` como lo haría un usuario, para validar el paquete exacto que publicarías:
+
+```bash
+npm i -g ./ozali-0.8.0.tgz     # (o: pnpm add -g ./ozali-0.8.0.tgz)
+ozali --version
+```
+
+Para desinstalar: `npm rm -g ozali`.
+
+### c) Efímero, sin instalar en el PATH — como `npx`/`pnpm dlx`
+
+```bash
+npx ./ozali-0.8.0.tgz init        # corre init desde el tarball, sin dejar 'ozali' instalado
+pnpm dlx ./ozali-0.8.0.tgz init   # equivalente con pnpm
+```
+
+> **Nota de seguridad:** el flag `--ignore-scripts` que recomendamos para instalar desde npm es
+> irrelevante aquí, porque `ozali` **no tiene dependencias ni lifecycle scripts** (nada que ejecutar
+> en install). Detalle en [security.md](security.md).
+
+---
+
+## 5. Probar en un proyecto sandbox
+
+Crea un repo de juguete y corre el flujo real sin ensuciar nada:
+
+```bash
+mkdir /tmp/ozali-sandbox && cd /tmp/ozali-sandbox && git init
+
+# opción sin instalar: apunta al bin del clon
+node /ruta/al/clon/ozali/cli/bin/ozali.mjs init --dry-run          # muestra el plan, no escribe
+node /ruta/al/clon/ozali/cli/bin/ozali.mjs init --yes --no-engram  # init real, sin instalar Engram
+node /ruta/al/clon/ozali/cli/bin/ozali.mjs doctor                  # verifica el resultado
+```
+
+Para probar **workspaces multi-repo**, crea una carpeta con varios repos git dentro y corre:
+
+```bash
+node /ruta/al/clon/ozali/cli/bin/ozali.mjs workspace --dry-run     # inventario + plan, sin escribir
+node /ruta/al/clon/ozali/cli/bin/ozali.mjs workspace --doctor      # health-check de todos los miembros
+```
+
+(Si hiciste `npm link`, sustituye todo lo anterior por simplemente `ozali <comando>`.)
+
+---
+
+## 6. Verificar y limpiar
+
+```bash
+ozali --version                 # debe coincidir con la "version" de package.json
+npm rm -g ozali                 # desinstala el global (link o tarball)
+rm -f ozali-*.tgz               # borra el tarball de prueba
+rm -rf package/                 # borra la extracción del tarball, si la hiciste
+```
+
+---
+
+## Resumen
+
+| Quiero… | Comando |
+|---|---|
+| Correr sin instalar | `node cli/bin/ozali.mjs <cmd>` |
+| Correr los tests | `npm test` |
+| Empaquetar el distribuible | `npm pack` → `ozali-<version>.tgz` |
+| Ver el contenido del paquete | `npm pack --dry-run` |
+| Extraer el tarball | `tar -xzf ozali-<version>.tgz` → `package/` |
+| Desarrollar con `ozali` en PATH | `npm link` |
+| Probar el artefacto real | `npm i -g ./ozali-<version>.tgz` |
+| Probar efímero | `npx ./ozali-<version>.tgz init` |
+
+> ¿Buscas **publicar** una versión nueva (no solo probar)? Eso es otro flujo: bump de `version` en
+> `package.json` → commit → tag `vX.Y.Z` → push; el tag dispara la publicación a npm con provenance
+> vía GitHub Actions.

package/docs/guia-de-uso.md

@@ -81,6 +81,7 @@ Lleva el histórico y la memoria al repo de conocimiento del equipo. Tus compañ
 | Comando | Qué hace |
 |---|---|
 | `ozali init` | Prepara el proyecto (lo corres una vez por repo). |
+| `ozali workspace` | Configura varios repos de una carpeta para trabajar en conjunto (lo corres en la carpeta raíz). |
 | `ozali doctor` | Revisa que todo esté bien. Es solo lectura, no cambia nada. |
 | `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. |
@@ -171,6 +172,51 @@ Atajos: `ozali audit --tui` abre un navegador interactivo de la memoria; `ozali
 busca un término; `ozali audit --general` fuerza el alcance general. Si no tienes Engram, audita el
 histórico local de `.ozali/docs/`.
 
+---
+
+## Trabajar con varios repos a la vez (`ozali workspace`)
+
+¿Tienes una carpeta que agrupa **varios repositorios que se hablan entre sí** (una API, su front, una
+librería compartida) y quieres que tu agente trabaje con todos juntos? Corre **una vez** en esa
+carpeta raíz:
+
+```bash
+ozali workspace             # escanea los repos hijos, prepara los que falten y arma la config conjunta
+ozali workspace --dry-run   # solo te muestra el inventario y el plan, sin escribir nada
+ozali workspace --yes       # sin preguntas: acepta los defaults y las referencias detectadas
+ozali workspace --depth 2   # busca repos hasta 2 niveles (si están en subcarpetas de grupo)
+```
+
+Qué hace, en orden:
+
+1. **Revisa** cada repo y te dice cómo está: `✔ listo`, `⚠ sin calibrar` (le falta correr la skill
+   `ozali`) o `✖ sin init` (nunca se preparó).
+2. **Prepara** los que están `✖ sin init` corriendo `ozali init` por ti, y te **guía** para calibrar
+   los que están `⚠ sin calibrar` (abrir ese repo y escribir *"diagnostica el proyecto"* — eso lo
+   hace tu agente, no el comando).
+3. **Detecta las referencias** entre repos (dependencias npm cruzadas, submódulos, `docker-compose`) y
+   te pide confirmarlas.
+4. **Escribe la configuración** para trabajar en conjunto:
+   - `ozali-workspace.json` — el mapa de repos, su estado y sus referencias (esto **sí** se commitea).
+   - `<carpeta>.code-workspace` — ábrelo en VSCode/Antigravity y verás todos los repos juntos.
+   - **ozali-workspace-jarvis** en el `CLAUDE.md`/`AGENTS.md` de la raíz: un orquestador que coordina
+     los repos según ese mapa y delega el trabajo de código en el `cdk` de cada uno.
+
+**Sin ir a cada proyecto:** desde la carpeta raíz puedes operar todos los repos de una vez:
+
+```bash
+ozali workspace --doctor    # revisa la salud de todos los repos y saca un resumen
+ozali workspace --update    # actualiza skills, permisos y jarvis de todos los repos
+```
+
+Y para **calibrar** (generar `cdk`) los que estén `⚠ sin calibrar`, ya **no** abres cada proyecto:
+abre tu agente en la carpeta raíz y pídele *"calibra los repos pendientes"* — el orquestador los
+recorre **uno por uno** (cada uno con su aprobación) sin que cambies de proyecto.
+
+Es **idempotente**: vuelve a correrlo cuando agregues un repo o cambien las referencias — no duplica
+nada. Cada repo conserva su autonomía (su propio jarvis, su `cdk` y su memoria); el workspace solo
+los **coordina**. Detalle completo en [workspaces.md](workspaces.md).
+
 ## Preguntas frecuentes
 
 **¿Tengo que usar Engram?**
@@ -185,6 +231,10 @@ Lo corriste con `dlx`/`npx`, que es temporal. Instálalo global: `pnpm add -g oz
 **¿Esto ensucia mi repositorio?**
 No. El histórico y la memoria se aíslan (`.ozali/`, `.engram/` van al `.gitignore`).
 
+**Tengo varios repos que dependen entre sí. ¿Los conecto?**
+Sí: abre la carpeta que los agrupa y corre `ozali workspace`. Prepara los que falten y arma una
+config para que tu agente trabaje con todos juntos. Ver [arriba](#trabajar-con-varios-repos-a-la-vez-ozali-workspace).
+
 **Veo "this workspace has not been trusted" y mis permisos no aplican.**
 Es el aviso de seguridad de Claude Code: ignora los permisos del proyecto hasta confiar en él.
 Deja que `init` lo marque como confiable, o abre Claude Code en la carpeta y acepta el diálogo una

package/docs/obsidian-integration.md

@@ -0,0 +1,93 @@
+# Integración con Obsidian
+
+← [README](README.md)
+
+Ozali puede exportar la memoria de equipo (Engram) y el histórico de hitos a un **vault de Obsidian**: un espacio navegable con wikilinks, grafo de conocimiento y Mapas de Contenido (MOCs).
+
+## ¿Qué es el vault?
+
+Es una carpeta `obsidian/` dentro de tu **repo de conocimiento** (`ozali-knowledge/` o `~/.ozali/knowledge/`). Contiene:
+
+- **README.md** — índice humano del vault
+- **MOCs/** — Mapas de Contenido auto-generados (proyectos, decisiones, bugfixes, métricas)
+- **Memoria/** — exportación de Engram (decisiones, bugfixes, resúmenes técnicos)
+- **.obsidian/** — configuración compartida del equipo (plugins core, hotkeys)
+
+## Requisitos
+
+- [Obsidian](https://obsidian.md) instalado (opt-in; ozali lo detecta y ofrece descargar)
+- Engram instalado (`engram obsidian-export` es el motor de exportación)
+
+## Uso
+
+### Generar / actualizar el vault
+
+```bash
+# Desde cualquier proyecto ozali
+ozali sync --obsidian
+```
+
+Esto:
+1. Exporta Engram al vault (`engram obsidian-export`)
+2. Actualiza los MOCs dinámicos (lista de proyectos, etc.)
+3. Commit en el repo de conocimiento
+
+### Sin el flag `--obsidian`
+
+```bash
+ozali sync
+```
+
+Si el vault ya existe, ozali pregunta: *"¿Exportar memoria a Obsidian vault?"*. Responde `sí` para actualizar.
+
+### Abrir el vault en Obsidian
+
+1. Abre Obsidian
+2. Selecciona **"Open folder as vault"**
+3. Navega a tu `ozali-knowledge/obsidian/` (o `~/.ozali/knowledge/obsidian/`)
+
+### Estructura recomendada del repo de conocimiento
+
+```
+ozali-knowledge/
+  .git/
+  engram/              ← export chunks de Engram
+  projects/
+    {proyecto}/
+      docs/            ← docs por hito
+  obsidian/            ← 🆕 VAULT DE OBSIDIAN
+    .obsidian/
+    README.md
+    MOCs/
+    Memoria/
+```
+
+## Configuración compartida
+
+La carpeta `.obsidian/` del vault **sí se commitea** en el repo de conocimiento. Contiene:
+- Plugins core habilitados (graph, backlinks, quick switcher)
+- Config de lectura (readable line length)
+
+**No se commitean** settings personales: temas, snippets, `workspace.json`, notas `Daily/`.
+
+## Flujo de trabajo típico
+
+1. Trabajas en un hito con `cdk` → ozali genera docs en `.ozali/docs/`
+2. `ozali sync` → lleva docs + Engram al repo de conocimiento
+3. `ozali sync --obsidian` → regenera el vault con la memoria actualizada
+4. Abres Obsidian → exploras el grafo, wikilinks, decisiones del equipo
+
+## Troubleshooting
+
+| Síntoma | Causa | Solución |
+|---|---|---|
+| `engram obsidian-export` falla | Vault abierto en Obsidian (lock de archivos) | Cierra el vault en Obsidian y reintenta |
+| MOCs vacíos | Sin proyectos en `knowledgeRepo/projects/` | Corre `ozali sync` primero para crear la estructura |
+| No se detecta Obsidian | Instalado en path no estándar | Ignora la advertencia; abre el vault manualmente |
+
+## Cerebro vs Vault
+
+- **Cerebro** (`AI.md` + `.ai/`) vive en **cada repo** — es la fuente de verdad.
+- **Vault** (`obsidian/`) vive en el **repo de conocimiento** — es la lectura humana acumulada.
+
+No duplicamos el cerebro en el vault. Los MOCs usan **markdown links** para referenciar `AI.md` fuera del vault, y **wikilinks** para todo lo que está dentro (`Memoria/`, `MOCs/`).

package/docs/workspaces.md

@@ -26,6 +26,18 @@ ozali workspace --no-trust   # no marca la raíz como confiable en Claude Code
 Un CLI **no puede auto-dispararse** con solo hacer `cd`; por eso es un comando explícito e
 **idempotente**: re-córrelo cuando agregues repos o cambien las referencias.
 
+### Operar todos los repos desde la raíz
+
+Para no entrar repo por repo, dos modos batch corren un comando sobre **todos los miembros**:
+
+```bash
+ozali workspace --doctor     # health-check de cada repo miembro + resumen consolidado
+ozali workspace --update     # actualiza skills/permisos/jarvis de cada repo + avisa de cdk desfasado
+```
+
+Ambos son **solo CLI** (no necesitan el agente) y saltan los repos `✖ sin init`. La **calibración**
+(generar `cdk`) sí la hace el agente, pero también **sin cambiar de proyecto** — ver abajo.
+
 ## Qué hace, paso a paso
 
 1. **Escaneo (read-only).** Enumera los repos git hijos y reporta el estado ozali de cada uno:
@@ -37,10 +49,11 @@ Un CLI **no puede auto-dispararse** con solo hacer `cd`; por eso es un comando e
    instala skills, aísla histórico, configura Engram). Hereda `agent`/`scope`/`knowledge-repo` de un
    repo ya inicializado para mantener el equipo consistente.
 
-3. **Guía de calibración.** El CLI **no calibra** (eso lo hace el agente). Para cada repo
-   `⚠ sin calibrar`, imprime la instrucción: abre ese repo en tu agente y corre la skill **`ozali`**
-   ("diagnostica el proyecto") para generar su `cdk`. El orquestador de workspace también queda
-   cableado para conducir esa calibración repo por repo.
+3. **Guía de calibración.** El CLI **no calibra** (eso lo hace el agente), pero ya **no** tienes que
+   abrir cada repo por separado: `ozali workspace` instala la skill **`ozali`** en la **raíz**, y el
+   orquestador `ozali-workspace-jarvis` la usa **en modo target** para calibrar cada repo
+   `⚠ sin calibrar` **desde el workspace**, repo por repo y con su propio 🛑 GATE. Abre el agente en la
+   raíz y pídele *"calibra los repos pendientes"*.
 
 4. **Referencias (auto-detección + confirmación).** Infiere aristas dirigidas `from → to`:
    - `npm-dep` — el `name` de un repo aparece en `dependencies`/`devDependencies`/`peerDependencies` de otro.
@@ -58,6 +71,7 @@ En la carpeta raíz:
 | `ozali-workspace.json` | Manifiesto: miembros (ruta, proyecto, estado, fuente de verdad), referencias, `knowledgeRepo`, cloud. Fuente de verdad del workspace. |
 | `<carpeta>.code-workspace` | Workspace **multi-root** de VSCode/Antigravity: abre todos los repos juntos. Merge idempotente si ya existe. |
 | `CLAUDE.md` / `AGENTS.md` (raíz) | Bloque marcado del orquestador **`ozali-workspace-jarvis`** + subagente / agente de opencode. |
+| `.claude/skills/ozali/` (raíz) | La skill **`ozali`** instalada en la raíz para **calibrar miembros en modo target** sin cambiar de proyecto (solo Claude Code). |
 
 Si la raíz es a su vez un repo git, se añade `.claude/`, `.engram/` y `.ozali/` a su `.gitignore`
 (los artefactos locales del agente no se commitean). `ozali-workspace.json` y `.code-workspace` **sí**
@@ -78,5 +92,5 @@ miembros). Su trabajo:
 ## Fuera de alcance (por ahora)
 
 - Auto-sugerencia al abrir la carpeta (tarea de editor/hook).
-- `ozali doctor`/`sync` agregados a nivel workspace.
+- `ozali sync` agregado a nivel workspace (`--doctor`/`--update` ya existen; falta `--sync`).
 - Detección de referencias más allá de npm/submódulos/compose (imports TS/py, `go.work`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ozali",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "Bootstrap interactivo de IA por equipo: calibra el proyecto, genera la skill de ejecución (cdk) con TDD/SDD, y mantiene memoria de equipo (Engram) con histórico aislado.",
   "type": "module",
   "bin": {

package/skill/SKILL.md

@@ -26,6 +26,28 @@ produce documentación, la calibración, el plan y los artefactos de la skill `c
 
 ---
 
+## Modo workspace — calibrar un repo miembro (target)
+
+Normalmente `ozali` opera sobre el **repo actual** (cwd). Pero cuando te invocan desde la **raíz de un
+workspace** (existe `ozali-workspace.json`) para calibrar un **repo miembro**, operas sobre un
+**target de subcarpeta** en vez del cwd. En ese caso:
+
+- **Todas las rutas son relativas al `<target>`**, no a la raíz: la fuente de verdad
+  (`<target>/AI.md` + `<target>/.ai/`, o su variante `IA.md` + `.ia/`), la skill que generas
+  (`<target>/.claude/skills/cdk/`), el histórico (`<target>/.ozali/docs/`) y
+  `<target>/.engram/config.json`.
+- **Identidad git del miembro:** usa `git -C <target> …` (no la raíz).
+- **Engram:** guarda con el `project_name` de `<target>/.engram/config.json` (equivale al
+  `members[].project` del manifiesto). **No mezcles** memoria entre repos.
+- **Un target por corrida**, secuencial, con su **propio 🛑 GATE**. No calibres varios a la vez sin
+  aprobación.
+- Al terminar, sugiere **re-correr `ozali workspace`** en la raíz para refrescar el estado del miembro
+  en el manifiesto (`needs-calibration` → `ready`).
+
+Si te invocan sin target (uso normal en un solo repo), ignora esta sección y sigue con el cwd.
+
+---
+
 ## Flujo general (7 fases)
 
 ```

package/templates/obsidian-vault/.obsidian/app.json

@@ -0,0 +1,12 @@
+{
+  "alwaysUpdateLinks": true,
+  "newFileLocation": "folder",
+  "newFileFolderPath": "Memoria",
+  "attachmentFolderPath": "Memoria",
+  "readableLineLength": true,
+  "strictLineBreaks": false,
+  "showLineNumber": false,
+  "spellcheck": false,
+  "tabSize": 2,
+  "useTab": false
+}

package/templates/obsidian-vault/.obsidian/core-plugins.json

@@ -0,0 +1,9 @@
+[
+  "graph",
+  "backlink",
+  "page-preview",
+  "command-palette",
+  "markdown-importer",
+  "switcher",
+  "outline"
+]

package/templates/obsidian-vault/MOCs/Bugfixes Recientes.md

@@ -0,0 +1,9 @@
+# 🗺️ Bugfixes Recientes
+
+Correcciones con impacto en otros módulos o que revelan gotchas del repo.
+
+> Este MOC se regenera automáticamente con `ozali sync --obsidian`.
+
+<!-- BUGFIXES_START -->
+<!-- Se rellena automáticamente por ozali sync --obsidian desde Engram -->
+<!-- BUGFIXES_END -->

package/templates/obsidian-vault/MOCs/Decisiones del Equipo.md

@@ -0,0 +1,9 @@
+# 🗺️ Decisiones del Equipo
+
+Decisiones de arquitectura, trade-offs y convenciones que afectan a todos.
+
+> Este MOC se regenera automáticamente con `ozali sync --obsidian`.
+
+<!-- DECISIONS_START -->
+<!-- Se rellena automáticamente por ozali sync --obsidian desde Engram -->
+<!-- DECISIONS_END -->

package/templates/obsidian-vault/MOCs/M/303/251tricas y Tokens.md"

@@ -0,0 +1,9 @@
+# 🗺️ Métricas y Tokens
+
+Resumen agregado de uso de tokens y eficiencia del equipo.
+
+> Este MOC se regenera automáticamente con `ozali sync --obsidian`.
+
+<!-- METRICS_START -->
+<!-- Se rellena automáticamente por ozali sync --obsidian desde Engram -->
+<!-- METRICS_END -->

package/templates/obsidian-vault/MOCs/Proyectos.md

@@ -0,0 +1,17 @@
+# 🗺️ Proyectos
+
+Proyectos activos en el workspace ozali.
+
+> Este MOC se regenera automáticamente con `ozali sync --obsidian`.
+
+## Activos
+
+<!-- PROJECTS_START -->
+<!-- Se rellena automáticamente por ozali sync --obsidian -->
+<!-- PROJECTS_END -->
+
+## Agregar un nuevo proyecto
+
+1. Corre `ozali init` en el repo del proyecto.
+2. Corre `ozali sync --obsidian` desde cualquier proyecto.
+3. El proyecto aparecerá aquí automáticamente.

package/templates/obsidian-vault/MOCs//303/215ndice Global.md"

@@ -0,0 +1,19 @@
+# 🗺️ Índice Global
+
+Bienvenido al vault de ozali. Usa este índice para navegar la memoria del equipo.
+
+## Mapas de Contenido (MOCs)
+
+- [[MOCs/Proyectos]] — Todos los proyectos del equipo
+- [[MOCs/Decisiones del Equipo]] — Decisiones arquitectónicas y trade-offs
+- [[MOCs/Bugfixes Recientes]] — Correcciones con impacto cruzado
+- [[MOCs/Métricas y Tokens]] — Consumo de tokens y eficiencia
+
+## Cómo actualizar este vault
+
+```bash
+# Desde cualquier proyecto ozali
+ozali sync --obsidian
+```
+
+> El vault se regenera automáticamente. No edites `Memoria/` a mano.