xonecode 0.1.0

package/dist/cli/run.js

@@ -0,0 +1,164 @@
+import { correrTurno } from "../core/turno.js";
+import { pedirDecisiones, preguntarPorStdin } from "./aprobar.js";
+import { crearPielStdio, escribirEnStdout } from "./stdio.js";
+import { AgenteGuionizado } from "../agent/guionizado.js";
+import { esDoble } from "../core/ports.js";
+import { inspeccionar } from "../agent/entorno.js";
+import { tomarInstantanea } from "../agent/instantanea.js";
+import { SkillsEnDisco } from "../agent/skills.js";
+import { Modelos } from "../agent/modelos.js";
+import { abrirSesionReal } from "../agent/turnoReal.js";
+/** La cabecera del turno real: qué hay detrás antes de que empiece a gastar. */
+function cabecera(escribir, modelos, skills, instantanea, entorno) {
+    const desc = modelos.descripcion();
+    const papeles = ["rapido", "trabajo", "afilado"];
+    escribir("--- turno real ---\n");
+    for (const p of papeles)
+        escribir(`  ${p.padEnd(8)} ${desc[p]}\n`);
+    escribir(`  skills: ${skills.catalogo().length}\n`);
+    escribir(`  foto del ANTES: ${instantanea.via === "git" ? "git" : "huellas de fichero"}\n`);
+    if (entorno.vistasAplanadas.length > 0) {
+        escribir(`  ${entorno.vistasAplanadas.length} vista(s) aplanada(s) .xml ocultas al agente\n`);
+    }
+    escribir("\n");
+}
+/**
+ * Un disparo: una petición, un turno, y a la calle. Pipeable.
+ *
+ * Devuelve el código de salida. **Una pausa sin humano no es un éxito**: en modo un
+ * disparo no hay a quién preguntar, así que se sale con código distinto de cero para que
+ * CI no lea como «hecho» un turno que se quedó esperando una aprobación que nadie iba a
+ * dar. No se aprueba por omisión: aprobar EJECUTA, y ante la duda va la opción recuperable.
+ */
+export async function cmdRun(opciones) {
+    const escribir = opciones.escribir ?? escribirEnStdout;
+    if (opciones.real)
+        return correrReal(opciones, escribir);
+    const agente = new AgenteGuionizado(opciones.retardoMs ?? 0);
+    const piel = crearPielStdio(escribir);
+    if (esDoble(agente)) {
+        escribir("⚠  AGENTE DE PEGA: esto es un guion, no ha corrido ningún modelo.\n\n");
+    }
+    let pausado = false;
+    const pielQueApunta = {
+        ...piel,
+        pausa: (pendientes) => {
+            pausado = true;
+            piel.pausa(pendientes);
+        },
+    };
+    const bitacora = await correrTurno(agente.turno(opciones.peticion), pielQueApunta, {
+        avisos: (b) => (b.corrio("verify") && esDoble(agente) ? ["⚠  El veredicto es de pega."] : []),
+    });
+    if (pausado) {
+        escribir("\n(sin humano en modo `run`: nada se aprobó y nada se aplicó)\n");
+        return 2;
+    }
+    return bitacora.corrio("bloqueado") ? 1 : 0;
+}
+/**
+ * Excepción centinela del corte «sin humano»: privada a este fichero, nunca una genérica
+ * (un `Error` suelto se confundiría con un fallo real del turno).
+ *
+ * Para qué existe: `sesion.turno` SIEMPRE reanuda el grafo tras `pedirAprobacion`, incluso
+ * si todas las decisiones son rechazos —es lo correcto para la consola, donde el modelo
+ * tiene que saber que se rechazó. Pero el `run` de un disparo sin terminal es otro caso:
+ * los rechazos no los dio un humano sino el fail-closed, reanudar gastaría una llamada más
+ * al modelo sin que nadie vaya a cambiar de respuesta, y el comportamiento exigido es NO
+ * reanudar, dar el diff y salir con 2. La única forma de colgar la reanudación sin tocar
+ * `turnoReal.ts` es lanzar en el callback: el corte ocurre DESPUÉS de preguntar y decidir,
+ * o sea la pregunta y el «→ rechazado» se ven igual que siempre.
+ */
+class CorteSinHumano extends Error {
+}
+/** El turno real, en el orden del plan: entorno → foto → sesión → cabecera → turno → cambios. */
+async function correrReal(opciones, escribir) {
+    const raiz = process.cwd();
+    const piel = crearPielStdio(escribir);
+    // 1. ¿Hay un proyecto aquí? Mismo diagnóstico que `doctor`, misma frase: no construir
+    //    NADA sobre un sitio que no es un proyecto XOne.
+    const entorno = await inspeccionar(raiz);
+    if (!entorno.esProyectoXone) {
+        escribir(`${entorno.raiz}  (no hay app.xml aquí)\n`);
+        escribir("✗ falta algo imprescindible: xonecode no puede trabajar aquí.\n");
+        return 1;
+    }
+    // 2. La foto del ANTES, ANTES de construir nada: además de anunciarla en la cabecera, es
+    //    la fuente del diff de la rama «sin humano» —esa rama sale por la centinela ANTES de
+    //    que el turno devuelva nada, así que no puede usar el diff por-turno de la sesión.
+    const instantanea = await tomarInstantanea(raiz, entorno.git);
+    // 3. Lo que la sesión necesita. Los ficheros del proyecto NO se calculan aquí: los
+    //    recorre la propia sesión al construir el agente.
+    const skills = new SkillsEnDisco();
+    const modelos = new Modelos(opciones.fuentes ?? {});
+    // 4. La cabecera va ANTES del turno: qué modelo, cuántas skills, cómo se tomó la foto.
+    cabecera(escribir, modelos, skills, instantanea, entorno);
+    // Con TTY el Enter aprueba; sin él NO, y es deliberado: en un pipe o en CI una línea en
+    // blanco no demuestra que haya nadie mirando, y esto aprueba escrituras sobre un
+    // proyecto real. La regla vive en `interpretAnswer`; aquí solo se le dice si hay TTY.
+    const interactivo = process.stdin.isTTY === true;
+    const preguntar = preguntarPorStdin();
+    let sinHumano = false;
+    const sesion = await abrirSesionReal({
+        raiz,
+        modelos,
+        skills,
+        entorno,
+        pedirAprobacion: async (lista, ficheros, diffs) => {
+            // **Se pregunta SIEMPRE, con TTY o sin él.** Cortar aquí sin preguntar dejaría
+            // muerto el conjunto de respuestas sin-TTY de `interpretAnswer`, que existe
+            // precisamente para que en un pipe o en CI se pueda aprobar con un `s` EXPLÍCITO.
+            // La garantía no la da negarse a preguntar, la da la asimetría: sin un sí
+            // explícito, es rechazo. Y si stdin está cerrado, `preguntarPorStdin` resuelve con
+            // cadena vacía — o sea, rechazo.
+            if (!interactivo) {
+                escribir(`\n⏸  ${lista.length} escritura(s) piden aprobación, y no hay terminal.\n`);
+                escribir("   Sin un «s» explícito se rechazan (una línea en blanco NO aprueba).\n");
+            }
+            const decisiones = await pedirDecisiones(lista, preguntar, escribir, {
+                interactive: interactivo,
+                fichero: (id) => ficheros.get(id),
+                diff: (id) => diffs.get(id),
+            });
+            if (!interactivo && [...decisiones.values()].every((d) => d.type === "reject")) {
+                sinHumano = true;
+                throw new CorteSinHumano();
+            }
+            return decisiones;
+        },
+    });
+    // 5-6. El turno: la sesión conduce el stream y el bucle de aprobación — el tope de
+    // rondas lo controla ella. La centinela recorta el caso «sin humano» antes de la
+    // reanudación; cualquier otro throw sigue siendo un fallo real y se propaga.
+    let bitacora = null;
+    let cambios;
+    let cortadoPorTope = false;
+    try {
+        ({ bitacora, cambios, cortadoPorTope } = await sesion.turno(opciones.peticion, piel));
+    }
+    catch (e) {
+        if (!(e instanceof CorteSinHumano))
+            throw e;
+        cambios = await instantanea.cambios();
+    }
+    // 7. El diff contra la foto. Un turno que no tocó nada TIENE que verse igual.
+    escribir("\n--- cambios en el proyecto ---\n");
+    if (cambios.length === 0) {
+        escribir("sin cambios en el proyecto\n");
+    }
+    else {
+        for (const c of cambios)
+            escribir(`  [${c.clase}] ${c.ruta}\n`);
+    }
+    if (sinHumano) {
+        escribir("\n(sin humano en modo `run`: nada se aprobó y nada se aplicó)\n");
+        return 2;
+    }
+    // Agotar el tope de rondas es el MISMO desenlace que quedarse sin humano: hay escrituras
+    // sin resolver y nada se aplicó. Sin esta línea caía al camino normal y salía 0 — o sea,
+    // CI habría leído como éxito un turno que se quedó a medias.
+    if (cortadoPorTope)
+        return 2;
+    return bitacora.corrio("bloqueado") ? 1 : 0;
+}
+//# sourceMappingURL=run.js.map

