xonecode 0.38.41 → 0.39.2

package/dist/core/iconos.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Iconos para quien no tiene los assets (IXCODE-18): buscar uno en Iconify y traer su SVG.
+ *
+ * Es la parte PURA: las reglas de qué se pide y qué se acepta de vuelta. La red entra por
+ * `IconosPort` (`core/ports.ts`) y la hace `agent/config/iconosEnRed.ts`; la tool es
+ * `agent/grafo/buscarIcono.ts`.
+ *
+ * ## Por qué se pide el color Y el tamaño, siempre
+ *
+ * Medido contra `api.iconify.design`: sin `color` el SVG trae `stroke="currentColor"`, y sin
+ * `height` trae `width="1em" height="1em"`. La documentación de XOne no dice qué hace su render
+ * con ninguna de las dos —ni tiñe por CSS ni resuelve `em`—, y XOne ignora en silencio lo que
+ * no entiende: un icono sin tinte válido saldría negro, o sin tamaño, sin un solo aviso. Así
+ * que el color entra como hexadecimal EXPLÍCITO, la altura como píxeles, y el SVG que vuelve
+ * ya los lleva cocidos. La regla es del código, no de un prompt.
+ *
+ * ## Un SVG es TEXTO, y va al proyecto
+ *
+ * Por eso no hay tool de escritura propia: lo escribe `write_file` con su diff y su
+ * aprobación de siempre. Y por eso se le pide a lo que vuelve de la red una forma mínima
+ * (`svgAceptable`): un `<script>` o un `onload` dentro de un fichero que acaba en la app del
+ * cliente no es un icono.
+ */
+import type { Agente } from "./agentes.js";
+export declare const NOMBRE_BUSCAR_ICONO = "buscar_icono";
+/**
+ * Quién la recibe: quien escribe el proyecto entero, que es quien puede dejar el icono en
+ * `icons/`. Regla de DATO —la misma que `recibeIncorporarAdjunto`—, no una lista de nombres: de
+ * los de serie, `designer-xone` y `developer-xone`. Vive en `core/` porque la usan DOS: la tool
+ * (`agent/grafo/buscarIcono.ts`) y la ficha con la que el orquestador conoce a su equipo
+ * (`fichaDeAgente`), y dos copias de la regla serían dos sitios donde puede divergir.
+ *
+ * Solo llega a `motor: "modelo"`: un especialista de motor externo corre en otro proceso y no
+ * recibe tools propias (la ficha lo comprueba aparte).
+ */
+export declare function recibeBuscarIcono(a: Pick<Agente, "soloLectura" | "ejecucion" | "escribeEn">): boolean;
+/** La carpeta de una app XOne donde viven los iconos (`fundamentos/plataforma-y-anatomia…`). */
+export declare const CARPETA_DE_ICONOS = "icons";
+/** Tope de la llamada de red: una búsqueda o un SVG son unos cientos de bytes. */
+export declare const TOPE_DE_ICONOS_MS = 10000;
+/** Lo que se acepta de vuelta. Un icono de Iconify son unos cientos de bytes; esto es holgura. */
+export declare const TOPE_DE_SVG_BYTES: number;
+export declare const LIMITES_DE_BUSQUEDA: {
+    readonly porOmision: 12;
+    readonly maximo: 32;
+};
+export declare const LIMITES_DE_TAMANO: {
+    readonly porOmision: 24;
+    readonly minimo: 8;
+    readonly maximo: 512;
+};
+/** La base es UNA constante: un host distinto es una decisión, no un parámetro. */
+export declare const BASE_DE_ICONIFY = "https://api.iconify.design";
+/** Por qué un id no vale, o `undefined`. Forma `prefijo:nombre`, en minúsculas y con guiones. */
+export declare function motivoDeIdInaceptable(id: string): string | undefined;
+export declare function motivoDePrefijoInaceptable(prefijo: string): string | undefined;
+/** Solo hexadecimal: `currentColor` o un nombre CSS dejarían el tinte a merced del render. */
+export declare function motivoDeColorInaceptable(color: string): string | undefined;
+/**
+ * El color como lo pide Iconify: `#RRGGBB`. Un `#FFRRGGBB` de XOne (opaco) pierde su alfa `FF`, que
+ * no dice nada; uno con alfa menor ya lo rechazó `motivoDeColorInaceptable`. Se llama DESPUÉS de validar.
+ */
+export declare function colorParaIconify(color: string): string;
+export declare function urlDeBusqueda(consulta: string, limite: number, prefijo?: string): string;
+/** El id ya viene validado: sin barras ni `..` no hay forma de salirse de `/prefijo/nombre.svg`. */
+export declare function urlDeSvg(id: string, color: string, tamano: number): string;
+/** De la respuesta de `/search`, solo los ids con forma de id: lo demás no es del contrato. */
+export declare function idsDeBusqueda(cuerpo: unknown): string[];
+/**
+ * Por qué lo que volvió de la red no se acepta como icono, o `undefined`.
+ *
+ * Lista de rechazo corta y a propósito: el SVG de Iconify no lleva nada de esto, así que
+ * cualquier aparición es señal de que lo devuelto no es lo pedido.
+ */
+export declare function motivoDeSvgInaceptable(svg: string): string | undefined;
+/**
+ * El nombre del fichero, por la convención de XOne (`ic_<descripcion>`, guiones bajos):
+ * `lucide:arrow-right` → `ic_arrow_right.svg`. Es también lo que se pone en `img`/`path`: los
+ * ejemplos de la plataforma referencian el nombre A SECAS (`img="add.png"`) y XOne lo busca en
+ * `icons/`; con `icons/` delante buscaría `icons/icons/…` y el icono no saldría, sin un aviso.
+ * El prefijo de la colección no entra: la regla es UNA colección por app, y así el nombre no
+ * cambia si se cambia de colección.
+ */
+export declare function nombreDeFicheroDeIcono(id: string): string;
+/** Dónde escribirlo (ruta virtual del backend): `/icons/ic_home.svg`. */
+export declare function rutaDeIcono(id: string): string;

