ozali 0.7.1 → 0.9.0

package/README.md

@@ -80,7 +80,10 @@ referencian entre sí, corre **una vez** en esa raíz:
 ```bash
 ozali workspace           # escanea repos hijos, remedia los que faltan y escribe la config conjunta
 ozali workspace --dry-run # solo muestra el inventario y el plan, sin escribir
+ozali workspace --yes     # no interactivo: acepta defaults y todas las referencias detectadas
 ozali workspace --depth 2 # busca repos hasta 2 niveles (para raíces con subcarpetas de grupo)
+ozali workspace --doctor  # health-check de TODOS los repos miembros + resumen (solo CLI)
+ozali workspace --update  # actualiza skills/permisos/jarvis de TODOS los repos miembros (solo CLI)
 ```
 
 Qué hace, en orden: (1) **escanea** los repos hijos y reporta su estado —`✔ listo`, `⚠ sin calibrar`
@@ -93,6 +96,13 @@ contigo; y (4) escribe la config para **trabajar en conjunto**:
 - `<carpeta>.code-workspace` — workspace multi-root que abre todos los repos juntos.
 - Orquestador **`ozali-workspace-jarvis`** en `CLAUDE.md`/`AGENTS.md` de la raíz: coordina los repos
   según el manifiesto y delega la ejecución en el `cdk` de cada uno.
+- La skill **`ozali`** en la raíz (`.claude/skills/ozali/`) para **calibrar los miembros desde el
+  workspace** (modo target), sin abrir cada proyecto.
+
+**Operar todo desde la raíz:** `ozali workspace --doctor` y `--update` corren el health-check y la
+actualización sobre **todos** los repos miembros (solo CLI). Y para calibrar los `⚠ sin calibrar`,
+abre el agente en la raíz y pídele a `ozali-workspace-jarvis` que *"calibre los repos pendientes"*: los
+recorre uno por uno (con su GATE) sin que cambies de proyecto.
 
 Es **idempotente**: re-córrelo cuando agregues repos o cambien las referencias. Detalle completo en
 [`docs/workspaces.md`](docs/workspaces.md).
@@ -152,10 +162,12 @@ Claude Code y opencode (perfiles de permisos para ambos en
 |---|---|
 | Guía de uso (usuarios generales) | [docs/guia-de-uso.md](docs/guia-de-uso.md) |
 | Uso previsto (modelo mental) | [docs/intended-usage.md](docs/intended-usage.md) |
+| Compilado y uso local (repo clonado) | [docs/compilado-local.md](docs/compilado-local.md) |
 | Seguridad del instalador (npx/pnpm) | [docs/security.md](docs/security.md) |
 | 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

@@ -16,6 +16,7 @@ ${c.bold("Comandos:")}
             ozali-commit, aísla el histórico, configura Engram y el repo de conocimiento.
   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.
   doctor    Health-check read-only del proyecto (fuente de verdad, Engram, versión de cdk, TDD…).
   update    Actualiza la instalación (skills ozali + ozali-commit + ozali-jarvis + permisos)
             al paquete y avisa si la skill cdk quedó desactualizada.
@@ -29,6 +30,8 @@ ${c.bold("Opciones comunes:")}
   --agent <a>          (init) claude-code | opencode | both.
   --scope <s>          (init) project | global.
   --depth <n>          (workspace) Niveles a escanear bajo la raíz (default 1).
+  --doctor             (workspace) Health-check de TODOS los repos miembros + resumen.
+  --update             (workspace) Actualiza (skills/permisos/jarvis) TODOS los repos miembros.
   --knowledge-repo <p> (init) Ruta del repo de conocimiento.
   --no-engram          (init) No usar Engram; arranca en modo docs.
   --no-trust           (init) No marcar el workspace como confiable en Claude Code.
@@ -60,6 +63,7 @@ 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 === "--no-engram") opts.noEngram = true;
     else if (a === "--no-trust") opts.noTrust = true;
     else if (a === "--no-jarvis") opts.noJarvis = true;
