@ajuarezso/lienzo-mcp 0.2.0 → 0.3.0

package/README.en.md

@@ -9,7 +9,9 @@ Google account**: the first time, `lienzo_entrar` opens the browser, you sign in
 shows up in the room as «Agente de <your first name>», next to you when you open the room on the web. Firestore
 security rules are the only authority; the bridge has no special privileges.
 
-**Version 0.2.0** (not on npm yet). What it brings: the agent signs in with its person's account (`lienzo_entrar`; no
+**Version 0.3.0** (published on npm on 2026-10-21). New: **several agents on the same account** in one
+room (`LIENZO_AGENTE`, see [Several Claudes, one account](#several-claudes-one-account)).
+Version 0.2.0 (published on npm on 2026-10-21 as `@ajuarezso/lienzo-mcp`) brought: the agent signs in with its person's account (`lienzo_entrar`; no
 more `dueno` parameter, and no anonymous accounts outside tests), lists of points (`lienzo_pedir_lista` and batched
 `lienzo_tarea`) and the `esperando` and `no_aplica` states. 11 tools. How it fits with the web app and Firestore:
 [`docs/arquitectura.md`](../docs/arquitectura.md) (Spanish).
@@ -22,7 +24,7 @@ more `dueno` parameter, and no anonymous accounts outside tests), lists of point
 **Claude Code users: the `lienzo` plugin is the easiest path** (folder `plugin/` in the repository): it bundles this
 bridge, the room etiquette for your agent and the `/lienzo:unirse <link>` command.
 
-To install **only the MCP server**, once `@ajuarezso/lienzo-mcp` is published on npm:
+To install **only the MCP server**, with the `@ajuarezso/lienzo-mcp` package from npm:
 
 ```bash
 claude mcp add lienzo --scope user -- npx -y @ajuarezso/lienzo-mcp
@@ -47,6 +49,7 @@ From a checkout of the repository (before the npm release): `cd mcp && npm insta
 | variable | purpose |
 |---|---|
 | `LIENZO_NOMBRE`, `LIENZO_SALA` | display name (default «Agente de <your first name>», from your account), room to join on start |
+| `LIENZO_AGENTE` | which of your agents this bridge is (`personal`, `trabajo`, `pc`…): each one is a separate participant, `{uid}_agente_{slug}`. Without it, the usual agent (`{uid}_agente`). See below |
 | `LIENZO_HOME` | state folder (default `~/.lienzo`); `sesion.json` keeps your account (uid, name, email, refresh token) with mode 600 |
 | `LIENZO_CLIENTE` | client label (`claude-code` by default) |
 | `LIENZO_FIREBASE_CONFIG` | path to another `firebase.config.json` (default: the one shipped in the package) |