package/dist/cli/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","sourceRoot":"","sources":["../../src/cli/run.ts"],"names":[],"mappings":"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"}

package/dist/cli/spinner.js

@@ -0,0 +1,89 @@
+/**
+ * El spinner de fase: `⠋ planificando (12s)` animando LA ÚLTIMA línea.
+ *
+ * En una consola que no repinta, solo la última línea escrita se puede volver a
+ * pintar (con `\r`), y solo mientras nadie más escriba: eso es exactamente una fase
+ * del agente, que llena los segundos en que no pasa nada visible. La disciplina de
+ * «una sola línea al fondo» es la cascada: **cualquier otra escritura termina el
+ * spinner primero**, y el historial no se toca — la fase queda como línea estática,
+ * igual que ha salido siempre.
+ *
+ * Sin TTY (tema sin color) no hay nada que animar: la misma línea estática de
+ * siempre, y ningún temporizador.
+ */
+const CUADROS = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/** Los segundos que lleva la fase: vacío hasta que cumple el primer segundo. */
+export function sufijoDeTiempo(ms) {
+    const s = Math.floor(ms / 1000);
+    return s > 0 ? ` (${s}s)` : "";
+}
+export class AnimadorDeFase {
+    escribir;
+    tema;
+    intervalo;
+    reloj;
+    cuadro = 0;
+    texto = "";
+    t0 = 0;
+    temporizador;
+    constructor(escribir, tema, 
+    /** Cómo de seguido repinta el fotograma. Entra por parámetro para los tests. */
+    intervalo = 120, 
+    /** El reloj, inyectado por la misma razón: un test mueve el tiempo, no lo espera. */
+    reloj = Date.now) {
+        this.escribir = escribir;
+        this.tema = tema;
+        this.intervalo = intervalo;
+        this.reloj = reloj;
+    }
+    activo() {
+        return this.texto !== "";
+    }
+    /**
+     * Empieza a animar una fase. Sin color es la línea estática de siempre y no arranca
+     * nada; con color, la fase anterior (si la había) queda como línea estática.
+     */
+    empieza(texto) {
+        if (this.tema.borrar === "") {
+            this.escribir(`  ·  ${texto}\n`);
+            return;
+        }
+        this.termina();
+        this.texto = texto;
+        this.t0 = this.reloj();
+        this.cuadro = 0;
+        this.pinta();
+        this.temporizador = setInterval(() => this.pinta(), this.intervalo);
+        // Un spinner olvidado no puede colgar el proceso: el temporizador no mantiene el
+        // bucle de eventos vivo por sí solo.
+        this.temporizador.unref();
+    }
+    /**
+     * Repinta el fotograma. Público a propósito: el `setInterval` llama aquí, y los
+     * tests también — sin esperar 120 ms de verdad.
+     */
+    pinta() {
+        if (!this.activo())
+            return;
+        // Se pinta el cuadro y DESPUÉS se avanza: el primer fotograma es el ⠋, no el
+        // segundo — la fase que empieza no debería llegar ya movida.
+        this.escribir(`\r  ${this.tema.mudo}${CUADROS[this.cuadro]} ${this.texto}` +
+            `${sufijoDeTiempo(this.reloj() - this.t0)}${this.tema.reset}`);
+        this.cuadro = (this.cuadro + 1) % CUADROS.length;
+    }
+    /**
+     * Deja la fase como línea estática en el historial y para el reloj. Sin fase activa
+     * no escribe nada: la cascada lo llama antes de CUALQUIER otra escritura.
+     */
+    termina() {
+        if (!this.activo())
+            return;
+        if (this.temporizador !== undefined)
+            clearInterval(this.temporizador);
+        // El borrado limpia lo que el fotograma animado dejara escrito más allá de la
+        // línea estática: «(12s)» es más largo que el punto de la línea definitiva.
+        this.escribir(`\r${this.tema.borrar}  ·  ${this.texto}\n`);
+        this.texto = "";
+    }
+}
+//# sourceMappingURL=spinner.js.map

