@ajuarezso/lienzo-mcp 0.4.0 → 0.6.0

package/lib/menciones.mjs

@@ -0,0 +1,200 @@
+// Menciones y tope de turnos entre agentes (F2, docs/rediseno-chat-lienzo.md §6).
+//
+// · `menciones` es un campo opcional de la tarjeta: lista de ids de participantes (hasta MAX_MENCIONES). El puente
+//   acepta ids o nombres y los resuelve contra la sala (un nombre repetido no se adivina). «@todos» = sin menciones.
+// · Convención: un agente contesta en la sala solo si lo mencionan o si la tarjeta es para él (paraId).
+// · Tope: un TURNO es una tarjeta de un agente DIRIGIDA a otro agente (paraId, menciones o respondeA a una tarjeta de
+//   otro agente) que sigue a la de OTRO agente; la respuesta a una tarea por lienzo_tarea (tomadaPor = otro agente)
+//   cuenta como turno de quien responde aunque no cree tarjeta. Después de TOPE_TURNOS turnos sin una persona en
+//   medio, el puente no publica nada dirigido a otro agente, y cada agente tiene UNA tarjeta más (a toda la sala o a
+//   una persona) para avisar que esperan a alguien. Lo que no va a otro agente no suma: varios agentes que publican
+//   avances para sus personas no se frenan entre sí. Una lista de puntos cuenta como una sola tarjeta.
+//   Las reglas de Firestore no pueden contarlo (no hay consultas entre documentos): es convención del puente.
+import { cuentaDe } from './agentes.mjs';
+
+export const MAX_MENCIONES = 10;
+export const TOPE_TURNOS = 6;
+/**
+ * El puente lee las tarjetas recientes de a PAGINA_TURNOS, de la más nueva a la más vieja, hasta dar con una de una
+ * persona (lo anterior no cuenta) o hasta PAGINAS_TURNOS páginas. Si en VENTANA_TURNOS tarjetas no escribió ninguna
+ * persona y hay más viejas, se trata como tope (`sinPersona`): así llenar la sala de tarjetas (una lista de 30 puntos)
+ * no reinicia la cuenta. Lo normal es una sola lectura de PAGINA_TURNOS.
+ */
+export const PAGINA_TURNOS = 16;
+export const PAGINAS_TURNOS = 3;
+export const VENTANA_TURNOS = PAGINA_TURNOS * PAGINAS_TURNOS;
+
+/** Palabras que significan «toda la sala» (no son una mención). */
+const TODOS = new Set(['todos', 'todas', 'all', 'everyone', 'sala']);
+
+/** ¿El participante es una persona? `{uid}` sí; `{uid}_agente` y `{uid}_agente_{slug}` no. */
+export const esPersona = (id) => Boolean(id) && cuentaDe(id) === String(id);
+
+/** ¿Es un agente? (cualquier participante que no es una persona) */
+export const esAgente = (id) => Boolean(id) && !esPersona(id);
+
+/**
+ * Las menciones tal como las pasó el agente → referencias limpias (sin «@», sin repetidos, sin «todos»).
+ * Lanza Error con el texto para el agente si no es una lista o trae más de MAX_MENCIONES.
+ */
+export function referenciasDeMenciones(menciones) {
+  if (menciones == null) return [];
+  if (!Array.isArray(menciones)) throw new Error('menciones es una lista de ids o nombres de participantes.');
+  const refs = [];
+  const vistas = new Set();
+  for (const m of menciones) {
+    const r = String(m ?? '').trim().replace(/^@+/, '').trim();
+    if (!r) continue;
+    if (TODOS.has(r.toLowerCase())) continue;
+    const clave = r.toLowerCase();
+    if (vistas.has(clave)) continue;
+    vistas.add(clave);
+    refs.push(r);
+  }
+  if (refs.length > MAX_MENCIONES) {
+    throw new Error(`Una tarjeta menciona hasta ${MAX_MENCIONES} participantes (trae ${refs.length}). Para toda la sala, publica sin menciones.`);
+  }
+  return refs;
+}
+
+/** Las menciones guardadas en una tarjeta (lo que venga: solo strings, sin repetidos, a lo sumo MAX_MENCIONES). */
+export function mencionesDe(t) {
+  const m = t?.menciones;
+  if (!Array.isArray(m)) return [];
+  return [...new Set(m.filter((x) => typeof x === 'string' && x))].slice(0, MAX_MENCIONES);
+}
+
+/** ¿La tarjeta menciona a `id`? */
+export const menciona = (t, id) => Boolean(id) && mencionesDe(t).includes(id);
+
+// ── turnos ─────────────────────────────────────────────────────────────────
+// La misma lógica vive en la web (web/src/app/sala/chat/turnos.ts) para la fila «los agentes van N turnos»: un
+// cambio acá va también allá, con sus tests.
+
+const RE_PUNTO = /^(.+)-p\d{2}$/;
+
+/** ¿Es un punto de una lista (id «<lista>-pNN» que responde a la lista)? Cuenta junto con su lista, no aparte. */
+export const esPuntoDeLista = (t) => Boolean(t?.respondeA) && RE_PUNTO.exec(String(t.id ?? ''))?.[1] === t.respondeA;
+
+/** A quiénes va una tarjeta: paraId, menciones y el autor de la tarjeta a la que responde (si se conoce). */
+export function destinosDe(t, autorDe = () => null) {
+  const d = [t?.paraId, ...mencionesDe(t)];
+  if (t?.respondeA) d.push(autorDe(t.respondeA));
+  return [...new Set(d.filter((x) => typeof x === 'string' && x))];
+}
+
+/** ¿Algún destino es un agente que no es quien publica? */
+export const vaAOtroAgente = (autorId, destinos) => (destinos ?? []).some((d) => d && d !== autorId && esAgente(d));
+
+/**
+ * Lo que una tarjeta aporta a la racha, en orden: { autor, persona } o { autor, dirigido }. Un punto de lista no
+ * aporta nada (va con su lista). Una tarea de un agente que tomó o respondió OTRO agente suma después la respuesta
+ * de ese agente (lienzo_tarea no crea tarjeta, pero es contestarle al que pidió).
+ */
+export function eventosDe(t, autorDe = () => null) {
+  if (!t?.autorId || esPuntoDeLista(t)) return [];
+  if (esPersona(t.autorId)) return [{ autor: t.autorId, persona: true }];
+  const eventos = [{ autor: t.autorId, dirigido: vaAOtroAgente(t.autorId, destinosDe(t, autorDe)) }];
+  if (t.tipo === 'tarea' && esAgente(t.tomadaPor) && t.tomadaPor !== t.autorId) eventos.push({ autor: t.tomadaPor, dirigido: true });
+  return eventos;
+}
+
+/**
+ * Racha: turnos agente↔agente desde la última persona, el autor del último paso dirigido a un agente, los agentes
+ * que ya usaron su tarjeta de salida después del tope y si la cuenta es por no haber visto a ninguna persona.
+ */
+export const RACHA_VACIA = Object.freeze({ turnos: 0, ultimo: null, salidas: Object.freeze([]), sinPersona: false });
+
+/** Suma un evento (eventosDe) a la racha. */
+export function sumarEvento(r, e) {
+  if (!e?.autor) return r;
+  if (e.persona) return { ...RACHA_VACIA, ultimo: e.autor };
+  if (!e.dirigido) {
+    // antes del tope no cuenta; después, es la única tarjeta que le queda a ese agente hasta que escriba una persona
+    return r.turnos >= TOPE_TURNOS && !r.salidas.includes(e.autor) ? { ...r, salidas: [...r.salidas, e.autor] } : r;
+  }
+  if (e.autor === r.ultimo) return r; // el mismo agente sigue: no es un turno nuevo
+  return { ...r, turnos: r.ultimo && esAgente(r.ultimo) ? r.turnos + 1 : r.turnos, ultimo: e.autor };
+}
+
+/** Suma una tarjeta a la racha (en orden de creación). */
+export const sumarTarjeta = (r, t, autorDe) => eventosDe(t, autorDe).reduce(sumarEvento, r);
+
+/** La racha de una lista de tarjetas en orden de creación (de la más vieja a la más nueva). */
+export function rachaDe(tarjetas, inicio = RACHA_VACIA) {
+  const autorDe = autoresDe(tarjetas);
+  return (tarjetas ?? []).reduce((r, t) => sumarTarjeta(r, t, autorDe), inicio);
+}
+
+const autoresDe = (tarjetas) => {
+  const porId = new Map((tarjetas ?? []).filter((t) => t?.id).map((t) => [t.id, t.autorId]));
+  return (id) => porId.get(id) ?? null;
+};
+
+/**
+ * La racha de las tarjetas recientes tal como las devuelve la consulta (de la más NUEVA a la más vieja). Cuenta solo
+ * desde la última tarjeta de una persona. `agotada` = no hay tarjetas más viejas que estas. Sin persona a la vista y
+ * con más tarjetas detrás, la racha arranca en el tope (`sinPersona`): nadie mira desde hace VENTANA_TURNOS tarjetas.
+ */
+export function rachaDeRecientes(nuevasPrimero, { agotada = true } = {}) {
+  const lista = nuevasPrimero ?? [];
+  const autorDe = autoresDe(lista);
+  const tramo = [];
+  let persona = null;
+  for (const t of lista) {
+    if (t?.autorId && esPersona(t.autorId)) { persona = t.autorId; break; }
+    tramo.push(t);
+  }
+  let inicio = RACHA_VACIA;
+  if (persona) inicio = { ...RACHA_VACIA, ultimo: persona };
+  else if (!agotada) inicio = { ...RACHA_VACIA, turnos: TOPE_TURNOS, sinPersona: true };
+  return tramo.reverse().reduce((r, t) => sumarTarjeta(r, t, autorDe), inicio);
+}
+
+/**
+ * ¿Publicar ahora pasaría el tope? Con TOPE_TURNOS turnos (o sin persona a la vista): nada dirigido a otro agente;
+ * lo demás (a toda la sala o a personas) pasa una vez por agente, para llamar a alguien. Sin persona a la vista la
+ * salida no se acaba: la sala solo tiene agentes y lo que no va a otro agente no gasta a nadie.
+ * @param {{ turnos: number, salidas: string[], sinPersona?: boolean }} racha
+ * @param {string} yo  el participante que publica
+ * @param {boolean} dirigido  ¿lo que publica va a otro agente? (vaAOtroAgente)
+ */
+export function pasaElTope(racha, yo, dirigido) {
+  if (!racha || racha.turnos < TOPE_TURNOS) return false;
+  if (dirigido) return true;
+  if (racha.sinPersona) return false;
+  return (racha.salidas ?? []).includes(yo);
+}
+
+const porQue = (racha) => (racha.sinPersona
+  ? `en las últimas ${VENTANA_TURNOS} tarjetas de la sala no escribió ninguna persona`
+  : `los agentes ya llevan ${racha.turnos} turnos seguidos contestándose sin que escriba una persona (el tope de Lienzo es ${TOPE_TURNOS})`);
+
+/** El mensaje con el que el puente rechaza la publicación que pasaría el tope. */
+export function textoTope(racha, dirigido = true) {
+  if (dirigido) {
+    return `No publiqué: ${porQue(racha)}, y esto va a otro agente (paraId, menciones o respondeA). Avísale a tu ` +
+      'usuario qué quedó pendiente y espera a que una persona escriba en la sala (lienzo_esperar). Si necesitas que ' +
+      'alguien decida, publica UNA tarjeta para una persona (paraId o menciones con el id de una persona) o para toda la sala.';
+  }
+  return `No publiqué: ${porQue(racha)}, y ya usaste tu tarjeta para avisar. Hasta que escriba una persona no ` +
+    'publicas más en esta sala: cuéntale a tu usuario qué quedó pendiente y espera (lienzo_esperar).';
+}
+
+/** La línea que el puente agrega a lo que entrega cuando la sala llegó al tope (null si no). */
+export function lineaTope(racha) {
+  if (!racha || racha.turnos < TOPE_TURNOS) return null;
+  return `Turnos entre agentes: ${racha.sinPersona ? `ninguna persona escribió en las últimas ${VENTANA_TURNOS} tarjetas` : `${racha.turnos} seguidos sin una persona en medio`} ` +
+    `(tope ${TOPE_TURNOS}). No le escribas a otro agente hasta que escriba una persona: el puente no lo publica. Avísale ` +
+    'a tu usuario; si hace falta que alguien decida, tienes UNA tarjeta para una persona o para la sala.';
+}
+
+/** Texto de la convención, para las instructions del servidor, la skill y los prompts. */
+export const CONVENCION =
+  'CUÁNDO CONTESTAR EN LA SALA: contesta solo si te mencionan (te lo dice «te mencionan») o si la tarjeta es para ti ' +
+  '(para: ti). Lo que va a toda la sala o a otros, léelo y cuéntaselo a tu usuario si le sirve, sin contestar. Para ' +
+  'nombrar a alguien usa menciones en lienzo_publicar (ids o nombres; sin menciones = toda la sala). Tope: después de ' +
+  `${TOPE_TURNOS} turnos seguidos entre agentes sin que escriba una persona (pedir una tarea a otro agente y que te ` +
+  'la responda también son turnos), el puente no publica nada dirigido a otro agente y te deja UNA tarjeta más, para ' +
+  'una persona o para la sala, para avisar que esperan a alguien. Así dos agentes no gastan las cuentas de sus ' +
+  'personas sin que nadie mire.';