package/dist/core/identidadDeProveedor.d.ts

@@ -0,0 +1,20 @@
+/** La forma que DeepSeek acepta, copiada de su documentación. */
+export declare const FORMA_DE_USER_ID: RegExp;
+/**
+ * El `sub` de un JWT, o `undefined` si no es un JWT legible o no trae un `sub` de texto.
+ *
+ * Nunca lanza: un token opaco (no JWT) es un caso NORMAL —un IDS puede emitir el access
+ * token así—, y aquí «no lo sé» se contesta no mandando el campo.
+ */
+export declare function subDeJwt(token: string): string | undefined;
+/** El `user_id` para DeepSeek de ese `sub` en ese entorno. Determinista. */
+export declare function userIdDeDeepSeek(entorno: string, sub: string): string;
+/**
+ * La identidad de un juego de tokens: el `id_token` primero —es el que existe para decir
+ * quién es alguien— y el `access_token` después, que IdentityServer emite como JWT con el
+ * mismo `sub`. Si ninguno lo trae, `undefined`: ausente, nunca un valor inventado.
+ */
+export declare function subDeTokens(tokens: {
+    id_token?: string;
+    access_token?: string;
+} | undefined): string | undefined;

package/dist/core/idiomaDeLaRespuesta.d.ts

@@ -0,0 +1,26 @@
+/**
+ * **Una respuesta que se fue al CHINO**, medida con reglas de código y no con otro modelo.
+ *
+ * Medido en Maset: tras un turno largo, `deepseek-flash` escribió la respuesta FINAL entera en chino, con su propio
+ * razonamiento diciendo justo antes «write the final answer in Spanish». La regla del idioma (`IDIOMA_DE_LA_RESPUESTA`)
+ * le había llegado y la había entendido: es una deriva del modelo, no un prompt que falte, así que el arreglo es código.
+ * Solo se reconoce el chino (lo único visto); una deriva a otro idioma no la ve esta regla.
+ */
+/** Por debajo de esto no se juzga: un nombre de producto en chino no es una respuesta en chino. */
+export declare const MINIMO_DE_IDEOGRAMAS = 20;
+/** Qué parte de las letras de la respuesta tienen que ser ideogramas para darla por escrita en chino. */
+export declare const PROPORCION_EN_CHINO = 0.3;
+/** ¿La respuesta está escrita en chino y quien pide NO escribe en chino? Una petición con ideogramas no se corrige. */
+export declare function respuestaEnChinoSinPedirlo(respuesta: string, peticion: string): boolean;
+/** Hasta dónde se cita el mensaje del usuario en la orden de reescribir: lo justo para que se vea su idioma. */
+export declare const TOPE_DE_CITA_DEL_USUARIO = 200;
+/** El mensaje que le devuelve al modelo su respuesta para que la reescriba, sin herramientas y sin cambiar el contenido. */
+export declare function textoDeReescritura(peticion: string): string;
+/** Cuántas palabras vacías de un idioma hacen falta para decir nada: un mensaje de una línea no se juzga. */
+export declare const MINIMO_DE_VACIAS = 6;
+/** ¿Está este texto en inglés y quien pide NO escribe en inglés? Las dos medidas, con margen: dudoso es «no». */
+export declare function textoEnInglesSinPedirlo(texto: string, peticion: string): boolean;
+/** Cuántas veces por turno se le recuerda: si no hace caso, insistir no lo arregla y gasta. */
+export declare const TOPE_DE_RECORDATORIOS_DE_IDIOMA = 2;
+/** El recordatorio, como mensaje de usuario antes de su siguiente llamada. */
+export declare function textoDeRecordatorioDeIdioma(peticion: string): string;