package/dist/cli/spinner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spinner.js","sourceRoot":"","sources":["../../src/cli/spinner.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AAEH,MAAM,OAAO,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAU,CAAC;AAE5E,gFAAgF;AAChF,MAAM,UAAU,cAAc,CAAC,EAAU;IACvC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC;IAChC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;AACjC,CAAC;AAED,MAAM,OAAO,cAAc;IAON;IACA;IAEA;IAEA;IAXX,MAAM,GAAG,CAAC,CAAC;IACX,KAAK,GAAG,EAAE,CAAC;IACX,EAAE,GAAG,CAAC,CAAC;IACP,YAAY,CAA6C;IAEjE,YACmB,QAAkB,EAClB,IAAU;IAC3B,gFAAgF;IAC/D,YAAY,GAAG;IAChC,qFAAqF;IACpE,QAAsB,IAAI,CAAC,GAAG;QAL9B,aAAQ,GAAR,QAAQ,CAAU;QAClB,SAAI,GAAJ,IAAI,CAAM;QAEV,cAAS,GAAT,SAAS,CAAM;QAEf,UAAK,GAAL,KAAK,CAAyB;IAC9C,CAAC;IAEJ,MAAM;QACJ,OAAO,IAAI,CAAC,KAAK,KAAK,EAAE,CAAC;IAC3B,CAAC;IAED;;;OAGG;IACH,OAAO,CAAC,KAAa;QACnB,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,EAAE,EAAE,CAAC;YAC5B,IAAI,CAAC,QAAQ,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC;YACjC,OAAO;QACT,CAAC;QACD,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;QACvB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;QAChB,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QACpE,iFAAiF;QACjF,qCAAqC;QACrC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACH,KAAK;QACH,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YAAE,OAAO;QAC3B,6EAA6E;QAC7E,6DAA6D;QAC7D,IAAI,CAAC,QAAQ,CACX,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK,EAAE;YAC1D,GAAG,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAChE,CAAC;QACF,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IACnD,CAAC;IAED;;;OAGG;IACH,OAAO;QACL,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YAAE,OAAO;QAC3B,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS;YAAE,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACtE,8EAA8E;QAC9E,4EAA4E;QAC5E,IAAI,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,MAAM,QAAQ,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC;QAC3D,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;IAClB,CAAC;CACF"}

