specatlas 0.1.38 → 0.1.39

package/dist/bin.js

@@ -36820,6 +36820,103 @@ function msg(key, language) {
   return dict[key] ?? key;
 }
 
+// src/ui.ts
+var CODIGOS = {
+  rojo: [31, 39],
+  verde: [32, 39],
+  amarillo: [33, 39],
+  azul: [34, 39],
+  morado: [35, 39],
+  cian: [36, 39],
+  gris: [90, 39],
+  negrita: [1, 22],
+  atenuado: [2, 22],
+  subrayado: [4, 24],
+  inverso: [7, 27]
+};
+function detectarTema(env = process.env, salida = process.stdout) {
+  const forzado = env["FORCE_COLOR"];
+  const color = forzado !== void 0 && forzado !== "0" ? true : env["NO_COLOR"] !== void 0 || env["TERM"] === "dumb" || salida.isTTY !== true ? false : true;
+  const unicode = env["SPECATLAS_ASCII"] === "1" ? false : process.platform !== "win32" || Boolean(env["WT_SESSION"] || env["TERM_PROGRAM"] || env["ConEmuANSI"] || env["TERM"]);
+  const ancho = Math.max(40, Math.min(salida.columns ?? 100, 120));
+  return { color, unicode, ancho };
+}
+function pinta(tema, estilo, texto) {
+  if (!tema.color || texto === "") return texto;
+  const estilos = Array.isArray(estilo) ? estilo : [estilo];
+  return estilos.reduce((acc, uno) => {
+    const [abre, cierra] = CODIGOS[uno];
+    return `\x1B[${abre}m${acc}\x1B[${cierra}m`;
+  }, texto);
+}
+var UNICODE = { ok: "\u2713", error: "\u2716", aviso: "\u25B2", info: "\u2139", flecha: "\u2192", punto: "\u25CF", bloqueo: "\u2298", pausa: "\u23F8", lleno: "\u25B0", vacio: "\u25B1", separador: "\xB7" };
+var ASCII = { ok: "v", error: "x", aviso: "!", info: "i", flecha: "->", punto: "*", bloqueo: "o", pausa: "||", lleno: "#", vacio: "-", separador: "-" };
+function simbolos(tema) {
+  return tema.unicode ? UNICODE : ASCII;
+}
+function anchoVisible(texto) {
+  return texto.replace(/\u001b\[[0-9;]*m/g, "").length;
+}
+function rellenar(texto, ancho) {
+  const falta = ancho - anchoVisible(texto);
+  return falta > 0 ? texto + " ".repeat(falta) : texto;
+}
+function encabezado(tema, titulo, contexto) {
+  const izquierda = pinta(tema, "negrita", titulo);
+  if (!contexto) return [izquierda, ""];
+  const hueco = tema.ancho - anchoVisible(izquierda) - anchoVisible(contexto);
+  if (hueco < 2) return [izquierda, pinta(tema, "gris", contexto), ""];
+  return [`${izquierda}${" ".repeat(hueco)}${pinta(tema, "gris", contexto)}`, ""];
+}
+function barraProgreso(tema, hecho, total, ancho = 8) {
+  const s = simbolos(tema);
+  if (total <= 0) return pinta(tema, "gris", `${s.vacio.repeat(ancho)} 0/0`);
+  const llenos = Math.max(0, Math.min(ancho, Math.round(hecho / total * ancho)));
+  const completo = hecho >= total;
+  const barra = `${s.lleno.repeat(llenos)}${s.vacio.repeat(ancho - llenos)}`;
+  return `${pinta(tema, completo ? "verde" : "azul", barra)} ${hecho}/${total}`;
+}
+function marcaSeveridad(tema, severidad) {
+  const s = simbolos(tema);
+  if (severidad === "error") return pinta(tema, "rojo", s.error);
+  if (severidad === "warning") return pinta(tema, "amarillo", s.aviso);
+  return pinta(tema, "azul", s.info);
+}
+function formatearDiagnostico(tema, d, rutaRelativa) {
+  const s = simbolos(tema);
+  const ubicacion = rutaRelativa ? pinta(tema, "gris", `${rutaRelativa}${d.line ? `:${d.line}` : ""}`) : "";
+  const codigo = pinta(tema, d.severity === "error" ? ["rojo", "negrita"] : d.severity === "warning" ? ["amarillo", "negrita"] : ["azul", "negrita"], d.code);
+  const cabeza = [`  ${marcaSeveridad(tema, d.severity)} ${codigo}`, ubicacion].filter((parte) => parte !== "").join("  ");
+  const lineas = [cabeza, `    ${d.message}`];
+  if (d.suggestion) lineas.push(pinta(tema, "gris", `    ${s.flecha} ${d.suggestion}`));
+  return lineas;
+}
+function resumenHallazgos(tema, counts) {
+  const s = simbolos(tema);
+  if (counts.errors === 0 && counts.warnings === 0 && counts.infos === 0) return "";
+  const partes = [];
+  if (counts.errors > 0) partes.push(pinta(tema, "rojo", `${s.error} ${counts.errors} ${counts.errors === 1 ? "error" : "errores"}`));
+  if (counts.warnings > 0) partes.push(pinta(tema, "amarillo", `${s.aviso} ${counts.warnings} ${counts.warnings === 1 ? "aviso" : "avisos"}`));
+  if (counts.infos > 0) partes.push(pinta(tema, "azul", `${s.info} ${counts.infos} ${counts.infos === 1 ? "nota" : "notas"}`));
+  return `  ${partes.join(pinta(tema, "gris", ` ${s.separador} `))}`;
+}
+function exito(tema, texto) {
+  return `  ${pinta(tema, "verde", simbolos(tema).ok)} ${texto}`;
+}
+function siguienteAccion(tema, comando, descripcion) {
+  const s = simbolos(tema);
+  const lineas = [`    ${pinta(tema, "cian", s.flecha)} ${pinta(tema, ["cian", "negrita"], comando)}`];
+  if (descripcion) lineas.push(pinta(tema, "gris", `      ${descripcion}`));
+  return lineas;
+}
+function filaAlineada(columnas, separacion = 2) {
+  return columnas.map((columna, indice) => indice === columnas.length - 1 || columna.ancho === void 0 ? columna.texto : rellenar(columna.texto, columna.ancho)).join(" ".repeat(separacion));
+}
+function seccion(tema, titulo, detalle) {
+  const cabeza = pinta(tema, ["negrita"], titulo);
+  return detalle ? `${cabeza} ${pinta(tema, "gris", detalle)}` : cabeza;
+}
+
 // src/version.ts
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
@@ -37665,7 +37762,7 @@ async function runCi(ctx) {
   }
   const gate = await runCiGate({ root, strict, extra });
   const diagnostics = [...gate.diagnostics];
-  const lines = ["CI de SpecAtlas", ""];
+  const lines = encabezado(detectarTema(), "Comprobaci\xF3n continua", strict ? "modo estricto" : void 0);
   let sarifWritten;
   if (sarifPath) {
     const target = path38.resolve(ctx.cwd, sarifPath);
@@ -37681,13 +37778,18 @@ async function runCi(ctx) {
       });
     }
   }
