xonecode 0.8.25 → 0.8.27

package/dist/core/podaDeCheckpoint.js

@@ -0,0 +1,74 @@
+/**
+ * Cuándo adelgazar el `checkpoint.sqlite` de un proyecto, y qué se queda dentro.
+ *
+ * **El problema, medido**: un fichero de un proyecto real llegó a 918 MB con UNA sesión
+ * dentro. No es basura acumulada — es que un checkpoint guarda la lista de mensajes ENTERA y
+ * se escribe uno por paso del grafo, así que el coste crece con el CUADRADO de la
+ * conversación: el primer checkpoint de esa sesión ocupaba 3 KB y el mayor 3.885 KB, con
+ * 2.794 pasos. Y el 70 % no era del hilo: eran los 21 espacios `tools:*` de los subagentes,
+ * cada delegación con su propia cadena.
+ *
+ * **Y no hay nada oficial que adoptar.** Comprobado contra el paquete instalado, no contra un
+ * blog: `BaseCheckpointSaver` declara cinco métodos —`getTuple`, `list`, `put`, `putWrites`,
+ * `deleteThread`— y ninguno poda; no existe `prune()` en JavaScript, y el único `ttl` del
+ * paquete es el de `InMemoryCache`, que es la caché de un NODO y otra cosa. La doc de
+ * persistencia reconoce el problema («prune old checkpoints periodically») sin dar una sola
+ * API ni decir qué filas hacen falta para reanudar, y el issue de langgraph.js que pregunta
+ * exactamente esto sigue abierto y sin contestar. Como el `SqliteSaver` es NUESTRO
+ * (`vendor/sqliteSaver.ts`), el SQL lo escribimos aquí y no se espera a nadie.
+ *
+ * Este módulo es la REGLA y no toca disco: decide SI se poda. El SQL vive en
+ * `agent/sesiones/checkpointer.ts`, que es quien ya tiene la conexión.
+ */
+/**
+ * A partir de cuánto estorba, en bytes.
+ *
+ * **Dimensionada con lo medido, no elegida**: una sesión de 2.794 pasos YA PODADA ocupa
+ * ~21 MB, así que 256 MB deja un orden de magnitud de margen y esto no puede cortar por lo
+ * sano en un proyecto que se porta bien. Es un TECHO, no un objetivo: un proyecto que nunca
+ * lo alcance no ejecuta la poda jamás.
+ *
+ * **Y la histéresis sale gratis de aquí**: podar deja el fichero en decenas de MB, o sea muy
+ * por debajo de la cota, así que no puede reengancharse turno tras turno. El propio tamaño es
+ * el estado, y por eso esto no necesita un fichero de marca ni recordar cuándo se podó — que
+ * es justo el trasto que se acumula en este repo.
+ */
+export const COTA_DE_PODA_BYTES = 256 * 1024 * 1024;
+/**
+ * ¿Toca podar?
+ *
+ * Dos condiciones, y la segunda es la que hace esto seguro:
+ *
+ * - **Pasa de la cota.** Si no, no hay nada que arreglar y mirar el tamaño cuesta un
+ *   `statSync`, o sea nada.
+ * - **No hay NADA pendiente.** Un subagente parado en una aprobación vive en su espacio
+ *   `tools:*`, y podarlo a media aprobación se lleva la reanudación por delante. Es un
+ *   predicado sobre datos que la base ya tiene, no una heurística.
+ *
+ * **Fail-closed: lo que no se sabe NO se poda** (`hayPendientes` ausente). La dirección
+ * segura aquí es la que no borra: un fichero grande es un incordio, y una sesión que no
+ * reanuda es trabajo perdido. La misma regla que «un verificador que no corrió no es verde».
+ */
+export function debePodar(situacion) {
+    if (situacion.hayPendientes !== false)
+        return false;
+    return situacion.bytes > COTA_DE_PODA_BYTES;
+}
+/**
+ * Lo que se cuenta de una poda, y **solo cuando cambió algo de verdad**.
+ *
+ * Un mantenimiento que anuncia su propia rutina es un aviso que enseña a ignorar los avisos,
+ * que es lo que la bitácora existe para evitar: si no se recuperó nada, esto se calla. Y no
+ * lleva la RUTA del fichero, porque esta línea puede viajar por el cable (`sinRutas`).
+ */
+export function resumenDePoda(r) {
+    const liberado = r.antes - r.despues;
+    if (liberado <= 0)
+        return undefined;
+    return (`memoria del agente compactada: ${enMb(r.antes)} → ${enMb(r.despues)} ` +
+        `(${r.checkpointsBorrados} checkpoints y ${r.writesBorrados} escrituras que ya no hacían falta)`);
+}
+function enMb(bytes) {
+    return `${Math.round((bytes / 1024 / 1024) * 10) / 10} MB`;
+}
+//# sourceMappingURL=podaDeCheckpoint.js.map