package/dist/cli/stdio.js

@@ -0,0 +1,193 @@
+import { crearTema } from "./tema.js";
+import { RenderizadorDeMarkdown, puntoSeguro } from "./markdown.js";
+import { AnimadorDeFase } from "./spinner.js";
+/**
+ * Por debajo de esto, un párrafo que aún no ha visto su `\n` puede esperar: fluye al
+ * confirmarse la línea. Por encima, se corta por un punto seguro (`puntoSeguro`) para
+ * que el streaming siga vivo en los párrafos largos.
+ */
+const MINIMO_DE_FLUJO = 80;
+/**
+ * La piel de terminal.
+ *
+ * El streaming del asistente se suelta por LÍNEA CONFIRMADA (y, en párrafos largos, por
+ * cortes que no rompen marcadores), y no por trozo: una consola que NO repinta solo
+ * puede escribir una línea cuando su texto es definitivo — un `**` partido entre dos
+ * escrituras queda literal para siempre. Sigue siendo streaming: la línea confirmada
+ * se pinta en el acto, y un colchón que solo se suelta al final sería un `ainvoke`
+ * disfrazado.
+ *
+ * Las otras dos cosas medidas, con el mismo síntoma (el streaming no se ve) y causas
+ * distintas:
+ *
+ * 1. **`flush` explícito** (en `escribirEnStdout`). Sin él la salida se queda en el
+ *    buffer y no aparece hasta que se vacía sola — un fallo que solo se manifiesta en
+ *    procesos de larga duración, o sea justo en el caso de uso real.
+ * 2. **Un solo `escribir` por línea confirmada**: juntar trozos en un buffer y volcar
+ *    al final también evita frases partidas, pero deja de ser streaming.
+ */
+export function crearPielStdio(escribir, tema = crearTema(process.stdout.isTTY === true)) {
+    const render = new RenderizadorDeMarkdown(tema);
+    let colchon = "";
+    let inicioDeLinea = true;
+    // El spinner de fase: anima la ÚLTIMA línea mientras una fase dura. La cascada es
+    // esta `firme`: CUALQUIER otra escritura termina el spinner primero — así solo hay
+    // una línea viva al fondo, y el historial queda con la fase como línea estática.
+    const animador = new AnimadorDeFase(escribir, tema);
+    const firme = (t) => {
+        animador.termina();
+        escribir(t);
+    };
+    const volcar = (linea, inicio, conSalto) => {
+        firme(render.linea(linea, inicio) + (conSalto ? "\n" : ""));
+    };
+    return {
+        token: (texto) => {
+            colchon += texto;
+            // Las líneas confirmadas se sueltan enteras y en el acto.
+            while (true) {
+                const salto = colchon.indexOf("\n");
+                if (salto === -1)
+                    break;
+                volcar(colchon.slice(0, salto), inicioDeLinea, true);
+                colchon = colchon.slice(salto + 1);
+                inicioDeLinea = true;
+            }
+            // Párrafo largo sin `\n` a la vista: fluir por un corte que no rompa marcadores.
+            // **Sin salto final**: la continuación sigue en la MISMA línea de terminal — un
+            // salto aquí partiría el párrafo en líneas de la longitud del corte. Y
+            // `inicioDeLinea` baja a false para que la continuación no se mire como cabecera
+            // ni viñeta: ya no empieza línea.
+            const corte = puntoSeguro(colchon, MINIMO_DE_FLUJO);
+            if (corte !== undefined) {
+                volcar(colchon.slice(0, corte), inicioDeLinea, false);
+                colchon = colchon.slice(corte);
+                inicioDeLinea = false;
+            }
+        },
+        cerrarLinea: () => {
+            // Lo que quede en el colchón es el final de la última línea. Si el mensaje acabó
+            // justo en un salto, no hay nada que añadir: esa línea ya se escribió entera.
+            if (colchon !== "")
+                volcar(colchon, inicioDeLinea, true);
+            colchon = "";
+            inicioDeLinea = true;
+        },
+        linea: (texto) => firme(`  ${texto}\n`),
+        /**
+         * La fase, animada: sin TTY el propio animador escribe la línea estática de
+         * siempre y no arranca nada.
+         */
+        fase: (texto) => animador.empieza(texto),
+        pausa: (pendientes) => {
+            // Quien pinta el detalle de cada pendiente (origen, descripción, fichero) es
+            // `pedirDecisiones`, al preguntar una a una. Aquí sería redundante, y el viejo
+            // «responde: approve / reject» además mentía: `interpretAnswer` acepta
+            // s/si/sí/y/yes, no esas palabras.
+            // En el modo de un disparo lo que sigue a la pausa NO es la respuesta del usuario:
+            // es la aprobación, que conduce `pedirDecisiones`. Decir «lo siguiente que escribas
+            // es la respuesta» sería mentira y despistaría justo en el paso delicado.
+            firme(`\n(turno pausado: ${pendientes.length} aprobación(es) pendiente(s))\n`);
+        },
+        fin: (ms) => firme(`\n(${(ms / 1000).toFixed(1)}s)\n`),
+    };
+}
+/**
+ * El `escribir` de producción. El `flush` es implícito en Node —`process.stdout.write`
+ * escribe ya—, pero se pasa por aquí para que exista UN solo sitio que cambiar si algún
+ * día hace falta forzarlo.
+ */
+export const escribirEnStdout = (texto) => {
+    process.stdout.write(texto);
+};
+/**
+ * El `preguntar` de producción para la consola: usa el ÚNICO `readline.Interface`
+ * compartido con el lazo de líneas y con `leerSecreto`. Tres lectores de stdin no pueden
+ * competir por sus eventos `data`; con un solo `rl`, `rl.question` se intercala sin
+ * robarle líneas al `for await` del lazo (es readline quien arbitra internamente).
+ *
+ * **Si el rl ya está cerrado (o se cierra a media pregunta), resuelve con cadena vacía
+ * y no lanza.** Es el EOF de un pipe que se agota mientras el turno corre — medido en
+ * e2e: la aprobación pregunta 20 segundos después de que stdin hiciera EOF, y el
+ * `readline was closed` abortaba el turno con el interrupt colgado. Y la cadena vacía
+ * es lo correcto además de lo seguro: `interpretAnswer` sin un «s» explícito RECHAZA.
+ * Mismo pacto que `leerSecreto` con su `alCerrar`.
+ */
+export function crearPreguntar(rl) {
+    // `rl.closed` existe en runtime pero no está en los tipos de esta versión de
+    // @types/node — mismo caso que `rl.history` abajo, y mismo cast justificado.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const cerrado = () => rl.closed === true;
+    return (pregunta) => new Promise((resolver) => {
+        const alCerrar = () => resolver("");
+        rl.once("close", alCerrar);
+        if (cerrado()) {
+            rl.off("close", alCerrar);
+            resolver("");
+            return;
+        }
+        rl.question(pregunta, (respuesta) => {
+            rl.off("close", alCerrar);
+            resolver(respuesta);
+        });
+    });
+}
+/**
+ * `leerSecreto` de producción (para `/provider <nombre>`): mismo `rl` que el lazo y
+ * `preguntar`, con el eco apagado mientras dura la pregunta.
+ *
+ * **No hay API pública de readline para silenciar el eco por tecla manteniendo la edición
+ * de línea** (backspace, etc.): la única costura es `_writeToOutput`, un método interno y
+ * no documentado — verificado contra Node 22 (existe, y es la vía que usan las
+ * herramientas de terminal que piden contraseña sin librería aparte). Se sustituye para
+ * dejar pasar SOLO el propio prompt (para que se vea la pregunta) y silenciar cualquier
+ * otra escritura —el eco de cada tecla— hasta que la pregunta termine. `rl.history`
+ * tampoco está en los tipos de esta versión de @types/node aunque existe en runtime
+ * (documentado desde Node 15.8), así que comparte el mismo cast justificado.
+ *
+ * Se restaura SIEMPRE, y por DOS vías, porque un terminal que se queda sin eco obliga al
+ * usuario a cerrarlo:
+ *   1. En el callback de `rl.question`: el camino normal.
+ *   2. En un `close` de `rl` a media pregunta (Ctrl-D/EOF sin dar línea): sin esto la
+ *      promesa no se resuelve nunca y el manejador de `/provider` se queda colgado para
+ *      siempre dentro del lazo de la consola.
+ *
+ * Y se borra la clave de `rl.history` tras leerla: readline añade la respuesta de
+ * `question` al historial igual que cualquier línea, y una flecha-arriba la recuperaría
+ * en claro en la MISMA sesión.
+ */
+export function crearLeerSecreto(rl) {
+    return (pregunta) => new Promise((resolve) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const rlAny = rl;
+        const escribirOriginal = rlAny._writeToOutput.bind(rlAny);
+        let restaurado = false;
+        const restaurar = () => {
+            if (restaurado)
+                return;
+            restaurado = true;
+            rlAny._writeToOutput = escribirOriginal;
+            rl.off("close", alCerrar);
+        };
+        const alCerrar = () => {
+            restaurar();
+            resolve("");
+        };
+        rl.once("close", alCerrar);
+        rlAny._writeToOutput = (cadena) => {
+            if (cadena === pregunta)
+                escribirOriginal(cadena);
+        };
+        rl.question(pregunta, (respuesta) => {
+            restaurar();
+            // El eco muteado se comió el '\r\n' que readline escribe al aceptar la línea: sin
+            // esto, la salida siguiente aparecería pegada a la pregunta.
+            escribirOriginal("\n");
+            const indice = rlAny.history.indexOf(respuesta);
+            if (indice !== -1)
+                rlAny.history.splice(indice, 1);
+            resolve(respuesta);
+        });
+    });
+}
+//# sourceMappingURL=stdio.js.map

