File size: 23,610 Bytes
b30b7c5
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
d305959
4bd8362
 
 
 
 
 
 
 
 
 
d305959
 
4bd8362
d305959
4bd8362
 
d305959
 
4bd8362
 
d305959
 
 
b30b7c5
 
4bd8362
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
73063cc
 
 
 
 
 
 
 
 
b30b7c5
 
 
4bd8362
b30b7c5
 
 
 
4bd8362
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
b30b7c5
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4bd8362
 
 
b30b7c5
 
4bd8362
b30b7c5
 
 
 
4bd8362
 
 
 
 
 
 
 
 
 
b30b7c5
4bd8362
 
 
 
 
b30b7c5
4bd8362
b30b7c5
4bd8362
b30b7c5
4bd8362
 
b30b7c5
 
 
4bd8362
 
 
 
b30b7c5
4bd8362
 
 
 
 
 
 
b30b7c5
4bd8362
b30b7c5
4bd8362
 
 
 
 
 
 
b30b7c5
4bd8362
 
b30b7c5
 
 
 
 
 
 
 
4bd8362
 
 
b30b7c5
 
 
 
 
4bd8362
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
b30b7c5
4bd8362
 
 
b30b7c5
 
4bd8362
b30b7c5
 
4bd8362
 
b30b7c5
 
 
4bd8362
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
b30b7c5
 
4bd8362
 
 
 
 
 
 
 
 
 
b30b7c5
 
 
 
 
 
4bd8362
 
 
 
 
 
 
 
 
 
 
 
 
 
 
b30b7c5
 
 
4bd8362
 
 
 
 
 
 
 
b30b7c5
4bd8362
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
b30b7c5
 
 
 
4bd8362
 
 
 
b30b7c5
4bd8362
 
 
 
 
b30b7c5
 
4bd8362
 
b30b7c5
4bd8362
b30b7c5
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4bd8362
 
 
 
 
 
 
b30b7c5
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
// 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();
}