@ajuarezso/lienzo-mcp 0.4.0 → 0.6.0

package/lib/lienzo.mjs

@@ -6,17 +6,24 @@ import { basename, extname, join } 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 { envolver, limpiarLinea, neutralizar, abreviarId, aviso, nuevoCodigo, tieneInvisibles, tieneLetraONumero } from './envoltorio.mjs';
 import { rutaCompartible, revisarNombre, ErrorArchivo } from './archivos.mjs';
 import { INTERVALO_MS } from './esperar.mjs';
 import { cerrarTimbre } from './escucha.mjs';
-import { idDeAgente, cuentaDe, esAgenteDe, TOPE_AGENTES } from './agentes.mjs';
+import { idDeAgente, cuentaDe, esAgenteDe, TOPE_AGENTES, RE_SLUG } from './agentes.mjs';
+import {
+  prepararInstalacion, resolverAgente, clienteDeMcp, nombreDeCliente, nombresAplicados, nombreDeConfigManda, anotarNombreAplicado,
+} from './instalacion.mjs';
 import { Storage, ErrorStorage } from './storage.mjs';
 import {
   ErrorAdjunto, detectarTipo, revisarTamano, sha256, nombreEnStorage, mimeParaStorage, disposicion, carpetaDescargas,
   nombreDescarga, nombreDeTipo, revisarBajado, revisarZip, imagenVisible, MAX_ADJUNTO_BYTES, MAX_IMAGEN_VISIBLE,
   IMAGENES_VISIBLES, MB,
 } from './adjuntos.mjs';
+import {
+  referenciasDeMenciones, mencionesDe, menciona, RACHA_VACIA, sumarTarjeta, rachaDeRecientes, pasaElTope, textoTope, lineaTope,
+  vaAOtroAgente, esPersona, PAGINA_TURNOS, PAGINAS_TURNOS, TOPE_TURNOS,
+} from './menciones.mjs';
 
 export const MAX_TEXTO = 20000;
 export const MAX_ARCHIVO_BYTES = 200 * 1024;
@@ -29,21 +36,48 @@ 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. */
+/**
+ * El nombre de la persona: el de su cuenta en una línea (hasta 80) o, si no hay (o no tiene ni una letra ni un número
+ * visibles, que las reglas rechazan), la parte local del correo.
+ */
 export function nombreDeCuenta(cuenta) {
   const n = limpiarLinea(cuenta?.nombre ?? '', 80);
-  if (n) return n;
+  if (n && tieneLetraONumero(n)) return n;
   const local = limpiarLinea(String(cuenta?.email ?? '').split('@')[0], 80);
-  return local || null;
+  return local && tieneLetraONumero(local) ? local : null;
 }
 
 /**
- * «Agente de <primer nombre>» (o null si la cuenta no tiene nombre ni correo). Con un agente con nombre
- * (LIENZO_AGENTE), «Agente de <primer nombre> · <slug>»: así tres agentes de la misma cuenta no se llaman igual.
+ * «<Cliente> de <primer nombre>» («Claude Code de Ana»; un cliente desconocido, «Agente de Ana»), o null si la cuenta
+ * no tiene nombre ni correo. Con un perfil de Claude Code que no es el de siempre (CLAUDE_CONFIG_DIR=~/.claude-ontop),
+ * «Claude Code (ontop) de Ana»: así la persona sabe en la web cuál es cuál. Con LIENZO_AGENTE explícito, «… · <slug>».
+ * Un slug automático no se muestra (no le dice nada a nadie): si choca, unirse() suma « · 2».
  */