package/dist/cli/stdio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.js","sourceRoot":"","sources":["../../src/cli/stdio.ts"],"names":[],"mappings":"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"}

package/dist/cli/tema.js

@@ -0,0 +1,40 @@
+/**
+ * El vocabulario de color de las pieles: tokens SEMÁNTICOS, nunca colores.
+ *
+ * Una piel pide significado (`tema.exito`, `tema.mudo`) igual que la TUI de
+ * qwen-code pide `theme.status.success`: si mañana hay temas de usuario o el diff
+ * quiere fondos en vez de texto, se cambia ESTE fichero y ninguna piel se entera.
+ * Es el mismo principio que `core/ports.ts` aplicado al color: lo que puede cambiar
+ * entra por una costura, no se pega a quien lo usa.
+ *
+ * La otra mitad del contrato: **con `conColor: false`, TODO token es cadena vacía.**
+ * Las pieles no ramifican por TTY — componen `${t.mudo}texto${t.reset}` igual en una
+ * tubería que en un terminal, y lo que mantiene limpios los pipes y los logs de CI es
+ * que el tema apagado no tiene nada que poner. (Y `src/cli/tema.test.ts` recorre
+ * `src/` entera y falla si alguien escribe un ANSI fuera de aquí.)
+ */
+const CON_COLOR = {
+    texto: "",
+    mudo: "\x1b[2m",
+    negrita: "\x1b[1m",
+    exito: "\x1b[32m",
+    aviso: "\x1b[33m",
+    grave: "\x1b[31m",
+    // Mismo código que exito/grave a propósito: son tokens distintos porque significan
+    // cosas distintas. Si el diff algún día quiere fondo de color, cambia aquí.
+    anadido: "\x1b[32m",
+    quitado: "\x1b[31m",
+    prompt: "\x1b[36m",
+    reset: "\x1b[0m",
+    borrar: "\x1b[K",
+};
+/**
+ * El tema apagado se DERIVA del encendido, no se escribe aparte: un token nuevo que
+ * se olvide de apagarse falla en el test que recorre `Object.entries`, no en un pipe
+ * de CI a las tantas.
+ */
+const SIN_COLOR = Object.fromEntries(Object.keys(CON_COLOR).map((nombre) => [nombre, ""]));
+export function crearTema(conColor) {
+    return conColor ? CON_COLOR : SIN_COLOR;
+}
+//# sourceMappingURL=tema.js.map

