// Conversaciones: varias a la vez, como pestañas — cada una con su propio // historial (su propio Agent) y su propia cola de mensajes pendientes. // Cerrar una pestaña NO borra la conversación (solo la Historial sí). Todo // persiste en IndexedDB, sobrevive a recargar. // // Procesado: cada conversación acepta y encola mensajes de forma totalmente // independiente (mandar en la pestaña B mientras la A está pensando no // bloquea nada). La generación en sí (la llamada real al modelo) se // serializa con un cerrojo global — solo hay UN modelo cargado en el // navegador y una sesión de inferencia no admite dos generate() a la vez sin // corromperse — así que las conversaciones se turnan para «hablar» con el // modelo, pero cada una sigue funcionando y aceptando mensajes de forma // independiente mientras espera su turno. import { Agent } from './agent.js'; import { runGoal, TASK_PREFIX } from './goal.js'; import * as db from './db.js'; import * as telemetry from './telemetry.js'; const NS = 'elffusscode'; const TABS_KEY = NS + '.openTabs'; const ACTIVE_KEY = NS + '.activeConv'; const HIST_CAP = 80; // mensajes por conversación que se persisten let providerRef = null; const convs = new Map(); // id -> { id, title, agent, queue, pumping, createdAt, updatedAt } let openTabIds = []; let activeId = null; let onChange = () => {}; const genId = () => 'c' + Date.now().toString(36) + Math.random().toString(36).slice(2, 7); const cleanTitle = s => String(s).replace(/\s+/g, ' ').trim(); const GOAL_PREFIX = TASK_PREFIX + 'Objetivo: '; export function titleFor(conv) { if (conv.title) return conv.title; const firstUser = conv.agent.history.find(m => m.role === 'user' && !m.content.startsWith('[resultado') && (!m.content.startsWith(TASK_PREFIX) || m.content.startsWith(GOAL_PREFIX))); if (!firstUser) return 'Nueva conversación'; // el objetivo lleva un prefijo interno ([tarea-objetivo] Objetivo: …) que // no debe filtrarse al título de la pestaña — se muestra el texto limpio. const raw = firstUser.content.startsWith(GOAL_PREFIX) ? firstUser.content.slice(GOAL_PREFIX.length) : firstUser.content; const t = cleanTitle(raw); return t.length > 40 ? t.slice(0, 40) + '…' : t || 'Nueva conversación'; } export function setProvider(mod) { providerRef = mod; for (const c of convs.values()) c.agent.setProvider(mod); } export function getProvider() { return providerRef; } export function isBusy() { for (const c of convs.values()) if (c.pumping || c.queue.length) return true; return false; } export function getActive() { return activeId ? convs.get(activeId) : null; } // Parar la conversación activa mientras trabaja: aborta el turno en curso (su // señal llega al agente, al proveedor y a las herramientas), vacía la cola y lo // GUARDA YA. Antes la cola vaciada solo vivía en memoria hasta que el turno // terminaba: si recargabas justo después de parar, el mensaje parado seguía en // IndexedDB y se volvía a ejecutar al abrir. // // `parando` cubre el rato entre el clic y el final real del turno (un modelo // lento tarda en soltar la generación): la UI lo enseña como «Parando…» en vez // de dejar un ■ que parece no hacer caso. Sin turno en marcha no hay nada que // soltar, y se dice ya que está parado. export function stopActive() { const c = getActive(); if (!c || (!c.pumping && !c.queue.length)) return false; c.stopped = true; c.parando = c.pumping; try { c.aborter?.abort(); } catch { /* */ } try { c.agent.stop(); } catch { /* */ } c.queue.length = 0; persistConv(c).catch(e => console.warn('[elffuss] no se pudo guardar la cola vaciada', e)); onChange('stopping', c.id, c.parando); return true; } export function getOpenTabs() { return openTabIds.map(id => convs.get(id)).filter(Boolean); } // Todas las conversaciones viven en UNA clave ('conversations'), y guardar una // es leer la lista entera, cambiar su registro y escribirla entera. Dos de esas // a la vez se pisan: la que escribe la última lo hace con lo que leyó ANTES de // la otra y borra lo que la otra guardó. Pasaba al parar un mensaje que // esperaba turno: se saltaba y guardaba justo cuando la conversación que tenía // el cerrojo guardaba su respuesta, y esa respuesta desaparecía de IndexedDB con // su mensaje aún en cola, así que al recargar se volvía a ejecutar (en un IDE // con agente, otra vez las ediciones y los comandos). Por eso cada escritura de // la lista espera a la anterior, y cada una lee el estado del momento en que le // toca, no el del momento en que se pidió. let escrituras = Promise.resolve(); function enOrden(fn) { const hecho = escrituras.then(fn, fn); escrituras = hecho.catch(() => {}); return hecho; } function persistConv(conv) { return enOrden(() => persistConvYa(conv)); } async function persistConvYa(conv) { // Borrada desde la Historial (también mientras su guardado esperaba): no se // vuelve a escribir, o resucitaría. if (conv.borrada || convs.get(conv.id) !== conv) return; // 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), queue: conv.queue, plan: planParaGuardar(conv), createdAt: conv.createdAt, updatedAt: conv.updatedAt, }; if (i >= 0) all[i] = rec; else all.push(rec); await db.set('kv', 'conversations', all).catch(() => {}); } // El plan de un objetivo PARADO que aún se está soltando se guarda ya como // parado: stopActive() guarda en el acto (para que recargar no repita nada), y // en ese momento el plan en memoria todavía dice «ejecutando», con su tarea en // curso. Recargando antes de que el objetivo terminase de soltarse, la tarjeta // decía «ejecutando…» para siempre sin que nada se ejecutara. Es lo mismo que // runGoal deja al terminar: la tarea en curso parada y las pendientes saltadas. function planParaGuardar(conv) { const plan = conv.plan || null; if (!plan || !conv.stopped || (plan.status !== 'planning' && plan.status !== 'running')) return plan; return { ...plan, status: 'stopped', tasks: (plan.tasks || []).map(t => ({ ...t, status: t.status === 'in-progress' ? 'stopped' : t.status === 'pending' ? 'skipped' : t.status, })), }; } function persistMeta() { try { localStorage.setItem(TABS_KEY, JSON.stringify(openTabIds)); } catch { /* lleno */ } try { localStorage.setItem(ACTIVE_KEY, activeId || ''); } catch { /* lleno */ } } function makeConv(id, saved) { const conv = { id, title: saved?.title || null, agent: new Agent(providerRef), queue: saved?.queue ? [...saved.queue] : [], pumping: false, plan: saved?.plan || null, createdAt: saved?.createdAt || Date.now(), updatedAt: saved?.updatedAt || Date.now(), }; if (saved?.history) conv.agent.history = saved.history; convs.set(id, conv); return conv; } export function create() { const conv = makeConv(genId()); openTabIds.push(conv.id); activeId = conv.id; persistMeta(); onChange('switch', conv.id); return conv; } // reabre una conversación guardada (de la Historial) como pestaña, o activa // la pestaña si ya estaba abierta export async function open(id) { if (!convs.has(id)) { const saved = (await db.get('kv', 'conversations').catch(() => null) || []).find(c => c.id === id); if (!saved) return null; makeConv(id, saved); } if (!openTabIds.includes(id)) openTabIds.push(id); activeId = id; persistMeta(); onChange('switch', id); return convs.get(id); } export function switchTo(id) { if (!convs.has(id) || activeId === id) return; activeId = id; persistMeta(); onChange('switch', id); } // añade un mensaje fuera del ciclo normal de envío (p.ej. el informe // autónomo del cerebro CEO) al historial REAL de una conversación — si no, // solo viviría en el DOM y desaparecería al cambiar de pestaña o recargar. // `extra` se guarda junto al mensaje (p. ej. la propuesta que acompaña al // informe del cerebro, para volver a pintar su botón al recargar). export async function appendMessage(id, role, content, extra = {}) { const c = convs.get(id); if (!c) return; c.agent.history.push({ ...extra, role, content, ts: Date.now() }); c.updatedAt = Date.now(); await persistConv(c); } // Ponerle nombre a una conversación (menú de su pestaña). Vacío vuelve al // título automático (el primer mensaje). export async function rename(id, title) { const c = convs.get(id); if (!c) return; c.title = cleanTitle(title || '').slice(0, 80) || null; await persistConv(c); onChange('tabs', activeId); } // quita la pestaña de la vista — la conversación sigue viva en la Historial // // Si la pestaña cerrada era la ACTIVA, se avisa con 'switch' y no con 'tabs': // con 'tabs' la barra se repintaba pero el chat seguía enseñando la // conversación cerrada, y lo siguiente que escribías iba a parar a otra que no // estaba en pantalla. export function closeTab(id) { const eraActiva = activeId === id; openTabIds = openTabIds.filter(x => x !== id); if (eraActiva) activeId = openTabIds[openTabIds.length - 1] || null; persistMeta(); if (!openTabIds.length) create(); else onChange(eraActiva ? 'switch' : 'tabs', activeId); } // borra la conversación de verdad (desde la Historial) // // Si estaba trabajando se para antes de borrarla: su turno, al terminar, // llamaba a persistConv y la volvía a escribir en IndexedDB, así que una // conversación borrada resucitaba en la Historial. export async function remove(id) { const c = convs.get(id); if (c) { c.borrada = true; c.queue.length = 0; try { c.aborter?.abort(); } catch { /* */ } try { c.agent.stop(); } catch { /* */ } } convs.delete(id); const eraActiva = activeId === id; openTabIds = openTabIds.filter(x => x !== id); if (eraActiva) activeId = openTabIds[openTabIds.length - 1] || null; // En la misma fila que los guardados: si no, un guardado en curso de esta // conversación la volvía a meter después de borrarla. await enOrden(async () => { const all = (await db.get('kv', 'conversations').catch(() => null) || []).filter(c => c.id !== id); await db.set('kv', 'conversations', all).catch(() => {}); }); persistMeta(); if (!openTabIds.length) create(); else onChange(eraActiva ? 'switch' : 'tabs', activeId); } export async function listAll() { const all = await db.get('kv', 'conversations').catch(() => null) || []; return all.slice().sort((a, b) => b.updatedAt - a.updatedAt); } // ---- envío / procesado ---- // items de la cola: {kind:'chat'|'goal'|'hard', text} — 'chat' es un turno normal // (agent.handle), 'goal' dispara el planificador/ejecutor de goal.js, 'hard' // el Hard Work (ver setHardWorkRunner). Las // colas persistidas ANTES de que existiera el modo Objetivo guardaban texto // suelto (strings) — normalizeItem() los sigue aceptando como 'chat'. let inferenceLock = Promise.resolve(); const normalizeItem = it => (typeof it === 'string' ? { kind: 'chat', text: it } : it); // Reanudar lo que quedó a medias, UNA VEZ HAY CEREBRO. Lo llama main.js después // de cargar el modelo. // // La guarda del contador no es paranoia: si un turno se llevó la pestaña por // delante —pasa con el modelo grande y poca memoria— reanudarlo al abrir la // vuelve a tumbar, y el usuario entra en un bucle del que no puede salir ni // abriendo la web. Se cuenta el intento ANTES de ejecutar y se persiste; si el // turno acaba, el item sale de la cola y el contador se va con él. Si la // pestaña muere, el contador sobrevive y al tercer intento ya no se reanuda // solo: se avisa y decide el usuario. const MAX_INTENTOS = 2; export function resumePending(onAviso = () => {}) { for (const conv of convs.values()) { if (!conv.queue.length) continue; const it = normalizeItem(conv.queue[0]); if ((it.intentos || 0) >= MAX_INTENTOS) { onAviso(conv.id, it); continue; } pump(conv); } } // Descarta el turno atascado y sigue con el resto de la cola. Para el botón del // aviso: sin esto, una conversación con un turno que cuelga queda bloqueada // para siempre y no hay forma de usarla. export async function descartarPendiente(id) { const conv = convs.get(id); if (!conv || !conv.queue.length) return; conv.queue.shift(); await persistConv(conv); if (conv.queue.length) pump(conv); } // Cada mensaje de la cola lleva su id: la UI marca «en cola» (⏳) la burbuja de // ESE mensaje y se la quita cuando empieza su turno ('turn' trae el item). Los // tres envíos devuelven el id. const genQid = () => 'q' + Date.now().toString(36) + Math.random().toString(36).slice(2, 7); function encola(id, kind, text) { const conv = convs.get(id); if (!conv) return null; const item = { kind, text, id: genQid() }; conv.queue.push(item); persistConv(conv); pump(conv); return item.id; } export function send(id, text) { return encola(id, 'chat', text); } // 🎯 Modo Objetivo: en vez de un turno de chat normal, el mensaje se trata // como un objetivo — se planifica en tareas y se ejecutan una a una (ver // goal.js, mismo patrón planificador/ejecutor de clonagent). export function startGoal(id, text) { return encola(id, 'goal', text); } // ⛏ Hard Work: lee el proyecto entero por partes. Va por la MISMA cola que el // resto: así el ■ lo para, la conversación se ve ocupada (el cerebro CEO // espera) y la pregunta y la respuesta se guardan como cualquier turno. Antes // corría por fuera: no se podía parar y desaparecía al cambiar de pestaña. // Quien sabe leer el proyecto (main.js) registra cómo se ejecuta. let hardWorkRunner = null; export function setHardWorkRunner(fn) { hardWorkRunner = fn; } export function startHardWork(id, text) { return encola(id, 'hard', text); } // true cuando le toca el turno; false si la parada llega antes. function turnoOParada(turno, signal) { if (signal.aborted) return Promise.resolve(false); return new Promise(resolve => { const alParar = () => resolve(false); signal.addEventListener('abort', alParar, { once: true }); turno.then(() => { signal.removeEventListener('abort', alParar); resolve(true); }); }); } // Cada turno lleva su propia parada (conv.aborter), creada ANTES de esperar el // cerrojo: parar mientras espera turno lo cancela sin llegar a llamar al // modelo. Antes la parada solo alcanzaba al turno que ya estaba generando, así // que un mensaje parado en la cola se ejecutaba igual en cuanto le tocaba. // // Y el turno solo se quita de la cola si sigue siendo el primero. Parar vacía // la cola, y lo que el usuario mande justo después entra en ella mientras el // turno parado termina de soltarse: el `shift()` a ciegas de antes se llevaba // ESE mensaje nuevo, y además el `break` por conv.stopped dejaba la cola // parada con él dentro. Mandar algo después de parar no obtenía respuesta. async function pump(conv) { if (conv.pumping) return; conv.pumping = true; onChange('pumping', conv.id, true); while (conv.queue.length) { const item = normalizeItem(conv.queue[0]); conv.queue[0] = item; // misma referencia para saber luego si sigue ahí // Lo que está en la cola llegó DESPUÉS de cualquier parada (parar la vacía), // así que la marca de la parada anterior no le aplica. Tampoco «Parando…»: // una parada que cayó entre dos turnos no tenía turno que soltar. conv.stopped = false; if (conv.parando) { conv.parando = false; onChange('stopping', conv.id, false); } // La parada del turno existe ANTES de la primera espera (guardar el intento // y luego el cerrojo): un ■ que cae en cualquiera de las dos lo cancela. const aborter = (conv.aborter = new AbortController()); const signal = aborter.signal; // El intento se cuenta y se GUARDA antes de ejecutar: si el turno se lleva // la pestaña, esto es lo único que queda para saber que ya se intentó. // Guardarlo después no serviría de nada — no habría «después». item.intentos = (item.intentos || 0) + 1; await persistConv(conv); const myTurn = inferenceLock; let release; inferenceLock = new Promise(r => { release = r; }); // Espera su turno de inferencia (un solo modelo cargado, no admite 2 // generate() a la vez)… o la parada, lo que llegue antes. Parar un mensaje // que solo espera turno no tiene nada que soltar: antes el botón se quedaba // en «Parando…» todo lo que durase el turno de OTRA conversación. Su hueco // en el cerrojo se suelta igualmente en orden, cuando lo suelte el de // delante, para que nadie se cuele por detrás mientras aquel sigue. const tengoTurno = await turnoOParada(myTurn, signal); if (!tengoTurno) myTurn.then(release); try { // Parado (o quitado de la cola) mientras esperaba: ni se llama al modelo, // y se dice en el chat como cualquier otro turno parado. if (signal.aborted && !tengoTurno) { try { onChange('event', conv.id, { type: 'aborted', text: '(Parado.)' }); } catch (e) { console.error('[elffuss] fallo pintando un evento de chat', e); } } if (tengoTurno && !signal.aborted && conv.queue[0] === item) { // Empieza DE VERDAD este mensaje: la UI deja de pintarlo «en cola». conv.turno = item; try { onChange('turn', conv.id, item); } catch (e) { console.error('[elffuss] fallo pintando el inicio de un turno', e); } // un fallo aquí (del modelo, de una tool, o del propio repintado en // main.js) NUNCA debe dejar la conversación "pumping" para siempre — // eso bloquearía sus futuros mensajes Y al cerebro CEO (isBusy()). // Tasa de resolución y tiempo por tarea. Se mide aquí, que es donde una // tarea empieza y acaba de verdad: el motor solo ve turnos y no sabe qué // es una tarea. «Resuelta» = ni excepción ni evento de error, porque el // fallo típico no es una excepción sino una respuesta que llega al // usuario como error — contar solo excepciones daría un 100 % perpetuo. // Una tarea PARADA no cuenta ni como resuelta ni como fallida: la cortó // quien la pidió. Contarla como resuelta inflaría la tasa (parar no // emite 'error'), y como fallida la hundiría por pulsar ■. Y va con el // cerebro que la empezó: el velocímetro solo apunta las del motor. const tTarea = (typeof performance !== 'undefined' ? performance.now() : Date.now()); const cerebro = providerRef; let huboError = false, parada = false; const onEvent = ev => { if (ev && ev.type === 'error') huboError = true; if (ev && ev.type === 'aborted') parada = true; try { onChange('event', conv.id, ev); } catch (e) { console.error('[elffuss] fallo pintando un evento de chat', e); } }; try { if (item.kind === 'goal') await runGoal(conv, item.text, onEvent, { signal }); else if (item.kind === 'hard' && hardWorkRunner) await hardWorkRunner(conv, item.text, onEvent, { signal }); else await conv.agent.handle(item.text, onEvent, { signal }); } finally { if (!parada && !signal.aborted) { try { const vm = await import('./velocimetro.js'); const fin = (typeof performance !== 'undefined' ? performance.now() : Date.now()); vm.tarea({ ok: !huboError, ms: fin - tTarea, cerebro }); } catch { /* sin velocímetro la app funciona igual */ } } } } } catch (e) { console.error('[elffuss] fallo procesando el turno', e); telemetry.reportError('pump: ' + (e?.message || e), { stack: e?.stack || '' }); try { onChange('event', conv.id, { type: 'error', text: 'Error interno: ' + (e?.message || e) }); } catch { /* ya está registrado arriba */ } } finally { if (tengoTurno) release(); } if (conv.turno === item) conv.turno = null; if (conv.aborter === aborter) conv.aborter = null; if (conv.queue[0] === item) conv.queue.shift(); conv.updatedAt = Date.now(); // «Parando…» se quita aquí solo si hay otro turno detrás. Si la cola queda // vacía se quita DESPUÉS del bucle, junto con `pumping`: quitarlo aquí, con // la conversación aún «trabajando» mientras se guarda, devolvía el botón a // un ■ «Parar» habilitado durante ese rato antes de pasar a «Enviar». if (conv.parando && conv.queue.length) { conv.parando = false; onChange('stopping', conv.id, false); } await persistConv(conv); } const sueltaParada = conv.parando; // una parada que llegó entre turnos ya no tiene nada que esperar conv.parando = false; conv.pumping = false; if (sueltaParada) onChange('stopping', conv.id, false); onChange('pumping', conv.id, false); } export async function init({ onEvent }) { onChange = onEvent; // migración única: el esquema viejo era UNA sola conversación (kv/history + kv/queue) const already = await db.get('kv', 'conversations').catch(() => null); if (!already) { const oldHistory = await db.get('kv', 'history').catch(() => null); if (oldHistory?.length) { const oldQueue = await db.get('kv', 'queue').catch(() => null); await db.set('kv', 'conversations', [{ id: genId(), title: null, history: oldHistory, queue: oldQueue || [], createdAt: Date.now(), updatedAt: Date.now(), }]).catch(() => {}); } } let tabIds = [], active = null; try { tabIds = JSON.parse(localStorage.getItem(TABS_KEY) || '[]'); } catch { /* corrupto */ } try { active = localStorage.getItem(ACTIVE_KEY) || null; } catch { /* */ } const all = await db.get('kv', 'conversations').catch(() => null) || []; for (const id of tabIds) { const saved = all.find(c => c.id === id); if (saved) { makeConv(id, saved); openTabIds.push(id); } } if (active && convs.has(active)) activeId = active; else if (openTabIds.length) activeId = openTabIds[0]; if (!openTabIds.length) { // nada abierto (primera vez, o se perdió el estado de pestañas): retoma // la conversación más reciente si hay alguna, si no, una nueva vacía const mostRecent = all.slice().sort((a, b) => b.updatedAt - a.updatedAt)[0]; if (mostRecent) { makeConv(mostRecent.id, mostRecent); openTabIds.push(mostRecent.id); activeId = mostRecent.id; } else create(); } // NO se reanuda aquí. Esta línea hacía `pump(conv)` directamente, y `init()` // corre ANTES de que el modelo esté cargado: el proveedor en ese momento es // `rules`, así que al refrescar a mitad de turno el mensaje en cola se // reprocesaba con el cerebro BÁSICO y se gastaba — peor que no reanudar, // porque además parecía que había contestado. Ahora lo dispara quien sabe // que hay cerebro: main.js, tras cargar el modelo, llamando a // `resumePending()`. persistMeta(); }