ozali 0.4.0 → 0.4.1

package/README.md

@@ -2,6 +2,8 @@
 
 # ozali
 
+[![npm version](https://img.shields.io/npm/v/ozali.svg)](https://www.npmjs.com/package/ozali)
+
 **Bootstrap de IA por equipo — calibra tus proyectos, genera una skill de ejecución con TDD/SDD, y mantiene memoria de equipo (Engram) con histórico aislado.**
 
 </div>
@@ -59,7 +61,7 @@ git clone <repo> && node ozali/cli/bin/ozali.mjs init
 ```bash
 ozali init      # detecta agente, instala la skill, aísla el histórico, instala+configura Engram
 ozali doctor    # health-check read-only (fuente de verdad, Engram, Cloud, Strict TDD, runner…)
-ozali update    # actualiza la skill instalada a la versión del paquete
+ozali update    # actualiza la instalación (skill ozali + ozali-jarvis + permisos) al paquete
 ozali sync      # lleva el histórico (docs + Engram) al repo de conocimiento de equipo
 ozali audit     # navega/audita la memoria de Engram del proyecto (o general)
 ```
@@ -69,6 +71,18 @@ 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/`.
 
+### Actualizar a una versión nueva
+
+```bash
+pnpm add -g ozali@<versión>   # actualiza el CLI global (pinea la versión por el cooldown de pnpm)
+ozali update                  # en cada repo: refresca skill ozali + ozali-jarvis + permisos
+```
+
+`ozali update` también **crea ozali-jarvis** en repos inicializados con versiones anteriores. La skill
+`cdk` la **regenera tu agente** (no el CLI): tras `ozali update`, abre el agente y vuelve a correr la
+skill `ozali` para regenerar `cdk` con el contrato nuevo — tus docs por hito y el plan congelado se
+conservan.
+
 `init` también escribe un **perfil base de permisos** (`.claude/settings.json` para Claude Code,
 `opencode.json` para opencode) para reducir confirmaciones: deja libres comandos seguros y bloquea
 los destructivos. Es un template — tus reglas se conservan al re-correr `init`. Como Claude Code

package/cli/bin/ozali.mjs

@@ -15,7 +15,7 @@ ${c.bold("Comandos:")}
   init      Detecta el agente (Claude Code/opencode), instala la skill ozali,
             aísla el histórico, configura Engram y el repo de conocimiento.
   doctor    Health-check read-only del proyecto (fuente de verdad, Engram, TDD…).
-  update    Actualiza la skill ozali instalada a la versión de este paquete.
+  update    Actualiza la instalación (skill ozali + ozali-jarvis + permisos) al paquete.
   sync      Sincroniza el histórico (docs + Engram) con el repo de conocimiento.
   audit     Navega/audita la memoria de Engram del proyecto (o general).
 
@@ -27,7 +27,7 @@ ${c.bold("Opciones comunes:")}
   --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.
-  --no-jarvis          (init) No crear el orquestador ozali-jarvis.
+  --no-jarvis          (init/update) No crear/refrescar el orquestador ozali-jarvis.
   --import             (sync) Importa del repo de conocimiento a local.
   --push               (sync) Hace push al remoto del repo de conocimiento.
   --cloud              (sync) Replica también a Engram Cloud (si está habilitado).
@@ -75,10 +75,12 @@ async function main() {
   if (!cmd || opts.help || cmd === "help") { console.log(HELP); return 0; }
 
   const cwd = process.cwd();
+  // Banner de versión: confirma qué versión de ozali está corriendo en cada comando.
+  console.log(`${c.bold("ozali")} ${c.dim("v" + pkgVersion())}`);
   switch (cmd) {
     case "init": return await init(cwd, opts);
     case "doctor": return doctor(cwd);
-    case "update": return update(cwd);
+    case "update": return update(cwd, opts);
     case "sync": return sync(cwd, opts);
     case "audit": return await audit(cwd, opts);
     default:

package/cli/lib/commands.mjs

@@ -528,20 +528,72 @@ function readStrictTdd(cwd, sot) {
 }
 
 // =========================================================== update ==========
-export function update(cwd) {
-  step("ozali update — actualizar skill instalada");
+// Lleva una instalación existente al paquete actual: refresca la skill ozali (con sus
+// 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 = {}) {
+  step("ozali update — actualizar la instalación al paquete actual");
   const env = detectAll(cwd);
-  if (!env.skill.installed) { warn("No hay skill ozali instalada. Corre " + c.bold("ozali init") + " primero."); return 1; }
-  for (const p of env.skill.paths) {
-    copyDir(SKILL_SRC, p);
-    ok(`Actualizada: ${path.relative(cwd, p) || p} → v${pkgVersion()}`);
-  }
   const cfgPath = CONFIG_PATH(cwd);
   const cfg = readJSON(cfgPath);
+  if (!env.skill.installed && !cfg) {
+    warn("No hay instalación de ozali en esta ruta. Corre " + c.bold("ozali init") + " primero.");
+    return 1;
+  }
+
+  // 1) Skill ozali (incluye las references: la base desde la que el agente regenera cdk)
+  if (env.skill.installed) {
+    for (const p of env.skill.paths) {
+      copyDir(SKILL_SRC, p);
+      ok(`Skill ozali actualizada: ${path.relative(cwd, p) || p} → v${pkgVersion()}`);
+    }
+  } else {
+    warn("Skill ozali no instalada en esta ruta (corre " + c.bold("ozali init") + " para instalarla).");
+  }
+
+  // Agente/scope: del config; si falta, infiere del entorno.
+  const agent = (cfg && cfg.agent) || (env.agents.opencode.present && !env.agents.claudeCode.present ? "opencode"
+    : env.agents.claudeCode.present && env.agents.opencode.present ? "both" : "claude-code");
+  const scope = (cfg && cfg.scope) || "project";
+
+  // 2) Perfiles base de permisos (idempotente: recoge defaults nuevos del paquete)
+  if (agent === "claude-code" || agent === "both") ensureClaudeCodeProfile(cwd, scope);
+  if (agent === "opencode" || agent === "both") ensureOpencodeProfile(cwd);
+
+  // 3) ozali-jarvis: crea el orquestador en repos previos a 0.4.0 y refresca el resto.
+  if (!opts.noJarvis) {
+    const proj = projectName(cwd);
+    const engPath = path.join(cwd, ".engram", "config.json");
+    if (!exists(engPath)) { writeJSON(engPath, { project_name: proj }); ok(`Proyecto de memoria fijado en ${c.bold(".engram/config.json")} (${proj}).`); }
+    if (agent === "claude-code" || agent === "both") ensureJarvisClaudeCode(cwd);
+    if (agent === "opencode" || agent === "both") ensureJarvisOpencode(cwd);
+  }
+
+  // 4) Skill cdk: la genera el AGENTE (Fase 6), el CLI no la regenera.
+  const cdk = detectCdk(cwd);
+  if (cdk.installed) {
+    step("Skill cdk (generada por el agente)");
+    warn("cdk no se actualiza desde el CLI: la regenera tu agente con el contrato nuevo.");
+    info("Abre tu agente y vuelve a correr la skill " + c.bold("ozali") + " para regenerar cdk (ozali-jarvis, recall-first §7, telemetría).");
+    info("Tus docs por hito (" + c.bold(".ozali/docs/cdk/") + ") y el plan congelado se conservan.");
+  }
+
+  // 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()}.`);
   return 0;
 }
 
