ozali 0.8.0 → 0.10.0

package/README.md

@@ -137,7 +137,8 @@ interactivo te pregunta (default sí), y con `--yes` lo instala automáticamente
 descarga el **binario precompilado** correcto según tu arquitectura (amd64/arm64) a `~/.local/bin`
 (sin sudo); en **macOS** usa brew → `go install` con el binario como fallback; en **Windows**
 usa `go install`. Si algún paso falla, imprime instrucciones específicas de tu SO. Si prefieres no
-instalarlo, pasa `--no-engram` (arranca en modo `docs`). Opcionalmente habilita **Engram Cloud**
+instalarlo, pasa `--no-engram` (arranca en modo `docs`). Más tarde puedes instalarlo con
+`ozali install-engram` bajo demanda. Opcionalmente habilita **Engram Cloud**
 (réplica de equipo opt-in) además del git-sync.
 
 `init` también crea **ozali-jarvis**, un **orquestador always-on**: persona en `CLAUDE.md`/`AGENTS.md`
@@ -167,6 +168,7 @@ Claude Code y opencode (perfiles de permisos para ambos en
 | Histórico aislado y memoria de equipo | [docs/team-history.md](docs/team-history.md) |
 | Desplegar Engram Cloud (VPS) | [docs/deploy-cloud-vps.md](docs/deploy-cloud-vps.md) |
 | Desplegar Engram Cloud (Google Cloud) | [docs/deploy-cloud-gcloud.md](docs/deploy-cloud-gcloud.md) |
+| Integración con Obsidian | [docs/obsidian-integration.md](docs/obsidian-integration.md) |
 | Skill bootstrap | [skill/SKILL.md](skill/SKILL.md) |
 | Calibración de testing + TDD | [skill/references/calibration-blueprint.md](skill/references/calibration-blueprint.md) |
 | Contrato y versión de `cdk` | [skill/references/cdk-contract.md](skill/references/cdk-contract.md) |

package/cli/bin/ozali.mjs

@@ -3,7 +3,7 @@
 // Seguridad: sin dependencias ni scripts de instalación. Ejecuta seguro con
 // `pnpm dlx ozali` o `npx --ignore-scripts ozali`. Ver docs/security.md.
 import { c, err, pkgVersion } from "../lib/util.mjs";
-import { init, doctor, update, sync, audit, cloud, workspace } from "../lib/commands.mjs";
+import { init, doctor, update, sync, audit, cloud, workspace, installEngramCmd } from "../lib/commands.mjs";
 
 const HELP = `
 ${c.bold("ozali")} ${c.dim("v" + pkgVersion())} — bootstrap de IA por equipo (TDD/SDD + memoria Engram)
@@ -14,6 +14,9 @@ ${c.bold("Uso:")}
 ${c.bold("Comandos:")}
   init      Detecta el agente (Claude Code/opencode), instala las skills ozali y
             ozali-commit, aísla el histórico, configura Engram y el repo de conocimiento.
+  install-engram
+            Instala (o reinstala) Engram bajo demanda, registra su MCP en el agente
+            y activa modo hybrid. Úsalo cuando saltaste la instalación en init.
   workspace Multi-repo: escanea los repos de la carpeta raíz, remedia los que no tienen
             ozali init, guía la calibración y escribe la config para trabajar en conjunto.
             Con --doctor / --update opera sobre TODOS los repos miembros desde la raíz.
@@ -63,6 +66,8 @@ function parseArgs(argv) {
     else if (a === "--import") opts.import = true;
     else if (a === "--push") opts.push = true;
     else if (a === "--cloud") opts.cloud = true;
+    else if (a === "--obsidian") opts.obsidian = true;
+    else if (a === "--force") opts.force = true;
     else if (a === "--no-engram") opts.noEngram = true;
     else if (a === "--no-trust") opts.noTrust = true;
     else if (a === "--no-jarvis") opts.noJarvis = true;
@@ -100,10 +105,11 @@ async function main() {
     case "init": return await init(cwd, opts);
     case "workspace": return await workspace(cwd, opts);
     case "doctor": return doctor(cwd);
-    case "update": return update(cwd, opts);
-    case "sync": return sync(cwd, opts);
+    case "update": return await update(cwd, opts);
+    case "sync": return await sync(cwd, opts);
     case "audit": return await audit(cwd, opts);
     case "cloud": return await cloud(cwd, opts);
+    case "install-engram": return await installEngramCmd(cwd, opts);
     default:
       err(`comando desconocido "${cmd}". Usa ${c.bold("ozali --help")}.`);
       return 1;

package/cli/lib/commands.mjs

@@ -7,6 +7,7 @@ import {
   SKILL_SRC, COMMIT_SKILL_SRC, TEMPLATES_SRC, exists, ensureDir, copyDir, readJSON, writeJSON,
   ensureGitignore, tryExec, spawnCmd, which, engramAssetName, pickEngramAsset,
   projectName, pkgVersion, DEFAULT_KNOWLEDGE, HOME, openURL, gitInfo,
+  toPortablePath, fromPortablePath,
 } from "./util.mjs";
 import { detectAll, detectWorkspace, detectReferences } from "./detect.mjs";
 import { ask, confirm, select } from "./prompt.mjs";
@@ -115,7 +116,8 @@ export async function init(cwd, opts) {
   ], 0);
 
   // Repo de conocimiento (histórico aislado)
-  const knowledgeRepo = opts.knowledgeRepo || await ask("Ruta del repo de conocimiento (histórico aislado)", DEFAULT_KNOWLEDGE);
+  const knowledgeRepoRaw = opts.knowledgeRepo || await ask("Ruta del repo de conocimiento (histórico aislado)", DEFAULT_KNOWLEDGE);
+  const knowledgeRepo = fromPortablePath(knowledgeRepoRaw, cwd);
 
   // Engram
   let memoryMode = "docs";
@@ -124,6 +126,24 @@ export async function init(cwd, opts) {
   } else if (env.engram.available) {
     memoryMode = "hybrid";
     ok(`Engram disponible (${env.engram.bin}). Modo de memoria: ${c.bold("hybrid")} (docs + Engram).`);
+    // Verificar si hay versión nueva con cooldown de seguridad
+    const versionCheck = checkEngramVersion();
+    if (versionCheck && versionCheck.canUpgrade) {
+      warn(`Hay una nueva versión de Engram: ${c.bold(versionCheck.latest)} (tienes ${versionCheck.current}).`);
+      if (await confirm("¿Actualizar Engram ahora?", false)) {
+        info("Actualizando Engram…");
+        if (process.platform === "darwin" && which("brew")) {
+          spawnCmd("brew", ["upgrade", "gentleman-programming/tap/engram"]);
+        } else if (which("go")) {
+          spawnCmd("go", ["install", "github.com/Gentleman-Programming/engram/cmd/engram@latest"]);
+        } else {
+          warn("No se puede auto-actualizar sin Homebrew (macOS) o Go. Descarga manual:");
+          info("  " + c.cyan(versionCheck.url));
+        }
+      }
+    } else if (versionCheck && versionCheck.cooldown) {
+      info(`Engram ${c.bold(versionCheck.latest)} está disponible pero aún en cooldown de seguridad (24h). Se activará el ${new Date(new Date(versionCheck.publishedAt).getTime() + 24*60*60*1000).toLocaleDateString()}.`);
+    }
   } else {
     warn("Engram no está instalado.");
     // --dry-run no instala; --yes usa el default (sí); interactivo pregunta.
@@ -155,6 +175,23 @@ export async function init(cwd, opts) {
     }
   }
 
+  // Obsidian (opt-in) — ofrecer instalación si no detectado
+  if (!env.obsidian.installed) {
+    warn("Obsidian no detectado. Es el visualizador recomendado para el vault de conocimiento.");
+    if (!opts.dryRun) {
+      const installObsidian = opts.yes ? false : await confirm("¿Abrir la página de descarga de Obsidian?", false);
+      if (installObsidian) {
+        const url = process.platform === "darwin" ? "https://obsidian.md/download"
+          : process.platform === "win32" ? "https://obsidian.md/download"
+          : "https://obsidian.md/download";
+        openURL(url);
+        info("Descarga e instala Obsidian, luego corre " + c.bold("ozali sync --obsidian") + " para generar el vault.");
+      }
+    }
+  } else {
+    ok(`Obsidian detectado (${c.dim(env.obsidian.path)}).`);
+  }
+
   // Engram Cloud (opt-in) — réplica de equipo además del git-sync. Solo si Engram quedó disponible.
   let cloud = { enabled: false };
   if (memoryMode === "hybrid" && !opts.dryRun) {
@@ -220,7 +257,9 @@ export async function init(cwd, opts) {
 
   // 5) config local (gitignored)
   const config = {
-    version: pkgVersion(), agent, scope, knowledgeRepo, memoryMode, cloud,
+    version: pkgVersion(), agent, scope,
+    knowledgeRepo: toPortablePath(knowledgeRepo, cwd),
+    memoryMode, cloud,
     project: projectName(cwd), createdAt: new Date().toISOString(),
   };
   writeJSON(CONFIG_PATH(cwd), config);
@@ -244,6 +283,53 @@ export async function init(cwd, opts) {
   return 0;
 }
 
+/**
+ * Consulta la API de releases de Engram y compara con la versión instalada.
+ * Si hay una versión estable más reciente cuyo release tenga >24h de antigüedad,
+ * advierte al usuario y ofrece upgrade. Si la versión nueva tiene <24h, ignora
+ * (cooldown de seguridad contra supply-chain attacks).
+ * Devuelve { current, latest, url, canUpgrade } o null si no hay info.
+ */
+function checkEngramVersion() {
+  const currentRaw = tryExec("engram", ["version"]);
+  if (!currentRaw) return null;
+  const current = currentRaw.trim().replace(/^engram\s+/, "");
+  const raw = fetchText(ENGRAM_RELEASES_LIST);
+  if (!raw) return null;
+  let releases;
+  try { releases = JSON.parse(raw); } catch { return null; }
+  if (!Array.isArray(releases)) return null;
+  const now = Date.now();
+  const COOLDOWN_MS = 24 * 60 * 60 * 1000;
+  for (const r of releases) {
+    if (!r || r.draft || r.prerelease) continue;
+    const m = /^v(\d+\.\d+\.\d+)$/.exec(r.tag_name || "");
+    if (!m) continue;
+    const latest = m[1];
+    if (compareSemver(latest, current) <= 0) break; // no hay nada más nuevo
+    const published = r.published_at ? new Date(r.published_at).getTime() : 0;
+    if (!published || now - published < COOLDOWN_MS) {
+      // Versión muy reciente — mostrar como disponible pero con cooldown activo
+      return { current, latest, url: r.html_url, canUpgrade: false, cooldown: true, publishedAt: r.published_at };
+    }
+    // Versión estable con cooldown cumplido
+    const asset = pickEngramAsset([r], process.platform, process.arch);
+    return { current, latest, url: asset ? asset.url : r.html_url, canUpgrade: true, cooldown: false, publishedAt: r.published_at };
+  }
+  return { current, latest: current, canUpgrade: false };
+}
+
+/** Comparación semver simple: devuelve >0 si a>b, <0 si a<b, 0 si iguales. */
+function compareSemver(a, b) {
+  const pa = a.split(".").map((n) => parseInt(n, 10));
+  const pb = b.split(".").map((n) => parseInt(n, 10));
+  for (let i = 0; i < 3; i++) {
+    const na = pa[i] || 0, nb = pb[i] || 0;
+    if (na !== nb) return na - nb;
+  }
+  return 0;
+}
+
 /**
  * Instala Engram con la mejor ruta disponible para el SO actual.
  * Linux: binario precompilado (auto-descarga, sin toolchain) con brew/go como alternativas.
@@ -795,7 +881,7 @@ export async function workspace(cwd, opts = {}) {
 
   // Modos batch (Track 1): operan sobre los miembros del workspace ya existente y salen.
   if (opts.wsDoctor) return workspaceDoctor(ws.members);
-  if (opts.wsUpdate) return workspaceUpdate(ws.members, opts);
+  if (opts.wsUpdate) return await workspaceUpdate(ws.members, opts);
 
   // Fase B — remediación de los que no tienen ozali init
   const missing = ws.members.filter((m) => m.status === "missing-init");
@@ -807,7 +893,7 @@ export async function workspace(cwd, opts = {}) {
     const shared = {
       agent: opts.agent || (base && base.agent),
       scope: opts.scope || (base && base.scope),
-      knowledgeRepo: opts.knowledgeRepo || (base && base.knowledgeRepo),
+      knowledgeRepo: fromPortablePath(opts.knowledgeRepo || (base && base.knowledgeRepo), root),
     };
     for (const m of missing) {
       const go = opts.yes ? true : await confirm(`¿Correr ${c.bold("ozali init")} en ${c.bold(m.dir)}?`, true);
@@ -888,7 +974,7 @@ function workspaceDoctor(members) {
 }
 
 /** Track 1 — update de todos los miembros ozali (skills/permisos/jarvis) + resumen. */
-function workspaceUpdate(members, opts) {
+async function workspaceUpdate(members, opts) {
   const results = [];
   let failed = 0;
   for (const m of members) {
@@ -899,7 +985,7 @@ function workspaceUpdate(members, opts) {
       results.push({ dir: m.dir, mark: c.yellow("—"), note: "sin init (saltado)" });
       continue;
     }
-    const code = update(m.path, opts);
+    const code = await update(m.path, opts);
     if (code !== 0) failed++;
     results.push({ dir: m.dir, mark: code === 0 ? c.green("✔") : c.yellow("✖"), note: code === 0 ? "actualizado" : "revisar" });
   }
@@ -956,7 +1042,10 @@ function writeWorkspaceManifest(root, members, references, opts) {
     version: pkgVersion(),
     root,
     agent,
-    knowledgeRepo: opts.knowledgeRepo || existing.knowledgeRepo || base.knowledgeRepo || DEFAULT_KNOWLEDGE,
+    knowledgeRepo: toPortablePath(
+      opts.knowledgeRepo || existing.knowledgeRepo || base.knowledgeRepo || DEFAULT_KNOWLEDGE,
+      root
+    ),
     cloud: base.cloud || existing.cloud || { enabled: false },
     members: members.map((m) => ({ path: m.dir, project: m.project, status: m.status, sot: m.sot.found ? m.sot.variant : null })),
     references: references.map((e) => ({ from: e.fromDir, to: e.toDir, kind: e.kind })),
@@ -1056,7 +1145,9 @@ export function doctor(cwd) {
        cloudMeta && cloudMeta.dashboard ? c.cyan(cloudMeta.dashboard) : ""].filter(Boolean).join(" · ")
     : "off (opt-in, git-sync activo)";
   add("Engram Cloud", true, cloudDetail);
-  add("Repo de conocimiento", !!(cfg && cfg.knowledgeRepo && exists(cfg.knowledgeRepo)), cfg ? cfg.knowledgeRepo : "sin configurar (ozali init)");
+  const kRepoPortable = cfg && cfg.knowledgeRepo;
+  const kRepoResolved = kRepoPortable ? fromPortablePath(kRepoPortable, cwd) : null;
+  add("Repo de conocimiento", !!(kRepoResolved && exists(kRepoResolved)), kRepoResolved || "sin configurar (ozali init)");
 
   // Strict TDD (de la fuente de verdad)
   const tdd = readStrictTdd(cwd, env.sot);
@@ -1166,7 +1257,7 @@ function readStrictTdd(cwd, sot) {
 // references), los perfiles de permisos y **crea/refresca ozali-jarvis** (clave para repos
 // inicializados antes de 0.4.0). La skill `cdk` la regenera el AGENTE (no el CLI): se detecta
 // y se guía la regeneración.
-export function update(cwd, opts = {}) {
+export async function update(cwd, opts = {}) {
   step("ozali update — actualizar la instalación al paquete actual");
   const env = detectAll(cwd);
   const cfgPath = CONFIG_PATH(cwd);
@@ -1232,6 +1323,37 @@ export function update(cwd, opts = {}) {
     info("cdk aún no generada en este repo. Corre la skill " + c.bold("ozali") + " en tu agente para crearla.");
   }
 
+  // 4.5) Engram version check (cooldown 24h)
+  if (env.engram.available) {
+    const versionCheck = checkEngramVersion();
+    if (versionCheck && versionCheck.canUpgrade) {
+      warn(`Hay una nueva versión de Engram: ${c.bold(versionCheck.latest)} (tienes ${versionCheck.current}).`);
+      if (await confirm("¿Actualizar Engram ahora?", false)) {
+        info("Actualizando Engram…");
+        if (process.platform === "darwin" && which("brew")) {
+          spawnCmd("brew", ["upgrade", "gentleman-programming/tap/engram"]);
+        } else if (which("go")) {
+          spawnCmd("go", ["install", "github.com/Gentleman-Programming/engram/cmd/engram@latest"]);
+        } else {
+          warn("No se puede auto-actualizar sin Homebrew (macOS) o Go. Descarga manual:");
+          info("  " + c.cyan(versionCheck.url));
+        }
+      }
+    } else if (versionCheck && versionCheck.cooldown) {
+      info(`Engram ${c.bold(versionCheck.latest)} está disponible pero aún en cooldown de seguridad (24h). Se activará el ${new Date(new Date(versionCheck.publishedAt).getTime() + 24*60*60*1000).toLocaleDateString()}.`);
+    }
+  }
+
+  // 4.6) Obsidian check
+  if (!env.obsidian.installed) {
+    warn("Obsidian no detectado. Es el visualizador recomendado para el vault de conocimiento.");
+    const installObsidian = opts.yes ? false : await confirm("¿Abrir la página de descarga de Obsidian?", false);
+    if (installObsidian) {
+      openURL("https://obsidian.md/download");
+      info("Descarga e instala Obsidian, luego corre " + c.bold("ozali sync --obsidian") + " para generar el vault.");
+    }
+  }
+
   // 5) versión del config
   if (cfg) { cfg.version = pkgVersion(); cfg.updatedAt = new Date().toISOString(); writeJSON(cfgPath, cfg); }
   ok(`Instalación al día con ozali v${pkgVersion()}.`);
@@ -1273,12 +1395,89 @@ function cdkCanonicalVersion() {
   }
 }
 
+// =========================================================== install-engram ===
+export async function installEngramCmd(cwd, opts) {
+  step("ozali install-engram — instalar o reparar Engram bajo demanda");
+  const env = detectAll(cwd);
+  const cfg = readJSON(CONFIG_PATH(cwd));
+  let needsInstall = !env.engram.available;
+
+  if (env.engram.available) {
+    const online = tryExec("engram", ["doctor"], { cwd }) !== null;
+    if (online && !opts.force) {
+      ok(`Engram ya está instalado y responde (${env.engram.bin}).`);
+      info("Usa --force si quieres forzar una reinstalación.");
+    } else if (online && opts.force) {
+      warn("Forzando reinstalación de Engram (--force)…");
+      needsInstall = true;
+    } else {
+      warn("Engram está en PATH pero no responde (engram doctor falló). Reinstalando…");
+      needsInstall = true;
+    }
+  }
+
+  if (needsInstall) {
+    if (opts.dryRun) {
+      info("(dry-run) Aquí instalaría Engram.");
+      return 0;
+    }
+    const installed = installEngram();
+    if (!installed) {
+      warn("No se pudo instalar Engram automáticamente.");
+      printEngramManualInstructions(cfg?.agent || "both");
+      return 1;
+    }
+  }
+
+  // Configurar agente MCP
+  let agent = opts.agent || (cfg && cfg.agent);
+  if (!agent && !opts.yes) {
+    agent = await select("¿Para qué agente configuro Engram?", [
+      { value: "claude-code", label: "Claude Code" },
+      { value: "opencode", label: "opencode" },
+      { value: "both", label: "Ambos" },
+    ], 2);
+  } else if (!agent) {
+    agent = "both";
+  }
+
+  if (agent === "claude-code" || agent === "both") {
+    info("Registrando MCP en Claude Code…");
+    spawnCmd("engram", ["setup", "claude-code"]);
+  }
+  if (agent === "opencode" || agent === "both") {
+    info("Registrando MCP en opencode…");
+    spawnCmd("engram", ["setup", "opencode"]);
+  }
+
+  // Actualizar config de ozali si existe
+  if (cfg) {
+    let wrote = false;
+    if (cfg.memoryMode === "docs") {
+      cfg.memoryMode = "hybrid";
+      wrote = true;
+      ok("Modo de memoria actualizado a " + c.bold("hybrid") + " en .ozali/config.json.");
+    }
+    if (!cfg.agent) {
+      cfg.agent = agent;
+      wrote = true;
+    }
+    if (wrote) writeJSON(CONFIG_PATH(cwd), cfg);
+  } else {
+    warn("No hay configuración de ozali en esta ruta (corre " + c.bold("ozali init") + " para completar el setup).");
+    info("Engram quedó instalado; solo falta el config de ozali para integrarlo al flujo.");
+  }
+
+  ok("Engram listo. Reinicia tu agente para que cargue el servidor MCP de Engram.");
+  return 0;
+}
+
 // ============================================================= sync ===========
-export function sync(cwd, opts) {
+export async function sync(cwd, opts) {
   step(`ozali sync${opts.import ? " --import" : ""}${opts.cloud ? " --cloud" : ""} — histórico ↔ repo de conocimiento`);
   const cfg = readJSON(CONFIG_PATH(cwd));
   if (!cfg || !cfg.knowledgeRepo) { warn("Sin repo de conocimiento configurado. Corre " + c.bold("ozali init") + "."); return 1; }
-  const kRepo = cfg.knowledgeRepo;
+  const kRepo = fromPortablePath(cfg.knowledgeRepo, cwd);
   if (!exists(kRepo)) { err(`El repo de conocimiento no existe: ${kRepo}`); return 1; }
   const project = cfg.project || projectName(cwd);
   const projDir = path.join(kRepo, "projects", project);
@@ -1383,6 +1582,16 @@ export function sync(cwd, opts) {
   if (exists(docsLocal)) { copyDir(docsLocal, path.join(projDir, "docs")); ok(`Docs copiados a projects/${project}/docs/.`); }
   else info("No hay .ozali/docs/ que sincronizar todavía.");
 
+  // 2.5) Obsidian vault export
+  const vaultPath = path.join(kRepo, "obsidian");
+  if (opts.obsidian) {
+    await exportObsidianVault(kRepo, project, vaultPath);
+  } else if (exists(vaultPath) && !opts.yes) {
+    if (await confirm("¿Exportar memoria a Obsidian vault?", true)) {
+      await exportObsidianVault(kRepo, project, vaultPath);
+    }
+  }
+
   // 3) commit (push solo si hay remoto)
   if (exists(path.join(kRepo, ".git"))) {
     tryExec("git", ["add", "-A"], { cwd: kRepo });
@@ -1400,6 +1609,57 @@ export function sync(cwd, opts) {
   return 0;
 }
 
+/**
+ * Exporta la memoria de Engram a un vault de Obsidian compatible.
+ * 1) Copia templates base si no existen.
+ * 2) Genera MOCs dinámicos (proyectos) desde knowledgeRepo/projects/.
+ * 3) Ejecuta `engram obsidian-export`.
+ */
+async function exportObsidianVault(kRepo, project, vaultPath) {
+  if (!tryExec("engram", ["--version"])) {
+    warn("Engram no está disponible. No se puede exportar a Obsidian.");
+    return;
+  }
+  ensureDir(vaultPath);
+  // 1) Templates base
+  const templateDir = path.join(TEMPLATES_SRC, "obsidian-vault");
+  if (exists(templateDir)) {
+    for (const entry of fs.readdirSync(templateDir, { withFileTypes: true })) {
+      const src = path.join(templateDir, entry.name);
+      const dst = path.join(vaultPath, entry.name);
+      if (entry.isDirectory()) {
+        if (!exists(dst)) copyDir(src, dst);
+      } else if (!exists(dst)) {
+        fs.copyFileSync(src, dst);
+      }
+    }
+  }
+  // 2) MOC dinámico — Proyectos
+  const projectsDir = path.join(kRepo, "projects");
+  const projectsMoc = path.join(vaultPath, "MOCs", "Proyectos.md");
+  if (exists(projectsDir)) {
+    const projects = [];
+    for (const entry of fs.readdirSync(projectsDir, { withFileTypes: true })) {
+      if (entry.isDirectory()) projects.push(entry.name);
+    }
+    const list = projects.map((p) => `- [[${p}]] — proyecto activo`).join("\n");
+    const body = fs.readFileSync(projectsMoc, "utf8");
+    const updated = body.replace(
+      /<!-- PROJECTS_START -->[\s\S]*?<!-- PROJECTS_END -->/,
+      `<!-- PROJECTS_START -->\n${list || "- Sin proyectos activos todavía."}\n<!-- PROJECTS_END -->`
+    );
+    fs.writeFileSync(projectsMoc, updated);
+  }
+  // 3) Export Engram
+  info("Exportando memoria a Obsidian vault…");
+  const out = tryExec("engram", ["obsidian-export", "--vault", vaultPath, "--project", project, "--graph-config", "preserve"]);
+  if (out !== null) {
+    ok("Obsidian vault actualizado.");
+  } else {
+    warn("engram obsidian-export falló. Revisa que el vault esté cerrado en Obsidian.");
+  }
+}
+
 // ============================================================ audit ===========
 // Navega/audita la memoria de Engram: del proyecto actual o general (todos los
 // proyectos). Sin contexto de proyecto en la ruta → general. Sin Engram → audita

package/cli/lib/detect.mjs

@@ -47,6 +47,32 @@ export function detectEngram() {
   return { available: !!bin, bin: bin || null };
 }
 
+/** Detecta si Obsidian está instalado. Devuelve { installed, path } por SO. */
+export function detectObsidian() {
+  const plat = process.platform;
+  if (plat === "darwin") {
+    const appPaths = [
+      "/Applications/Obsidian.app",
+      path.join(HOME, "Applications", "Obsidian.app"),
+    ];
+    for (const p of appPaths) if (exists(p)) return { installed: true, path: p };
+    const bin = which("obsidian");
+    if (bin) return { installed: true, path: bin };
+  } else if (plat === "linux") {
+    const bin = which("obsidian");
+    if (bin) return { installed: true, path: bin };
+    const flatpak = path.join(HOME, ".var", "app", "md.obsidian.Obsidian");
+    if (exists(flatpak)) return { installed: true, path: flatpak };
+    const snap = "/snap/bin/obsidian";
+    if (exists(snap)) return { installed: true, path: snap };
+  } else if (plat === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || path.join(HOME, "AppData", "Local");
+    const exe = path.join(localAppData, "Obsidian", "Obsidian.exe");
+    if (exists(exe)) return { installed: true, path: exe };
+  }
+  return { installed: false, path: null };
+}
+
 /** Metadatos compartibles de Engram Cloud del proyecto (sin secretos). */
 export function detectCloud(cwd) {
   const metaPath = path.join(cwd, ".ozali", "cloud.json");
@@ -105,6 +131,7 @@ export function detectAll(cwd) {
     agents: detectAgents(cwd),
     skill: detectInstalledSkill(cwd),
     engram: detectEngram(),
+    obsidian: detectObsidian(),
     cloud: detectCloud(cwd),
     testing: detectTesting(cwd),
   };

package/cli/lib/util.mjs

@@ -193,5 +193,60 @@ export function nodeMajor() {
   return parseInt(process.versions.node.split(".")[0], 10);
 }
 
+// ---- rutas portables (cross-platform / cross-team) --------------------------
+
+/**
+ * Convierte un path absoluto a formato portable para guardar en config.json.
+ * Reglas (en orden de prioridad):
+ * 1. Si está bajo `os.homedir()`, reemplazar prefijo por `~`.
+ * 2. Si `base` (cwd del proyecto) está definido y el path está bajo `base`,
+ *    devolver relativo a `base`.
+ * 3. Dejar absoluto (legacy; emitir warning en el caller si es necesario).
+ */
+export function toPortablePath(absPath, base = null) {
+  if (!absPath) return absPath;
+  // Normalizar con realpath para resolver symlinks (macOS: /var → /private/var)
+  let normalized;
+  try { normalized = fs.realpathSync(absPath); } catch { normalized = path.resolve(absPath); }
+  const home = os.homedir();
+  // 1) home-relative → ~
+  if (home && (normalized === home || normalized.startsWith(home + path.sep))) {
+    return "~" + normalized.slice(home.length);
+  }
+  // 2) base-relative
+  if (base) {
+    let baseNorm;
+    try { baseNorm = fs.realpathSync(base); } catch { baseNorm = path.resolve(base); }
+    if (normalized.startsWith(baseNorm + path.sep)) {
+      return path.relative(baseNorm, normalized);
+    }
+  }
+  // 3) absoluto legacy
+  return normalized;
+}
+
+/**
+ * Expande un path portable a absoluto.
+ * Reglas:
+ * 1. Si empieza con `~`, expandir a `os.homedir()`.
+ * 2. Si es relativo, resolver contra `base` (cwd del proyecto).
+ * 3. Si ya es absoluto (legacy), devolver tal cual.
+ */
+export function fromPortablePath(portablePath, base = null) {
+  if (!portablePath) return portablePath;
+  // 1) expandir ~
+  if (portablePath.startsWith("~")) {
+    const home = os.homedir();
+    const rest = portablePath.slice(1);
+    return home + (rest.startsWith(path.sep) || rest === "" ? rest : path.sep + rest);
+  }
+  // 2) relativo → absoluto contra base
+  if (base && !path.isAbsolute(portablePath)) {
+    return path.resolve(base, portablePath);
+  }
+  // 3) absoluto legacy o ya resuelto
+  return path.resolve(portablePath);
+}
+
 export const HOME = os.homedir();
 export const DEFAULT_KNOWLEDGE = path.join(HOME, ".ozali", "knowledge");

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");
@@ -383,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/guia-de-uso.md

@@ -81,11 +81,11 @@ 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 install-engram` | Instala (o reinstala) Engram y registra su MCP cuando saltaste la instalación en `init`. |
 | `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. |
-| `ozali sync --import` | Baja lo que el equipo ya guardó. |
 | `ozali audit` | Navega/audita la memoria de Engram (qué se ha hecho). |
 
 ¿Algo no funciona? Corre **`ozali doctor`** primero: te dice qué falta y cómo arreglarlo.
@@ -146,8 +146,8 @@ no puede, te deja las instrucciones. Con Engram, tu agente **recuerda** decision
 convenciones — y los recupera en futuras sesiones.
 
 ¿No quieres Engram ahora? Pasa `--no-engram` y ozali arranca en modo `docs` (la memoria se queda en
-documentos legibles). Cuando quieras activarlo, instálalo y corre `ozali doctor`: el modo sube a
-`hybrid` solo.
+documentos legibles). Cuando quieras activarlo, corre `ozali install-engram` — lo instala, configura
+el MCP en tu agente y sube el modo a `hybrid` de una vez.
 
 Dos detalles si lo usas en equipo:
 

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ozali",
-  "version": "0.8.0",
+  "version": "0.10.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/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.

package/templates/obsidian-vault/README.md

@@ -0,0 +1,22 @@
+# Vault de Ozali — Memoria del Equipo
+
+Este vault contiene la memoria acumulada de los proyectos gestionados con ozali.
+Se actualiza automáticamente con `ozali sync --obsidian`.
+
+## 📁 Estructura
+
+- [[MOCs/Índice Global]] — Navegación principal
+- [[MOCs/Proyectos]] — Lista de proyectos activos
+- [[MOCs/Decisiones del Equipo]] — Decisiones de arquitectura y trade-offs
+- [[MOCs/Bugfixes Recientes]] — Correcciones que afectan a otros
+- [[MOCs/Métricas y Tokens]] — Uso de tokens y ahorro por recall
+- `Memoria/` — Exportación de Engram (decisiones, bugfixes, métricas)
+
+## 🔗 Fuentes de verdad (cerebros)
+
+Los documentos de arquitectura y reglas de cada proyecto viven en su repo:
+
+- Abre el workspace en tu editor para acceder al `AI.md` / `IA.md` de cada proyecto.
+
+> No edites los archivos en `Memoria/` manualmente — se regeneran automáticamente.
+> Usa `MOCs/` y `Daily/` para tus notas personales.