@ajuarezso/lienzo-mcp 0.0.0-stage → 0.2.0

package/lib/lienzo.mjs

@@ -0,0 +1,1278 @@
+// Operaciones de Lienzo sobre Firestore (contrato en docs/spec.md).
+import { randomBytes } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { basename, extname } from 'node:path';
+import { Firestore, ErrorFirestore, filtro, y, marcaDeTiempo } from './firestore.mjs';
+import { Sesion, ErrorSesion, abrirNavegador, ENTRAR_TIMEOUT_MS } from './sesion.mjs';
+import { buscarSecretos, explicarBloqueo } from './secretos.mjs';
+import { envolver, limpiarLinea, neutralizar, abreviarId, aviso, nuevoCodigo } from './envoltorio.mjs';
+import { rutaCompartible, revisarNombre, ErrorArchivo } from './archivos.mjs';
+import { INTERVALO_MS } from './esperar.mjs';
+import { cerrarTimbre } from './escucha.mjs';
+
+export const MAX_TEXTO = 20000;
+export const MAX_ARCHIVO_BYTES = 200 * 1024;
+/** Tope de caracteres de una respuesta de lienzo_leer / lienzo_esperar (lo que entra en el contexto del agente). */
+export const MAX_RESPUESTA = 60000;
+export const ID_TARJETA = /^[A-Za-z0-9_-]{1,64}$/;
+const CONECTADO_MS = 2 * 60 * 1000;
+const LATIDO_MS = 30 * 1000;
+const RECARGA_PARTICIPANTES_MS = 30 * 1000;
+const VISTA_ARCHIVO = 3000; // caracteres de un archivo que se muestran en una lista
+const LIMITE_CONSULTA = 50;
+
+/** El nombre de la persona: el de su cuenta en una línea (hasta 80) o, si no hay, la parte local del correo. */
+export function nombreDeCuenta(cuenta) {
+  const n = limpiarLinea(cuenta?.nombre ?? '', 80);
+  if (n) return n;
+  const local = limpiarLinea(String(cuenta?.email ?? '').split('@')[0], 80);
+  return local || null;
+}
+
+/** «Agente de <primer nombre>» (o null si la cuenta no tiene nombre ni correo). */
+export function nombreAgentePorDefecto(cuenta) {
+  const n = nombreDeCuenta(cuenta);
+  return n ? limpiarLinea(`Agente de ${n.split(/\s+/)[0]}`, 80) : null;
+}
+
+// ── listas de puntos (docs/producto.md §4) ──────────────────────────────────
+// Topes pensados para que una lista entera quepa en UNA respuesta de lienzo_leer/lienzo_esperar
+// (30 × 1 000 + 10 000 de contexto + encabezados ≈ 45 000 < 60 000).
+export const MAX_PUNTOS = 30;
+export const MAX_PUNTO = 1000;
+export const MAX_TITULO_LISTA = 200;
+export const MAX_CONTEXTO_LISTA = 10000;
+export const MAX_RESPUESTA_LOTE = 1000;
+export const ESTADOS = ['abierta', 'tomada', 'esperando', 'hecha', 'no_aplica'];
+const CERRADOS = new Set(['hecha', 'no_aplica']);
+const RE_PUNTO = /^(.+)-p(\d{2})$/;
+
+/** id del punto n (1..30) de una lista: «<idLista>-p01». Cabe en ID_TARJETA (20 + 4). */
+export const idPunto = (idLista, n) => `${idLista}-p${String(n).padStart(2, '0')}`;
+
+/** Número del punto según su id (null si no tiene forma de punto). */
+export const numeroPunto = (id) => {
+  const m = RE_PUNTO.exec(String(id ?? ''));
+  return m ? Number(m[2]) : null;
+};
+
+/**
+ * ¿`h` es un punto de la lista `padre`? Cualquiera de la sala puede crear una tarjeta con respondeA
+ * apuntando a una lista; solo cuentan las tareas hijas del MISMO autor, para el MISMO destinatario y con
+ * id «<lista>-pNN» (una tarea de seguimiento con respondeA no convierte a su padre en lista).
+ * Es el único filtro: lo usan la derivación del padre, el resumen al autor y el formato.
+ */
+export function esPunto(h, padre) {
+  return Boolean(h && padre)
+    && h.tipo === 'tarea' && padre.tipo === 'tarea' && !padre.respondeA
+    && h.respondeA === padre.id && RE_PUNTO.exec(String(h.id))?.[1] === padre.id
+    && h.autorId === padre.autorId && (h.paraId ?? null) === (padre.paraId ?? null);
+}
+
+/** Estado de la lista según sus puntos: todos cerrados → hecha; todos abiertos → abierta; alguno esperando → esperando; si no, tomada. */
+export function estadoDeLista(estados) {
+  if (estados.every((e) => CERRADOS.has(e))) return 'hecha';
+  if (estados.every((e) => e === 'abierta')) return 'abierta';
+  if (estados.includes('esperando')) return 'esperando';
+  return 'tomada';
+}
+
+/** «5 resueltos · 2 esperando a Lucho · 1 no aplica · 0 pendientes» */
+export function resumenLista(estados, quienEspera = null) {
+  const n = (f) => estados.filter(f).length;
+  const resueltos = n((e) => e === 'hecha');
+  const esperando = n((e) => e === 'esperando');
+  const noAplica = n((e) => e === 'no_aplica');
+  const pendientes = estados.length - resueltos - esperando - noAplica;
+  return `${resueltos} resuelto${resueltos === 1 ? '' : 's'} · ${esperando} esperando${quienEspera ? ` a ${quienEspera}` : ''} · ` +
+    `${noAplica} no aplica · ${pendientes} pendiente${pendientes === 1 ? '' : 's'}`;
+}
+
+/**
+ * A quién espera una lista: una persona, nunca el agente («esperando a Agente de Beto» no dice a quién le
+ * toca). Persona → su nombre; agente → su `dueño`; sin `dueño`, `persona` (la de su cuenta, `{uid}` de
+ * `{uid}_agente`, si está en la sala); y si no, «la persona de <agente>» (agente sin cuenta).
+ */
+export function quienEsperaLista(dest, persona = null) {
+  if (dest.tipo !== 'agente') return limpiarLinea(dest.nombre);
+  if (String(dest['dueño'] ?? '').trim()) return limpiarLinea(dest['dueño']);
+  if (persona?.tipo === 'persona' && String(persona.nombre ?? '').trim()) return limpiarLinea(persona.nombre);
+  return limpiarLinea(`la persona de ${dest.nombre}`);
+}
+
+/** Primera línea de un texto (el título de una lista), limpia y topada. */
+const primeraLinea = (t, max = MAX_TITULO_LISTA) => limpiarLinea(String(t ?? '').split('\n')[0], max);
+
+/** Las tarjetas que comparten la primera o la última hora de creación (un grupo nacido en un solo :commit). */
+function quitarGrupo(lista, { alFinal }) {
+  if (!lista.length) return lista;
+  const borde = claveTiempo((alFinal ? lista[lista.length - 1] : lista[0]).creadaEn);
+  const resto = lista.filter((t) => claveTiempo(t.creadaEn) !== borde);
+  return resto.length ? resto : lista; // un solo grupo que llena el tope: se entrega igual (no se traba)
+}
+
+/** Para comparar nombres: sin controles, sin mayúsculas, ancho normal, espacios simples. */
+export const claveNombre = (s) => limpiarLinea(s, 200).normalize('NFKC').toLowerCase().replace(/\s+/g, ' ').trim();
+
+const ALFABETO = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+
+export class ErrorLienzo extends Error {}
+
+// Por qué una cuenta ya no puede usar una sala (explicarNegado). Textos exactos del contrato (docs/spec.md).
+const SALIDA = 'Únete a otra con lienzo_unirse o crea una con lienzo_crear_sala.';
+export const TEXTO_QUITADO = `Te quitaron de esta sala: quien la creó ya no te deja leer ni publicar ahí. ${SALIDA}`;
+export const TEXTO_BORRADA = `Esta sala se borró: quien la creó la borró y ya nadie puede entrar. ${SALIDA}`;
+export const textoSaliste = (salaId) => `Ya no estás en esta sala: tu agente salió o lo sacaron (p. ej. saliste desde la web). Para volver, usa lienzo_unirse con el salaId ${salaId}.`;
+
+/**
+ * El ErrorFirestore de permiso negado que haya detrás de `e` (crudo, o conservado por _traducir en `cause`);
+ * null si el error es de otra cosa.
+ */
+export function negadoDe(e) {
+  const f = e instanceof ErrorFirestore ? e : e?.cause instanceof ErrorFirestore ? e.cause : null;
+  return f?.negado ? f : null;
+}
+
+/** 22 caracteres base64url = 16 bytes aleatorios (~128 bits). */
+export const nuevoSalaId = () => randomBytes(16).toString('base64url');
+
+export function nuevoId(n = 20) {
+  const b = randomBytes(n);
+  let s = '';
+  for (let i = 0; i < n; i++) s += ALFABETO[b[i] % ALFABETO.length];
+  return s;
+}
+
+/** Clave ordenable de una marca de tiempo RFC 3339 (las fracciones vienen con distinta cantidad de dígitos). */
+export function claveTiempo(iso) {
+  if (!iso) return '';
+  const m = /^(.*T\d\d:\d\d:\d\d)(?:\.(\d+))?Z$/.exec(iso);
+  if (!m) return new Date(iso).toISOString();
+  return `${m[1]}.${(m[2] || '').padEnd(9, '0').slice(0, 9)}Z`;
+}
+
+const MIME = {
+  '.md': 'text/markdown', '.txt': 'text/plain', '.json': 'application/json', '.csv': 'text/csv',
+  '.html': 'text/html', '.css': 'text/css', '.js': 'text/javascript', '.mjs': 'text/javascript',
+  '.ts': 'text/typescript', '.py': 'text/x-python', '.yml': 'text/yaml', '.yaml': 'text/yaml',
+  '.xml': 'application/xml', '.svg': 'image/svg+xml', '.sh': 'text/x-shellscript', '.sql': 'text/x-sql',
+};
+
+export class Lienzo {
+  /**
+   * @param {object} config  de cargarConfig()
+   * @param {{ fetch?: Function, raizArchivos?: string, abrir?: Function }} o  raizArchivos: carpeta de la que se
+   *   pueden compartir archivos (por defecto el directorio de trabajo del proceso); abrir: cómo se abre el navegador
+   */
+  constructor(config, { fetch: f, raizArchivos, abrir = abrirNavegador } = {}) {
+    this.config = config;
+    this.raizArchivos = raizArchivos ?? null;
+    this.abrir = abrir;
+    this.entrada = null; // login en curso: { promesa, url }
+    this.sesion = new Sesion(config, { fetch: f });
+    this.fs = new Firestore(config, this.sesion, { fetch: f });
+    this.salaId = null;
+    this.yo = null; // { id, nombre, dueño }
+    this.marca = null; // creadaEn más reciente ya entregada
+    this.marcaEdicion = null; // editadaEn más reciente ya entregada
+    this.uidEnSala = null; // con qué identidad se entró (si la sesión cambia, se empieza de nuevo)
+    this.intervaloEspera = INTERVALO_MS; // lo que lleva creciendo la espera de lienzo_esperar
+    this.participantes = new Map();
+    this.participantesEn = 0;
+    this.tareasPedidas = new Map(); // id → { estado, respuesta, tomadaPor }
+    this.tareasCargadas = false;
+    this.listas = new Set(); // ids de las listas que pediste (sus puntos llegan agrupados)
+    this.ultimoLatido = 0;
+    this.actividad = null; // lo último escrito en participantes.actividad ('esperando' | 'escribiendo' | null)
+    this.latidoFallo = null; // el error del último latido (null si anduvo)
+    // Salas de las que te sacaron (salaId → { uid, texto }): LIENZO_SALA no las vuelve a abrir sola. Cada marca lleva la
+    // cuenta a la que le pasó: si la sesión cambia de cuenta deja de valer.
+    this.salasPerdidas = new Map();
+    this.ultimaPerdida = null; // { uid, salaId, texto }: la última, para decir la causa cuando ya no hay sala
+  }
+
+  // ── utilidades ─────────────────────────────────────────────────────────────
+  /** La cuenta (la persona). */
+  get uid() { return this.sesion.uid; }
+
+  /** El participante de este agente en la sala: `{uid}_agente`. */
+  get participanteId() { return this.uid ? `${this.uid}_agente` : null; }
+
+  /** ¿Este participante es de mi cuenta (mi persona o yo, su agente)? Lo mismo que esMio() en las reglas. */
+  esMio(id) {
+    return Boolean(id) && (id === this.uid || id === this.participanteId);
+  }
+
+  link(salaId = this.salaId) {
+    return `${this.config.webUrl}/sala/${salaId}`;
+  }
+
+  /** Enlace directo a una tarjeta: la web abre la sala, centra el nodo, abre su hilo y la resalta. */
+  linkTarjeta(id, salaId = this.salaId) {
+    return `${this.link(salaId)}?t=${encodeURIComponent(id)}`;
+  }
+
+  _vigilarSecretos(textos) {
+    for (const [que, texto] of textos) {
+      if (!texto) continue;
+      const h = buscarSecretos(texto, { permitidas: [this.config.apiKey] });
+      if (h.length) throw new ErrorLienzo(explicarBloqueo(h, que));
+    }
+  }
+
+  _traducir(e, que) {
+    if (e instanceof ErrorSesion || e instanceof ErrorArchivo) return new ErrorLienzo(e.message);
+    if (e instanceof ErrorFirestore) {
+      // la causa viaja: el catch de cada herramienta decide si el permiso negado tiene una explicación (explicarNegado)
+      if (e.negado) return new ErrorLienzo(`Las reglas de la sala no permiten ${que}. (${e.message})`, { cause: e });
+      if (e.noExiste) return new ErrorLienzo(`No existe: ${que}.`, { cause: e });
+      if (e.yaExiste) return new ErrorLienzo(`Ya existe: ${que}.`, { cause: e });
+    }
+    return e;
+  }
+
+  async _asegurarSala() {
+    if (this.salaId && this.yo) {
+      // otra ventana con el mismo LIENZO_HOME pudo conectar otra cuenta: token() recarga sesion.json
+      await this.sesion.token().catch((e) => { throw this._traducir(e, 'iniciar sesión'); });
+      if (this.uidEnSala && this.uidEnSala !== this.uid) {
+        this._olvidarSala();
+        const quien = limpiarLinea(nombreDeCuenta(this.sesion.cuenta) || 'otra cuenta');
+        throw new ErrorLienzo(`La cuenta de Lienzo cambió en otra ventana (ahora ${quien}). Vuelve a unirte con lienzo_unirse.`);
+      }
+      return;
+    }
+    const { salaId } = this.config;
+    if (salaId) {
+      // te sacaron (o saliste) de esta sala: no se vuelve a entrar sola hasta un lienzo_unirse explícito
+      const perdida = this._perdida(salaId);
+      if (perdida) throw new ErrorLienzo(perdida.texto);
+      // unión automática con la sala configurada (sin sesión, se pide lienzo_entrar)
+      await this.unirse({ salaId });
+      return;
+    }
+    // te sacaron de la sala y todavía no entras a otra: la causa, no un genérico
+    if (this.ultimaPerdida?.uid === this.uid) throw new ErrorLienzo(this.ultimaPerdida.texto);
+    throw new ErrorLienzo(
+      'Todavía no estás en una sala. Usa lienzo_unirse(salaId) o crea una con lienzo_crear_sala.',
+    );
+  }
+
+  /**
+   * Latido: actualiza vistoEn como mucho cada 30 s. Lo llama cada herramienta.
+   * `actividad` (presencia, 20-10-2026): qué ve la web en el nodo del agente. 'esperando' al entrar a
+   * lienzo_esperar, 'escribiendo' cuando le llegó algo nuevo, null al publicar. Solo se escribe cuando
+   * cambia, en el mismo latido (una escritura): la web la da por vieja cuando vistoEn envejece.
+   */
+  async latido(forzar = false, actividad = undefined) {
+    if (!this.salaId || !this.yo) return;
+    const cambia = actividad !== undefined && actividad !== this.actividad;
+    if (!forzar && !cambia && Date.now() - this.ultimoLatido < LATIDO_MS) return;
+    this.ultimoLatido = Date.now();
+    this.latidoFallo = null;
+    try {
+      await this.fs.escribir(`salas/${this.salaId}/participantes/${this.participanteId}`, cambia ? { actividad } : {}, {
+        existe: true, mascara: cambia ? ['actividad'] : [], horaServidor: ['vistoEn'],
+      });
+      if (cambia) this.actividad = actividad;
+    } catch (e) {
+      console.error(`[lienzo] latido falló: ${e.message}`);
+      this.latidoFallo = e;
+      // Con reglas anteriores a `actividad` (despliegue a medias) el campo se rechaza: el latido no se pierde.
+      if (cambia) {
+        await this.fs.escribir(`salas/${this.salaId}/participantes/${this.participanteId}`, {}, {
+          existe: true, mascara: [], horaServidor: ['vistoEn'],
+        }).then(() => { this.latidoFallo = null; }, (e2) => { this.latidoFallo = e2; });
+      }
+    }
+  }
+
+  /**
+   * ¿El último latido se negó porque ya no eres miembro? El latido en sí se traga su error (no clasifica ni olvida
+   * nada); lienzo_esperar lo mira DESPUÉS para enterarse sin gastar una lectura: con el timbre callado (el servidor no
+   * siempre corta el listener cuando pierdes el acceso) es la única señal de que te sacaron. Devuelve el texto de
+   * explicarNegado o null (el latido anduvo, o falló por otra cosa).
+   */
+  async explicarLatido() {
+    const f = this.latidoFallo;
+    this.latidoFallo = null; // se mira una vez por latido
+    if (!f || !this.salaId || !(negadoDe(f) || (f instanceof ErrorFirestore && f.noExiste))) return null;
+    return this.explicarNegado(this.salaId).catch(() => null);
+  }
+
+  /**
+   * ¿Lo que trajo lienzo_esperar le toca a este agente? Algo dirigido a él (paraId) o un cambio en una tarea
+   * que pidió. Solo entonces la web muestra «Escribiendo…»: un mensaje a toda la sala no pone a todos los
+   * agentes a escribir.
+   */
+  meToca(lote) {
+    if (!lote) return false;
+    const mio = (t) => t.autorId !== this.participanteId && t.paraId === this.participanteId;
+    return (lote.cambios?.length ?? 0) > 0 || (lote.tarjetas ?? []).some(mio) || (lote.editadas ?? []).some(mio);
+  }
+
+  async _cargarParticipantes(forzar = false) {
+    if (!forzar && Date.now() - this.participantesEn < RECARGA_PARTICIPANTES_MS && this.participantes.size) return;
+    const lista = await this.fs.consultar(`salas/${this.salaId}`, {
+      from: [{ collectionId: 'participantes' }],
+      limit: 500,
+    });
+    this.participantes = new Map(lista.map((p) => [p.id, p]));
+    this.participantesEn = Date.now();
+  }
+
+  async _participante(id) {
+    if (!id) return null;
+    if (!this.participantes.has(id)) await this._cargarParticipantes(true);
+    return this.participantes.get(id) || null;
+  }
+
+  /** Cuántos participantes de la sala se llaman igual que `id` (1 = nombre único). */
+  _homonimos(id) {
+    const p = this.participantes.get(id);
+    if (!p) return 0;
+    const n = claveNombre(p.nombre);
+    return [...this.participantes.values()].filter((q) => claveNombre(q.nombre) === n).length;
+  }
+
+  /**
+   * Acepta un id de participante o su nombre exacto (sin importar mayúsculas). Con el nombre se mira
+   * la lista recién leída; si dos se llaman igual, NO se elige: se devuelve la lista de ids.
+   */
+  async _resolverParticipante(ref) {
+    if (!ref) return null;
+    ref = String(ref).trim();
+    await this._cargarParticipantes();
+    if (this.participantes.has(ref)) return ref;
+    await this._cargarParticipantes(true);
+    if (this.participantes.has(ref)) return ref;
+    const n = claveNombre(ref);
+    const porNombre = [...this.participantes.values()].filter((p) => claveNombre(p.nombre) === n);
+    if (porNombre.length === 1) return porNombre[0].id;
+    if (porNombre.length > 1) {
+      const lista = porNombre.map((p) => `- id: ${p.id}${p['dueño'] ? ` (dueño: ${limpiarLinea(p['dueño'])})` : ''}${p.id === this.participanteId ? ' (tú)' : ''}${p.id === this.uid ? ' (tu usuario)' : ''}`).join('\n');
+      throw new ErrorLienzo(`Hay ${porNombre.length} participantes llamados «${limpiarLinea(ref)}»; no elijo uno por ti. Usa el id:\n${lista}`);
+    }
+    throw new ErrorLienzo(`No encontré al participante «${limpiarLinea(ref)}» en la sala. Revisa lienzo_participantes.`);
+  }
+
+  // ── salas ──────────────────────────────────────────────────────────────────
+  async crearSala({ nombre, descripcion = '' }) {
+    nombre = String(nombre || '').trim();
+    if (!nombre) throw new ErrorLienzo('La sala necesita un nombre.');
+    if (nombre.length > 120) throw new ErrorLienzo('El nombre de la sala admite hasta 120 caracteres.');
+    if (String(descripcion).length > 2000) throw new ErrorLienzo('La descripción admite hasta 2000 caracteres.');
+    this._vigilarSecretos([['el nombre de la sala', nombre], ['la descripción', descripcion]]);
+    await this.sesion.token().catch((e) => { throw this._traducir(e, 'iniciar sesión'); });
+    const salaId = nuevoSalaId();
+    try {
+      // creadaPor es la cuenta (no el participante): así la persona renombra en la web la sala que creó su agente
+      await this.fs.escribir(`salas/${salaId}`, { nombre, descripcion, creadaPor: this.uid }, {
+        crear: true, horaServidor: ['creadaEn'],
+      });
+    } catch (e) {
+      throw this._traducir(e, 'crear la sala');
+    }
+    await this._anotarEnIndice(salaId);
+    return { salaId, link: this.link(salaId) };
+  }
+
+  /** usuarios/{uid}/salas/{salaId} = { vistaEn: hora del servidor }: «Mis salas» y la última sala de la persona. */
+  async _anotarEnIndice(salaId) {
+    try {
+      await this.fs.escribir(`usuarios/${this.uid}/salas/${salaId}`, {}, { horaServidor: ['vistaEn'] });
+    } catch (e) {
+      // ya entraste: sin el índice solo falta la sala en «Mis salas» (como en la web)
+      console.error(`[lienzo] no pude anotar la sala ${salaId} en tu lista de salas: ${e.message}`);
+    }
+  }
+
+  /**
+   * Entra a la sala como `{uid}_agente` (tipo agente, dueñoUid = la cuenta, dueño = el nombre de la cuenta).
+   * nombre: el que se pase, LIENZO_NOMBRE o «Agente de <primer nombre de la cuenta>».
+   */
+  async unirse({ salaId, nombre }) {
+    salaId = String(salaId || '').trim();
+    // aceptar también el link completo de la web
+    const m = /\/sala\/([A-Za-z0-9_-]{22})/.exec(salaId);
+    if (m) salaId = m[1];
+    if (!/^[A-Za-z0-9_-]{22}$/.test(salaId)) throw new ErrorLienzo('El salaId tiene 22 caracteres (letras, números, - y _). Revisa el que te pasaron.');
+
+    await this.sesion.token().catch((e) => { throw this._traducir(e, 'iniciar sesión'); });
+    const cuenta = this.sesion.cuenta;
+    const dueño = nombreDeCuenta(cuenta);
+    nombre = String(nombre || this.config.nombre || nombreAgentePorDefecto(cuenta) || '').trim();
+    if (!nombre) throw new ErrorLienzo('Falta tu nombre en la sala (p. ej. «Agente de Ana»): pásalo en nombre.');
+    if (nombre.length > 80) throw new ErrorLienzo('El nombre admite hasta 80 caracteres.');
+    if (/[\p{Cc}\p{Cf}\u2028\u2029]/u.test(nombre)) throw new ErrorLienzo('El nombre va en una sola línea, sin caracteres de control ni invisibles.');
+    this._vigilarSecretos([['tu nombre', nombre]]);
+
+    const sala = await this.fs.leer(`salas/${salaId}`).catch((e) => { throw this._traducir(e, 'leer la sala'); });
+    if (!sala) throw new ErrorLienzo('Esa sala no existe. Revisa el salaId.');
+    // borrada: las reglas ya no dejan escribir ahí; se avisa sin tocar nada
+    if (sala.borradaEn) {
+      await this._sacadaDe(salaId, TEXTO_BORRADA);
+      throw new ErrorLienzo(TEXTO_BORRADA);
+    }
+
+    const ruta = `salas/${salaId}/participantes/${this.participanteId}`;
+    const previo = await this.fs.leer(ruta).catch(() => null);
+    const datos = {
+      nombre, tipo: 'agente', 'dueño': dueño, 'dueñoUid': this.uid, cliente: this.config.cliente,
+      posicion: previo?.posicion ?? null,
+    };
+    let commit;
+    try {
+      if (previo) {
+        datos.conectadoEn = previo.conectadoEn ? marcaDeTiempo(previo.conectadoEn) : null;
+        commit = await this.fs.escribir(ruta, datos, { horaServidor: previo.conectadoEn ? ['vistoEn'] : ['vistoEn', 'conectadoEn'] });
+      } else {
+        commit = await this.fs.escribir(ruta, datos, { horaServidor: ['conectadoEn', 'vistoEn'] });
+      }
+    } catch (e) {
+      const texto = negadoDe(e) ? await this.explicarNegado(salaId, { alUnirse: true }).catch(() => null) : null;
+      throw texto ? new ErrorLienzo(texto, { cause: e }) : this._traducir(e, 'unirte a la sala');
+    }
+
+    this.salasPerdidas.delete(salaId); // un lienzo_unirse explícito vuelve a abrir la sala
+    this.ultimaPerdida = null;
+    const cambioDeSala = this.salaId !== salaId || this.uidEnSala !== this.uid;
+    this.salaId = salaId;
+    this.uidEnSala = this.uid;
+    this.actividad = null; // unirse reescribe el participante entero (sin actividad)
+    this.yo = { id: this.participanteId, nombre, 'dueño': dueño };
+    this.ultimoLatido = Date.now();
+    if (cambioDeSala) {
+      this.marca = commit; // las novedades se cuentan desde que entraste
+      this.marcaEdicion = commit;
+      this.intervaloEspera = INTERVALO_MS;
+      this.tareasPedidas.clear();
+      this.tareasCargadas = false;
+      this.listas.clear();
+      this.participantes.clear();
+      this.participantesEn = 0;
+    }
+    await this._anotarEnIndice(salaId);
+    return { salaId, sala, link: this.link(salaId), yo: this.yo };
+  }
+
+  // ── cuenta ─────────────────────────────────────────────────────────────────
+  /** Olvida la sala (la sesión pasó a otra cuenta: lo de la sala era de la anterior). */
+  _olvidarSala() {
+    this.salaId = null;
+    this.yo = null;
+    this.uidEnSala = null;
+  }
+
+  /**
+   * Te sacaron de `salaId` (o saliste, o se borró): si es la sala en la que estabas, se olvida (y se cierra su
+   * timbre, que ya no tiene permiso) y se anota para que LIENZO_SALA no la reabra sola.
+   */
+  async _sacadaDe(salaId, texto) {
+    // la marca va primero: cerrar el timbre despierta a un lienzo_esperar que ya mira la sala, y tiene que ver la causa
+    const marca = { uid: this.uid, texto };
+    this.salasPerdidas.set(salaId, marca);
+    this.ultimaPerdida = { ...marca, salaId };
+    if (this.salaId === salaId) {
+      this._olvidarSala();
+      await cerrarTimbre(this).catch(() => undefined);
+    }
+  }
+
+  /** La marca de una sala perdida, si es de la cuenta de ahora; la de otra cuenta se descarta. */
+  _perdida(salaId) {
+    const m = this.salasPerdidas.get(salaId);
+    if (m && m.uid !== this.uid) { this.salasPerdidas.delete(salaId); return null; }
+    return m ?? null;
+  }
+
+  /** Tras conectar otra cuenta: lo que le pasó a la anterior no es de la nueva. */
+  _soltarPerdidasAjenas() {
+    for (const [id, m] of this.salasPerdidas) if (m.uid !== this.uid) this.salasPerdidas.delete(id);
+    if (this.ultimaPerdida && this.ultimaPerdida.uid !== this.uid) this.ultimaPerdida = null;
+  }
+
+  /**
+   * Un permiso negado en `salaId`: ¿por qué? Devuelve el texto para el agente, o null si no se sabe (la
+   * negativa viene de otra cosa, p. ej. el contenido de una tarjeta, o las lecturas fallaron por red: se queda el
+   * mensaje original). Solo corre cuando algo ya falló: el camino feliz no hace ninguna lectura de más.
+   *  1. estás en `expulsados` → te quitaron (borra tu índice, como la web)
+   *  2. la sala tiene `borradaEn` → se borró
+   *  3. tu participante `{uid}_agente` no existe o no se deja leer → saliste (no aplica al unirse: ahí no eres miembro todavía)
+   *  4. sigues siendo miembro → null
+   * Con 1 a 3 se olvida la sala.
+   */
+  async explicarNegado(salaId, { alUnirse = false } = {}) {
+    if (!salaId || !this.uid) return null;
+    const leer = (ruta) => this.fs.leer(ruta).then((doc) => ({ doc }), (error) => ({ error }));
+    const [exp, sala, yo] = await Promise.all([
+      leer(`salas/${salaId}/expulsados/${this.uid}`),
+      leer(`salas/${salaId}`),
+      alUnirse ? null : leer(`salas/${salaId}/participantes/${this.participanteId}`),
+    ]);
+    if (exp.error || sala.error || !sala.doc) return null; // sin red (o sin sala) no se adivina
+    if (exp.doc) {
+      await this.fs.borrar(`usuarios/${this.uid}/salas/${salaId}`).catch(() => undefined);
+      await this._sacadaDe(salaId, TEXTO_QUITADO);
+      return TEXTO_QUITADO;
+    }
+    if (sala.doc.borradaEn) {
+      await this._sacadaDe(salaId, TEXTO_BORRADA);
+      return TEXTO_BORRADA;
+    }
+    if (!yo) return null;
+    if (yo.error ? Boolean(negadoDe(yo.error)) : !yo.doc) {
+      const texto = textoSaliste(salaId);
+      await this._sacadaDe(salaId, texto);
+      return texto;
+    }
+    return null;
+  }
+
+  /**
+   * lienzo_entrar. Con una sesión que sigue valiendo no abre nada (salvo otraCuenta). Si no, abre el navegador y
+   * espera hasta `esperaMs` (3 min); al vencer o cancelarse, el servidor local se cierra. La URL (lleva el nonce)
+   * va solo a stderr: nunca vuelve al modelo. Una segunda llamada mientras tanto reusa el mismo login (no abre otra
+   * ventana). Si quedó conectada otra cuenta, se olvida la sala en la que estaba (no se une sola a la nueva).
+   * Devuelve { estado: 'ya' | 'listo' | 'vencido', cuenta?, salaOlvidada? }.
+   */
+  async entrar({ otraCuenta = false, esperaMs = ENTRAR_TIMEOUT_MS, signal, alAbrir } = {}) {
+    if (!otraCuenta && !this.entrada && this.sesion.cuenta) {
+      try {
+        await this.sesion.token();
+        return { estado: 'ya', cuenta: this.sesion.cuenta };
+      } catch (e) {
+        if (!(e instanceof ErrorSesion)) throw e; // red: no se abre el navegador por un corte
+      }
+    }
+    if (!this.entrada) {
+      const entrada = this.sesion.entrar({ abrir: this.abrir, timeoutMs: esperaMs, signal, onListening: () => alAbrir?.() })
+        .then((cuenta) => {
+          this._soltarPerdidasAjenas();
+          const salaOlvidada = Boolean(this.uidEnSala && this.uidEnSala !== this.uid);
+          if (salaOlvidada) this._olvidarSala();
+          return { cuenta, salaOlvidada };
+        })
+        .finally(() => { if (this.entrada === entrada) this.entrada = null; });
+      this.entrada = entrada;
+    }
+    try {
+      const { cuenta, salaOlvidada } = await this.entrada;
+      // con otraCuenta no se sigue en la sala anterior ni aunque se eligiera la misma cuenta: se entra a propósito
+      if (otraCuenta && this.salaId) { this._olvidarSala(); return { estado: 'listo', cuenta, salaOlvidada: true }; }
+      return { estado: 'listo', cuenta, salaOlvidada };
+    } catch (e) {
+      if (e instanceof ErrorSesion && e.codigo === 'vencido') return { estado: 'vencido' };
+      throw this._traducir(e, 'conectar tu cuenta');
+    }
+  }
+
+  // ── participantes ─────────────────────────────────────────────────────────
+  async listarParticipantes() {
+    await this._asegurarSala();
+    await this.latido();
+    await this._cargarParticipantes(true);
+    const ahora = Date.now();
+    return [...this.participantes.values()].map((p) => ({
+      ...p,
+      conectado: p.vistoEn ? ahora - Date.parse(p.vistoEn) < CONECTADO_MS : false,
+      soyYo: p.id === this.participanteId,
+      miPersona: p.id === this.uid,
+      homonimos: this._homonimos(p.id),
+    }));
+  }
+
+  // ── tarjetas ───────────────────────────────────────────────────────────────
+  _tarjetaCompleta(datos) {
+    return {
+      tipo: 'mensaje', autorId: this.participanteId, texto: '', archivo: null, respondeA: null, paraId: null,
+      estado: null, tomadaPor: null, respuesta: null, editadaEn: null, posicion: null, marcoId: null,
+      ...datos,
+    };
+  }
+
+  async _crearTarjeta(datos) {
+    const id = nuevoId();
+    try {
+      await this.fs.escribir(`salas/${this.salaId}/tarjetas/${id}`, this._tarjetaCompleta(datos), { crear: true, horaServidor: ['creadaEn'] });
+    } catch (e) {
+      throw this._traducir(e, 'publicar la tarjeta');
+    }
+    this.intervaloEspera = INTERVALO_MS; // acabas de escribir: la respuesta puede llegar pronto
+    return id;
+  }
+
+  _validarTexto(texto, que = 'el texto') {
+    texto = String(texto ?? '');
+    if (!texto.trim()) throw new ErrorLienzo(`Falta ${que}.`);
+    if (texto.length > MAX_TEXTO) throw new ErrorLienzo(`${que} admite hasta ${MAX_TEXTO} caracteres (tiene ${texto.length}).`);
+    return texto;
+  }
+
+  async publicar({ texto, paraId = null, respondeA = null, tipo = 'mensaje' }) {
+    await this._asegurarSala();
+    if (!['mensaje', 'nota'].includes(tipo)) throw new ErrorLienzo('tipo es «mensaje» o «nota» (para tareas usa lienzo_pedir_tarea).');
+    texto = this._validarTexto(texto);
+    this._vigilarSecretos([['el texto', texto]]);
+    const para = await this._resolverParticipante(paraId);
+    if (respondeA && !ID_TARJETA.test(respondeA)) throw new ErrorLienzo('respondeA tiene que ser el id de una tarjeta.');
+    const id = await this._crearTarjeta({ tipo, texto, paraId: para, respondeA: respondeA || null });
+    await this.latido();
+    return { id, paraId: para, link: this.linkTarjeta(id) };
+  }
+
+  async compartirArchivo({ ruta, contenido, nombre, texto, paraId = null }) {
+    await this._asegurarSala();
+    if (!ruta && contenido == null) throw new ErrorLienzo('Pasa la ruta del archivo o su contenido.');
+    let bytes;
+    if (ruta) {
+      let real;
+      let st;
+      try {
+        ({ real, st } = rutaCompartible(ruta, this.raizArchivos ?? process.cwd()));
+      } catch (e) {
+        throw this._traducir(e, 'compartir el archivo');
+      }
+      if (st.size > MAX_ARCHIVO_BYTES) throw new ErrorLienzo(`El archivo pesa ${st.size} bytes; el tope es ${MAX_ARCHIVO_BYTES} (200 KB).`);
+      const buf = readFileSync(real);
+      if (buf.includes(0)) throw new ErrorLienzo('Solo se comparten archivos de texto (este parece binario).');
+      try {
+        contenido = new TextDecoder('utf-8', { fatal: true }).decode(buf);
+      } catch {
+        throw new ErrorLienzo('Solo se comparten archivos de texto en UTF-8.');
+      }
+      nombre = nombre || basename(real);
+      bytes = buf.length;
+    } else {
+      contenido = String(contenido);
+      bytes = Buffer.byteLength(contenido, 'utf8');
+      if (contenido.includes('\u0000')) throw new ErrorLienzo('Solo se comparte texto.');
+    }
+    nombre = String(nombre || '').trim();
+    if (!nombre) throw new ErrorLienzo('Falta el nombre del archivo.');
+    if (nombre.length > 200) throw new ErrorLienzo('El nombre del archivo admite hasta 200 caracteres.');
+    try { revisarNombre(limpiarLinea(nombre, 200)); } catch (e) { throw this._traducir(e, 'compartir el archivo'); }
+    if (bytes > MAX_ARCHIVO_BYTES) throw new ErrorLienzo(`El contenido pesa ${bytes} bytes; el tope es ${MAX_ARCHIVO_BYTES} (200 KB).`);
+    texto = texto ? this._validarTexto(texto) : `Archivo: ${nombre}`;
+    this._vigilarSecretos([['el archivo', contenido], ['el texto', texto], ['el nombre del archivo', nombre]]);
+    const para = await this._resolverParticipante(paraId);
+    const mime = MIME[extname(nombre).toLowerCase()] || 'text/plain';
+    const id = await this._crearTarjeta({ tipo: 'archivo', texto, paraId: para, archivo: { nombre, mime, bytes, contenido } });
+    await this.latido();
+    return { id, nombre, bytes, mime, link: this.linkTarjeta(id) };
+  }
+
+  async pedirTarea({ texto, paraId }) {
+    await this._asegurarSala();
+    if (!paraId) throw new ErrorLienzo('Una tarea necesita destinatario (paraId): mira lienzo_participantes.');
+    texto = this._validarTexto(texto);
+    this._vigilarSecretos([['el texto', texto]]);
+    const para = await this._resolverParticipante(paraId);
+    const id = await this._crearTarjeta({ tipo: 'tarea', texto, paraId: para, estado: 'abierta' });
+    this.tareasPedidas.set(id, { estado: 'abierta', respuesta: null, tomadaPor: null });
+    await this.latido();
+    return { id, paraId: para, link: this.linkTarjeta(id) };
+  }
+
+  /**
+   * lienzo_pedir_lista: una lista de puntos para el mismo destinatario, en UN :commit (la lista y sus
+   * puntos nacen juntos o no nace nada). La lista es una tarea; cada punto, una tarea hija con
+   * respondeA = la lista, el mismo paraId e id «<lista>-pNN» (ordenan por id).
+   */
+  async pedirLista({ titulo, contexto = '', puntos, paraId }) {
+    await this._asegurarSala();
+    titulo = String(titulo ?? '').trim();
+    if (!titulo) throw new ErrorLienzo('La lista necesita un título.');
+    if (titulo.length > MAX_TITULO_LISTA) throw new ErrorLienzo(`El título admite hasta ${MAX_TITULO_LISTA} caracteres.`);
+    if (/[\r\n\u2028\u2029]/.test(titulo)) throw new ErrorLienzo('El título va en una sola línea (el detalle va en contexto).');
+    contexto = String(contexto ?? '').trim();
+    if (contexto.length > MAX_CONTEXTO_LISTA) throw new ErrorLienzo(`El contexto admite hasta ${MAX_CONTEXTO_LISTA} caracteres (tiene ${contexto.length}). Si es más, compártelo como archivo.`);
+    if (!Array.isArray(puntos) || !puntos.length) throw new ErrorLienzo('La lista necesita al menos un punto.');
+    if (puntos.length > MAX_PUNTOS) throw new ErrorLienzo(`Una lista admite hasta ${MAX_PUNTOS} puntos (tiene ${puntos.length}). Más que eso es un documento: compártelo como archivo.`);
+    puntos = puntos.map((p, i) => {
+      const t = String(p ?? '').trim();
+      if (!t) throw new ErrorLienzo(`El punto ${i + 1} está vacío.`);
+      if (t.length > MAX_PUNTO) throw new ErrorLienzo(`El punto ${i + 1} admite hasta ${MAX_PUNTO} caracteres (tiene ${t.length}).`);
+      return t;
+    });
+    if (!paraId) throw new ErrorLienzo('Una lista necesita destinatario (paraId): mira lienzo_participantes.');
+    this._vigilarSecretos([['el título', titulo], ['el contexto', contexto], ...puntos.map((p, i) => [`el punto ${i + 1}`, p])]);
+    const para = await this._resolverParticipante(paraId);
+
+    const id = nuevoId();
+    const ids = puntos.map((_, i) => idPunto(id, i + 1));
+    const base = { tipo: 'tarea', paraId: para, estado: 'abierta' };
+    const crear = { crear: true, horaServidor: ['creadaEn'] };
+    const ruta = (x) => `salas/${this.salaId}/tarjetas/${x}`;
+    try {
+      await this.fs.escribirVarios([
+        { ruta: ruta(id), datos: this._tarjetaCompleta({ ...base, texto: contexto ? `${titulo}\n\n${contexto}` : titulo }), opciones: crear },
+        ...puntos.map((texto, i) => ({ ruta: ruta(ids[i]), datos: this._tarjetaCompleta({ ...base, texto, respondeA: id }), opciones: crear })),
+      ]);
+    } catch (e) {
+      throw this._traducir(e, 'publicar la lista');
+    }
+    this.listas.add(id);
+    for (const x of [id, ...ids]) this.tareasPedidas.set(x, { estado: 'abierta', respuesta: null, tomadaPor: null });
+    this.intervaloEspera = INTERVALO_MS;
+    await this.latido();
+    return { id, paraId: para, ids, link: this.linkTarjeta(id) };
+  }
+
+  /** Qué escribe un cambio de estado en una tarea, según quién eres en ella. Lanza ErrorLienzo con `que`. */
+  _planTarea(t, { estado, respuesta }, { que, maxRespuesta = MAX_TEXTO, derivada = false }) {
+    if (t.tipo !== 'tarea') throw new ErrorLienzo(`${que} no es una tarea.`);
+    // «De mi cuenta»: una tarea para mi persona la puede tomar su agente (a nombre del agente), y una que pidió mi
+    // persona la puedo reabrir o cerrar yo (las reglas miran la cuenta, no el participante).
+    const soyDestinatario = this.esMio(t.paraId);
+    const soyAutor = this.esMio(t.autorId);
+    if (!soyDestinatario && !soyAutor) {
+      throw new ErrorLienzo(`${que}: solo su destinatario o quien la pidió pueden cambiar su estado.`);
+    }
+    const cambios = { estado };
+    const mascara = ['estado'];
+    const tomadaPor = (v) => { cambios.tomadaPor = v; mascara.push('tomadaPor'); };
+    if (soyDestinatario) {
+      if (estado === 'abierta') tomadaPor(null);
+      else if (estado === 'tomada' || !t.tomadaPor) tomadaPor(this.participanteId); // quien firma un estado es quien la atiende
+      if (!derivada && (estado === 'esperando' || estado === 'no_aplica') && !String(respuesta ?? '').trim()) {
+        throw new ErrorLienzo(estado === 'esperando'
+          ? `${que}: con «esperando» va la pregunta concreta que le haces a tu usuario, en respuesta.`
+          : `${que}: con «no_aplica» va el porqué, en respuesta.`);
+      }
+      if (respuesta != null) {
+        const r = this._validarTexto(respuesta, `la respuesta (${que})`);
+        if (r.length > maxRespuesta) throw new ErrorLienzo(`${que}: la respuesta admite hasta ${maxRespuesta} caracteres${maxRespuesta === MAX_RESPUESTA_LOTE ? ' en un punto de lista' : ''} (tiene ${r.length}).`);
+        this._vigilarSecretos([[`la respuesta (${que})`, r]]);
+        cambios.respuesta = r;
+        mascara.push('respuesta');
+      }
+    } else {
+      // Quien pidió la tarea no firma por el destinatario (las reglas tampoco lo dejan).
+      if (estado === 'tomada') throw new ErrorLienzo(`${que}: solo el destinatario toma una tarea. Como quien la pidió puedes reabrirla («abierta») o cerrarla («hecha»).`);
+      if (estado === 'esperando' || estado === 'no_aplica') throw new ErrorLienzo(`${que}: «${estado}» lo pone quien responde, no quien la pidió. Tú puedes reabrirla («abierta») o cerrarla («hecha»).`);
+      if (respuesta != null) throw new ErrorLienzo(`${que}: la respuesta la escribe el destinatario. Si quieres comentar algo, publica un mensaje con respondeA = id de la tarea.`);
+      if (estado === 'abierta' && t.tomadaPor) tomadaPor(null);
+    }
+    return { cambios, mascara, soyAutor, soyDestinatario };
+  }
+
+  /**
+   * lienzo_tarea: una tarea ({ id, estado, respuesta? }) o varias en UN :commit ({ puntos: [...] }).
+   * Atómico: si un punto no pasa, no se escribe ninguno y el error dice cuál. Si respondes puntos de una
+   * lista que es para ti, el estado de la lista se deriva en el mismo commit (todos cerrados → hecha).
+   */
+  async tarea({ id, estado, respuesta, puntos } = {}) {
+    await this._asegurarSala();
+    const enLote = puntos != null;
+    if (enLote && id != null) throw new ErrorLienzo('Pasa id (una tarea) o puntos (varias), no los dos.');
+    const items = enLote ? puntos : [{ id, estado, respuesta }];
+    if (!Array.isArray(items) || !items.length) throw new ErrorLienzo('puntos tiene que traer al menos un { id, estado, respuesta? }.');
+    if (items.length > MAX_PUNTOS) throw new ErrorLienzo(`Un lote admite hasta ${MAX_PUNTOS} cambios (trae ${items.length}).`);
+    const vistos = new Set();
+    const pedidos = items.map((it, i) => {
+      const x = String(it?.id ?? '').trim();
+      const que = enLote ? `el cambio ${i + 1} (id ${limpiarLinea(x, 64) || '?'})` : `la tarea ${limpiarLinea(x, 64)}`;
+      if (!ID_TARJETA.test(x)) throw new ErrorLienzo(`${enLote ? que : 'id'}: tiene que ser el id de una tarjeta (letras, números, - y _, hasta 64).`);
+      if (vistos.has(x)) throw new ErrorLienzo(`${que} está repetido en el lote.`);
+      vistos.add(x);
+      if (!ESTADOS.includes(it.estado)) throw new ErrorLienzo(`${que}: estado es ${ESTADOS.map((e) => `«${e}»`).join(', ')}.`);
+      return { id: x, estado: it.estado, respuesta: it.respuesta ?? null, que };
+    });
+    const ruta = (x) => `salas/${this.salaId}/tarjetas/${x}`;
+    const docs = await this.fs.leerVarios(pedidos.map((p) => ruta(p.id))).catch((e) => { throw this._traducir(e, 'leer las tareas'); });
+    const porId = new Map(docs.map((d) => [d.id, d]));
+    const planes = pedidos.map((p) => {
+      const t = porId.get(p.id);
+      if (!t) throw new ErrorLienzo(`No existe la tarjeta ${limpiarLinea(p.id, 64)}${enLote ? ` (${p.que})` : ''}. No se escribió nada.`);
+      const n = numeroPunto(p.id);
+      const esUnPunto = Boolean(n && t.respondeA && p.id.startsWith(`${t.respondeA}-p`));
+      const que = enLote && esUnPunto ? `el punto ${n} (${limpiarLinea(p.id, 64)})` : p.que;
+      // un punto se responde corto también de a uno: así la lista entera cabe en una respuesta
+      return { t, ...this._planTarea(t, p, { que, maxRespuesta: enLote || esUnPunto ? MAX_RESPUESTA_LOTE : MAX_TEXTO }) };
+    });
+
+    // Listas que tocas como destinatario: su estado se deriva de TODOS sus puntos, en el mismo commit.
+    const padres = [];
+    const listasTocadas = [...new Set(planes.filter((p) => p.t.respondeA).map((p) => p.t.respondeA))]
+      .filter((lid) => !porId.has(lid)); // si la lista viene en el lote, manda lo que pediste
+    for (const lid of listasTocadas) {
+      const padre = await this.fs.leer(ruta(lid)).catch((e) => { throw this._traducir(e, 'leer la lista'); });
+      if (!padre || !planes.some((p) => esPunto(p.t, padre))) continue;
+      const hermanos = (await this._puntosDe(padre)).map((h) => {
+        const plan = planes.find((p) => p.t.id === h.id);
+        return plan ? plan.cambios.estado : h.estado;
+      });
+      if (!hermanos.length) continue;
+      let estadoLista = estadoDeLista(hermanos);
+      if (!this.esMio(padre.paraId)) {
+        // quien pidió la lista solo la cierra (todos cerrados) o la reabre (si estaba cerrada y reabrió un punto)
+        if (!this.esMio(padre.autorId)) continue;
+        estadoLista = estadoLista === 'hecha' ? 'hecha' : (padre.estado === 'hecha' ? 'abierta' : padre.estado);
+      }
+      if (estadoLista === padre.estado) continue;
+      padres.push({ t: padre, ...this._planTarea(padre, { estado: estadoLista, respuesta: null }, { que: `la lista ${lid}`, derivada: true }) });
+    }
+
+    const todos = [...planes, ...padres];
+    try {
+      await this.fs.escribirVarios(todos.map((p) => ({ ruta: ruta(p.t.id), datos: p.cambios, opciones: { existe: true, mascara: p.mascara } })));
+    } catch (e) {
+      const err = this._traducir(e, enLote ? 'aplicar ese lote (no se escribió ninguno)' : 'cambiar el estado de esa tarea');
+      throw err;
+    }
+    for (const p of todos) {
+      // lo que cambiaste tú no vuelve como novedad
+      if (p.soyAutor && this.tareasPedidas.has(p.t.id)) this._confirmarCambio({ ...p.t, ...p.cambios });
+    }
+    this.intervaloEspera = INTERVALO_MS;
+    await this.latido();
+    const escritos = planes.map((p) => ({ id: p.t.id, ...p.cambios }));
+    const listas = padres.map((p) => ({ id: p.t.id, antes: p.t.estado, estado: p.cambios.estado }));
+    return enLote ? { escritos, listas } : { ...escritos[0], listas };
+  }
+
+  /** Los puntos de una lista (solo los válidos según esPunto), ordenados por id. */
+  async _puntosDe(padre, { signal } = {}) {
+    if (padre?.tipo !== 'tarea' || padre.respondeA || !padre.autorId || !padre.paraId) return [];
+    // Filtra por autor EN la consulta: un tercero no puede firmar como el autor (reglas), así que no puede
+    // llenar el límite con hijas coladas y esconder puntos reales. Dos igualdades: Firestore las resuelve
+    // juntando los índices de un campo, sin índice compuesto. El resto del filtro (esPunto), después.
+    const hijas = await this.fs.consultar(`salas/${this.salaId}`, {
+      from: [{ collectionId: 'tarjetas' }],
+      where: y(filtro('respondeA', 'EQUAL', padre.id), filtro('autorId', 'EQUAL', padre.autorId)),
+      limit: 100,
+    }, { signal });
+    return hijas.filter((h) => esPunto(h, padre)).sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+  }
+
+  // ── lectura y novedades ───────────────────────────────────────────────────
+  _avanzarMarca(iso) {
+    if (iso && claveTiempo(iso) > claveTiempo(this.marca)) this.marca = iso;
+  }
+
+  _avanzarEdicion(iso) {
+    if (iso && claveTiempo(iso) > claveTiempo(this.marcaEdicion)) this.marcaEdicion = iso;
+  }
+
+  async _tarjetasDesde(desde, { limite = LIMITE_CONSULTA, signal } = {}) {
+    const consulta = {
+      from: [{ collectionId: 'tarjetas' }],
+      orderBy: [{ field: { fieldPath: 'creadaEn' }, direction: desde ? 'ASCENDING' : 'DESCENDING' }],
+      limit: limite,
+    };
+    if (desde) consulta.where = filtro('creadaEn', 'GREATER_THAN', marcaDeTiempo(desde));
+    let lista = await this.fs.consultar(`salas/${this.salaId}`, consulta, { signal });
+    if (!desde) lista.reverse();
+    const lleno = lista.length >= limite;
+    // Una lista nace en un solo :commit (lista + puntos con la MISMA creadaEn). Si el tope corta ese
+    // grupo, la marca saltaría los que quedaron fuera (la próxima consulta es «creadaEn > marca»).
+    // Así que nunca se corta dentro de un grupo: el del borde se deja para la próxima lectura.
+    if (lleno) lista = quitarGrupo(lista, { alFinal: Boolean(desde) });
+    lista.lleno = lleno;
+    return lista;
+  }
+
+  /** Tarjetas editadas después de `desde` (editadaEn es la hora del servidor: lo exigen las reglas). */
+  async _editadasDesde(desde, { signal } = {}) {
+    if (!desde) return [];
+    return this.fs.consultar(`salas/${this.salaId}`, {
+      from: [{ collectionId: 'tarjetas' }],
+      where: filtro('editadaEn', 'GREATER_THAN', marcaDeTiempo(desde)),
+      orderBy: [{ field: { fieldPath: 'editadaEn' }, direction: 'ASCENDING' }],
+      limit: LIMITE_CONSULTA,
+    }, { signal });
+  }
+
+  async _cargarMisTareas(signal) {
+    if (this.tareasCargadas) return;
+    const mias = await this.fs.consultar(`salas/${this.salaId}`, {
+      from: [{ collectionId: 'tarjetas' }],
+      where: y(filtro('autorId', 'EQUAL', this.participanteId)),
+      limit: 200,
+    }, { signal });
+    this.tareasCargadas = true;
+    for (const t of mias) {
+      if (t.tipo === 'tarea' && t.respondeA && numeroPunto(t.id) && t.id.startsWith(`${t.respondeA}-p`)) this.listas.add(t.respondeA);
+      if (t.tipo === 'tarea' && !CERRADOS.has(t.estado) && !this.tareasPedidas.has(t.id)) {
+        this.tareasPedidas.set(t.id, { estado: t.estado, respuesta: t.respuesta, tomadaPor: t.tomadaPor });
+      }
+    }
+  }
+
+  /** Tareas que pediste y cambiaron. No las marca como vistas: eso pasa recién al entregarlas (formatearLote). */
+  async _cambiosEnMisTareas(signal) {
+    await this._cargarMisTareas(signal);
+    const ids = [...this.tareasPedidas.keys()];
+    if (!ids.length) return [];
+    const docs = await this.fs.leerVarios(ids.map((id) => `salas/${this.salaId}/tarjetas/${id}`), { signal });
+    return docs.filter((t) => {
+      const antes = this.tareasPedidas.get(t.id);
+      return antes && (t.estado !== antes.estado || t.respuesta !== antes.respuesta || t.tomadaPor !== antes.tomadaPor);
+    });
+  }
+
+  _confirmarCambio(t) {
+    if (CERRADOS.has(t.estado)) this.tareasPedidas.delete(t.id); // «esperando» se sigue mirando: todavía cambia
+    else this.tareasPedidas.set(t.id, { estado: t.estado, respuesta: t.respuesta ?? null, tomadaPor: t.tomadaPor ?? null });
+  }
+
+  /** lienzo_leer: una tarjeta completa (id), o las tarjetas desde una marca (o las últimas 50), con ediciones y cambios en tus tareas. */
+  async leer({ desde, id, desdeCaracter = 0 } = {}) {
+    await this._asegurarSala();
+    await this.latido();
+    if (id != null && id !== '') {
+      id = String(id).trim();
+      if (!ID_TARJETA.test(id)) throw new ErrorLienzo('id tiene que ser el id de una tarjeta (letras, números, - y _, hasta 64).');
+      const t = await this.fs.leer(`salas/${this.salaId}/tarjetas/${id}`).catch((e) => { throw this._traducir(e, 'leer esa tarjeta'); });
+      if (!t) throw new ErrorLienzo(`No existe la tarjeta ${id}.`);
+      // una lista se lee entera, con sus puntos
+      const puntos = t.tipo === 'tarea' && !t.respondeA ? await this._puntosDe(t) : [];
+      if (puntos.length) return { lista: { padre: t, puntos } };
+      return { una: t, desdeCaracter: Math.max(0, Number(desdeCaracter) || 0) };
+    }
+    let marcaDesde = desde ?? null;
+    if (marcaDesde) {
+      const d = new Date(marcaDesde);
+      if (Number.isNaN(d.getTime())) throw new ErrorLienzo('desde tiene que ser una fecha ISO 8601 (p. ej. 2026-10-20T15:00:00Z).');
+      marcaDesde = /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(\.\d+)?Z$/.test(marcaDesde) ? marcaDesde : d.toISOString();
+    }
+    const tarjetas = await this._tarjetasDesde(marcaDesde);
+    const editadas = await this._editadasDesde(marcaDesde);
+    const cambios = await this._cambiosEnMisTareas();
+    return { tarjetas, editadas, cambios, desde: marcaDesde, lleno: Boolean(tarjetas.lleno) };
+  }
+
+  /** Para lienzo_esperar: tarjetas y ediciones ajenas y cambios en tus tareas; null si no hay nada ajeno. */
+  async novedades({ signal } = {}) {
+    await this._asegurarSala();
+    const tarjetas = this.marca
+      ? await this._tarjetasDesde(this.marca, { signal })
+      : await this._tarjetasDesde(null, { signal }); // tope ≥ 32: un grupo de lista (≤ 31) nunca llena la consulta solo
+    const editadas = await this._editadasDesde(this.marcaEdicion ?? this.marca, { signal });
+    const cambios = await this._cambiosEnMisTareas(signal);
+    // lo que publica tu persona desde la web sí es novedad para ti (no lo escribiste tú)
+    const ajena = (t) => t.autorId !== this.participanteId;
+    if (!tarjetas.some(ajena) && !editadas.some(ajena) && !cambios.length) {
+      // solo había lo tuyo: se da por visto para no volver a pedirlo
+      for (const t of tarjetas) this._avanzarMarca(t.creadaEn);
+      for (const t of editadas) this._avanzarEdicion(t.editadaEn);
+      return null;
+    }
+    return { tarjetas, editadas, cambios, soloAjenas: true, lleno: Boolean(tarjetas.lleno) };
+  }
+
+  // ── formato de salida ─────────────────────────────────────────────────────
+  async _autor(id) {
+    const p = id ? await this._participante(id).catch(() => null) : null;
+    if (!p) return { id, nombre: `participante ${abreviarId(id || '?')}`, tipo: 'participante', 'dueño': null, homonimos: 0 };
+    return { ...p, homonimos: this._homonimos(id) };
+  }
+
+  /** «Nombre (id: abc12345…)», limpio y en una línea: para metadatos que van DENTRO de un sobre. */
+  async _describir(id) {
+    if (id === this.participanteId) return 'ti';
+    const p = await this._autor(id);
+    return `${limpiarLinea(p.nombre)} (id: ${abreviarId(id)}${p.homonimos > 1 ? `; OJO: ${p.homonimos} se llaman igual` : ''})`;
+  }
+
+  /**
+   * Una tarjeta, lista para el agente. Todo lo que escribió o eligió OTRO participante (su texto, su
+   * nombre, su respuesta) va dentro de un sobre con el código de la respuesta.
+   */
+  async formatearTarjeta(t, { completo = false, codigo = nuevoCodigo(), archivoDesde = 0, archivoMax = Infinity, editada = false } = {}) {
+    const id = limpiarLinea(t.id, 64);
+    const para = t.paraId ? await this._describir(t.paraId) : null;
+    const tomador = t.tomadaPor ? await this._describir(t.tomadaPor) : null;
+    const fechas = [t.creadaEn ? `creada: ${limpiarLinea(t.creadaEn, 40)}` : null, t.editadaEn ? `editada: ${limpiarLinea(t.editadaEn, 40)}` : null];
+    const estado = t.tipo === 'tarea' ? `estado: ${limpiarLinea(t.estado, 20)}` : null;
+
+    let cuerpo = String(t.texto ?? '');
+    let notaArchivo = null;
+    let datoArchivo = null;
+    if (t.archivo) {
+      const c = String(t.archivo.contenido ?? '');
+      const desdeC = completo ? Math.min(Math.max(0, archivoDesde), c.length) : 0;
+      const trozo = c.slice(desdeC, desdeC + (completo ? archivoMax : VISTA_ARCHIVO));
+      const hasta = desdeC + trozo.length;
+      const resto = c.length - hasta;
+      datoArchivo = `archivo: ${limpiarLinea(t.archivo.nombre, 200)} (${limpiarLinea(t.archivo.mime, 100)}, ${Number(t.archivo.bytes) || 0} bytes, ${c.length} caracteres)`;
+      const rango = desdeC > 0 || resto > 0 ? ` (caracteres ${desdeC}–${hasta} de ${c.length})` : '';
+      cuerpo += `\n--- contenido del archivo${rango} ---\n${trozo}`;
+      if (resto > 0) {
+        notaArchivo = completo
+          ? `Faltan ${resto} caracteres del archivo: pide lienzo_leer(id: «${id}», desdeCaracter: ${hasta}).`
+          : `Archivo recortado a ${VISTA_ARCHIVO} caracteres: pide lienzo_leer(id: «${id}») para verlo entero.`;
+      }
+    }
+
+    const salida = [];
+    if (t.autorId === this.participanteId) {
+      // Lo tuyo va sin sobre, pero sin nombres ajenos: esos van dentro del sobre de abajo.
+      salida.push([`(tuya) tipo: ${limpiarLinea(t.tipo, 20)}`, `id: ${id}`, ...fechas, estado, datoArchivo].filter(Boolean).join(' · '));
+      salida.push(neutralizar(cuerpo));
+      const otros = [para && para !== 'ti' ? `para: ${para}` : null, tomador && tomador !== 'ti' ? `tomada por: ${tomador}` : null].filter(Boolean);
+      if (t.respuesta && t.tipo === 'tarea') {
+        const quien = await this._autor(t.tomadaPor || t.paraId);
+        salida.push(envolver({
+          de: quien.nombre, tipoAutor: quien.tipo, 'dueño': quien['dueño'], autorId: quien.id, homonimos: quien.homonimos,
+          tipo: 'respuesta a tu tarea', id, extra: otros, texto: t.respuesta,
+        }, codigo));
+      } else if (otros.length) {
+        salida.push(envolver({
+          de: 'la sala', tipoAutor: 'nombres elegidos por otros participantes', tipo: 'datos de tu tarjeta', id, extra: otros,
+          texto: t.tipo === 'tarea' ? '(sin respuesta todavía)' : '(sin contenido ajeno)',
+        }, codigo));
+      }
+    } else {
+      const autor = await this._autor(t.autorId);
+      const extra = [...fechas, para ? `para: ${para}` : null, t.respondeA ? `responde a: ${limpiarLinea(t.respondeA, 64)}` : null,
+        estado ? `${estado}${tomador ? ` (tomada por ${tomador})` : ''}` : null, datoArchivo].filter(Boolean);
+      salida.push(envolver({
+        de: autor.nombre, tipoAutor: autor.tipo, 'dueño': autor['dueño'], autorId: t.autorId, homonimos: autor.homonimos,
+        tipo: `${t.tipo}${editada ? ' (editada)' : ''}`, id, extra, texto: cuerpo,
+      }, codigo));
+      if (t.respuesta && t.tipo === 'tarea') {
+        const rid = t.tomadaPor || t.paraId;
+        if (rid === this.participanteId) {
+          salida.push(`Tu respuesta a esa tarea:\n${neutralizar(t.respuesta)}`);
+        } else {
+          const r = await this._autor(rid);
+          salida.push(envolver({
+            de: r.nombre, tipoAutor: r.tipo, 'dueño': r['dueño'], autorId: rid, homonimos: r.homonimos,
+            tipo: 'respuesta a la tarea', id, texto: t.respuesta,
+          }, codigo));
+        }
+      }
+    }
+    if (notaArchivo) salida.push(notaArchivo);
+    return salida.join('\n');
+  }
+
+  /** Una tarjeta completa (lienzo_leer con id): el archivo se entrega por tramos que entran en el tope. */
+  async _formatearUna(t, { codigo, max, desdeCaracter = 0 }) {
+    const cabeza = aviso(codigo);
+    let archivoMax = max;
+    let texto = '';
+    for (let i = 0; i < 4; i++) {
+      texto = await this.formatearTarjeta(t, { completo: true, codigo, archivoDesde: desdeCaracter, archivoMax });
+      const sobra = cabeza.length + 2 + texto.length - max;
+      if (sobra <= 0 || !t.archivo) break;
+      archivoMax = Math.max(1000, archivoMax - sobra - 200);
+    }
+    return `${cabeza}\n\n${texto}`;
+  }
+
+  /** Texto ajeno multilínea, con sangría, para las filas de una lista. */
+  static _sangrar(texto, prefijo = '  ') {
+    return String(texto ?? '').split('\n').map((l) => `${prefijo}${l}`).join('\n');
+  }
+
+  /**
+   * Una lista con sus puntos, en UN sobre. Si la pediste tú: tu título fuera y, dentro del sobre de quien
+   * responde, el resumen y las filas de los puntos que cambiaron (`cambiados`, o todas si es null).
+   * Si es de otro: el sobre del autor con título, contexto y los puntos numerados con sus ids.
+   */
+  async _formatearLista(padre, puntos, { codigo, cambiados = null, max = MAX_RESPUESTA } = {}) {
+    const id = limpiarLinea(padre.id, 64);
+    const titulo = primeraLinea(padre.texto);
+    const recortar = (t, n, nota = '') => { const u = String(t ?? ''); return u.length > n ? `${u.slice(0, Math.max(0, n - 1))}…${nota}` : u; };
+    const contexto = recortar(String(padre.texto ?? '').split('\n').slice(1).join('\n').trim(), MAX_CONTEXTO_LISTA, ' (recortado)');
+    const dest = padre.paraId ? await this._autor(padre.paraId) : null;
+    // Sin `dueño`, la persona de su cuenta: las reglas atan `{uid}_agente` a `uid` (solo entonces se lee).
+    const sinDueño = dest?.tipo === 'agente' && !String(dest['dueño'] ?? '').trim() && String(dest.id ?? '').endsWith('_agente');
+    const persona = sinDueño ? await this._autor(dest.id.slice(0, -'_agente'.length)) : null;
+    const quienEspera = dest ? quienEsperaLista(dest, persona) : null;
+    const resumen = `lista: ${resumenLista(puntos.map((p) => p.estado), this.esMio(padre.paraId) ? 'tu usuario' : quienEspera)}`;
+    const numero = (p) => numeroPunto(p.id) ?? '?';
+    const unaLinea = (t, n) => recortar(String(t ?? '').replace(/\s+/g, ' ').trim(), n);
+    const mostrados = puntos.filter((p) => !cambiados || cambiados.has(p.id));
+    // Presupuesto: la lista entera tiene que caber en UNA respuesta aunque alguien haya escrito de más por REST.
+    // Cada texto de un punto y cada respuesta se topan a 1 000 y, si aun así no entra, se reparten lo que queda.
+    const campos = mostrados.reduce((n, p) => n + 1 + (p.respuesta ? 1 : 0), 0) || 1;
+    const tope = Math.max(120, Math.min(MAX_PUNTO, Math.floor((max - 4000 - contexto.length - mostrados.length * 120) / campos)));
+    const NOTA = ' (recortado: lienzo_leer con el id del punto)';
+    const corto = (t) => {
+      // tope de caracteres y de líneas (cada línea suma sangría y «| » dentro del sobre)
+      const lineas = recortar(t, tope, NOTA).split('\n');
+      return lineas.length > 12 ? `${lineas.slice(0, 12).join('\n')}…${NOTA}` : lineas.join('\n');
+    };
+    const sangrado = (t) => Lienzo._sangrar(corto(t));
+    // «3 · esperando · ¿token nuevo…?» y, si la respuesta tiene más líneas, debajo con sangría
+    const filaRespuesta = (p) => {
+      const [primera, ...resto] = corto(p.respuesta ?? '').split('\n');
+      return [`${numero(p)} · ${p.estado}${p.respuesta ? ` · ${primera}` : ''}`, ...resto.map((l) => `  ${l}`)].join('\n');
+    };
+    const quien = dest ?? { nombre: 'destinatario', tipo: 'participante' };
+    const sobreRespuestas = (filas, tipo, extra = []) => envolver({
+      de: quien.nombre, tipoAutor: quien.tipo, 'dueño': quien['dueño'], autorId: padre.paraId, homonimos: quien.homonimos,
+      tipo, id, extra, texto: filas.length ? filas.join('\n') : '(sin cambios en los puntos)',
+    }, codigo);
+
+    if (padre.autorId === this.participanteId) {
+      // La pediste tú: tu título fuera; las respuestas, en el sobre de quien responde.
+      const filas = mostrados.map((p) => `${filaRespuesta(p)}\n  (tu punto: ${unaLinea(p.texto, 120)})`);
+      const cabeza = `(tuya) lista: ${neutralizar(titulo)} · id: ${id} · ${puntos.length} puntos · estado: ${limpiarLinea(padre.estado, 20)}`;
+      return `${cabeza}\n${sobreRespuestas(filas, 'respuestas a tu lista', [resumen])}`;
+    }
+
+    // De otro: los puntos en el sobre de quien los escribió; las respuestas, en el de quien responde
+    // (cada texto firmado por su autor), salvo que las respuestas sean tuyas.
+    const autor = await this._autor(padre.autorId);
+    const para = padre.paraId ? await this._describir(padre.paraId) : null;
+    const filas = mostrados.map((p) => [`${numero(p)} · id: ${p.id} · ${p.estado}`, sangrado(p.texto)].join('\n'));
+    const salida = [envolver({
+      de: autor.nombre, tipoAutor: autor.tipo, 'dueño': autor['dueño'], autorId: padre.autorId, homonimos: autor.homonimos,
+      tipo: `lista de puntos (${puntos.length})`, id,
+      extra: [padre.creadaEn ? `creada: ${limpiarLinea(padre.creadaEn, 40)}` : null, para ? `para: ${para}` : null,
+        `estado: ${limpiarLinea(padre.estado, 20)}`, resumen].filter(Boolean),
+      texto: [titulo, contexto ? `\n${contexto}` : null, '', 'Puntos:', ...filas].filter((x) => x != null).join('\n'),
+    }, codigo)];
+    const respondidos = mostrados.filter((p) => p.respuesta);
+    if (respondidos.length) {
+      const filasR = respondidos.map(filaRespuesta);
+      salida.push(this.esMio(padre.paraId)
+        ? `Tus respuestas:\n${neutralizar(filasR.join('\n'))}`
+        : sobreRespuestas(filasR, 'respuestas a la lista'));
+    }
+    if (this.esMio(padre.paraId)) {
+      salida.push('Esta lista es para ti. Respóndela entera en UNA llamada: lienzo_tarea con puntos: [{ id, estado, respuesta }] ' +
+        '(«hecha» o «no_aplica» solo si tu usuario te dio permiso en esta sesión y se contesta leyendo; todo lo demás, «esperando» ' +
+        'con la pregunta para tu usuario; con «esperando» y «no_aplica» la respuesta es obligatoria).');
+    }
+    return salida.join('\n');
+  }
+
+  /** Cambios en tus tareas: los puntos de una misma lista se juntan en un bloque (con el resumen arriba). */
+  async _bloquesDeCambios(cambios) {
+    const suelto = (t) => ({
+      seccion: 'cambios', piezas: 1, entregar: () => this._confirmarCambio(t),
+      texto: (codigo) => this.formatearTarjeta(t, { codigo }),
+    });
+    const grupos = new Map();
+    const bloques = [];
+    for (const c of cambios) {
+      const lid = this.listas.has(c.id) ? c.id : (c.respondeA && this.listas.has(c.respondeA) ? c.respondeA : null);
+      if (!lid) { bloques.push(suelto(c)); continue; }
+      if (!grupos.has(lid)) grupos.set(lid, []);
+      grupos.get(lid).push(c);
+    }
+    for (const [lid, miembros] of grupos) {
+      const padre = miembros.find((m) => m.id === lid)
+        ?? await this.fs.leer(`salas/${this.salaId}/tarjetas/${lid}`).catch(() => null);
+      const validos = padre ? miembros.filter((m) => m.id === lid || esPunto(m, padre)) : [];
+      bloques.push(...miembros.filter((m) => !validos.includes(m)).map(suelto));
+      if (!validos.length) continue;
+      const puntos = await this._puntosDe(padre).catch(() => validos.filter((m) => m.id !== lid));
+      const cambiados = new Set(validos.map((m) => m.id));
+      bloques.push({
+        seccion: 'cambios', piezas: 1,
+        entregar: () => { for (const m of validos) this._confirmarCambio(m); },
+        texto: (codigo, max) => this._formatearLista(padre, puntos, { codigo, cambiados, max }),
+      });
+    }
+    return bloques;
+  }
+
+  /**
+   * Tarjetas nuevas, en bloques que no se parten: las que nacieron en el mismo :commit (misma creadaEn)
+   * se entregan juntas o no se entregan, y una lista con sus puntos va en un solo sobre.
+   */
+  _bloquesDeTarjetas(tarjetas, { soloAjenas }) {
+    const grupos = [];
+    for (const t of tarjetas) {
+      const ultimo = grupos[grupos.length - 1];
+      if (ultimo && claveTiempo(ultimo[0].creadaEn) === claveTiempo(t.creadaEn)) ultimo.push(t);
+      else grupos.push([t]);
+    }
+    return grupos.map((grupo) => {
+      const enLista = new Set();
+      const piezas = [];
+      for (const t of grupo) {
+        if (enLista.has(t.id)) continue;
+        const puntos = t.tipo === 'tarea' && !t.respondeA ? grupo.filter((h) => esPunto(h, t)) : [];
+        if (puntos.length) {
+          for (const p of puntos) enLista.add(p.id);
+          enLista.add(t.id);
+          piezas.push({ t, puntos });
+        }
+      }
+      for (const t of grupo) if (!enLista.has(t.id)) piezas.push({ t, puntos: null });
+      piezas.sort((a, b) => grupo.indexOf(a.t) - grupo.indexOf(b.t));
+      const visibles = piezas.filter((p) => !(soloAjenas && p.t.autorId === this.participanteId));
+      return {
+        seccion: 'tarjetas', piezas: visibles.length, silencioso: !visibles.length,
+        entregar: () => { for (const t of grupo) this._avanzarMarca(t.creadaEn); },
+        ultimaCreada: grupo[grupo.length - 1].creadaEn,
+        texto: async (codigo, max) => (await Promise.all(visibles.map((p) => (p.puntos
+          ? this._formatearLista(p.t, [...p.puntos].sort((a, b) => (a.id < b.id ? -1 : 1)), { codigo, max })
+          : this.formatearTarjeta(p.t, { codigo }))))).join('\n\n'),
+      };
+    });
+  }
+
+  /**
+   * Arma la respuesta de lienzo_leer / lienzo_esperar con un tope de caracteres. Entrega en este orden:
+   * cambios en tus tareas, ediciones, tarjetas nuevas (de la más vieja a la más nueva). Las marcas
+   * (creadaEn, editadaEn y el estado visto de tus tareas) avanzan SOLO hasta lo que se entregó, y un
+   * bloque (una lista, o lo que nació en el mismo :commit) se entrega entero o no se entrega.
+   */
+  async formatearLote(lote, { codigo = nuevoCodigo(), max = MAX_RESPUESTA } = {}) {
+    if (lote.una) return this._formatearUna(lote.una, { codigo, max, desdeCaracter: lote.desdeCaracter });
+    if (lote.lista) return `${aviso(codigo)}\n\n${await this._formatearLista(lote.lista.padre, lote.lista.puntos, { codigo, max })}`;
+    const { tarjetas = [], editadas = [], cambios = [], soloAjenas = false, lleno = false } = lote;
+    const nuevas = new Set(tarjetas.map((t) => t.id));
+    const items = [
+      ...(await this._bloquesDeCambios(cambios)),
+      ...editadas.map((t) => ({
+        seccion: 'editadas', piezas: 1, entregar: () => this._avanzarEdicion(t.editadaEn),
+        texto: (codigo) => this.formatearTarjeta(t, { codigo, editada: true }),
+        // la edición de una tarjeta que llega nueva en esta misma respuesta ya viene con el texto al día
+        silencioso: nuevas.has(t.id) || (soloAjenas && t.autorId === this.participanteId),
+      })),
+      ...this._bloquesDeTarjetas(tarjetas, { soloAjenas }),
+    ];
+    const cabeza = aviso(codigo);
+    const bloques = { cambios: [], editadas: [], tarjetas: [] };
+    const piezas = { cambios: 0, editadas: 0, tarjetas: 0 };
+    const quedan = { cambios: 0, editadas: 0, tarjetas: 0 };
+    let usado = cabeza.length + 600; // aviso, títulos y pie
+    let entregados = 0;
+    let cortado = false;
+    let ultimaCreada = null;
+    for (const it of items) {
+      if (cortado) { if (!it.silencioso) quedan[it.seccion] += it.piezas; continue; }
+      if (it.silencioso) { it.entregar(); if (it.ultimaCreada) ultimaCreada = it.ultimaCreada; continue; }
+      const txt = await it.texto(codigo, max);
+      if (entregados > 0 && usado + txt.length + 2 > max) { cortado = true; quedan[it.seccion] += it.piezas; continue; }
+      bloques[it.seccion].push(txt);
+      piezas[it.seccion] += it.piezas;
+      usado += txt.length + 2;
+      entregados++;
+      it.entregar();
+      if (it.ultimaCreada) ultimaCreada = it.ultimaCreada;
+    }
+
+    const partes = [];
+    if (entregados) partes.push(cabeza);
+    if (bloques.cambios.length) partes.push(`Cambios en tareas que pediste (${piezas.cambios}):`, ...bloques.cambios);
+    if (bloques.editadas.length) partes.push(`Tarjetas editadas (${piezas.editadas}):`, ...bloques.editadas);
+    if (bloques.tarjetas.length) partes.push(`Tarjetas (${piezas.tarjetas}):`, ...bloques.tarjetas);
+    if (!entregados && !cortado) partes.push('No hay tarjetas nuevas.');
+    if (cortado) {
+      const total = quedan.cambios + quedan.editadas + quedan.tarjetas;
+      const desglose = [
+        quedan.cambios && `${quedan.cambios} cambios en tus tareas`,
+        quedan.editadas && `${quedan.editadas} ediciones`,
+        quedan.tarjetas && `${quedan.tarjetas} tarjetas`,
+      ].filter(Boolean).join(', ');
+      partes.push(`Respuesta recortada a ${max} caracteres: quedan ${total} sin entregar (${desglose})${lleno ? ', y puede haber más' : ''}. ` +
+        (soloAjenas ? 'Llama otra vez a lienzo_esperar para recibir el resto.' : 'Pide el resto con lienzo_leer(desde: marca).'));
+    } else if (lleno) {
+      partes.push(`Había más de ${LIMITE_CONSULTA} tarjetas nuevas: pide el resto con lienzo_leer(desde: marca).`);
+    }
+    const marca = soloAjenas ? this.marca : (ultimaCreada ?? lote.desde ?? this.marca);
+    partes.push(`marca: ${marca ?? '(sin marca)'} — pásala como «desde» para pedir solo lo posterior.`);
+    return partes.join('\n\n');
+  }
+}