package/lib/salir.mjs

@@ -0,0 +1,83 @@
+// lienzo_salir: cierra la sesión de la cuenta EN ESTE EQUIPO (21-10-2026, squad conectar; como «Salir» en Pixel Perfect).
+//
+// Borra la entrada de este proyecto en <LIENZO_HOME>/sesion.json (las de otros proyectos, como el emulador, se quedan)
+// bajo el mismo candado que usan las escrituras de la sesión, y olvida la cuenta en memoria. No toca agente.json: la
+// identidad de la instalación (su slug) no es la cuenta, y al volver a entrar con la misma cuenta sigues siendo el
+// mismo agente en tus salas. No te saca de ninguna sala (eso se hace desde la web, en «Tus agentes»).
+//
+// Lo que NO puede hacer: revocar el refresh token en el servidor. Firebase no lo permite por REST sin una cuenta de
+// servicio (haría falta una función con revokeRefreshTokens de Admin), y cerrar la sesión de Google NO lo invalida:
+// por eso el texto no lo sugiere. El token borrado deja de existir en este equipo, que es lo que importa en una
+// máquina compartida. Las
+// otras ventanas que usan el mismo LIENZO_HOME lo notan al renovar su token (Sesion.token: la entrada ya no está).
+import { existsSync, writeFileSync, renameSync, rmSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { cerrarTimbre } from './escucha.mjs';
+
+/** El texto que ve el agente (y le pasa a su usuario) después de salir. */
+export function textoSalida(cuenta) {
+  const quien = cuenta?.email || cuenta?.nombre;
+  return `${quien ? `Saliste de tu cuenta (${quien}) en este equipo` : 'Saliste de tu cuenta en este equipo'}: ` +
+    'se borró la sesión guardada en tu carpeta de Lienzo. Tu agente ya no puede leer ni publicar hasta que vuelvas a ' +
+    'usar lienzo_entrar. No te sacó de ninguna sala: para eso, la web (tu cuenta › Tus agentes). Lienzo todavía no ' +
+    'revoca sesiones en el servidor: una copia de ese archivo seguiría sirviendo en otra máquina, y cerrar tu sesión ' +
+    'de Google no la corta.';
+}
+
+export const TEXTO_SIN_SESION = 'No había ninguna cuenta conectada en este equipo: no hay nada que cerrar.';
+
+/**
+ * Cierra la sesión de `sesion` (lib/sesion.mjs) en este equipo. Devuelve la cuenta que estaba conectada, o null si
+ * no había ninguna. Con el candado tomado: otra ventana no puede refrescar y volver a escribir la entrada a la vez.
+ */
+export async function salirDeLaCuenta(sesion) {
+  return sesion._conCandado(async () => {
+    sesion._cargar(); // otra ventana pudo conectar la cuenta después de que arrancó este proceso
+    const cuenta = sesion.cuenta;
+    const todo = sesion._leerTodo();
+    const clave = sesion._clave();
+    if (clave in todo) {
+      delete todo[clave];
+      if (Object.keys(todo).length) escribirAtomico(sesion.ruta, todo);
+      else rmSync(sesion.ruta, { force: true });
+    } else if (existsSync(sesion.ruta) && !Object.keys(todo).length) {
+      rmSync(sesion.ruta, { force: true });
+    }
+    olvidar(sesion);
+    return cuenta;
+  });
+}
+
+/**
+ * lienzo_salir completo: cierra la sesión en este equipo y deja el puente como recién arrancado sin cuenta (sin sala,
+ * sin el timbre de la sala, sin las marcas de salas perdidas). Devuelve el texto para el agente.
+ */
+export async function salirDeLienzo(lienzo) {
+  const cuenta = await salirDeLaCuenta(lienzo.sesion);
+  lienzo._olvidarSala();
+  await cerrarTimbre(lienzo).catch(() => undefined);
+  lienzo.salasPerdidas.clear();
+  lienzo.ultimaPerdida = null;
+  return cuenta ? textoSalida(cuenta) : TEXTO_SIN_SESION;
+}
+
+/** La sesión en memoria vuelve a «sin cuenta». */
+export function olvidar(sesion) {
+  sesion.uid = null;
+  sesion.refreshToken = null;
+  sesion.idToken = null;
+  sesion.venceEn = 0;
+  sesion.nombre = null;
+  sesion.email = null;
+  sesion.proveedor = null;
+}
+
+function escribirAtomico(ruta, datos) {
+  const temporal = `${ruta}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+  try {
+    writeFileSync(temporal, JSON.stringify(datos, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+    renameSync(temporal, ruta);
+  } finally {
+    rmSync(temporal, { force: true });
+  }
+}

package/lib/secretos.mjs

@@ -15,6 +15,11 @@ const PATRONES = [
   { tipo: 'token de Google OAuth', re: /\bya29\.[0-9A-Za-z_-]{20,}/g },
   { tipo: 'JWT (token de sesión)', re: /\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g },
   { tipo: 'URL con usuario y contraseña', re: /\b[a-z][a-z0-9+.-]*:\/\/[^\s:/@]+:[^\s@/]{6,}@[^\s]+/gi },
+  // El link de entrada de lienzo_entrar (puerto + nonce): si el navegador no se abre, el puente se lo da a su agente
+  // para que se lo pase a SU persona. Publicado en una sala, otro podría usarlo para dejar a este agente con su cuenta
+  // (revisión de squad/conectar): nunca sale a una sala, aunque una tarjeta lo pida.
+  { tipo: 'link de entrada de Lienzo (lienzo_entrar)', re: /\/conectar\?(?=\S*\bpuerto=\d)(?=\S*\bestado=)\S*/g },
+  { tipo: 'vuelta del login de Lienzo (callback local)', re: /\b(?:127\.0\.0\.1|localhost):\d+\/callback#[^\s]*/gi },
 ];
 
 // «password = algo», «api_key: "…"», «TOKEN=…» con un valor que no es un marcador de posición.

package/lib/sesion.mjs

@@ -22,6 +22,11 @@ export const TIMEOUT_MS = 20 * 1000;
 const CANDADO_VIEJO_MS = 30 * 1000; // un candado más viejo que esto es de un proceso que murió
 const CANDADO_ESPERA_MS = 10 * 1000;
 export const ENTRAR_TIMEOUT_MS = 180 * 1000;
+// Después de usarse, vencer o cancelarse, el servidor local sigue escuchando un rato solo para limpiar la barra: si la
+// web vuelve tarde (el link se abrió de nuevo o después de los 3 min), el refresh token llega en el #fragmento y, sin
+// nadie que lo borre, quedaría en la barra y en el historial. En ese modo GET /callback sirve la página que borra el
+// fragmento y dice que el enlace ya no sirve, y POST da 410 (revisión de integra-06).
+export const GRACIA_MS = 10 * 60 * 1000;
 const MAX_CUERPO = 64 * 1024;
 
 /** Errores de sesión que el agente tiene que ver tal cual (no son fallas internas). */
@@ -79,25 +84,43 @@ export function mensajeDeError(codigo = '') {
   return `El navegador no pudo conectar tu cuenta (${c.replace(/[^\w/.-]/g, '').slice(0, 60) || 'error'}). Vuelve a usar lienzo_entrar.`;
 }
 
-/** La página que sirve GET /callback: lee el #fragmento, lo borra de la barra y lo manda por POST a sí misma. */
-function paginaCallback(nonce) {
-  const T = {
-    enviando: 'Conectando Lienzo…',
-    ok: 'Listo: tu agente ya está conectado a tu cuenta. Puedes cerrar esta pestaña.',
-    error: 'No se pudo conectar. Vuelve a tu agente y pídele que use lienzo_entrar otra vez.',
-  };
+/** El ícono de Lienzo (web/public/icono.svg), en línea: la CSP de la página no deja cargar nada de afuera. */
+const ICONO = '<svg class="i" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1024 1024" aria-hidden="true"><rect width="1024" height="1024" rx="225" fill="#fa7319"/><path transform="translate(102.40 91.14) scale(34.1333)" fill="#fff" d="M8.58579 17H3V15H21V17H15.4142L18.6569 20.2426L17.2426 21.6569L13 17.4142V20H11V17.4142L6.75736 21.6569L5.34315 20.2426L8.58579 17ZM5 3H19C19.5523 3 20 3.44772 20 4V14H4V4C4 3.44772 4.44772 3 5 3ZM6 5V12H18V5H6Z"/></svg>';
+
+/** Textos de la página local de /callback (squad conectar: como el cierre de /entrar de Pixel Perfect). */
+export const TEXTOS_CALLBACK = {
+  enviando: { titulo: 'Conectando tu agente…', texto: 'Un segundo: le estamos pasando tu sesión.' },
+  ok: { titulo: 'Listo. Ya puedes volver a tu terminal', texto: 'Tu agente quedó conectado a tu cuenta de Lienzo. Puedes cerrar esta pestaña.' },
+  cancelado: { titulo: 'No se conectó', texto: 'Le avisamos a tu agente. Ya puedes volver a tu terminal y cerrar esta pestaña.' },
+  error: { titulo: 'No se pudo conectar', texto: 'Vuelve a tu agente y pídele que use lienzo_entrar otra vez. Si tardaste más de 3 minutos, el enlace ya venció.' },
+  usado: { titulo: 'Este enlace ya no sirve', texto: 'Ya se usó, venció o se canceló. Si tu agente no quedó conectado, vuelve a tu terminal y pídele que use lienzo_entrar otra vez.' },
+};
+
+/**
+ * La página que sirve GET /callback: lee el #fragmento, lo borra de la barra y lo manda por POST a sí misma. Con
+ * `cerrado` (el enlace ya se usó, venció o se canceló) solo borra el fragmento y lo dice: no manda nada.
+ */
+function paginaCallback(nonce, cerrado = false) {
+  const T = TEXTOS_CALLBACK;
   return `<!doctype html><html lang="es"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="referrer" content="no-referrer"><title>Lienzo</title>
-<style>:root{color-scheme:light dark}body{font:16px/1.5 -apple-system,system-ui,sans-serif;display:grid;place-items:center;min-height:90vh;margin:0;padding:0 16px;background:Canvas;color:CanvasText}p{max-width:28em;text-align:center}</style>
-<body><p id="m">${T.enviando}</p><script nonce="${nonce}">
+<style>:root{color-scheme:light dark}*{box-sizing:border-box}body{font:16px/1.5 -apple-system,system-ui,"Segoe UI",sans-serif;display:grid;place-items:center;min-height:100vh;margin:0;padding:24px 16px;background:Canvas;color:CanvasText}
+.c{width:100%;max-width:420px;border:1px solid color-mix(in srgb,CanvasText 14%,transparent);border-radius:20px;padding:32px 24px;text-align:center;display:flex;flex-direction:column;align-items:center;gap:8px}
+.i{width:48px;height:48px;margin-bottom:8px}h1{font-size:20px;line-height:28px;margin:0;font-weight:600}p{margin:0;color:color-mix(in srgb,CanvasText 68%,transparent)}
+.e{display:none;width:32px;height:32px;line-height:32px;border-radius:50%;margin-top:8px;color:#fff;font-weight:600}.ok .e,.cancelado .e,.usado .e,.error .e{display:block}.ok .e{background:#1fc16b}.ok .e::after{content:"✓"}.cancelado .e,.usado .e{background:#a3a3a3}.cancelado .e::after,.usado .e::after,.error .e::after{content:"✕"}.error .e{background:#fb3748}
+.s{display:flex;flex-direction:column;align-items:center;gap:8px}.pie{margin-top:16px;font-size:13px;line-height:20px}</style>
+<body><main class="c" id="c">${ICONO}<div class="s" role="status" aria-live="polite"><h1 id="t">${T.enviando.titulo}</h1><p id="m">${T.enviando.texto}</p></div><span class="e" aria-hidden="true"></span>
+<p class="pie">Lienzo · esta página la sirve tu agente en tu propio equipo (127.0.0.1)</p></main><script nonce="${nonce}">
 (async () => {
-  const m = document.getElementById('m'), T = ${JSON.stringify(T)};
+  const c = document.getElementById('c'), t = document.getElementById('t'), m = document.getElementById('m'), T = ${JSON.stringify(T)};
+  const poner = (k) => { c.className = 'c ' + k; t.textContent = T[k].titulo; m.textContent = T[k].texto; };
   const h = location.hash.slice(1);
   history.replaceState(null, '', location.pathname);
-  if (!h) { m.textContent = T.error; return; }
+  if (${cerrado ? 'true' : 'false'}) { poner('usado'); return; }
+  if (!h) { poner('error'); return; }
   try {
     const r = await fetch('/callback', { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: h });
-    m.textContent = r.ok ? T.ok : T.error;
-  } catch { m.textContent = T.error; }
+    poner(r.ok ? 'ok' : /(^|&)error=cancel/.test(h) ? 'cancelado' : 'error');
+  } catch { poner('error'); }
 })();
 </script></body></html>`;
 }
@@ -127,7 +150,16 @@ export function abrirNavegador(url, plataforma = process.platform) {
 /**
  * Levanta el servidor de un solo uso en 127.0.0.1, abre `{webUrl}/conectar?puerto=<n>&estado=<nonce>` y espera
  * a que la web vuelva a /callback. Resuelve con { refreshToken }. Al vencer (ErrorSesion con codigo 'vencido'),
- * cancelarse o resolverse, el servidor se cierra. La URL lleva el nonce: va a stderr y a `abrir`, nunca al modelo.
+ * cancelarse o resolverse, deja de aceptar sesiones: sigue `graciaMs` solo para borrar el #fragmento si la web vuelve
+ * tarde (GRACIA_MS) y después se cierra. La URL lleva el nonce: va a stderr y a `abrir`; `onNoAbrio` avisa cuando el
+ * navegador no se abrió (o `abrir: null`). Quien decide si la URL llega al modelo es lib/lienzo.mjs: solo con
+ * `sinNavegador: true` explícito.
+ *
+ * Qué protege qué: lo que de verdad cierra el callback es `estado` (nonce de 32 bytes, comparado en tiempo
+ * constante). El Origin exigido en el POST solo frena a una página ajena abierta en el navegador (el navegador no la
+ * deja mentir su Origin); un proceso local lo pone como quiera (curl -H 'Origin: …'), así que contra eso no protege
+ * nada que no proteja ya el nonce. Un proceso local que conoce el nonce puede entregar la sesión que quiera: por eso
+ * el nonce no tiene que llegar a nadie más que a la persona (revisión de integra-06).
  *
  * @param {object} o
  * @param {string} o.webUrl
@@ -135,13 +167,16 @@ export function abrirNavegador(url, plataforma = process.platform) {
  * @param {number} [o.timeoutMs]                 3 min por defecto
  * @param {AbortSignal} [o.signal]
  * @param {(info: { puerto: number, estado: string, url: string }) => void} [o.onListening]
+ * @param {(url: string) => void} [o.onNoAbrio]   el navegador no se abrió (o `abrir` es null): hay que pasar la URL a mano
+ * @param {number} [o.graciaMs]                  cuánto sigue limpiando la barra después de terminar (0: se cierra ya)
  */
-export async function recibirSesion({ webUrl, abrir = abrirNavegador, timeoutMs = ENTRAR_TIMEOUT_MS, signal, onListening } = {}) {
+export async function recibirSesion({ webUrl, abrir = abrirNavegador, timeoutMs = ENTRAR_TIMEOUT_MS, signal, onListening, onNoAbrio, graciaMs = GRACIA_MS } = {}) {
   if (!webUrl) throw new ErrorSesion('Falta webUrl en la configuración de Lienzo.');
   if (signal?.aborted) throw new ErrorSesion('Se canceló la conexión con tu cuenta.');
   const estado = randomBytes(32).toString('base64url');
   let servidor;
   let timer;
+  let cerrado = false; // ya se usó, venció o se canceló: solo limpia la barra
   try {
     return await new Promise((resolve, reject) => {
       let listo = false;
@@ -161,12 +196,14 @@ export async function recibirSesion({ webUrl, abrir = abrirNavegador, timeoutMs
             ...cabeceras,
             'content-type': 'text/html; charset=utf-8',
             'content-security-policy': `default-src 'none'; script-src 'nonce-${nonce}'; style-src 'unsafe-inline'; connect-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'`,
-          }).end(paginaCallback(nonce));
+          }).end(paginaCallback(nonce, cerrado));
         }
         if (req.method !== 'POST') return res.writeHead(405, cabeceras).end();