@@ -73,6 +77,8 @@ function parseArgs(argv) {
     else if (a === "--agent") opts.agent = argv[++i];
     else if (a === "--scope") opts.scope = argv[++i];
     else if (a === "--depth") opts.depth = argv[++i];
+    else if (a === "--doctor") opts.wsDoctor = true;
+    else if (a === "--update") opts.wsUpdate = true;
     else if (a === "--knowledge-repo") opts.knowledgeRepo = argv[++i];
     else if (a === "-h" || a === "--help") opts.help = true;
     else if (a === "-v" || a === "--version") opts.version = true;
@@ -95,8 +101,8 @@ 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);
     default:

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.
@@ -793,6 +879,10 @@ export async function workspace(cwd, opts = {}) {
   step("Repos detectados");
   printMembers(ws.members);
 
+  // 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 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");
   if (missing.length && opts.dryRun) {
@@ -803,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);
@@ -836,6 +926,7 @@ export async function workspace(cwd, opts = {}) {
   const agent = manifest.agent;
   if (agent === "claude-code" || agent === "both") {
     ensureWorkspaceJarvisClaudeCode(cwd);
+    ensureWorkspaceOzaliSkill(cwd); // Track 2: skill ozali en la raíz → calibrar miembros desde el workspace
     if (!opts.noTrust) await ensureClaudeWorkspaceTrust(cwd, opts);
   }
   if (agent === "opencode" || agent === "both") ensureWorkspaceJarvisOpencode(cwd);
@@ -849,11 +940,68 @@ export async function workspace(cwd, opts = {}) {
   step("Siguientes pasos");
   const wsFile = `${path.basename(cwd)}.code-workspace`;
   console.log(`  1. Abre el workspace en tu editor: ${c.bold(wsFile)} ${c.dim("(VSCode/Antigravity → Open Workspace).")}`);
-  if (needCal.length) console.log(`  2. Calibra los repos pendientes (${c.bold(needCal.map((m) => m.dir).join(", "))}) corriendo la skill ${c.bold("ozali")} en cada uno.`);
+  if (needCal.length) {
+    console.log(`  2. Calibra los pendientes (${c.bold(needCal.map((m) => m.dir).join(", "))}) ${c.dim("sin salir del workspace:")}`);
+    console.log(`     ${c.dim("abre el agente en la raíz y pide a")} ${c.bold("ozali-workspace-jarvis")} ${c.dim('que "calibre los repos pendientes"')}`);
+    console.log(`     ${c.dim("(usa la skill")} ${c.bold("ozali")} ${c.dim("en modo target, repo por repo con su GATE).")}`);
+  }
+  console.log(`  ${c.dim("• Salud de todos los repos:")}     ${c.bold("ozali workspace --doctor")}`);
+  console.log(`  ${c.dim("• Actualizar todos los repos:")}   ${c.bold("ozali workspace --update")}`);
   console.log(`  ${c.dim("Re-corre")} ${c.bold("ozali workspace")} ${c.dim("cuando agregues repos o cambien las referencias (es idempotente).")}`);
   return 0;
 }
 
+/** Track 1 — health-check de todos los miembros (doctor por repo) + resumen consolidado. */
+function workspaceDoctor(members) {
+  const results = [];
+  for (const m of members) {
+    console.log("");
+    console.log(c.bold(c.magenta(`── ${m.dir} ──`)));
+    if (m.status === "missing-init") {
+      warn(`Sin ozali init → córrelo (o re-corre ${c.bold("ozali workspace")}).`);
+      results.push({ dir: m.dir, ok: false, note: "sin init" });
+      continue;
+    }
+    const code = doctor(m.path);
+    results.push({ dir: m.dir, ok: code === 0, note: code === 0 ? "todo en orden" : "puntos a atender" });
+  }
+  step("Resumen del workspace");
+  const pad = Math.max(4, ...members.map((m) => m.dir.length));
+  for (const r of results) {
+    console.log(`  ${r.ok ? c.green("✔") : c.yellow("✖")} ${r.dir.padEnd(pad)}  ${c.dim(r.note)}`);
+  }
+  return results.every((r) => r.ok) ? 0 : 1;
+}
+
+/** Track 1 — update de todos los miembros ozali (skills/permisos/jarvis) + resumen. */
+async function workspaceUpdate(members, opts) {
+  const results = [];
+  let failed = 0;
+  for (const m of members) {
+    console.log("");
+    console.log(c.bold(c.magenta(`── ${m.dir} ──`)));
+    if (m.status === "missing-init") {
+      warn("Sin ozali init → nada que actualizar (córrelo primero).");
+      results.push({ dir: m.dir, mark: c.yellow("—"), note: "sin init (saltado)" });
+      continue;
+    }
+    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" });
+  }
+  step("Resumen del workspace");
+  const pad = Math.max(4, ...members.map((m) => m.dir.length));
+  for (const r of results) console.log(`  ${r.mark} ${r.dir.padEnd(pad)}  ${c.dim(r.note)}`);
+  info(`La skill ${c.bold("cdk")} la regenera el agente. Re-corre ${c.bold("ozali workspace")} para refrescar estados.`);
+  return failed > 0 ? 1 : 0;
+}
+
+/** Track 2 — instala la skill `ozali` en la raíz para calibrar miembros desde el workspace. */
+function ensureWorkspaceOzaliSkill(root) {
+  copyDir(SKILL_SRC, path.join(root, ".claude", "skills", "ozali"));
+  ok(`Skill ${c.bold("ozali")} instalada en la raíz (${c.bold(".claude/skills/ozali")}) para calibrar miembros desde el workspace.`);
+}
+
 /** Primer .ozali/config.json entre los miembros ya inicializados (para heredar defaults). */
 function inheritedConfig(members) {
   for (const m of members) {
@@ -894,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 })),
@@ -994,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);
@@ -1104,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);
@@ -1170,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()}.`);
@@ -1212,11 +1396,11 @@ function cdkCanonicalVersion() {
 }
 
 // ============================================================= 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);
@@ -1321,6 +1505,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 });
@@ -1338,6 +1532,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

@@ -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, readJSON, projectName, DEFAULT_KNOWLEDGE } from "./util.mjs";
+import { exists, which, gitInfo, tryExec, nodeMajor, HOME, readJSON, projectName, DEFAULT_KNOWLEDGE } from "./util.mjs";
 
 /** Variante de fuente de verdad: {found, doc, dir, variant} */
 export function detectSourceOfTruth(cwd) {
@@ -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),
   };
@@ -121,9 +148,21 @@ function isKnowledgeRepo(dir) {
   return d === k || d.startsWith(k + path.sep);
 }
 
+/**
+ * ¿`dir` es la RAÍZ de su propio repo git? No basta con estar dentro de un work tree
+ * (una subcarpeta de un repo también lo está): exigimos que el toplevel de git sea `dir`.
+ * Así, correr `ozali workspace` dentro de un repo NO trata sus subcarpetas como miembros.
+ */
+function isRepoRoot(dir) {
+  const top = tryExec("git", ["-C", dir, "rev-parse", "--show-toplevel"]);
+  if (!top) return false;
+  try { return fs.realpathSync(top) === fs.realpathSync(dir); } catch { return false; }
+}
+
 /**
  * Junta las rutas de repos git bajo `root` hasta `depth` niveles. Un directorio que
- * ES repo git se trata como hoja (no se desciende dentro). Salta ocultos/ignorados.
+ * ES la raíz de su propio repo git se trata como hoja (no se desciende dentro). Salta
+ * ocultos/ignorados.
  */
 function collectRepoDirs(root, depth, level = 1, acc = []) {
   let entries;
@@ -133,7 +172,7 @@ function collectRepoDirs(root, depth, level = 1, acc = []) {
     if (e.name.startsWith(".") || IGNORE_DIRS.has(e.name)) continue;
     const full = path.join(root, e.name);
     if (isKnowledgeRepo(full)) continue;
-    if (gitInfo(full).isRepo) { acc.push(full); continue; } // repo = hoja
+    if (isRepoRoot(full)) { acc.push(full); continue; } // repo propio = hoja
     if (level < depth) collectRepoDirs(full, depth, level + 1, acc);
   }
   return acc;

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");