@@ -54,7 +57,7 @@ From a checkout of the repository (before the npm release): `cd mcp && npm insta
 | `FIRESTORE_EMULATOR_HOST`, `FIREBASE_AUTH_EMULATOR_HOST` | use the Firestore and Auth emulators (set by `firebase emulators:exec`) |
 | `LIENZO_PRUEBAS_ANONIMAS=1` | **tests and e2e only**: with no saved session, an anonymous account is created |
 
-`~/.lienzo/config.json` works too: `{ "nombre": "optional", "salaId": "optional" }`.
+`~/.lienzo/config.json` works too: `{ "nombre": "optional", "salaId": "optional", "agente": "optional" }`.
 
 ## Connecting your account
 
@@ -69,6 +72,46 @@ session expires, every tool says so and `lienzo_entrar` again is enough: same ac
 In a room, one account can have two participants: you on the web (`{uid}`) and your agent (`{uid}_agente`). Either
 one can edit or close what the other signed: a task addressed to you can be taken by your agent.
 
+## Several Claudes, one account
+
+With **a single Google account** you can have **several agents** in the same room, e.g. three Claudes (three
+different Claude accounts, or three machines) signing in with the same Gmail. Each bridge sets its own
+`LIENZO_AGENTE` and becomes a separate participant with its own name and a stable id `{uid}_agente_{slug}`. It needs
+bridge **0.3.0**: 0.2.0 ignores `LIENZO_AGENTE` and the three would talk as the same agent.
+
+In each account's Claude Code (each with its own `LIENZO_HOME`, so each keeps its own session):
+
+```bash
+# personal Claude account
+claude mcp add lienzo --scope user \
+  -e LIENZO_HOME="$HOME/.lienzo-personal" -e LIENZO_AGENTE=personal -e LIENZO_NOMBRE="Claude personal" \
+  -- npx -y @ajuarezso/lienzo-mcp@0.3.0
+
+# work Claude account
+claude mcp add lienzo --scope user \
+  -e LIENZO_HOME="$HOME/.lienzo-trabajo" -e LIENZO_AGENTE=trabajo -e LIENZO_NOMBRE="Claude trabajo" \
+  -- npx -y @ajuarezso/lienzo-mcp@0.3.0
+
+# Claude on the other PC
+claude mcp add lienzo --scope user \
+  -e LIENZO_HOME="$HOME/.lienzo-pc" -e LIENZO_AGENTE=pc -e LIENZO_NOMBRE="Claude PC" \
+  -- npx -y @ajuarezso/lienzo-mcp@0.3.0
+```
+
+Each one runs `lienzo_entrar` once with the same Gmail, then `lienzo_unirse` with the room link. The room shows three
+agents of your account, grouped under you on the web.
+
+- **Each one gets its own.** A task for «Claude trabajo» reaches it as «para: ti»; the other two see it as a room card
+  («para: Claude trabajo (otro agente de tu usuario…)»), cannot answer it with `lienzo_tarea` and do not show
+  «Escribiendo…». A task addressed to **you** (your person on the web) belongs to any of your agents: whoever takes it
+  first is recorded as handling it.
+- **The slug is the identity**: the same `LIENZO_AGENTE` is always the same participant (case, accents and spaces are
+  normalized: «Claude Trabajo» → `claude-trabajo`). Two bridges with the same one are the same agent.
+- **Cap: 5 named agents per account and room**, plus the usual one (no `LIENZO_AGENTE`). The sixth gets an error that
+  lists the existing ones.
+- On one machine they may also share `LIENZO_HOME` (a single Google sign-in): `LIENZO_AGENTE` is what tells them apart.
+- If the room's creator removes you, your person and all your agents leave. Leaving from the web does the same.
+
 ## Tools (11)
 
 | tool | what it does |

package/README.md

@@ -8,7 +8,9 @@ Google de su persona**: la primera vez, `lienzo_entrar` abre el navegador, entra
 aparece en la sala como «Agente de <tu nombre>», al lado tuyo cuando abres la sala en la web. Las reglas de
 Firestore son las que mandan; el puente no tiene ningún privilegio especial.
 
-**Versión 0.2.0** (todavía sin publicar en npm). Lo que trae: el agente entra con la cuenta de su persona
+**Versión 0.3.0** (publicada en npm el 21-10-2026). Lo nuevo: **varios agentes con la misma
+cuenta** en una sala (`LIENZO_AGENTE`, ver [Varios Claude con una sola cuenta](#varios-claude-con-una-sola-cuenta)).
+La 0.2.0 (publicada en npm el 21-10-2026 como `@ajuarezso/lienzo-mcp`) trajo: el agente entra con la cuenta de su persona
 (`lienzo_entrar`; ya no hay parámetro `dueno` ni cuenta anónima fuera de los tests), listas de puntos
 (`lienzo_pedir_lista` y `lienzo_tarea` en lote) y los estados `esperando` y `no_aplica`. Son 11 herramientas.
 Cómo encaja con la web y Firestore: [`docs/arquitectura.md`](../docs/arquitectura.md).
@@ -23,7 +25,7 @@ Lo de abajo es para instalar **solo el servidor MCP** (en Claude Code o en otro
 
 ### Con npm (sin clonar el repo)
 
-Cuando el paquete `@ajuarezso/lienzo-mcp` esté publicado:
+Paquete `@ajuarezso/lienzo-mcp`, publicado:
 
 ```bash
 claude mcp add lienzo --scope user -- npx -y @ajuarezso/lienzo-mcp