package/dist/cli/tema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tema.js","sourceRoot":"","sources":["../../src/cli/tema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAwBH,MAAM,SAAS,GAAS;IACtB,KAAK,EAAE,EAAE;IACT,IAAI,EAAE,SAAS;IACf,OAAO,EAAE,SAAS;IAClB,KAAK,EAAE,UAAU;IACjB,KAAK,EAAE,UAAU;IACjB,KAAK,EAAE,UAAU;IACjB,mFAAmF;IACnF,4EAA4E;IAC5E,OAAO,EAAE,UAAU;IACnB,OAAO,EAAE,UAAU;IACnB,MAAM,EAAE,UAAU;IAClB,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,QAAQ;CACjB,CAAC;AAEF;;;;GAIG;AACH,MAAM,SAAS,GAAS,MAAM,CAAC,WAAW,CACxC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAClC,CAAC;AAErB,MAAM,UAAU,SAAS,CAAC,QAAiB;IACzC,OAAO,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;AAC1C,CAAC"}

package/dist/cli/verify.js

@@ -0,0 +1,62 @@
+import { SimuladorVerifier, ErrorDelSimulador } from "../agent/verificador.js";
+import { huella } from "../core/ports.js";
+import { escribirEnStdout } from "./stdio.js";
+const MARCA = {
+    error: "✗",
+    warning: "⚠",
+    info: "·",
+};
+/** `code fichero:linea` — y sin la línea cuando no viene, que es el caso normal. */
+function donde(h) {
+    if (!h.fichero)
+        return "";
+    return h.linea === undefined ? ` ${h.fichero}` : ` ${h.fichero}:${h.linea}`;
+}
+/**
+ * Corre el verificador REAL sobre un proyecto y cuenta lo que encuentra.
+ *
+ * Sale con 1 si hay errores. Los avisos no tumban el comando: son de otra severidad y
+ * colapsarlos con los errores es una decisión de producto que nadie ha tomado.
+ */
+export async function cmdVerify(ruta, escribir = escribirEnStdout, verificador = new SimuladorVerifier()) {
+    let informe;
+    try {
+        informe = await verificador.verificar(ruta);
+    }
+    catch (e) {
+        // Que no esté el binario NO es un fallo del proyecto. Distinguirlo importa: si no,
+        // un entorno mal montado se lee como «tu proyecto está roto».
+        escribir(`✗ no se pudo verificar: ${e instanceof Error ? e.message : String(e)}\n`);
+        // La pista solo si viene al caso. Un `ErrorDelSimulador` significa que el binario
+        // CORRIÓ y contestó —lo que falla es la ruta, o el proyecto—, así que preguntar por
+        // la instalación manda a mirar donde no es: una pista falsa cuesta más que ninguna.
+        if (!(e instanceof ErrorDelSimulador)) {
+            escribir("  ¿está `xone-simulator` instalado? Compruébalo con `xonecode doctor`.\n");
+        }
+        return 70; // EX_SOFTWARE: es del entorno, no del proyecto
+    }
+    const errores = informe.hallazgos.filter((h) => h.severidad === "error");
+    const avisos = informe.hallazgos.filter((h) => h.severidad !== "error");
+    for (const h of informe.hallazgos) {
+        escribir(`  ${MARCA[h.severidad]} ${h.code}${donde(h)}\n`);
+        escribir(`      ${h.mensaje}\n`);
+    }
+    if (informe.verde) {
+        escribir(`\n✓ verde: ${ruta}\n`);
+        return 0;
+    }
+    // Las huellas REPETIDAS son el dato que delata que reparar no avanza. Se cuenta aquí
+    // porque es lo que el lazo (fase 7) va a usar para bloquear antes de gastar el tope.
+    const repetidas = new Set();
+    const vistas = new Set();
+    for (const h of informe.hallazgos) {
+        const f = huella(h);
+        if (vistas.has(f))
+            repetidas.add(f);
+        vistas.add(f);
+    }
+    escribir(`\n✗ ${errores.length} error(es), ${avisos.length} aviso(s)`);
+    escribir(repetidas.size > 0 ? `, ${repetidas.size} huella(s) repetida(s)\n` : "\n");
+    return errores.length > 0 ? 1 : 0;
+}
+//# sourceMappingURL=verify.js.map