package/dist/core/imagenesDeDocumento.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Las IMÁGENES que enlaza un documento (`.md` o `.html`), resueltas dentro del proyecto.
+ *
+ * Existe porque un enlace relativo —`![Login](img/login.png)`— solo funciona leído desde la carpeta
+ * del documento, y los dos sitios donde se lee no están ahí: `/pdf` imprime un HTML escrito en un
+ * temporal (`agent/exportarPdf.ts`), y la pestaña Ficheros lo pinta en la página de la consola. En
+ * los dos la imagen salía rota. En el PDF se INCRUSTA —`data:`, que no depende de dónde se lea—; en
+ * la web se reescribe el enlace a una ruta que la sirve, porque su visor solo pinta imágenes
+ * `http(s)` absolutas.
+ *
+ * Puro: aquí solo se ENCUENTRAN los enlaces, se resuelven a una ruta del proyecto y se sustituyen.
+ * Leer la imagen —con las barreras de la pestaña Ficheros— es de `agent/`.
+ */
+/**
+ * La ruta HTTP de la consola web que sirve una imagen del proyecto (`?ruta=<relativa>`). La
+ * reescribe `agent/grafo/arbolDeProyecto.ts#vistaDeMarkdown` y la atiende `web/servidor/arranque.ts`;
+ * el cliente la lleva copiada (`apps/web/src/imagenesDelDocumento.ts`), como un tipo del cable.
+ */
+export declare const RUTA_IMAGEN_DEL_PROYECTO = "/imagen-del-proyecto";
+/**
+ * La ruta HTTP que sirve el ICONO de la app de un proyecto bajado (`?id=<id del proyecto>`), para la
+ * barra y la cabecera de su panel. Lleva el ID y no una ruta: qué fichero es lo decide el servidor
+ * leyendo `app.ini` (`agent/grafo/arbolDeProyecto.ts#iconoDelProyecto`). Copiada en el cliente
+ * (`apps/web/src/imagenesDelDocumento.ts`).
+ */
+export declare const RUTA_ICONO_DEL_PROYECTO = "/icono-del-proyecto";
+/** Los enlaces a imagen de un documento, tal cual están escritos y sin repetir. */
+export declare function enlacesDeImagen(texto: string): string[];
+/**
+ * La ruta RELATIVA al proyecto de la imagen que enlaza `enlace` desde el documento `documento`
+ * (también relativa al proyecto), o `undefined` si no es una imagen del proyecto: una URL, un enlace
+ * que se sale de la raíz con `..`. Una ruta que empieza por `/` es la VIRTUAL, desde la raíz.
+ */
+export declare function imagenEnProyecto(documento: string, enlace: string): string | undefined;
+/**
+ * El documento con cada enlace de `incrustadas` (enlace tal cual → `data:…`) sustituido, en las dos
+ * sintaxis. Lo que no está en el mapa se deja EXACTAMENTE igual: una imagen que no se pudo leer
+ * sigue rota, pero no se inventa ni se borra.
+ */
+export declare function conImagenesIncrustadas(texto: string, incrustadas: ReadonlyMap<string, string>): string;

package/dist/core/jsParaRhino.d.ts

@@ -0,0 +1,3 @@
+import type { ResultadoXml } from "./xmlBienFormado.js";
+export type ResultadoJs = ResultadoXml;
+export declare function comprobarJs(entrada: string): ResultadoJs;

package/dist/core/juezDelTurno.d.ts