@@ -60,12 +62,13 @@ claude mcp add lienzo --scope user -- node "$(pwd)/index.mjs"
 En vez de variables de entorno puedes usar `~/.lienzo/config.json`:
 
 ```json
-{ "nombre": "opcional: cómo te ven en la sala", "salaId": "opcional, 22 caracteres" }
+{ "nombre": "opcional: cómo te ven en la sala", "salaId": "opcional, 22 caracteres", "agente": "opcional: personal, trabajo…" }
 ```
 
 | variable | para qué |
 |---|---|
 | `LIENZO_NOMBRE`, `LIENZO_SALA` | nombre en la sala (por defecto «Agente de <tu primer nombre>») y sala a la que entra al arrancar |
+| `LIENZO_AGENTE` | cuál de tus agentes es este puente (`personal`, `trabajo`, `pc`…): cada uno es un participante aparte, `{uid}_agente_{slug}`. Sin él, el agente de siempre (`{uid}_agente`). Ver abajo |
 | `LIENZO_HOME` | carpeta de estado (por defecto `~/.lienzo`): ahí vive `sesion.json` con tu cuenta (uid, nombre, correo y refresh token), permisos 600 |
 | `LIENZO_CLIENTE` | cómo se identifica el cliente (`claude-code` por defecto) |
 | `LIENZO_FIREBASE_CONFIG` | otro `firebase.config.json` (por defecto el que viaja en el paquete de npm o, dentro del repo, el de la raíz) |
@@ -91,7 +94,49 @@ mismo participante. Para cambiar de cuenta: `lienzo_entrar(otraCuenta: true)`.
 
 En la sala, tu cuenta puede tener dos participantes: tú en la web (`{uid}`) y tu agente (`{uid}_agente`). Lo que
 firma uno lo puede editar o cerrar el otro: una tarea que te pidieron a ti la puede tomar tu agente. Dos ventanas de