-export function nombreAgentePorDefecto(cuenta, slug = null) {
+export function nombreAgentePorDefecto(cuenta, slug = null, cliente = 'claude-code', perfil = null) {
   const n = nombreDeCuenta(cuenta);
-  return n ? limpiarLinea(`Agente de ${n.split(/\s+/)[0]}${slug ? ` · ${slug}` : ''}`, 80) : null;
+  const deCliente = `${nombreDeCliente(cliente)}${perfil && cliente === 'claude-code' ? ` (${perfil})` : ''}`;
+  return n ? limpiarLinea(`${deCliente} de ${n.split(/\s+/)[0]}${slug ? ` · ${slug}` : ''}`, 80) : null;
+}
+
+/**
+ * ¿Sirve como nombre de participante? Una línea, sin invisibles (también los que no son de formato: U+034F, rellenos
+ * Hangul, braille en blanco, un selector de variante suelto), con al menos una letra o un número, 1..80. Lo mismo que
+ * exigen las reglas (nombreVisible en firestore.rules).
+ */
+export const nombreValido = (n) => typeof n === 'string' && n.trim().length > 0 && n.length <= 80 && !tieneInvisibles(n)
+  && tieneLetraONumero(n);
+
+/** «hace un momento», «hace 5 min», «hace 3 h», «hace 2 días» o la fecha (AAAA-MM-DD). */
+export function haceCuanto(iso, ahora = Date.now()) {
+  const t = Date.parse(iso ?? '');
+  if (!Number.isFinite(t)) return 'sin fecha';
+  const s = Math.max(0, Math.round((ahora - t) / 1000));
+  if (s < 60) return 'hace un momento';
+  if (s < 3600) return `hace ${Math.floor(s / 60)} min`;
+  if (s < 86400) return `hace ${Math.floor(s / 3600)} h`;
+  const d = Math.floor(s / 86400);
+  if (d < 30) return `hace ${d} día${d === 1 ? '' : 's'}`;
+  return new Date(t).toISOString().slice(0, 10);
 }
 
 // ── listas de puntos (docs/producto.md §4) ──────────────────────────────────
@@ -122,8 +156,26 @@ function quitarGrupo(lista, { alFinal }) {
   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();
+// Letras cirílicas y griegas que se ven igual que una latina (las más comunes). Solo para COMPARAR nombres: «Claude Code
+// de Аna» (A cirílica) cuenta como homónimo de «Claude Code de Ana» (revisión de seguridad, 21-10-2026).
+const PARECIDAS = new Map(Object.entries({
+  А: 'A', В: 'B', Е: 'E', К: 'K', М: 'M', Н: 'H', О: 'O', Р: 'P', С: 'C', Т: 'T', Х: 'X', У: 'Y', І: 'I', Ј: 'J', Ѕ: 'S',
+  а: 'a', е: 'e', о: 'o', р: 'p', с: 'c', у: 'y', х: 'x', і: 'i', ј: 'j', ѕ: 's', ԁ: 'd', һ: 'h', ӏ: 'l', ɡ: 'g', ı: 'i',
+  Α: 'A', Β: 'B', Ε: 'E', Ζ: 'Z', Η: 'H', Ι: 'I', Κ: 'K', Μ: 'M', Ν: 'N', Ο: 'O', Ρ: 'P', Τ: 'T', Υ: 'Y', Χ: 'X',
+  ο: 'o', ν: 'v', ρ: 'p', ι: 'i', κ: 'k', υ: 'u', χ: 'x', α: 'a',
+}));
+
+/**
+ * Para comparar nombres: sin controles ni invisibles, sin tildes ni marcas combinantes (NFKD sin \p{Mn}), con las
+ * letras cirílicas o griegas que parecen latinas pasadas a latinas, sin mayúsculas y con espacios simples. No sirve para
+ * mostrar: solo para decidir si dos nombres se confunden a la vista.
+ */
+export function claveNombre(s) {
+  const t = limpiarLinea(s, 200).normalize('NFKD').replace(/\p{Mn}/gu, '');
+  let r = '';
+  for (const c of t) r += PARECIDAS.get(c) ?? c;
+  return r.normalize('NFKC').toLowerCase().replace(/\s+/g, ' ').trim();
+}
 
 const ALFABETO = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
 
@@ -196,6 +248,9 @@ export class Lienzo {
     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)
+    // turnos agente↔agente de lo que ya se entregó (menciones.mjs); `hasta` = creadaEn de la última sumada, así una
+    // tarjeta que vuelve a llegar (canal y lienzo_esperar) no suma dos veces
+    this.racha = { ...RACHA_VACIA, hasta: '' };
     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)
@@ -203,14 +258,44 @@ export class Lienzo {
     // 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
+    // Id automático por instalación (lib/instalacion.mjs): agente.json se prepara al arrancar (ahí se fija si este home
+    // ya tenía sesión, para heredar `{uid}_agente`); el slug se resuelve en el primer unirse.
+    prepararInstalacion(config.home);
+    this.slugInstalacion = undefined; // undefined = sin resolver; null = el de siempre; string = slug automático
+    this.clienteMcp = null; // clientInfo.name del handshake (lo pone index.mjs al inicializar)
   }
 
   // ── utilidades ─────────────────────────────────────────────────────────────
   /** La cuenta (la persona). */
   get uid() { return this.sesion.uid; }
 
-  /** El slug de este puente (LIENZO_AGENTE), o null: el agente de siempre. */
-  get slug() { return this.config.agente ?? null; }
+  /**
+   * El slug de este puente: LIENZO_AGENTE si viene; si no, el automático de la instalación (resuelto en unirse); null =
+   * el agente de siempre (`{uid}_agente`: la instalación que lo heredó, o antes de resolver).
+   */
+  get slug() { return this.config.agente ?? this.slugInstalacion ?? null; }
+
+  /** El cliente: LIENZO_CLIENTE si viene; si no, el del handshake MCP si se reconoce; si no, 'claude-code'. */
+  get cliente() {
+    if (this.config.clienteExplicito) return this.config.cliente;
+    return clienteDeMcp(this.clienteMcp) ?? this.config.cliente ?? 'claude-code';
+  }
+
+  /** La instalación: `<cliente>@<CLAUDE_CONFIG_DIR o predeterminada>` (clave en agente.json). */
+  get claveInstalacion() {
+    return `${this.cliente}@${this.config.carpetaConfig ?? 'predeterminada'}`;
+  }
+
+  /** Fija el slug automático de esta instalación (una vez por proceso; estable entre arranques por agente.json). */
+  async _resolverInstalacion() {
+    if (this.config.agente || this.slugInstalacion !== undefined) return;
+    const { agente, origen } = await resolverAgente(this.config.home, this.claveInstalacion);
+    // otra llamada pudo resolverlo mientras tanto: gana la primera (el id no cambia a mitad del proceso)
+    if (this.slugInstalacion === undefined) {
+      this.slugInstalacion = agente;
+      console.error(`[lienzo] instalación ${this.claveInstalacion}: ${agente ? `agente ${agente}` : 'el agente de siempre'} (${origen})`);
+    }
+  }
 
   /** El participante de este agente en la sala: `{uid}_agente` o, con LIENZO_AGENTE, `{uid}_agente_{slug}`. */
   get participanteId() { return this.uid ? idDeAgente(this.uid, this.slug) : null; }
@@ -291,7 +376,8 @@ export class Lienzo {
     // 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.',
+      'Todavía no estás en una sala. Usa lienzo_mis_salas para ver tus salas y lienzo_unirse para entrar (con su nombre, ' +
+      'su link o su salaId), o crea una con lienzo_crear_sala.',
     );
   }
 
