ozali 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jaime Baños
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,94 @@
+<div align="center">
+
+# 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>
+
+---
+
+## Qué es
+
+`ozali` lleva a cualquier repositorio existente a un flujo de desarrollo asistido por IA,
+**disciplinado y trazable**, pensado para equipos. No es un chatbot: es un método.
+
+- **Diagnostica y calibra** el proyecto: detecta stack, arquitectura, convenciones, capacidades de
+  testing y resuelve **Strict TDD** (test-first sí/no) contra lo que el proyecto realmente soporta.
+- **Fuente de verdad** legible: `AI.md` + `.ai/` (el "Project Brain") — generado evaluando el
+  código real, nunca inventado.
+- **Genera `cdk`**, la skill de ejecución con **8 subagentes** (owner, manager, analyzer,
+  orchestrator, executioners, proposer, documenter, tester), **GATE de aprobación** y plan
+  congelado inmutable.
+- **Memoria híbrida**: documentos legibles por humanos **+** Engram buscable/acumulable, para que
+  la herramienta **aprenda de lo que el equipo va haciendo**.
+- **Histórico aislado**: el registro que crece vive en un repo de conocimiento aparte, sin
+  sobrecargar el repo principal.
+
+## Dos piezas
+
+1. **Proyecto completo** (este repo): la skill `ozali`, las `references/`, el harness, el CLI y los docs.
+2. **Plug-n-play CLI**: instala y arranca el método en cualquier repo, de forma interogativa.
+
+## Instalación (segura por diseño)
+
+CLI **Node de cero dependencias y sin lifecycle scripts** → sin vector de supply-chain.
+Detalle en [docs/security.md](docs/security.md).
+
+```bash
+# Recomendado (pnpm 10 deshabilita postinstall de deps por defecto)
+pnpm dlx ozali@<versión> init
+
+# npm con scripts desactivados
+npx --ignore-scripts ozali@<versión> init
+
+# Máxima auditabilidad
+git clone <repo> && node ozali/cli/bin/ozali.mjs init
+```
+
+### Uso del CLI
+
+```bash
+ozali init      # detecta agente, instala la skill, aísla el histórico, configura Engram
+ozali doctor    # health-check read-only (fuente de verdad, Engram, Strict TDD, runner…)
+ozali update    # actualiza la skill instalada a la versión del paquete
+ozali sync      # lleva el histórico (docs + Engram) al repo de conocimiento de equipo
+```
+
+Flags útiles: `--yes` (no interactivo), `--dry-run` (init sin escribir), `--agent`, `--scope`,
+`--knowledge-repo`, `--import`/`--push` (sync). Modelo mental completo en
+[docs/intended-usage.md](docs/intended-usage.md).
+
+## Agentes soportados
+
+Claude Code y opencode (perfiles de permisos para ambos en
+[skill/references/permissions-bypass.md](skill/references/permissions-bypass.md)).
+
+## Documentación
+
+| Tema | Doc |
+|---|---|
+| Uso previsto (modelo mental) | [docs/intended-usage.md](docs/intended-usage.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) |
+| Skill bootstrap | [skill/SKILL.md](skill/SKILL.md) |
+| Calibración de testing + TDD | [skill/references/calibration-blueprint.md](skill/references/calibration-blueprint.md) |
+| Blueprint de agentes | [skill/references/agents-blueprint.md](skill/references/agents-blueprint.md) |
+| Memoria híbrida (docs + Engram) | [skill/references/engram-convention.md](skill/references/engram-convention.md) |
+
+## Estado del roadmap
+
+- [x] **Fase A** — Calibración + Strict TDD en el bootstrap.
+- [x] **Fase B** — Memoria híbrida (docs + Engram, `state` recuperable, contrato de arranque).
+- [x] **Fase C** — CLI plug-n-play (`init`/`doctor`/`update`/`sync`), Node cero-deps.
+- [x] **Fase D** — Repo distribuible: tests (node:test), CI (matriz Node 16–22 + invariantes de seguridad), publicación npm con provenance.
+
+> Siguiente paso natural: crear el repo en GitHub y publicar la primera versión (`pnpm publish` vía tag), más probar el bootstrap en un repo real del equipo.
+
+> Linaje: `ozali` evoluciona la skill `copsis-doctor`, nutrida con conceptos de
+> [gentle-ai](https://github.com/Gentleman-Programming/gentle-ai) (Engram, calibración SDD/TDD,
+> distribución plug-n-play).
+
+## Licencia
+
+MIT