@@ -0,0 +1,95 @@
+/**
+ * ¿El turno CUMPLIÓ lo que se le pidió? Un juez para la pregunta que ningún `if` contesta.
+ *
+ * ## Por qué hace falta
+ *
+ * El harness sabe medir muchas cosas del turno —si el verificador quedó verde, qué ficheros
+ * cambiaron, si quedaron escrituras sin aprobar— y **ninguna de ellas contesta la pregunta
+ * de quien lo encargó**. Un turno puede cerrar con el simulador en verde, tres ficheros
+ * tocados y un resumen impecable, y no haber hecho lo que se pedía.
+ *
+ * Y eso pasa. MEDIDO en turnos reales del usuario, tres veces en la misma sesión:
+ * «el especialista se ha vuelto a cortar antes de darme el informe», «las dos tareas que
+ * lancé no llegaron a ejecutarse», «la devolución del verificador ha llegado cortada». En
+ * los tres el turno cerró y el resumen sonaba a trabajo terminado.
+ *
+ * ## El reparto: código para lo comprobable, juez para lo difuso
+ *
+ * Es el mismo de las tareas de fondo (`core/entrega.ts`), y por el mismo motivo: un juez
+ * que se equivoque en verde cierra un trabajo a medias sin que nadie lo vea. Así que los
+ * HECHOS los mide el código y se le dan hechos —no se le pide que los averigüe—, y lo único
+ * que se le pregunta es lo que de verdad es un juicio: si con esos hechos delante el
+ * encargo está cumplido.
+ *
+ * ## Fail-closed, y en la dirección que importa
+ *
+ * La respuesta peligrosa es «cumplido» cuando no lo está: cierra el turno en falso y quien
+ * lo pidió se entera al usar la app. Por eso lo que no se entiende es **`dudoso`** y nunca
+ * `cumplido` — igual que `indeterminado` no es verde en el juez de tareas.
+ */
+/** Qué contesta el juez. `dudoso` es también lo que sale de una respuesta que no se entiende. */
+export type Cumplimiento = "cumplido" | "no-cumplido" | "dudoso";
+export interface VeredictoDelTurno {
+    cumplimiento: Cumplimiento;
+    /** Una frase. Es lo que lee la persona, así que dice QUÉ falta, no «no se cumplió». */
+    motivo: string;
+}
+/**
+ * Los hechos MEDIDOS que se le ponen delante. Todos opcionales y todos con el mismo
+ * contrato: **ausente es «no consta», nunca cero ni falso**. Un turno del que no se pudo
+ * medir si escribió no es un turno que no escribió, y el juez tiene que poder distinguirlo
+ * — si no, contestaría «no cumplido» sobre una medición que nadie hizo.
+ */
+export interface HechosDelTurno {
+    /** El veredicto del simulador, si corrió. Ausente = no corrió. */
+    verificador?: "verde" | "rojo";
+    /** Ficheros del proyecto que el turno cambió, en relativo. */
+    ficheros?: readonly string[];
+    /** Quedaron escrituras que nadie aprobó, o se agotó un tope. */
+    escriturasSinResolver?: boolean;
+    /** Algún especialista se quedó sin llamadas o sin tools antes de contestar. */
+    algunEspecialistaCortado?: boolean;
+}
+export declare const PREGUNTA_POR_OMISION = "No tengo claro si esto es lo que quer\u00EDas. \u00BFLo doy por bueno?";
+/** Lo que el juez tiene que contestar, en el mismo formato que el de tareas: JSON y nada más. */
+export declare function promptDelJuezDelTurno(caso: {
+    objetivo: string;
+    respuesta: string;
+    hechos: HechosDelTurno;
+}): string;
+/**
+ * El JSON del juez → veredicto. Lo que no se entiende es `dudoso`.
+ *
+ * Se busca el objeto dentro del texto en vez de exigir un JSON limpio: un modelo que
+ * envuelve su respuesta en ``` o le pone una frase delante ha contestado igual, y tirar ese
+ * veredicto por la envoltura sería perder la respuesta por su presentación.
+ */
+export declare function veredictoDelTurnoDeTexto(texto: string): VeredictoDelTurno;
+/** Qué hace el harness con el veredicto. Puro: decidirlo aquí es lo que lo hace probable. */
+export type AccionDelJuez = {
+    tipo: "nada";
+} | {
+    tipo: "aviso";
+    texto: string;
+} | {
+    tipo: "preguntar";
+    texto: string;
+};
+/**
+ * Del veredicto a lo que se hace, y las tres salidas no son intercambiables.
+ *
+ * - **Cumplido → NADA.** Ni una línea. Un juez que felicita en cada turno es ruido, y el
+ *   ruido es cómo un aviso deja de leerse — la misma razón por la que los avisos de
+ *   honestidad tienen alcance de turno y no salen cuando no ha pasado nada.
+ * - **No cumplido → AVISO.** No se pregunta: no hay nada que decidir, hay algo que decir.
+ *   Quien lo lea ya está delante del turno y sabe qué hacer.
+ * - **Dudoso → PREGUNTAR**, si hay alguien a quien preguntar. Es la mitad que pidió el
+ *   usuario y la que un `if` no puede dar: el juez no sabe, y el que sabe está ahí.
+ *
+ * **Sin humano, la duda se degrada a AVISO y no a silencio.** En una tarea de fondo no hay
+ * a quién preguntar —`consolaDeTarea` aparca en vez de contestar por nadie—, y tragarse la
+ * duda ahí sería cerrar en falso justo donde nadie está mirando.
+ */
+export declare function accionDelJuez(veredicto: VeredictoDelTurno, opciones: {
+    hayHumano: boolean;
+}): AccionDelJuez;