@@ -338,16 +424,22 @@ export class Lienzo {
   }
 
   /**
-   * ¿Lo que trajo lienzo_esperar le toca a este agente? Algo dirigido a él (paraId) o un cambio en una tarea
+   * ¿Lo que trajo lienzo_esperar le toca a este agente? Algo dirigido a él (paraId), que lo menciona, 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;
+    // para mí (paraId) o me mencionan (menciones): la convención es contestar solo en esos casos
+    const mio = (t) => t.autorId !== this.participanteId && (t.paraId === this.participanteId || menciona(t, this.participanteId));
     return (lote.cambios?.length ?? 0) > 0 || (lote.tarjetas ?? []).some(mio) || (lote.editadas ?? []).some(mio);
   }
 
+  /** ¿Una tarjeta ajena te menciona a ti (este agente)? */
+  _meMencionan(t) {
+    return Boolean(t) && t.autorId !== this.participanteId && menciona(t, this.participanteId);
+  }
+
   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}`, {
@@ -436,27 +528,132 @@ export class Lienzo {
   }
 
   /**
-   * 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>».
+   * Las salas de tu cuenta (índice `usuarios/{uid}/salas`, las de `vistaEn` más nuevo primero), sin las borradas:
+   * [{ salaId, nombre, vistaEn, archivada, creadaPorMi, aqui, link }]. 1 consulta + 1 batchGet.
+   */
+  async misSalas({ limite = 30 } = {}) {
+    await this.sesion.token().catch((e) => { throw this._traducir(e, 'iniciar sesión'); });
+    let indice;
+    let salas;
+    try {
+      indice = (await this.fs.consultar(`usuarios/${this.uid}`, {
+        from: [{ collectionId: 'salas' }],
+        orderBy: [{ field: { fieldPath: 'vistaEn' }, direction: 'DESCENDING' }],
+        limit: limite,
+      })).filter((f) => /^[A-Za-z0-9_-]{22}$/.test(f.id));
+      salas = indice.length ? await this.fs.leerVarios(indice.map((f) => `salas/${f.id}`)) : [];
+    } catch (e) {
+      throw this._traducir(e, 'leer tus salas');
+    }
+    const porId = new Map(salas.map((s) => [s.id, s]));
+    return indice.flatMap((f) => {
+      const s = porId.get(f.id);
+      if (!s || s.borradaEn) return [];
+      return [{
+        salaId: f.id, nombre: String(s.nombre ?? ''), vistaEn: f.vistaEn ?? null, archivada: Boolean(s.archivadaEn),
+        creadaPorMi: s.creadaPor === this.uid, aqui: f.id === this.salaId, link: this.link(f.id),
+      }];
+    });
+  }
+
+  /** La sala de lo que pasó el agente: link, salaId o el nombre de una de tus salas (no se adivina entre varias). */
+  async _salaDe(entrada) {
+    const m = /\/sala\/([A-Za-z0-9_-]{22})(?:[/?#]|$)/.exec(entrada);
+    if (m) return m[1];
+    if (/^[A-Za-z0-9_-]{22}$/.test(entrada)) return entrada; // si no existe, unirse() lo prueba como nombre
+    if (/^https?:\/\//i.test(entrada) || /\/sala\//.test(entrada)) {
+      throw new ErrorLienzo('Ese link no es de una sala de Lienzo (…/sala/<salaId de 22 caracteres>). Revisa el que te pasaron.');
+    }
+    const salaId = await this._salaPorNombre(entrada);
+    if (salaId) return salaId;
+    throw new ErrorLienzo(`No encontré una sala tuya que se llame «${limpiarLinea(entrada, 120)}». Por nombre solo busco entre tus ` +
+      'salas (las que abriste tú o tu agente): lienzo_mis_salas las lista. Si es de otra persona, pídele el link.');
+  }
+
+  /**
+   * Por nombre, entre tus salas. Entra sola SOLO si hay una única coincidencia (exacta o parcial, juntas) y es una sala
+   * que creó tu usuario: el nombre de una sala ajena lo pone quien la creó y puede renombrarla para que calce con lo
+   * que vas a escribir (revisión de seguridad, 21-10-2026). En cualquier otro caso lista y no elige. Un nombre con
+   * caracteres invisibles nunca calza. null si no hay ninguna.
+   */
+  async _salaPorNombre(entrada) {
+    const salas = (await this.misSalas()).filter((s) => !tieneInvisibles(s.nombre));
+    const clave = claveNombre(entrada);
+    if (!clave) return null;
+    const exactas = salas.filter((s) => claveNombre(s.nombre) === clave);
+    const parciales = clave.length >= 3 ? salas.filter((s) => claveNombre(s.nombre) !== clave && claveNombre(s.nombre).includes(clave)) : [];
+    const hallo = [...exactas, ...parciales];
+    if (!hallo.length) return null;
+    if (hallo.length === 1 && hallo[0].creadaPorMi) return hallo[0].salaId;
+    const filas = hallo.map((s) => `- salaId: ${s.salaId} · ${s.creadaPorMi ? 'la creó tu usuario' : 'de otra persona'} · ` +
+      `tu última vez: ${haceCuanto(s.vistaEn)}${s.archivada ? ' · archivada' : ''}`);
+    throw new ErrorLienzo(`${hallo.length === 1 ? 'Hay 1 sala que coincide' : `Tienes ${hallo.length} salas que coinciden`} con ` +
+      `«${limpiarLinea(entrada, 120)}»${hallo.length === 1 ? ', pero no la creó tu usuario' : ''}: no elijo por ti. ` +
+      `Pregúntale a tu usuario cuál (lienzo_mis_salas las muestra con su nombre) y usa su salaId:\n${filas.join('\n')}`);
+  }
+
+  /** Los nombres (normalizados) de los otros agentes de mi cuenta en la sala. Solo lee si ya hay alguno (si no, []). */
+  async _nombresDeHermanos(salaId) {
+    try {
+      const idx = await this.fs.leer(`salas/${salaId}/cuentas/${this.uid}`).catch(() => null);
+      const slugs = (Array.isArray(idx?.agentes) ? idx.agentes : []).filter((x) => RE_SLUG.test(String(x)));
+      const ids = [idDeAgente(this.uid), ...slugs.map((x) => idDeAgente(this.uid, x))].filter((id) => id !== this.participanteId);
+      const docs = await this.fs.leerVarios(ids.map((id) => `salas/${salaId}/participantes/${id}`));
+      return docs.filter((d) => d.tipo === 'agente').map((d) => claveNombre(d.nombre ?? ''));
+    } catch {
+      return []; // sin permiso todavía (la cuenta no está en la sala): no hay hermanos que mirar
+    }
+  }
+
+  /** Nombre por defecto para un agente que entra por primera vez: con « · 2», « · 3»… si otro de mis agentes ya se llama así. */
+  async _nombreNuevo(salaId, cuenta) {
+    const base = nombreAgentePorDefecto(cuenta, this.config.agente, this.cliente, this.config.perfil);
+    if (!base) return null;
+    const usados = new Set(await this._nombresDeHermanos(salaId));
+    if (!usados.has(claveNombre(base))) return base;
+    for (let n = 2; n < 100; n++) {
+      const candidato = limpiarLinea(`${base.slice(0, 74)} · ${n}`, 80);
+      if (!usados.has(claveNombre(candidato))) return candidato;
+    }
+    return base;
+  }
+
+  /**
+   * Entra a la sala como el agente de esta instalación: `{uid}_agente_{slug}` (slug de LIENZO_AGENTE o el automático
+   * de la instalación) o `{uid}_agente` (la instalación que heredó el de siempre). Tipo agente, dueñoUid = la cuenta,
+   * dueño = el nombre de la cuenta. `salaId` acepta el id, el link o el nombre de una de tus salas.
+   * Nombre: el que se pase o LIENZO_NOMBRE (mandan siempre); si no, el que ya tenga el agente en la sala (p. ej. el que
+   * le puso su persona desde la web: no se pisa); si entra por primera vez, «<Cliente> de <primer nombre>» (+ « · 2»
+   * si otro agente de la cuenta ya se llama así).
    */
   async unirse({ salaId, nombre }) {
     this._exigirAgenteValido();
-    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.');
+    const entrada = String(salaId || '').trim();
+    if (!entrada) throw new ErrorLienzo('Falta la sala: pasa su link, su salaId o su nombre (lienzo_mis_salas lista las tuyas).');
+    // `nombre` (lo pidió tu usuario en esta llamada) manda siempre; LIENZO_NOMBRE no pisa un nombre puesto desde la web
+    const pedido = String(nombre || '').trim();
+    const deConfig = pedido ? '' : String(this.config.nombre || '').trim();
+    const explicito = pedido || deConfig;
+    if (explicito.length > 80) throw new ErrorLienzo('El nombre admite hasta 80 caracteres.');
+    if (tieneInvisibles(explicito)) throw new ErrorLienzo('El nombre va en una sola línea, sin caracteres de control ni invisibles.');
+    if (explicito && !tieneLetraONumero(explicito)) throw new ErrorLienzo('El nombre necesita al menos una letra o un número.');
+    if (explicito) this._vigilarSecretos([['tu nombre', explicito]]);
 
     await this.sesion.token().catch((e) => { throw this._traducir(e, 'iniciar sesión'); });
+    salaId = await this._salaDe(entrada);
+    await this._resolverInstalacion();
     const cuenta = this.sesion.cuenta;
     const dueño = nombreDeCuenta(cuenta);
-    nombre = String(nombre || this.config.nombre || nombreAgentePorDefecto(cuenta, this.slug) || '').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'); });
+    let sala = await this.fs.leer(`salas/${salaId}`).catch((e) => { throw this._traducir(e, 'leer la sala'); });
+    // 22 letras y números que no son el id de ninguna sala: puede ser el NOMBRE de una de tus salas
+    if (!sala && salaId === entrada) {
+      const porNombre = await this._salaPorNombre(entrada);
+      if (porNombre) {
+        salaId = porNombre;
+        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) {
@@ -466,8 +663,13 @@ export class Lienzo {
 
     const ruta = `salas/${salaId}/participantes/${this.participanteId}`;
     const previo = await this.fs.leer(ruta).catch(() => null);
+    const enSala = nombreValido(previo?.nombre) ? previo.nombre : '';
+    const clave = this.claveInstalacion;
+    const configManda = deConfig && nombreDeConfigManda(deConfig, enSala, nombresAplicados(this.config.home, clave));
+    nombre = pedido || (configManda ? deConfig : '') || enSala || deConfig || (await this._nombreNuevo(salaId, cuenta)) || '';
+    if (!nombre) throw new ErrorLienzo('Falta tu nombre en la sala (p. ej. «Claude Code de Ana»): pásalo en nombre.');
     const datos = {
-      nombre, tipo: 'agente', 'dueño': dueño, 'dueñoUid': this.uid, cliente: this.config.cliente,
+      nombre, tipo: 'agente', 'dueño': dueño, 'dueñoUid': this.uid, cliente: this.cliente,
       posicion: previo?.posicion ?? null,
     };
     let commit;
@@ -492,6 +694,7 @@ export class Lienzo {
       throw texto ? new ErrorLienzo(texto, { cause: e }) : this._traducir(e, 'unirte a la sala');
     }
 
+    if (deConfig) await anotarNombreAplicado(this.config.home, clave, deConfig);
     this.salasPerdidas.delete(salaId); // un lienzo_unirse explícito vuelve a abrir la sala
     this.ultimaPerdida = null;
     // accesos/{uid} se vuelve a escribir: pudo borrarse al salir desde la web, o la cuenta es otra
@@ -512,6 +715,7 @@ export class Lienzo {
       this.participantes.clear();
       this.participantesEn = 0;
       this._ausentes.clear();
+      this.racha = { ...RACHA_VACIA, hasta: '' };
     }
     await this._anotarEnIndice(salaId);
     return { salaId, sala, link: this.link(salaId), yo: this.yo };
@@ -523,8 +727,11 @@ export class Lienzo {
     const idx = await this.fs.leer(`salas/${salaId}/cuentas/${this.uid}`);
     const agentes = Array.isArray(idx?.agentes) ? idx.agentes : [];
     if (agentes.length < TOPE_AGENTES || agentes.includes(this.slug)) return null;
-    return `Tu cuenta ya tiene ${agentes.length} agentes con nombre en esta sala (${agentes.map((a) => limpiarLinea(a, 24)).join(', ')}), ` +
-      `que es el tope. Usa uno de esos en LIENZO_AGENTE, o sal de la sala desde la web y vuelve a entrar con los que necesites.`;
+    return `Tu cuenta ya tiene ${agentes.length} agentes en esta sala (${agentes.map((a) => limpiarLinea(a, 24)).join(', ')}), ` +
+      'que es el tope. Cada instalación del puente (cada perfil de Claude Code, cada cliente o cada máquina) es un agente ' +
+      'aparte. Pídele a tu usuario que abra la sala en la web, vaya a ⋮ → Participantes y use «Quitar» en el agente suyo ' +
+      'que ya no usa (sale solo ese agente; él y los demás siguen en la sala). Después vuelve a llamar lienzo_unirse. O ' +
+      'usa en LIENZO_AGENTE uno de esos.';
   }
 
   // ── cuenta ─────────────────────────────────────────────────────────────────
@@ -603,12 +810,21 @@ export class Lienzo {
 
   /**
    * 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? }.
+   * espera hasta `esperaMs` (3 min); al vencer o cancelarse, el servidor local se cierra. 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).
+   *
+   * La URL (lleva el nonce) va a stderr y vuelve al modelo SOLO si la pide con `sinNavegador: true`: `{ estado:
+   * 'link', url }`, sin esperar (sirve también para una entrada que ya estaba en curso). Si el navegador no se pudo
+   * abrir y no se pidió el link, devuelve `{ estado: 'noAbrio' }` SIN la URL: el agente decide pedirla con
+   * sinNavegador (revisión de integra-06; antes la URL volvía al modelo cada vez que fallaba `abrir`). La decisión de
+   * fondo (a: nunca al modelo / b: con sinNavegador) sigue siendo del dueño (docs/pendientes.md, «Link de /conectar
+   * solo en stderr»). En los dos casos la espera sigue en segundo plano y la próxima lienzo_entrar se engancha a ella
+   * y devuelve 'listo' o 'vencido'. Sin esto, Codex en su sandbox o Cursor sin navegador no tenían cómo conectar.
+   *
+   * Devuelve { estado: 'ya' | 'listo' | 'vencido' | 'noAbrio' | 'link', cuenta?, salaOlvidada?, url? }.
    */
-  async entrar({ otraCuenta = false, esperaMs = ENTRAR_TIMEOUT_MS, signal, alAbrir } = {}) {
+  async entrar({ otraCuenta = false, esperaMs = ENTRAR_TIMEOUT_MS, signal, alAbrir, sinNavegador = false } = {}) {
     if (!otraCuenta && !this.entrada && this.sesion.cuenta) {
       try {
         await this.sesion.token();
@@ -617,25 +833,63 @@ export class Lienzo {
         if (!(e instanceof ErrorSesion)) throw e; // red: no se abre el navegador por un corte
       }
     }
+    // La espera tiene su propio AbortController: la llamada que espera la cancela si la cancelan a ella, pero una que
+    // ya devolvió (el link o «no se abrió») no se la lleva (la espera sigue para la próxima lienzo_entrar).
     if (!this.entrada) {
-      const entrada = this.sesion.entrar({ abrir: this.abrir, timeoutMs: esperaMs, signal, onListening: () => alAbrir?.() })
+      const control = new AbortController();
+      let avisarUrl;
+      let avisarNoAbrio;
+      const info = {
+        url: new Promise((r) => { avisarUrl = r; }), // la URL de esta entrada, apenas escucha el servidor local
+        noAbrio: new Promise((r) => { avisarNoAbrio = r; }),
+        avisada: false, // ya se le dijo al modelo que siga esperando (le dio el link o le dijo que no se abrió)
+      };
+      const entrada = this.sesion.entrar({
+        abrir: sinNavegador ? null : this.abrir,
+        timeoutMs: esperaMs,
+        signal: control.signal,
+        onListening: ({ url }) => { avisarUrl(url); alAbrir?.(); },
+        onNoAbrio: () => avisarNoAbrio(),
+      })
         .then((cuenta) => {
           this._soltarPerdidasAjenas();
-          const salaOlvidada = Boolean(this.uidEnSala && this.uidEnSala !== this.uid);
+          let salaOlvidada = Boolean(this.uidEnSala && this.uidEnSala !== this.uid);
+          // 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) salaOlvidada = true;
           if (salaOlvidada) this._olvidarSala();
           return { cuenta, salaOlvidada };
         })
         .finally(() => { if (this.entrada === entrada) this.entrada = null; });
+      entrada.catch(() => undefined); // si nadie la espera (se devolvió antes), que no quede una promesa sin manejar
       this.entrada = entrada;
+      this.entradaControl = control;
+      this.entradaInfo = info;
     }
+    const info = this.entradaInfo;
+    const control = this.entradaControl;
+    const cancelar = () => control?.abort();
+    signal?.addEventListener('abort', cancelar, { once: true });
     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 }; }
+      const espera = this.entrada.then((r) => ({ hecho: r }));
+      let r;
+      if (sinNavegador) r = await Promise.race([espera, info.url.then((url) => ({ url }))]);
+      else if (info.avisada) r = await espera;
+      else r = await Promise.race([espera, info.noAbrio.then(() => ({ noAbrio: true }))]);
+      if (r.url) {
+        info.avisada = true;
+        return { estado: 'link', url: r.url };
+      }
+      if (r.noAbrio) {
+        info.avisada = true;
+        return { estado: 'noAbrio' };
+      }
+      const { cuenta, salaOlvidada } = r.hecho;
       return { estado: 'listo', cuenta, salaOlvidada };
     } catch (e) {
       if (e instanceof ErrorSesion && e.codigo === 'vencido') return { estado: 'vencido' };
       throw this._traducir(e, 'conectar tu cuenta');
+    } finally {
+      signal?.removeEventListener('abort', cancelar);
     }
   }
 
@@ -681,16 +935,115 @@ export class Lienzo {
     return texto;
   }
 
-  async publicar({ texto, paraId = null, respondeA = null, tipo = 'mensaje' }) {
+  /**
+   * menciones (ids o nombres, «@» opcional) → ids de participantes que existen, sin repetidos y sin ti. Un nombre que
+   * llevan dos no se adivina (_resolverParticipante). «@todos» o una lista vacía = sin menciones (toda la sala).
+   */
+  async _resolverMenciones(menciones) {
+    let refs;
+    try { refs = referenciasDeMenciones(menciones); } catch (e) { throw new ErrorLienzo(e.message); }
+    const ids = [];
+    for (const r of refs) {
+      const id = await this._resolverParticipante(r);
+      if (id && id !== this.participanteId && !ids.includes(id)) ids.push(id);
+    }
+    return ids;
+  }
+
+  /**
+   * Las tarjetas recientes para contar turnos (menciones.mjs): de la más nueva a la más vieja, de a PAGINA_TURNOS,
+   * hasta dar con una de una persona o PAGINAS_TURNOS páginas. El cursor es (creadaEn, id): los puntos de una lista
+   * nacen en el mismo commit y comparten la hora, así que un corte solo por la hora se saltaría tarjetas.
+   */
+  async _rachaReciente() {
+    const recientes = [];
+    let agotada = false;
+    let cursor = null;
+    for (let i = 0; i < PAGINAS_TURNOS; i++) {
+      const consulta = {
+        from: [{ collectionId: 'tarjetas' }],
+        orderBy: [
+          { field: { fieldPath: 'creadaEn' }, direction: 'DESCENDING' },
+          { field: { fieldPath: '__name__' }, direction: 'DESCENDING' },
+        ],
+        limit: PAGINA_TURNOS,
+      };
+      if (cursor) consulta.startAt = { values: cursor, before: false };
+      const pagina = await this.fs.consultar(`salas/${this.salaId}`, consulta)
+        .catch((e) => { throw this._traducir(e, 'leer las últimas tarjetas de la sala'); });
+      recientes.push(...pagina);
+      const ultima = pagina.at(-1);
+      if (pagina.length < PAGINA_TURNOS || !ultima?.creadaEn) { agotada = true; break; }
+      if (pagina.some((t) => esPersona(t.autorId))) break; // lo anterior a una persona no cuenta
+      cursor = [
+        { timestampValue: ultima.creadaEn },
+        { referenceValue: this.fs.nombre(`salas/${this.salaId}/tarjetas/${ultima.id}`) },
+      ];
+    }
+    return { racha: rachaDeRecientes(recientes, { agotada }), recientes };
+  }
+
+  /**
+   * Tope de turnos entre agentes (menciones.mjs): antes de crear una tarjeta se cuenta la racha y, si ya llegó al tope,
+   * no se publica nada dirigido a otro agente (paraId, menciones o respondeA a una tarjeta de otro agente) y lo demás
+   * pasa una vez por agente. El autor de respondeA se lee solo en el tope (de lo ya leído o con una lectura).
+   */
+  async _revisarTurnos({ destinos = [], respondeA = null } = {}) {
+    const { racha, recientes } = await this._rachaReciente();
+    if (racha.turnos < TOPE_TURNOS) return racha;
+    const lista = destinos.filter(Boolean);
+    if (respondeA) {
+      let autor = recientes.find((t) => t.id === respondeA)?.autorId ?? null;
+      if (!autor) {
+        autor = (await this.fs.leer(`salas/${this.salaId}/tarjetas/${respondeA}`).catch(() => null))?.autorId ?? null;
+      }
+      if (autor) lista.push(autor);
+    }
+    const dirigido = vaAOtroAgente(this.participanteId, lista);
+    if (pasaElTope(racha, this.participanteId, dirigido)) throw new ErrorLienzo(textoTope(racha, dirigido));
+    return racha;
+  }
+
+  /** Suma a la racha las tarjetas entregadas (en orden de creación), cada una una sola vez. */
+  _sumarRacha(tarjetas) {
+    let r = this.racha ?? { ...RACHA_VACIA, hasta: '' };
+    const porId = new Map(tarjetas.map((t) => [t.id, t.autorId]));
+    const autorDe = (id) => porId.get(id) ?? null;
+    for (const t of tarjetas) {
+      const k = claveTiempo(t.creadaEn);
+      if (!k || k <= r.hasta) continue;
+      r = { ...sumarTarjeta(r, t, autorDe), hasta: k };
+    }
+    this.racha = r;
+  }
+
+  async publicar({ texto, paraId = null, respondeA = null, tipo = 'mensaje', menciones = null }) {
     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);
+    const ids = await this._resolverMenciones(menciones);
     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._revisarTurnos({ destinos: [para, ...ids], respondeA });
+    const datos = { tipo, texto, paraId: para, respondeA: respondeA || null };
+    let sinMenciones = false;
+    let id;
+    // el campo va solo si hay menciones: una tarjeta sin ellas es igual a la de siempre (reglas viejas incluidas)
+    if (!ids.length) id = await this._crearTarjeta(datos);
+    else {
+      try {
+        id = await this._crearTarjeta({ ...datos, menciones: ids });
+      } catch (e) {
+        // Reglas anteriores a F2 (despliegue a medias): el campo se rechaza. Se publica igual, sin él, y se dice.
+        // Si te sacaron de la sala, el reintento también se niega y el error es el de siempre.
+        if (!negadoDe(e)) throw e;
+        id = await this._crearTarjeta(datos);
+        sinMenciones = true;
+      }
+    }
     await this.latido();
-    return { id, paraId: para, link: this.linkTarjeta(id) };
+    return { id, paraId: para, menciones: sinMenciones ? [] : ids, sinMenciones, link: this.linkTarjeta(id) };
   }
 
   /**
@@ -740,6 +1093,8 @@ export class Lienzo {
       try { revisarZip(buf); } catch (e) { throw this._traducir(e, 'compartir el archivo'); }
     }
     const para = await this._resolverParticipante(paraId);
+    // el tope de turnos se mira antes de subir nada a Storage (si no, quedaría un objeto sin tarjeta)
+    await this._revisarTurnos({ destinos: [para] });
 
     // texto chico (también un SVG, como en 0.3: la tarjeta lo muestra como código, nunca lo dibuja): en la tarjeta
     if (enTarjeta) {
@@ -953,6 +1308,7 @@ export class Lienzo {
     texto = this._validarTexto(texto);
     this._vigilarSecretos([['el texto', texto]]);
     const para = await this._resolverParticipante(paraId);
+    await this._revisarTurnos({ destinos: [para] });
     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();
@@ -983,6 +1339,7 @@ export class Lienzo {
     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);
+    await this._revisarTurnos({ destinos: [para] });
 
     const id = nuevoId();
     const ids = puntos.map((_, i) => idPunto(id, i + 1));
@@ -1229,9 +1586,12 @@ export class Lienzo {
       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);
+    // las últimas de la sala: la racha de turnos se cuenta de nuevo sobre ellas (con un hueco no se arrastra la vieja)
+    if (!marcaDesde) this.racha = { ...RACHA_VACIA, hasta: '' };
     const editadas = await this._editadasDesde(marcaDesde);
     const cambios = await this._cambiosEnMisTareas();
-    return { tarjetas, editadas, cambios, desde: marcaDesde, lleno: Boolean(tarjetas.lleno) };
+    // sin desde son las últimas de la sala: la línea del tope de turnos vale (con desde pueden ser viejas)
+    return { tarjetas, editadas, cambios, desde: marcaDesde, lleno: Boolean(tarjetas.lleno), conTope: !marcaDesde };
   }
 
   /** Para lienzo_esperar: tarjetas y ediciones ajenas y cambios en tus tareas; null si no hay nada ajeno. */
@@ -1277,6 +1637,10 @@ export class Lienzo {
     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;
+    // menciones: quién (nombres elegidos por otros → siempre dentro del sobre) y si te nombran a ti
+    const mencionados = mencionesDe(t).sort((a, b) => Number(b === this.participanteId) - Number(a === this.participanteId));
+    const menciona_ = mencionados.length ? `menciona a: ${(await Promise.all(mencionados.map((m) => this._describir(m)))).join(', ')}` : null;
+    const teMencionan = t.autorId !== this.participanteId && mencionados.includes(this.participanteId);
     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;
 
@@ -1309,7 +1673,7 @@ export class Lienzo {
       // 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);
+      const otros = [para && para !== 'ti' ? `para: ${para}` : null, tomador && tomador !== 'ti' ? `tomada por: ${tomador}` : null, menciona_].filter(Boolean);
       if (t.respuesta && t.tipo === 'tarea') {
         const quien = await this._autor(t.tomadaPor || t.paraId);
         salida.push(envolver({
@@ -1324,7 +1688,7 @@ export class Lienzo {
       }
     } else {
       const autor = await this._autor(t.autorId);
-      const extra = [...fechas, para ? `para: ${para}` : null, t.respondeA ? `responde a: ${limpiarLinea(t.respondeA, 64)}` : null,
+      const extra = [teMencionan ? 'te mencionan' : null, ...fechas, para ? `para: ${para}` : null, menciona_, 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,
@@ -1500,7 +1864,8 @@ export class Lienzo {
       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); },
+        mias: visibles.filter((p) => this._meMencionan(p.t)).map((p) => p.t.id),
+        entregar: () => { for (const t of grupo) this._avanzarMarca(t.creadaEn); this._sumarRacha(grupo); },
         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 })
@@ -1534,6 +1899,7 @@ export class Lienzo {
       ...editadas.map((t) => ({
         seccion: 'editadas', piezas: 1, entregar: () => this._avanzarEdicion(t.editadaEn),
         texto: (codigo) => this.formatearTarjeta(t, { codigo, editada: true }),
+        mias: this._meMencionan(t) ? [t.id] : [],
         // 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),
       })),
@@ -1547,6 +1913,7 @@ export class Lienzo {
     let entregados = 0;
     let cortado = false;
     let ultimaCreada = null;
+    const mencionan = []; // ids de lo entregado que te menciona
     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; }
@@ -1557,11 +1924,20 @@ export class Lienzo {
       usado += txt.length + 2;
       entregados++;
       it.entregar();
+      for (const m of it.mias ?? []) if (!mencionan.includes(m)) mencionan.push(m);
       if (it.ultimaCreada) ultimaCreada = it.ultimaCreada;
     }
 
     const partes = [];
     if (entregados) partes.push(cabeza);
+    // lo pone el puente (fuera de los sobres): a quién le toca contestar y si la sala llegó al tope de turnos
+    if (mencionan.length && !sinPie) {
+      // sin ids: el id de una tarjeta lo puede elegir quien la escribe por REST, y fuera del sobre solo va lo del puente
+      partes.push(`Te mencionan en ${mencionan.length === 1 ? '1 tarjeta' : `${mencionan.length} tarjetas`} (dice «te mencionan» ` +
+        'en su sobre). Contesta en la sala solo lo que te menciona o es para ti, y solo si tu usuario te lo pidió.');
+    }
+    const tope = (soloAjenas || lote.conTope) && entregados ? lineaTope(this.racha) : null;
+    if (tope) partes.push(tope);
     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);