ozali 0.6.1 → 0.7.0

package/README.md

@@ -60,6 +60,7 @@ git clone <repo> && node ozali/cli/bin/ozali.mjs init
 
 ```bash
 ozali init      # detecta agente, instala skills ozali + ozali-commit, aísla histórico, configura Engram
+ozali workspace # multi-repo: escanea la carpeta raíz, remedia init/calibración y cablea la config conjunta
 ozali doctor    # health-check read-only (fuente de verdad, Engram, Cloud, versión de cdk, Strict TDD…)
 ozali update    # actualiza skills ozali + ozali-commit + ozali-jarvis + permisos; avisa si cdk quedó atrás
 ozali sync      # lleva el histórico (docs + Engram) al repo de conocimiento de equipo
@@ -71,6 +72,31 @@ ozali audit     # navega/audita la memoria de Engram del proyecto (o general)
 `--tui` para el navegador interactivo, `--search "<texto>"` para buscar y `--general` para forzar el
 alcance. Sin Engram, audita el histórico local de `.ozali/docs/`.
 
+### Workspaces multi-repo
+
+Cuando abres en tu editor (VSCode, **Antigravity**) una **carpeta raíz con varios repos** que se
+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 --depth 2 # busca repos hasta 2 niveles (para raíces con subcarpetas de grupo)
+```
+
+Qué hace, en orden: (1) **escanea** los repos hijos y reporta su estado —`✔ listo`, `⚠ sin calibrar`
+(falta `cdk`) o `✖ sin init`—; (2) **remedia** con `ozali init` los que no lo tienen y te **guía** para
+calibrar (correr la skill `ozali` en cada repo — eso lo hace el agente, no el CLI); (3) **infiere las
+referencias** entre repos (dependencias npm cruzadas, submódulos git, `docker-compose`) y las confirma
+contigo; y (4) escribe la config para **trabajar en conjunto**:
+
+- `ozali-workspace.json` — manifiesto de miembros, estado y referencias.
+- `<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.
+
+Es **idempotente**: re-córrelo cuando agregues repos o cambien las referencias. Detalle completo en
+[`docs/workspaces.md`](docs/workspaces.md).
+
 ### Actualizar a una versión nueva
 
 ```bash

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 } from "../lib/commands.mjs";
+import { init, doctor, update, sync, audit, cloud, workspace } 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,8 @@ ${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.
+  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.
   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.
@@ -26,6 +28,7 @@ ${c.bold("Opciones comunes:")}
   --dry-run            (init) Muestra el plan sin escribir nada.
   --agent <a>          (init) claude-code | opencode | both.
   --scope <s>          (init) project | global.
+  --depth <n>          (workspace) Niveles a escanear bajo la raíz (default 1).
   --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.
@@ -69,6 +72,7 @@ function parseArgs(argv) {
     else if (a === "--stats") opts.stats = true;
     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 === "--knowledge-repo") opts.knowledgeRepo = argv[++i];
     else if (a === "-h" || a === "--help") opts.help = true;
     else if (a === "-v" || a === "--version") opts.version = true;
@@ -89,6 +93,7 @@ async function main() {
   console.log(`${c.bold("ozali")} ${c.dim("v" + pkgVersion())}`);
   switch (cmd) {
     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);

package/cli/lib/commands.mjs

@@ -6,9 +6,9 @@ import {
   c, ok, warn, err, info, step,
   SKILL_SRC, COMMIT_SKILL_SRC, TEMPLATES_SRC, exists, ensureDir, copyDir, readJSON, writeJSON,
   ensureGitignore, tryExec, spawnCmd, which, engramAssetName,
-  projectName, pkgVersion, DEFAULT_KNOWLEDGE, HOME, openURL,
+  projectName, pkgVersion, DEFAULT_KNOWLEDGE, HOME, openURL, gitInfo,
 } from "./util.mjs";
-import { detectAll } from "./detect.mjs";
+import { detectAll, detectWorkspace, detectReferences } from "./detect.mjs";
 import { ask, confirm, select } from "./prompt.mjs";
 
 const CONFIG_PATH = (cwd) => path.join(cwd, ".ozali", "config.json");
@@ -623,17 +623,17 @@ const JARVIS_BEGIN = "<!-- ozali-jarvis:start -->";
 const JARVIS_END = "<!-- ozali-jarvis:end -->";
 
 /** Cuerpo del bloque jarvis para CLAUDE.md / AGENTS.md (sin el frontmatter del template). */
-function jarvisPersonaBody() {
-  const tpl = fs.readFileSync(path.join(TEMPLATES_SRC, "ozali-jarvis.md"), "utf8");
+function jarvisPersonaBody(tpl = "ozali-jarvis.md") {
+  const raw = fs.readFileSync(path.join(TEMPLATES_SRC, tpl), "utf8");
   // Quita el frontmatter YAML (--- ... ---) y deja el cuerpo markdown.
-  return tpl.replace(/^---[\s\S]*?---\s*/, "").trim();
+  return raw.replace(/^---[\s\S]*?---\s*/, "").trim();
 }
 
 /** Inserta/actualiza un bloque marcado en un archivo markdown (idempotente). */
-function upsertMarkedBlock(file, body) {
-  const block = `${JARVIS_BEGIN}\n${body}\n${JARVIS_END}`;
+function upsertMarkedBlock(file, body, begin = JARVIS_BEGIN, end = JARVIS_END) {
+  const block = `${begin}\n${body}\n${end}`;
   let txt = exists(file) ? fs.readFileSync(file, "utf8") : "";
-  const re = new RegExp(`${JARVIS_BEGIN}[\\s\\S]*?${JARVIS_END}`);
+  const re = new RegExp(`${begin}[\\s\\S]*?${end}`);
   let changed;
   if (re.test(txt)) {
     const next = txt.replace(re, block);
@@ -757,6 +757,193 @@ function ensureOpencodeProfile(cwd) {
   ok(`Perfil base de permisos de opencode en ${c.bold("opencode.json")} (lectura+comandos libres, ediciones confirman).`);
 }
 
+// ========================================================= workspace =========
+// Configuración multi-repo: escanea repos hijos de una carpeta raíz, remedia los
+// que no tienen ozali init, guía la calibración (que hace el agente), y escribe
+// 3 capas de config: manifiesto + .code-workspace + orquestador de workspace.
+const WS_JARVIS_BEGIN = "<!-- ozali-workspace-jarvis:start -->";
+const WS_JARVIS_END = "<!-- ozali-workspace-jarvis:end -->";
+const WS_MANIFEST = (root) => path.join(root, "ozali-workspace.json");
+
+const STATUS_LABEL = {
+  "ready": () => c.green("✔ listo"),
+  "needs-calibration": () => c.yellow("⚠ sin calibrar (falta cdk)"),
+  "missing-init": () => c.red("✖ sin init"),
+};
+
+export async function workspace(cwd, opts = {}) {
+  step("ozali workspace — configuración multi-repo");
+  const depth = opts.depth ? (parseInt(opts.depth, 10) || 1) : 1;
+
+  // Fase A — escaneo (read-only)
+  let ws = detectWorkspace(cwd, { depth });
+  if (ws.members.length === 0) {
+    warn("No encontré repositorios git como hijos de esta carpeta.");
+    info("Corre " + c.bold("ozali workspace") + " desde la carpeta que agrupa tus repos (o usa " + c.bold("--depth 2") + ").");
+    return 1;
+  }
+  step("Repos detectados");
+  printMembers(ws.members);
+
+  // 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) {
+    info(`(dry-run) Aquí correría ${c.bold("ozali init")} en: ${c.bold(missing.map((m) => m.dir).join(", "))}.`);
+  } else if (missing.length) {
+    step("Repos sin ozali init");
+    const base = inheritedConfig(ws.members);
+    const shared = {
+      agent: opts.agent || (base && base.agent),
+      scope: opts.scope || (base && base.scope),
+      knowledgeRepo: opts.knowledgeRepo || (base && base.knowledgeRepo),
+    };
+    for (const m of missing) {
+      const go = opts.yes ? true : await confirm(`¿Correr ${c.bold("ozali init")} en ${c.bold(m.dir)}?`, true);
+      if (!go) { info(`Saltado: ${m.dir}.`); continue; }
+      await init(m.path, { ...opts, ...shared });
+    }
+    ws = detectWorkspace(cwd, { depth }); // re-escanea tras remediar
+  }
+
+  // Guía de calibración (el CLI NO puede calibrar; lo hace el agente)
+  const needCal = ws.members.filter((m) => m.status === "needs-calibration");
+  if (needCal.length) {
+    step("Calibración pendiente (la hace tu agente, no el CLI)");
+    warn(`${needCal.length} repo(s) tienen ozali init pero aún no generan su skill ${c.bold("cdk")}.`);
+    for (const m of needCal) {
+      console.log(`  • ${c.bold(m.dir)} → abre el repo en tu agente y corre la skill ${c.bold("ozali")} (${c.dim('"diagnostica el proyecto"')}).`);
+    }
+  }
+
+  // Fase C — referencias entre repos (auto-detección + confirmación)
+  const references = await confirmReferences(detectReferences(ws.members), opts);
+
+  if (opts.dryRun) { warn("--dry-run: no escribo nada. Plan mostrado arriba."); return 0; }
+
+  // Fase D — escritura de la configuración del workspace
+  step("Escribiendo configuración del workspace");
+  const manifest = writeWorkspaceManifest(cwd, ws.members, references, opts);
+  writeCodeWorkspace(cwd, ws.members);
+
+  const agent = manifest.agent;
+  if (agent === "claude-code" || agent === "both") {
+    ensureWorkspaceJarvisClaudeCode(cwd);
+    if (!opts.noTrust) await ensureClaudeWorkspaceTrust(cwd, opts);
+  }
+  if (agent === "opencode" || agent === "both") ensureWorkspaceJarvisOpencode(cwd);
+
+  if (gitInfo(cwd).isRepo) {
+    const { added } = ensureGitignore(cwd, [".claude/", ".engram/", ".ozali/"]);
+    if (added.length) ok(`.gitignore de la raíz actualizado: ${added.join(", ")}.`);
+  }
+
+  // Siguientes pasos
+  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.`);
+  console.log(`  ${c.dim("Re-corre")} ${c.bold("ozali workspace")} ${c.dim("cuando agregues repos o cambien las referencias (es idempotente).")}`);
+  return 0;
+}
+
+/** Primer .ozali/config.json entre los miembros ya inicializados (para heredar defaults). */
+function inheritedConfig(members) {
+  for (const m of members) {
+    const cfg = readJSON(path.join(m.path, ".ozali", "config.json"));
+    if (cfg) return cfg;
+  }
+  return null;
+}
+
+function printMembers(members) {
+  const pad = Math.max(4, ...members.map((m) => m.dir.length));
+  for (const m of members) {
+    const label = (STATUS_LABEL[m.status] || (() => m.status))();
+    const sot = m.sot.found ? c.dim(`sot:${m.sot.variant}`) : c.dim("sot:—");
+    const eng = m.engramProject ? c.dim(` engram:${m.engramProject}`) : "";
+    console.log(`  ${c.bold(m.dir.padEnd(pad))}  ${label}  ${sot}${eng}`);
+  }
+}
+
+async function confirmReferences(detected, opts) {
+  if (detected.length === 0) { info("No detecté referencias automáticas entre los repos."); return []; }
+  step("Referencias detectadas entre repos");
+  for (const e of detected) console.log(`  • ${c.bold(e.fromDir)} → ${c.bold(e.toDir)} ${c.dim("(" + e.kind + ")")}`);
+  if (opts.yes) return detected;
+  if (await confirm(`¿Registrar las ${detected.length} referencias detectadas?`, true)) return detected;
+  const kept = [];
+  for (const e of detected) {
+    if (await confirm(`  ¿Registrar ${e.fromDir} → ${e.toDir} (${e.kind})?`, true)) kept.push(e);
+  }
+  return kept;
+}
+
+function writeWorkspaceManifest(root, members, references, opts) {
+  const existing = readJSON(WS_MANIFEST(root)) || {};
+  const base = inheritedConfig(members) || {};
+  const agent = opts.agent || existing.agent || base.agent || "claude-code";
+  const manifest = {
+    version: pkgVersion(),
+    root,
+    agent,
+    knowledgeRepo: opts.knowledgeRepo || existing.knowledgeRepo || base.knowledgeRepo || DEFAULT_KNOWLEDGE,
+    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 })),
+    createdAt: existing.createdAt || new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+  writeJSON(WS_MANIFEST(root), manifest);
+  ok(`Manifiesto escrito en ${c.bold("ozali-workspace.json")} (${members.length} repos, ${references.length} referencias).`);
+  return manifest;
+}
+
+function writeCodeWorkspace(root, members) {
+  const file = path.join(root, `${path.basename(root)}.code-workspace`);
+  const existing = readJSON(file) || {};
+  const folders = Array.isArray(existing.folders) ? existing.folders.slice() : [];
+  const have = new Set(folders.map((f) => f && f.path));
+  for (const m of members) if (!have.has(m.dir)) folders.push({ path: m.dir });
+  const cfg = {
+    folders,
+    settings: existing.settings || {},
+    extensions: existing.extensions || { recommendations: ["anthropic.claude-code"] },
+  };
+  writeJSON(file, cfg);
+  ok(`Workspace de editor escrito en ${c.bold(path.basename(file))} (${folders.length} carpetas, multi-root).`);
+}
+
+function ensureWorkspaceJarvisClaudeCode(root) {
+  const claudeMd = path.join(root, "CLAUDE.md");
+  const ch = upsertMarkedBlock(claudeMd, jarvisPersonaBody("ozali-workspace-jarvis.md"), WS_JARVIS_BEGIN, WS_JARVIS_END);
+  ok(`ozali-workspace-jarvis ${ch ? "escrito" : "ya presente"} en ${c.bold("CLAUDE.md")} de la raíz.`);
+  const agentFile = path.join(root, ".claude", "agents", "ozali-workspace-jarvis.md");
+  ensureDir(path.dirname(agentFile));
+  fs.copyFileSync(path.join(TEMPLATES_SRC, "ozali-workspace-jarvis.md"), agentFile);
+  ok(`Subagente ${c.bold(".claude/agents/ozali-workspace-jarvis.md")} instalado.`);
+}
+
+function ensureWorkspaceJarvisOpencode(root) {
+  const agentsMd = path.join(root, "AGENTS.md");
+  const ch = upsertMarkedBlock(agentsMd, jarvisPersonaBody("ozali-workspace-jarvis.md"), WS_JARVIS_BEGIN, WS_JARVIS_END);
+  ok(`ozali-workspace-jarvis ${ch ? "escrito" : "ya presente"} en ${c.bold("AGENTS.md")} de la raíz.`);
+  const p = path.join(root, "opencode.json");
+  const cfg = readJSON(p, {});
+  cfg.$schema = cfg.$schema || "https://opencode.ai/config.json";
+  cfg.agent = cfg.agent || {};
+  if (!cfg.agent["ozali-workspace-jarvis"]) {
+    cfg.agent["ozali-workspace-jarvis"] = {
+      mode: "primary",
+      description: "Orquestador multi-repo: coordina repos hermanos según ozali-workspace.json.",
+      prompt: "{file:./AGENTS.md}",
+    };
+    writeJSON(p, cfg);
+    ok(`Agente ${c.bold("ozali-workspace-jarvis")} (primary) añadido a ${c.bold("opencode.json")}.`);
+  } else {
+    info("Agente ozali-workspace-jarvis ya presente en opencode.json.");
+  }
+}
+
 // =========================================================== doctor ==========
 export function doctor(cwd) {
   step("ozali doctor — health-check (read-only)");

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 } from "./util.mjs";
+import { exists, which, gitInfo, nodeMajor, HOME, readJSON, projectName, DEFAULT_KNOWLEDGE } from "./util.mjs";
 
 /** Variante de fuente de verdad: {found, doc, dir, variant} */
 export function detectSourceOfTruth(cwd) {
@@ -109,3 +109,125 @@ export function detectAll(cwd) {
     testing: detectTesting(cwd),
   };
 }
+
+// ===================================================== workspace (multi-repo) ==
+
+const IGNORE_DIRS = new Set(["node_modules", ".git", "dist", "build", "vendor", "target"]);
+
+/** ¿La raíz misma es el knowledge repo (o vive dentro de él)? Para no auto-escanearlo. */
+function isKnowledgeRepo(dir) {
+  const k = path.resolve(DEFAULT_KNOWLEDGE);
+  const d = path.resolve(dir);
+  return d === k || d.startsWith(k + path.sep);
+}
+
+/**
+ * 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.
+ */
+function collectRepoDirs(root, depth, level = 1, acc = []) {
+  let entries;
+  try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { return acc; }
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    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 (level < depth) collectRepoDirs(full, depth, level + 1, acc);
+  }
+  return acc;
+}
+
+/** Estado ozali de un repo: missing-init | needs-calibration | ready. */
+function memberStatus(hasConfig, hasCdk) {
+  if (!hasConfig) return "missing-init";
+  if (!hasCdk) return "needs-calibration";
+  return "ready";
+}
+
+/**
+ * Inventario multi-repo de una carpeta raíz. Read-only. Por cada repo git hijo arma
+ * su estado ozali (init/calibración), fuente de verdad, proyecto Engram y nombre de
+ * package.json (para inferir referencias). `existing` = manifiesto previo, si lo hay.
+ */
+export function detectWorkspace(root, opts = {}) {
+  const depth = Math.max(1, opts.depth || 1);
+  const dirs = collectRepoDirs(root, depth);
+  const members = dirs.map((full) => {
+    const hasConfig = exists(path.join(full, ".ozali", "config.json"));
+    const hasCdk = exists(path.join(full, ".claude", "skills", "cdk", "SKILL.md"));
+    const engramCfg = readJSON(path.join(full, ".engram", "config.json"));
+    const pkg = readJSON(path.join(full, "package.json"));
+    const g = gitInfo(full);
+    return {
+      dir: path.relative(root, full) || path.basename(full),
+      path: full,
+      project: projectName(full),
+      pkgName: pkg && typeof pkg.name === "string" ? pkg.name : null,
+      sot: detectSourceOfTruth(full),
+      hasConfig,
+      hasCdk,
+      engramProject: engramCfg && engramCfg.project_name ? engramCfg.project_name : null,
+      status: memberStatus(hasConfig, hasCdk),
+      git: { branch: g.branch || null, remote: g.remote || null },
+    };
+  }).sort((a, b) => a.dir.localeCompare(b.dir));
+  const existing = readJSON(path.join(root, "ozali-workspace.json"));
+  return { root, members, existing };
+}
+
+/**
+ * Infiere referencias entre repos (aristas dirigidas {from, to, kind}). Zero-dep,
+ * best-effort: dependencias npm cruzadas, submódulos git y contextos de docker-compose.
+ * `from` depende de / apunta a `to`. Devuelve aristas únicas.
+ */
+export function detectReferences(members) {
+  const byPkg = new Map();
+  const byDir = new Map();
+  for (const m of members) {
+    if (m.pkgName) byPkg.set(m.pkgName, m);
+    byDir.set(path.basename(m.dir), m);
+  }
+  const edges = [];
+  const seen = new Set();
+  const push = (from, to, kind) => {
+    if (!from || !to || from.dir === to.dir) return;
+    const key = `${from.dir}→${to.dir}:${kind}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    edges.push({ from: from.project, to: to.project, fromDir: from.dir, toDir: to.dir, kind });
+  };
+
+  for (const m of members) {
+    // 1) dependencias npm cruzadas
+    const pkg = readJSON(path.join(m.path, "package.json"));
+    if (pkg) {
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies };
+      for (const name of Object.keys(deps)) {
+        const target = byPkg.get(name);
+        if (target) push(m, target, "npm-dep");
+      }
+    }
+    // 2) submódulos git (.gitmodules → path de cada submódulo)
+    const gm = path.join(m.path, ".gitmodules");
+    if (exists(gm)) {
+      const txt = fs.readFileSync(gm, "utf8");
+      for (const match of txt.matchAll(/^\s*path\s*=\s*(.+)$/gim)) {
+        const target = byDir.get(path.basename(match[1].trim()));
+        if (target) push(m, target, "git-submodule");
+      }
+    }
+    // 3) docker-compose (build context que apunte a un repo hermano)
+    for (const f of ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"]) {
+      const cf = path.join(m.path, f);
+      if (!exists(cf)) continue;
+      const txt = fs.readFileSync(cf, "utf8");
+      for (const match of txt.matchAll(/context:\s*(\.{1,2}\/\S+)/gi)) {
+        const target = byDir.get(path.basename(match[1].trim().replace(/\/+$/, "")));
+        if (target) push(m, target, "compose");
+      }
+    }
+  }
+  return edges;
+}

package/cli/test/smoke.test.mjs

@@ -36,7 +36,7 @@ test("--version imprime la versión del package.json", () => {
 
 test("--help menciona los comandos", () => {
   const { stdout } = run(["--help"]);
-  for (const cmd of ["init", "doctor", "update", "sync", "audit"]) assert.match(stdout, new RegExp(cmd));
+  for (const cmd of ["init", "workspace", "doctor", "update", "sync", "audit"]) assert.match(stdout, new RegExp(cmd));
 });
 
 test("audit imprime cabecera y no rompe (general)", () => {
@@ -207,6 +207,67 @@ test("update también instala ozali-commit en repos previos", () => {
   }
 });
 
+// ------------------------------------------------------------------ workspace
+function wsRepo(root, name, { config = false, cdk = false, pkg = null } = {}) {
+  const dir = path.join(root, name);
+  fs.mkdirSync(dir, { recursive: true });
+  execFileSync("git", ["init", "-q"], { cwd: dir });
+  if (config) {
+    fs.mkdirSync(path.join(dir, ".ozali"), { recursive: true });
+    fs.writeFileSync(path.join(dir, ".ozali", "config.json"), JSON.stringify({ agent: "claude-code" }));
+  }
+  if (cdk) {
+    fs.mkdirSync(path.join(dir, ".claude", "skills", "cdk"), { recursive: true });
+    fs.writeFileSync(path.join(dir, ".claude", "skills", "cdk", "SKILL.md"), "---\nname: cdk\n---\n");
+  }
+  if (pkg) fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify(pkg));
+}
+
+test("workspace escanea y clasifica repos hijos sin escribir (dry-run)", () => {
+  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, pkg: { name: "web", dependencies: { api: "^1" } } });
+    wsRepo(root, "lib-bare", { pkg: { name: "lib" } });
+    const { stdout } = run(["workspace", "--dry-run"], root);
+    assert.match(stdout, /listo/, "clasifica api como listo");
+    assert.match(stdout, /sin calibrar/, "clasifica web como sin calibrar");
+    assert.match(stdout, /sin init/, "clasifica lib-bare como sin init");
+    assert.match(stdout, /web → api \(npm-dep\)/, "detecta la referencia npm web→api");
+    assert.match(stdout, /no escribo nada/, "dry-run no escribe");
+    assert.ok(!fs.existsSync(path.join(root, "ozali-workspace.json")), "dry-run: no hay manifiesto");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("workspace escribe manifiesto + .code-workspace + jarvis y es idempotente", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ozali-ws-"));
+  try {
+    // Ambos ready (con cdk) → sin missing-init, no invoca init pesado.
+    wsRepo(root, "api", { config: true, cdk: true, pkg: { name: "api", version: "1.0.0" } });
+    wsRepo(root, "web", { config: true, cdk: true, pkg: { name: "web", dependencies: { api: "^1" } } });
+    run(["workspace", "--yes", "--no-trust"], root);
+
+    const manifest = JSON.parse(fs.readFileSync(path.join(root, "ozali-workspace.json"), "utf8"));
+    assert.equal(manifest.members.length, 2, "manifiesto con 2 miembros");
+    assert.ok(manifest.references.some((r) => r.from === "web" && r.to === "api"), "referencia web→api en el manifiesto");
+
+    const wsFile = path.join(root, `${path.basename(root)}.code-workspace`);
+    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");
+
+    // idempotencia: re-correr no duplica
+    run(["workspace", "--yes", "--no-trust"], root);
+    const claude = fs.readFileSync(path.join(root, "CLAUDE.md"), "utf8");
+    assert.equal((claude.match(/ozali-workspace-jarvis:start/g) || []).length, 1, "no duplica el bloque jarvis");
+    assert.equal(JSON.parse(fs.readFileSync(wsFile, "utf8")).folders.length, 2, "no duplica folders");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("init --dry-run no escribe nada", () => {
   const dir = tmpProject();
   try {

package/docs/workspaces.md

@@ -0,0 +1,82 @@
+# Workspaces multi-repo (`ozali workspace`)
+
+← [README](../README.md)
+
+Objetivo: cuando abres en tu editor (VSCode, **Antigravity** — ambos de la familia VSCode) una
+**carpeta raíz que agrupa varios repositorios relacionados** (una API, su front, librerías
+compartidas), que el agente pueda **trabajar en conjunto** con todos, porque tienen **referencias
+entre ellos**.
+
+`ozali` opera por defecto **repo por repo**. El comando `ozali workspace` añade una capa de
+coordinación **a nivel de la carpeta raíz**, sin quitarle autonomía a ningún repo miembro (cada uno
+conserva su `ozali-jarvis`, su skill `cdk`, su fuente de verdad y su memoria Engram).
+
+## Uso
+
+Corre **una vez** en la carpeta raíz (la que contiene los repos):
+
+```bash
+ozali workspace              # escanea, remedia y escribe la config conjunta
+ozali workspace --dry-run    # solo inventario + plan, sin escribir nada
+ozali workspace --yes        # no interactivo (acepta defaults y todas las referencias detectadas)
+ozali workspace --depth 2    # busca repos hasta 2 niveles bajo la raíz
+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.
+
+## Qué hace, paso a paso
+
+1. **Escaneo (read-only).** Enumera los repos git hijos y reporta el estado ozali de cada uno:
+   - `✔ listo` — tiene `.ozali/config.json` **y** su skill `cdk` (`.claude/skills/cdk/SKILL.md`).
+   - `⚠ sin calibrar` — tiene `ozali init` pero **falta `cdk`** (aún no se calibró).
+   - `✖ sin init` — no tiene `.ozali/config.json`.
+
+2. **Remediación.** Por cada repo `✖ sin init`, ofrece correr **`ozali init`** (el "prepare":
+   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.
+
+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.
+   - `git-submodule` — un `path` de `.gitmodules` apunta a un repo hermano.
+   - `compose` — un `build.context` de `docker-compose.yml` apunta a un repo hermano.
+
+   Te muestra lo detectado y lo confirmas (con `--yes` se aceptan todas).
+
+## Qué escribe
+
+En la carpeta raíz:
+
+| Artefacto | Qué es |
+|---|---|
+| `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. |
+
+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í**
+son commiteables/compartibles.
+
+## El orquestador `ozali-workspace-jarvis`
+
+Es una persona de agente que **lee `ozali-workspace.json` en runtime** (no se re-templatiza al cambiar
+miembros). Su trabajo:
+
+- Recall-first **a nivel workspace**: ubica qué repo(s) toca la tarea y recupera memoria **solo** de
+  los proyectos involucrados.
+- Verifica que el repo esté `listo` antes de tocar código; si está `sin init`/`sin calibrar`, lo dice.
+- **Delega la ejecución** al `cdk` del repo correspondiente (plan, GATE, TDD, docs por hito).
+- En cambios que **cruzan repos**, secuencia según las `references` (primero el proveedor/`to`, luego
+  el consumidor/`from`) y anota el cambio en la memoria de **ambos** repos.
+
+## Fuera de alcance (por ahora)
+
+- Auto-sugerencia al abrir la carpeta (tarea de editor/hook).
+- `ozali doctor`/`sync` agregados a nivel workspace.
+- 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.6.1",
+  "version": "0.7.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/ozali-workspace-jarvis.md

@@ -0,0 +1,45 @@
+---
+name: ozali-workspace-jarvis
+description: Orquestador de un WORKSPACE multi-repo de ozali. Coordina varios repositorios hermanos que se referencian entre sí. Úsalo/actúa como jarvis de workspace para CUALQUIER trabajo que cruce repos — lee el manifiesto ozali-workspace.json, recupera contexto de todos los proyectos involucrados antes de actuar, y delega la ejecución de código en el ozali-jarvis y la skill cdk de CADA repo miembro.
+---
+
+# ozali-workspace-jarvis — orquestador multi-repo
+
+Eres **ozali-workspace-jarvis**, el orquestador de esta **carpeta raíz que agrupa varios
+repositorios** relacionados. Existes porque los repos miembros **se referencian entre sí** y a veces
+un cambio abarca a más de uno. Tu trabajo es mantener la coherencia **entre repos** y delegar la
+ejecución disciplinada dentro de cada uno.
+
+> Cada repo miembro conserva su propia autonomía: su `ozali-jarvis`, su skill `cdk`, su fuente de
+> verdad (`.ai/`/`.ia/`) y su memoria Engram. Tú **no** los reemplazas: los **coordinas**.
+
+## 1. Al iniciar (recall-first, a nivel workspace)
+- **Lee `ozali-workspace.json`** en la raíz: es la fuente de verdad de los **miembros**, su **estado**
+  (`ready` / `needs-calibration` / `missing-init`) y las **referencias** entre ellos (`from → to`).
+- Ubica la tarea: ¿qué repo(s) toca y a través de qué referencias impacta a otros?
+- Recupera contexto de memoria **de cada proyecto involucrado** (no de todos): confirma el proyecto de
+  cada repo con `mem_current_project` y usa `mem_search`/`mem_context` acotado a esos proyectos.
+- **Recuperación selectiva:** nunca vuelques toda la memoria; trae solo lo necesario por repo.
+
+## 2. Antes de tocar código — verifica que el repo esté listo
+- Si un miembro está `missing-init`, dilo y sugiere `ozali init` en ese repo (o re-correr
+  `ozali workspace` en la raíz).
+- Si un miembro está `needs-calibration` (sin `cdk`), **condúcelo**: sugiere abrir ese repo y correr la
+  skill **`ozali`** ("diagnostica el proyecto") para generar su `cdk` antes de ejecutar cambios.
+
+## 3. Para ejecutar cambios → delega en el repo correcto
+- Un cambio se ejecuta **dentro** del repo que le corresponde, usando **su** skill `cdk` (plan, GATE,
+  TDD, docs por hito). Tú preparas el contexto cruzado; el `cdk` del repo ejecuta.
+- **Cambios que cruzan repos** (p. ej. un contrato de API que consume un front): secuencia el trabajo
+  siguiendo las `references` (primero el `to`/proveedor, luego el `from`/consumidor), y deja registrado
+  en la memoria de cada repo qué cambió y por qué, enlazando ambos lados.
+
+## 4. Al cerrar
+- Resume por repo tocado con `mem_session_summary` (solo el agente top-level).
+- Si el cambio afectó una referencia entre repos, anótalo en **ambos** proyectos para que el recall
+  futuro lo encuentre desde cualquiera de los dos.
+
+## Reglas duras
+- La memoria **nunca bloquea**: si Engram no responde, sigue en modo `docs` y anótalo.
+- **No inventes** referencias ni miembros: si algo no está en `ozali-workspace.json`, no lo asumas.
+- No edites el histórico ni los planes congelados de ningún repo miembro.