+  const tema = detectarTema();
+  const s = simbolos(tema);
   for (const check of gate.checks) {
-    const mark = check.errors > 0 ? "FALLA" : check.warnings > 0 ? "AVISO" : "OK  ";
-    lines.push(`  ${mark} ${check.name}: ${check.errors} errores, ${check.warnings} avisos`);
+    const marca = check.errors > 0 ? pinta(tema, "rojo", s.error) : check.warnings > 0 ? pinta(tema, "amarillo", s.aviso) : pinta(tema, "verde", s.ok);
+    const detalle = check.errors === 0 && check.warnings === 0 ? pinta(tema, "gris", "sin hallazgos") : [check.errors > 0 ? pinta(tema, "rojo", `${check.errors} ${check.errors === 1 ? "error" : "errores"}`) : "", check.warnings > 0 ? pinta(tema, "amarillo", `${check.warnings} ${check.warnings === 1 ? "aviso" : "avisos"}`) : ""].filter((parte) => parte !== "").join(pinta(tema, "gris", ` ${s.separador} `));
+    lines.push(filaAlineada([{ texto: `  ${marca} ${check.name}`, ancho: 46 }, { texto: detalle }]));
   }
   lines.push("");
-  lines.push(gate.failed ? "Resultado: BLOQUEADO" : "Resultado: OK");
-  if (strict) lines.push("(modo estricto: los avisos tambi\xE9n bloquean)");
+  lines.push(
+    gate.failed ? `  ${pinta(tema, ["rojo", "negrita"], `${s.error} BLOQUEADO`)}${pinta(tema, "gris", " \u2014 resuelve los hallazgos antes de continuar")}` : `  ${pinta(tema, ["verde", "negrita"], `${s.ok} TODO EN ORDEN`)}`
+  );
+  if (strict) lines.push(pinta(tema, "gris", "  (modo estricto: los avisos tambi\xE9n bloquean)"));
   if (sarifPath) {
     lines.push(sarifWritten ? `Informe SARIF: ${sarifWritten} (${gate.diagnostics.length} hallazgo(s))` : `Informe SARIF: no se pudo escribir en "${sarifPath}"`);
   }
