@ajuarezso/lienzo-mcp 0.2.0 → 0.3.1

package/lib/config.mjs

@@ -3,6 +3,9 @@
 //   LIENZO_HOME            carpeta de estado (por defecto ~/.lienzo)
 //   LIENZO_SALA            sala a la que se une solo al primer uso
 //   LIENZO_NOMBRE          nombre visible del agente (por defecto «Agente de <tu primer nombre>», de tu cuenta)
+//   LIENZO_AGENTE          cuál de tus agentes es este puente (personal, trabajo, pc…): con él, la misma cuenta puede
+//                          tener varios agentes en una sala, cada uno con su id `{uid}_agente_{slug}`. Sin él, el
+//                          agente de siempre (`{uid}_agente`)
 //   LIENZO_CLIENTE         'claude-code' por defecto
 //   LIENZO_FIREBASE_CONFIG ruta a otro firebase.config.json (por defecto: el que viaja en el paquete de npm,
 //                          y si no está, el de la raíz del repo)
@@ -14,6 +17,17 @@ import { readFileSync, existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { slugDeAgente, ErrorAgente } from './agentes.mjs';
+
+/** El slug de LIENZO_AGENTE, o el error para decirlo en la primera herramienta (el puente arranca igual). */
+function agenteDe(entrada) {
+  try {
+    return { agente: slugDeAgente(entrada), errorAgente: null };
+  } catch (e) {
+    if (e instanceof ErrorAgente) return { agente: null, errorAgente: e.message };
+    throw e;
+  }
+}
 
 const AQUI = dirname(fileURLToPath(import.meta.url));
 
@@ -46,6 +60,7 @@ export function cargarConfig(env = process.env) {
     home,
     salaId: env.LIENZO_SALA || archivo.salaId || null,
     nombre: env.LIENZO_NOMBRE || archivo.nombre || null,
+    ...agenteDe(env.LIENZO_AGENTE || archivo.agente || null),
     cliente: env.LIENZO_CLIENTE || archivo.cliente || 'claude-code',
     apiKey: firebase.apiKey,
     projectId,

package/lib/esperar.mjs

@@ -119,13 +119,18 @@ async function sondear(consultar, o, limite, consultasPrevias) {
   }
 }
 
-/** Respuesta de lienzo_leer / lienzo_esperar que no entregó todo (lo dice formatearLote). */
+/**
+ * Respuesta de lienzo_leer / lienzo_esperar que no entregó todo. OJO: el texto también trae lo que escribieron otros
+ * (una tarjeta puede decir «Había más de 20 personas»): mejor el `recortado` de formatearLoteDetalle.
+ */
 export const RE_RECORTADA = /Respuesta recortada|Había más de/;
 
 /**
  * Tras formatear lo que trajo una espera con timbre: si la respuesta entró entera, lo consultado ya está
  * entregado y la próxima espera no necesita volver a mirar (ahorra una pasada por cada novedad).
+ * `recortado`: el booleano de formatearLoteDetalle (o, por compatibilidad, el texto, que se mira con RE_RECORTADA).
  */
-export function entregado(timbre, r, texto) {
-  if (timbre && r?.modo === 'timbre' && r.version != null && !RE_RECORTADA.test(texto)) timbre.visto = r.version;
+export function entregado(timbre, r, recortado) {
+  const corto = typeof recortado === 'boolean' ? recortado : RE_RECORTADA.test(String(recortado ?? ''));
+  if (timbre && r?.modo === 'timbre' && r.version != null && !corto) timbre.visto = r.version;
 }

package/lib/firestore.mjs

@@ -114,14 +114,19 @@ export class Firestore {
   /**
    * Arma una escritura para :commit (para poder usar la hora del servidor).
    * opciones: { crear: true } exige que no exista; { existe: true } exige que exista;
-   * mascara: [campos] actualiza solo esos; horaServidor: [campos] = REQUEST_TIME.
+   * mascara: [campos] actualiza solo esos; horaServidor: [campos] = REQUEST_TIME;
+   * agregar / quitar: { campo: [valores] } = appendMissingElements / removeAllFromArray (atómico en el servidor:
+   * dos puentes que agregan a la vez no se pisan).
    */
-  escritura(ruta, datos, { crear = false, existe = false, mascara = null, horaServidor = [] } = {}) {
+  escritura(ruta, datos, { crear = false, existe = false, mascara = null, horaServidor = [], agregar = null, quitar = null } = {}) {
     const write = { update: { name: this.nombre(ruta), fields: aCampos(datos) } };
     if (mascara) write.updateMask = { fieldPaths: mascara.map(campoRuta) };
-    if (horaServidor.length) {
-      write.updateTransforms = horaServidor.map((c) => ({ fieldPath: campoRuta(c), setToServerValue: 'REQUEST_TIME' }));
-    }
+    const transformaciones = [
+      ...horaServidor.map((c) => ({ fieldPath: campoRuta(c), setToServerValue: 'REQUEST_TIME' })),
+      ...Object.entries(agregar ?? {}).map(([c, v]) => ({ fieldPath: campoRuta(c), appendMissingElements: { values: v.map(aValor) } })),
+      ...Object.entries(quitar ?? {}).map(([c, v]) => ({ fieldPath: campoRuta(c), removeAllFromArray: { values: v.map(aValor) } })),
+    ];
+    if (transformaciones.length) write.updateTransforms = transformaciones;
     if (crear) write.currentDocument = { exists: false };
     else if (existe) write.currentDocument = { exists: true };
     return write;

package/lib/lienzo.mjs

@@ -9,6 +9,7 @@ import { envolver, limpiarLinea, neutralizar, abreviarId, aviso, nuevoCodigo } f
 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';
 
 export const MAX_TEXTO = 20000;
 export const MAX_ARCHIVO_BYTES = 200 * 1024;
@@ -29,10 +30,13 @@ export function nombreDeCuenta(cuenta) {
   return local || null;
 }
 
-/** «Agente de <primer nombre>» (o null si la cuenta no tiene nombre ni correo). */
-export function nombreAgentePorDefecto(cuenta) {
+/**
+ * «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.
+ */
+export function nombreAgentePorDefecto(cuenta, slug = null) {
   const n = nombreDeCuenta(cuenta);
-  return n ? limpiarLinea(`Agente de ${n.split(/\s+/)[0]}`, 80) : null;
+  return n ? limpiarLinea(`Agente de ${n.split(/\s+/)[0]}${slug ? ` · ${slug}` : ''}`, 80) : null;
 }
 
 // ── listas de puntos (docs/producto.md §4) ──────────────────────────────────
@@ -179,6 +183,7 @@ export class Lienzo {
     this.intervaloEspera = INTERVALO_MS; // lo que lleva creciendo la espera de lienzo_esperar
     this.participantes = new Map();
     this.participantesEn = 0;
+    this._ausentes = new Map(); // id → cuándo se confirmó que no está en la sala (no se recarga todo por él cada vez)
     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)
@@ -195,14 +200,26 @@ export class Lienzo {
   /** 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; }
+  /** El slug de este puente (LIENZO_AGENTE), o null: el agente de siempre. */
+  get slug() { return this.config.agente ?? null; }
+
+  /** 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; }
 
-  /** ¿Este participante es de mi cuenta (mi persona o yo, su agente)? Lo mismo que esMio() en las reglas. */
+  /**
+   * ¿Esto es para mí? Mi persona o yo, ESTE agente. Más estrecho que esMio() de las reglas (que mira la cuenta
+   * entera): una tarea para otro agente de mi misma cuenta («Claude trabajo») no es de «Claude personal», aunque las
+   * reglas lo dejarían tocarla.
+   */
   esMio(id) {
     return Boolean(id) && (id === this.uid || id === this.participanteId);
   }
 
+  /** ¿Es otro agente de mi misma cuenta (no yo)? */
+  esOtroAgenteMio(id) {
+    return Boolean(id) && id !== this.participanteId && esAgenteDe(id, this.uid);
+  }
+
   link(salaId = this.salaId) {
     return `${this.config.webUrl}/sala/${salaId}`;
   }
@@ -231,7 +248,13 @@ export class Lienzo {
     return e;
   }
 
+  /** LIENZO_AGENTE que no deja un slug: el puente arranca igual y cada herramienta lo dice (no «MCP failed»). */
+  _exigirAgenteValido() {
+    if (this.config.errorAgente) throw new ErrorLienzo(this.config.errorAgente);
+  }
+
   async _asegurarSala() {
+    this._exigirAgenteValido();
     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'); });
@@ -323,8 +346,19 @@ export class Lienzo {
 
   async _participante(id) {
     if (!id) return null;
-    if (!this.participantes.has(id)) await this._cargarParticipantes(true);
-    return this.participantes.get(id) || null;
+    if (this.participantes.has(id)) return this.participantes.get(id);
+    // Un id que no está fuerza una recarga (quien entró recién). Pero si ya se confirmó hace poco que no está (alguien
+    // que salió, o un paraId inventado), no se vuelve a leer la sala entera (hasta 500) por cada tarjeta que lo nombre.
+    const ausente = this._ausentes.get(id);
+    if (ausente != null && Date.now() - ausente < RECARGA_PARTICIPANTES_MS) return null;
+    await this._cargarParticipantes(true);
+    const p = this.participantes.get(id) || null;
+    if (p) this._ausentes.delete(id);
+    else {
+      if (this._ausentes.size >= 500) this._ausentes.clear();
+      this._ausentes.set(id, Date.now());
+    }
+    return p;
   }
 
   /** Cuántos participantes de la sala se llaman igual que `id` (1 = nombre único). */
@@ -392,6 +426,7 @@ export class Lienzo {
    * nombre: el que se pase, LIENZO_NOMBRE o «Agente de <primer nombre de la cuenta>».
    */
   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);
@@ -401,7 +436,7 @@ export class Lienzo {
     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();
+    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.');
@@ -423,14 +458,23 @@ export class Lienzo {
     };
     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'] });
+      if (previo) datos.conectadoEn = previo.conectadoEn ? marcaDeTiempo(previo.conectadoEn) : null;
+      const escrituras = [{
+        ruta, datos, opciones: { horaServidor: previo?.conectadoEn ? ['vistoEn'] : ['vistoEn', 'conectadoEn'] },
+      }];
+      // Un agente con nombre entra en el MISMO :commit que su slug en el índice de la cuenta (las reglas lo exigen:
+      // así se cumple el tope y el índice nunca lista a alguien que no está). appendMissingElements: tres puentes
+      // de la misma cuenta que entran a la vez no se pisan el índice.
+      if (this.slug) {
+        escrituras.push({
+          ruta: `salas/${salaId}/cuentas/${this.uid}`, datos: {}, opciones: { mascara: [], agregar: { agentes: [this.slug] } },
+        });
       }
+      commit = await this.fs.escribirVarios(escrituras);
     } catch (e) {
-      const texto = negadoDe(e) ? await this.explicarNegado(salaId, { alUnirse: true }).catch(() => null) : null;
+      const texto = negadoDe(e)
+        ? (await this.explicarNegado(salaId, { alUnirse: true }).catch(() => null)) ?? (await this._explicarTope(salaId).catch(() => null))
+        : null;
       throw texto ? new ErrorLienzo(texto, { cause: e }) : this._traducir(e, 'unirte a la sala');
     }
 
@@ -451,11 +495,22 @@ export class Lienzo {
       this.listas.clear();
       this.participantes.clear();
       this.participantesEn = 0;
+      this._ausentes.clear();
     }
     await this._anotarEnIndice(salaId);
     return { salaId, sala, link: this.link(salaId), yo: this.yo };
   }
 
+  /** Un agente con nombre que no entra: ¿es por el tope? (solo se mira cuando ya falló) */
+  async _explicarTope(salaId) {
+    if (!this.slug) return null;
+    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.`;
+  }
+
   // ── cuenta ─────────────────────────────────────────────────────────────────
   /** Olvida la sala (la sesión pasó a otra cuenta: lo de la sala era de la anterior). */
   _olvidarSala() {
@@ -498,7 +553,7 @@ export class Lienzo {
    * 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)
+   *  3. tu participante (`{uid}_agente` o `{uid}_agente_{slug}`) 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.
    */
@@ -578,6 +633,7 @@ export class Lienzo {
       conectado: p.vistoEn ? ahora - Date.parse(p.vistoEn) < CONECTADO_MS : false,
       soyYo: p.id === this.participanteId,
       miPersona: p.id === this.uid,
+      otroAgenteMio: this.esOtroAgenteMio(p.id),
       homonimos: this._homonimos(p.id),
     }));
   }
@@ -729,6 +785,12 @@ export class Lienzo {
     if (!soyDestinatario && !soyAutor) {
       throw new ErrorLienzo(`${que}: solo su destinatario o quien la pidió pueden cambiar su estado.`);
     }
+    // Una tarea para mi persona es de cualquiera de sus agentes, pero la atiende el primero que la toma: otro agente
+    // de la misma cuenta no la retoma ni responde por él (su respuesta saldría firmada por el que la tomó).
+    if (soyDestinatario && t.tomadaPor && this.esOtroAgenteMio(t.tomadaPor) && !CERRADOS.has(t.estado)) {
+      const quien = limpiarLinea(this.participantes.get(t.tomadaPor)?.nombre ?? abreviarId(t.tomadaPor));
+      throw new ErrorLienzo(`${que}: ya la tomó ${quien}, otro agente de tu usuario. Déjasela a él (o que la reabra).`);
+    }
     const cambios = { estado };
     const mascara = ['estado'];
     const tomadaPor = (v) => { cambios.tomadaPor = v; mascara.push('tomadaPor'); };
@@ -973,7 +1035,9 @@ export class Lienzo {
   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` : ''})`;
+    // otro agente de tu misma cuenta: no eres tú, aunque las reglas te dejarían tocar lo suyo
+    const mio = this.esOtroAgenteMio(id) ? 'otro agente de tu usuario, ' : '';
+    return `${limpiarLinea(p.nombre)} (${mio}id: ${abreviarId(id)}${p.homonimos > 1 ? `; OJO: ${p.homonimos} se llaman igual` : ''})`;
   }
 
   /**
@@ -1079,9 +1143,9 @@ export class Lienzo {
     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;
+    // Sin `dueño`, la persona de su cuenta: las reglas atan `{uid}_agente` (y `{uid}_agente_{slug}`) a `uid`.
+    const sinDueño = dest?.tipo === 'agente' && !String(dest['dueño'] ?? '').trim() && cuentaDe(dest.id) !== String(dest.id ?? '');
+    const persona = sinDueño ? await this._autor(cuentaDe(dest.id)) : 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) ?? '?';
@@ -1217,9 +1281,18 @@ export class Lienzo {
    * (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 })}`;
+  async formatearLote(lote, o = {}) {
+    return (await this.formatearLoteDetalle(lote, o)).texto;
+  }
+
+  /**
+   * formatearLote con el dato de si quedó algo sin entregar (`recortado`: tope de caracteres o más de
+   * LIMITE_CONSULTA tarjetas), sin tener que buscarlo en el texto (que también trae lo que escribieron otros).
+   * sinPie: sin los párrafos finales («Respuesta recortada…», «Había más de…», «marca: …»), para el canal.
+   */
+  async formatearLoteDetalle(lote, { codigo = nuevoCodigo(), max = MAX_RESPUESTA, sinPie = false } = {}) {
+    if (lote.una) return { texto: await this._formatearUna(lote.una, { codigo, max, desdeCaracter: lote.desdeCaracter }), recortado: false };
+    if (lote.lista) return { texto: `${aviso(codigo)}\n\n${await this._formatearLista(lote.lista.padre, lote.lista.puntos, { codigo, max })}`, recortado: false };
     const { tarjetas = [], editadas = [], cambios = [], soloAjenas = false, lleno = false } = lote;
     const nuevas = new Set(tarjetas.map((t) => t.id));
     const items = [
@@ -1259,6 +1332,8 @@ export class Lienzo {
     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.');
+    const recortado = cortado || Boolean(lleno);
+    if (sinPie) return { texto: partes.join('\n\n'), recortado };
     if (cortado) {
       const total = quedan.cambios + quedan.editadas + quedan.tarjetas;
       const desglose = [
@@ -1273,6 +1348,6 @@ export class Lienzo {
     }
     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');
+    return { texto: partes.join('\n\n'), recortado };
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ajuarezso/lienzo-mcp",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Servidor MCP de Lienzo: une tu agente (Claude Code u otro cliente MCP) a una sala compartida con los agentes de otras personas. / MCP server that joins your agent to a room shared with other people's agents.",
   "keywords": [
     "mcp",