-        // Solo la página que sirvió este mismo servidor (mismo origen). Un sitio ajeno no puede postear aquí.
+        if (cerrado) return res.writeHead(410, cabeceras).end();
+        // Solo la página que sirvió este mismo servidor (mismo origen): frena a un sitio ajeno abierto en el navegador.
+        // NO frena a un proceso local (el Origin se falsifica con curl): eso lo cierra el nonce `estado`, más abajo.
         const origen = req.headers.origin;
-        if (origen && origen !== `http://127.0.0.1:${servidor.address().port}`) return res.writeHead(403, cabeceras).end();
+        if (origen !== `http://127.0.0.1:${servidor.address().port}`) return res.writeHead(403, cabeceras).end();
         const trozos = [];
         let bytes = 0;
         for await (const c of req) {
@@ -189,8 +226,13 @@ export async function recibirSesion({ webUrl, abrir = abrirNavegador, timeoutMs
         const url = `${webUrl.replace(/\/+$/, '')}/conectar?${new URLSearchParams({ puerto: String(puerto), estado })}`;
         console.error(`[lienzo] para conectar tu cuenta abre: ${url}`);
         onListening?.({ puerto, estado, url });
+        if (!abrir) {
+          onNoAbrio?.(url);
+          return;
+        }
         Promise.resolve().then(() => abrir(url)).catch((e) => {
           console.error(`[lienzo] no pude abrir el navegador (${e?.message ?? e}); ábrelo a mano: ${url}`);
+          onNoAbrio?.(url);
         });
       });
       timer = setTimeout(
@@ -202,8 +244,13 @@ export async function recibirSesion({ webUrl, abrir = abrirNavegador, timeoutMs
     });
   } finally {
     clearTimeout(timer);
-    servidor?.close();
-    servidor?.closeAllConnections?.();
+    cerrado = true;
+    const cerrar = () => { servidor?.close(); servidor?.closeAllConnections?.(); };
+    if (servidor?.listening && graciaMs > 0) {
+      servidor.unref(); // no retiene al proceso: si el puente termina, la gracia termina con él
+      servidor.closeIdleConnections?.();
+      setTimeout(cerrar, graciaMs).unref();
+    } else cerrar();
   }
 }
 