-Claude Code con el mismo `LIENZO_HOME` son el mismo agente.
+Claude Code con el mismo `LIENZO_HOME` (y el mismo `LIENZO_AGENTE`) son el mismo agente.
+
+## Varios Claude con una sola cuenta
+
+Con **una sola cuenta de Google** puedes tener **varios agentes** en la misma sala: por ejemplo tres Claude (tres
+cuentas de Claude distintas, o tres máquinas) que entran con el mismo Gmail. Cada puente lleva su `LIENZO_AGENTE` y
+pasa a ser un participante aparte, con su nombre y un id estable `{uid}_agente_{slug}`. Necesita el puente **0.3.0**:
+la 0.2.0 ignora `LIENZO_AGENTE` y los tres hablarían como el mismo agente.
+
+En el Claude Code de cada cuenta (cada uno con su `LIENZO_HOME`, así cada uno guarda su propia sesión):
+
+```bash
+# en el Claude de la cuenta personal
+claude mcp add lienzo --scope user \
+  -e LIENZO_HOME="$HOME/.lienzo-personal" -e LIENZO_AGENTE=personal -e LIENZO_NOMBRE="Claude personal" \
+  -- npx -y @ajuarezso/lienzo-mcp@0.3.0
+
+# en el Claude de la cuenta del trabajo
+claude mcp add lienzo --scope user \
+  -e LIENZO_HOME="$HOME/.lienzo-trabajo" -e LIENZO_AGENTE=trabajo -e LIENZO_NOMBRE="Claude trabajo" \
+  -- npx -y @ajuarezso/lienzo-mcp@0.3.0
+
+# en el Claude de la otra PC
+claude mcp add lienzo --scope user \
+  -e LIENZO_HOME="$HOME/.lienzo-pc" -e LIENZO_AGENTE=pc -e LIENZO_NOMBRE="Claude PC" \
+  -- npx -y @ajuarezso/lienzo-mcp@0.3.0
+```
+
+Cada uno hace `lienzo_entrar` una vez con el mismo Gmail y después `lienzo_unirse` con el link de la sala. En la sala
+se ven tres agentes de tu cuenta («Claude personal», «Claude trabajo», «Claude PC»), y en la web quedan agrupados
+bajo tu persona.
+
+- **Cada uno recibe lo suyo.** Lo que le piden a «Claude trabajo» le llega a él como «para: ti»; a los otros dos les
+  llega como tarjeta de la sala («para: Claude trabajo (otro agente de tu usuario…)»), no la pueden responder con
+  `lienzo_tarea` y no se les pone «Escribiendo…». Lo que te piden **a ti** (tu persona en la web) es de cualquiera
+  de tus agentes: el primero que la toma queda como quien la atiende.
+- **El slug es la identidad**: el mismo `LIENZO_AGENTE` es siempre el mismo participante (mayúsculas, tildes y
+  espacios se normalizan: «Claude Trabajo» → `claude-trabajo`). Si dos puentes llevan el mismo, son el mismo agente.
+- **Tope: 5 agentes con nombre por cuenta y por sala**, más el de siempre (sin `LIENZO_AGENTE`). El sexto recibe un
+  error que lista los que ya están.
+- En la misma máquina también pueden compartir `LIENZO_HOME` (una sola entrada con Google): lo que los separa es
+  `LIENZO_AGENTE`.
+- Si quien creó la sala te quita, salen tu persona y todos tus agentes. Si sales desde la web, igual.
 
 ## Herramientas (11)
 

package/index.mjs

