Fix the brain that stopped loading, plus workspace, Hard Work and i18n

- litert.js imported the runtime from an unpinned CDN URL. On 11 Aug version
0.16.0 shipped, jsdelivr cannot build its +esm bundle (404), and the Gemma
brain stopped loading in production without a line of our code changing.
The version is now pinned; check the URL returns 200 before bumping it.
- Workspace: pick a folder on disk and keep sessions, skills and generated
apps as normal files. Inventory of what is stored, one-click wipe, and a
downloadable copy for browsers without File System Access. The encrypted
vault is never exported in the clear.
- Hard Work (RLM): work a whole folder in parts — map over chunks, merge the
findings, recurse when the merge still doesn't fit.
- Settings reordered: live usage (memory, disk, loaded brain) and cleanup come
first; external cloud models move to a collapsed section at the end.
- Data-loss fixes: a transient IndexedDB read error used to wipe every skill
and collapse the conversation store to a single entry.
- Claw UI completed in Ukrainian, French, German and Portuguese.

css/code.css

@@ -1,7 +1,8 @@
 /* Elffuss Code — VS Code oscuro con alma élfica */
 :root {
-  --bg: #0b0d12; --bg2: #11141c; --bg3: #171b26; --line: #262c3d;
-  --fg: #e8ebf4; --muted: #8b93a8; --accent: #ff4d8d; --accent2: #7c5cff;
+  --bg: #090a11; --bg2: #101317; --bg3: #161a24; --line: #20252c;
+  --fg: #eae8f2; --muted: #8b929c; --accent: #c8a06a; --accent2: #8272ff;
+  --serif: "Iowan Old Style", Georgia, "Times New Roman", serif;
 }
 * { box-sizing: border-box; }
 html, body { height: 100%; margin: 0; }