+/** ¿Existe la skill cdk (generada por el agente)? */
+function detectCdk(cwd) {
+  const paths = [
+    path.join(cwd, ".claude", "skills", "cdk", "SKILL.md"),
+    path.join(HOME, ".claude", "skills", "cdk", "SKILL.md"),
+  ].filter(exists);
+  return { installed: paths.length > 0, paths };
+}
+
 // ============================================================= sync ===========
 export function sync(cwd, opts) {
   step(`ozali sync${opts.import ? " --import" : ""} — histórico ↔ repo de conocimiento`);

package/cli/test/smoke.test.mjs

@@ -118,6 +118,20 @@ test("init opencode crea jarvis (AGENTS.md + agente + plugin)", () => {
   }
 });
 
+test("update agrega ozali-jarvis en un repo que no lo tenía", () => {
+  const dir = tmpProject();
+  try {
+    run(["init", "--yes", "--no-engram", "--no-trust", "--no-jarvis", "--agent", "claude-code", "--scope", "project", "--knowledge-repo", path.join(dir, ".k")], dir);
+    assert.ok(!fs.existsSync(path.join(dir, ".claude", "agents", "ozali-jarvis.md")), "precondición: sin jarvis");
+    run(["update"], dir);
+    assert.ok(fs.existsSync(path.join(dir, ".claude", "agents", "ozali-jarvis.md")), "update crea subagente jarvis");
+    assert.match(fs.readFileSync(path.join(dir, "CLAUDE.md"), "utf8"), /ozali-jarvis:start/, "update crea bloque jarvis");
+    assert.ok(fs.existsSync(path.join(dir, ".engram", "config.json")), "update fija .engram/config.json");
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test("init --dry-run no escribe nada", () => {
   const dir = tmpProject();
   try {

package/docs/guia-de-uso.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ozali",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "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": {