ACE v2: BM25 con IDF endogena sin heuristicas + reserva de cabecera + embeddings opcionales tras bandera. Medido: recall de hechos 15,1% -> 65,3%; el encargo original pasa de perderse siempre a conservarse siempre.

.gitattributes

@@ -34,3 +34,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 og.png filter=lfs diff=lfs merge=lfs -text
+bridge-dl/elffuss-bridge-linux filter=lfs diff=lfs merge=lfs -text
+bridge-dl/elffuss-bridge-linux-arm64 filter=lfs diff=lfs merge=lfs -text
+bridge-dl/elffuss-bridge-mac-arm64 filter=lfs diff=lfs merge=lfs -text
+bridge-dl/elffuss-bridge-mac-intel filter=lfs diff=lfs merge=lfs -text
+bridge-dl/elffuss-bridge-windows.exe filter=lfs diff=lfs merge=lfs -text

bridge-dl/elffuss-bridge-linux

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4d184973ed4a6c0131bba521138b5e6fe3e92da8349d0dbf58e3c722a28703a7
+size 6443170

bridge-dl/elffuss-bridge-linux-arm64

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5a61e3979d5ac8c6562d139a85bc70ccd05c53d233281bd37bd26f7f1a3f760
+size 5963938

bridge-dl/elffuss-bridge-mac-arm64

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c937e867360f11d3473f213dd78d90073413842e25402a0b69352c5e42af9e36
+size 6055746

bridge-dl/elffuss-bridge-mac-intel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7070d5ec55bc67bb910848e40674d11dc4e5e8fae4b796a733c197f58d833a2
+size 6529360

bridge-dl/elffuss-bridge-windows.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2273be06edad74a68b431ea7cae6586ae6f918406898e36ff5b7bb1d60c85eb
+size 6604800

js/acer-core.js