@@ -301,6 +302,8 @@ body.hide-tree #sidebar { display: none; }
 /* 🎯 Modo Objetivo: botón + tarjeta de plan (planificador/ejecutor) */
 .cbtn.goal { font-size: .74rem; }
 .cbtn.goal.on { color: #fff; border-color: var(--accent); background: linear-gradient(135deg, #3a2050, #2a1840); }
+.cbtn.hardwork { font-size: .74rem; }
+.cbtn.hardwork.on { color: #fff; border-color: var(--accent); background: linear-gradient(135deg, #3a2a18, #2a1f40); box-shadow: 0 0 0 1px var(--accent) inset; }
 .msg.plan-card { background: var(--bg3); border: 1px solid var(--line); border-radius: 11px; padding: 10px 12px; font-size: .82rem; align-self: stretch; max-width: 100%; }
 .plan-card .plan-head { font-weight: 600; margin-bottom: 2px; }
 .plan-card .plan-summary { color: var(--muted); font-size: .78rem; margin-bottom: 8px; }

css/lab.css

@@ -0,0 +1,131 @@
+/* Elffuss Lab — panel de banco de pruebas. Estética de instrumental: oscuro,
+   datos en monoespaciada, acentos fosforescentes y nada de adorno que no diga
+   un dato. Independiente de code.css para no pisar el IDE. */
+:root {
+  --bg: #070b0e;
+  --panel: #0d141a;
+  --panel-2: #111b23;
+  --line: #1d2c37;
+  --ink: #d7e6ef;
+  --dim: #7d94a3;
+  --accent: #2af5c0;
+  --accent-2: #35b8ff;
+  --warn: #ffb648;
+  --bad: #ff5c72;
+  --mono: ui-monospace, SFMono-Regular, Menlo, monospace;
+}
+* { box-sizing: border-box; }
+body {
+  margin: 0; background: var(--bg); color: var(--ink);
+  font: 14px/1.5 system-ui, -apple-system, "Segoe UI", sans-serif;
+  background-image:
+    radial-gradient(1200px 600px at 15% -10%, #0d2b33 0%, transparent 60%),
+    radial-gradient(900px 500px at 110% 10%, #101f36 0%, transparent 55%);
+  min-height: 100vh;
+}
+a { color: var(--accent-2); }
+
+/* ── cabecera ── */
+header {
+  display: flex; align-items: center; gap: 16px; flex-wrap: wrap;
+  padding: 14px 20px; border-bottom: 1px solid var(--line);
+  background: linear-gradient(180deg, rgba(13,20,26,.95), rgba(13,20,26,.6));
+  position: sticky; top: 0; z-index: 20; backdrop-filter: blur(8px);
+}
+header h1 { margin: 0; font-size: 17px; letter-spacing: .06em; text-transform: uppercase; }
+header h1 span { color: var(--accent); }
+.sub { color: var(--dim); font-size: 12px; font-family: var(--mono); }
+.spacer { flex: 1; }
+
+/* piloto de estado */
+.led { display: inline-flex; align-items: center; gap: 7px; font-family: var(--mono); font-size: 12px; color: var(--dim); }
+.led i {
+  width: 9px; height: 9px; border-radius: 50%; background: #33454f; display: block;
+  box-shadow: 0 0 0 0 rgba(42,245,192,.5);
+}
+.led.on i { background: var(--accent); animation: pulse 1.8s infinite; }
+.led.busy i { background: var(--warn); animation: pulse .9s infinite; }
+.led.err i { background: var(--bad); }
+@keyframes pulse { 0% { box-shadow: 0 0 0 0 rgba(42,245,192,.45); } 70% { box-shadow: 0 0 0 7px rgba(42,245,192,0); } 100% { box-shadow: 0 0 0 0 rgba(42,245,192,0); } }
+
+/* ── rejilla ── */
+main { display: grid; grid-template-columns: minmax(300px, 380px) 1fr; gap: 16px; padding: 16px 20px 40px; align-items: start; }
+@media (max-width: 940px) { main { grid-template-columns: 1fr; } }
+
+.panel { background: var(--panel); border: 1px solid var(--line); border-radius: 12px; overflow: hidden; }
+.panel + .panel { margin-top: 14px; }
+.panel > h2 {
+  margin: 0; padding: 11px 14px; font-size: 11px; letter-spacing: .14em; text-transform: uppercase;
+  color: var(--dim); border-bottom: 1px solid var(--line); background: var(--panel-2);
+  display: flex; align-items: center; gap: 8px;
+}
+.panel > h2 .tag { margin-left: auto; font-family: var(--mono); font-size: 10px; color: var(--accent); letter-spacing: .04em; }
+.panel .body { padding: 12px 14px; }
+
+/* ── controles ── */
+.seg { display: grid; gap: 6px; }
+.seg label {
+  display: flex; gap: 10px; align-items: flex-start; padding: 9px 11px; cursor: pointer;
+  border: 1px solid var(--line); border-radius: 9px; background: #0a1116; transition: .15s;
+}
+.seg label:hover { border-color: #2b4250; }
+.seg input { margin: 3px 0 0; accent-color: var(--accent); }
+.seg label.sel { border-color: var(--accent); background: rgba(42,245,192,.07); }
+.seg .t { font-weight: 600; }
+.seg .d { color: var(--dim); font-size: 12px; }
+
+.knobs { display: grid; gap: 4px; }
+.knob { display: flex; align-items: center; gap: 10px; padding: 6px 8px; border-radius: 7px; }
+.knob:hover { background: #0a1116; }
+.knob code { font-family: var(--mono); font-size: 12px; color: var(--ink); flex: 1; }
+.knob .why { color: var(--dim); font-size: 11px; flex: 2; }
+.knob input[type=checkbox] { accent-color: var(--accent); width: 16px; height: 16px; }
+.knob input[type=number] { width: 68px; background: #0a1116; color: var(--ink); border: 1px solid var(--line); border-radius: 6px; padding: 3px 6px; font-family: var(--mono); }
+.group-title { font-family: var(--mono); font-size: 10px; letter-spacing: .12em; color: var(--dim); text-transform: uppercase; margin: 10px 0 4px; }
+
+.row { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
+.btn {
+  border: 1px solid var(--line); background: #0e1a21; color: var(--ink);
+  padding: 9px 14px; border-radius: 9px; cursor: pointer; font: inherit; transition: .15s;
+}
+.btn:hover:not(:disabled) { border-color: var(--accent); color: #fff; }
+.btn:disabled { opacity: .45; cursor: not-allowed; }
+.btn.primary { background: rgba(42,245,192,.14); border-color: var(--accent); color: var(--accent); font-weight: 600; }
+.btn.ghost { background: transparent; }
+
+/* ── métricas ── */
+.tiles { display: grid; grid-template-columns: repeat(auto-fit, minmax(120px, 1fr)); gap: 10px; }
+.tile { background: #0a1116; border: 1px solid var(--line); border-radius: 10px; padding: 10px 12px; }
+.tile .k { font-family: var(--mono); font-size: 10px; letter-spacing: .1em; text-transform: uppercase; color: var(--dim); }
+.tile .v { font-family: var(--mono); font-size: 22px; margin-top: 3px; color: var(--accent); }
+.tile .v.small { font-size: 15px; }
+.tile.bad .v { color: var(--bad); }
+.tile.warn .v { color: var(--warn); }
+
+/* barra de progreso */
+.bar { height: 6px; background: #0a1116; border: 1px solid var(--line); border-radius: 99px; overflow: hidden; }
+.bar > i { display: block; height: 100%; width: 0; background: linear-gradient(90deg, var(--accent-2), var(--accent)); transition: width .25s; }
+
+/* ── tabla de resultados ── */
+table { width: 100%; border-collapse: collapse; font-family: var(--mono); font-size: 12px; }
+th { text-align: left; color: var(--dim); font-weight: 500; font-size: 10px; letter-spacing: .1em; text-transform: uppercase; padding: 6px 8px; border-bottom: 1px solid var(--line); }
+td { padding: 6px 8px; border-bottom: 1px solid #131f27; }
+tr:last-child td { border-bottom: 0; }
+.ok { color: var(--accent); }
+.no { color: var(--bad); }
+.pend { color: var(--dim); }
+
+/* ── consola ── */
+.log {
+  font-family: var(--mono); font-size: 11.5px; line-height: 1.6; color: #9fb6c4;
+  background: #060a0d; border: 1px solid var(--line); border-radius: 9px;
+  padding: 10px 12px; height: 220px; overflow: auto; white-space: pre-wrap; word-break: break-word;
+}
+.log .t { color: #4d6572; }
+.log .a { color: var(--accent); }
+.log .w { color: var(--warn); }
+.log .e { color: var(--bad); }
+
+iframe.arena { width: 100%; height: 320px; border: 1px solid var(--line); border-radius: 9px; background: #000; }
+.hint { color: var(--dim); font-size: 12px; margin: 8px 0 0; }
+.pill { font-family: var(--mono); font-size: 10px; padding: 2px 7px; border-radius: 99px; border: 1px solid var(--line); color: var(--dim); }

index.html

@@ -8,14 +8,14 @@
 <meta property="og:site_name" content="Elffuss">
 <meta property="og:title" content="Elffuss Code — a VS Code-style IDE with an AI soul, in your browser">
 <meta property="og:description" content="A web IDE with an AI coding elf that reads, searches and edits your project. Open a folder and code with a local model on WebGPU — nothing leaves your machine.">
-<meta property="og:url" content="https://elffuss-code.utopiaia.com/">
-<meta property="og:image" content="https://elffuss-code.utopiaia.com/og.png">
+<meta property="og:url" content="https://code.elffuss.utopiaia.com/">
+<meta property="og:image" content="https://code.elffuss.utopiaia.com/og.png">
 <meta property="og:image:width" content="1200">
 <meta property="og:image:height" content="630">
 <meta name="twitter:card" content="summary_large_image">
 <meta name="twitter:title" content="Elffuss Code — a VS Code-style IDE with an AI soul, in your browser">
 <meta name="twitter:description" content="A web IDE with an AI coding elf that reads, searches and edits your project. Open a folder and code with a local model on WebGPU — nothing leaves your machine.">
-<meta name="twitter:image" content="https://elffuss-code.utopiaia.com/og.png">
+<meta name="twitter:image" content="https://code.elffuss.utopiaia.com/og.png">
 <meta name="description" content="Open a local folder and code with Elffuss: a web IDE plus an AI agent that runs on your own GPU (WebGPU). Nothing leaves your machine.">
 <link rel="icon" href="img/elffuss-code.svg">
 <link rel="stylesheet" href="css/code.css">
@@ -129,6 +129,7 @@
           <input id="prompt" autocomplete="off" placeholder="Pídele código a Elffuss…">
           <button type="button" id="btn-autoedit" class="cbtn autoedit on" title="Editar archivos automáticamente"><span class="ae-ico">&lt;/&gt;</span> <span class="ae-txt">Auto</span></button>
           <button type="button" id="btn-goal" class="cbtn goal" title="Modo Objetivo: descompone el mensaje en tareas y las ejecuta una a una (planificador + ejecutor)">🎯 <span class="goal-txt">Goal</span></button>
+          <button type="button" id="btn-hardwork" class="cbtn hardwork" title="Hard Work (RLM): lee tu proyecto ENTERO por partes — audita, resume o busca en código que no cabe en el modelo. Tarda, pero lo abarca todo.">⛏ <span class="hw-txt">Hard Work</span></button>
           <button type="submit" id="btn-send" title="Enviar"></button>
         </form>
       </div>
@@ -147,6 +148,5 @@
 </div>
 
 <script type="module" src="js/main.js"></script>
-<script type="module" src="js/challenge.js"></script>
 </body>
 </html>

js/challenge.js

@@ -1,74 +0,0 @@
-// challenge.js — top bar announcing the 15-minute challenge, with the two places to post
-// the result. Self-contained (injects its own CSS), dismissible, and it removes itself
-// after the deadline so nobody has to remember to take it down.
-import { uiLang } from './i18n.js';
-
-const DEADLINE = Date.parse('2026-08-10T00:00:00Z'); // winner announced Sun Aug 9
-const KEY = 'elffuss_challenge_v1_dismissed';
-const X_URL = 'https://x.com/KikoCisneros/status/2085358719190130963';
-const LI_URL = 'https://www.linkedin.com/feed/update/urn:li:activity:7491125059768516608/';
-
-const COPY = {
-  es: {
-    text: '⚡ Reto de 15 min: abre una carpeta tuya y deja que Elffuss arregle un bug real. Gana el comentario con más likes — ganador el domingo 9.',
-    x: 'Publicar en X', li: 'En LinkedIn', close: 'Cerrar aviso',
-  },
-  en: {
-    text: '⚡ 15-min challenge: open one of your folders and let Elffuss fix a real bug. Most-liked comment wins — winner on Sun Aug 9.',
-    x: 'Post on X', li: 'On LinkedIn', close: 'Dismiss',
-  },
-};
-
-export function mountChallengeBar() {
-  if (Date.now() > DEADLINE) return;
-  try { if (localStorage.getItem(KEY)) return; } catch (e) {}
-  const c = COPY[uiLang() === 'es' ? 'es' : 'en'];
-
-  const css = document.createElement('style');
-  css.textContent = `
-    body.elf-ch { padding-top: 38px; }
-    body.elf-ch #ide { height: calc(100vh - 38px); }
-    .elf-ch-bar {
-      position: fixed; inset: 0 0 auto 0; z-index: 400; height: 38px;
-      display: flex; align-items: center; justify-content: center; gap: 10px;
-      padding: 0 42px 0 12px; font-size: .82rem; color: #fff;
-      background: linear-gradient(135deg, var(--accent, #7c5cff), var(--accent2, #ff5cd6));
-      box-shadow: 0 2px 12px rgba(0,0,0,.35);
-    }
-    .elf-ch-bar span { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-    .elf-ch-bar a {
-      flex: none; padding: 3px 10px; border-radius: 999px; text-decoration: none;
-      color: #fff; background: rgba(0,0,0,.28); font-weight: 600;
-    }
-    .elf-ch-bar a:hover { background: rgba(0,0,0,.45); }
-    .elf-ch-bar button {
-      position: absolute; right: 8px; top: 50%; transform: translateY(-50%);
-      background: none; border: none; color: #fff; font-size: 1.1rem; cursor: pointer; opacity: .8;
-    }
-    .elf-ch-bar button:hover { opacity: 1; }
-    @media (max-width: 620px) { .elf-ch-bar span { font-size: .74rem; } }
-  `;
-  document.head.appendChild(css);
-
-  const bar = document.createElement('div');
-  bar.className = 'elf-ch-bar';
-  bar.innerHTML = `<span></span>
-    <a target="_blank" rel="noopener" href="${X_URL}"></a>
-    <a target="_blank" rel="noopener" href="${LI_URL}"></a>
-    <button type="button" aria-label=""></button>`;
-  bar.querySelector('span').textContent = c.text;
-  const [ax, ali] = bar.querySelectorAll('a');
-  ax.textContent = c.x; ali.textContent = c.li;
-  const btn = bar.querySelector('button');
-  btn.textContent = '✕'; btn.setAttribute('aria-label', c.close);
-  btn.addEventListener('click', () => {
-    try { localStorage.setItem(KEY, '1'); } catch (e) {}
-    bar.remove(); document.body.classList.remove('elf-ch');
-  });
-
-  document.body.classList.add('elf-ch');
-  document.body.appendChild(bar);
-}
-
-if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', mountChallengeBar);
-else mountChallengeBar();

js/conversations.js

@@ -59,7 +59,15 @@ export function getActive() { return activeId ? convs.get(activeId) : null; }
 export function getOpenTabs() { return openTabIds.map(id => convs.get(id)).filter(Boolean); }
 
 async function persistConv(conv) {
-  const all = await db.get('kv', 'conversations').catch(() => null) || [];
+  // NO tragarse el error de lectura: un fallo transitorio devolvía [] y el
+  // db.set de abajo reescribía el store entero con UNA sola conversación,
+  // borrando el resto. Distinguir «no existe aún» (undefined → []) de «no se
+  // pudo leer» (excepción → no escribir nada este turno).
+  let stored;
+  try { stored = await db.get('kv', 'conversations'); }
+  catch (e) { console.warn('[elffuss] no se pudo leer conversations; no sobrescribo', e); return; }
+  const all = stored == null ? [] : stored;
+  if (!Array.isArray(all)) { console.warn('[elffuss] conversations corrupto; no sobrescribo'); return; }
   const i = all.findIndex(c => c.id === conv.id);
   const rec = {
     id: conv.id, title: titleFor(conv), history: conv.agent.history.slice(-HIST_CAP),

js/i18n.js

@@ -54,7 +54,69 @@ const L = {
     setCalc: 'Calculando espacio…', setPersist: '✓ almacenamiento persistente (no se borra solo)',
     setNoPersist: '⚠ sin persistencia: el navegador podría desalojarlo', setLimit: ' · límite ~{gb}',
     setModelPh: 'modelo (p. ej. gpt-4o-mini)', keyNeeded: 'clave (no necesaria)',
-  },
+    wsTitle: "Espacio de trabajo (tu disco)",
+    wsDesc: "Tus conversaciones y skills viven en este navegador, que puede borrarlas. Guárdalas en una carpeta y quedan como ficheros normales.",
+    wsNoSupport: "Este navegador no permite elegir carpeta. Usa «Descargar copia».",
+    wsNoFolder: "Sin carpeta: solo viven en este navegador.",
+    wsFolder: "Carpeta: {name}",
+    wsNeedsPerm: "«{name}» necesita permiso otra vez (pasa al recargar).",
+    wsPick: "Elegir carpeta",
+    wsUseProject: "Usar la del proyecto",
+    wsRegrant: "Conceder permiso",
+    wsSaveNow: "Guardar ahora",
+    wsSaved: "Guardado ({n} almacenes)",
+    wsAuto: "Guardar solo",
+    wsForget: "Olvidar carpeta",
+    wsDownload: "Descargar copia",
+    wsWhat: "Qué hay guardado",
+    setTitle: "Ajustes",
+    close: "cerrar",
+    setBrainTitle: "Cerebro (modelo)",
+    setModelE4bSub: "El mejor · WebGPU local · ~4 GB",
+    setModelE2bSub: "Ligero · WebGPU local · ~2 GB",
+    setModelOnnxSub: "Modelo propio · 850 MB · tool-calls + apps",
+    setModelRulesSub: "Órdenes directas, cero descarga",
+    setBridgeTitle: "🔌 Bridge local (ejecución real en tu máquina)",
+    setBridgeDisconnected: "desconectado",
+    setBridgeFolderPh: "/ruta/completa/a/tu/proyecto",
+    setBridgeConnect: "Conectar",
+    setBridgeOnStatus: "✓ conectado — ejecución real activa",
+    setBridgeNoToken: "⚠️ pega el token que imprimió el programa al arrancarlo",
+    setBridgeConnecting: "Conectando…",
+    setBridgeConnectedMsg: "✔ conectado — ejecución real en tu máquina",
+    setPermTitle: "✅ Permisos de ejecución",
+    setGoalTitle: "🎯 Modo Objetivo",
+    setTelTitle: "📨 Errores y feedback",
+    setTelEmpty: "escribe algo primero",
+    setTelThanks: "¡enviado, gracias!",
+    setProvTitle: "Proveedores externos (opcional · la clave se queda en tu navegador)",
+    setProvUse: "Usar",
+    setManageSkillsBtn: "Gestionar skills de Claude Code",
+    skRemove: "Quitar",
+    skBrowse: "Explorar",
+    skAddRepoPh: "owner/repo o URL de GitHub (p. ej. OpenClaude/…)",
+    skAddRepo: "Añadir repo",
+    hwPlaceholder: "⛏ Hard Work: pregunta algo sobre TODO el proyecto…",
+    hwNeedBrain: "Hard Work necesita un cerebro cargado: elige un modelo en Ajustes y reintenta.",
+    hwNeedProject: "Hard Work trabaja sobre tu proyecto. Abre una carpeta primero y vuelve a pulsar ⛏ Hard Work.",
+    hwReading: "Hard Work · leyendo el proyecto…",
+    hwNoFiles: "No encontré archivos de texto/código legibles en el proyecto.",
+    hwTrimmed: " — recortado",
+    hwPhaseReduce: "Hard Work · sintetizando…",
+    hwResultTrunc: " Proyecto recortado al máximo — acota con una subcarpeta.",
+    planPlanning: "planificando…",
+    planRunning: "ejecutando…",
+    planDone: "completado",
+    planFailed: "con fallos",
+    stModelLoadingAI: "Cargando el modelo IA…",
+    termCapsBridge: "🔌 Bridge local: node/npm/python reales",
+    termCapsNoBridge: "shell del proyecto · node/npm/python → Bridge local (⚙ Ajustes)",
+    setBridgeFolderLabel: "Carpeta de trabajo (opcional — si no, usa una temporal)",
+    setBridgeDesc: "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.",
+    setBridgeDownload: "⬇ Descargar para {os}",
+    setBridgeOtherOS: "otro sistema operativo",
+    setModelRulesName: "Básico (sin modelo)",
+},
   en: {
     ph: 'Ask Elffuss for code…',
     thinking: 'Elffuss is thinking', writing: 'Elffuss writes · {n} chars', using: 'Elffuss uses {name}',
@@ -103,7 +165,69 @@ const L = {
     setCalc: 'Calculating space…', setPersist: '✓ persistent storage (won’t be auto-cleared)',
     setNoPersist: '⚠ not persistent: the browser could evict it', setLimit: ' · limit ~{gb}',
     setModelPh: 'model (e.g. gpt-4o-mini)', keyNeeded: 'key (not needed)',
-  },
+    wsTitle: "Workspace (your disk)",
+    wsDesc: "Your conversations and skills live in this browser, which can wipe them. Save them to a folder and they stay as normal files.",
+    wsNoSupport: "This browser can't pick a folder. Use «Download copy».",
+    wsNoFolder: "No folder: they only live in this browser.",
+    wsFolder: "Folder: {name}",
+    wsNeedsPerm: "«{name}» needs permission again (happens after a reload).",
+    wsPick: "Pick a folder",
+    wsUseProject: "Use the project's",
+    wsRegrant: "Grant permission",
+    wsSaveNow: "Save now",
+    wsSaved: "Saved ({n} stores)",
+    wsAuto: "Save automatically",
+    wsForget: "Forget folder",
+    wsDownload: "Download copy",
+    wsWhat: "What's stored",
+    setTitle: "Settings",
+    close: "close",
+    setBrainTitle: "Brain (model)",
+    setModelE4bSub: "The best · local WebGPU · ~4 GB",
+    setModelE2bSub: "Light · local WebGPU · ~2 GB",
+    setModelOnnxSub: "Our own model · 850 MB · tool-calls + apps",
+    setModelRulesSub: "Direct commands, zero download",
+    setBridgeTitle: "🔌 Local bridge (real execution on your machine)",
+    setBridgeDisconnected: "disconnected",
+    setBridgeFolderPh: "/full/path/to/your/project",
+    setBridgeConnect: "Connect",
+    setBridgeOnStatus: "✓ connected — real execution active",
+    setBridgeNoToken: "⚠️ paste the token the program printed on startup",
+    setBridgeConnecting: "Connecting…",
+    setBridgeConnectedMsg: "✔ connected — real execution on your machine",
+    setPermTitle: "✅ Execution permissions",
+    setGoalTitle: "🎯 Goal mode",
+    setTelTitle: "📨 Errors and feedback",
+    setTelEmpty: "type something first",
+    setTelThanks: "sent, thanks!",
+    setProvTitle: "External providers (optional · the key stays in your browser)",
+    setProvUse: "Use",
+    setManageSkillsBtn: "Manage Claude Code skills",
+    skRemove: "Remove",
+    skBrowse: "Browse",
+    skAddRepoPh: "owner/repo or GitHub URL (e.g. OpenClaude/…)",
+    skAddRepo: "Add repo",
+    hwPlaceholder: "⛏ Hard Work: ask something about the WHOLE project…",
+    hwNeedBrain: "Hard Work needs a loaded brain: pick a model in Settings and try again.",
+    hwNeedProject: "Hard Work works on your project. Open a folder first, then press ⛏ Hard Work again.",
+    hwReading: "Hard Work · reading the project…",
+    hwNoFiles: "I found no readable text/code files in the project.",
+    hwTrimmed: " — trimmed",
+    hwPhaseReduce: "Hard Work · synthesizing…",
+    hwResultTrunc: " Project trimmed to the max — narrow it down to a subfolder.",
+    planPlanning: "planning…",
+    planRunning: "running…",
+    planDone: "completed",
+    planFailed: "with failures",
+    stModelLoadingAI: "Loading the AI model…",
+    termCapsBridge: "🔌 Local bridge: real node/npm/python",
+    termCapsNoBridge: "project shell · node/npm/python → Local bridge (⚙ Settings)",
+    setBridgeFolderLabel: "Working folder (optional — otherwise a temporary one is used)",
+    setBridgeDesc: "A small program that YOU run on your computer — it gives the elf real execution (node, npm, python…) without leaving your machine. Nothing is installed in the browser.",
+    setBridgeDownload: "⬇ Download for {os}",
+    setBridgeOtherOS: "another operating system",
+    setModelRulesName: "Basic (no model)",
+},
 };
 
 // Idioma del chrome: 2 letras, ES por defecto.

js/lab.js

@@ -0,0 +1,574 @@
+// Elffuss Lab — banco de pruebas del propio producto.
+//
+// Tres cosas, en la misma mesa:
+//   1) ELEGIR algoritmo de generación (directo / RLM map-reduce / RLM con
+//      crítica) y ENCENDER o APAGAR cada perilla del compresor de contexto.
+//   2) LANZAR benchmarks reales y ver el progreso caso a caso, en vivo.
+//   3) GUARDAR la corrida con su TRAZA en un historial y un ranking LOCALES:
+//      todo se queda en esta máquina, no se envía nada a ningún sitio.
+//
+// Nada de esto simula: el banco de contexto llama al `packHistoryACER` de
+// verdad, el de SWE ejecuta los tests de verdad contra el módulo arreglado, y
+// el de juegos ejecuta el juego generado y lo puntúa mirándolo correr.
+import { DEFAULTS, packHistoryACER, estimateTokens } from './acer-core.js';
+import { TASKS } from './swe-tasks.js';
+
+const $ = s => document.querySelector(s);
+const el = (t, c, x) => { const n = document.createElement(t); if (c) n.className = c; if (x != null) n.textContent = x; return n; };
+
+// ─────────────────────────── estado ───────────────────────────
+const S = {
+  brain: localStorage.getItem('elffusscode.model') || 'rules',
+  algo: 'directo',
+  algoOpts: { rounds: 1, chunkTokens: 1800, maxChunks: 24 },
+  ctx: {},                       // overrides sobre DEFAULTS
+  bench: 'contexto',
+  provider: null,
+  running: false, abort: false,
+  run: null,                     // { bench, casos:[], métricas:{} } — la traza
+};
+
+// Perillas del compresor que tiene sentido tocar a mano (las demás quedan en su
+// valor por defecto). El «porqué» sale del propio acer-core.
+const CTX_KNOBS = [
+  ['recuperación', [
+    ['SEMANTIC', 'bool', 'fusiona embeddings con BM25 — INERTE en el banco de contexto (ese usa el packer sin embeddings)'],
+    ['MMR', 'bool', 'diversifica lo recuperado (evita repetir lo mismo)'],
+    ['DEDUP', 'bool', 'quita mensajes casi idénticos'],
+    ['PIN_QUERY_TERMS', 'bool', 'clava los términos de la pregunta'],
+    ['SUPERSEDE', 'bool', 'lo nuevo pisa a lo viejo cuando se contradicen'],
+    ['RECENCY_WEIGHT', 'num', 'peso de lo reciente al puntuar'],
+  ]],
+  ['presupuesto', [
+    ['ELASTIC', 'bool', 'estira/encoge según la presión real'],
+    ['RECENT', 'num', 'nº de turnos recientes intocables'],
+    ['TAIL_MIN_FRAC', 'num', 'suelo garantizado para la cola'],
+    ['HEAD_FRAC', 'num', 'reserva para el arranque (0 = apagada)'],
+    ['MAX_MSG_CHARS', 'num', 'recorte por mensaje'],
+  ]],
+  ['extras', [
+    ['DATES', 'bool', 'anota «ayer» con la fecha del turno'],
+    ['SUMMARY', 'bool', 'tarjeta de recuento (cuesta presupuesto)'],
+    ['AUTO', 'bool', 'deriva las perillas de lo medido en ESTE historial'],
+  ]],
+];
+
+const ALGOS = [
+  ['directo', 'Directo', 'Una sola inferencia. El baremo contra el que se compara todo.'],
+  ['rlm-deep', 'RLM · crear y criticar', 'Borrador → crítica → reescritura, N rondas (deepCreate).'],
+  ['rlm-hard', 'RLM · Hard Work', 'Trocea el material, pregunta a cada trozo y funde (map-reduce).'],
+];
+
+const BENCHES = [
+  ['contexto', 'Contexto (ACER)', 'Determinista y sin GPU: mide qué evidencia SOBREVIVE al compresor y a qué precio en tokens. Reacciona a las perillas al instante.'],
+  ['swe', 'SWE-bench-style', `${TASKS.length} repos con un bug real: el agente lo arregla con sus tools y se EJECUTA el test. Métrica: resolved/N.`],
+  ['juegos', 'Juegos (generar y jugar)', 'Genera un juego con el algoritmo elegido, lo ejecuta y lo puntúa: carga sin errores, arranca, se mueve y aguanta jugando.'],
+];
+
+const BRAINS = [
+  ['rules', 'Reglas (sin GPU)', 'Determinista. Valida el arnés sin bajar pesos.'],
+  ['onnx', 'Elffuss LM (CPU/wasm)', 'LFM2.5-1.2B por transformers.js.'],
+  ['litert:gemma-e2b', 'Gemma-4 E2B (~2 GB)', 'WebGPU.'],
+  ['litert:gemma-e4b', 'Gemma-4 E4B (~3 GB)', 'WebGPU. El mejor.'],
+];
+
+// ─────────────────────────── consola ───────────────────────────
+function log(msg, cls = '') {
+  const t = new Date().toTimeString().slice(0, 8);
+  const line = el('div');
+  line.appendChild(el('span', 't', t + '  '));
+  line.appendChild(el('span', cls, msg));
+  $('#log').appendChild(line);
+  $('#log').scrollTop = $('#log').scrollHeight;
+}
+const setLed = (id, cls, txt) => { const n = $(id); n.className = 'led ' + cls; n.querySelector('span').textContent = txt; };
+const prog = (done, total, txt) => {
+  $('#prog').style.width = total ? Math.round(done / total * 100) + '%' : '0';
+  $('#prog-txt').textContent = txt || (total ? `${done}/${total}` : '—');
+};
+
+function tiles(obj) {
+  const box = $('#tiles'); box.innerHTML = '';
+  for (const [k, v] of Object.entries(obj)) {
+    const t = el('div', 'tile' + (v && v.bad ? ' bad' : v && v.warn ? ' warn' : ''));
+    t.appendChild(el('div', 'k', k));
+    const val = (v && typeof v === 'object') ? v.v : v;
+    t.appendChild(el('div', 'v' + (String(val).length > 7 ? ' small' : ''), String(val)));
+    box.appendChild(t);
+  }
+}
+function table(cols, rows) {
+  $('#res-head').innerHTML = '<tr>' + cols.map(c => `<th>${c}</th>`).join('') + '</tr>';
+  $('#res-body').innerHTML = '';
+  rows.forEach(addRow);
+}
+function addRow(cells) {
+  const tr = el('tr');
+  cells.forEach(c => {
+    const td = el('td');
+    if (c && typeof c === 'object') { td.className = c.cls || ''; td.textContent = c.t; }
+    else td.textContent = c;
+    tr.appendChild(td);
+  });
+  $('#res-body').appendChild(tr);
+  return tr;
+}
+
+// ─────────────────────────── interfaz ───────────────────────────
+function radio(host, items, current, onPick) {
+  host.innerHTML = '';
+  items.forEach(([id, title, desc]) => {
+    const l = el('label', id === current ? 'sel' : '');
+    const i = el('input'); i.type = 'radio'; i.name = host.id; i.checked = id === current;
+    i.onchange = () => { onPick(id); radio(host, items, id, onPick); };
+    const d = el('div');
+    d.appendChild(el('div', 't', title));
+    d.appendChild(el('div', 'd', desc));
+    l.append(i, d); host.appendChild(l);
+  });
+}
+
+function ctxUI() {
+  const host = $('#ctx-knobs'); host.innerHTML = '';
+  for (const [group, knobs] of CTX_KNOBS) {
+    host.appendChild(el('div', 'group-title', group));
+    const box = el('div', 'knobs');
+    for (const [key, type, why] of knobs) {
+      const row = el('div', 'knob');
+      const cur = key in S.ctx ? S.ctx[key] : DEFAULTS[key];
+      const inp = el('input');
+      if (type === 'bool') { inp.type = 'checkbox'; inp.checked = !!cur; }
+      else { inp.type = 'number'; inp.step = 'any'; inp.value = cur ?? 0; }
+      inp.onchange = () => {
+        S.ctx[key] = type === 'bool' ? inp.checked : Number(inp.value);
+        ctxTag();
+        if (S.bench === 'contexto') log('perilla ' + key + ' → ' + S.ctx[key] + ' (relanza para medir)', 'w');
+      };
+      row.append(inp, el('code', '', key), el('div', 'why', why));
+      box.appendChild(row);
+    }
+    host.appendChild(box);
+  }
+  ctxTag();
+}
+function ctxTag() {
+  const on = CTX_KNOBS.flatMap(([, k]) => k).filter(([key, t]) => t === 'bool' && (key in S.ctx ? S.ctx[key] : DEFAULTS[key])).length;
+  $('#ctx-tag').textContent = on + ' activas';
+}
+function algoKnobs() {
+  const host = $('#algo-knobs'); host.innerHTML = '';
+  const defs = S.algo === 'rlm-hard'
+    ? [['chunkTokens', 'tamaño de cada trozo'], ['maxChunks', 'techo de sub-llamadas']]
+    : S.algo === 'rlm-deep' ? [['rounds', 'rondas de crítica + reescritura']] : [];
+  if (!defs.length) { host.appendChild(el('div', 'hint', 'El modo directo no tiene parámetros: una inferencia y ya.')); return; }
+  const box = el('div', 'knobs');
+  defs.forEach(([k, why]) => {
+    const row = el('div', 'knob');
+    const i = el('input'); i.type = 'number'; i.value = S.algoOpts[k]; i.min = 0;
+    i.onchange = () => { S.algoOpts[k] = Number(i.value); };
+    row.append(i, el('code', '', k), el('div', 'why', why));
+    box.appendChild(row);
+  });
+  host.appendChild(box);
+}
+
+// ─────────────────────────── cerebro ───────────────────────────
+async function loadBrain() {
+  const id = S.brain;
+  $('#btn-load').disabled = true;
+  setLed('#led-model', 'busy', 'cargando ' + id + '…');
+  try {
+    let mod;
+    if (id === 'rules') mod = await import('./providers/rules.js');
+    else if (id === 'onnx') mod = await import('./providers/onnx.js');
+    else if (id.startsWith('litert:')) {
+      mod = await import('./providers/litert.js');
+      mod.configure(id.split(':')[1]);
+    }
+    if (mod.load) await mod.load(s => { $('#load-state').textContent = String(s).slice(0, 60); });
+    S.provider = mod;
+    setLed('#led-model', 'on', 'modelo: ' + id);
+    $('#load-state').textContent = '';
+    log('cerebro listo: ' + id, 'a');
+  } catch (e) {
+    setLed('#led-model', 'err', 'fallo al cargar');
+    log('no se pudo cargar el cerebro: ' + e.message, 'e');
+  }
+  $('#btn-load').disabled = false;
+}
+
+// ═══════════════ BANCO 1 · contexto (determinista, sin GPU) ═══════════════
+// Construye un historial largo con HECHOS plantados y ruido alrededor, lo pasa
+// por el compresor con las perillas elegidas y mide qué evidencia sobrevive y
+// cuántos tokens cuesta. Sin modelo: mide el COMPRESOR, no al que responde.
+// Cada caso trae: el dato BUENO, una versión CADUCADA del mismo dato (dicha
+// antes) y distractores que comparten vocabulario con la pregunta. Así el banco
+// no premia «meter mucho», sino traer lo correcto y dejar fuera lo viejo — que
+// es lo que de verdad hacen SUPERSEDE, PIN_QUERY_TERMS o DEDUP.
+const HECHOS = [
+  { bueno: 'Ahora el servidor de pagos escucha en el puerto 7421.', viejo: 'El servidor de pagos escuchaba en el puerto 3000.',
+    q: '¿en qué puerto escucha el servidor de pagos?', clave: '7421', claveVieja: '3000',
+    ruido: ['El servidor de correo va por otro puerto distinto.', 'Ese puerto del router no tiene nada que ver con pagos.'] },
+  { bueno: 'La clave de despliegue caduca el 3 de marzo.', viejo: 'La clave de despliegue caducaba el 9 de enero.',
+    q: '¿cuándo caduca la clave de despliegue?', clave: '3 de marzo', claveVieja: '9 de enero',
+    ruido: ['La clave del wifi la cambiaron en verano.', 'El despliegue de ayer no tocó ninguna clave.'] },
+  { bueno: 'Nordvik factura ahora en coronas.', viejo: 'Nordvik facturaba en euros.',
+    q: '¿en qué moneda factura Nordvik?', clave: 'coronas', claveVieja: 'facturaba en euros',
+    ruido: ['Nordvik cambió de comercial el trimestre pasado.', 'A otros clientes se les factura en euros.'] },
+  { bueno: 'El informe trimestral lo firma Beatriz.', viejo: 'El informe trimestral lo firmaba Andrés.',
+    q: '¿quién firma el informe trimestral?', clave: 'firma Beatriz', claveVieja: 'firmaba Andrés',
+    ruido: ['Andrés sigue en la empresa, pero en otro equipo.', 'Beatriz también revisa el informe mensual.'] },
+  { bueno: 'El backup nocturno corre a las 02:30.', viejo: 'El backup nocturno corría a las 23:00.',
+    q: '¿a qué hora corre el backup nocturno?', clave: '02:30', claveVieja: '23:00',
+    ruido: ['El backup semanal es otra tarea distinta.', 'A las 23:00 lo que hay es el corte de logs.'] },
+  { bueno: 'El almacén de Lugo pasó a Vigo.', viejo: 'El almacén principal estaba en Lugo.',
+    q: '¿a dónde se movió el almacén de Lugo?', clave: 'pasó a Vigo', claveVieja: 'estaba en Lugo',
+    ruido: ['En Lugo queda solo una oficina comercial.', 'El almacén de Vigo ya existía para otra cosa.'] },
+];
+const RUIDO = [
+  'Vale, seguimos mañana con eso.', 'Te paso el enlace en un momento.',
+  'Creo que el diseño nuevo se ve mejor.', 'Nos vemos en la reunión de las cinco.',
+  'Ese ticket lo cerró soporte la semana pasada.', 'Prefiero no tocar eso hoy.',
+  'Lo dejo apuntado para el lunes.', 'Sí, ya lo hemos hablado antes.',
+];
+
+// Historial LARGO: el dato bueno queda enterrado y fuera de la ventana reciente.
+function historialCon(c, largo = 420) {
+  const h = [];
+  const posViejo = Math.floor(largo * 0.10);
+  const posBueno = Math.floor(largo * 0.55);
+  const posRuido = [Math.floor(largo * 0.30), Math.floor(largo * 0.75)];
+  for (let i = 0; i < largo; i++) {
+    let txt = RUIDO[i % RUIDO.length] + ' (' + i + ')';
+    if (i === posViejo) txt = c.viejo;
+    else if (i === posBueno) txt = c.bueno;
+    else if (i === posRuido[0]) txt = c.ruido[0];
+    else if (i === posRuido[1]) txt = c.ruido[1];
+    h.push({ role: i % 2 ? 'assistant' : 'user', content: txt, ts: Date.now() - (largo - i) * 60000 });
+  }
+  return h;
+}
+
+async function benchContexto(onCase) {
+  const opts = { ...DEFAULTS, ...S.ctx };
+  const budget = 320;                    // muy apretado: obliga a ELEGIR
+  const filas = [];
+  for (let i = 0; i < HECHOS.length; i++) {
+    if (S.abort) break;
+    const c = HECHOS[i];
+    const hist = historialCon(c);
+    hist.push({ role: 'user', content: c.q, ts: Date.now() });
+    const { messages } = packHistoryACER(hist, budget, opts);
+    const texto = messages.map(m => m.content).join('\n');
+    const sobrevive = texto.includes(c.clave);
+    const arrastraViejo = texto.includes(c.claveVieja);
+    const usados = estimateTokens(texto);
+    filas.push({ pregunta: c.q, sobrevive, arrastraViejo, usados, deN: hist.length, quedan: messages.length });
+    onCase(filas[filas.length - 1], i, HECHOS.length);
+    await new Promise(r => setTimeout(r, 25));         // deja respirar a la UI
+  }
+  const rec = filas.filter(f => f.sobrevive).length;
+  const conf = filas.filter(f => f.arrastraViejo).length;
+  return {
+    filas,
+    resumen: {
+      'evidencia recuperada': `${rec}/${filas.length}`,
+      'recall': (filas.length ? (rec / filas.length * 100).toFixed(0) : 0) + '%',
+      'arrastra dato viejo': { v: `${conf}/${filas.length}`, bad: conf > 0 },
+      'tokens medios': Math.round(filas.reduce((a, f) => a + f.usados, 0) / (filas.length || 1)),
+      'presupuesto': budget,
+      'mensajes que pasan': Math.round(filas.reduce((a, f) => a + f.quedan, 0) / (filas.length || 1)),
+    },
+  };
+}
+
+// ═══════════════ BANCO 2 · SWE-bench-style (ejecuta los tests) ═══════════════
+async function opfsRoot() { return navigator.storage.getDirectory(); }
+async function limpiarOPFS() {
+  const o = await opfsRoot();
+  for await (const e of o.values()) await o.removeEntry(e.name, { recursive: true }).catch(() => {});
+}
+async function sembrar(files) {
+  const o = await opfsRoot();
+  for (const [path, txt] of Object.entries(files)) {
+    const parts = path.split('/'); const name = parts.pop(); let d = o;
+    for (const x of parts) d = await d.getDirectoryHandle(x, { create: true });
+    const w = await (await d.getFileHandle(name, { create: true })).createWritable();
+    await w.write(txt); await w.close();
+  }
+}
+async function leer(path) {
+  const o = await opfsRoot();
+  const parts = path.split('/'); const name = parts.pop(); let d = o;
+  for (const x of parts) d = await d.getDirectoryHandle(x);
+  return (await (await d.getFileHandle(name)).getFile()).text();
+}
+// Ejecuta DE VERDAD el módulo arreglado y le pasa el test de la tarea.
+async function pasaElTest(task) {
+  const src = await leer(task.target);
+  const url = URL.createObjectURL(new Blob([src], { type: 'text/javascript' }));
+  try { return !!task.test(await import(/* @vite-ignore */ url)); }
+  catch { return false; }
+  finally { URL.revokeObjectURL(url); }
+}
+
+async function benchSWE(onCase) {
+  const code = await import('./tools/code.js');
+  await code.openProject(await opfsRoot());
+  const { Agent } = await import('./agent.js');
+  const filas = [];
+  for (let i = 0; i < TASKS.length; i++) {
+    if (S.abort) break;
+    const t = TASKS[i];
+    await limpiarOPFS(); await sembrar(t.files);
+    code.invalidateFileList();
+    const t0 = performance.now();
+    let pasos = 0, err = null;
+    try {
+      if (S.brain === 'rules') {
+        // Solver de guion: valida el ARNÉS (debe dar N/N) sin gastar GPU.
+        await sembrar({ [t.target]: t.solution });
+      } else {
+        const ag = new Agent(S.provider);
+        await ag.handle(`${t.task}\n\nEl fichero a arreglar es ${t.target}. Usa code.read y code.edit.`,
+          ev => { if (ev.type === 'tool') pasos++; });
+      }
+    } catch (e) { err = e.message; }
+    const ok = err ? false : await pasaElTest(t);
+    filas.push({ id: t.id, ok, pasos, secs: Math.round((performance.now() - t0) / 1000), err });
+    onCase(filas[filas.length - 1], i, TASKS.length);
+  }
+  const res = filas.filter(f => f.ok).length;
+  return { filas, resumen: { resolved: `${res}/${filas.length}`, '% resueltas': (filas.length ? (res / filas.length * 100).toFixed(0) : 0) + '%', 'pasos totales': filas.reduce((a, f) => a + f.pasos, 0) } };
+}
+
+// ═══════════════ BANCO 3 · juegos (genera, ejecuta y puntúa) ═══════════════
+const BRIEF_JUEGO = 'Un juego tipo Flappy Bird: un pájaro que cae por gravedad, sube al pulsar espacio o click, ' +
+  'tuberías que avanzan y hay que esquivar, colisiones, puntuación y pantalla de fin de partida.';
+
+async function generarJuego() {
+  const rlm = await import('./rlm.js').catch(() => null);
+  if (!rlm) throw new Error('rlm.js no disponible en esta build');
+  let inferencias = 0;
+  const contando = { chat: (...a) => { inferencias++; return S.provider.chat(...a); } };
+  const rondas = S.algo === 'rlm-deep' ? Math.max(1, S.algoOpts.rounds) : 0;
+  const out = await rlm.deepCreate({ brief: BRIEF_JUEGO, provider: contando, rounds: rondas, onProgress: e => log('  ' + JSON.stringify(e)) });
+  return { html: out.html, inferencias, trace: out.trace };
+}
+
+// Puntúa el juego EJECUTÁNDOLO en la arena: ¿carga sin errores? ¿arranca?
+// ¿se mueve? ¿aguanta jugando? Cada criterio suma.
+async function puntuarJuego(html) {
+  const frame = $('#arena');
+  $('#arena-panel').hidden = false;
+  const errores = [];
+  const onErr = e => errores.push(String(e.message || e).slice(0, 120));
+  frame.srcdoc = html;
+  await new Promise(r => frame.onload = r);
+  const w = frame.contentWindow, d = frame.contentDocument;
+  w.addEventListener('error', onErr);
+  const hash = () => {
+    const c = d.querySelector('canvas'); if (!c) return -1;
+    try { const px = c.getContext('2d').getImageData(0, 0, c.width, c.height).data;
+      let h = 7; for (let i = 0; i < px.length; i += 997) h = (h * 31 + px[i]) % 999983; return h;
+    } catch { return -1; }
+  };
+  const esperar = ms => new Promise(r => setTimeout(r, ms));
+  const canvas = !!d.querySelector('canvas');
+  await esperar(600);
+  const h0 = hash();
+  // arrancar: pulsar el botón si lo hay, y quitarle el foco (si no, ESPACIO
+  // re-pulsa el botón en vez de saltar — nos pasó midiéndolo a mano)
+  const btn = d.querySelector('button');
+  if (btn) { btn.click(); btn.blur?.(); }
+  await esperar(400);
+  const arranca = hash() !== h0;
+  // jugar: aletear con click en el canvas, que es el manejador que sí registran
+  const c = d.querySelector('canvas');
+  let vivoMs = 0, puntos = 0;
+  const t0 = performance.now();
+  for (let i = 0; i < 20; i++) {
+    c?.dispatchEvent(new w.MouseEvent('click', { bubbles: true }));
+    d.dispatchEvent(new w.KeyboardEvent('keydown', { key: ' ', code: 'Space', bubbles: true }));
+    await esperar(300);
+    const run = (() => { try { return w.gameRunning; } catch { return null; } })();
+    puntos = Math.max(puntos, (() => { try { return w.score || 0; } catch { return 0; } })());
+    if (run === false) break;
+    vivoMs = performance.now() - t0;
+  }
+  const criterios = {
+    'carga sin errores': errores.length === 0,
+    'tiene canvas': canvas,
+    'arranca': arranca,
+    'aguanta ≥3 s jugando': vivoMs >= 3000,
+    'llega a puntuar': puntos > 0,
+  };
+  return { criterios, errores, vivoSegs: +(vivoMs / 1000).toFixed(1), puntos, bytes: html.length };
+}
+
+async function benchJuegos(onCase) {
+  if (!S.provider || S.brain === 'rules') throw new Error('este banco necesita un modelo de verdad (Reglas no genera juegos)');
+  const filas = [];
+  log('generando el juego con «' + S.algo + '»… esto tarda', 'w');
+  const g = await generarJuego();
+  log(`generado: ${g.html.length} bytes en ${g.inferencias} inferencias`, 'a');
+  const p = await puntuarJuego(g.html);
+  Object.entries(p.criterios).forEach(([k, v], i) => {
+    filas.push({ criterio: k, ok: v });
+    onCase(filas[filas.length - 1], i, Object.keys(p.criterios).length);
+  });
+  S.lastGame = { html: g.html, trace: g.trace };
+  const pasa = filas.filter(f => f.ok).length;
+  return {
+    filas,
+    resumen: {
+      'criterios superados': `${pasa}/${filas.length}`, inferencias: g.inferencias,
+      'bytes': p.bytes, 'segundos vivo': p.vivoSegs, 'puntuación': p.puntos,
+    },
+  };
+}
+
+// ─────────────────────────── orquestación ───────────────────────────
+async function run() {
+  if (S.running) return;
+  S.running = true; S.abort = false;
+  $('#btn-run').disabled = true; $('#btn-stop').disabled = false;
+  setLed('#led-run', 'busy', 'ejecutando ' + S.bench);
+  tiles({}); prog(0, 1, 'preparando…');
+  log('▶ benchmark «' + S.bench + '» · algoritmo «' + S.algo + '» · cerebro «' + S.brain + '»', 'a');
+  const t0 = Date.now();
+  let out = null, error = null;
+  try {
+    if (S.bench === 'contexto') {
+      table(['pregunta', 'dato bueno', 'dato viejo', 'tokens', 'mensajes'], []);
+      out = await benchContexto((f, i, n) => {
+        addRow([f.pregunta.slice(0, 38),
+          f.sobrevive ? { t: 'SOBREVIVE', cls: 'ok' } : { t: 'PERDIDO', cls: 'no' },
+          f.arrastraViejo ? { t: 'lo arrastra', cls: 'no' } : { t: 'descartado', cls: 'ok' },
+          f.usados, `${f.quedan}/${f.deN}`]);
+        prog(i + 1, n, `caso ${i + 1} de ${n}`);
+      });
+    } else if (S.bench === 'swe') {
+      table(['tarea', 'resultado', 'pasos', 'seg'], []);
+      out = await benchSWE((f, i, n) => {
+        addRow([f.id, f.ok ? { t: 'RESUELTA', cls: 'ok' } : { t: f.err ? 'ERROR' : 'FALLA', cls: 'no' }, f.pasos, f.secs]);
+        prog(i + 1, n, `tarea ${i + 1} de ${n}`);
+      });
+    } else {
+      table(['criterio', 'resultado'], []);
+      out = await benchJuegos((f, i, n) => {
+        addRow([f.criterio, f.ok ? { t: 'SÍ', cls: 'ok' } : { t: 'NO', cls: 'no' }]);
+        prog(i + 1, n, `criterio ${i + 1} de ${n}`);
+      });
+    }
+  } catch (e) { error = e.message; log('fallo: ' + e.message, 'e'); }
+
+  if (out) {
+    tiles(out.resumen);
+    S.run = {
+      bench: S.bench, algo: S.algo, algoOpts: { ...S.algoOpts }, brain: S.brain,
+      ctx: { ...DEFAULTS, ...S.ctx }, resumen: out.resumen, casos: out.filas,
+      duracionSegs: Math.round((Date.now() - t0) / 1000), cuando: new Date().toISOString(),
+    };
+    log('✔ terminado: ' + JSON.stringify(out.resumen), 'a');
+  }
+  setLed('#led-run', error ? 'err' : 'on', error ? 'con fallo' : 'listo');
+  prog(1, 1, error ? 'abortado' : 'completado');
+  S.running = false; $('#btn-run').disabled = false; $('#btn-stop').disabled = true;
+}
+
+// ─────────────────── historial y ranking, en local ───────────────────
+// Todo se queda en esta máquina: ni se envía ni se pide permiso a nadie. La
+// gracia del ranking es comparar CONFIGURACIONES entre sí — qué combinación de
+// algoritmo y perillas gana en cada banco — con su traza al lado para revisarla.
+const STORE = 'elffusscode.lab.runs';
+const MAX_GUARDADAS = 60;
+
+// Puntuación comparable (0-100) según el banco, para poder ordenar.
+function puntuar(r) {
+  const n = (s) => Number(String(s).split('/')[0]) || 0;
+  const d = (s) => Number(String(s).split('/')[1]) || 1;
+  if (r.bench === 'contexto') return Math.round(n(r.resumen['evidencia recuperada']) / d(r.resumen['evidencia recuperada']) * 100);
+  if (r.bench === 'swe') return Math.round(n(r.resumen.resolved) / d(r.resumen.resolved) * 100);
+  return Math.round(n(r.resumen['criterios superados']) / d(r.resumen['criterios superados']) * 100);
+}
+// Huella corta de la configuración: lo que de verdad distingue una corrida.
+function huella(r) {
+  const on = Object.entries(r.ctx).filter(([k, v]) => v === true).map(([k]) => k);
+  const extra = r.algo === 'rlm-deep' ? `·${r.algoOpts.rounds}r` : '';
+  return `${r.algo}${extra} · ${r.brain} · ${on.length} perillas`;
+}
+const leerRuns = () => { try { return JSON.parse(localStorage.getItem(STORE)) || []; } catch { return []; } };
+function guardarCorrida() {
+  if (!S.run) return log('todavía no hay ninguna corrida que guardar', 'w');
+  const runs = leerRuns();
+  runs.push({ ...S.run, score: puntuar(S.run), id: (S.run.cuando || '') + '·' + Math.round(performance.now()) });
+  localStorage.setItem(STORE, JSON.stringify(runs.slice(-MAX_GUARDADAS)));
+  log('guardada en el historial local (' + runs.length + ' corridas)', 'a');
+  pintarRanking();
+}
+function pintarRanking() {
+  const host = $('#rank-body'); host.innerHTML = '';
+  const runs = leerRuns().filter(r => r.bench === S.bench).sort((a, b) => b.score - a.score);
+  $('#rank-tag').textContent = runs.length ? runs.length + ' corridas · ' + S.bench : 'sin corridas de ' + S.bench;
+  if (!runs.length) { host.innerHTML = '<tr><td colspan="5" class="pend">Aún no has guardado ninguna corrida de este banco.</td></tr>'; return; }
+  runs.forEach((r, i) => {
+    const tr = el('tr');
+    const medalla = i === 0 ? '🥇' : i === 1 ? '🥈' : i === 2 ? '🥉' : String(i + 1);
+    [[medalla], [{ t: r.score + '%', cls: r.score >= 80 ? 'ok' : r.score >= 40 ? '' : 'no' }],
+     [huella(r)], [new Date(r.cuando).toLocaleString()]].forEach(([c]) => {
+      const td = el('td');
+      if (c && typeof c === 'object') { td.className = c.cls || ''; td.textContent = c.t; } else td.textContent = c;
+      tr.appendChild(td);
+    });
+    const acc = el('td');
+    const ver = el('button', 'btn ghost', 'traza');
+    ver.style.padding = '2px 8px'; ver.style.fontSize = '11px';
+    ver.onclick = () => descargarTraza(r);
+    acc.appendChild(ver); tr.appendChild(acc);
+    host.appendChild(tr);
+  });
+}
+// Exportar es un fichero en tu disco, no un envío: sirve para revisar la traza
+// caso a caso o comparar dos corridas fuera del panel.
+function descargarTraza(r) {
+  const a = el('a');
+  a.href = URL.createObjectURL(new Blob([JSON.stringify(r, null, 2)], { type: 'application/json' }));
+  a.download = `elffuss-lab-${r.bench}-${r.score}.json`;
+  a.click();
+  log('traza exportada a tu disco', 'a');
+}
+function borrarHistorial() {
+  if (!confirm('¿Borrar TODAS las corridas guardadas?')) return;
+  localStorage.removeItem(STORE); pintarRanking(); log('historial local borrado', 'w');
+}
+
+// ─────────────────────────── arranque ───────────────────────────
+radio($('#brains'), BRAINS, S.brain, id => { S.brain = id; $('#brain-tag').textContent = id; });
+radio($('#algos'), ALGOS, S.algo, id => { S.algo = id; $('#algo-tag').textContent = id; algoKnobs(); });
+radio($('#benches'), BENCHES, S.bench, id => { S.bench = id; $('#bench-tag').textContent = id; });
+$('#brain-tag').textContent = S.brain;
+$('#bench-tag').textContent = S.bench;
+algoKnobs(); ctxUI();
+
+$('#btn-load').onclick = loadBrain;
+$('#btn-run').onclick = run;
+$('#btn-stop').onclick = () => { S.abort = true; log('parando tras el caso en curso…', 'w'); };
+$('#ctx-all').onclick = () => { CTX_KNOBS.flatMap(([, k]) => k).forEach(([k, t]) => { if (t === 'bool') S.ctx[k] = true; }); ctxUI(); };
+$('#ctx-none').onclick = () => { CTX_KNOBS.flatMap(([, k]) => k).forEach(([k, t]) => { if (t === 'bool') S.ctx[k] = false; }); ctxUI(); };
+$('#ctx-def').onclick = () => { S.ctx = {}; ctxUI(); };
+$('#btn-launch').onclick = () => {
+  localStorage.setItem('elffusscode.model', S.brain);
+  localStorage.setItem('elffusscode.ctxopts', JSON.stringify(S.ctx));
+  localStorage.setItem('elffusscode.algo', JSON.stringify({ algo: S.algo, opts: S.algoOpts }));
+  log('configuración guardada; abriendo el IDE', 'a');
+  window.open('index.html', '_blank');
+};
+
+$('#btn-save').onclick = guardarCorrida;
+$('#btn-clear').onclick = borrarHistorial;
+pintarRanking();
+
+log('Elffuss Lab listo. Elige algoritmo, enciende o apaga la compresión y lanza un banco.', 'a');
+log('El banco de contexto no necesita GPU: mide el compresor y responde al instante.');
+log('Los resultados se quedan en esta máquina: historial y ranking local, sin enviar nada.');

js/main.js

@@ -20,6 +20,24 @@ import { t, applyI18n } from './i18n.js';
 import * as bridge from './bridge.js';
 import * as conv from './conversations.js';
 import { TASK_PREFIX } from './goal.js';
+import { hardWork, gatherFolder } from './rlm.js';
+import * as workspace from './workspace.js';
+
+// Espacio de trabajo (core): qué de Code puede guardarse en tu disco.
+workspace.init({
+  app: 'code', ns: 'elffusscode', db,
+  stores: [
+    { id: 'conversations', label: 'Conversaciones', icon: '💬', kind: 'idb-key', store: 'kv', key: 'conversations',
+      files: { ext: '.json', name: c => c.title || c.id } },
+    { id: 'skills', label: 'Skills', icon: '🧩', kind: 'idb-key', store: 'kv', key: 'skills',
+      files: { ext: '.md', name: s => s.name, body: s => `---\nname: ${s.name}\ndescription: ${s.description || ''}\n---\n\n${s.content || ''}` } },
+    { id: 'prefs', label: 'Preferencias', icon: '⚙️', kind: 'ls',
+      keys: ['elffusscode.model', 'elffusscode.autoedit', 'elffusscode.goalmode', 'elffuss.acer', 'elffuss.resumen', 'elffuss.semantic'] },
+  ],
+});
+workspace.restore().catch(() => {});
+if (workspace.autosaveEnabled()) workspace.autosave({ enabled: true });
+
 import * as telemetry from './telemetry.js';
 
 const $ = id => document.getElementById(id);
@@ -100,7 +118,7 @@ const escapeHtml = s => String(s).replace(/[&<>"']/g, c => ({ '&': '&amp;', '<':
 // llegan los eventos 'plan'/'plan_update'/'plan_complete' — así se ve la
 // lista evolucionar en vivo en vez de reconstruirse entera cada vez.
 const PLAN_ICO = { pending: '⏳', 'in-progress': '🔄', done: '✅', failed: '❌', skipped: '⏭️' };
-const PLAN_STATUS_LABEL = { planning: 'planificando…', running: 'ejecutando…', done: 'completado', failed: 'con fallos' };
+const PLAN_STATUS_LABEL = { planning: t("planPlanning"), running: t("planRunning"), done: t("planDone"), failed: t("planFailed") };
 function renderPlanCard(plan) {
   const domId = 'plan-' + plan.id;
   let div = document.getElementById(domId);
@@ -338,7 +356,7 @@ function modelOptions() {
   if (realGPU) opts.push({ id: 'litert:gemma-e4b', label: 'Gemma-4 E4B · LiteRT-LM (~4 GB) ★' });
   if (realGPU) opts.push({ id: 'litert:gemma-e2b', label: 'Gemma-4 E2B · LiteRT-LM (~2 GB)' });
   opts.push({ id: 'onnx', label: 'Elffuss LM (healed · 850 MB) — ligero' });
-  opts.push({ id: 'rules', label: 'Básico (sin modelo)' });
+  opts.push({ id: 'rules', label: t('setModelRulesName') });
   return [...opts, ...settings.enabledExternals()];
 }
 
@@ -382,7 +400,7 @@ async function changeModel(id) {
   if (loadingId === id || activeModel === id) return true; // un solo modelo, una sola carga
   loadingId = id;
   $('model-dot').className = 'dot loading';
-  showModelProgress('Cargando el modelo IA…', 4);
+  showModelProgress(t("stModelLoadingAI"), 4);
   try {
     const mod = await resolveProvider(id);
     await mod.load(p => {
@@ -451,7 +469,7 @@ function settingsShell(title) {
   const box = $('settings-panel');
   box.hidden = false;
   box.replaceChildren();
-  const close = el('button', 'panel-close'); close.innerHTML = UI.close; close.title = 'cerrar';
+  const close = el('button', 'panel-close'); close.innerHTML = UI.close; close.title = t("close");
   close.onclick = () => { box.hidden = true; };
   box.append(close, el('h3', 'panel-title', title));
   return box;
@@ -502,15 +520,15 @@ function fireworks() {
 }
 
 function renderSettings() {
-  const box = settingsShell('Ajustes');
+  const box = settingsShell(t("setTitle"));
 
   // --- Cerebro (modelo) ---
-  box.append(el('div', 'sk-h', 'Cerebro (modelo)'));
+  box.append(el('div', 'sk-h', t("setBrainTitle")));
   const LOCAL = [
-    { id: 'litert:gemma-e4b', name: 'Gemma-4 E4B ★', sub: 'El mejor · WebGPU local · ~4 GB', need: 'gpu' },
-    { id: 'litert:gemma-e2b', name: 'Gemma-4 E2B', sub: 'Ligero · WebGPU local · ~2 GB', need: 'gpu' },
-    { id: 'onnx', name: 'Elffuss LM (healed)', sub: 'Modelo propio · 850 MB · tool-calls + apps' },
-    { id: 'rules', name: 'Básico (sin modelo)', sub: 'Órdenes directas, cero descarga' },
+    { id: 'litert:gemma-e4b', name: 'Gemma-4 E4B ★', sub: t("setModelE4bSub"), need: 'gpu' },
+    { id: 'litert:gemma-e2b', name: 'Gemma-4 E2B', sub: t("setModelE2bSub"), need: 'gpu' },
+    { id: 'onnx', name: 'Elffuss LM (healed)', sub: t("setModelOnnxSub") },
+    { id: 'rules', name: t('setModelRulesName'), sub: t("setModelRulesSub") },
   ];
   const grid = el('div', 'model-grid');
   for (const m of LOCAL) {
@@ -523,6 +541,53 @@ function renderSettings() {
   }
   box.appendChild(grid);
 
+  // --- Espacio de trabajo: guardar conversaciones/skills en disco ---
+  box.append(el('div', 'sk-h', '💾 ' + t('wsTitle')));
+  const wsCard = el('div', 'prov-card');
+  const wsState = el('div', 'muted'); wsState.style.fontSize = '.78rem';
+  const wsRow = el('div', 'field'); wsRow.style.cssText = 'display:flex;gap:8px;flex-wrap:wrap;margin-top:8px';
+  const wsInv = el('div'); wsInv.style.cssText = 'margin-top:10px;font-size:.78rem';
+  wsCard.append(el('span', 'muted', t('wsDesc')), wsState, wsRow, wsInv);
+  box.appendChild(wsCard);
+  const wsKb = n => n > 1048576 ? (n / 1048576).toFixed(1) + ' MB' : n > 1024 ? Math.round(n / 1024) + ' KB' : n + ' B';
+  async function paintWs() {
+    const st = workspace.status();
+    wsRow.replaceChildren();
+    wsState.textContent = !st.supported.pick ? t('wsNoSupport')
+      : !st.folder ? t('wsNoFolder')
+      : st.ready ? t('wsFolder', { name: st.folder }) : t('wsNeedsPerm', { name: st.folder });
+    const mk = (label, fn) => { const b = el('button', 'prov-use', label); b.onclick = fn; wsRow.appendChild(b); };
+    if (st.supported.pick) {
+      if (!st.folder) {
+        mk(t('wsPick'), async () => { try { await workspace.pick(); await paintWs(); } catch (e) { wsState.textContent = '⚠️ ' + e.message; } });
+        // Code ya tiene una carpeta abierta: reutilizarla es un clic
+        if (codeTools.handle()) mk(t('wsUseProject'), async () => { await workspace.adopt(codeTools.handle()); await paintWs(); });
+      } else if (!st.ready) mk(t('wsRegrant'), async () => { try { await workspace.regrant(); await paintWs(); } catch (e) { wsState.textContent = '⚠️ ' + e.message; } });
+      else {
+        mk(t('wsSaveNow'), async () => { try { const r = await workspace.save(); wsState.textContent = r.ok ? t('wsSaved', { n: r.wrote.length }) : '⚠️ ' + (r.errors[0]?.error || ''); } catch (e) { wsState.textContent = '⚠️ ' + e.message; await paintWs(); } });
+        const lbl = el('label', null); lbl.style.cssText = 'display:flex;align-items:center;gap:6px;font-size:.78rem';
+        const chk = el('input'); chk.type = 'checkbox'; chk.checked = workspace.autosaveEnabled();
+        chk.onchange = () => workspace.autosave({ enabled: chk.checked });
+        lbl.append(chk, el('span', 'muted', t('wsAuto'))); wsRow.appendChild(lbl);
+        mk(t('wsForget'), async () => { await workspace.forget(); await paintWs(); });
+      }
+    }
+    mk(t('wsDownload'), async () => {
+      const blob = await workspace.bundle();
+      const a = document.createElement('a');
+      a.href = URL.createObjectURL(blob);
+      a.download = `elffuss-code-${new Date().toISOString().slice(0, 10)}.json`;
+      a.click(); setTimeout(() => URL.revokeObjectURL(a.href), 4000);
+    });
+    wsInv.replaceChildren(el('b', null, t('wsWhat')));
+    for (const it of await workspace.inventory()) {
+      const line = el('div'); line.style.cssText = 'display:flex;justify-content:space-between;padding:3px 0';
+      line.append(el('span', null, `${it.icon} ${it.label}`), el('span', 'muted', it.error ? '⚠️' : `${it.count} · ${wsKb(it.bytes)}`));
+      wsInv.appendChild(line);
+    }
+  }
+  paintWs().catch(() => {});
+
   // --- Almacenamiento del modelo (caché persistente) ---
   box.append(el('div', 'sk-h', t('setStoreTitle')));
   const storeCard = el('div', 'prov-card');
@@ -545,7 +610,7 @@ function renderSettings() {
   paintStorage();
 
   // --- Bridge local (ejecución REAL en tu máquina: node, npm, python…) ---
-  box.append(el('div', 'sk-h', '🔌 Bridge local (ejecución real en tu máquina)'));
+  box.append(el('div', 'sk-h', t("setBridgeTitle")));
   const brCard = el('div', 'prov-card bridge-card');
   const guessOS = () => {
     const ua = navigator.userAgent;
@@ -558,14 +623,14 @@ function renderSettings() {
   const primary = guessOS();
   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="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>` +
+    `<p class="muted" style="font-size:.72rem;margin:6px 0">${t('setBridgeDesc')}</p>` +
+    `<a class="prov-use" style="text-decoration:none;display:inline-block" href="bridge-dl/${primary}" download>${t('setBridgeDownload',{os:OTHER[primary]})}</a>` +
+    `<details style="margin-top:6px"><summary class="muted" style="font-size:.7rem;cursor:pointer">${t('setBridgeOtherOS')}</summary>` +
     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>` +
-    `<button id="br-connect" class="prov-use" style="margin-top:8px">Conectar</button>`;
+    `<div class="field" style="margin-top:6px"><label class="muted" style="font-size:.68rem">${t('setBridgeFolderLabel')}</label><input id="br-folder" placeholder="${t('setBridgeFolderPh')}"></div>` +
+    `<button id="br-connect" class="prov-use" style="margin-top:8px">${t('setBridgeConnect')}</button>`;
   box.appendChild(brCard);
   brCard.querySelector('#br-folder').value = bridge.getFolder();
   brCard.querySelector('#br-token').value = localStorage.getItem('elffusscode.bridgeToken') || '';
@@ -575,7 +640,7 @@ function renderSettings() {
     if (!document.body.contains(brCard)) { bridge.onStatusChange(() => {}); return; }
     const on = bridge.isConnected();
     brCard.querySelector('#br-dot').className = 'dot ' + (on ? 'on' : 'off');
-    brCard.querySelector('#br-status').textContent = on ? '✓ conectado — ejecución real activa' : 'desconectado';
+    brCard.querySelector('#br-status').textContent = on ? t("setBridgeOnStatus") : t("setBridgeDisconnected");
     if (on) brCard.querySelector('#br-token').value = localStorage.getItem('elffusscode.bridgeToken') || '';
   };
   paintBridge();
@@ -584,15 +649,15 @@ function renderSettings() {
     const btn = brCard.querySelector('#br-connect');
     bridge.setFolder(brCard.querySelector('#br-folder').value);
     const token = brCard.querySelector('#br-token').value.trim();
-    if (!token) return showBridgeMsg(brCard, '⚠️ pega el token que imprimió el programa al arrancarlo', true);
-    btn.disabled = true; btn.textContent = 'Conectando…';
-    try { await bridge.connect(token); paintBridge(); showBridgeMsg(brCard, '✔ conectado — ejecución real en tu máquina'); fireworks(); }
+    if (!token) return showBridgeMsg(brCard, t("setBridgeNoToken"), true);
+    btn.disabled = true; btn.textContent = t("setBridgeConnecting");
+    try { await bridge.connect(token); paintBridge(); showBridgeMsg(brCard, t("setBridgeConnectedMsg")); fireworks(); }
     catch (e) { showBridgeMsg(brCard, '⚠️ ' + e.message, true); }
-    finally { btn.disabled = false; btn.textContent = 'Conectar'; }
+    finally { btn.disabled = false; btn.textContent = t("setBridgeConnect"); }
   };
 
   // --- Permisos de ejecución (mismo interruptor que </> Auto de la barra) ---
-  box.append(el('div', 'sk-h', '✅ Permisos de ejecución'));
+  box.append(el('div', 'sk-h', t("setPermTitle")));
   const permCard = el('div', 'prov-card');
   permCard.innerHTML =
     `<label style="display:flex;align-items:center;gap:8px;cursor:pointer">` +
@@ -610,7 +675,7 @@ function renderSettings() {
   };
 
   // --- 🎯 Modo Objetivo (planificador + ejecutor, mismo patrón que Auto) ---
-  box.append(el('div', 'sk-h', '🎯 Modo Objetivo'));
+  box.append(el('div', 'sk-h', t("setGoalTitle")));
   const goalCard = el('div', 'prov-card');
   goalCard.innerHTML =
     `<label style="display:flex;align-items:center;gap:8px;cursor:pointer">` +
@@ -628,7 +693,7 @@ function renderSettings() {
   };
 
   // --- 📨 Errores y feedback (opt-in — apagado no sale NADA de tu máquina) ---
-  box.append(el('div', 'sk-h', '📨 Errores y feedback'));
+  box.append(el('div', 'sk-h', t("setTelTitle")));
   const telCard = el('div', 'prov-card');
   telCard.innerHTML =
     `<label style="display:flex;align-items:center;gap:8px;cursor:pointer">` +
@@ -648,24 +713,24 @@ function renderSettings() {
     const ta = telCard.querySelector('#tel-feedback');
     const msg = telCard.querySelector('#tel-msg');
     const text = ta.value.trim();
-    if (!text) { msg.textContent = 'escribe algo primero'; return; }
+    if (!text) { msg.textContent = t("setTelEmpty"); return; }
     const wasEnabled = telemetry.isEnabled();
     if (!wasEnabled) telemetry.setEnabled(true); // el envío manual es explícito, se permite aunque el automático esté apagado
     await telemetry.sendFeedback(text);
     if (!wasEnabled) telemetry.setEnabled(false); // no activa el automático de fondo si no lo pidió
     ta.value = '';
-    msg.textContent = '¡enviado, gracias!';
+    msg.textContent = t("setTelThanks");
     setTimeout(() => { msg.textContent = ''; }, 4000);
   };
 
   // --- Proveedores externos (API keys) ---
-  box.append(el('div', 'sk-h', 'Proveedores externos (opcional · la clave se queda en tu navegador)'));
+  box.append(el('div', 'sk-h', t("setProvTitle")));
   for (const [id, c] of Object.entries(settings.configs())) {
     const card = el('div', 'prov-card' + (c.enabled ? ' on' : ''));
     const head = el('div', 'prov-head');
     const toggle = document.createElement('input'); toggle.type = 'checkbox'; toggle.checked = c.enabled;
     const title = el('b', null, c.label);
-    const use = el('button', 'prov-use', 'Usar');
+    const use = el('button', 'prov-use', t("setProvUse"));
     use.hidden = !c.enabled || activeModel === 'ext:' + id;
     use.onclick = () => { changeModel('ext:' + id); renderSettings(); };
     head.append(toggle, title, use);
@@ -687,7 +752,7 @@ function renderSettings() {
   // --- Skills ---
   box.append(el('div', 'sk-h', 'Skills'));
   const skBtn = el('button', 'primary wide', '🧩 Gestionar skills de Claude Code');
-  skBtn.textContent = 'Gestionar skills de Claude Code';
+  skBtn.textContent = t("setManageSkillsBtn");
   skBtn.onclick = openSkillsPanel;
   box.appendChild(skBtn);
 }
@@ -1069,7 +1134,7 @@ async function toggleTerminal(force) {
   $('act-term').classList.toggle('on', show);
   if (show) {
     const cap = shell.capabilities();
-    $('term-caps').textContent = cap.bridge ? '🔌 Bridge local: node/npm/python reales' : 'shell del proyecto · node/npm/python → Bridge local (⚙ Ajustes)';
+    $('term-caps').textContent = cap.bridge ? t("termCapsBridge") : t("termCapsNoBridge");
     await terminal.mount($('terminal-host'));
     terminal.refit();
   }
@@ -1240,9 +1305,50 @@ $('btn-goal').addEventListener('click', () => {
 });
 paintGoal();
 
+// ── Hard Work (RLM): lee el proyecto ENTERO por partes ──
+let hardMode = false;
+$('btn-hardwork').addEventListener('click', () => {
+  hardMode = !hardMode;
+  $('btn-hardwork').classList.toggle('on', hardMode);
+  $('prompt').placeholder = hardMode ? t("hwPlaceholder") : 'Pídele código a Elffuss…';
+});
+
+// Trabaja el proyecto abierto por partes: trocea, pregunta a cada parte y funde.
+async function runHardWork(question) {
+  const active = conv.getActive();
+  if (!active) return;
+  addMsg('user', question);
+  const thinking = thinkingBubble();
+  const fail = msg => { thinking.remove(); addMsg('assistant', msg); };
+  try {
+    const provider = conv.getProvider();
+    if (!provider || provider === rules) return fail(t("hwNeedBrain"));
+    const root = codeTools.handle();
+    if (!root) return fail(t("hwNeedProject"));
+    thinking.tool(t("hwReading"));
+    const context = await gatherFolder(root, { maxBytes: 1.5e6 });
+    if (!context.trim()) return fail(t("hwNoFiles"));
+    const res = await hardWork({
+      question, context, provider,
+      onProgress: p => {
+        if (p.phase === 'plan') thinking.tool(`Hard Work · ${p.chunks} partes (${Math.round(p.chars / 1000)}k)${p.truncated ? t("hwTrimmed") : ''}`);
+        else if (p.phase === 'map') thinking.tool(`Hard Work · leyendo ${p.i}/${p.n}`);
+        else if (p.phase === 'reduce-group') thinking.tool(`Hard Work · fundiendo ${p.g}/${p.n}`);
+        else if (p.phase === 'reduce') thinking.tool(t("hwPhaseReduce"));
+      },
+    });
+    thinking.remove();
+    addMsg('assistant', res.answer + `\n\n_⛏ Hard Work (RLM): ${res.chunks} partes, ${res.kept} con señal.${res.truncated ? t("hwResultTrunc") : ''}_`);
+  } catch (e) {
+    thinking.remove();
+    addMsg('assistant err', 'Hard Work falló: ' + (e?.message || String(e)));
+  }
+}
+
 // resolver @rutas del mensaje: se leen y se adjuntan como contexto
 const _send = send;
 send = async (text) => {
+  if (hardMode) return runHardWork(text);
   const refs = [...text.matchAll(/@([\w./-]+\.\w+)/g)].map(m => m[1]);
   if (refs.length) {
     let ctx = '';
@@ -1279,7 +1385,7 @@ async function openSkillsPanel() {
     row.className = 'sk-row';
     row.innerHTML = `<b>${s.name}</b><span class="muted">${s.repo || 'local'}</span>`;
     const rm = document.createElement('button');
-    rm.className = 'ghost'; rm.textContent = 'Quitar';
+    rm.className = 'ghost'; rm.textContent = t("skRemove");
     rm.onclick = async () => { await skills.remove(s.name); openSkillsPanel(); };
     row.appendChild(rm);
     instBox.appendChild(row);
@@ -1296,7 +1402,7 @@ async function openSkillsPanel() {
     row.className = 'sk-row';
     row.innerHTML = `<b>${s.label}</b><a href="https://github.com/${s.repo}" target="_blank" rel="noopener">${s.repo} ↗</a>`;
     const browse = document.createElement('button');
-    browse.className = 'primary'; browse.textContent = 'Explorar';
+    browse.className = 'primary'; browse.textContent = t("skBrowse");
     browse.onclick = () => browseRepo(s.repo, box);
     row.appendChild(browse);
     if (!s.official) {
@@ -1310,9 +1416,9 @@ async function openSkillsPanel() {
   const addRow = document.createElement('div');
   addRow.className = 'sk-row';
   const inp = document.createElement('input');
-  inp.placeholder = 'owner/repo o URL de GitHub (p. ej. OpenClaude/…)';
+  inp.placeholder = t("skAddRepoPh");
   const add = document.createElement('button');
-  add.className = 'primary'; add.textContent = 'Añadir repo';
+  add.className = 'primary'; add.textContent = t("skAddRepo");
   add.onclick = async () => {
     try { await skills.addSource(inp.value); openSkillsPanel(); }
     catch (e) { alert(e.message); }

js/providers/litert.js

@@ -39,7 +39,12 @@ export async function load(onProgress = () => {}) {
   let adapter = null;
   try { adapter = await navigator.gpu.requestAdapter(); } catch { /* sin adaptador */ }
   if (!adapter) throw new Error('No hay un adaptador WebGPU real disponible (la API existe pero no hay GPU accesible) — prueba con Elffuss LM, que corre en CPU/wasm.');
-  const litertlm = await import('https://cdn.jsdelivr.net/npm/@litert-lm/core/+esm');
+  // VERSIÓN FIJADA a propósito. Sin fijarla, la URL apunta siempre a la última
+  // publicada: el 2026-08-11 salió 0.16.0, jsdelivr NO consigue construirle el
+  // bundle `+esm` (404) y el cerebro Gemma dejó de cargar en producción sin que
+  // nosotros tocáramos una línea. Al subir de versión hay que COMPROBAR que
+  // `https://cdn.jsdelivr.net/npm/@litert-lm/core@<v>/+esm` responde 200.
+  const litertlm = await import('https://cdn.jsdelivr.net/npm/@litert-lm/core@0.15.0/+esm');
   // El .litertlm lo descargamos NOSOTROS (cache-first en Cache Storage) y se lo
   // pasamos a Engine.create como Blob (la API acepta string|Blob|ReadableStream).
   // Motivo: el fetch interno de LiteRT baja el peso con XHR+Range desde un WORKER
@@ -78,17 +83,41 @@ export async function cachedModelBlob(url, onProgress = () => {}) {
     if (!net.ok || !net.body) return url;
     const total = +net.headers.get('content-length') || 0;
     const t0 = performance.now();
-    const [prog, toCache] = net.body.tee();
-    (async () => {
-      const r = prog.getReader(); let loaded = 0;
-      for (;;) { const { done, value } = await r.read(); if (done) break; loaded += value.length; onProgress(fmtBytes(loaded, total, t0)); }
-    })().catch(() => {});
+    // Progreso SIN tee(): con un modelo de gigabytes, tee() crea dos ramas que
+    // se consumen a ritmos distintos y el navegador tiene que bufferizar la
+    // diferencia en memoria → el cache.put acababa reventando y el modelo NO se
+    // cacheaba NUNCA (medido con E4B: 2832 MB bajados y cero guardados; el
+    // usuario se los re-bajaba en cada sesión). Con un TransformStream hay un
+    // solo consumidor: contamos al vuelo y el mismo flujo va a la caché.
+    let loaded = 0;
+    const counted = net.body.pipeThrough(new TransformStream({
+      transform(chunk, ctrl) {
+        loaded += chunk.byteLength ?? chunk.length;
+        onProgress(fmtBytes(loaded, total, t0));
+        ctrl.enqueue(chunk);
+      },
+    }));
     const headers = { 'Content-Type': 'application/octet-stream' };
     if (total) headers['Content-Length'] = String(total);
-    await cache.put(url, new Response(toCache, { headers }));
+    // Cachear GIGABYTES puede fallar de verdad: ventana privada (Cache Storage
+    // en memoria), disco lleno, cuota del origen. Si falla hay que DECIRLO: el
+    // progreso ya ha prometido «se cachea para la próxima vez» y, callándolo,
+    // el usuario se re-baja el modelo entero cada sesión sin saber por qué.
+    try {
+      await cache.put(url, new Response(counted, { headers }));
+    } catch (e) {
+      onProgress(`No se pudo guardar el modelo en caché (${e.name || 'error'}): habrá que descargarlo otra vez la próxima. ` +
+        `Suele ser ventana privada o falta de espacio.`);
+      console.warn('[elffuss] modelo NO cacheado:', e);
+      return url;
+    }
     const cached = await cache.match(url);
-    return cached ? await cached.blob() : url;
-  } catch { return url; }
+    if (!cached) { onProgress('No se pudo guardar el modelo en caché: habrá que descargarlo otra vez la próxima.'); return url; }
+    return await cached.blob();
+  } catch (e) {
+    console.warn('[elffuss] caché de modelo no disponible:', e);
+    return url;
+  }
 }
 function fmtBytes(loaded, total, t0) {
   const mb = n => (n / 1048576).toFixed(0);

js/rlm.js

@@ -0,0 +1,404 @@
+// RLM — Recursive Language Models (el modo «Hard Work» de Elffuss).
+//
+// Idea (Zhang et al., MIT, 2025): un modelo PEQUEÑO y local puede manejar
+// entradas ENORMES si no las mete todas de golpe en su ventana, sino que
+// TROCEA el material, pregunta a cada trozo (map = una sub-llamada al mismo
+// modelo) y FUNDE las respuestas (reduce). Si lo fundido aún no cabe, se
+// recurre. El modelo raíz nunca ve todo el contexto a la vez: trabaja por
+// partes, como un humano leyendo un tocho capítulo a capítulo.
+//
+// Trade-off honesto: cambia LATENCIA por CAPACIDAD. Son muchas inferencias del
+// modelo local (que es lento), así que es para tareas que PUEDEN esperar —
+// auditar, resumir o revisar una carpeta/repo entero— no para tiempo real.
+//
+// El motor es agnóstico del proveedor: solo necesita algo con
+// `chat(history, system, onToken)` (lo cumplen rules/onnx/litert/api).
+
+const CHARS_PER_TOK = 4; // misma estimación que context.js
+const DEFAULTS = {
+  chunkTokens: 1800,     // tamaño de cada trozo (deja hueco al prompt del modelo)
+  overlapTokens: 120,    // solape para no cortar una idea a la mitad entre trozos
+  maxDepth: 3,           // recursión máxima del reduce jerárquico
+  maxChunks: 80,         // techo DURO de sub-llamadas del map (coste/tiempo)
+  callTimeoutMs: 120000, // guarda por sub-llamada (un motor colgado no bloquea todo)
+};
+
+const clip = (s, n) => (s.length > n ? s.slice(0, n) + '…' : s);
+
+// Trocea respetando límites de línea cuando es posible (no parte a mitad de
+// palabra si hay un salto cerca del corte).
+function chunk(text, chunkChars, overlapChars) {
+  const step = Math.max(1, chunkChars - overlapChars);
+  const out = [];
+  for (let i = 0; i < text.length; i += step) {
+    let end = Math.min(i + chunkChars, text.length);
+    if (end < text.length) {
+      const nl = text.lastIndexOf('\n', end);
+      if (nl > i + chunkChars * 0.6) end = nl; // corta en salto si cae en el último 40%
+    }
+    out.push(text.slice(i, end));
+    if (end >= text.length) break;
+  }
+  return out;
+}
+
+// sub(): UNA inferencia del modelo local sobre un fragmento. Es la recursión.
+async function sub(provider, system, prompt, timeoutMs) {
+  const run = provider.chat([{ role: 'user', content: prompt }], system, () => {});
+  if (!timeoutMs) return run;
+  let to;
+  const guard = new Promise((_, rej) => { to = setTimeout(() => rej(new Error('sub-llamada agotó el tiempo')), timeoutMs); });
+  try { return await Promise.race([run, guard]); }
+  finally { clearTimeout(to); }
+}
+
+const MAP_SYS = 'Eres un analista minucioso. Te doy UN fragmento de un material más grande y una pregunta. Responde SOLO con lo que ESTE fragmento aporte a la pregunta: datos concretos, en pocas frases, con cita textual breve si procede. No inventes lo que no esté en el fragmento. Si el fragmento no aporta nada a la pregunta, responde exactamente: NADA';
+const REDUCE_SYS = 'Eres un sintetizador. Te doy una pregunta y varios hallazgos extraídos de fragmentos distintos del MISMO material. Fúndelos en una única respuesta, coherente y completa, a la pregunta. Resuelve solapes, no repitas, no inventes lo que no esté en los hallazgos. Responde en el idioma de la pregunta.';
+
+// Motor RLM. Devuelve { answer, chunks, kept }.
+export async function hardWork({ question, context, provider, onProgress = () => {}, opts = {} }) {
+  const o = { ...DEFAULTS, ...opts };
+  if (!provider || typeof provider.chat !== 'function') throw new Error('Hard Work necesita un cerebro cargado (elige un modelo local o remoto arriba).');
+  const q = String(question || '').trim();
+  const ctx = String(context || '').trim();
+  if (!q) throw new Error('Hard Work: dime qué quieres saber del material.');
+  if (!ctx) throw new Error('Hard Work: no encontré material que procesar.');
+
+  const chunkChars = o.chunkTokens * CHARS_PER_TOK;
+  let parts = chunk(ctx, chunkChars, o.overlapTokens * CHARS_PER_TOK);
+  const truncated = parts.length > o.maxChunks;
+  if (truncated) parts = parts.slice(0, o.maxChunks);
+  onProgress({ phase: 'plan', chunks: parts.length, chars: ctx.length, truncated });
+
+  // MAP — un modelo local es UN motor, así que las sub-llamadas van en serie.
+  const findings = [];
+  for (let i = 0; i < parts.length; i++) {
+    onProgress({ phase: 'map', i: i + 1, n: parts.length });
+    let ans;
+    try { ans = await sub(provider, MAP_SYS, `PREGUNTA:\n${q}\n\nFRAGMENTO ${i + 1}/${parts.length}:\n${parts[i]}`, o.callTimeoutMs); }
+    catch { ans = 'NADA'; }
+    ans = String(ans || '').trim();
+    if (ans && !/^NADA\b/i.test(ans)) findings.push(`[${i + 1}] ${ans}`);
+  }
+  onProgress({ phase: 'mapped', kept: findings.length, of: parts.length });
+  if (!findings.length) return { answer: 'Revisé el material por partes y no encontré nada relevante para eso.', chunks: parts.length, kept: 0, truncated };
+
+  const answer = await reduce(provider, q, findings, o, onProgress, 0);
+  return { answer: String(answer || '').trim(), chunks: parts.length, kept: findings.length, truncated };
+}
+
+// REDUCE jerárquico: si los hallazgos caben, funde en uno; si no, agrupa,
+// funde cada grupo y recurre con las respuestas parciales.
+async function reduce(provider, q, findings, o, onProgress, depth) {
+  const budget = o.chunkTokens * CHARS_PER_TOK * 2; // el reduce puede ver algo más que un trozo
+  const joined = findings.join('\n');
+  if (joined.length <= budget || depth >= o.maxDepth) {
+    onProgress({ phase: 'reduce', depth, final: true });
+    return sub(provider, REDUCE_SYS, `PREGUNTA:\n${q}\n\nHALLAZGOS:\n${clip(joined, budget)}`, o.callTimeoutMs);
+  }
+  const groups = [];
+  let cur = [];
+  let len = 0;
+  for (const f of findings) {
+    if (len + f.length + 1 > budget && cur.length) { groups.push(cur); cur = []; len = 0; }
+    cur.push(f); len += f.length + 1;
+  }
+  if (cur.length) groups.push(cur);
+  onProgress({ phase: 'reduce', depth, groups: groups.length, final: false });
+  const partials = [];
+  for (let g = 0; g < groups.length; g++) {
+    onProgress({ phase: 'reduce-group', depth, g: g + 1, n: groups.length });
+    const p = await sub(provider, REDUCE_SYS, `PREGUNTA:\n${q}\n\nHALLAZGOS (grupo ${g + 1}/${groups.length}):\n${groups[g].join('\n')}`, o.callTimeoutMs);
+    partials.push(`[g${g + 1}] ${String(p || '').trim()}`);
+  }
+  return reduce(provider, q, partials, o, onProgress, depth + 1);
+}
+
+// ── Hard Work · CREACIÓN: borrador → autocrítica → reescritura ──────────────
+// El hermano creativo de RLM. RLM gasta cómputo LEYENDO material enorme; esto
+// lo gasta MEJORANDO lo que el modelo crea: en vez de una sola pasada, el
+// modelo pequeño hace un borrador, se autocritica sin piedad y se reescribe
+// corrigiendo sus propios fallos. Sube la calidad de un modelo modesto sin
+// cambiar de modelo — solo pensando más veces.
+const CREATE_SYS = 'Eres Elffuss creando una app web. Respondes SOLO con un documento HTML completo y autocontenido (CSS y JS inline, fondo oscuro). Si es un juego o algo visual, usa <canvas> y que se vea vivo (color, movimiento, efectos). Nada de texto fuera del HTML.';
+const CRITIQUE_SYS = 'Eres un crítico de videojuegos y front-end, implacable pero útil. Te doy el código de una app/juego web. Enumera 3 a 6 defectos CONCRETOS y accionables: bugs de lógica, controles que faltan, colisiones mal hechas, falta de condición de fin o de puntuación, jugabilidad sosa y pobreza visual (sin color, sin efectos, estático). Sé específico y breve. NO reescribas el código: solo la lista de defectos.';
+const REWRITE_SYS = 'Eres Elffuss mejorando tu propia app. Te doy el HTML actual y una crítica. Devuelve SOLO el HTML completo y autocontenido MEJORADO que corrige TODOS los puntos de la crítica, conservando lo que ya funcionaba y subiendo el nivel visual (color, brillo, partículas si encaja). Sin explicaciones fuera del HTML.';
+
+// Saca el documento HTML de la respuesta del modelo (fence ```html o directo).
+export function extractHtml(text) {
+  const s = String(text || '');
+  const fence = s.match(/```html\s*([\s\S]*?)```/i) || s.match(/```\s*([\s\S]*?)```/);
+  const body = fence ? fence[1] : s;
+  const m = body.match(/<!doctype[\s\S]*<\/html>/i) || body.match(/<html[\s\S]*<\/html>/i);
+  return (m ? m[0] : body).trim();
+}
+
+const CONT_SYS = 'Continúas un documento HTML/JS que se cortó a media escritura. Devuelve SOLO la continuación EXACTA desde donde termina —sin repetir nada de lo ya escrito, sin reabrir <html> ni <script>, sin explicaciones— hasta cerrar todas las etiquetas y </html>.';
+
+// Genera y, si el modelo se quedó sin tokens a media escritura (el HTML no
+// cierra </html>), pide la continuación desde la cola y la cose. Así el techo
+// de 1024 tokens deja de truncar apps grandes: se completan por tramos.
+async function genComplete(provider, system, prompt, { maxCont = 4 } = {}) {
+  let full = String(await provider.chat([{ role: 'user', content: prompt }], system, () => {}) || '');
+  for (let i = 0; i < maxCont && !/<\/html>/i.test(full); i++) {
+    const tail = full.slice(-1400);
+    let cont = String(await provider.chat(
+      [{ role: 'user', content: `FINAL de lo escrito hasta ahora (continúa desde aquí, sin repetirlo):\n${tail}` }],
+      CONT_SYS, () => {}) || '');
+    // Defensa: si el modelo reabre el documento en vez de continuar, recórtalo.
+    cont = cont.replace(/^[\s\S]*?<!doctype html>/i, '').replace(/^[\s\S]*?<html[^>]*>/i, '');
+    if (!cont.trim()) break;
+    full += cont;
+  }
+  return full;
+}
+
+
+// ── Jurado deliberante (Reasoning Jury, arXiv 2608.12585) ───────────────────
+// Un juez único detecta mal los defectos: se inventa unos y se le escapan
+// otros (lo vimos con el crítico único de Hard Work). El paper sustituye al
+// juez por un JURADO que delibera: cada jurado propone defectos, luego ve los
+// de los demás y VOTA cuáles son reales, y un moderador se queda con los que
+// tienen apoyo. Aquí el jurado es un mismo modelo con lentes distintas —no
+// modelos distintos, que no caben en el navegador—, así que el efecto es
+// menor que en el paper; por eso se mide, no se asume.
+const JURY_LENSES = [
+  { key: 'logica', name: 'lógica', ask: 'errores de lógica y de estado: variables sin definir, condiciones al revés, bucles que no avanzan, una condición de fin que nunca se cumple, cuentas mal hechas' },
+  { key: 'interaccion', name: 'interacción', ask: 'controles y respuesta: entradas que no hacen nada, colisiones que no detectan, falta de arranque o de reinicio, nada que indique al usuario qué pasa' },
+  { key: 'visual', name: 'presentación', ask: 'lo que se ve: elementos con tamaño cero o fuera de pantalla, todo del mismo color, nada dibujado, texto ilegible' },
+];
+
+const asLines = t => String(t || '').split('\n')
+  .map(l => l.replace(/^\s*(?:[-*\u2022]|\d+[.)])\s*/, '').trim())
+  .filter(l => l.length > 12 && l.length < 220);
+
+const normDefect = d => d.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+  .replace(/[^a-z0-9 ]/g, ' ').split(/\s+/).filter(w => w.length > 3).slice(0, 6).join(' ');
+
+// Devuelve { defects:[{text,votes,jurors}], rounds } sobre un artefacto.
+// Normaliza espacios para comparar una cita con el código real.
+const flat = t => String(t).replace(/\s+/g, ' ').trim();
+
+// Elige las lentes que TIENEN algo que mirar en este artefacto. Pasarle
+// «presentación» a una función pura de cálculo no aporta nada: ese jurado o
+// calla o repite lo que dijo el de lógica, y los repetidos se comían las
+// plazas de candidatos.
+function lensesFor(material) {
+  const tieneUI = /<canvas|<button|<input|<form|document\.|addEventListener|innerHTML|querySelector/i.test(material);
+  const tienePintado = /<canvas|getContext|fillRect|drawImage|style\.|css/i.test(material);
+  const out = [JURY_LENSES[0]];                                  // lógica: siempre
+  if (tieneUI) out.push(JURY_LENSES[1]);                         // interacción
+  if (tienePintado) out.push(JURY_LENSES[2]);                    // presentación
+  if (out.length === 1) out.push(JURY_LENSES_EXTRA[0], JURY_LENSES_EXTRA[1]);  // código puro
+  else if (out.length === 2) out.push(JURY_LENSES_EXTRA[0]);
+  return out;
+}
+
+// Lentes para código sin interfaz, donde «interacción» y «presentación» no pintan nada.
+const JURY_LENSES_EXTRA = [
+  { key: 'datos', name: 'datos y tipos', ask: 'tipos y datos: conversiones implícitas, valores que llegan como texto cuando se esperan números, undefined/NaN, claves que cambian de tipo' },
+  { key: 'bordes', name: 'casos límite', ask: 'casos límite y validación: entradas vacías, negativas o fuera de rango, ausencia de comprobaciones, resultados absurdos que nadie detiene' },
+];
+
+export async function juryReview({ artifact, provider, onProgress = () => {}, lenses = null, requireEvidence = true }) {
+  const dropped = [];
+  if (!provider?.chat) throw new Error('el jurado necesita un cerebro cargado');
+  const material = String(artifact || '').slice(0, 6000);
+  lenses = lenses || lensesFor(material);
+  onProgress({ phase: 'jury-lenses', lenses: lenses.map(l => l.name) });
+
+  // Ronda 1 — cada jurado propone defectos desde SU lente, sin ver a los demás.
+  const proposals = [];
+  for (const L of lenses) {
+    onProgress({ phase: 'jury-propose', lens: L.name });
+    const sys = `Eres un revisor especializado en ${L.ask}. Te doy el código de una app web. Enumera SOLO los defectos REALES que veas desde tu especialidad. Por cada uno escribe DOS líneas seguidas:
+DEFECTO: <qué está mal, en una línea>
+PRUEBA: <copia LITERAL del fragmento de código que lo demuestra, tal cual aparece>
+Máximo 4 defectos. Si no ves ninguno, escribe NINGUNO. La PRUEBA debe estar copiada del código palabra por palabra; si no puedes copiarla, no incluyas ese defecto.`;
+    const out = await provider.chat([{ role: 'user', content: 'CÓDIGO:\n' + material }], sys, () => {});
+    // Emparejar DEFECTO con su PRUEBA y COMPROBAR que la cita existe de verdad
+    // en el código. Es un filtro determinista: si el modelo no sabe citar, se
+    // lo ha inventado. (El modelo verifica mucho mejor de lo que propone, pero
+    // esto ni siquiera necesita al modelo.)
+    const raw = String(out).split('\n').map(x => x.trim());
+    const found = [];
+    for (let i = 0; i < raw.length; i++) {
+      const dm = raw[i].match(/^DEFECTO:\s*(.+)/i);
+      if (!dm) continue;
+      const pm = (raw[i + 1] || '').match(/^PRUEBA:\s*(.+)/i);
+      const texto = dm[1].trim();
+      if (texto.length < 12) continue;
+      if (!requireEvidence) { found.push({ texto, cita: pm ? pm[1].trim() : '' }); continue; }
+      const cita = pm ? pm[1].trim().replace(/^[`'"]|[`'"]$/g, '') : '';
+      if (cita.length >= 8 && flat(material).includes(flat(cita))) found.push({ texto, cita });
+      else dropped.push({ lens: L.name, texto, cita: cita.slice(0, 60) });
+    }
+    proposals.push({ lens: L, found });
+  }
+
+  // Candidatos únicos (los jurados repiten el mismo defecto con otras palabras).
+  // Deduplicar por la CITA de código, no por las palabras: dos jurados describen
+  // el mismo fallo con frases distintas («el bucle empieza en 1» y «ignora el
+  // primer elemento») y el deduplicador léxico los dejaba pasar como dos, con lo
+  // que la lista de candidatos se llenaba de repetidos. Si señalan el mismo
+  // fragmento de código, es el mismo defecto.
+  const seen = new Map();
+  for (const p of proposals) for (const d of p.found) {
+    const k = d.cita && d.cita.length >= 8 ? 'c:' + flat(d.cita).slice(0, 80) : 't:' + normDefect(d.texto);
+    if (k && !seen.has(k)) seen.set(k, d.texto);
+  }
+  const candidates = [...seen.values()].slice(0, 12);
+  onProgress({ phase: 'jury-candidates', n: candidates.length });
+  if (!candidates.length) return { defects: [], candidates: 0, dropped };
+
+  // Ronda 2 — DELIBERACIÓN: cada jurado ve TODOS los candidatos (incluidos los
+  // ajenos) y vota cuáles son de verdad. Aquí es donde puede retirar el suyo.
+  const votes = candidates.map(() => 0);
+  for (const L of lenses) {
+    onProgress({ phase: 'jury-vote', lens: L.name });
+    const list = candidates.map((c, i) => `${i + 1}. ${c}`).join('\n');
+    // OJO con el formato: poner "N: SI" como plantilla hacía que el modelo
+    // escribiera literalmente la letra N y no se parseara NINGÚN voto (el
+    // jurado parecía rechazarlo todo). Los modelos pequeños copian el ejemplo
+    // tal cual: hay que darles números de verdad.
+    const sys = `Eres un revisor riguroso (especialidad: ${L.name}). Te doy el código y una lista numerada de defectos propuestos por otros revisores. Para CADA número, mira el código y di si el defecto es REAL. Responde SOLO con una línea por defecto, con su número y SI o NO. Así:
+1: SI
+2: NO
+3: SI
+Nada más: ni explicaciones ni texto extra. Ante la duda, NO.`;
+    const out = await provider.chat(
+      [{ role: 'user', content: 'CÓDIGO:\n' + material + '\n\nDEFECTOS PROPUESTOS:\n' + list }], sys, () => {});
+    const txt = String(out);
+    let parsed = 0;
+    for (const m of txt.matchAll(/(\d+)\s*[:.)\-]\s*(S[IÍ]|YES|NO)\b/gi)) {
+      const i = +m[1] - 1;
+      parsed++;
+      if (i >= 0 && i < votes.length && /^(s[ií]|yes)$/i.test(m[2])) votes[i]++;
+    }
+    // Respaldo: si el modelo ignoró el formato numerado, leer los SI/NO en orden.
+    if (!parsed) {
+      const seq = [...txt.matchAll(/\b(S[IÍ]|YES|NO)\b/gi)].map(m => m[1]);
+      seq.slice(0, votes.length).forEach((v, i) => { if (/^(s[ií]|yes)$/i.test(v)) votes[i]++; });
+    }
+    onProgress({ phase: 'jury-parsed', lens: L.name, parsed });
+  }
+
+  // Moderador — se queda con los que tienen apoyo de la mayoría del jurado.
+  const need = Math.ceil(lenses.length / 2);
+  const defects = candidates.map((text, i) => ({ text, votes: votes[i] }))
+    .filter(d => d.votes >= need)
+    .sort((a, b) => b.votes - a.votes);
+  onProgress({ phase: 'jury-verdict', kept: defects.length, of: candidates.length });
+  onProgress({ phase: 'jury-evidence', dropped: dropped.length });
+  return { defects, candidates: candidates.length, jurors: lenses.length, dropped };
+}
+
+
+// ── Edición QUIRÚRGICA en vez de reescritura completa ───────────────────────
+// Reescribir el documento entero para corregir tres cosas hace que el modelo
+// regenere de cero lo que ya funcionaba, y por el camino rompe la mecánica.
+// Aquí solo se le piden los CAMBIOS, y los aplica este código: si el fragmento
+// a buscar no está tal cual en el documento, ese cambio se descarta. El modelo
+// propone, el código decide — igual que con las citas del jurado.
+const PATCH_SYS = `Eres Elffuss arreglando tu propia app. Te doy el HTML actual y una lista de defectos. NO reescribas el documento. Devuelve SOLO los cambios mínimos, en bloques de exactamente tres líneas:
+BUSCAR: <fragmento LITERAL del código actual, copiado tal cual, en una línea>
+CAMBIAR: <con qué se sustituye, en una línea>
+MOTIVO: <qué defecto arregla>
+Repite el bloque por cada cambio. Máximo 6. El texto de BUSCAR debe existir palabra por palabra en el HTML y ser único; si no puedes copiarlo exacto, omite ese cambio. No toques nada que ya funcione.`;
+
+export function applyPatches(html, respuesta) {
+  const lineas = String(respuesta || '').split('\n').map(x => x.trim());
+  let out = html;
+  const aplicados = [], fallidos = [];
+  for (let i = 0; i < lineas.length; i++) {
+    const b = lineas[i].match(/^BUSCAR:\s*(.+)/i);
+    if (!b) continue;
+    const c = (lineas[i + 1] || '').match(/^CAMBIAR:\s*(.+)/i);
+    if (!c) continue;
+    const buscar = b[1].trim(), cambiar = c[1].trim();
+    if (buscar.length < 6) continue;
+    const veces = out.split(buscar).length - 1;
+    if (veces === 1) { out = out.replace(buscar, cambiar); aplicados.push(buscar.slice(0, 60)); }
+    else fallidos.push({ buscar: buscar.slice(0, 60), veces });   // 0 = inventado, >1 = ambiguo
+  }
+  return { html: out, aplicados, fallidos };
+}
+
+export async function deepCreate({ brief, provider, rounds = 1, onProgress = () => {}, useJury = false, editMode = 'rewrite' }) {
+  if (!provider || typeof provider.chat !== 'function') throw new Error('Hard Work necesita un cerebro cargado (elige un modelo arriba).');
+  if (!String(brief || '').trim()) throw new Error('Hard Work: dime qué quieres que cree.');
+  onProgress({ phase: 'draft' });
+  let html = extractHtml(await genComplete(provider, CREATE_SYS, String(brief)));
+  const trace = [{ round: 0, html }];
+  for (let r = 1; r <= rounds; r++) {
+    onProgress({ phase: 'critique', round: r });
+    let critique;
+    if (useJury) {
+      const v = await juryReview({ artifact: html, provider, onProgress });
+      critique = v.defects.length
+        ? v.defects.map(d => `- ${d.text} (${d.votes} de ${v.jurors} revisores)`).join('\n')
+        : 'Sin defectos con apoyo suficiente del jurado.';
+    } else {
+      critique = String(await provider.chat([{ role: 'user', content: `APP/JUEGO:\n${html}` }], CRITIQUE_SYS, () => {})).trim();
+    }
+    onProgress({ phase: 'rewrite', round: r, modo: editMode });
+    if (editMode === 'patch') {
+      const resp = await provider.chat(
+        [{ role: 'user', content: `HTML ACTUAL:\n${html}\n\nDEFECTOS A CORREGIR:\n${critique}` }], PATCH_SYS, () => {});
+      const { html: nuevo, aplicados, fallidos } = applyPatches(html, resp);
+      onProgress({ phase: 'patched', round: r, aplicados: aplicados.length, fallidos: fallidos.length });
+      if (aplicados.length) { html = nuevo; trace.push({ round: r, critique, html, aplicados, fallidos }); }
+      else trace.push({ round: r, critique, html, aplicados: [], fallidos });
+    } else {
+      const improved = extractHtml(await genComplete(provider, REWRITE_SYS, `HTML ACTUAL:\n${html}\n\nCRÍTICA A CORREGIR:\n${critique}`));
+      if (improved && /<\w+[\s>]/.test(improved)) { html = improved; trace.push({ round: r, critique, html }); }
+    }
+  }
+  onProgress({ phase: 'done', rounds: trace.length - 1 });
+  return { html, trace };
+}
+
+// ── Recolección de material desde una carpeta autorizada (File System Access) ──
+// Camina el árbol, concatena ficheros de texto con cabecera de ruta, y corta a
+// maxBytes para no reventar la memoria. Mismo código sirve a Claw (carpeta
+// autorizada) y a Code (proyecto abierto): ambos entregan un directory handle.
+const TEXT_EXT = new Set(('txt md markdown js mjs cjs ts tsx jsx json html htm css scss sass ' +
+  'py rb php go rs java kt swift c h cpp hpp cc cs sh bash zsh yml yaml toml ini cfg conf ' +
+  'xml csv tsv sql vue svelte astro lua r pl pm ex exs erl clj tex org rst gradle properties env').split(' '));
+const SKIP_DIR = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'out', 'target', 'vendor', '.cache', 'coverage', '__pycache__', '.venv', 'venv']);
+
+export async function gatherFolder(rootHandle, { maxBytes = 1.5e6, maxFiles = 400 } = {}) {
+  if (!rootHandle || typeof rootHandle.entries !== 'function') throw new Error('no hay carpeta que leer');
+  const out = [];
+  let bytes = 0;
+  let files = 0;
+  async function walk(dir, prefix) {
+    if (bytes >= maxBytes || files >= maxFiles) return;
+    const entries = [];
+    for await (const e of dir.entries()) entries.push(e);
+    entries.sort((a, b) => a[0].localeCompare(b[0]));
+    for (const [name, handle] of entries) {
+      if (bytes >= maxBytes || files >= maxFiles) return;
+      if (name.startsWith('.') && name !== '.env') { if (handle.kind === 'directory') continue; }
+      const path = prefix ? prefix + '/' + name : name;
+      if (handle.kind === 'directory') {
+        if (SKIP_DIR.has(name)) continue;
+        await walk(handle, path);
+      } else {
+        const ext = name.includes('.') ? name.split('.').pop().toLowerCase() : '';
+        if (!TEXT_EXT.has(ext)) continue;
+        try {
+          const file = await handle.getFile();
+          if (file.size > 400000) continue; // un fichero enorme suelto no monopoliza
+          const text = await file.text();
+          const block = `\n\n===== ${path} =====\n${text}`;
+          out.push(block);
+          bytes += block.length;
+          files++;
+        } catch { /* ilegible: se salta */ }
+      }
+    }
+  }
+  await walk(rootHandle, '');
+  return out.join('').slice(0, maxBytes);
+}

js/skills.js

@@ -19,16 +19,36 @@ export const DEFAULT_SOURCES = [
 
 let cache = []; // instaladas, en memoria (para que el systemPrompt sea síncrono)
 
+// `loaded` distingue «no hay skills» de «no se pudo leer»: si la lectura
+// falla, cache queda vacío pero loaded=false, y install() se niega a persistir
+// (antes, un fallo transitorio de IndexedDB borraba TODAS las skills al
+// guardar la siguiente).
+let loaded = false;
 export async function initSkills() {
-  cache = (await db.get('kv', KEY).catch(() => null)) || [];
+  try {
+    const stored = await db.get('kv', KEY);
+    cache = Array.isArray(stored) ? stored : [];
+    loaded = true;
+  } catch (e) {
+    cache = [];
+    loaded = false;
+    console.warn('[elffuss] no se pudieron leer las skills; no las sobrescribiré', e);
+  }
   return cache;
 }
+export function skillsLoaded() { return loaded; }
 
 export async function all() { return cache; }
 export function installed() { return cache; }
 export function isInstalled(repo, path) { return cache.some(s => s.repo === repo && s.path === path); }
 
 export async function install(skill) {
+  // Si la carga inicial falló, cache no representa lo instalado: reintentar
+  // leer antes de escribir. Sin esto, guardar aquí borraría las skills reales.
+  if (!loaded) {
+    await initSkills();
+    if (!loaded) throw new Error('No pude leer tus skills guardadas; no instalo para no perderlas. Recarga la página e inténtalo otra vez.');
+  }
   cache = cache.filter(s => !(s.repo === skill.repo && s.path === skill.path) && s.name !== skill.name);
   const entry = { ...skill, content: (skill.content || '').slice(0, MAX_SKILL) };
   cache.push(entry);

js/splash-gl.js

@@ -35,9 +35,9 @@ void main(){
   float tw = 0.55 + 0.45 * sin(t * (1.5 + seed.x * 3.0) + seed.y * 40.0);
   vGlow = tw * (1.0 - burst * 0.55);
   float gold = step(0.93, hash(seed.x * 31.3 + seed.y * 7.7));
-  vec3 pink = vec3(1.0, 0.30, 0.55);
-  vec3 violet = vec3(0.49, 0.36, 1.0);
-  vec3 goldc = vec3(1.0, 0.84, 0.42);
+  vec3 pink = vec3(0.33, 0.86, 0.77);
+  vec3 violet = vec3(0.51, 0.45, 1.0);
+  vec3 goldc = vec3(0.82, 0.63, 0.42);
   vColor = mix(mix(pink, violet, smoothstep(0.1, 1.3, r)), goldc, gold);
   gl_PointSize = (1.3 + 2.8 * tw * max(1.2 - r * 0.5, 0.2)) * dpr;
 }`;

js/swe-tasks.js

@@ -0,0 +1,74 @@
+// Batería de tareas estilo SWE-bench, autocontenidas y REPRODUCIBLES en el
+// navegador: cada una siembra un repo con un BUG + una especificación (lo que el
+// test espera), y un `test(mod)` que se EJECUTA de verdad contra el módulo
+// arreglado (métrica `resolved`, como SWE-bench). `solution` es el contenido
+// correcto del fichero objetivo (lo usa el solver determinista del arnés; el
+// modelo real no lo ve, tiene que deducirlo leyendo `target` y la spec).
+export const TASKS = [
+  {
+    id: 'add-sub',
+    target: 'src/math.js',
+    files: {
+      'src/math.js': 'export function add(a, b) {\n  return a - b; // BUG\n}\n',
+      'spec/math.md': '# add(a, b)\nDebe SUMAR: add(2,3) → 5, add(10,-4) → 6.',
+    },
+    task: 'add() en src/math.js resta en vez de sumar; arréglalo para que sume.',
+    solution: 'export function add(a, b) {\n  return a + b;\n}\n',
+    test: m => m.add(2, 3) === 5 && m.add(10, -4) === 6 && m.add(0, 0) === 0,
+  },
+  {
+    id: 'max-empty',
+    target: 'src/max.js',
+    files: {
+      'src/max.js': 'export function max(arr) {\n  return arr.reduce((a, b) => a > b ? a : b); // BUG: peta con []\n}\n',
+      'spec/max.md': '# max(arr)\nmax([3,1,2]) → 3. Con array vacío NO debe petar: max([]) → undefined.',
+    },
+    task: 'max() peta con un array vacío; haz que devuelva undefined en ese caso.',
+    solution: 'export function max(arr) {\n  if (!arr.length) return undefined;\n  return arr.reduce((a, b) => a > b ? a : b);\n}\n',
+    test: m => m.max([3, 1, 2]) === 3 && m.max([]) === undefined && m.max([-1, -5]) === -1,
+  },
+  {
+    id: 'unique',
+    target: 'src/unique.js',
+    files: {
+      'src/unique.js': 'export function unique(arr) {\n  return arr; // BUG: no deduplica\n}\n',
+      'spec/unique.md': '# unique(arr)\nDevuelve el array SIN duplicados: unique([1,1,2,3,3]) → [1,2,3].',
+    },
+    task: 'unique() no elimina duplicados; arréglalo.',
+    solution: 'export function unique(arr) {\n  return [...new Set(arr)];\n}\n',
+    test: m => { const r = m.unique([1, 1, 2, 3, 3]); return r.length === 3 && r.join(',') === '1,2,3'; },
+  },
+  {
+    id: 'slugify',
+    target: 'src/slug.js',
+    files: {
+      'src/slug.js': 'export function slugify(s) {\n  return s.replace(/ /g, "-"); // BUG: no pasa a minúsculas\n}\n',
+      'spec/slug.md': '# slugify(s)\nMinúsculas y guiones: slugify("Hola Mundo") → "hola-mundo".',
+    },
+    task: 'slugify() no pasa a minúsculas; debe devolver minúsculas con guiones.',
+    solution: 'export function slugify(s) {\n  return s.toLowerCase().replace(/ /g, "-");\n}\n',
+    test: m => m.slugify('Hola Mundo') === 'hola-mundo' && m.slugify('A B C') === 'a-b-c',
+  },
+  {
+    id: 'clamp',
+    target: 'src/clamp.js',
+    files: {
+      'src/clamp.js': 'export function clamp(v, lo, hi) {\n  return v; // BUG: no acota\n}\n',
+      'spec/clamp.md': '# clamp(v, lo, hi)\nAcota v al rango [lo,hi]: clamp(15,0,10) → 10, clamp(-5,0,10) → 0.',
+    },
+    task: 'clamp() no acota el valor al rango [lo,hi]; arréglalo.',
+    solution: 'export function clamp(v, lo, hi) {\n  return Math.min(hi, Math.max(lo, v));\n}\n',
+    test: m => m.clamp(15, 0, 10) === 10 && m.clamp(-5, 0, 10) === 0 && m.clamp(5, 0, 10) === 5,
+  },
+  {
+    id: 'fizzbuzz',
+    target: 'src/fizzbuzz.js',
+    files: {
+      'src/fizzbuzz.js': 'export function fizzbuzz(n) {\n  if (n % 3 === 0) return "Fizz";\n  if (n % 5 === 0) return "Buzz";\n  if (n % 15 === 0) return "FizzBuzz"; // BUG: inalcanzable\n  return String(n);\n}\n',
+      'spec/fizzbuzz.md': '# fizzbuzz(n)\nMúltiplo de 15 → "FizzBuzz", de 3 → "Fizz", de 5 → "Buzz", si no el número.',
+    },
+    task: 'fizzbuzz(15) debería dar "FizzBuzz" pero da "Fizz"; el caso de 15 es inalcanzable, arréglalo.',
+    solution: 'export function fizzbuzz(n) {\n  if (n % 15 === 0) return "FizzBuzz";\n  if (n % 3 === 0) return "Fizz";\n  if (n % 5 === 0) return "Buzz";\n  return String(n);\n}\n',
+    test: m => m.fizzbuzz(15) === 'FizzBuzz' && m.fizzbuzz(9) === 'Fizz' && m.fizzbuzz(10) === 'Buzz' && m.fizzbuzz(7) === '7',
+  },
+];

js/tools/code.js

@@ -186,6 +186,10 @@ export async function read({ path, offset, limit, around } = {}) {
     ? Math.max(1, Math.round(around) - Math.floor(size / 2))
     : Math.max(1, Math.round(offset) || 1);
   const startIdx = start - 1;
+  // Pedir más allá del final devolvía un rango imposible («líneas 999-998 de 6»)
+  // y CERO contenido: el modelo se quedaba sin nada que hacer. Mejor decírselo.
+  if (startIdx >= total)
+    return `${path}: solo tiene ${total} líneas y pediste desde la ${start} — usa offset entre 1 y ${total}.`;
   const slice = lines.slice(startIdx, startIdx + size);
   const endLine = startIdx + slice.length;
   const numbered = slice.map((l, i) => `${start + i}→${l}`).join('\n');
@@ -249,30 +253,84 @@ export async function edit({ path, search, replace } = {}) {
   // los espacios; localizamos el bloque normalizando espacios y, si hace falta,
   // por parecido de líneas — y sustituimos ESE bloque, esté donde esté (también
   // en lo hondo de un fichero grande).
-  const norm = s => s.replace(/[ \t]+/g, ' ').trim();
-  const curLines = current.split('\n');
-  const seaLines = search.replace(/\n+$/, '').split('\n');
-  const nSea = seaLines.map(norm);
-  const k = seaLines.length;
+  const norm = s => s.replace(/[ \t]+/g, ' ').trim();   // .trim() se lleva también el \r final
+  // Partimos guardando el offset de carácter de cada línea: así el bloque se
+  // sustituye por CORTE EXACTO y todo lo de fuera queda byte a byte igual
+  // (incluidos sus finales de línea). Con split/join se reescribía el fichero
+  // entero y un fichero CRLF acababa con finales de línea MEZCLADOS.
+  const curLines = [], lineStart = [];
+  for (let i = 0; i <= current.length;) {
+    const nl = current.indexOf('\n', i);
+    lineStart.push(i);
+    if (nl === -1) { curLines.push(current.slice(i)); break; }
+    curLines.push(current.slice(i, nl));                // puede acabar en \r
+    i = nl + 1;
+  }
+  const crlf = (current.match(/\r\n/g) || []).length;
+  const eol = crlf && crlf * 2 >= (current.match(/\n/g) || []).length ? '\r\n' : '\n';
+  const nCur = curLines.map(norm);                        // normalizamos UNA vez
+  let seaLines = search.replace(/[\r\n]+$/, '').split(/\r?\n/);
+  let repLines = replace.split(/\r?\n/);
+
+  // Posiciones donde un bloque de líneas encaja (ignorando espacios).
+  const locate = (nBlock) => {
+    const at = [];
+    for (let i = 0; i + nBlock.length <= nCur.length; i++) {
+      let same = true;
+      for (let j = 0; j < nBlock.length; j++) if (nCur[i + j] !== nBlock[j]) { same = false; break; }
+      if (same) { at.push(i); if (at.length > 8) break; }
+    }
+    return at;
+  };
+  const ambiguous = () => new Error(`«search» coincide (ignorando espacios) en más de un sitio de ${path} — añade líneas de contexto para que sea inequívoco.`);
 
-  // 1) bloque idéntico salvo espacios → tiene que ser ÚNICO
-  let exactStart = -1, exactHits = 0;
-  for (let i = 0; i + k <= curLines.length; i++) {
-    let same = true;
-    for (let j = 0; j < k; j++) if (norm(curLines[i + j]) !== nSea[j]) { same = false; break; }
-    if (same) { exactHits++; if (exactStart === -1) exactStart = i; if (exactHits > 1) break; }
+  let start = -1, k = seaLines.length;
+
+  // 1) el bloque ENTERO, idéntico salvo espacios → tiene que ser ÚNICO
+  {
+    const at = locate(seaLines.map(norm));
+    if (at.length > 1) throw ambiguous();
+    if (at.length === 1) start = at[0];
+  }
+
+  // 2) si no aparece entero, puede ser que el fichero tenga líneas que el modelo
+  // NO vio (un comentario añadido después, p. ej.) metidas dentro del bloque.
+  // Como search y replace comparten el contexto sin tocar al principio y al
+  // final, recortamos esa parte común y buscamos solo el NÚCLEO que cambia: así
+  // lo que el modelo no vio se queda donde estaba en vez de desaparecer.
+  if (start === -1) {
+    let pre = 0, suf = 0;
+    while (pre < seaLines.length && pre < repLines.length && norm(seaLines[pre]) === norm(repLines[pre])) pre++;
+    while (suf < seaLines.length - pre && suf < repLines.length - pre &&
+           norm(seaLines[seaLines.length - 1 - suf]) === norm(repLines[repLines.length - 1 - suf])) suf++;
+    const core = seaLines.slice(pre, seaLines.length - suf);
+    if (core.length) {
+      let at = locate(core.map(norm));
+      if (at.length > 1) {
+        // desempate por CONTEXTO: gana el candidato con más líneas del contexto
+        // recortado alrededor (y solo si gana en solitario).
+        const ctx = [...seaLines.slice(0, pre), ...seaLines.slice(seaLines.length - suf)].map(norm).filter(Boolean);
+        const near = i => {
+          const from = Math.max(0, i - pre - 3), to = Math.min(nCur.length, i + core.length + suf + 3);
+          const around = nCur.slice(from, to);
+          return ctx.filter(c => around.includes(c)).length;
+        };
+        const scored = at.map(i => ({ i, s: near(i) })).sort((a, b) => b.s - a.s);
+        if (ctx.length && scored[0].s > scored[1].s) at = [scored[0].i];
+      }
+      if (at.length > 1) throw ambiguous();
+      if (at.length === 1) { start = at[0]; k = core.length; repLines = repLines.slice(pre, repLines.length - suf); }
+    }
   }
-  if (exactHits > 1)
-    throw new Error(`«search» coincide (ignorando espacios) en más de un sitio de ${path} — añade líneas de contexto para que sea inequívoco.`);
 
-  let start = exactStart;
+  // 3) por parecido: la ventana con más líneas coincidentes, exigiendo ≥70% y
+  // que gane con claridad a la segunda mejor (sin ambigüedad)
   if (start === -1) {
-    // 2) por parecido: la ventana con más líneas coincidentes (normalizadas),
-    // exigiendo ≥70% y que gane con claridad a la segunda mejor (sin ambigüedad)
+    const nSea = seaLines.map(norm);
     let best = -1, bestScore = 0, second = 0;
-    for (let i = 0; i + k <= curLines.length; i++) {
+    for (let i = 0; i + k <= nCur.length; i++) {
       let hit = 0;
-      for (let j = 0; j < k; j++) if (norm(curLines[i + j]) === nSea[j]) hit++;
+      for (let j = 0; j < k; j++) if (nCur[i + j] === nSea[j]) hit++;
       const score = hit / k;
       if (score > bestScore) { second = bestScore; bestScore = score; best = i; }
       else if (score > second) second = score;
@@ -283,8 +341,13 @@ export async function edit({ path, search, replace } = {}) {
     throw new Error(`No encontré con suficiente confianza el punto exacto a editar en ${path} (ni exacto ni aproximado). ` +
       `Vuelve a leerlo (code.read) y copia «search» literal de esas líneas, más corto si hace falta.`);
 
-  const nextLines = [...curLines.slice(0, start), ...replace.split('\n'), ...curLines.slice(start + k)];
-  const nextContent = nextLines.join('\n');
+  // Corte exacto del bloque [start, start+k): desde el inicio de su primera
+  // línea hasta el inicio de la siguiente (es decir, salto de línea incluido).
+  const cutFrom = lineStart[start];
+  const hasTrailingNL = start + k < lineStart.length;
+  const cutTo = hasTrailingNL ? lineStart[start + k] : current.length;
+  const block = repLines.join(eol) + (hasTrailingNL ? eol : '');
+  const nextContent = current.slice(0, cutFrom) + block + current.slice(cutTo);
   if (nextContent === current)
     throw new Error(`La edición en ${path} no cambió nada — revisa «replace».`);
   return write({ path, content: nextContent });
@@ -294,11 +357,16 @@ export async function edit({ path, search, replace } = {}) {
 // existen por rendimiento, pero si se alcanzan hay que DECÍRSELO al modelo
 // (igual que read() avisa «quedan líneas…»); si no, un corte silencioso se lee
 // como «no hay más» y el modelo da por cerrada una búsqueda incompleta.
-const SEARCH_MAX_FILES = 1500, SEARCH_MAX_HITS = 80;
+const SEARCH_MAX_FILES = 1500, SEARCH_MAX_HITS = 80, SEARCH_MAX_BYTES = 2_000_000;
+// Binarios: NO pueden contener el texto que se busca y leerlos como texto es
+// caro. Fuera de esta lista quedan .svg/.json/.md/.csv, que son texto y sí se
+// buscan. (Antes el tope de tamaño hacía de filtro accidental de binarios.)
+const BINARY_EXT = /\.(png|jpe?g|gif|webp|avif|ico|bmp|tiff?|mp[34]|m4a|wav|ogg|mov|avi|webm|pdf|zip|gz|bz2|xz|tar|7z|rar|woff2?|ttf|eot|otf|wasm|bin|exe|dll|so|dylib|class|jar|pyc|sqlite3?)$/i;
 export async function search({ query, ext = '' } = {}) {
   if (!query) throw new Error('Falta query');
   if (!projectHandle) throw new Error('No hay proyecto abierto');
   const results = [];
+  const skipped = [];                       // ficheros de texto NO buscados por tamaño
   let checked = 0, capped = false;
   const q = query.toLowerCase();
   async function walk(dir, prefix) {
@@ -308,8 +376,13 @@ export async function search({ query, ext = '' } = {}) {
       const p = prefix ? prefix + '/' + e.name : e.name;
       if (e.kind === 'directory') { await walk(e, p); if (capped) return; continue; }
       if (ext && !e.name.endsWith(ext)) continue;
+      if (BINARY_EXT.test(e.name)) continue;
       const f = await e.getFile();
-      if (f.size > 200_000) continue;
+      // Un fichero grande es justo donde el modelo NO puede leerlo entero, así
+      // que es el que más falta hace buscar. Se busca hasta SEARCH_MAX_BYTES; y
+      // lo que quede fuera se DICE (antes: >200KB se saltaba en silencio, y
+      // «Sin resultados» sonaba a «ese código no existe» siendo mentira).
+      if (f.size > SEARCH_MAX_BYTES) { skipped.push(p); continue; }
       checked++;
       const lines = (await f.text()).split('\n');
       for (let i = 0; i < lines.length; i++) {
@@ -322,9 +395,13 @@ export async function search({ query, ext = '' } = {}) {
     }
   }
   await walk(projectHandle, '');
+  // Todo lo que la búsqueda NO ha mirado se cuenta; un resultado incompleto que
+  // se presenta como completo es peor que no buscar.
+  const notes = [];
+  if (capped) notes.push(`búsqueda cortada (${results.length} resultados, ${checked} ficheros revisados) — puede haber más: afina con ext o un término más concreto`);
+  if (skipped.length) notes.push(`${skipped.length} fichero(s) NO buscados por tamaño (>${SEARCH_MAX_BYTES / 1e6} MB): ${skipped.slice(0, 3).join(', ')}${skipped.length > 3 ? '…' : ''} — mira dentro con code.read`);
+  const tail = notes.length ? '\n… ' + notes.join('. ') + '.' : '';
   if (!results.length)
-    return `Sin resultados para «${query}»` + (capped ? ` (búsqueda cortada tras ${checked} ficheros; afina con ext:".js" o un término más concreto).` : '');
-  return results.join('\n') + (capped
-    ? `\n… búsqueda cortada (${results.length} resultados, ${checked} ficheros revisados) — puede haber más: afina con ext o un término más concreto.`
-    : '');
+    return `Sin resultados para «${query}»` + (tail || '');
+  return results.join('\n') + tail;
 }

js/workspace.js

@@ -0,0 +1,289 @@
+// workspace.js — carpeta de trabajo, copia legible en disco e inventario.
+//
+// CORE compartido por Claw y Code. El módulo no sabe qué es una «app generada»
+// ni una «conversación»: cada app le pasa un MANIFIESTO de almacenes y él sabe
+// leerlos, medirlos, escribirlos a disco, reimportarlos y borrarlos.
+//
+// Por qué existe: todo vive en IndexedDB/localStorage, que el navegador puede
+// desalojar (o el usuario borrar con «limpiar datos del sitio») sin avisar. Con
+// una carpeta de trabajo, tu trabajo queda en ficheros normales que puedes ver,
+// copiar y respaldar tú.
+//
+// Lo que NUNCA sale a disco en claro: el vault (secretos cifrados). Se marca
+// `sensitive` en el manifiesto y se excluye salvo petición explícita.
+
+const HANDLE_KEY = 'workspace-handle';
+const ROOT = '.elffuss';
+
+let cfg = null;             // { app, ns, db, stores }
+let dirHandle = null;       // FileSystemDirectoryHandle de la carpeta de trabajo
+let ready = false;          // permiso concedido AHORA
+let dirty = new Set();
+let listeners = [];
+let lastSaveAt = null, lastError = null;
+let autosaveCfg = { enabled: false, debounceMs: 3000 };
+let autosaveTimer = null;
+
+export function init({ app, ns, db, stores }) {
+  cfg = { app, ns, db, stores: stores || [] };
+}
+
+export function supported() {
+  return {
+    pick: typeof window !== 'undefined' && typeof window.showDirectoryPicker === 'function',
+    persist: !!(navigator.storage && navigator.storage.persist),
+  };
+}
+
+const emit = () => { const s = statusSync(); listeners.forEach(f => { try { f(s); } catch { /* */ } }); };
+export function onChange(fn) { listeners.push(fn); return () => { listeners = listeners.filter(f => f !== fn); }; }
+
+function statusSync() {
+  return {
+    supported: supported(), folder: dirHandle ? dirHandle.name : null, ready,
+    dirty: [...dirty], lastSaveAt, lastError, autosave: autosaveCfg.enabled,
+  };
+}
+export function status() { return statusSync(); }
+
+// ── carpeta de trabajo ───────────────────────────────────────────────────────
+async function perm(handle, mode = 'readwrite') {
+  if (!handle?.queryPermission) return true;              // OPFS u otros: dados
+  if ((await handle.queryPermission({ mode })) === 'granted') return true;
+  return false;
+}
+
+// En el arranque: recupera el handle SIN pedir permiso ni abrir diálogos.
+export async function restore() {
+  if (!cfg) throw new Error('workspace.init() primero');
+  let h = null;
+  try { h = await cfg.db.get('kv', HANDLE_KEY); } catch { return null; }
+  if (!h) return null;
+  dirHandle = h;
+  ready = await perm(h);
+  emit();
+  return { name: h.name, ready, reason: ready ? null : 'prompt' };
+}
+
+// Elegir carpeta (requiere gesto de usuario).
+export async function pick() {
+  if (!supported().pick) throw new Error('Este navegador no permite elegir una carpeta. Usa «Descargar copia» para guardar tu trabajo.');
+  const h = await window.showDirectoryPicker({ mode: 'readwrite', id: 'elffuss-workspace', startIn: 'documents' });
+  dirHandle = h;
+  ready = true;
+  await cfg.db.set('kv', HANDLE_KEY, h);
+  emit();
+  return { name: h.name, ready: true };
+}
+
+// Reutilizar un handle que la app ya tiene (Code: la carpeta del proyecto).
+export async function adopt(handle) {
+  if (!handle) throw new Error('sin handle');
+  dirHandle = handle;
+  ready = await perm(handle);
+  await cfg.db.set('kv', HANDLE_KEY, handle);
+  emit();
+  return { name: handle.name, ready };
+}
+
+// Re-conceder permiso tras recargar (requiere gesto de usuario).
+export async function regrant() {
+  if (!dirHandle) throw new Error('no hay carpeta elegida');
+  const ok = dirHandle.requestPermission
+    ? (await dirHandle.requestPermission({ mode: 'readwrite' })) === 'granted'
+    : true;
+  ready = ok;
+  emit();
+  if (!ok) throw new Error('permiso denegado');
+  return { name: dirHandle.name, ready: true };
+}
+
+export async function forget() {
+  const name = dirHandle?.name || null;
+  dirHandle = null; ready = false;
+  try { await cfg.db.del('kv', HANDLE_KEY); } catch { /* */ }
+  emit();
+  return { forgot: name, deleted: false };   // nunca borra los ficheros del disco
+}
+
+export async function ensurePersistence() {
+  if (!navigator.storage?.persist) return { persisted: false, asked: false };
+  const already = navigator.storage.persisted ? await navigator.storage.persisted() : false;
+  if (already) return { persisted: true, asked: false };
+  const got = await navigator.storage.persist().catch(() => false);
+  return { persisted: got, asked: true };
+}
+
+// ── inventario: «ver qué hay» ────────────────────────────────────────────────
+const sizeOf = v => { try { return new Blob([typeof v === 'string' ? v : JSON.stringify(v)]).size; } catch { return 0; } };
+
+async function readStore(st) {
+  if (st.kind === 'ls') {
+    const items = [];
+    for (const k of st.keys || []) {
+      const v = localStorage.getItem(k);
+      if (v != null) items.push({ key: k, value: v });
+    }
+    return items;
+  }
+  if (st.kind === 'idb-store') {                      // store entero (apps, tasks…)
+    const [ks, vs] = await Promise.all([cfg.db.keys(st.store), cfg.db.all(st.store)]);
+    return ks.map((k, i) => ({ key: String(k), value: vs[i] }));
+  }
+  // 'idb-key': una clave concreta dentro de kv (history, conversations, skills…)
+  const v = await cfg.db.get(st.store || 'kv', st.key);
+  if (v == null) return [];
+  return Array.isArray(v) ? v.map((x, i) => ({ key: String(x.id ?? x.name ?? i), value: x })) : [{ key: st.key, value: v }];
+}
+
+export async function inventory() {
+  const out = [];
+  for (const st of cfg.stores) {
+    let items = [];
+    let err = null;
+    try { items = await readStore(st); } catch (e) { err = e.message; }
+    out.push({
+      id: st.id, label: st.label, icon: st.icon || '•', sensitive: !!st.sensitive,
+      count: items.length, bytes: items.reduce((a, b) => a + sizeOf(b.value), 0),
+      note: st.note || '', error: err,
+    });
+  }
+  return out;
+}
+
+export async function peek(id, { limit = 50 } = {}) {
+  const st = cfg.stores.find(s => s.id === id);
+  if (!st) throw new Error('almacén desconocido: ' + id);
+  const items = await readStore(st);
+  return {
+    id, truncated: items.length > limit,
+    items: items.slice(0, limit).map(it => ({
+      key: it.key, bytes: sizeOf(it.value),
+      preview: st.sensitive ? '(cifrado — no se muestra)'
+        : (typeof it.value === 'string' ? it.value : JSON.stringify(it.value)).slice(0, 240),
+    })),
+  };
+}
+
+// Espacio real del origen, incluidas TODAS las caches (los modelos son GB).
+export async function storageReport() {
+  const est = navigator.storage?.estimate ? await navigator.storage.estimate().catch(() => ({})) : {};
+  const persisted = navigator.storage?.persisted ? await navigator.storage.persisted().catch(() => false) : false;
+  const out = { usage: est.usage || 0, quota: est.quota || 0, persisted, caches: [] };
+  if (typeof caches !== 'undefined') {
+    for (const name of await caches.keys().catch(() => [])) {
+      const c = await caches.open(name);
+      const reqs = await c.keys();
+      let bytes = 0;
+      for (const r of reqs) {
+        const res = await c.match(r);
+        const len = +(res?.headers.get('content-length') || 0);
+        bytes += len;
+      }
+      out.caches.push({ name, entries: reqs.length, bytes });
+    }
+  }
+  return out;
+}
+
+// ── guardar en disco ─────────────────────────────────────────────────────────
+export function touch(id) {
+  dirty.add(id);
+  emit();
+  if (autosaveCfg.enabled) {
+    clearTimeout(autosaveTimer);
+    autosaveTimer = setTimeout(() => { save({ reason: 'auto' }).catch(() => {}); }, autosaveCfg.debounceMs);
+  }
+}
+
+export function autosave({ enabled, debounceMs }) {
+  autosaveCfg = { enabled: !!enabled, debounceMs: debounceMs || autosaveCfg.debounceMs };
+  try { localStorage.setItem(cfg.ns + '.workspace.autosave', enabled ? '1' : '0'); } catch { /* */ }
+  emit();
+  return autosaveCfg;
+}
+export function autosaveEnabled() {
+  try { return localStorage.getItem(cfg.ns + '.workspace.autosave') === '1'; } catch { return false; }
+}
+
+async function dirFor(path) {                 // crea .elffuss/<app>/<sub> y devuelve el handle
+  let d = dirHandle;
+  for (const part of path.split('/').filter(Boolean)) d = await d.getDirectoryHandle(part, { create: true });
+  return d;
+}
+async function writeFile(dir, name, text) {
+  const fh = await dir.getFileHandle(name, { create: true });
+  const w = await fh.createWritable();
+  await w.write(text);
+  await w.close();
+}
+const safeName = s => String(s).replace(/[^\w.\-]+/g, '_').slice(0, 60) || 'item';
+
+export async function save({ only = null, reason = 'manual' } = {}) {
+  if (!dirHandle) throw new Error('no-folder');
+  if (!(await perm(dirHandle))) { ready = false; emit(); throw new Error('needs-regrant'); }
+  const targets = cfg.stores.filter(st => !st.sensitive && (only ? only.includes(st.id) : true));
+  const wrote = [], errors = [];
+  for (const st of targets) {
+    try {
+      const items = await readStore(st);
+      const base = `${ROOT}/${cfg.app}/${st.id}`;
+      if (st.files) {                              // uno por fichero (apps .html, skills .md)
+        const d = await dirFor(base);
+        for (const it of items) {
+          const body = st.files.body ? st.files.body(it.value) : JSON.stringify(it.value, null, 1);
+          await writeFile(d, safeName(st.files.name ? st.files.name(it.value, it.key) : it.key) + (st.files.ext || '.json'), body);
+        }
+      } else {                                      // uno solo (historial, ajustes)
+        const d = await dirFor(`${ROOT}/${cfg.app}`);
+        await writeFile(d, st.id + '.json', JSON.stringify(items.map(i => i.value), null, 1));
+      }
+      wrote.push({ id: st.id, files: items.length });
+      dirty.delete(st.id);
+    } catch (e) { errors.push({ id: st.id, error: e.message }); }
+  }
+  lastSaveAt = Date.now();
+  lastError = errors.length ? errors[0].error : null;
+  // índice legible con lo que hay
+  try {
+    const d = await dirFor(`${ROOT}/${cfg.app}`);
+    await writeFile(d, 'index.json', JSON.stringify({ app: cfg.app, at: lastSaveAt, reason, wrote }, null, 1));
+  } catch { /* */ }
+  emit();
+  return { ok: !errors.length, at: lastSaveAt, wrote, errors };
+}
+
+// ── copia descargable (Safari/Firefox o backup manual) ───────────────────────
+export async function bundle({ only = null, includeSensitive = false } = {}) {
+  const data = { app: cfg.app, at: Date.now(), stores: {} };
+  for (const st of cfg.stores) {
+    if (st.sensitive && !includeSensitive) continue;
+    if (only && !only.includes(st.id)) continue;
+    try { data.stores[st.id] = (await readStore(st)).map(i => i.value); } catch { /* */ }
+  }
+  return new Blob([JSON.stringify(data, null, 1)], { type: 'application/json' });
+}
+
+// ── borrar ───────────────────────────────────────────────────────────────────
+export async function wipe({ only = null, confirm } = {}) {
+  if (confirm !== 'BORRAR') throw new Error('confirmación requerida');
+  const removed = [];
+  for (const st of cfg.stores) {
+    if (only && !only.includes(st.id)) continue;
+    try {
+      if (st.kind === 'ls') { for (const k of st.keys || []) localStorage.removeItem(k); removed.push({ id: st.id }); }
+      else if (st.kind === 'idb-store') { for (const k of await cfg.db.keys(st.store)) await cfg.db.del(st.store, k); removed.push({ id: st.id }); }
+      else { await cfg.db.del(st.store || 'kv', st.key); removed.push({ id: st.id }); }
+    } catch (e) { removed.push({ id: st.id, error: e.message }); }
+  }
+  emit();
+  return { removed };
+}
+
+export async function clearCaches({ names } = {}) {
+  if (typeof caches === 'undefined') return { deleted: [] };
+  const target = names || await caches.keys();
+  const deleted = [];
+  for (const n of target) if (await caches.delete(n)) deleted.push(n);
+  return { deleted };
+}

lab.html

@@ -0,0 +1,123 @@
+<!doctype html>
+<html lang="es">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Elffuss Lab — banco de pruebas</title>
+<link rel="icon" href="data:,">
+<link rel="stylesheet" href="css/lab.css">
+</head>
+<body>
+
+<header>
+  <h1>Elffuss <span>Lab</span></h1>
+  <div class="sub">banco de pruebas · algoritmos y compresión de contexto</div>
+  <div class="spacer"></div>
+  <div class="led" id="led-model"><i></i><span>modelo: sin cargar</span></div>
+  <div class="led" id="led-run"><i></i><span>en reposo</span></div>
+  <a class="sub" href="index.html">← volver al IDE</a>
+</header>
+
+<main>
+  <!-- ══════════ IZQUIERDA: configuración del experimento ══════════ -->
+  <section>
+    <div class="panel">
+      <h2>Cerebro <span class="tag" id="brain-tag">—</span></h2>
+      <div class="body">
+        <div class="seg" id="brains"></div>
+        <p class="hint">El banco usa el mismo proveedor que el IDE. «Reglas» no
+        gasta GPU y sirve para validar el arnés; los benchmarks que exigen
+        generación real necesitan un modelo de verdad.</p>
+        <div class="row" style="margin-top:10px">
+          <button class="btn" id="btn-load">Cargar cerebro</button>
+          <span class="sub" id="load-state"></span>
+        </div>
+      </div>
+    </div>
+
+    <div class="panel">
+      <h2>Algoritmo de generación <span class="tag" id="algo-tag">directo</span></h2>
+      <div class="body">
+        <div class="seg" id="algos"></div>
+        <div class="group-title">parámetros</div>
+        <div class="knobs" id="algo-knobs"></div>
+      </div>
+    </div>
+
+    <div class="panel">
+      <h2>Compresión de contexto (ACER) <span class="tag" id="ctx-tag">—</span></h2>
+      <div class="body">
+        <div class="row" style="margin-bottom:8px">
+          <button class="btn ghost" id="ctx-all">Todo ON</button>
+          <button class="btn ghost" id="ctx-none">Todo OFF</button>
+          <button class="btn ghost" id="ctx-def">Por defecto</button>
+        </div>
+        <div id="ctx-knobs"></div>
+        <p class="hint">Cada perilla es la del motor real (<code>acer-core.js</code>).
+        Lo que marques aquí es lo que se le pasa a <code>packHistoryACER</code>
+        en el banco de contexto y lo que se guarda al lanzar el IDE.</p>
+      </div>
+    </div>
+  </section>
+
+  <!-- ══════════ DERECHA: ejecución y resultados ══════════ -->
+  <section>
+    <div class="panel">
+      <h2>Banco de pruebas <span class="tag" id="bench-tag">—</span></h2>
+      <div class="body">
+        <div class="seg" id="benches"></div>
+        <div class="row" style="margin-top:12px">
+          <button class="btn primary" id="btn-run">▶ Lanzar benchmark</button>
+          <button class="btn" id="btn-stop" disabled>■ Parar</button>
+          <button class="btn" id="btn-save">★ Guardar en el ranking</button>
+          <button class="btn ghost" id="btn-launch">Lanzar el IDE con esta configuración</button>
+        </div>
+        <div class="bar" style="margin-top:12px"><i id="prog"></i></div>
+        <div class="sub" id="prog-txt" style="margin-top:6px">—</div>
+      </div>
+    </div>
+
+    <div class="panel">
+      <h2>Métricas en vivo</h2>
+      <div class="body"><div class="tiles" id="tiles"></div></div>
+    </div>
+
+    <div class="panel">
+      <h2>Resultados por caso</h2>
+      <div class="body" style="padding:0">
+        <table><thead id="res-head"></thead><tbody id="res-body"></tbody></table>
+      </div>
+    </div>
+
+    <div class="panel" id="arena-panel" hidden>
+      <h2>Arena <span class="tag">lo generado, ejecutándose</span></h2>
+      <div class="body"><iframe class="arena" id="arena" sandbox="allow-scripts allow-same-origin"></iframe></div>
+    </div>
+
+    <div class="panel">
+      <h2>Ranking local <span class="tag" id="rank-tag">—</span></h2>
+      <div class="body" style="padding:0">
+        <table>
+          <thead><tr><th>#</th><th>score</th><th>configuración</th><th>cuándo</th><th></th></tr></thead>
+          <tbody id="rank-body"></tbody>
+        </table>
+      </div>
+      <div class="body" style="border-top:1px solid var(--line)">
+        <div class="row">
+          <span class="pill">todo en esta máquina · no se envía nada</span>
+          <div class="spacer" style="flex:1"></div>
+          <button class="btn ghost" id="btn-clear">Borrar historial</button>
+        </div>
+      </div>
+    </div>
+
+    <div class="panel">
+      <h2>Consola</h2>
+      <div class="body"><div class="log" id="log"></div></div>
+    </div>
+  </section>
+</main>
+
+<script type="module" src="js/lab.js"></script>
+</body>
+</html>

style.css

@@ -1,28 +0,0 @@
-body {
-	padding: 2rem;
-	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
-	font-size: 16px;
-	margin-top: 0;
-}
-
-p {
-	color: rgb(107, 114, 128);
-	font-size: 15px;
-	margin-bottom: 10px;
-	margin-top: 5px;
-}
-
-.card {
-	max-width: 620px;
-	margin: 0 auto;
-	padding: 16px;
-	border: 1px solid lightgray;
-	border-radius: 16px;
-}
-
-.card p:last-child {
-	margin-bottom: 0;
-}