package/dist/core/podaDeCheckpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"podaDeCheckpoint.js","sourceRoot":"","sources":["../../src/core/podaDeCheckpoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,CAAC;AAYpD;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,SAAS,CAAC,SAA4B;IACpD,IAAI,SAAS,CAAC,aAAa,KAAK,KAAK;QAAE,OAAO,KAAK,CAAC;IACpD,OAAO,SAAS,CAAC,KAAK,GAAG,kBAAkB,CAAC;AAC9C,CAAC;AASD;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,CAAkB;IAC9C,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,OAAO,CAAC;IACrC,IAAI,QAAQ,IAAI,CAAC;QAAE,OAAO,SAAS,CAAC;IACpC,OAAO,CACL,kCAAkC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG;QACvE,IAAI,CAAC,CAAC,mBAAmB,kBAAkB,CAAC,CAAC,cAAc,qCAAqC,CACjG,CAAC;AACJ,CAAC;AAED,SAAS,IAAI,CAAC,KAAa;IACzB,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC;AAC7D,CAAC"}

package/dist/core/validacionDeEscritura.js

@@ -0,0 +1,105 @@
+/**
+ * Qué se le deja escribir a un agente, mirando el CONTENIDO antes de escribirlo.
+ *
+ * XOne ignora en silencio lo desconocido: un atributo inventado, un `<frame>` sin cerrar o un
+ * `font-size` en vez de `fontsize` no dan error, dan un bug mudo. Esa es la regla que gobierna
+ * este harness entero, y hasta ahora solo la sostenían el prompt y el verificador del final
+ * del turno. Esto la mueve al momento de escribir.
+ *
+ * **LA DECISIÓN QUE HACE QUE ESTO SEA USABLE: solo se rechaza lo que la escritura INTRODUCE.**
+ *
+ * Medido sobre siete proyectos reales antes de escribir una línea: con las reglas del linter
+ * ya corregidas siguen quedando hallazgos en ficheros que están en producción y funcionan. Si
+ * la guarda mirase solo el contenido nuevo, el día que entrara no se podría editar un fichero
+ * que ya tuviera un defecto —el agente vendría a arreglar otra cosa y se le rechazaría por
+ * algo que no escribió—. Esa es la guarda que se desactiva al segundo día.
+ *
+ * Así que se compara la HUELLA de antes con la de después, que es exactamente lo que
+ * `agent/turno/turnoReal.ts#conVerificacion` ya hace con el simulador: la huella son los
+ * hallazgos identificados por código+línea, y lo que estaba antes se arrastra sin estorbar.
+ *
+ * **Y la dirección de los dos fallos posibles NO es la misma**, que es la otra mitad del
+ * diseño: si falla el CONTENIDO se rechaza (fail-closed); si falla el VALIDADOR —no está la
+ * librería, revienta el parser— se DEJA ESCRIBIR y se cuenta. Un fallo del entorno no puede
+ * convertirse en un veredicto sobre el trabajo del agente; es la misma frontera que
+ * `ErrorDelSimulador` frente a un informe en rojo.
+ */
+/**
+ * La huella de un hallazgo: lo que lo identifica entre dos versiones del mismo fichero.
+ *
+ * **Código y línea, nunca el mensaje.** El mensaje lleva el nombre de la prop o el fragmento,
+ * así que cambia en cuanto se toca la línea de al lado y haría «nuevo» a un hallazgo que
+ * estaba. Es la misma huella que usa el verificador del turno.
+ */
+function huella(h) {
+    return `${h.codigo}|${h.linea ?? ""}`;
+}
+/**
+ * Compara el fichero que hay con el que se quiere escribir.
+ *
+ * `antes` ausente es un fichero NUEVO: ahí no hay nada preexistente y todo hallazgo es de esta
+ * escritura. Es el caso en el que la guarda muerde más, y es el correcto — un fichero que se
+ * crea ya roto no tiene ninguna excusa.
+ *
+ * Un hallazgo repetido cuenta las veces que esté: si antes había un `font-size` y ahora hay
+ * dos, el segundo es nuevo. Por eso se descuentan por multiplicidad y no con un `Set`, que
+ * dejaría colar todas las repeticiones a partir de la primera.
+ */
+export function veredictoDeEscritura(antes, despues) {
+    const disponibles = new Map();
+    for (const h of antes ?? [])
+        disponibles.set(huella(h), (disponibles.get(huella(h)) ?? 0) + 1);
+    const introducidos = [];
+    const preexistentes = [];
+    for (const h of despues) {
+        const clave = huella(h);
+        const quedan = disponibles.get(clave) ?? 0;
+        if (quedan > 0) {
+            disponibles.set(clave, quedan - 1);
+            preexistentes.push(h);
+        }
+        else {
+            introducidos.push(h);
+        }
+    }
+    return { introducidos, preexistentes };
+}
+/**
+ * Cuántos hallazgos se enseñan en el rechazo.
+ *
+ * Esto acaba dentro del contexto de un modelo, así que tiene tope por lo mismo que las
+ * observaciones del crítico visual: para que quepa. Lo que no cabe se CUENTA, que una lista
+ * recortada en silencio se lee como la lista entera.
+ */
+export const TOPE_DE_HALLAZGOS = 10;
+/**
+ * El texto del rechazo, que es lo único que el modelo va a leer.
+ *
+ * Tres cosas deliberadas:
+ *
+ *  - **Dice que NO se ha escrito nada.** Sin eso, un modelo que recibe un error se queda sin
+ *    saber si el fichero quedó a medias y lo siguiente que hace es releerlo para averiguarlo.
+ *  - **Lleva el código, la línea y el mensaje** —que ya trae el arreglo cuando se sabe, como
+ *    «"font-size" … el atributo que hace esto en XOne es "fontsize"»—. Es el patrón de
+ *    `xone_navegacion`: el paso siguiente escrito, no un consejo.
+ *  - **Y NO nombra lo preexistente.** Eso es ruido para quien viene a arreglar otra cosa, y
+ *    peor: invita a tocar lo que nadie ha pedido, que es la deriva que este repo ya ha pagado
+ *    tres veces.
+ */
+export function motivoDelRechazo(ruta, introducidos) {
+    const visibles = introducidos.slice(0, TOPE_DE_HALLAZGOS);
+    const lineas = [
+        `No he escrito «${ruta}»: el contenido introduce ${introducidos.length === 1 ? "un problema" : `${introducidos.length} problemas`} que antes no estaba${introducidos.length === 1 ? "" : "n"}.`,
+        "El fichero se queda EXACTAMENTE como estaba — no hay nada a medias.",
+        "",
+    ];
+    for (const h of visibles) {
+        lineas.push(`- ${h.codigo}${h.linea === undefined ? "" : ` (línea ${h.linea})`}: ${h.mensaje}`);
+    }
+    if (introducidos.length > visibles.length) {
+        lineas.push(`- … y ${introducidos.length - visibles.length} más.`);
+    }
+    lineas.push("", "Corrige eso en el contenido y vuelve a escribirlo.");
+    return lineas.join("\n");
+}
+//# sourceMappingURL=validacionDeEscritura.js.map