package/dist/core/logDeDispositivo.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Del log crudo de un aparato a hallazgos que el bucle de reparación pueda comparar.
+ *
+ * **POR QUÉ EXISTE, medido sobre AppDemo en un `pixel8` real**: el log del host recién
+ * arrancado son 29 líneas de las que UNA es de la app; tras hacer login, 27 líneas de las que
+ * 23 son suyas y, al deduplicar, **cinco hallazgos distintos** (`Invalid resource ID` ×10, ×7,
+ * ×2, ×2, ×2). Pasarle eso crudo a un modelo es darle veintitantas líneas de las que la mayoría
+ * son la misma, más Android quejándose de sí mismo.
+ *
+ * TRES TRANSFORMACIONES, Y LAS TRES SON DE FORMA — ninguna dice qué hacer:
+ *
+ *  1. **Quitar fecha, pid y tid.** No es higiene: es lo que hace que haya HUELLA. El pid cambia
+ *     en cada arranque de la app, así que sin quitarlo dos vueltas del mismo error son dos
+ *     huellas distintas y la guarda de «no progreso» de `turnoReal.ts#conVerificacion` —lo
+ *     único que impide que el bucle dé vueltas para siempre— no puede comparar nada.
+ *  2. **Deduplicar, contando.** Diez veces el mismo error no son diez hechos. El `veces` se
+ *     conserva porque sí dice algo (un error que sale diez veces al pintar una pantalla es otra
+ *     cosa que uno que sale una vez), pero no multiplica el texto.
+ *  3. **ORDENAR lo de la plataforma detrás, y CONTARLO. Nunca descartarlo.** Esto es una
+ *     decisión explícita y no un descuido: una lista negra de etiquetas escrita a fuego
+ *     esconde, el día que el fallo de verdad salga por `HWUI`, la única línea que lo explica —
+ *     y no hay forma de enterarse. Es el patrón de las «colecciones huérfanas» que este repo ya
+ *     midió y tiró: una señal equivocada no se arregla con un aviso al pie. Así que aquí no se
+ *     filtra, se PRIORIZA, y lo que queda detrás se cuenta, que es la regla de la casa: «lo que
+ *     falta se ROTULA; lo que queda fuera se CUENTA».
+ *
+ * Y se acaba aquí. Lo que el modelo haga con los hallazgos es suyo: este módulo decide qué VE
+ * y cuándo se puede decir que no avanza, no qué piensa ni por dónde empieza.
+ */
+import type { HallazgoDelTurno } from "./events.js";
+/**
+ * El `code` con el que estos hallazgos entran en el bucle.
+ *
+ * Uno solo y no uno por mensaje: el `code` de un hallazgo del simulador es un identificador
+ * ESTABLE de familia (`REF_JS_COLL_MISSING`) y el texto va en `mensaje`. Aquí la familia es
+ * «lo que el aparato dijo al arrancar la app», y el mensaje es el que distingue.
+ */
+export declare const ETIQUETA_DE_ARRANQUE = "DISPOSITIVO_ARRANQUE";
+export interface HallazgoDeDispositivo {
+    /** La línea ya sin fecha, sin pid y sin tid: esto es lo que se compara. */
+    mensaje: string;
+    /** Cuántas veces salió la MISMA línea. */
+    veces: number;
+    /** Falso para lo que es del sistema y no del proyecto. Ordena, no filtra. */
+    deLaApp: boolean;
+    /** La que dijo el propio log, degradada si la línea es de la plataforma. */
+    severidad: "error" | "warning" | "info";
+}
+export interface LecturaDeLog {
+    /** Todos, los de la app primero. Nada se ha tirado. */
+    hallazgos: HallazgoDeDispositivo[];
+    /** Cuántos de los de arriba son de la plataforma, para poder DECIRLO. */
+    plataforma: number;
+    /** La traducción a lo que `conVerificacion` ya consume. */
+    aHallazgosDelTurno(): HallazgoDelTurno[];
+}
+export declare function hallazgosDeLog(texto: string): LecturaDeLog;
+/**
+ * La huella de una lectura, con el MISMO formato que la de `conVerificacion`
+ * (`code|fichero|linea`), para que las dos sean intercambiables en la misma guarda.
+ *
+ * Solo los de la app: un aviso de la plataforma que va y viene no dice nada de si el error se
+ * está arreglando — la misma razón por la que allí la huella son los ERRORES y no todos los
+ * hallazgos. El `mensaje` entra en la huella porque aquí el `code` es uno solo: sin él, dos
+ * excepciones distintas darían la misma huella y el bucle se creería atascado.
+ */
+export declare function huellaDeHallazgos(hallazgos: readonly HallazgoDeDispositivo[]): string;

package/dist/core/memoria.d.ts

@@ -0,0 +1,18 @@
+/**
+ * La ruta VIRTUAL por la que el agente ve la memoria del proyecto, y cómo se reconoce una
+ * lectura suya en el flujo de tools.
+ *
+ * Vive en `core/` porque la usan dos lados: `agent/` la monta en el backend
+ * (`agent/grafo/memoriaDeProyecto.ts`, que la reexporta) y `core/turno.ts` la reconoce para
+ * decir en la pantalla QUIÉN pidió leerla. Dos copias del literal serían dos sitios donde la
+ * ruta puede cambiar y el reconocimiento quedarse mudo.
+ */
+export declare const RUTA_MEMORIA_VIRTUAL = "/MEMORIA_PROYECTO.md";
+/**
+ * ¿Esta llamada pide leer la memoria? Por la tool y por la ruta EXACTA, con barra o sin ella:
+ * medido en una sesión real, el modelo pidió `read_file MEMORIA_PROYECTO.md` sin la barra, y
+ * el backend de TrueForge la normaliza (`toolsDeFichero.ts#normalizarRuta`), así que esa
+ * lectura ocurre igual. No se reconoce por «contiene el nombre»: un `grep` que lo mencione no
+ * es una lectura.
+ */
+export declare function pideLeerLaMemoria(nombre: string, detalle: string | undefined): boolean;