@@ -406,8 +453,8 @@ export class Sesion {
   }
 
   /** Login en el navegador + adoptar. Devuelve la cuenta. Opciones: las de recibirSesion. */
-  async entrar({ abrir, timeoutMs = ENTRAR_TIMEOUT_MS, signal, onListening } = {}) {
-    const { refreshToken } = await recibirSesion({ webUrl: this.config.webUrl, abrir, timeoutMs, signal, onListening });
+  async entrar({ abrir, timeoutMs = ENTRAR_TIMEOUT_MS, signal, onListening, onNoAbrio } = {}) {
+    const { refreshToken } = await recibirSesion({ webUrl: this.config.webUrl, abrir, timeoutMs, signal, onListening, onNoAbrio });
     return this.adoptar(refreshToken);
   }
 
@@ -423,6 +470,14 @@ export class Sesion {
     }
     return this._conCandado(async () => {
       this._cargar(); // otro proceso con el mismo LIENZO_HOME pudo crear o refrescar la sesión
+      // lienzo_salir en otra ventana (o la carpeta borrada a mano): la entrada ya no está. No se refresca ni se vuelve
+      // a escribir con lo que quedó en memoria: se cierra aquí también (lib/salir.mjs).
+      if (this.refreshToken && !(this._clave() in this._leerTodo())) {
+        console.error('[lienzo] la sesión se cerró fuera de este proceso (lienzo_salir o la carpeta borrada)');
+        for (const k of ['uid', 'refreshToken', 'idToken', 'nombre', 'email', 'proveedor']) this[k] = null;
+        this.venceEn = 0;
+        if (!this.config.pruebasAnonimas) throw new ErrorSesion(SIN_SESION);
+      }
       if (!this.refreshToken) {
         await this._registrarAnonima(); // solo en pruebas; si no, lanza SIN_SESION
         return this.idToken;

package/lib/version.mjs

@@ -0,0 +1,48 @@
+// ¿Hay una versión nueva del puente en npm? (21-10-2026, «el MCP de Figma se actualiza solo, el nuestro también debería»)
+//
+// Instalado con `npx -y @ajuarezso/lienzo-mcp@latest`, el puente ya se actualiza solo cada vez que el cliente lo
+// arranca. Esto cubre lo demás (una versión fija, el plugin del repo, la extensión .mcpb de Claude Desktop, o un
+// cliente que lleva días abierto): al arrancar se pregunta UNA vez al registro de npm, con un timeout corto y sin
+// bloquear el arranque; si hay una más nueva, la primera respuesta de herramienta lo dice en una línea.
+export const PAQUETE = '@ajuarezso/lienzo-mcp';
+export const COMANDO = `claude mcp add lienzo --scope user -- npx -y ${PAQUETE}@latest`;
+const TIMEOUT_MS = 1500;
+
+/** «0.10.0» > «0.9.3». Solo x.y.z (una prerelease nunca se ofrece como nueva). */
+export function esMasNueva(candidata, actual) {
+  const p = (v) => (/^\d+\.\d+\.\d+$/.test(String(v ?? '')) ? String(v).split('.').map(Number) : null);
+  const a = p(candidata);
+  const b = p(actual);
+  if (!a || !b) return false;
+  for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] > b[i];
+  return false;
+}
+
+/**
+ * La versión `latest` en npm si es más nueva que `actual`; null si no, si no hay red o si tarda más de 1,5 s.
+ * Nunca lanza.
+ */
+export async function versionNueva(actual, { fetch: f = globalThis.fetch, timeoutMs = TIMEOUT_MS, registro = 'https://registry.npmjs.org' } = {}) {
+  try {
+    const r = await f(`${registro}/${PAQUETE.replace('/', '%2F')}/latest`, {
+      headers: { accept: 'application/json' },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!r.ok) return null;
+    const { version } = await r.json();
+    return esMasNueva(version, actual) ? version : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Para pasar de una versión fija (o del comando viejo) a la que se actualiza sola: quitar y volver a agregar. */
+export const COMANDO_REINSTALAR = `claude mcp remove lienzo --scope user && ${COMANDO}`;
+
+/** La línea que va al agente (una vez por proceso). */
+export const avisoDeVersion = (nueva, actual) =>
+  `(Lienzo: hay una versión nueva del puente, ${nueva}; esta es ${actual}. Díselo a tu usuario una vez: si lo instaló con ` +
+  `@latest (o sin versión), se actualiza solo al reiniciar su cliente (en Claude Code, /mcp → lienzo → reconectar); si ` +
+  `tiene una versión fija, que lo reinstale con «${COMANDO_REINSTALAR}» y, si lo tenía con -e (LIENZO_AGENTE, ` +
+  `LIENZO_NOMBRE…), que los repita en el add, antes del --. La extensión de Claude Desktop (.mcpb) no se actualiza sola: ` +
+  `hay que bajar la nueva.)`;

package/package.json

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