package/dist/core/validacionDeEscritura.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validacionDeEscritura.js","sourceRoot":"","sources":["../../src/core/validacionDeEscritura.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAUH;;;;;;GAMG;AACH,SAAS,MAAM,CAAC,CAAsB;IACpC,OAAO,GAAG,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,KAAK,IAAI,EAAE,EAAE,CAAC;AACxC,CAAC;AASD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,oBAAoB,CAClC,KAAwC,EACxC,OAA8B;IAE9B,MAAM,WAAW,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC9C,KAAK,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE;QAAE,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAE/F,MAAM,YAAY,GAA0B,EAAE,CAAC;IAC/C,MAAM,aAAa,GAA0B,EAAE,CAAC;IAChD,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACxB,MAAM,MAAM,GAAG,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC3C,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;YACf,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC,CAAC;YACnC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACxB,CAAC;aAAM,CAAC;YACN,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;IACD,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,CAAC;AACzC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,CAAC;AAEpC;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY,EAAE,YAAmC;IAChF,MAAM,QAAQ,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC;IAC1D,MAAM,MAAM,GAAG;QACb,kBAAkB,IAAI,6BAA6B,YAAY,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,MAAM,YAAY,uBAAuB,YAAY,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG;QAC/L,qEAAqE;QACrE,EAAE;KACH,CAAC;IACF,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;QACzB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;IAClG,CAAC;IACD,IAAI,YAAY,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC;QAC1C,MAAM,CAAC,IAAI,CAAC,SAAS,YAAY,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,OAAO,CAAC,CAAC;IACrE,CAAC;IACD,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,oDAAoD,CAAC,CAAC;IACtE,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC3B,CAAC"}