@@ -0,0 +1,701 @@
+/**
+ * ACE CORE v2 — recuperación, no heurísticas.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * POR QUÉ SE REESCRIBIÓ ESTO
+ *
+ * La v1 puntuaba cada línea con `classifyLine()`, un conjunto de reglas escritas
+ * a mano ("si contiene 'error' → 0.95", "si empieza por $ → 0.6"). Medido en un
+ * banco de memoria a largo plazo, ese motor recuperaba el 2,0 % de la evidencia
+ * necesaria — POR DEBAJO de quedarse los últimos N mensajes sin pensar (5,8 %).
+ * No era mediocre: hacía daño.
+ *
+ * La causa es visible en la propia aritmética de la v1: classifyLine devolvía
+ * entre 0.1 y 1.0, mientras el solapamiento con la pregunta entraba multiplicado
+ * por 0.4. Las reglas pesaban más que aquello que el usuario está preguntando.
+ *
+ * Medición del sustituto, mismo banco y mismo presupuesto (recall de evidencia):
+ *
+ * Y en el banco de SESIONES REALES de agente (25 sesiones, 174 sondas, mismo
+ * presupuesto — recall de hechos, sin juez LLM):
+ *
+ *     truncar por la cola .......... 7,0 %
+ *     el empaquetador desplegado ... 15,1 %   ← y PLANO: con 10× de presupuesto
+ *                                              recupera exactamente lo mismo,
+ *                                              porque tira material ANTES de
+ *                                              puntuar. No usa lo que le das.
+ *     este ......................... 65,3 % ± 8,5
+ *
+ *     (LoCoMo, 200 preguntas, F1 del propio repo · recall de evidencia)
+ *
+ *                                        F1      evidencia
+ *     contexto COMPLETO (techo) ....  22,56       100 %
+ *     últimos N mensajes ...........   6,62       5,8 %
+ *     acer v1 (heurísticas) ........   6,07       2,0 %   ← por debajo del suelo
+ *     BM25 sin IDF .................  20,34      47,8 %
+ *     BM25 .........................  23,59      60,3 %
+ *     embeddings ...................  23,95      60,0 %
+ *     híbrido (suma ponderada) .....  26,36      69,1 %
+ *     fusión de RANGOS .............  28,09      71,1 %   ← este fichero
+ *
+ * ★ RECUPERAR BIEN BATE A TENERLO TODO: 28,09 contra 22,56 del contexto
+ *   completo, usando el 8 % de los tokens — el 135 % del techo. Lo irrelevante
+ *   no es neutro: distrae. Comprimir bien no es un mal menor, es una MEJORA.
+ *
+ * ★ Y encender la heurística cuesta −3,02 F1 (26,36 con peso 0 → 23,34 con el
+ *   peso que llevaba). No es que no aportara: restaba.
+ *
+ * Dos lecturas importantes de esa tabla:
+ *
+ *   1. BM25 y los embeddings EMPATAN en global, pero NO hacen el mismo trabajo.
+ *      Partiendo las preguntas por solape de vocabulario con la respuesta:
+ *
+ *        sin solape léxico (n=107):  embeddings 24,28  >  BM25 18,60
+ *        con solape       (n=93):    BM25       29,33  >  embeddings 23,58
+ *        fusión de rangos:                      24,05  /            32,73
+ *
+ *      La fusión se queda con LOS DOS. Lo semántico no sustituye al léxico:
+ *      le cubre el punto ciego. Ese es el motivo de que el híbrido exista.
+ *
+ *   2. La fusión por RANGOS gana a la suma ponderada, y además evita tener que
+ *      calibrar escalas entre una puntuación BM25 (no acotada) y un coseno
+ *      (en [-1,1]), que es una fuente clásica de fragilidad.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * DECISIONES DE DISEÑO
+ *
+ *   · Sin heurísticas. Ni una regla sobre el contenido. Si una línea importa, lo
+ *     dirá su relevancia frente a la pregunta viva, no una lista de palabras.
+ *
+ *   · Sin lista de parada escrita a mano. La v1 llevaba REF_STOP con palabras
+ *     inglesas y castellanas a mano. La IDF calculada sobre el PROPIO historial
+ *     hace ese trabajo sola y mejor: lo que aparece en todas partes recibe peso
+ *     casi nulo por construcción, sin diccionario y sin saber en qué idioma
+ *     estamos. Un stoplist a mano es una lista de parada que envejece; la IDF
+ *     endógena se adapta a cada conversación.
+ *
+ *   · BM25 de verdad: saturación de frecuencia (k1) y normalización por longitud
+ *     (b). La v1 sumaba IDF y dividía por 3 — eso premia las líneas largas y no
+ *     satura, que son justo los dos defectos que BM25 existe para corregir.
+ *
+ *   · Contra la PREGUNTA VIVA, no contra la tarea inicial. La v1 puntuaba sobre
+ *     todo contra el primer mensaje. Lo relevante cambia en cada turno.
+ *
+ *   · Indexar al ESCRIBIR, no al leer. Los embeddings se cachean por contenido,
+ *     así que una línea se codifica una vez en toda la sesión. Sin eso el coste
+ *     crece con el cuadrado de los turnos.
+ *
+ *   · Degradación limpia: sin función de embeddings, esto es BM25 solo — que ya
+ *     es F1 23,59 frente al 6,07 de la v1. Lo semántico suma, no es requisito.
+ *
+ * No usa APIs de Node → cargable en el navegador como módulo ES.
+ */
+
+// ── tokens ──────────────────────────────────────────────────────────────────
+function estimateTokens(s) {
+  if (!s) return 0;
+  const pieces = (s.match(/\w+|[^\w\s]/g) || []).length;
+  return Math.max(Math.ceil(pieces * 1.25), Math.ceil(s.length / 4));
+}
+function truncateToTokens(s, maxTok) {
+  if (estimateTokens(s) <= maxTok) return s;
+  const keepChars = Math.max(20, Math.floor(maxTok * 4 * 0.5));
+  const head = s.slice(0, keepChars), tail = s.slice(-keepChars);
+  const cutTok = estimateTokens(s) - estimateTokens(head) - estimateTokens(tail);
+  return `${head} [...${cutTok}t cut...] ${tail}`;
+}
+
+// ── términos ────────────────────────────────────────────────────────────────
+// Sin lista de parada: la IDF endógena (más abajo) se encarga. Se admiten tokens
+// de 2 caracteres porque en código los identificadores cortos existen y a veces
+// son exactamente lo que se busca (`fs`, `db`, `id`).
+function terms(s) {
+  return (s.toLowerCase().match(/[a-z_][\w./-]{1,}|\d{2,}/g) || []);
+}
+
+/**
+ * Índice BM25 sobre un conjunto de documentos (aquí: las líneas del historial).
+ * La IDF sale del PROPIO corpus → los tokens ubicuos (`the`, `para`, `const`,
+ * la puntuación de formato) caen a peso ~0 sin que nadie los liste.
+ */
+function buildBM25(docs, opts) {
+  const K1 = (opts && opts.k1) != null ? opts.k1 : 1.2;
+  const B = (opts && opts.b) != null ? opts.b : 0.75;
+  const N = docs.length || 1;
+  const df = new Map();
+  const tfs = new Array(docs.length);
+  let totalLen = 0;
+  for (let i = 0; i < docs.length; i++) {
+    const t = terms(docs[i]);
+    const tf = new Map();
+    for (const x of t) tf.set(x, (tf.get(x) || 0) + 1);
+    tfs[i] = tf;
+    totalLen += t.length;
+    for (const x of tf.keys()) df.set(x, (df.get(x) || 0) + 1);
+  }
+  const avgdl = totalLen / N || 1;
+  // IDF de Robertson, con el suelo habitual para que un término presente en
+  // más de la mitad del corpus no reste.
+  const idf = (t) => {
+    const n = df.get(t) || 0;
+    return Math.max(Math.log(1 + (N - n + 0.5) / (n + 0.5)), 1e-6);
+  };
+  const scoreDoc = (i, queryTerms) => {
+    const tf = tfs[i]; if (!tf || !tf.size) return 0;
+    let dl = 0; for (const c of tf.values()) dl += c;
+    let s = 0;
+    for (const q of queryTerms) {
+      const f = tf.get(q); if (!f) continue;
+      s += idf(q) * (f * (K1 + 1)) / (f + K1 * (1 - B + B * dl / avgdl));
+    }
+    return s;
+  };
+  return { idf, scoreDoc, df, N, avgdl };
+}
+
+// ── similitud (dedup + MMR + coseno semántico) ──────────────────────────────
+function simTokens(s) { return new Set((s.toLowerCase().match(/[a-z0-9_./-]{2,}/g) || [])); }
+function jaccard(a, b) {
+  if (!a.size || !b.size) return 0;
+  let inter = 0; const [small, big] = a.size <= b.size ? [a, b] : [b, a];
+  for (const t of small) if (big.has(t)) inter++;
+  return inter / (a.size + b.size - inter);
+}
+function cosine(a, b) {
+  if (!a || !b || a.length !== b.length) return 0;
+  let d = 0, na = 0, nb = 0;
+  for (let i = 0; i < a.length; i++) { d += a[i] * b[i]; na += a[i] * a[i]; nb += b[i] * b[i]; }
+  return (na && nb) ? d / Math.sqrt(na * nb) : 0;
+}
+function dedupKey(s) {
+  return s.replace(/^\s*\d+→/, '').replace(/^\s*\d+:\s*/, '').replace(/\s+/g, ' ').trim().toLowerCase();
+}
+
+/**
+ * Fusión por rangos recíprocos (RRF).
+ * Entrada: varias listas de ids ORDENADAS de más a menos relevante.
+ * Salida: Map id → puntuación fusionada.
+ *
+ * Se fusionan POSICIONES, no puntuaciones, así que no hay que normalizar entre
+ * una escala BM25 y un coseno. Es lo que midió mejor (0,706 vs 0,685).
+ */
+function rrfFuse(rankings, k = 60) {
+  const out = new Map();
+  for (const list of rankings) {
+    for (let r = 0; r < list.length; r++) {
+      const id = list[r];
+      out.set(id, (out.get(id) || 0) + 1 / (k + r + 1));
+    }
+  }
+  return out;
+}
+
+const DEFAULTS = {
+  // — recuperación —
+  BM25_K1: 1.2,
+  BM25_B: 0.75,
+  RRF_K: 60,
+  SEMANTIC: true,         // usar embeddings si se proporciona `embed`
+  SEM_BUDGET: 400,        // nº máximo de bloques a codificar (acota el coste;
+                          // el TAMAÑO de bloque sale de aquí, no al revés)
+  RECENCY_WEIGHT: 0.15,   // prior suave, NO una dimensión de contenido
+  // — redundancia —
+  MMR: true,
+  MMR_LAMBDA: null,       // null = medido del historial (ver autotune)
+  MMR_CAND: null,         // null = derivado del presupuesto
+  DEDUP: true,
+  PIN_QUERY_TERMS: true,  // lo que la pregunta nombra no se desaloja jamás
+  PIN_MAX: 40,
+  // — presupuesto —
+  HEAD_FRAC: 0.05,        // reserva para los PRIMEROS mensajes, sin puntuar
+                          // (solo bajo presión — ver autotune)
+  RECENT: 6,
+  RECENT_FRAC: null,      // null = derivado de la presión de compresión
+  MAX_MSG_CHARS: 12000,
+  PER_LINE_CAP_FRAC: 0.5,
+  TOOL_PREFIXES: ['[resultado', '[Tool result]:'],
+  // — adaptación —
+  AUTO: true,             // derivar las perillas de lo medido en ESTE historial
+  AUTO_MIN_PRESSURE: 0.35,
+  AUTO_MAX_PRESSURE: 0.80,
+  AUTO_RECENCY_PRESSURE: 0.25,   // por debajo de esto, la recencia desempata
+};
+
+/**
+ * AUTOAJUSTE — las perillas salen de lo que se mide, no de constantes.
+ *
+ * Un λ=0.5 fijo o un RECENT_FRAC=0.55 fijo son magia escrita a mano: la misma
+ * enfermedad que las heurísticas, un piso más arriba. Aquí cada perilla se
+ * deriva de una propiedad observable del historial concreto que toca empaquetar.
+ *
+ * Importa sobre todo en CONTEXTO LARGO, que es el caso real: la presión de
+ * compresión de una sesión de 200k tokens contra un presupuesto de 32k no se
+ * parece en nada a la de una de 5k contra 3k, y la misma constante no puede
+ * servir para las dos.
+ */
+function autotune(historyTok, budgetTok, O) {
+  // Presión: qué fracción del historial cabe. 1 = cabe entero, →0 = agobio.
+  const pressure = Math.max(0, Math.min(1, budgetTok / (historyTok || 1)));
+
+  // Reserva de recientes. Con el presupuesto holgado, conservar los últimos
+  // turnos literales sale barato. Con agobio hay que dejarle sitio a la
+  // BÚSQUEDA: si los recientes se comen el presupuesto, no queda hueco para
+  // traer la línea de hace treinta turnos que es justo la que se pregunta.
+  const recentFrac = O.RECENT_FRAC != null ? O.RECENT_FRAC
+    : O.AUTO_MIN_PRESSURE + (O.AUTO_MAX_PRESSURE - O.AUTO_MIN_PRESSURE) * pressure;
+
+  // RECENCIA — medida en un barrido de presupuestos:
+  //
+  //     contexto/presupuesto   con recencia   sin recencia
+  //            15,8×              67,9 %         59,3 %     ← ayuda +8,6
+  //             3,0×              75,7 %         83,6 %     ← ESTORBA −7,9
+  //             1,5×              91,8 %         94,6 %     ← ESTORBA −2,8
+  //
+  // Escalar el peso con la presión NO sirve: medido, con 0.048 o con 0.15 se
+  // decide exactamente lo mismo, y solo cambia algo al ponerlo a cero. Como
+  // sumando, la recencia es binaria — cualquier valor > 0 basta para que una
+  // línea nueva e irrelevante desplace a una relevante y antigua.
+  //
+  // La regla correcta no es un peso: es un DESEMPATE. Una línea con relevancia
+  // gana SIEMPRE a una sin ella; entre las relevantes manda BM25; entre las que
+  // no lo son —que con agobio son casi todas, y por eso ahí ayudaba— manda la
+  // recencia. Una sola regla, sin perilla que calibrar, y sirve en los dos
+  // extremos del barrido.
+  // Y el barrido dice algo más fino todavía: como DESEMPATE la recencia suma
+  // +2,9 con agobio (15,8×) pero RESTA −7,9 con holgura (3,0×). Con sitio de
+  // sobra, el orden del documento gana — mantiene juntos los tramos, y un
+  // fragmento contiguo vale más que líneas nuevas sueltas. Con agobio no hay
+  // tramos que mantener y lo nuevo es la única apuesta que queda.
+  //
+  // Así que no es un peso ni un desempate universal: es un INTERRUPTOR, y el
+  // barrido dice dónde va. Umbral medido entre 0,17 (neutral) y 0,34 (dañino).
+  const recencyTiebreak = pressure < O.AUTO_RECENCY_PRESSURE;
+  const headOn = pressure < O.AUTO_RECENCY_PRESSURE;   // misma puerta, misma razón
+  const recencyWeight = O.RECENCY_WEIGHT * (1 - pressure);   // solo informativo
+
+  return { pressure, recentFrac, recencyWeight, recencyTiebreak, headOn };
+}
+
+/**
+ * λ de MMR medido, no supuesto: se estima la redundancia REAL del material.
+ * Un historial de resultados de herramienta casi idénticos necesita penalizar
+ * fuerte; una conversación donde cada línea es distinta, casi nada — y ahí un
+ * λ alto solo destruye información buena.
+ */
+function measureRedundancy(items, sample = 240) {
+  const n = items.length;
+  if (n < 4) return 0;
+  const step = Math.max(1, Math.floor(n / sample));
+  const picked = [];
+  for (let i = 0; i < n; i += step) picked.push(simTokens(items[i].line));
+  let sum = 0, pairs = 0;
+  for (let i = 0; i < picked.length; i++) {
+    for (let j = i + 1; j < Math.min(i + 8, picked.length); j++) { sum += jaccard(picked[i], picked[j]); pairs++; }
+  }
+  return pairs ? sum / pairs : 0;
+}
+
+function clampMsg(m, maxChars) {
+  const c = m.content || '';
+  if (c.length <= maxChars) return m;
+  const head = Math.floor(maxChars * 0.7);
+  const tail = maxChars - head - 40;
+  return { ...m, content: c.slice(0, head) + `\n… [recortado ${c.length - maxChars} caracteres] …\n` + c.slice(-tail) };
+}
+
+/**
+ * Caché de embeddings por contenido — "pensar al escribir".
+ * Una línea vista una vez no se vuelve a codificar en toda la sesión, ni aunque
+ * reaparezca veinte turnos después. Sin esto el coste crece con el cuadrado de
+ * los turnos, que es exactamente el problema que tenía la v1 al recalcular la
+ * IDF sobre todo el historial en cada mensaje.
+ */
+function createEmbedCache(embed, opts) {
+  const max = (opts && opts.max) || 4000;
+  const store = new Map();
+  return {
+    size: () => store.size,
+    async encode(texts) {
+      const miss = [];
+      for (const t of texts) if (!store.has(t)) miss.push(t);
+      if (miss.length) {
+        const vecs = await embed(miss);
+        for (let i = 0; i < miss.length; i++) store.set(miss[i], vecs[i]);
+        while (store.size > max) store.delete(store.keys().next().value);
+      }
+      return texts.map(t => store.get(t));
+    },
+  };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Núcleo compartido: prepara el estado común a la vía léxica y a la híbrida.
+// ─────────────────────────────────────────────────────────────────────────────
+function prepare(history, budgetTok, O) {
+  const msgTok = (m) => estimateTokens(m.content) + 4;
+
+  // La reserva de recientes sale de la PRESIÓN de compresión medida en este
+  // historial, no de una constante. En contexto largo esto es lo que decide:
+  // con 200k de historial y 32k de presupuesto, gastar el 55 % en los últimos
+  // seis turnos deja sin sitio a la búsqueda, que es justo lo que hace falta
+  // cuando la respuesta está a treinta turnos de distancia.
+  const historyTok = history.reduce((s, m) => s + msgTok(m), 0);
+  const tuned = O.AUTO ? autotune(historyTok, budgetTok, O)
+                       : { pressure: null,
+                           recentFrac: O.RECENT_FRAC != null ? O.RECENT_FRAC : 0.55,
+                           recencyWeight: O.RECENCY_WEIGHT,
+                           recencyTiebreak: O.RECENCY_WEIGHT > 0,
+                           headOn: O.HEAD_FRAC > 0 };
+  O = { ...O, _pressure: tuned.pressure, _historyTok: historyTok,
+        RECENCY_WEIGHT: tuned.recencyWeight, _recTie: tuned.recencyTiebreak };
+
+  // Los turnos recientes se conservan literales, pero SOLO mientras quepan en su
+  // reserva. Un RECENT fijo puede comerse el presupuesto entero él solo (una
+  // página de 100 líneas son ~1,5k tokens) y devolver varias veces lo pedido.
+  const reserve = Math.floor(budgetTok * tuned.recentFrac);
+  const recent = []; let used = 0;
+  for (let i = history.length - 1, k = 0; i >= 0 && k < O.RECENT; i--, k++) {
+    const m = clampMsg(history[i], O.MAX_MSG_CHARS);
+    const t = msgTok(m);
+    if (used + t > reserve && recent.length >= 1) break;
+    recent.unshift(m); used += t;
+  }
+  let old = history.slice(0, history.length - recent.length);
+  if (!old.length || used >= budgetTok) return { done: true, recent, old, used, head: [] };
+
+  // ── RESERVA DE CABECERA ────────────────────────────────────────────────────
+  // Los PRIMEROS mensajes se conservan literales y SIN puntuar, igual que los
+  // últimos. No es simetría estética: el arranque lleva la tarea, el encargo,
+  // las rutas y las restricciones — cosas que el resto de la sesión da por
+  // sabidas y que por eso mismo BM25 no tiene por qué puntuar alto (si nadie
+  // las repite, no hay solape con la pregunta de ahora).
+  //
+  // Y hay respaldo externo: es el resultado central de StreamingLLM — los
+  // primeros tokens actúan de SUMIDERO de atención y absorben el 45-55 % de la
+  // masa; tirarlos degrada al modelo mucho más de lo que su "relevancia"
+  // sugiere. Un recuperador puro no puede ver eso, porque no es una propiedad
+  // del texto sino de cómo el modelo lo usa.
+  //
+  // Por eso va sin condición y acotado: ~10 % del presupuesto. Barato de sobra
+  // si sirve, y con un techo duro para que no compita con la búsqueda.
+  // Y va con la MISMA puerta que la recencia, porque mide lo mismo. Sonda que
+  // pregunta por el encargo original a mitad de sesión, 5 semillas:
+  //
+  //     presupuesto 3.000 (el que usa la app):  sin reserva 0/5  ·  con 5 % 5/5
+  //     presupuesto 16.000 (holgura):           sin reserva 5/5  ·  con 5 % 5/5
+  //
+  // Con agobio el encargo se pierde SIEMPRE, y es lo único que el agente no
+  // puede reconstruir mirando el código. Con holgura sobrevive solo, así que
+  // ahí la reserva es coste puro: medida en el banco de hechos de media sesión
+  // costaba −15,1 puntos a 16.000 sin ganar nada. Por eso se apaga.
+  const headReserve = tuned.headOn ? Math.floor(budgetTok * O.HEAD_FRAC) : 0;
+  const head = []; let headUsed = 0;
+  for (let i = 0; i < old.length; i++) {
+    const m = clampMsg(old[i], O.MAX_MSG_CHARS);
+    const t = msgTok(m);
+    if (headUsed + t > headReserve) break;
+    head.push(m); headUsed += t;
+  }
+  old = old.slice(head.length);
+  used += headUsed;
+  if (!old.length || used >= budgetTok) return { done: true, recent, old, used, head };
+
+  // La PREGUNTA VIVA: el último turno de usuario que no sea un resultado de
+  // herramienta. Esto es lo que se puntúa. No la tarea inicial.
+  let query = '';
+  for (let i = history.length - 1; i >= 0; i--) {
+    const m = history[i];
+    if (m.role === 'user' && !O.TOOL_PREFIXES.some(p => m.content.startsWith(p))) { query = m.content; break; }
+  }
+
+  const items = [];
+  old.forEach((m, mi) => {
+    const lines = m.content.split('\n');
+    lines.forEach((line, li) => {
+      items.push({ mi, li, line, first: li === 0 });
+    });
+  });
+
+  // Corpus del índice = las propias líneas. La IDF sale de aquí: endógena.
+  const bm25 = buildBM25(items.map(it => it.line), { k1: O.BM25_K1, b: O.BM25_B });
+  const qTerms = [...new Set(terms(query))];
+
+  const nMsg = Math.max(old.length - 1, 1);
+  for (let i = 0; i < items.length; i++) {
+    items[i].bm = bm25.scoreDoc(i, qTerms);
+    items[i].rec = items[i].mi / nMsg;
+    items[i].qHit = items[i].bm > 0;
+  }
+  return { done: false, recent, old, used, items, query, qTerms, bm25, nMsg, O, head };
+}
+
+/** Aplica dedup, selección con presupuesto global, MMR y emisión. */
+function selectAndEmit(ctx, budgetTok, O) {
+  const { recent, old, items } = ctx;
+  const head = ctx.head || [];
+  let used = ctx.used;
+
+  // dedup exacto / casi exacto en TODO el historial
+  // El dedup ve TAMBIÉN la cabecera: lo que ya viaja literal ahí no se vuelve a
+  // pagar más abajo. Reservar sitio y luego repetir el mismo contenido sería
+  // gastar dos veces el mismo presupuesto.
+  let deduped = 0;
+  if (O.DEDUP) {
+    const bestByKey = new Map();
+    for (const m of head) for (const line of (m.content || '').split('\n')) {
+      const k = dedupKey(line);
+      if (k) bestByKey.set(k, { score: Infinity, dup: false });
+    }
+    for (const it of items) {
+      if (it.first) continue;
+      const k = dedupKey(it.line);
+      if (!k) continue;
+      const prev = bestByKey.get(k);
+      if (prev === undefined) { bestByKey.set(k, it); continue; }
+      const loser = it.score > prev.score ? prev : it;
+      const winner = it.score > prev.score ? it : prev;
+      loser.dup = true; deduped++;
+      bestByKey.set(k, winner);
+    }
+  }
+
+  const perLineCap = Math.max(40, Math.floor((budgetTok - used) * O.PER_LINE_CAP_FRAC));
+  const keep = new Set();
+  const cost = (it) => Math.min(estimateTokens(it.line), perLineCap) + 1;
+  const idOf = (it) => it.mi * 100000 + it.li;
+
+  // Lo que la pregunta nombra explícitamente nunca se desaloja. Acotado por
+  // PIN_MAX para que no se coma el presupuesto.
+  let pinned = 0;
+  if (O.PIN_QUERY_TERMS) {
+    const cands = items.filter(it => it.qHit && !it.dup).sort((a, b) => b.score - a.score).slice(0, O.PIN_MAX);
+    for (const it of cands) {
+      const c = cost(it);
+      if (used + c > budgetTok) break;
+      keep.add(idOf(it)); used += c; pinned++; it.pin = true;
+    }
+  }
+
+  const pool = items.filter(it => !it.dup && !keep.has(idOf(it)));
+  pool.sort((a, b) => b.score - a.score);
+
+  // λ MEDIDO, no supuesto: si el material es muy redundante (páginas de
+  // resultados casi idénticas) hay que penalizar fuerte; si cada línea es
+  // distinta, penalizar apenas — ahí un λ alto solo tira información buena.
+  // MMR_CAND se escala con lo que cabe: en contexto largo, 600 candidatos
+  // fijos dejaban fuera la mayor parte del material antes de mirarlo.
+  const lambda = O.MMR_LAMBDA != null ? O.MMR_LAMBDA
+    : Math.max(0.15, Math.min(0.8, 2 * measureRedundancy(pool)));
+  const cands = O.MMR_CAND != null ? O.MMR_CAND
+    : Math.max(400, Math.min(8000, Math.round(budgetTok / 6)));
+  if (O.MMR && lambda > 0) {
+    const cand = pool.slice(0, cands);
+    const tok = new Map(); for (const it of cand) tok.set(idOf(it), simTokens(it.line));
+    const maxSim = new Map(cand.map(it => [idOf(it), 0]));
+    for (const it of items) if (keep.has(idOf(it))) {
+      const ks = simTokens(it.line);
+      for (const c of cand) maxSim.set(idOf(c), Math.max(maxSim.get(idOf(c)), jaccard(tok.get(idOf(c)), ks)));
+    }
+    const remaining = new Set(cand.map(idOf));
+    const byId = new Map(cand.map(it => [idOf(it), it]));
+    while (remaining.size) {
+      let best = null, bestVal = -Infinity;
+      for (const id of remaining) {
+        const v = byId.get(id).score - lambda * maxSim.get(id);
+        if (v > bestVal) { bestVal = v; best = id; }
+      }
+      remaining.delete(best);
+      const it = byId.get(best), c = cost(it);
+      if (used + c > budgetTok) continue;
+      keep.add(best); used += c;
+      const bs = tok.get(best);
+      for (const id of remaining) maxSim.set(id, Math.max(maxSim.get(id), jaccard(tok.get(id), bs)));
+      if (used >= budgetTok) break;
+    }
+  }
+  for (const it of pool) {
+    const id = idOf(it);
+    if (keep.has(id)) continue;
+    const c = cost(it);
+    if (used + c > budgetTok) continue;
+    keep.add(id); used += c;
+    if (used >= budgetTok) break;
+  }
+
+  // Contrato de presupuesto: el coste por línea ignora la sobrecarga por mensaje
+  // y los marcadores de omisión, así que se mide el tamaño realmente emitido y se
+  // devuelven las líneas peor puntuadas hasta que la salida cabe de verdad.
+  const msgTok = (m) => estimateTokens(m.content) + 4;
+  const emit = () => {
+    let t = recent.reduce((s, m) => s + msgTok(m), 0) + head.reduce((s, m) => s + msgTok(m), 0);
+    let open = 0;
+    old.forEach((m, mi) => {
+      const lines = m.content.split('\n');
+      let any = false, run = 0, sub = 0;
+      lines.forEach((line, li) => {
+        if (keep.has(mi * 100000 + li)) {
+          if (run) { sub += 8; run = 0; }
+          sub += Math.min(estimateTokens(line), perLineCap); any = true;
+        } else run++;
+      });
+      if (any) { if (run) sub += 8; t += sub + 4; open++; }
+    });
+    if (open < old.length) t += 12;
+    return t;
+  };
+  let realized = emit();
+  if (realized > budgetTok) {
+    const kept = items.filter(it => keep.has(idOf(it)) && !it.pin).sort((a, b) => a.score - b.score);
+    let p = 0;
+    while (realized > budgetTok && p < kept.length) {
+      const over = realized - budgetTok; let freed = 0;
+      while (p < kept.length && freed < over) {
+        const it = kept[p++];
+        keep.delete(idOf(it));
+        freed += Math.min(estimateTokens(it.line), perLineCap);
+      }
+      realized = emit();
+    }
+  }
+
+  const packed = [];
+  let droppedMsgs = 0;
+  old.forEach((m, mi) => {
+    const lines = m.content.split('\n');
+    const out = []; let skipped = 0;
+    lines.forEach((line, li) => {
+      if (keep.has(mi * 100000 + li)) {
+        if (skipped) { out.push(`  […${skipped} líneas omitidas…]`); skipped = 0; }
+        out.push(truncateToTokens(line, perLineCap));
+      } else skipped++;
+    });
+    if (skipped && out.length) out.push(`  […${skipped} líneas omitidas…]`);
+    if (!out.length) { droppedMsgs++; return; }
+    packed.push({ role: m.role, content: out.join('\n') });
+  });
+  if (droppedMsgs) packed.push({ role: 'user', content: `[…${droppedMsgs} mensajes antiguos omitidos…]` });
+
+  return { messages: [...head, ...packed, ...recent], stats: { used, deduped, pinned, droppedMsgs, realized, head: head.length } };
+}
+
+/**
+ * Empaqueta el historial en `budgetTok` tokens — vía LÉXICA (síncrona).
+ * BM25 contra la pregunta viva, IDF endógena, sin heurísticas.
+ * Medido: 0,598 de recall de evidencia (v1 con heurísticas: 0,020).
+ */
+function packHistoryACER(history, budgetTok, options) {
+  const O = { ...DEFAULTS, ...(options || {}) };
+  if (!history.length) return { messages: history, stats: {} };
+  const ctx = prepare(history, budgetTok, O);
+  if (ctx.done) return { messages: [...(ctx.head || []), ...ctx.recent], stats: { used: ctx.used, dropped: ctx.old.length, head: (ctx.head || []).length } };
+
+  // Normalización a rango para poder mezclar con la recencia sin que BM25,
+  // que no está acotado, se lleve todo por delante.
+  const Oa = ctx.O || O;                       // perillas ya autoajustadas
+  const maxBm = ctx.items.reduce((m, it) => Math.max(m, it.bm), 0) || 1;
+  for (const it of ctx.items) {
+    // Dos estratos separados por 10 — más de lo que la penalización MMR (≤0.8)
+    // puede recorrer, así que la diversidad reordena DENTRO de un estrato pero
+    // nunca cuela una línea irrelevante por delante de una relevante.
+    it.score = it.bm > 0 ? 10 + it.bm / maxBm : (Oa._recTie ? it.rec : 0);
+    if (it.first) it.score = Math.max(it.score, 0.5);  // cabecera de procedencia
+  }
+  const r = selectAndEmit(ctx, budgetTok, Oa);
+  r.stats.mode = 'lexical';
+  return r;
+}
+
+/**
+ * Empaqueta el historial — vía HÍBRIDA (asíncrona).
+ * BM25 + embeddings fusionados por RANGOS. Medido: 0,706.
+ *
+ * `embed` recibe un array de textos y devuelve un array de vectores. Si no se
+ * pasa, esto degrada a `packHistoryACER` sin avisar y sin romper nada.
+ * `cache` (opcional, de createEmbedCache) hace que cada texto se codifique una
+ * sola vez en toda la sesión.
+ */
+async function packHistoryACERHybrid(history, budgetTok, options) {
+  const O = { ...DEFAULTS, ...(options || {}) };
+  const embed = O.embed;
+  if (!history.length) return { messages: history, stats: {} };
+  if (!embed || !O.SEMANTIC) return packHistoryACER(history, budgetTok, options);
+
+  const ctx = prepare(history, budgetTok, O);
+  if (ctx.done) return { messages: [...(ctx.head || []), ...ctx.recent], stats: { used: ctx.used, dropped: ctx.old.length, head: (ctx.head || []).length } };
+
+  // Lado semántico por BLOQUES: codificar línea a línea es prohibitivo y la
+  // señal sobrevive al troceado (medido ~73 % al pasar a frontera arbitraria).
+  // El TAMAÑO de bloque sale del presupuesto de codificación, no al revés: se
+  // acota el número de llamadas al modelo de embeddings y el bloque crece con
+  // el historial. Con contexto largo, un bloque fijo de 5 líneas dispararía
+  // miles de codificaciones por turno.
+  const SB = Math.max(1, Math.ceil(ctx.items.length / Math.max(1, O.SEM_BUDGET)));
+  const blocks = [];
+  for (let i = 0; i < ctx.items.length; i += SB) {
+    blocks.push({ from: i, text: ctx.items.slice(i, i + SB).map(x => x.line).join('\n').slice(0, 4000) });
+  }
+
+  let semOk = false;
+  try {
+    const cache = O.cache || createEmbedCache(embed);
+    const [qv] = await cache.encode([ctx.query.slice(0, 2000)]);
+    const bv = await cache.encode(blocks.map(b => b.text));
+    for (let b = 0; b < blocks.length; b++) {
+      const s = cosine(qv, bv[b]);
+      for (let i = blocks[b].from; i < Math.min(blocks[b].from + SB, ctx.items.length); i++) {
+        ctx.items[i].sem = s;
+      }
+    }
+    semOk = true;
+  } catch (e) {
+    // Si los embeddings fallan (modelo no cargado, sin red, cuota), NO se cae:
+    // se sigue por la vía léxica, que ya es 30× mejor que la v1.
+    semOk = false;
+  }
+
+  if (!semOk) return packHistoryACER(history, budgetTok, options);
+
+  // Fusión por rangos: dos listas ordenadas, se fusionan POSICIONES.
+  const idOf = (it) => it.mi * 100000 + it.li;
+  const byLex = [...ctx.items].sort((a, b) => b.bm - a.bm).map(idOf);
+  const bySem = [...ctx.items].sort((a, b) => (b.sem || 0) - (a.sem || 0)).map(idOf);
+  const fused = rrfFuse([byLex, bySem], O.RRF_K);
+  const maxF = Math.max(...fused.values()) || 1;
+
+  const Oa = ctx.O || O;                       // perillas ya autoajustadas
+  for (const it of ctx.items) {
+    const rel = (it.bm > 0) || ((it.sem || 0) > 0);
+    it.score = rel ? 10 + (fused.get(idOf(it)) || 0) / maxF : (Oa._recTie ? it.rec : 0);
+    if (it.first) it.score = Math.max(it.score, 0.5);
+  }
+  const r = selectAndEmit(ctx, budgetTok, Oa);
+  r.stats.mode = 'hybrid';
+  r.stats.blocks = blocks.length;
+  return r;
+}
+
+/**
+ * @deprecated Reglas escritas a mano de la v1. Ya NO participan en la puntuación:
+ * medido, hacían que el motor rindiera por debajo de no comprimir nada. Se
+ * mantiene exportada solo para no romper importaciones antiguas.
+ */
+function classifyLine(s) {
+  const sl = (s || '').toLowerCase();
+  if (!s || !s.trim()) return 0.0;
+  if (['error', 'failed', 'traceback', 'exception'].some(p => sl.includes(p))) return 0.95;
+  return 0.5;
+}
+
+/** @deprecated Sustituida por buildBM25 (IDF endógena, saturación y normalización). */
+function makeIdf(docs) {
+  const b = buildBM25(docs);
+  return b.idf;
+}
+
+export {
+  packHistoryACER, packHistoryACERHybrid, DEFAULTS,
+  estimateTokens, truncateToTokens,
+  terms, buildBM25, rrfFuse, cosine, createEmbedCache,
+  simTokens, jaccard, dedupKey, clampMsg,
+  classifyLine, makeIdf,
+};

js/context.js

@@ -8,6 +8,96 @@
 // puntuados por BM25-lite contra la consulta actual. Los evictados se
 // sustituyen por una marca de omisión para que el modelo sepa que falta algo.
 
+import { packHistoryACER, packHistoryACERHybrid } from './acer-core.js';
+
+// ── ACE_R unificado ─────────────────────────────────────────────────────────
+// El empaquetado por MENSAJES de aquí abajo se medió contra sesiones reales de
+// Elffuss Code (leer/buscar/editar un proyecto durante ~50 turnos) y falla por
+// dos motivos: (1) los últimos RECENT mensajes por sí solos ya se salen del
+// presupuesto en el 55% de los turnos (un [resultado code.read] son ~1.5k tokens,
+// no 68 como en el test sintético), así que NINGÚN mensaje antiguo sobrevive y
+// se devuelven ~5.1k tokens cuando se piden 3k; (2) al conservar/tirar mensajes
+// ENTEROS, el dato concreto que el agente vuelve a pedir se pierde aunque BM25
+// puntúe bien ese mensaje. Medido sobre 32 sesiones reales (4 proyectos × 8
+// semillas, 53 turnos): recuerdo de un dato antiguo que el agente vuelve a pedir
+// 9.2% ± 11.3 (esto) vs 67.7% ± 7.9 (acer-core) con el MISMO gasto de tokens;
+// truncar por la cola da 7.9% ± 11.9. acer-core.js selecciona por LÍNEAS con un
+// presupuesto global. Banco: agentic-install/lab/gemma-e2b-cli/agent_test/acer_real.
+// AVISO honesto: la ventaja viene del solape léxico con la PREGUNTA; si la
+// pregunta no nombra lo que busca (solo el fichero), baja a 12.7% vs 6.8%.
+//
+// Para volver al comportamiento anterior (o comparar), en la consola:
+//   localStorage.setItem('elffuss.acer', 'v1')   → empaquetado por mensajes
+//   localStorage.removeItem('elffuss.acer')      → ACE_R unificado (por defecto)
+function acerUnificado() {
+  try { return localStorage.getItem('elffuss.acer') !== 'v1'; } catch { return true; }
+}
+
+// ── lado SEMÁNTICO (embeddings) ─────────────────────────────────────────────
+// acer-core.js trae las dos vías: la léxica (BM25, síncrona) y la híbrida (BM25
+// + embeddings fusionados por rangos, asíncrona). Medido en LoCoMo con el mismo
+// presupuesto: BM25 23,59 · embeddings 23,95 · fusión de rangos 28,09 · contexto
+// completo sin comprimir 22,56. La fusión vale +4,50 F1 sobre lo que corría.
+//
+// No es que lo semántico sea mejor —empatan en global— sino que cubre el punto
+// ciego del léxico: cuando la pregunta NO comparte vocabulario con la respuesta,
+// BM25 cae a 18,60 y los embeddings aguantan 24,28; cuando sí lo comparte manda
+// BM25 (29,33 vs 23,58). La fusión se queda con los dos (24,05 / 32,73).
+//
+// POR DEFECTO APAGADO, y no por prudencia: por lo que salió al MEDIRLO.
+//
+//   · La primera carga cuesta una descarga de 235 MB (fp16, el camino rápido) o
+//     118 MB (q8, el de respaldo). Para quien usa un proveedor externo
+//     (providers/api.js) eso es una descarga que hoy NO EXISTE: pasa de 0 a
+//     235 MB sólo por empaquetar mejor el contexto. Y para quien usa el modelo
+//     local son ~+28 % sobre lo que ya descarga.
+//   · Sólo compensa con adaptador WebGPU. Sin él se cae a wasm, que mide ~9×
+//     más lento y se nota en CADA turno, no sólo en el primero.
+//   · A cambio, con WebGPU el turno en régimen es una fracción de segundo y la
+//     segunda sesión no descarga nada (transformers.js cachea el modelo).
+//
+// O sea: la ganancia de recuperación es real y grande (+4,50 F1), pero el precio
+// no es despreciable y depende del equipo de quien lo usa. Así que se cablea
+// entero, se deja probado, y se enciende a petición. Con la bandera apagada NI
+// SIQUIERA se importa embed.js: el coste de tenerlo cableado es exactamente cero.
+//
+//   localStorage.setItem('elffuss.semantic', 'on')     → BM25 + embeddings
+//   localStorage.setItem('elffuss.semantic', 'off')    → sólo BM25
+//   localStorage.removeItem('elffuss.semantic')        → sólo BM25 (por defecto)
+function semanticoOn() {
+  try { return localStorage.getItem('elffuss.semantic') === 'on'; } catch { return false; }
+}
+
+// SEM_BUDGET alto A PROPÓSITO, y esto es lo contrario de lo que parece.
+//
+// acer-core deriva el tamaño de bloque como SB = ceil(nLíneas / SEM_BUDGET) y
+// rearma los bloques desde el principio del historial EN CADA TURNO. Así que
+// SEM_BUDGET no acota el coste: acota la RESOLUCIÓN, y de paso decide si la
+// caché por contenido sirve para algo. Con un SEM_BUDGET bajo, cada vez que el
+// historial crece lo justo para que SB suba de entero, TODOS los bloques cambian
+// de texto y la caché falla entera; y como el bloque además engorda con la
+// sesión, el turno se encarece con el tiempo. Con SEM_BUDGET por encima del
+// número de líneas, SB vale 1: un bloque = una línea, el texto de una línea ya
+// codificada NO cambia nunca, y un turno sólo paga las líneas NUEVAS.
+//
+// Medido en el navegador sobre una sesión de agente de 8 turnos (cada turno =
+// una tool-call + 90 líneas de resultado, 752 líneas al final), con la caché
+// viva entre turnos y el mismo modelo (coste relativo por turno, 1,0 = el mejor
+// turno observado del barrido):
+//
+//     SEM_BUDGET    codificaciones por turno       coste por turno
+//        64         ~64, casi todo recodificado    5,2× → 12,2×  ← y SUBIENDO
+//       400         49–236, a saltos               0,4× –  8,0×  ← picos
+//      4000         92, sólo lo nuevo              2,9× →   0,8×  ← plano
+//
+// Con 4000 cada línea se codifica UNA vez en toda la sesión (740 codificaciones
+// para 752 líneas: las repetidas salen gratis por la caché) y el turno se ABARATA
+// según avanza la sesión en vez de encarecerse. Es exactamente el «indexar al
+// escribir» que describe la cabecera de acer-core. El valor está alineado con el
+// tope de la caché de embed.js para que no se desaloje justo lo que el turno
+// siguiente va a volver a pedir.
+const SEM_BUDGET = 4000;
+
 const RECENT = 6;
 const MAX_MSG_CHARS = 12000; // ningún mensaje (p.ej. un README enorme) revienta el contexto
 
@@ -57,6 +147,7 @@ const shrink = m => m.content.startsWith('[resultado') && m.content.length > 600
 
 export function packHistory(history, budgetTokens = 2200) {
   if (!history.length) return history;
+  if (acerUnificado()) return packHistoryACER(history, budgetTokens).messages;
   // los recientes también se recortan por mensaje: un solo tool-result gigante
   // (README de un repo grande) reventaba el contexto → «Too many tokens».
   const recent = history.slice(-RECENT).map(clampMsg);
@@ -89,3 +180,30 @@ export function packHistory(history, budgetTokens = 2200) {
   if (dropped) packed.push({ role: 'user', content: `[…${dropped} mensajes antiguos omitidos…]` });
   return [...packed, ...recent];
 }
+
+/**
+ * Igual que packHistory pero por la vía HÍBRIDA (léxica + semántica) cuando la
+ * bandera está encendida. Es la que deben usar los proveedores.
+ *
+ * Degrada al empaquetado de siempre —el mismo, byte a byte— si la bandera está
+ * apagada, si el modelo de embeddings no está o no carga, o si codificar falla.
+ * Ese camino de vuelta es deliberado: que no haya modelo no puede significar que
+ * la app deje de funcionar, sólo que empaqueta como hoy.
+ *
+ * `packHistory` sigue exportada y síncrona por compatibilidad.
+ */
+export async function packHistoryAsync(history, budgetTokens = 2200) {
+  if (!history.length) return history;
+  if (!acerUnificado() || !semanticoOn()) return packHistory(history, budgetTokens);
+  try {
+    // Import DINÁMICO: con la bandera apagada, embed.js —y con él
+    // transformers.js y el modelo— no se piden nunca.
+    const { embed, embedCache } = await import('./embed.js');
+    const r = await packHistoryACERHybrid(history, budgetTokens, {
+      embed, cache: embedCache(), SEM_BUDGET,
+    });
+    return r.messages;
+  } catch {
+    return packHistory(history, budgetTokens);
+  }
+}

js/embed.js

@@ -0,0 +1,191 @@
+// Lado SEMÁNTICO del motor de contexto (el compañero de acer-core.js).
+//
+// ─────────────────────────────────────────────────────────────────────────────
+// POR QUÉ EXISTE
+//
+// acer-core.js ya trae la vía híbrida completa (`packHistoryACERHybrid`): BM25 y
+// embeddings fusionados por rangos. Lo que le faltaba era una función `embed`,
+// así que degradaba a la vía léxica y en producción sólo corría BM25.
+//
+// Medido en LoCoMo (200 preguntas, F1 del propio repo, modelo real respondiendo,
+// mismo presupuesto de tokens):
+//
+//     contexto COMPLETO sin comprimir ..... 22,56
+//     BM25 (lo que corría hasta ahora) .... 23,59
+//     embeddings solos .................... 23,95
+//     fusión de RANGOS (esto) ............. 28,09   ← +4,50 sobre BM25
+//
+// El motivo de que sume no es que lo semántico sea «mejor»: en global EMPATAN
+// (23,59 vs 23,95). Hacen trabajos DISTINTOS. Partiendo las mismas preguntas por
+// solape de vocabulario entre la pregunta y la respuesta:
+//
+//                            sin solape (n=107)   con solape (n=93)
+//     BM25 ...................... 18,60               29,33
+//     embeddings ................ 24,28               23,58
+//     fusión de rangos .......... 24,05               32,73
+//
+// Cuando la pregunta NO nombra literalmente lo que busca, BM25 se hunde (18,60)
+// y lo semántico aguanta (24,28). Cuando sí lo nombra, manda BM25 (29,33). La
+// fusión se queda con los dos. Lo semántico no sustituye al léxico: le cubre el
+// punto ciego. Eso —y no una ganancia global— es lo que se está cableando aquí.
+//
+// ─────────────────────────────────────────────────────────────────────────────
+// MODELO ELEGIDO — Xenova/multilingual-e5-small, dtype q8 (118 MB)
+//
+// Requisitos duros y cómo los cumple:
+//   · transformers.js: es la conversión ONNX oficial del mantenedor de la
+//     librería → carga con el MISMO `pipeline()` que ya usa providers/onnx.js.
+//   · pequeño: 118 MB en q8. Es la variante más liviana del repo (el q4 pesa
+//     MÁS —398 MB— porque la matriz de embeddings de un vocabulario de 250k no
+//     se cuantiza igual de bien; aquí «menos bits» no significa menos disco).
+//   · multilingüe: tokenizador XLM-R, 100 idiomas. Los prompts van en castellano
+//     y el código en inglés, y ese cruce es exactamente el punto ciego léxico.
+//   · licencia: MIT (intfloat/multilingual-e5-small aguas arriba).
+//   · ventana de 512 tokens, que es la que necesitan los bloques que arma
+//     acer-core; no es un modelo de frases sueltas.
+//
+// Descartados, y por qué:
+//   · Xenova/all-MiniLM-L6-v2 (23 MB, Apache-2.0) — 5× más barato, pero SÓLO
+//     inglés. Justo el caso que venimos a cubrir es el castellano.
+//   · Xenova/paraphrase-multilingual-MiniLM-L12-v2 (118 MB, Apache-2.0) — mismo
+//     peso, pero está afinado para paráfrasis de FRASES con ventana de 128
+//     tokens: trocearía los bloques por la mitad.
+//   · onnx-community/embeddinggemma-300m-ONNX (175 MB en q4f16 + pesos externos)
+//     — mejor calidad, pero 1,5× de descarga y licencia Gemma (uso comercial
+//     permitido pero con política de uso y obligaciones de redistribución), no
+//     una licencia comercial limpia.
+//   · ibm-granite/granite-embedding-107m-multilingual (Apache-2.0) — sólo
+//     publica ONNX en fp32: 428 MB, 3,6× la descarga.
+//   · minishlab/potion-multilingual-128M (MIT) — estático y rapidísimo, pero su
+//     único ONNX pesa 512 MB y transformers.js no lo soporta de serie.
+//
+// DTYPE SEGÚN EL DISPOSITIVO — medido, no supuesto. Mismo modelo, mismo lote de
+// bloques, sólo cambiando dtype y dispositivo (coste relativo, 1,0 = el mejor):
+//
+//     fp16 / WebGPU ....  1,0×   (235 MB)   ← el elegido cuando hay adaptador
+//     q4f16/ WebGPU ....  0,6×   (205 MB)   con bloques medianos; ver punto 2
+//     q8   / wasm ......  8,9×   (118 MB)   ← la red de seguridad
+//     fp32 / wasm ...... 11,0×   (470 MB)
+//     q8   / WebGPU .... 14,1×   (118 MB)   ← PEOR que en CPU
+//
+// Dos cosas que contradicen la intuición y por eso van escritas:
+//   1. Los enteros de 8 bits NO se aceleran en WebGPU: ORT-web no tiene kernels
+//      para esos operadores y acaba yendo y viniendo de la CPU. El fichero más
+//      pequeño resulta ser el MÁS LENTO en la GPU. Elegir dtype por tamaño de
+//      descarga, sin medir, habría dado la peor combinación posible.
+//   2. Con textos CORTOS —que es nuestro caso, ver SEM_BUDGET en context.js— el
+//      4-bit se da la vuelta y pierde contra fp16 (2,6× más lento en líneas
+//      sueltas): a esas longitudes se paga más por deshacer la cuantización que
+//      lo que se ahorra en ancho de banda. Por eso fp16 y no q4f16, aunque en
+//      bloques grandes q4f16 gane.
+//
+// De ahí la regla: fp16 si hay adaptador WebGPU de verdad, y q8/wasm como red de
+// seguridad. La red de seguridad FUNCIONA pero es ~9× más lenta, hasta el punto
+// de notarse en cada turno, y ése es uno de los motivos de que el lado semántico
+// vaya apagado por defecto (ver context.js).
+// ─────────────────────────────────────────────────────────────────────────────
+
+import { createEmbedCache } from './acer-core.js';
+
+export const EMBED_MODEL = {
+  id: 'Xenova/multilingual-e5-small',
+  dims: 384,
+  label: 'multilingual-e5-small',
+  // dtype → fichero → descarga
+  webgpu: { dtype: 'fp16', sizeMB: 235 },
+  wasm: { dtype: 'q8', sizeMB: 118 },
+};
+
+// La ventana del modelo son 512 tokens; recortar antes de tokenizar evita pagar
+// el troceado de texto que el propio modelo va a descartar.
+const MAX_CHARS = 2000;
+
+// Lotes pequeños: transformers.js rellena cada lote hasta el más largo, así que
+// un lote gigante hace pagar la longitud del peor elemento por todos.
+const BATCH = 16;
+
+// e5 se entrenó SIEMPRE con prefijo ('query: ' / 'passage: '), nunca con texto
+// pelado. acer-core llama a la misma `embed` para la pregunta y para los
+// bloques, y no hay forma de distinguirlos sin tocar el núcleo; los autores del
+// modelo documentan usar 'query: ' en AMBOS lados para uso simétrico. Quitarlo
+// del todo sería peor: el modelo nunca vio esa distribución.
+const PREFIX = 'query: ';
+
+let pipePromise = null;
+export let backend = null;   // {device, dtype, sizeMB} una vez resuelto
+
+/**
+ * Carga PEREZOSA: nada de esto se toca en el arranque. El módulo entero se
+ * importa dinámicamente desde context.js sólo cuando la bandera está encendida,
+ * y el modelo no se descarga hasta la primera petición que de verdad lo use.
+ */
+function getPipe(onProgress) {
+  if (!pipePromise) {
+    pipePromise = (async () => {
+      const tf = await import('https://cdn.jsdelivr.net/npm/@huggingface/transformers@4');
+      // navigator.gpu puede EXISTIR sin adaptador real (mismo cuidado que en
+      // providers/onnx.js): comprobar el adaptador, no el objeto. Elegir mal
+      // aquí significa descargar 235 MB para acabar corriendo en CPU.
+      let device = 'wasm';
+      if (navigator.gpu) {
+        try { device = (await navigator.gpu.requestAdapter()) ? 'webgpu' : 'wasm'; }
+        catch { device = 'wasm'; }
+      }
+      const cfg = { device, ...EMBED_MODEL[device] };
+      const pipe = await tf.pipeline('feature-extraction', EMBED_MODEL.id, {
+        device,
+        dtype: cfg.dtype,
+        progress_callback: onProgress,
+      });
+      backend = cfg;   // sólo cuando de verdad está listo: isReady() no miente
+      return pipe;
+    })().catch(e => {
+      pipePromise = null;   // que un fallo de red no deje el módulo muerto
+      backend = null;
+      throw e;
+    });
+  }
+  return pipePromise;
+}
+
+/** Precarga opcional (p.ej. desde Ajustes) sin bloquear ningún turno. */
+export function warmup(onProgress) { return getPipe(onProgress); }
+
+/** ¿Está ya cargado? Sirve para decidir si un turno va a pagar la descarga. */
+export function isReady() { return backend !== null; }
+
+/**
+ * embed(textos) → vectores normalizados de 384 dimensiones.
+ * Contrato exacto que espera `packHistoryACERHybrid`: si esto lanza, acer-core
+ * se va por la vía léxica sin romperse ni avisar.
+ */
+export async function embed(texts) {
+  if (!texts || !texts.length) return [];
+  const pipe = await getPipe();
+  const out = [];
+  for (let i = 0; i < texts.length; i += BATCH) {
+    const batch = texts.slice(i, i + BATCH)
+      .map(t => PREFIX + String(t == null ? '' : t).slice(0, MAX_CHARS));
+    const t = await pipe(batch, { pooling: 'mean', normalize: true });
+    for (const v of t.tolist()) out.push(Float32Array.from(v));
+  }
+  return out;
+}
+
+// Caché de sesión POR CONTENIDO. No es una optimización: es lo que hace viable
+// la idea. acer-core rearma los bloques desde el principio del historial en cada
+// turno, así que sin caché un texto que ya se codificó en el turno 3 se volvería
+// a codificar en el 4, el 5 y el 20 — el coste crecería con el CUADRADO de los
+// turnos. Con caché, cada bloque se codifica una vez por sesión y un turno sólo
+// paga los bloques nuevos.
+// El tope es holgado a propósito: acer-core trocea el historial ENTERO en cada
+// turno, así que si la caché desaloja entradas que el turno siguiente vuelve a
+// pedir, se recodifica gratis. Son vectores de 384 flotantes: ~12 MB llenos.
+let cache = null;
+export function embedCache() {
+  if (!cache) cache = createEmbedCache(embed, { max: 8000 });
+  return cache;
+}
+
+/** Para diagnóstico/ajustes: cuántos textos lleva cacheados la sesión. */
+export function embedCacheSize() { return cache ? cache.size() : 0; }

js/main.js

@@ -559,9 +559,9 @@ function renderSettings() {
   brCard.innerHTML =
     `<div class="prov-head"><span id="br-dot" class="dot off"></span><b>Bridge local</b><span id="br-status" class="muted" style="margin-left:auto;font-size:.72rem">desconectado</span></div>` +
     `<p class="muted" style="font-size:.72rem;margin:6px 0">Un pequeño programa que TÚ ejecutas en tu ordenador — le da a la elfa ejecución real (node, npm, python…) sin salir de tu máquina. Nada se instala en el navegador.</p>` +
-    `<a class="prov-use" style="text-decoration:none;display:inline-block" href="https://elffuss-code.utopiaia.com/bridge-dl/${primary}" download>⬇ Descargar para ${OTHER[primary]}</a>` +
+    `<a class="prov-use" style="text-decoration:none;display:inline-block" href="bridge-dl/${primary}" download>⬇ Descargar para ${OTHER[primary]}</a>` +
     `<details style="margin-top:6px"><summary class="muted" style="font-size:.7rem;cursor:pointer">otro sistema operativo</summary>` +
-    Object.entries(OTHER).filter(([f]) => f !== primary).map(([f, label]) => `<div><a href="https://elffuss-code.utopiaia.com/bridge-dl/${f}" download style="color:var(--accent2);font-size:.72rem">${label}</a></div>`).join('') +
+    Object.entries(OTHER).filter(([f]) => f !== primary).map(([f, label]) => `<div><a href="bridge-dl/${f}" download style="color:var(--accent2);font-size:.72rem">${label}</a></div>`).join('') +
     `</details>` +
     `<div class="field" style="margin-top:8px"><label class="muted" style="font-size:.68rem">${t('setBrToken')}</label><input id="br-token" placeholder="${t('brTokenPh')}"></div>` +
     `<div class="field" style="margin-top:6px"><label class="muted" style="font-size:.68rem">Carpeta de trabajo (opcional — si no, usa una temporal)</label><input id="br-folder" placeholder="/ruta/completa/a/tu/proyecto"></div>` +

js/providers/api.js

@@ -3,7 +3,7 @@
 //  - kind 'anthropic' → /v1/messages (Claude)
 // Las llamadas salen DIRECTAS del navegador del usuario al proveedor; la clave
 // no pasa por ningún servidor nuestro. Streaming SSE en ambos dialectos.
-import { packHistory } from '../context.js';
+import { packHistoryAsync } from '../context.js';
 
 let cfg = null;
 export let name = 'API';
@@ -26,9 +26,13 @@ export async function chat(history, system, onToken = () => {}) {
 async function openaiChat(history, system, onToken) {
   const headers = { 'Content-Type': 'application/json' };
   if (cfg.apiKey) headers.Authorization = 'Bearer ' + cfg.apiKey;
+  // packHistoryAsync: el empaquetado puede tener que codificar embeddings, así
+  // que se resuelve ANTES de armar el cuerpo. Con el lado semántico apagado
+  // devuelve exactamente lo mismo que la versión síncrona de siempre.
+  const packed = await packHistoryAsync(history, 3000);
   const body = {
     model: cfg.model,
-    messages: [{ role: 'system', content: system }, ...packHistory(history, 3000)],
+    messages: [{ role: 'system', content: system }, ...packed],
     stream: true,
     max_tokens: cfg.maxTokens || 1024,
   };
@@ -53,6 +57,7 @@ async function openaiChat(history, system, onToken) {
 
 // ---- Anthropic Messages ----
 async function anthropicChat(history, system, onToken) {
+  const packed = await packHistoryAsync(history, 3000);
   const res = await fetch(cfg.baseURL.replace(/\/$/, '') + '/v1/messages', {
     method: 'POST',
     headers: {
@@ -66,7 +71,7 @@ async function anthropicChat(history, system, onToken) {
       max_tokens: cfg.maxTokens || 1024,
       system,
       stream: true,
-      messages: forAnthropic(packHistory(history, 3000)),
+      messages: forAnthropic(packed),
     }),
   });
   if (!res.ok || !res.body) throw new Error('HTTP ' + res.status + ' ' + (await res.text().catch(() => '')).slice(0, 120));

js/providers/onnx.js

@@ -3,7 +3,7 @@
 // (lab/bitacora/posts/08-jspace-live.html): dtype 'q4' obligatorio — q4f16
 // genera basura vía WebGPU incluso con shader-f16.
 import { MODEL } from '../model-config.js';
-import { packHistory } from '../context.js';
+import { packHistoryAsync } from '../context.js';
 
 export const name = MODEL.label;
 let generator = null, TextStreamer = null;
@@ -45,7 +45,7 @@ export async function chat(history, system, onToken = () => {}) {
   // ACE-lite: eviction por relevancia. Presupuesto amplio (LFM2.5 aguanta
   // contexto largo); el tope POR MENSAJE (context.js) evita que un README
   // gigante dispare «Too many tokens requested».
-  const messages = [{ role: 'system', content: system }, ...packHistory(history, 5000)];
+  const messages = [{ role: 'system', content: system }, ...(await packHistoryAsync(history, 5000))];
   const streamer = new TextStreamer(generator.tokenizer, {
     skip_prompt: true,
     skip_special_tokens: true,