package/dist/cli/verify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.js","sourceRoot":"","sources":["../../src/cli/verify.ts"],"names":[],"mappings":"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"}

package/dist/core/bitacora.js

@@ -0,0 +1,30 @@
+/**
+ * La bitácora de UN turno. Se construye al empezarlo y muere con él.
+ *
+ * El alcance es la mitad del valor: una bitácora de proceso haría que los avisos de
+ * honestidad («el verificador es de pega») salieran en todos los turnos posteriores al
+ * primero, incluido un «cuéntame un chiste» que no verificó nada. Un aviso que salta
+ * cuando no ha pasado nada enseña al usuario a ignorarlo, que es lo contrario de lo que
+ * se compra con él.
+ *
+ * Por eso `corrio()` pregunta por lo que ha pasado AHORA, y nunca se le pregunta al objeto
+ * de dependencias, que vive en el proceso entero.
+ */
+export class Bitacora {
+    lineas = [];
+    /** `nodo` es la clave que luego consulta `corrio()`; `detalle` es para el humano. */
+    anota(nodo, detalle = "") {
+        this.lineas.push(detalle ? `${nodo}: ${detalle}` : `${nodo}:`);
+    }
+    /** ¿Ha corrido este nodo en ESTE turno? */
+    corrio(nodo) {
+        return this.lineas.some((l) => l.startsWith(`${nodo}:`));
+    }
+    get todo() {
+        return this.lineas;
+    }
+    get vacia() {
+        return this.lineas.length === 0;
+    }
+}
+//# sourceMappingURL=bitacora.js.map

package/dist/core/bitacora.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitacora.js","sourceRoot":"","sources":["../../src/core/bitacora.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,QAAQ;IACF,MAAM,GAAa,EAAE,CAAC;IAEvC,qFAAqF;IACrF,KAAK,CAAC,IAAY,EAAE,OAAO,GAAG,EAAE;QAC9B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,KAAK,OAAO,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC;IACjE,CAAC;IAED,2CAA2C;IAC3C,MAAM,CAAC,IAAY;QACjB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC;IAC3D,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC;IAClC,CAAC;CACF"}