package/dist/core/metodoDeComparacionVisual.d.ts

@@ -0,0 +1,20 @@
+/**
+ * **El MÉTODO para comparar una captura con su maqueta**, el mismo para el crítico visual (`juezVisual.ts`) y para un
+ * desarrollador en Claude Code que compara él mismo (`agentes.ts#textoDeTrabajoSinLlamar`): dos que comparan distinto
+ * dan dos veredictos que no se pueden contrastar.
+ *
+ * Existe por una medida en Maset (MAS-3): con un prompt que pedía comparar «forma, tamaños, color, colocación» en
+ * general, DeepSeek flash vio la mitad de lo evidente; con este recorrido —inventario de la maqueta elemento a elemento,
+ * y cada uno comparado en un orden fijo— vio además las flechas desalineadas y las tarjetas más altas. Lo que le falta a
+ * un modelo no es la vista: es un recorrido que no le deje resumir.
+ */
+export declare const METODO_DE_COMPARACION_VISUAL: string;
+/** Cuántas pasadas del modelo por crítica con maqueta: una sola variaba mucho (medido: de 4 a 8 diferencias). */
+export declare const PASADAS_DE_COMPARACION = 2;
+/** Lo que dos observaciones tienen que compartir para ser la MISMA dicha con otras palabras. */
+export declare const PARECIDO_PARA_REPETIDA = 0.5;
+/**
+ * Las observaciones de varias pasadas, sin las repetidas (`repetidas`): dos pasadas del mismo modelo cuentan lo mismo
+ * con otras palabras. Puro y en orden: primero las de la primera pasada.
+ */
+export declare function unirObservaciones(...listas: readonly (readonly string[])[]): string[];

package/dist/core/modelos.d.ts