package/cli/bin/ozali.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+// ozali — CLI plug-n-play (Node, CERO dependencias, SIN lifecycle scripts).
+// 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 } from "../lib/commands.mjs";
+
+const HELP = `
+${c.bold("ozali")} ${c.dim("v" + pkgVersion())} — bootstrap de IA por equipo (TDD/SDD + memoria Engram)
+
+${c.bold("Uso:")}
+  ozali <comando> [opciones]
+
+${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.
+  sync      Sincroniza el histórico (docs + Engram) con el repo de conocimiento.
+
+${c.bold("Opciones comunes:")}
+  --yes, -y            No interactivo: usa defaults.
+  --dry-run            (init) Muestra el plan sin escribir nada.
+  --agent <a>          (init) claude-code | opencode | both.
+  --scope <s>          (init) project | global.
+  --knowledge-repo <p> (init) Ruta del repo de conocimiento.
+  --import             (sync) Importa del repo de conocimiento a local.
+  --push               (sync) Hace push al remoto del repo de conocimiento.
+  -h, --help           Esta ayuda.    -v, --version   Versión.
+
+${c.bold("Instalación segura:")}
+  pnpm dlx ozali@<versión> init            ${c.dim("# recomendado (pnpm 10: postinstall off)")}
+  npx --ignore-scripts ozali@<versión> init
+  git clone … && node cli/bin/ozali.mjs init
+`;
+
+function parseArgs(argv) {
+  const opts = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--yes" || a === "-y") opts.yes = true;
+    else if (a === "--dry-run") opts.dryRun = true;
+    else if (a === "--import") opts.import = true;
+    else if (a === "--push") opts.push = true;
+    else if (a === "--agent") opts.agent = argv[++i];
+    else if (a === "--scope") opts.scope = 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;
+    else opts._.push(a);
+  }
+  return opts;
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const cmd = opts._[0];
+
+  if (opts.version) { console.log(pkgVersion()); return 0; }
+  if (!cmd || opts.help || cmd === "help") { console.log(HELP); return 0; }
+
+  const cwd = process.cwd();
+  switch (cmd) {
+    case "init": return await init(cwd, opts);
+    case "doctor": return doctor(cwd);
+    case "update": return update(cwd);
+    case "sync": return sync(cwd, opts);
+    default:
+      err(`comando desconocido "${cmd}". Usa ${c.bold("ozali --help")}.`);
+      return 1;
+  }
+}
+
+main().then((code) => process.exit(code || 0)).catch((e) => {
+  err(e && e.stack ? e.stack : String(e));
+  process.exit(1);
+});

package/cli/lib/commands.mjs