package/dist/web/servidor/arranque.js

@@ -61,7 +61,8 @@ import { motivoDeClaveInaceptable } from "../../core/config.js";
 import { aplicarAuth, aplicarCredencialAlProceso, cargar, guardarModeloGlobal, } from "../../agent/config/configEnDisco.js";
 import { borrarCredencial, guardarCredencial } from "../../agent/config/authEnDisco.js";
 import { borrarProveedorPersonalizado, guardarProveedorPersonalizado, proveedoresPersonalizados, } from "../../agent/config/configEnDisco.js";
-import { crearCheckpointerDeProyecto, hayCheckpoint, olvidarHilo, } from "../../agent/sesiones/checkpointer.js";
+import { crearCheckpointerDeProyecto, hayCheckpoint, mantenimientoDelCheckpointer, olvidarHilo, } from "../../agent/sesiones/checkpointer.js";
+import { resumenDePoda } from "../../core/podaDeCheckpoint.js";
 import { cargarSettings, guardarConcurrenciaDeTareas, guardarWorkspace as guardarWorkspaceEnDisco, guardarDispositivos, guardarEntorno as guardarEntornoEnDisco, } from "../../agent/config/settingsEnDisco.js";
 import { dentroDelWorkspace, expandirConCasa, motivoDeWorkspaceInaceptable, } from "../../core/settings.js";
 import { esModoDeEscritura, MODO_POR_OMISION, } from "../../core/modoDeEscritura.js";
@@ -4156,6 +4157,27 @@ export function commitDeTurnoCableado(opciones) {
         return hecho.via === "fallo" ? `no se pudo commitear el turno: ${hecho.motivo}` : undefined;
     };
 }
+/**
+ * El mantenimiento de la memoria del agente, cableado — y EXTRAÍDO por el motivo de siempre:
+ * compuesto dentro del cierre de `arrancarConsolaWeb`, que todos sus tests doblan, esta regla
+ * estaría escrita y no probada. Es la novena vez que este repo tropieza con lo mismo.
+ *
+ * Lo que aquí se puede caer sin que TypeScript diga nada son las DOS mitades: pedir el
+ * checkpointer del proyecto que TOCA —`crearCheckpointerDeProyecto` devuelve la conexión
+ * compartida, y una segunda competiría con nosotros mismos por el lock exclusivo del
+ * `VACUUM`— y devolver el resumen en vez de tragárselo, que es lo único que hace visible que
+ * esto corrió.
+ *
+ * `podar` entra por parámetro para poder mirarlo desde fuera sin una base delante.
+ */
+export function mantenimientoDeMemoriaCableado(opciones) {
+    const podar = opciones?.podar ?? mantenimientoDelCheckpointer;
+    const abrir = opciones?.checkpointer ?? crearCheckpointerDeProyecto;
+    return (raiz) => {
+        const hecho = podar(abrir(raiz), raiz);
+        return hecho === undefined ? undefined : resumenDePoda(hecho);
+    };
+}
 /**
  * La mudanza de una vez de las copias que siguen en el reparto viejo, cableada — y extraída
  * por el motivo de siempre: compuesta dentro del cierre de `arrancarConsolaWeb`, que todos
@@ -4795,6 +4817,9 @@ function vestibuloReal(opciones, servidor, escribir, informar) {
         commitearTurno: commitDeTurnoCableado({
             base: () => cargarSettings().settings.workspace ?? baseDeWorkspacePorOmision(),
         }),
+        // Y el mantenimiento de esa memoria: pasada la cota, se poda lo que ya no reanuda. La
+        // composición está EXTRAÍDA y probada (`mantenimientoDeMemoriaCableado`).
+        mantenerMemoria: mantenimientoDeMemoriaCableado(),
         olvidarMarcaDeSesion: olvidarSesion,
         // La memoria del agente por hilo. `historica` deja de ser «se reabrió» para ser «no hay
         // checkpoint que cargar», y borrar una sesión se lleva también su checkpoint.