@@ -38072,7 +38174,7 @@ assumptions: []
 }
 
 // src/commands/doctor.ts
-import path44 from "path";
+import "path";
 async function runDoctorCommand(ctx) {
   const { root, config } = await requireWorkspace(ctx);
   const report = await runDoctor(root);
@@ -38092,17 +38194,10 @@ async function runDoctorCommand(ctx) {
   const advisory = await upgradeAdvisory(root);
   report.findings.push(...advisory.diagnostics);
   report.summary = countBySeverity(report.findings);
-  const lines = [msg("doctor.title", ctx.language), ""];
+  const tema = detectarTema();
+  const lines = encabezado(tema, msg("doctor.title", ctx.language));
   if (report.findings.length === 0) {
-    lines.push("Sin hallazgos. El workspace est\xE1 sano.");
-  } else {
-    for (const finding of report.findings) {
-      const location = finding.path ? ` ${path44.relative(ctx.cwd, finding.path)}${finding.line ? `:${finding.line}` : ""}` : "";
-      lines.push(`  ${finding.severity.toUpperCase()}  ${finding.code}${location} \u2014 ${finding.message}`);
-      if (finding.suggestion) lines.push(`       \u21B3 ${finding.suggestion}`);
-    }
-    lines.push("");
-    lines.push(`${report.summary.errors} errores, ${report.summary.warnings} avisos, ${report.summary.infos} notas`);
+    lines.push(exito(tema, "El workspace est\xE1 sano."));
   }
   return {
     exitCode: report.summary.errors > 0 ? 1 : 0,
@@ -39267,21 +39362,28 @@ async function runNext(ctx) {
       text: [`\u25B6 ${action.command}`, "", ...outcome.result.text ?? []]
     };
   }
-  const lines = [msg("next.title", ctx.language), ""];
+  const tema = detectarTema();
+  const s = simbolos(tema);
+  const lines = encabezado(tema, msg("next.title", ctx.language));
   const data = [];
   let hasErrors2 = false;
   for (const change of targets) {
     const evaluation = await evaluateChange(workspace, config, change, approvals);
     if (evaluation.blocking > 0) hasErrors2 = true;
     const { state, nextAction, blockedBy } = evaluation.state;
-    lines.push(`  ${change.slug} \u2014 ${stateLabel(state)}`);
-    lines.push(`    ${msg("status.next", ctx.language)} ${nextAction.command}`);
-    lines.push(`    ${nextAction.description}${nextAction.requiresAgent ? " (requiere agente)" : ""}`);
-    for (const block of blockedBy) lines.push(`    bloqueado por: ${block}`);
+    const actor = nextAction.requiresAgent ? pinta(tema, "azul", "con agente") : /^satlas (approve|archive|amend|pause|resume)/.test(nextAction.command) ? pinta(tema, "morado", "humana") : pinta(tema, "verde", "local");
+    lines.push(
+      filaAlineada([
+        { texto: `  ${pinta(tema, "negrita", change.slug)}`, ancho: 30 },
+        { texto: pinta(tema, "gris", stateLabel(state)) }
+      ])
+    );
+    lines.push(...siguienteAccion(tema, nextAction.command, `${nextAction.description}  ${s.separador}  ${actor}`));
+    for (const block of blockedBy) lines.push(`      ${pinta(tema, "amarillo", s.bloqueo)} ${pinta(tema, "gris", block)}`);
     lines.push("");
     data.push({ slug: change.slug, state, next: nextAction.command, blockedBy, requiresAgent: nextAction.requiresAgent });
   }
-  if (targets.length === 0) lines.push("Sin cambios activos.");
+  if (targets.length === 0) lines.push(pinta(tema, "gris", "  Sin cambios activos."));
   return { exitCode: hasErrors2 ? 1 : 0, diagnostics: [], data: { changes: data }, text: lines };
 }
 
@@ -39568,20 +39670,52 @@ async function avisoDeActualizacion(json2, cwd) {
 }
 
 // src/commands/status.ts
+var TONO_ESTADO = {
+  draft: "gris",
+  spec_draft: "amarillo",
+  paused: "amarillo",
+  awaiting_mockups: "morado",
+  awaiting_approval: "morado",
+  approved: "azul",
+  planned: "azul",
+  building: "azul",
+  built: "amarillo",
+  verified: "verde",
+  reviewed: "verde",
+  ready: "verde",
+  archived: "gris"
+};
+function marcaDeEstado(tema, estado, bloqueado) {
+  const s = simbolos(tema);
+  if (bloqueado) return pinta(tema, "rojo", s.bloqueo);
+  if (estado === "paused") return pinta(tema, "amarillo", s.pausa);
+  if (estado === "ready") return pinta(tema, "verde", s.ok);
+  return pinta(tema, TONO_ESTADO[estado] ?? "azul", s.punto);
+}
 async function runStatus(ctx) {
   const { root, workspace, config, approvals } = await requireWorkspace(ctx);
   const advisory = await upgradeAdvisory(root);
-  const lines = [msg("status.title", ctx.language), ""];
+  const tema = detectarTema();
+  const s = simbolos(tema);
+  const fixes = await loadLivingFixes(root);
+  const contexto = [
+    `${workspace.specs.length} ${workspace.specs.length === 1 ? "spec viva" : "specs vivas"}`,
+    `${workspace.changes.length} ${workspace.changes.length === 1 ? "cambio" : "cambios"}`,
+    fixes.length > 0 ? `${fixes.length} ${fixes.length === 1 ? "fix" : "fixes"}` : ""
+  ].filter((parte) => parte !== "").join(` ${s.separador} `);
+  const lines = encabezado(tema, msg("status.title", ctx.language), `${config.project.name} ${s.separador} ${contexto}`);
   const changes = [];
   if (workspace.changes.length === 0) {
-    lines.push("Sin cambios activos. Crea uno con `satlas new <slug>`.");
+    lines.push(pinta(tema, "gris", `  Sin cambios activos. Crea uno con \`satlas new <slug>\`.`));
   }
   for (const change of workspace.changes) {
     const evaluation = await evaluateChange(workspace, config, change, approvals);
-    const { state, progress, nextAction } = evaluation.state;
+    const { state, progress, nextAction, blockedBy } = evaluation.state;
+    const lane = change.meta?.lane ?? config.lanes.default;
+    const bloqueado = blockedBy.length > 0 || evaluation.blocking > 0;
     changes.push({
       slug: change.slug,
-      lane: change.meta?.lane ?? config.lanes.default,
+      lane,
       domain: change.meta?.domain,
       state,
       label: stateLabel(state),
@@ -39590,27 +39724,48 @@ async function runStatus(ctx) {
       blocking: evaluation.blocking
     });
     lines.push(
-      `  ${change.slug}  ${(change.meta?.domain ?? "-").padEnd(10)} ${(change.meta?.lane ?? config.lanes.default).padEnd(9)} ${stateLabel(state)}`
-    );
-    lines.push(
-      `    ${msg("status.tasks", ctx.language)} ${progress.tasksDone}/${progress.tasksTotal} \xB7 ${msg("status.evidence", ctx.language)} ${progress.scenariosEvidenced}/${progress.scenariosTotal}`
+      filaAlineada([
+        { texto: `  ${marcaDeEstado(tema, state, bloqueado)} ${pinta(tema, "negrita", change.slug)}`, ancho: 30 },
+        { texto: pinta(tema, TONO_ESTADO[state] ?? "azul", stateLabel(state)), ancho: 22 },
+        { texto: pinta(tema, "gris", `${change.meta?.domain ?? "\u2014"} ${s.separador} ${lane}`) }
+      ])
     );
-    lines.push(`    ${msg("status.next", ctx.language)} ${nextAction.command} \u2014 ${nextAction.description}`);
+    const medidas = [
+      `${pinta(tema, "gris", "tareas")} ${barraProgreso(tema, progress.tasksDone, progress.tasksTotal)}`,
+      `${pinta(tema, "gris", "evidencia")} ${barraProgreso(tema, progress.scenariosEvidenced, progress.scenariosTotal)}`
+    ];
+    lines.push(`      ${medidas.join(pinta(tema, "gris", `  ${s.separador}  `))}`);
+    for (const bloqueo of blockedBy) lines.push(`      ${pinta(tema, "amarillo", s.bloqueo)} ${pinta(tema, "gris", bloqueo)}`);
+    lines.push(...siguienteAccion(tema, nextAction.command, nextAction.description));
+    lines.push("");
   }
-  lines.push("");
-  lines.push(`${msg("status.specs", ctx.language)}: ${workspace.specs.length}`);
-  for (const spec of workspace.specs) {
-    lines.push(`  ${spec.domain} \u2014 ${spec.spec.requirements.length} requisitos`);
+  if (workspace.specs.length > 0) {
+    lines.push(seccion(tema, msg("status.specs", ctx.language), `${workspace.specs.length}`));
+    const ancho = Math.max(...workspace.specs.map((spec) => spec.domain.length), 8);
+    for (const spec of workspace.specs) {
+      lines.push(
+        filaAlineada([
+          { texto: `  ${pinta(tema, "morado", s.punto)} ${spec.domain}`, ancho: ancho + 6 },
+          { texto: pinta(tema, "gris", `${spec.spec.requirements.length} ${spec.spec.requirements.length === 1 ? "requisito" : "requisitos"}`) }
+        ])
+      );
+    }
+    lines.push("");
   }
-  const fixes = await loadLivingFixes(root);
-  lines.push("");
-  lines.push(`${msg("status.fixes", ctx.language)}: ${fixes.length}`);
+  lines.push(seccion(tema, msg("status.fixes", ctx.language), `${fixes.length}`));
   if (fixes.length === 0) {
-    lines.push("  (se llenan al archivar un fix)");
+    lines.push(pinta(tema, "gris", "  (se llenan al archivar un fix)"));
   } else {
     for (const fix of fixes) {
-      const origin = fix.source === "archive" ? " (hist\xF3rico)" : "";
-      lines.push(`  ${fix.date || "\u2014"}  ${(fix.domain ?? "\u2014").padEnd(10)} ${fix.slug} \u2014 ${fix.result}${origin}`);
+      const resultado = fix.result === "pass" ? pinta(tema, "verde", fix.result) : pinta(tema, "rojo", fix.result);
+      lines.push(
+        filaAlineada([
+          { texto: `  ${pinta(tema, "gris", fix.date || "\u2014")}`, ancho: 14 },
+          { texto: pinta(tema, "gris", fix.domain ?? "\u2014"), ancho: 14 },
+          { texto: fix.slug, ancho: 28 },
+          { texto: `${resultado}${fix.source === "archive" ? pinta(tema, "gris", " (hist\xF3rico)") : ""}` }
+        ])
+      );
     }
   }
   const diagnostics = [...workspace.diagnostics, ...advisory.diagnostics];
@@ -39620,7 +39775,7 @@ async function runStatus(ctx) {
     diagnostics,
     data: {
       changes,
-      specs: workspace.specs.map((s) => ({ domain: s.domain, requirements: s.spec.requirements.length })),
+      specs: workspace.specs.map((spec) => ({ domain: spec.domain, requirements: spec.spec.requirements.length })),
       fixes: fixes.map((fix) => ({
         slug: fix.slug,
         date: fix.date,
@@ -39794,8 +39949,10 @@ async function runValidate(ctx) {
   const slug = flagString(ctx.flags, "change");
   const strict = flagBool(ctx.flags, "strict");
   const advisory = slug ? void 0 : await upgradeAdvisory(root);
+  const tema = detectarTema();
+  const s = simbolos(tema);
   const diagnostics = [];
-  const lines = [msg("validate.title", ctx.language), ""];
+  const lines = encabezado(tema, msg("validate.title", ctx.language), slug ? slug : void 0);
   for (const spec of workspace.specs) {
     diagnostics.push(...lintSpec(spec.spec, { language: config.spec.language, businessOnly: config.spec.business_only }));
   }
@@ -39811,11 +39968,15 @@ async function runValidate(ctx) {
     const evaluation = await evaluateChange(workspace, config, change, approvals);
     diagnostics.push(...evaluation.lintFindings);
     changes.push({ slug: change.slug, blocking: evaluation.blocking, findings: evaluation.lintFindings.length });
-    lines.push(`  ${change.slug}: ${evaluation.lintFindings.length} ${msg("summary.findings", ctx.language)}`);
-    for (const finding of evaluation.lintFindings) {
-      lines.push(`    ${finding.severity.toUpperCase()} ${finding.code}${finding.line ? `:${finding.line}` : ""} \u2014 ${finding.message}`);
-    }
-    lines.push(`    archivo: ${path59.relative(ctx.cwd, path59.join(change.dir, "spec.md"))}`);
+    const errores = evaluation.lintFindings.filter((finding) => finding.severity === "error").length;
+    const marca = errores > 0 ? pinta(tema, "rojo", s.error) : evaluation.lintFindings.length > 0 ? pinta(tema, "amarillo", s.aviso) : pinta(tema, "verde", s.ok);
+    lines.push(
+      filaAlineada([
+        { texto: `  ${marca} ${pinta(tema, "negrita", change.slug)}`, ancho: 30 },
+        { texto: evaluation.lintFindings.length === 0 ? pinta(tema, "gris", "sin hallazgos") : `${evaluation.lintFindings.length} ${msg("summary.findings", ctx.language)}`, ancho: 20 },
+        { texto: pinta(tema, "gris", path59.relative(ctx.cwd, path59.join(change.dir, "spec.md"))) }
+      ])
+    );
   }
   if (targets.length === 0) lines.push("Sin cambios activos.");
   if (advisory && advisory.plan.pending.length > 0) {
@@ -39823,7 +39984,10 @@ async function runValidate(ctx) {
   }
   const errors = diagnostics.filter((d) => d.severity === "error").length;
   const warnings = diagnostics.filter((d) => d.severity === "warning").length;
-  if (errors === 0 && warnings === 0) lines.push(msg("validate.ok", ctx.language));
+  if (errors === 0 && warnings === 0) {
+    lines.push("");
+    lines.push(exito(tema, msg("validate.ok", ctx.language)));
+  }
   return {
     exitCode: errors > 0 || strict && warnings > 0 ? 1 : 0,
     diagnostics: advisory ? [...diagnostics, ...advisory.diagnostics] : diagnostics,
@@ -40192,15 +40356,28 @@ function printResult(command, result, json2, language) {
 `);
     return;
   }
+  const tema = detectarTema();
   const lines = [...result.text ?? []];
+  if (result.diagnostics.length > 0) lines.push("");
   for (const d of result.diagnostics) {
-    const location = d.path ? ` ${path62.relative(process.cwd(), d.path)}${d.line ? `:${d.line}` : ""}` : "";
-    lines.push(`${d.severity === "error" ? "ERROR" : d.severity === "warning" ? "AVISO" : "NOTA"}  ${d.code}${location} \u2014 ${d.message}`);
-    if (d.suggestion) lines.push(`       \u21B3 ${d.suggestion}`);
+    const ruta = d.path ? path62.relative(process.cwd(), d.path) : void 0;
+    lines.push(
+      ...formatearDiagnostico(
+        tema,
+        {
+          code: d.code,
+          severity: d.severity,
+          message: d.message,
+          ...d.line !== void 0 ? { line: d.line } : {},
+          ...d.suggestion !== void 0 ? { suggestion: d.suggestion } : {}
+        },
+        ruta
+      )
+    );
   }
-  const counts = countBySeverity(result.diagnostics);
   if (result.diagnostics.length > 0) {
-    lines.push(`${counts.errors} ${msg("label.errors", language)}, ${counts.warnings} ${msg("label.warnings", language)}, ${counts.infos} ${msg("label.infos", language)}`);
+    lines.push("");
+    lines.push(resumenHallazgos(tema, countBySeverity(result.diagnostics)));
   }
   if (lines.length > 0) process.stdout.write(`${lines.join("\n")}
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specatlas",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "description": "SpecAtlas: kernel determinista de Spec-Driven Development (CLI)",
   "license": "MIT",
   "type": "module",