@@ -0,0 +1,235 @@
+// commands.mjs — implementación de init / doctor / update / sync.
+import fs from "node:fs";
+import path from "node:path";
+import {
+  c, ok, warn, err, info, step,
+  SKILL_SRC, exists, ensureDir, copyDir, readJSON, writeJSON,
+  ensureGitignore, tryExec, projectName, pkgVersion, DEFAULT_KNOWLEDGE,
+} from "./util.mjs";
+import { detectAll } from "./detect.mjs";
+import { ask, confirm, select } from "./prompt.mjs";
+
+const CONFIG_PATH = (cwd) => path.join(cwd, ".ozali", "config.json");
+
+function skillTarget(cwd, scope) {
+  const base = scope === "global" ? path.join(process.env.HOME || "", ".claude") : path.join(cwd, ".claude");
+  return path.join(base, "skills", "ozali");
+}
+
+// ============================================================ init ===========
+export async function init(cwd, opts) {
+  step("ozali init — bootstrap del proyecto");
+  const env = detectAll(cwd);
+
+  if (!env.node.ok) warn(`Node ${env.node.version} detectado; ozali y el harness piden ≥16. Continúo, pero actualiza si ves errores.`);
+  if (!env.git.isRepo) warn("No estás en un repo git: la trazabilidad por commit y el sync quedarán limitados.");
+
+  // Fuente de verdad
+  if (env.sot.found) ok(`Fuente de verdad detectada: ${c.bold(env.sot.doc)} + ${c.bold(env.sot.dir + "/")} (variante ${env.sot.variant}).`);
+  else info(`Sin fuente de verdad aún (se generará al correr la skill 'ozali' en tu agente).`);
+
+  // Agente
+  const agentDefault = env.agents.opencode.present && !env.agents.claudeCode.present ? "opencode"
+    : env.agents.claudeCode.present && env.agents.opencode.present ? "both" : "claude-code";
+  const agent = opts.agent || await select("¿Para qué agente configuro ozali?", [
+    { value: "claude-code", label: "Claude Code" },
+    { value: "opencode", label: "opencode" },
+    { value: "both", label: "Ambos (Claude Code + opencode)" },
+  ], { "claude-code": 0, opencode: 1, both: 2 }[agentDefault]);
+
+  // Scope
+  const scope = opts.scope || await select("¿Dónde instalo la skill?", [
+    { value: "project", label: `Proyecto (${c.dim(".claude/skills/ozali")})` },
+    { value: "global", label: `Global (${c.dim("~/.claude/skills/ozali")})` },
+  ], 0);
+
+  // Repo de conocimiento (histórico aislado)
+  const knowledgeRepo = opts.knowledgeRepo || await ask("Ruta del repo de conocimiento (histórico aislado)", DEFAULT_KNOWLEDGE);
+
+  // Engram
+  let memoryMode = "hybrid";
+  if (env.engram.available) {
+    ok(`Engram disponible (${env.engram.bin}). Modo de memoria: ${c.bold("hybrid")} (docs + Engram).`);
+  } else {
+    memoryMode = "docs";
+    warn("Engram no está instalado. Arrancamos en modo " + c.bold("docs") + " (solo documentos legibles).");
+    info("Para activar memoria buscable/acumulativa instala Engram: " + c.cyan("https://github.com/Gentleman-Programming/engram"));
+    info("Tras instalarlo, vuelve a correr " + c.bold("ozali doctor") + " — el modo subirá a hybrid automáticamente.");
+  }
+
+  if (opts.dryRun) { warn("--dry-run: no escribo nada. Plan mostrado arriba."); return 0; }
+
+  // --- acciones ---
+  step("Aplicando");
+  // 1) copiar skill
+  const target = skillTarget(cwd, scope);
+  ensureDir(path.dirname(target));
+  copyDir(SKILL_SRC, target);
+  ok(`Skill instalada en ${c.bold(path.relative(cwd, target) || target)}.`);
+
+  // 2) opencode: perfil base de permisos (idempotente, merge mínimo)
+  if (agent === "opencode" || agent === "both") {
+    ensureOpencodeProfile(cwd);
+  }
+
+  // 3) gitignore del histórico aislado
+  if (env.git.isRepo) {
+    const { added } = ensureGitignore(cwd, [".ozali/", ".engram/"]);
+    if (added.length) ok(`.gitignore actualizado: ${added.join(", ")} (histórico aislado del repo principal).`);
+    else info(".gitignore ya aislaba el histórico.");
+  }
+
+  // 4) repo de conocimiento
+  ensureDir(knowledgeRepo);
+  if (!exists(path.join(knowledgeRepo, ".git"))) {
+    if (await confirm(`¿Inicializo git en el repo de conocimiento (${knowledgeRepo})?`, true)) {
+      tryExec("git", ["init", "-q"], { cwd: knowledgeRepo });
+      ensureDir(path.join(knowledgeRepo, "projects"));
+      ensureDir(path.join(knowledgeRepo, "engram"));
+      ok("Repo de conocimiento inicializado.");
+    }
+  } else info("Repo de conocimiento ya existe.");
+
+  // 5) config local (gitignored)
+  const config = {
+    version: pkgVersion(), agent, scope, knowledgeRepo, memoryMode,
+    project: projectName(cwd), createdAt: new Date().toISOString(),
+  };
+  writeJSON(CONFIG_PATH(cwd), config);
+  ok(`Config local escrita en ${c.bold(".ozali/config.json")} (gitignored).`);
+
+  // --- siguientes pasos ---
+  step("Siguientes pasos");
+  console.log(`  1. Abre tu agente en este proyecto.`);
+  console.log(`  2. Escribe ${c.bold('"diagnostica el proyecto"')} o ${c.bold('"ozali"')} para arrancar el bootstrap (calibración + generación de la skill ${c.bold("cdk")}).`);
+  console.log(`  3. Tras trabajar, corre ${c.bold("ozali sync")} para llevar el histórico al repo de conocimiento.`);
+  console.log(`  ${c.dim("Salud en cualquier momento:")} ${c.bold("ozali doctor")}`);
+  return 0;
+}
+
+function ensureOpencodeProfile(cwd) {
+  const p = path.join(cwd, "opencode.json");
+  const base = readJSON(p, {});
+  base["$schema"] = base["$schema"] || "https://opencode.ai/config.json";
+  base.permission = base.permission || {};
+  const perm = base.permission;
+  // Perfil base modo normal: lectura+comandos+fetch libres, ediciones confirman.
+  for (const [k, v] of Object.entries({ read: "allow", grep: "allow", glob: "allow", webfetch: "allow", external_directory: "ask", edit: "ask" })) {
+    if (perm[k] === undefined) perm[k] = v;
+  }
+  if (perm.bash === undefined) perm.bash = { "*": "allow", "rm -rf *": "ask", "git push *": "ask" };
+  writeJSON(p, base);
+  ok(`Perfil base de permisos de opencode en ${c.bold("opencode.json")} (lectura+comandos libres, ediciones confirman).`);
+}
+
+// =========================================================== doctor ==========
+export function doctor(cwd) {
+  step("ozali doctor — health-check (read-only)");
+  const env = detectAll(cwd);
+  const cfg = readJSON(CONFIG_PATH(cwd));
+  const rows = [];
+  const add = (label, good, detail) => rows.push({ label, good, detail });
+
+  add("Repo git", env.git.isRepo, env.git.isRepo ? (env.git.commit ? `${env.git.branch}@${env.git.commit}` : "repo sin commits") : "no es repo git");
+  add("Node ≥ 16", env.node.ok, env.node.version);
+  add("Fuente de verdad", env.sot.found, env.sot.found ? `${env.sot.doc} + ${env.sot.dir}/` : "ausente (corre la skill 'ozali')");
+  add("Skill ozali instalada", env.skill.installed, env.skill.installed ? env.skill.paths.map((p) => path.relative(cwd, p) || p).join(", ") : "no instalada (ozali init)");
+  add("Engram", env.engram.available, env.engram.available ? env.engram.bin : "no instalado → modo docs");
+  add("Repo de conocimiento", !!(cfg && cfg.knowledgeRepo && exists(cfg.knowledgeRepo)), cfg ? cfg.knowledgeRepo : "sin configurar (ozali init)");
+
+  // Strict TDD (de la fuente de verdad)
+  const tdd = readStrictTdd(cwd, env.sot);
+  add("Strict TDD calibrado", tdd.found, tdd.found ? `strict_tdd: ${tdd.value}` : "sin calibrar (Fase 3.5 del bootstrap)");
+
+  // Testing signals
+  add("Runner de pruebas", env.testing.runners.length > 0, env.testing.runners.join(", ") || "ninguno detectado");
+
+  const pad = Math.max(...rows.map((r) => r.label.length));
+  console.log("");
+  for (const r of rows) {
+    const mark = r.good ? c.green("✔") : c.yellow("✖");
+    console.log(`  ${mark} ${r.label.padEnd(pad)}  ${c.dim(r.detail)}`);
+  }
+  const bad = rows.filter((r) => !r.good).length;
+  console.log("");
+  if (bad === 0) ok("Todo en orden. ozali está listo para trabajar.");
+  else warn(`${bad} punto(s) a atender. Revisa los ✖ de arriba.`);
+  return bad === 0 ? 0 : 1;
+}
+
+function readStrictTdd(cwd, sot) {
+  const f = path.join(cwd, sot.dir, "context", "tech-stack.md");
+  if (!exists(f)) return { found: false };
+  const txt = fs.readFileSync(f, "utf8");
+  const m = txt.match(/Strict\s*TDD[:*\s]+(true|false)/i);
+  return m ? { found: true, value: m[1].toLowerCase() } : { found: false };
+}
+
+// =========================================================== update ==========
+export function update(cwd) {
+  step("ozali update — actualizar skill instalada");
+  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 (cfg) { cfg.version = pkgVersion(); cfg.updatedAt = new Date().toISOString(); writeJSON(cfgPath, cfg); }
+  return 0;
+}
+
+// ============================================================= sync ===========
+export function sync(cwd, opts) {
+  step(`ozali sync${opts.import ? " --import" : ""} — 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;
+  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);
+  const docsLocal = path.join(cwd, ".ozali", "docs");
+  const engramLocal = path.join(cwd, ".engram");
+
+  if (opts.import) {
+    // Repo de conocimiento → local
+    const srcDocs = path.join(projDir, "docs");
+    if (exists(srcDocs)) { copyDir(srcDocs, docsLocal); ok("Docs importados a .ozali/docs/."); }
+    if (cfg.memoryMode === "hybrid" && tryExec("engram", ["--version"])) {
+      info("Ejecutando engram sync --import…");
+      tryExec("engram", ["sync", "--import"], { cwd });
+    }
+    info("Import completo. Revisa .ozali/docs/.");
+    return 0;
+  }
+
+  // Local → repo de conocimiento
+  // 1) Engram export (si hybrid + disponible)
+  if (cfg.memoryMode === "hybrid" && tryExec("engram", ["--version"])) {
+    info("Exportando memorias con engram sync…");
+    tryExec("engram", ["sync"], { cwd });
+    if (exists(engramLocal)) { copyDir(engramLocal, path.join(kRepo, "engram", project)); ok("Export de Engram copiado al repo de conocimiento."); }
+  } else if (cfg.memoryMode === "hybrid") {
+    warn("Modo hybrid pero Engram no responde; sincronizo solo docs.");
+  }
+  // 2) Docs
+  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.");
+
+  // 3) commit (push solo si hay remoto)
+  if (exists(path.join(kRepo, ".git"))) {
+    tryExec("git", ["add", "-A"], { cwd: kRepo });
+    const msg = `sync(${project}): histórico ${new Date().toISOString().slice(0, 19)}`;
+    tryExec("git", ["commit", "-m", msg], { cwd: kRepo });
+    ok("Commit en el repo de conocimiento.");
+    const remote = tryExec("git", ["remote", "get-url", "origin"], { cwd: kRepo });
+    if (remote) {
+      if (opts.push) { tryExec("git", ["push"], { cwd: kRepo }); ok("Push realizado."); }
+      else info("Hay remoto configurado. Usa " + c.bold("ozali sync --push") + " para publicar al equipo.");
+    } else {
+      info("Sin remoto en el repo de conocimiento. Añade uno (git remote add origin …) para compartir con el equipo.");
+    }
+  }
+  return 0;
+}

package/cli/lib/detect.mjs

@@ -0,0 +1,103 @@
+// 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 } from "./util.mjs";
+
+/** Variante de fuente de verdad: {found, doc, dir, variant} */
+export function detectSourceOfTruth(cwd) {
+  const variants = [
+    { variant: "AI", doc: "AI.md", dir: ".ai" },
+    { variant: "IA", doc: "IA.md", dir: ".ia" },
+  ];
+  for (const v of variants) {
+    const docPath = path.join(cwd, v.doc);
+    const dirPath = path.join(cwd, v.dir);
+    if (exists(docPath) || exists(dirPath)) {
+      return { found: true, ...v, hasDoc: exists(docPath), hasDir: exists(dirPath) };
+    }
+  }
+  return { found: false, variant: "AI", doc: "AI.md", dir: ".ai" };
+}
+
+/** Agentes presentes: claude-code y/o opencode. */
+export function detectAgents(cwd) {
+  const claudeProject = exists(path.join(cwd, ".claude"));
+  const claudeGlobal = exists(path.join(HOME, ".claude"));
+  const opencodeProject = exists(path.join(cwd, "opencode.json")) || exists(path.join(cwd, ".opencode"));
+  const opencodeGlobal = exists(path.join(HOME, ".config", "opencode"));
+  return {
+    claudeCode: { present: claudeProject || claudeGlobal, project: claudeProject, global: claudeGlobal },
+    opencode: { present: opencodeProject || opencodeGlobal, project: opencodeProject, global: opencodeGlobal },
+  };
+}
+
+/** ¿Está instalada la skill ozali? Devuelve rutas encontradas. */
+export function detectInstalledSkill(cwd) {
+  const candidates = [
+    path.join(cwd, ".claude", "skills", "ozali"),
+    path.join(HOME, ".claude", "skills", "ozali"),
+  ];
+  const found = candidates.filter((p) => exists(path.join(p, "SKILL.md")));
+  return { installed: found.length > 0, paths: found };
+}
+
+/** Engram disponible (binario CLI en PATH). El MCP no se puede sondear desde aquí. */
+export function detectEngram() {
+  const bin = which("engram");
+  return { available: !!bin, bin: bin || null };
+}
+
+/**
+ * Capacidades de testing (heurística read-only). Devuelve runner(s), comando y
+ * un conteo aproximado de archivos de prueba. NO resuelve strict_tdd (eso lo
+ * hace el bootstrap en la Fase 3.5); aquí solo damos señales.
+ */
+export function detectTesting(cwd) {
+  const out = { runners: [], command: null, testFiles: 0, hints: [] };
+  const pkg = path.join(cwd, "package.json");
+  if (exists(pkg)) {
+    try {
+      const j = JSON.parse(fs.readFileSync(pkg, "utf8"));
+      const deps = { ...j.dependencies, ...j.devDependencies };
+      for (const r of ["vitest", "jest", "mocha", "@playwright/test", "cypress", "karma", "ava"]) {
+        if (deps[r]) out.runners.push(r);
+      }
+      if (j.scripts && j.scripts.test) out.command = "npm test";
+    } catch { /* ignore */ }
+  }
+  if (exists(path.join(cwd, "go.mod"))) { out.runners.push("go test"); out.command = out.command || "go test ./..."; }
+  if (exists(path.join(cwd, "pom.xml"))) { out.runners.push("maven/junit"); out.command = out.command || "mvn test"; }
+  if (exists(path.join(cwd, "pyproject.toml")) || exists(path.join(cwd, "pytest.ini"))) {
+    out.runners.push("pytest"); out.command = out.command || "pytest";
+  }
+  out.testFiles = countTestFiles(cwd);
+  if (out.runners.length === 0) out.hints.push("No se detectó runner de pruebas (strict_tdd tenderá a false).");
+  return out;
+}
+
+function countTestFiles(dir, depth = 0, acc = { n: 0 }) {
+  if (depth > 6 || acc.n > 9999) return acc.n;
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return acc.n; }
+  for (const e of entries) {
+    if (e.name === "node_modules" || e.name === ".git" || e.name.startsWith(".") && e.isDirectory()) continue;
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) countTestFiles(full, depth + 1, acc);
+    else if (/\.(spec|test)\.(ts|tsx|js|jsx)$|_test\.go$|Test\.java$|^test_.*\.py$/.test(e.name)) acc.n++;
+  }
+  return acc.n;
+}
+
+/** Snapshot completo del entorno. */
+export function detectAll(cwd) {
+  return {
+    cwd,
+    node: { major: nodeMajor(), version: process.versions.node, ok: nodeMajor() >= 16 },
+    git: gitInfo(cwd),
+    sot: detectSourceOfTruth(cwd),
+    agents: detectAgents(cwd),
+    skill: detectInstalledSkill(cwd),
+    engram: detectEngram(),
+    testing: detectTesting(cwd),
+  };
+}

package/cli/lib/prompt.mjs

@@ -0,0 +1,51 @@
+// prompt.mjs — prompts interactivos sin dependencias (node:readline callback,
+// compatible con Node 16+; readline/promises no existe en 16, por eso envolvemos).
+import readline from "node:readline";
+import { c } from "./util.mjs";
+
+function rl() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+
+function question(query) {
+  return new Promise((resolve) => {
+    const i = rl();
+    i.question(query, (ans) => { i.close(); resolve(ans); });
+  });
+}
+
+const interactive = () => process.stdin.isTTY && process.stdout.isTTY;
+
+/** Texto libre con valor por defecto. En no-TTY devuelve el default. */
+export async function ask(message, def = "") {
+  if (!interactive()) return def;
+  const hint = def ? c.dim(` (${def})`) : "";
+  const ans = (await question(`${c.cyan("?")} ${message}${hint}: `)).trim();
+  return ans || def;
+}
+
+/** Confirmación sí/no. En no-TTY devuelve def. */
+export async function confirm(message, def = true) {
+  if (!interactive()) return def;
+  const hint = def ? "Y/n" : "y/N";
+  const ans = (await question(`${c.cyan("?")} ${message} ${c.dim("[" + hint + "]")} `)).trim().toLowerCase();
+  if (!ans) return def;
+  return ans[0] === "y" || ans[0] === "s"; // acepta sí/yes
+}
+
+/**
+ * Selección de una opción. options: [{value, label}]. En no-TTY devuelve el
+ * primero (o el marcado por defecto).
+ */
+export async function select(message, options, defIndex = 0) {
+  if (!interactive()) return options[defIndex].value;
+  console.log(`${c.cyan("?")} ${message}`);
+  options.forEach((o, i) => {
+    const mark = i === defIndex ? c.green("●") : c.dim("○");
+    console.log(`  ${mark} ${c.bold(String(i + 1))}) ${o.label}`);
+  });
+  const ans = (await question(`  ${c.dim("Elige [" + (defIndex + 1) + "]")}: `)).trim();
+  const n = ans ? parseInt(ans, 10) : defIndex + 1;
+  const idx = Number.isInteger(n) && n >= 1 && n <= options.length ? n - 1 : defIndex;
+  return options[idx].value;
+}