@@ -0,0 +1,198 @@
+import type { Papel } from "./ports.js";
+import type { ConfigDeFichero } from "./config.js";
+export declare const PAPELES: readonly Papel[];
+export type ProveedorDeSerie = "gemini" | "openai" | "anthropic" | "ollama" | "ollama-cloud" | "nvidia" | "groq" | "xai" | "deepseek" | "opencode-go" | "opencode-zen";
+/**
+ * Un endpoint compatible con OpenAI dado de alta por el USUARIO, con la forma
+ * `custom:<slug>`.
+ *
+ * Es un tipo de plantilla y no una entrada más de la lista cerrada porque estos no se
+ * conocen al compilar: los declara quien usa el programa. Lo que sí se puede afirmar sin
+ * registro es la FORMA, y con eso `parsear` sigue siendo una función pura —no hay que
+ * pasarle la lista de altas para partir «custom:mi-llm/qwen3»—; que ese slug esté dado de
+ * alta se comprueba donde importa, al construir el cliente y al pedir el catálogo, con un
+ * mensaje que dice dónde darlo de alta.
+ */
+export type ProveedorPersonalizado = `custom:${string}`;
+export type Proveedor = ProveedorDeSerie | ProveedorPersonalizado;
+export declare const PREFIJO_PERSONALIZADO = "custom:";
+export declare function motivoDeSlugInaceptable(slug: string): string | undefined;
+/**
+ * El identificador que le toca a un proveedor por su NOMBRE.
+ *
+ * Se deriva en vez de pedirse: un tercer campo en el formulario —«nombre», «id», «URL»—
+ * solo puede escribirse mal, y quien da de alta «Mi LM Studio» no tiene por qué saber que
+ * eso va a acabar siendo un segmento de un id y un trozo del nombre de una variable de
+ * entorno. Se quitan los acentos (`NFD` + la marca combinante), lo que no sea letra o
+ * cifra pasa a guion, y se recorta a lo que admite `SLUG`.
+ *
+ * Puede salir vacío —un nombre de solo signos— y entonces devuelve cadena vacía, que
+ * `motivoDeSlugInaceptable` rechaza con su motivo: adivinar un id ahí sería inventarlo.
+ */
+export declare function slugDesdeNombre(nombre: string): string;
+export declare function esProveedorPersonalizado(valor: string): valor is ProveedorPersonalizado;
+export declare function slugDeProveedor(proveedor: ProveedorPersonalizado): string;
+export declare function idDeProveedorPersonalizado(slug: string): ProveedorPersonalizado;
+/** Un proveedor personalizado tal como se declara y se guarda. */
+export interface ProveedorDeclarado {
+    /** Sin el prefijo. El id completo, el que se teclea, es `custom:<slug>`. */
+    slug: string;
+    /** Lo que escribe el usuario para reconocerlo. No es un identificador. */
+    nombre: string;
+    /** La URL base compatible con OpenAI. El catálogo pide `<baseUrl>/models`. */
+    baseUrl: string;
+}
+/**
+ * ¿Vale eso como endpoint? Devuelve el MOTIVO del rechazo, o `undefined` si pasa.
+ *
+ * La misma regla que la URL de un MCP, y por la misma razón: HTTPS fuera de la máquina,
+ * `http://` solo en loopback, y nunca credenciales dentro de la URL —una URL con usuario
+ * y contraseña acaba escrita en `config.json` y en cada traza que la enseñe—.
+ *
+ * Que loopback pase NO es una concesión: es el caso principal. Un LM Studio, un
+ * `llama.cpp --server` o un vLLM escuchan en `http://localhost:1234/v1`, y ahí el texto
+ * plano no cruza ninguna red — el mismo trato que ya reciben el `redirect_uri` del
+ * callback de OAuth y esta propia consola.
+ */
+export declare function motivoDeEndpointInaceptable(valor: string): string | undefined;
+export declare const PROVEEDORES: readonly ProveedorDeSerie[];
+/**
+ * Los que se hablan con el cliente de OpenAI cambiándole la URL base.
+ *
+ * Los tres —NVIDIA (`build.nvidia.com`), Groq y xAI (los modelos `grok-*`)— publican una
+ * API compatible con OpenAI: mismo `/chat/completions` y mismo `GET /v1/models`. Así que
+ * no son tres ramas nuevas en `construirModelo` ni tres listados nuevos en el catálogo,
+ * son tres FILAS de esta tabla, y quien las consume tiene una sola rama genérica. La
+ * cuarta que se añada será otra fila.
+ *
+ * **`openai` NO está aquí a propósito**, aunque encaje en la forma: su listado filtra por
+ * las familias de ids de OpenAI (`gpt-`, `o3-`, `codex-`), que en estos tres no significan
+ * nada — meterlo en la rama genérica cambiaría lo que hoy ofrece.
+ *
+ * Y la lista de proveedores sigue siendo CERRADA (no hay «proveedor personalizado», ver
+ * `componentes/Ajustes.tsx`): lo que cambia con esto es que añadir uno compatible cuesta
+ * una fila de datos en vez de una rama por sitio, no que se pueda declarar desde fuera.
+ */
+export type ProveedorCompatibleOpenAi = "nvidia" | "groq" | "xai" | "deepseek" | "opencode-go" | "opencode-zen";
+export declare const COMPATIBLES_OPENAI: Record<ProveedorCompatibleOpenAi, {
+    baseUrl: string;
+    variable: string;
+}>;
+/**
+ * La variable de entorno donde vive la clave de cada proveedor, y el ÚNICO sitio donde
+ * se escribe.
+ *
+ * Hubo cuatro copias de esta tabla —`agent/config/configEnDisco.ts`, `agent/config/catalogoModelos.ts`,
+ * `cli/config.ts` y `cli/consola.ts`—, duplicadas para que `cli/` no tirase de `agent/`
+ * por un mapa de cuatro líneas. Ya habían divergido: la de `cli/config.ts` no tenía
+ * `OLLAMA_API_KEY`, así que `/config` decía «sin credencial» de Ollama Cloud aunque
+ * estuviera puesta. Puesta en `core/` —que es datos puros y de donde SÍ pueden tirar los
+ * dos lados— el problema desaparece por construcción.
+ *
+ * `ollama` no está: es local y no necesita clave. Esa ausencia es la misma que declara
+ * `SIN_CREDENCIAL`, y hay un test que exige que las dos cuenten lo mismo.
+ */
+export declare const VARIABLES_POR_PROVEEDOR: Partial<Record<ProveedorDeSerie, string>>;
+/**
+ * Cómo se escribe un proveedor. Para uno personalizado, el nombre que puso quien lo dio
+ * de alta; sin registro —o con un slug que ya no está— se cae a su slug, que es lo único
+ * que se puede afirmar: inventarle un nombre sería peor que enseñar el identificador.
+ */
+export declare function nombreDeProveedor(proveedor: Proveedor, declarados?: readonly ProveedorDeclarado[]): string;
+/**
+ * La variable de entorno donde vive la clave de un proveedor.
+ *
+ * Para los de serie, la tabla. Para uno personalizado se DERIVA del slug
+ * (`XONECODE_CLAVE_MI_LLM`) en vez de guardarse: una variable elegida por el usuario sería
+ * un cuarto campo del formulario que solo puede escribirse mal, y derivarla hace que todo
+ * lo que ya existe —`aplicarAuth`, `guardarCredencial`, el constructor del cliente y el
+ * catálogo— siga funcionando sin saber que estos proveedores existen.
+ */
+export declare function variableDeProveedor(proveedor: Proveedor): string | undefined;
+/**
+ * La fila de un proveedor compatible con OpenAI, o nada si no lo es.
+ *
+ * Un personalizado LO ES por definición —es lo único que se puede dar de alta—, pero solo
+ * si consta en el registro: sin su URL base no hay a dónde llamar, y devolver algo aquí
+ * sería fabricar un endpoint.
+ */
+export declare function compatibleConOpenAi(proveedor: Proveedor, declarados?: readonly ProveedorDeclarado[]): {
+    baseUrl: string;
+    variable: string;
+} | undefined;
+/**
+ * Los que NO llevan clave. Hoy solo Ollama local, que es la omisión del repo.
+ *
+ * Vive aquí, en datos puros, porque lo consultan dos sitios que no se conocen: el asistente
+ * de cuenta (`cli/wizardInicial.ts`, para no pedir una clave que no hace falta) y el estado
+ * de modelos de la consola web (`web/servidor/arranque.ts`, que necesita distinguir «no
+ * necesita credencial» de «la tiene» — pintarle a Ollama un punto verde sería concederle un
+ * permiso que nadie le dio, y uno rojo, inventarle un problema). Dos listas de esto ya
+ * habrían divergido: `hayCredencial` (`cli/consola.ts`) devuelve `true` para un proveedor
+ * sin variable de entorno, que para su pregunta —«¿puedo usarlo?»— es correcto y para ésta
+ * —«¿tiene credencial?»— sería falso.
+ */
+export declare const SIN_CREDENCIAL: ReadonlySet<Proveedor>;
+export interface Eleccion {
+    proveedor: Proveedor;
+    modelo: string;
+    /** De dónde salió, para que `describe` lo pueda decir. */
+    origen: "bandera" | "entorno" | "proyecto" | "global" | "omision";
+}
+/**
+ * Los modelos por omisión de cada papel.
+ *
+ * `rapido` es el que corre en TODOS los turnos, así que es el que más veces se paga en la
+ * vida del agente: arranca abajo y solo se sube con una medición delante. `afilado` es
+ * para el juez, que es quien decide si algo está bien — ahí un modelo flojo cuesta más de
+ * lo que ahorra.
+ *
+ * Ollama por omisión, y a propósito: el usuario tiene modelos locales con tool-calling y
+ * los frontier de pago no son la vía por defecto de este laboratorio.
+ */
+export declare const POR_OMISION: Record<Papel, {
+    proveedor: Proveedor;
+    modelo: string;
+}>;
+export declare class ModeloMalEscrito extends Error {
+}
+/**
+ * `proveedor/modelo` → sus dos partes.
+ *
+ * El separador es la PRIMERA barra, no la última: un id de Ollama puede llevar barras
+ * (`library/qwen3:8b`) y partir por la última dejaría el proveedor con basura. Se valida
+ * el proveedor contra la lista en vez de aceptar cualquier cosa, porque un proveedor mal
+ * escrito no falla al parsear: falla mucho después, al construir el cliente, con un error
+ * que no menciona la bandera.
+ */
+export declare function parsear(texto: string): {
+    proveedor: Proveedor;
+    modelo: string;
+};
+export interface FuentesDeEleccion {
+    /** `--modelo proveedor/modelo`: fija los TRES papeles. */
+    bandera?: string;
+    /** `--modelo-rapido`, etc.: fija UNO, y gana sobre `--modelo`. */
+    porPapel?: Partial<Record<Papel, string>>;
+    /** Variables de entorno, por si se prefiere no repetir la bandera. */
+    entorno?: {
+        XONECODE_MODELO?: string;
+    };
+    /** `config.json` del proyecto, ya validado. */
+    proyecto?: ConfigDeFichero;
+    /** `config.json` global (~/.xonecode/config.json), ya validado. */
+    global?: ConfigDeFichero;
+}
+/**
+ * Qué modelo le toca a cada papel, y de dónde salió.
+ *
+ * Precedencia, de más fuerte a más débil, evaluada papel a papel: porPapel > bandera
+ * > entorno > proyecto > global > omisión. Los dos primeros escalones son de CLÍ y
+ * preceden a cualquier fichero. Entre ficheros manda el RANGO (proyecto gana a global),
+ * y solo DENTRO de un mismo fichero manda la especificidad (modelos.<papel> gana a
+ * modelo): el campo general de un fichero de rango superior nunca pierde contra el
+ * campo específico de uno inferior.
+ */
+export declare function resolver(fuentes?: FuentesDeEleccion): Record<Papel, Eleccion>;
+export declare function pideThinkingAdaptativo(proveedor: Proveedor, modelo: string): boolean;
+export declare function aceptaThinkingAdaptativo(proveedor: Proveedor, modelo: string): boolean;