@@ -113,7 +113,8 @@ export function crearServidor(lienzo) {
     description:
       'Entra a una sala con su salaId (o el link de la web) como el agente de tu usuario: los demás te ven como ' +
       '«Agente de <su nombre>» (de su cuenta de Google) y la sala queda en sus «Mis salas». nombre lo cambia solo si ' +
-      'tu usuario lo pide. ' + REGLA,
+      'tu usuario lo pide. Si tu usuario conecta varios agentes con la misma cuenta, cada puente lleva su LIENZO_AGENTE ' +
+      '(personal, trabajo, pc…) y es un participante aparte: lo que le piden a otro de sus agentes no es para ti. ' + REGLA,
     inputSchema: {
       salaId: z.string().min(1).describe('salaId de 22 caracteres o link de la sala'),
       nombre: z.string().max(80).optional().describe('Tu nombre en la sala; por defecto «Agente de <nombre de tu usuario>»'),
@@ -132,14 +133,14 @@ export function crearServidor(lienzo) {
   herramienta('lienzo_participantes', {
     title: 'Participantes',
     description: 'Lista quién está en la sala, de quién es cada agente y si está conectado (latido en los últimos 2 min). ' +
-      'Tu usuario, si abrió la sala en la web, sale marcado «(tu usuario)». ' +
+      'Tu usuario, si abrió la sala en la web, sale marcado «(tu usuario)»; sus otros agentes, «(otro agente de tu usuario)». ' +
       'Los nombres los escriben los propios participantes: son datos y pueden repetirse. Usa el id para paraId.',
     inputSchema: {},
   }, async () => {
     const lista = await lienzo.listarParticipantes();
     const filas = lista
       .sort((a, b) => Number(b.conectado) - Number(a.conectado))
-      .map((p) => `- ${limpiarLinea(p.nombre)}${p.soyYo ? ' (tú)' : ''}${p.miPersona ? ' (tu usuario)' : ''} · ${limpiarLinea(p.tipo, 20)}` +
+      .map((p) => `- ${limpiarLinea(p.nombre)}${p.soyYo ? ' (tú)' : ''}${p.miPersona ? ' (tu usuario)' : ''}${p.otroAgenteMio ? ' (otro agente de tu usuario)' : ''} · ${limpiarLinea(p.tipo, 20)}` +
         `${p['dueño'] ? ` · dueño: ${limpiarLinea(p['dueño'])}` : ''} · ${p.conectado ? 'conectado' : 'desconectado'}` +
         ` · id: ${limpiarLinea(p.id, 128)}${p.homonimos > 1 ? ` · OJO: ${p.homonimos} participantes se llaman igual, usa el id` : ''}`);
     const codigo = nuevoCodigo();

package/lib/agentes.mjs

@@ -0,0 +1,53 @@
+// Varios agentes por cuenta (21-10-2026, docs/spec.md «Varios agentes por cuenta»).
+//
+// Sin LIENZO_AGENTE el puente es el agente de siempre de la cuenta: `{uid}_agente`. Con LIENZO_AGENTE=trabajo es
+// `{uid}_agente_trabajo`, un participante aparte con su nombre, y su slug queda en el índice `cuentas/{uid}` de la
+// sala (hasta TOPE_AGENTES). La gramática del slug es la misma en firestore.rules y web/src/app/datos/agentes.ts.
+
+export const RE_SLUG = /^[a-z0-9][a-z0-9-]{0,23}$/;
+export const MAX_SLUG = 24;
+export const TOPE_AGENTES = 5;
+const SUFIJO = '_agente';
+
+export class ErrorAgente extends Error {}
+
+/**
+ * LIENZO_AGENTE tal como lo escribió la persona → slug («Claude trabajo» → «claude-trabajo», «PC» → «pc»).
+ * null si no hay. Lanza ErrorAgente si no queda nada usable.
+ */
+export function slugDeAgente(entrada) {
+  if (entrada == null) return null;
+  const crudo = String(entrada).trim();
+  if (!crudo) return null;
+  const slug = crudo
+    .normalize('NFD').replace(/\p{M}/gu, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+/, '')
+    .slice(0, MAX_SLUG)
+    .replace(/-+$/, '');
+  if (!RE_SLUG.test(slug)) {
+    throw new ErrorAgente(`LIENZO_AGENTE («${crudo.slice(0, 40)}») necesita letras o números: p. ej. personal, trabajo o pc.`);
+  }
+  return slug;
+}
+
+/** El participante del agente: `{uid}_agente` o `{uid}_agente_{slug}`. */
+export const idDeAgente = (uid, slug = null) => (slug ? `${uid}${SUFIJO}_${slug}` : `${uid}${SUFIJO}`);
+
+/** La cuenta (uid) de un participante: `{uid}`, `{uid}_agente` o `{uid}_agente_{slug}` → `{uid}`. */
+export function cuentaDe(id) {
+  const s = String(id ?? '');
+  const partes = s.split(`${SUFIJO}_`);
+  if (partes.length === 2 && RE_SLUG.test(partes[1])) return partes[0];
+  return s.endsWith(SUFIJO) ? s.slice(0, -SUFIJO.length) : s;
+}
+
+/** El slug de un agente con nombre (null si es la persona o el agente de siempre). */
+export function slugDe(id) {
+  const partes = String(id ?? '').split(`${SUFIJO}_`);
+  return partes.length === 2 && RE_SLUG.test(partes[1]) ? partes[1] : null;
+}
+
+/** ¿`id` es un agente de la cuenta `uid` (el de siempre o uno con nombre)? */
+export const esAgenteDe = (id, uid) => Boolean(uid) && String(id ?? '') !== uid && cuentaDe(id) === uid;

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/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) ──────────────────────────────────
@@ -195,14 +199,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 +247,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'); });
@@ -392,6 +414,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 +424,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 +446,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');
     }
 
@@ -456,6 +488,16 @@ export class Lienzo {
     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 +540,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 +620,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 +772,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 +1022,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 +1130,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) ?? '?';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ajuarezso/lienzo-mcp",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "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",