@nyx5/nyx5 0.7.0 → 0.8.0

package/src/correo/estafeta.js

@@ -19,8 +19,9 @@
 // body, ip } -> { status, body }. El almacenamiento es async (FileStore local, D1Store en el edge).
 
 import { FileStore } from '../nucleo/almacen.js';
+import { ObjetosDisco } from '../nucleo/objetos.js';
 import { Resolver, parseAddress } from './resolver.js';
-import { validateEnvelope, applyInboxPolicy, applyEmailPolicy, RateLimiter, RateLimiterDurable, proyectoDe, nombreDeProyecto, validarPerfil, usdSinBilletera } from './politica.js';
+import { validateEnvelope, applyInboxPolicy, applyEmailPolicy, RateLimiter, RateLimiterDurable, proyectoDe, resumenDe, nombreDeProyecto, validarPerfil, usdSinBilletera } from './politica.js';
 import { generateSigningKeys, signObject, verifyObject, signBytes, verifyBytes, canonical, uuid, unb64u, sha256hex } from '../nucleo/crypto.js';
 import { Libro, MEDIA, LibroError } from '../libro/libro.js';
 import { veredicto, pruebasDe, pruebasDisponibles } from '../libro/verifica.js';
@@ -40,7 +41,11 @@ import { atenderMcp } from '../puentes/mcp-remoto.js';
 import { abrirBoveda } from '../nucleo/boveda.js';
 import { ICONOS } from '../plataformas/iconos.js';
 import { Agent } from './agente.js';
-import { atenderAsistentes, PRECIOS } from './asistente.js';
+import { eventoDeCobro } from './cobro.js';
+import { atenderAsistentes, gastoDe, PRECIOS, MEDIA_GATE } from './asistente.js';
+import { atenderIdeas, paginaDeIdeas, puertaIdeas, LOCAL as IDEAS_LOCAL, VIA as IDEAS_VIA } from './ideas.js';
+import { subirAdjunto, bajarAdjunto, borrarAdjunto, limpiarAdjuntos, capacidadAdjuntos } from './adjuntos.js';
+import { atenderEjecutores, despachar as despacharCi, despachable, validarConfig as validarCi, urlDe as urlCi, PROVEEDORES as CI_PROVEEDORES, INTENTOS as CI_INTENTOS, CUPO_DESPACHOS_DIA } from './ci.js';
 import { validarFiltros, puntajeDe, precioMinimo, FILTROS } from './indice.js';
 
 const now = () => Date.now();
@@ -60,13 +65,19 @@ const rutaCors = (p) => p.startsWith('/.well-known/oauth-') || p === '/oauth/reg
 // del usuario a los siete días sin abrirla.
 const MANIFIESTO = { name: 'Nyx5', short_name: 'Nyx5', start_url: '/app', scope: '/', display: 'standalone', background_color: '#FFFFFF', theme_color: '#12A594', icons: [{ src: '/icon-192.png', sizes: '192x192', type: 'image/png' }, { src: '/icon-512.png', sizes: '512x512', type: 'image/png', purpose: 'any maskable' }] };
 
+// Direcciones por petición en GET /agents/historial?addresses=… (NX-905). El rastreo del índice
+// pide lotes de este tamaño y una casa que no tenga la ruta (versión anterior) contesta 404.
+export const HISTORIAL_LOTE_MAX = 50;
+// Proyectos que la lista de conversaciones devuelve por contacto (14-sep-2026): los de último uso.
+export const PROYECTOS_POR_CONTACTO = 20;
+
 export class Estafeta {
   constructor({
     domain, dataDir, store, adminToken,
     port = 4000, host = '127.0.0.1', publicUrl,
     hosts = {}, fetchImpl = globalThis.fetch,
-    policy = {}, retry = {}, workerIntervalMs = 1000, libro = {},
-    index = {}, email = {}, verifica = {}, eventos = true, tareas = {}, terms = null, remoto = {}, asistente = {},
+    policy = {}, retry = {}, workerIntervalMs = 1000, libro = {}, objetos, sinObjetos = false,
+    index = {}, email = {}, verifica = {}, eventos = true, tareas = {}, terms = null, remoto = {}, asistente = {}, ideas = {},
     extensions = null,
     log = (...a) => console.log(`[estafeta ${domain}]`, ...a),
   }) {
@@ -119,6 +130,11 @@ export class Estafeta {
     this.hostsOverride = hosts;
 
     this.store = store || new FileStore(dataDir);
+    // Almacén de OBJETOS: dónde vive un adjunto cifrado (NX-413). Una casa de archivos lo tiene
+    // solo; una casa del edge lo tiene si su Worker le pasó el binding R2. Sin almacén, la ruta
+    // /blob contesta 503 y lo DICE: aceptar un archivo que no se va a guardar es peor que no
+    // tenerlo, porque el remitente cree que viajó. `sinObjetos` es para probar justamente eso.
+    this.objetos = objetos || (dataDir && !sinObjetos ? new ObjetosDisco(`${dataDir}/blobs`) : null);
     // Límites de tasa durables (NX-901): cuentan en el almacén, así que valen para toda la casa y
     // no por isolate. Un almacén sin contador (uno ajeno, mínimo) cae al de memoria.
     const limitador = (perMinute, ns) => (this.store.kvIncrement ? new RateLimiterDurable({ store: this.store, perMinute, ns, log: (m) => this.log(m) }) : new RateLimiter({ perMinute }));
@@ -134,6 +150,10 @@ export class Estafeta {
     // Asistentes (src/correo/asistente.js): existen sólo si la casa tiene una clave de la API de
     // Anthropic. La clave no se guarda aparte: sólo el asistente la usa, al llamar.
     this.asistente = asistente.apiKey ? { apiKey: asistente.apiKey, fetch: (...a) => (asistente.fetchImpl || this.fetch)(...a) } : null;
+    // ideas@ (src/correo/ideas.js): el buzón que registra y confirma, nunca ejecuta. Se enciende por
+    // casa (NYX5_IDEAS=on) y exige la bóveda: su llave vive ahí, como la de un asistente de sistema.
+    // `cupo` sólo para pruebas (no sale de ninguna variable de entorno): el límite es de código.
+    this.ideas = { enabled: !!(ideas.enabled && this.boveda), cupo: ideas.cupo || undefined };
     this._ready = null;
     this._domainCardCache = null; // { value, until }
     this._pushes = [];            // avisos por webhook en vuelo (los espera flushPushes)
@@ -236,13 +256,20 @@ export class Estafeta {
       this._primeros.add(raiz);
     } catch (e) { this.log(`first_message ${raiz} no registrado: ${e.message}`); }
   }
+  // `eventoDeCobro` copia campo por campo: aunque el remitente meta `amount` en la extensión, no entra.
+  async _eventoDeCobro(env, local) {
+    const ev = eventoDeCobro(env);
+    if (ev) await this._evento(ev.name, env.from, { ...ev.data, to: `${local}@${this.domain}` });
+  }
   isSystem(local) { return ['postmaster', 'libro', 'verifica', 'tareas'].includes(local); }
   // ¿Podría alguien registrarse HOY con este nombre? Mismas reglas que registerAgent, sin registrar nada.
   async nombreDisponible(local) {
     if (!local || Estafeta.RESERVED.has(local) || local.length < (this.policy.min_name_length || 0)) return false;
     return !(await this.store.getAgent(local));
   }
-  static RESERVED = new Set(['postmaster', 'libro', 'verifica', 'tareas', 'casa', 'admin', 'root', 'abuse', 'security', 'hostmaster', 'noreply', 'no-reply', 'support', 'estafeta', 'nyx5', 'indice']);
+  // `qa` es de la casa (NX-606): sólo un asistente de sistema puede vivir ahí, nunca un registro.
+  // `ideas` igual: sólo el buzón de vacaciones (POST /admin/ideas) puede ocuparlo.
+  static RESERVED = new Set(['postmaster', 'libro', 'verifica', 'tareas', 'casa', 'admin', 'root', 'abuse', 'security', 'hostmaster', 'noreply', 'no-reply', 'support', 'estafeta', 'nyx5', 'indice', 'historial', 'qa', 'ideas']);
 
   // ---------- servicio de registro ----------
   // Invitaciones: la casa emite códigos con usos y vencimiento; un agente los presenta al inscribirse.
@@ -290,6 +317,10 @@ export class Estafeta {
       nyx5: '1', domain: this.domain, estafeta: this.publicUrl,
       keys: rec.keys.map((k) => ({ sig: k.sig, created: k.created })),
       policy: { inbound: this.policy.inbound, max_bytes: this.policy.max_bytes, registration: this.policy.registration, ...(this.policy.outbound ? { outbound: this.policy.outbound } : {}) },
+      // Los cupos de los adjuntos, SÓLO si esta casa los aloja de verdad (NX-413). Una casa sin
+      // almacén de objetos no los anuncia: anunciar un límite es prometer que hay dónde guardar, y
+      // esa promesa sin nada detrás es justamente el defecto que este ítem vino a cerrar.
+      ...(this.objetos ? { attachments: capacidadAdjuntos() } : {}),
       extensions: this.extensions,
     };
     const guardada = rec.card;
@@ -312,7 +343,10 @@ export class Estafeta {
 
   // ---------- agentes ----------
   static VISIBILIDADES = ['public', 'private', 'secret'];
-  async registerAgent({ local, sig, enc = null, capabilities = {}, inbox = { policy: 'open' }, wallet = null, wallets = null, webhook = null, notify_email = null, valid_until = null, delegation = null, welcome = null, custody = null, group = null, profile = undefined, visibility = undefined }) {
+  // `system`: una dirección de sistema con llaves propias (un asistente de la casa, NX-606). Sólo
+  // la pone `_adminAsistente` (ruta de la casa): salta la lista de reservados y el largo mínimo,
+  // como verifica@ y tareas@, y no recibe regalo de bienvenida.
+  async registerAgent({ local, sig, enc = null, capabilities = {}, inbox = { policy: 'open' }, wallet = null, wallets = null, webhook = null, notify_email = null, valid_until = null, delegation = null, welcome = null, custody = null, group = null, profile = undefined, visibility = undefined, system = false }) {
     // Visibilidad (NX-202): public = en el directorio; private = existe, lo encuentra quien sabe la
     // dirección (lo de siempre; es el defecto); secret = a quien no está en su lista se le responde
     // exactamente lo que a un nombre inexistente. Se conserva entre re-certificaciones.
@@ -328,11 +362,11 @@ export class Estafeta {
     local = String(local).toLowerCase();
     const address = `${local}@${this.domain}`;
     parseAddress(address);
-    if (Estafeta.RESERVED.has(local) && !this.isSystem(local)) throw Object.assign(new Error(`name reserved by the protocol: ${local}`), { status: 409 });
+    if (Estafeta.RESERVED.has(local) && !this.isSystem(local) && !system) throw Object.assign(new Error(`name reserved by the protocol: ${local}`), { status: 409 });
     // Nombres de 1 a 3 caracteres: reservados en una casa de registro abierto. Son lo primero
     // que alguien acapara para revender o para suplantar (a@casa se confunde con cualquiera), y
     // un agente que llega no necesita un nombre corto: necesita uno suyo. Los de sistema pasan.
-    if (local.length <= this.policy.min_name_length - 1 && !this.isSystem(local) && !delegation) {
+    if (local.length <= this.policy.min_name_length - 1 && !this.isSystem(local) && !delegation && !system) {
       throw Object.assign(new Error(`names shorter than ${this.policy.min_name_length} characters are reserved in this house`), { status: 409 });
     }
     if (delegation) {
@@ -410,7 +444,7 @@ export class Estafeta {
       await this.store.putAgent(local, { ...card, webhook, notify_email });
     }
     const gift = welcome ?? this.libro.welcome;
-    if (creado && !prev && !this.isSystem(local) && !delegation && !group && gift > 0) await this.libro.topup(address, gift, 'regalo de bienvenida', { agent: address });
+    if (creado && !prev && !this.isSystem(local) && !delegation && !group && !system && gift > 0) await this.libro.topup(address, gift, 'regalo de bienvenida', { agent: address });
     return card;
   }
 
@@ -665,16 +699,51 @@ export class Estafeta {
     const contraparte = (x) => grupo(x) || (x.dir === 'in' ? (x.envelope.extensions?.['urn:nyx5:ext:email']?.from || x.envelope.from) : (x.envelope.to.find((t) => t !== propia) || x.envelope.to[0]));
     const orden = (a, b) => String(a.at).localeCompare(String(b.at));
     if (con) return todos.filter((x) => contraparte(x) === con || (x.dir === 'out' && x.envelope.to.includes(con))).sort(orden).slice(-limit);
+    // La lista trae, por contacto, los proyectos vistos (14-sep-2026, decisión de Nicholas): la app
+    // filtra por proyecto sin leer cada hilo. Sale de la MISMA pasada, no de otra consulta: el
+    // proyecto real es `proyectoDe` (NFKC, sin invisibles, minúsculas), que SQLite no sabe calcular
+    // (su `lower()` es sólo ASCII y no hay NFKC), y el contacto tampoco es una columna (grupo,
+    // pasarela de correo o primer destinatario). Con `?project=` todo se calcula sobre ese proyecto.
     const mapa = new Map();
     for (const x of todos) {
       const c = contraparte(x);
-      const r = mapa.get(c) || { with: c, count: 0, pending: 0, last_at: '', last_dir: null, last_id: null };
+      const r = mapa.get(c) || { with: c, count: 0, pending: 0, last_at: '', last_dir: null, last_id: null, proyectos: new Map(), pendientes: new Map() };
       r.count++;
-      if (x.dir === 'in' && !x.acked) r.pending++;
+      const pendiente = x.dir === 'in' && !x.acked;
+      if (pendiente) r.pending++;
       if (String(x.at) > r.last_at) { r.last_at = String(x.at); r.last_dir = x.dir; r.last_id = x.id; }
+      const p = proyectoDe(x.envelope);
+      if (p) {
+        // Sin proyecto no hay entrada: no se inventa un «(none)».
+        if (String(x.at) > (r.proyectos.get(p) || '')) r.proyectos.set(p, String(x.at));
+        if (pendiente) r.pendientes.set(p, (r.pendientes.get(p) || 0) + 1);
+      }
       mapa.set(c, r);
     }
-    return [...mapa.values()].sort((a, b) => b.last_at.localeCompare(a.last_at));
+    return [...mapa.values()].sort((a, b) => b.last_at.localeCompare(a.last_at)).map(({ proyectos, pendientes, ...r }) => {
+      // Por último uso, a lo sumo 20: un contacto que etiquetó 10.000 proyectos distintos no
+      // devuelve 10.000 nombres. `pending_by_project` cubre SÓLO esos 20 (revisión del 14-sep-2026:
+      // traía una clave por proyecto pendiente, 1.000 con la ventana del historial, y el lector no
+      // podía cruzarlas con `projects`); lo pendiente bajo los demás va sumado en `pending_other`.
+      // Ninguna de las dos claves aparece en cero. `Object.fromEntries` crea propiedades propias:
+      // aunque llegara un nombre como `__proto__`, no pisaría el prototipo.
+      r.projects = [...proyectos.entries()].sort((a, b) => b[1].localeCompare(a[1])).slice(0, PROYECTOS_POR_CONTACTO).map(([p]) => p);
+      const listados = new Set(r.projects);
+      const porProyecto = [...pendientes].filter(([p]) => listados.has(p));
+      const otros = [...pendientes].filter(([p]) => !listados.has(p)).reduce((s, [, n]) => s + n, 0);
+      if (porProyecto.length) r.pending_by_project = Object.fromEntries(porProyecto);
+      if (otros) r.pending_other = otros;
+      return r;
+    });
+  }
+  // El `?project=` de una ruta: null si no viene (o viene vacío: sin filtro), el nombre normalizado
+  // como al enviar, o `false` si viene algo que no es un nombre (sólo invisibles, `%00`, una palabra
+  // reservada). Revisión del 14-sep-2026: `?project=%00` devolvía la lista ENTERA como si no hubiera
+  // filtro, y quien pidió un proyecto se llevaba todo. Se evalúa después de autenticar: no es oráculo.
+  _proyectoPedido(query) {
+    const crudo = query.get('project');
+    if (!crudo) return null;
+    return nombreDeProyecto(crudo) ?? false;
   }
   // Los subagentes que un dueño delegó (sus Claude conectados), con lo necesario para revocarlos.
   async delegados(local) {
@@ -771,13 +840,195 @@ export class Estafeta {
     // seal: cada respuesta termina con su sha256, para sellarla en la notaría (qa@, NX-606).
     const seal = c.seal ?? base.seal ?? false;
     if (typeof seal !== 'boolean') return { error: 'seal must be true or false' };
-    return { model, effort, max_tokens, budget_usd, seal };
+    const free_for = c.free_for ?? base.free_for ?? [];
+    if (!Array.isArray(free_for) || free_for.length > 10 || !free_for.every((a) => { try { parseAddress(a); return true; } catch { return false; } })) return { error: 'free_for must be a list of up to 10 addresses that do not pay' };
+    // Cobro por crédito (NX-606 fase 1): tokens por respuesta de Spec, por veredicto de Gate y por
+    // abstención de Gate. 0 = gratis (el asistente de Sigo). Decisión de Nicholas (14-sep-2026):
+    // Spec 400, Gate 400 si dictamina y 200 si se abstiene.
+    const entero = (k, def, max = 1_000_000) => { const v = Number(c[k] ?? base[k] ?? def); return Number.isInteger(v) && v >= 0 && v <= max ? v : null; };
+    const price_tokens = entero('price_tokens', 0);
+    if (price_tokens === null) return { error: 'price_tokens must be an integer between 0 and 1000000' };
+    const gate_price_tokens = entero('gate_price_tokens', price_tokens);
+    if (gate_price_tokens === null) return { error: 'gate_price_tokens must be an integer between 0 and 1000000' };
+    const gate_abstain_tokens = entero('gate_abstain_tokens', Math.floor(gate_price_tokens / 2));
+    if (gate_abstain_tokens === null || gate_abstain_tokens > gate_price_tokens) return { error: 'gate_abstain_tokens must be an integer between 0 and gate_price_tokens' };
+    const gate = c.gate ?? base.gate ?? false;
+    if (typeof gate !== 'boolean') return { error: 'gate must be true or false' };
+    const persona_gate = c.persona_gate ?? base.persona_gate ?? '';
+    if (typeof persona_gate !== 'string' || persona_gate.length > 20_000) return { error: 'persona_gate must be a string of at most 20000 characters' };
+    // `tools` (26-oct-2026): las manos del agente vivo (src/correo/acciones.js), APAGADAS por
+    // defecto. Un cerebro no recibe manos por existir: hay que decirlo, y la lista es cerrada.
+    const tools = c.tools ?? base.tools ?? false;
+    if (typeof tools !== 'boolean') return { error: 'tools must be true or false' };
+    return { model, effort, max_tokens, budget_usd, seal, price_tokens, gate_price_tokens, gate_abstain_tokens, gate, persona_gate, free_for, tools };
+  }
+  // Alta de un asistente de SISTEMA (NX-606): `<local>@<casa>` con llaves propias guardadas en la
+  // bóveda, tarjeta certificada por la casa, buzón abierto y cuenta en el Libro (recibe `pay`).
+  // A diferencia del modo delegado, no cuelga de nadie: su dueño es quien diga `config.owner`.
+  async _altaAsistenteSistema(b) {
+    const l = String(b.local || '').toLowerCase();
+    if (!Estafeta.validLocal(l) || l.startsWith('g.')) return { status: 400, body: { reason: 'local must be a valid address name' } };
+    if (this.isSystem(l)) return { status: 409, body: { reason: `${l}@ is a protocol address, not an assistant` } };
+    if (await this.store.getAgent(l)) return { status: 409, body: { reason: `${l}@${this.domain} already exists` } };
+    const k = b.keys || {};
+    if (![k.sig, k.sigPriv, k.enc, k.encPriv].every((x) => typeof x === 'string' && x)) return { status: 400, body: { reason: 'keys must bring sig, sigPriv, enc and encPriv' } };
+    // Prueba de posesión (invariante 9): la llave privada firma y la pública verifica.
+    let posee = false; try { posee = verifyObject(signObject({ nyx5: '1', prueba: l }, k), k.sig); } catch { posee = false; }
+    if (!posee) return { status: 400, body: { reason: 'sigPriv does not match sig' } };
+    const c = b.config || {};
+    const v = this._configAsistente(c);
+    if (v.error) return { status: 400, body: { reason: v.error } };
+    let owner = null;
+    if (c.owner != null) {
+      try { const p = parseAddress(String(c.owner)); owner = `${p.local}@${p.domain}`; } catch { return { status: 400, body: { reason: 'owner must be an address' } }; }
+    }
+    const since = iso();
+    let card;
+    try {
+      card = await this.registerAgent({ local: l, sig: k.sig, enc: k.enc, system: true, welcome: 0, inbox: { policy: 'open' },
+        capabilities: { accepts: ['text/plain', 'application/json', ...(v.gate ? [MEDIA_GATE] : [])], listed: true, assistant: { spec_tokens: v.price_tokens, ...(v.gate ? { gate_tokens: v.gate_price_tokens, gate_abstain_tokens: v.gate_abstain_tokens } : {}) } },
+        custody: { keys: 'house', via: 'assistant', since } });
+    } catch (e) { return { status: e.status || 400, body: { reason: e.message } }; }
+    await this.store.kvPut('boveda', l, { sellado: this.boveda.sellar({ sig: k.sig, sigPriv: k.sigPriv, enc: k.enc, encPriv: k.encPriv }, l), root: null, since });
+    const cfg = { local: l, owner, system: true, ...v, persona: String(c.persona || ''), enabled: true, created: since };
+    await this.store.kvPut('asistente', l, cfg);
+    const i = (await this.store.kvGet('asistente', '_indice')) || [];
+    if (!i.includes(l)) await this.store.kvPut('asistente', '_indice', [...i, l]);
+    await this._evento('assistant_created', card.address, { budget_usd: cfg.budget_usd, system: true, price_tokens: cfg.price_tokens });
+    return { status: 201, body: { address: card.address, custody: card.custody, system: true, config: { ...cfg, persona: `${cfg.persona.length} chars`, persona_gate: `${cfg.persona_gate.length} chars` } } };
+  }
+  // ADOPCIÓN (26-oct-2026): un cerebro para una dirección que YA EXISTE. Nació de la prioridad de
+  // Nicholas — «que los agentes y sus funciones persistan y funcionen sin mi máquina» —: rosetta@,
+  // norte@ o sigo@ ya viven, tienen historial y tarjeta; lo que les falta es poder pensar desde la
+  // casa. No se crea nada: se toma la dirección viva, su tarjeta pasa a declarar que desde ahora la
+  // casa guarda su llave (la excepción declarada al invariante 8, visible para quien le escriba), y
+  // queda APAGADA. Nadie se despierta solo por haber sido adoptado: hay que encenderlo a mano.
+  async _adoptarAsistente(b) {
+    const l = String(b.local || '').toLowerCase();
+    if (!Estafeta.validLocal(l)) return { status: 400, body: { reason: 'local must be a valid address name' } };
+    if (this.isSystem(l)) return { status: 409, body: { reason: `${l}@ is a protocol address, not an assistant` } };
+    const rec = await this.store.getAgent(l);
+    if (!rec || rec.revoked) return { status: 404, body: { reason: `${l}@${this.domain} does not exist: adoption is for an address that is already alive` } };
+    if (l.startsWith('g.') || rec.group) return { status: 409, body: { reason: `${l}@${this.domain} is a group, not an agent` } };
+    // Un DELEGADO no se adopta: su llave la controla su dueño y la casa no se la toma por detrás.
+    // El modo delegado existe y pide la llave al dueño (POST sin `adopt`); aquí se nombra a quién pedírsela.
+    if (rec.delegation) return { status: 409, body: { reason: `${l}@${this.domain} is a delegated address of ${rec.delegation.by}: its owner registers it as a delegated assistant, or adopt the root address instead` } };
+    // Ya bajo custodia de la casa por OTRA vía (el buzón de ideas, un Claude conectado): no se pisa.
+    if (rec.custody?.keys === 'house' && rec.custody.via !== 'assistant') return { status: 409, body: { reason: `${l}@${this.domain} is already under house custody via ${rec.custody.via}: that brain is not replaced from here` } };
+    if (await this.store.kvGet('asistente', l)) return { status: 409, body: { reason: `${l}@${this.domain} already has an assistant brain: change it with PUT /admin/assistants/${l}/config, or remove it with DELETE /admin/assistants/${l}` } };
+    const k = b.keys || {};
+    if (k.sig !== rec.sig || k.enc !== rec.enc || !k.sigPriv || !k.encPriv) return { status: 400, body: { reason: 'keys do not match the card of that address' } };
+    // Prueba de posesión (invariante 9): la privada firma y la pública de la tarjeta verifica.
+    let posee = false; try { posee = verifyObject(signObject({ nyx5: '1', prueba: l }, k), k.sig); } catch { posee = false; }
+    if (!posee) return { status: 400, body: { reason: 'sigPriv does not match sig' } };
+    const c = b.config || {};
+    const v = this._configAsistente(c);
+    if (v.error) return { status: 400, body: { reason: v.error } };
+    let owner = null;
+    if (c.owner != null) {
+      try { const p = parseAddress(String(c.owner)); owner = `${p.local}@${p.domain}`; } catch { return { status: 400, body: { reason: 'owner must be an address' } }; }
+    }
+    const since = iso();
+    const { certification: _c, webhook, notify_email, ...cuerpo } = rec;
+    const card = signObject({ ...cuerpo, custody: { keys: 'house', via: 'assistant', since } }, this.keys, 'certification');
+    await this.store.putAgent(l, { ...card, webhook, notify_email });
+    this.resolver.invalidate(`agent:${l}@${this.domain}`);
+    await this.store.kvPut('boveda', l, { sellado: this.boveda.sellar({ sig: k.sig, sigPriv: k.sigPriv, enc: k.enc, encPriv: k.encPriv }, l), root: null, since });
+    const cfg = { local: l, owner, adopted: true, ...v, persona: String(c.persona || ''), enabled: false, created: since };
+    await this.store.kvPut('asistente', l, cfg);
+    const i = (await this.store.kvGet('asistente', '_indice')) || [];
+    if (!i.includes(l)) await this.store.kvPut('asistente', '_indice', [...i, l]);
+    await this._evento('assistant_adopted', card.address, { budget_usd: cfg.budget_usd, tools: cfg.tools === true });
+    return { status: 201, body: { address: card.address, custody: card.custody, adopted: true, enabled: false, config: { ...cfg, persona: `${cfg.persona.length} chars`, persona_gate: `${cfg.persona_gate.length} chars` } } };
+  }
+  // Quitar el cerebro: la dirección sigue VIVA y queda sin cerebro. La llave sale de la bóveda, así
+  // que la casa deja de poder firmar y descifrar en su nombre, y la tarjeta lo dice.
+  async _quitarAsistente(local, cfg) {
+    const rec = await this.store.getAgent(local);
+    let custody = null;
+    if (rec && rec.custody?.via === 'assistant') {
+      const { certification: _c, webhook, notify_email, custody: _cu, ...cuerpo } = rec;
+      custody = { keys: 'self', via: null, ended: iso(), was: 'assistant' };
+      const card = signObject({ ...cuerpo, custody }, this.keys, 'certification');
+      await this.store.putAgent(local, { ...card, webhook, notify_email });
+      this.resolver.invalidate(`agent:${local}@${this.domain}`);
+    }
+    await this.store.kvDelete?.('boveda', local);
+    await this.store.kvDelete?.('asistente', local);
+    await this.store.kvDelete?.('asistente-conocimiento', local);
+    const i = (await this.store.kvGet('asistente', '_indice')) || [];
+    await this.store.kvPut('asistente', '_indice', i.filter((x) => x !== local));
+    await this._evento('assistant_removed', `${local}@${this.domain}`, { adopted: cfg?.adopted === true });
+    return { status: 200, body: { address: `${local}@${this.domain}`, removed: true, alive: !!(rec && !rec.revoked), custody } };
+  }
+  // Alta del buzón de vacaciones ideas@ (src/correo/ideas.js): dirección raíz de la casa con llaves
+  // propias en la bóveda, tarjeta `custody.via = ideas`, buzón por lista (el dueño y quien él diga) y
+  // sin cuenta que valga nada (nace sin regalo y nunca opera el Libro). Con el buzón ya dado de alta,
+  // un cuerpo sin `keys` sólo cambia la lista: la llave no se reemplaza por esta puerta.
+  async _altaBuzonIdeas(b) {
+    const l = IDEAS_LOCAL;
+    // La confirmación tiene que poder VOLVER: un Claude conectado sólo acepta a su dueño (lista), y
+    // la confirmación de ideas@ le rebotaría en silencio. A cada dirección de la lista que sea de
+    // esta casa y filtre por lista se le agrega ideas@ (lo mismo que hace /admin/contacts).
+    const abrirVuelta = async (allow) => {
+      const propia = `${l}@${this.domain}`;
+      for (const dir of allow) {
+        const p = parseAddress(dir);
+        if (p.domain !== this.domain || p.local === l) continue;
+        const rec = await this.store.getAgent(p.local);
+        if (rec?.inbox?.policy === 'allowlist' && !(rec.inbox.allowlist || []).includes(propia)) { await this.agregarContactos(p.local, [propia]); this.resolver.invalidate(`agent:${dir}`); }
+      }
+    };
+    let owner;
+    try { const p = parseAddress(String(b.owner || '')); owner = `${p.local}@${p.domain}`; } catch { return { status: 400, body: { reason: 'owner must be an address' } }; }
+    const allow = [];
+    for (const x of Array.isArray(b.allow) ? b.allow : []) {
+      let dir; try { const p = parseAddress(String(x)); dir = `${p.local}@${p.domain}`; } catch { return { status: 400, body: { reason: `allow: ${String(x).slice(0, 80)} is not an address` } }; }
+      if (!allow.includes(dir)) allow.push(dir);
+    }
+    if (!allow.includes(owner)) allow.unshift(owner);
+    if (allow.length > 20) return { status: 400, body: { reason: 'allow: at most 20 addresses' } };
+    const previo = await this.store.getAgent(l);
+    const since = iso();
+    if (previo) {
+      if (previo.custody?.via !== IDEAS_VIA) return { status: 409, body: { reason: `${l}@${this.domain} already exists and is not the ideas mailbox` } };
+      if (b.keys) return { status: 409, body: { reason: `${l}@${this.domain} already exists; send only owner and allow to change its list` } };
+      const { certification: _c, webhook, notify_email, ...cuerpo } = previo;
+      const card = signObject({ ...cuerpo, inbox: { policy: 'allowlist', allowlist: allow } }, this.keys, 'certification');
+      await this.store.putAgent(l, { ...card, webhook, notify_email });
+      this.resolver.invalidate(`agent:${l}@${this.domain}`);
+      await this.store.kvPut('ideas', '_config', { owner, allow, updated: since });
+      await abrirVuelta(allow);
+      return { status: 200, body: { address: card.address, owner, allow } };
+    }
+    const k = b.keys || {};
+    if (![k.sig, k.sigPriv, k.enc, k.encPriv].every((x) => typeof x === 'string' && x)) return { status: 400, body: { reason: 'keys must bring sig, sigPriv, enc and encPriv' } };
+    let posee = false; try { posee = verifyObject(signObject({ nyx5: '1', prueba: l }, k), k.sig); } catch { posee = false; }
+    if (!posee) return { status: 400, body: { reason: 'sigPriv does not match sig' } };
+    let card;
+    try {
+      card = await this.registerAgent({ local: l, sig: k.sig, enc: k.enc, system: true, welcome: 0, inbox: { policy: 'allowlist', allowlist: allow },
+        capabilities: { accepts: ['text/plain', 'application/json'], listed: false }, custody: { keys: 'house', via: IDEAS_VIA, since } });
+    } catch (e) { return { status: e.status || 400, body: { reason: e.message } }; }
+    await this.store.kvPut('boveda', l, { sellado: this.boveda.sellar({ sig: k.sig, sigPriv: k.sigPriv, enc: k.enc, encPriv: k.encPriv }, l), root: null, since });
+    await this.store.kvPut('ideas', '_config', { owner, allow, created: since });
+    await abrirVuelta(allow);
+    await this._evento('ideas_created', card.address, { owner, allow: allow.length });
+    return { status: 201, body: { address: card.address, custody: card.custody, owner, allow } };
   }
   async _adminAsistente(rx, local, accion) {
     const b = rx.body || {};
     const indice = async () => (await this.store.kvGet('asistente', '_indice')) || [];
     if (rx.method === 'POST' && !local && !accion) {
       if (!this.boveda) return { status: 503, body: { reason: 'this house has no vault key' } };
+      // El recíproco del guard de /admin/executors: un sobre lo contesta UNO. Si esta dirección ya
+      // trabaja en CI, darle cerebro la haría contestar dos veces el mismo encargo.
+      const conEjecutor = String(b.local || '').toLowerCase();
+      if (conEjecutor && await this.store.kvGet('ci', conEjecutor)) {
+        return { status: 409, body: { reason: `${conEjecutor}@${this.domain} already has an executor in CI: an address answers with a brain or with an executor, not both. Remove it with DELETE /admin/executors/${conEjecutor}` } };
+      }
+      if (b.adopt === true) return this._adoptarAsistente(b);
+      if (b.system === true) return this._altaAsistenteSistema(b);
       const l = String(b.local || '').toLowerCase();
       const rec = Estafeta.validLocal(l) ? await this.store.getAgent(l) : null;
       if (!rec?.delegation || rec.revoked) return { status: 404, body: { reason: 'an assistant must be an existing delegated address' } };
@@ -812,19 +1063,115 @@ export class Estafeta {
     if (rx.method === 'PUT' && accion === 'config') {
       const v = this._configAsistente(b, cfg);
       if (v.error) return { status: 400, body: { reason: v.error } };
-      const nueva = { ...cfg, ...v, ...(typeof b.persona === 'string' ? { persona: b.persona } : {}), updated: iso() };
+      if (b.enabled != null && typeof b.enabled !== 'boolean') return { status: 400, body: { reason: 'enabled must be true or false' } };
+      // `enabled` por aquí es lo que ENCIENDE un cerebro adoptado: nace apagado a propósito.
+      const nueva = { ...cfg, ...v, ...(typeof b.persona === 'string' ? { persona: b.persona } : {}), ...(typeof b.enabled === 'boolean' ? { enabled: b.enabled } : {}), updated: iso() };
       await this.store.kvPut('asistente', local, nueva);
-      return { status: 200, body: { model: nueva.model, effort: nueva.effort, max_tokens: nueva.max_tokens, budget_usd: nueva.budget_usd, seal: nueva.seal === true } };
+      return { status: 200, body: { enabled: nueva.enabled === true, model: nueva.model, effort: nueva.effort, max_tokens: nueva.max_tokens, budget_usd: nueva.budget_usd, seal: nueva.seal === true, tools: nueva.tools === true, price_tokens: nueva.price_tokens, gate: nueva.gate === true, gate_price_tokens: nueva.gate_price_tokens, gate_abstain_tokens: nueva.gate_abstain_tokens, free_for: nueva.free_for || [] } };
     }
+    if (rx.method === 'DELETE' && !accion) return this._quitarAsistente(local, cfg);
     if (rx.method === 'POST' && (accion === 'pause' || accion === 'resume')) {
       await this.store.kvPut('asistente', local, { ...cfg, enabled: accion === 'resume' });
       return { status: 200, body: { enabled: accion === 'resume' } };
     }
     if (rx.method === 'GET' && !accion) {
       const mes = new Date().toISOString().slice(0, 7);
-      const gasto = (await this.store.kvGet('asistente-gasto', `${local}:${mes}`)) || { usd: 0, llamadas: 0 };
+      const gasto = await gastoDe(this.store, local, mes);
       const con = await this.store.kvGet('asistente-conocimiento', local);
-      return { status: 200, body: { address: `${local}@${this.domain}`, enabled: cfg.enabled, model: cfg.model, effort: cfg.effort, budget_usd: cfg.budget_usd, month: mes, spent_usd: Math.round(gasto.usd * 10000) / 10000, calls: gasto.llamadas, knowledge_bytes: con ? Buffer.byteLength(con.texto) : 0, knowledge_updated: con?.updated || null, api_key: !!this.asistente, pending: (await this.store.listMail(local)).length } };
+      return { status: 200, body: { address: `${local}@${this.domain}`, enabled: cfg.enabled, system: cfg.system === true, adopted: cfg.adopted === true, tools: cfg.tools === true, owner: cfg.owner || null, free_for: cfg.free_for || [], model: cfg.model, effort: cfg.effort, budget_usd: cfg.budget_usd, price_tokens: cfg.price_tokens ?? 0, gate: cfg.gate === true, gate_price_tokens: cfg.gate_price_tokens ?? 0, gate_abstain_tokens: cfg.gate_abstain_tokens ?? 0, month: mes, spent_usd: Math.round(gasto.usd * 10000) / 10000, calls: gasto.llamadas, knowledge_bytes: con ? Buffer.byteLength(con.texto) : 0, knowledge_updated: con?.updated || null, api_key: !!this.asistente, pending: (await this.store.listMail(local)).length } };
+    }
+    return { status: 405, body: { reason: 'method not allowed here' } };
+  }
+
+  // ----- ejecutores: la dirección que trabaja sobre archivos (NX-412) -----
+  // Lo que la casa guarda es el TOKEN de CI y a dónde dispararlo. El trabajo lo hace el ejecutor,
+  // con la llave del rol en los secrets de su repositorio: aquí no se guarda ninguna llave de agente.
+  // El token es de SÓLO ESCRITURA (como los secrets de Cloudflare): se rota, nunca se lee de vuelta.
+  async _adminEjecutor(rx, local, accion) {
+    const b = rx.body || {};
+    const indice = async () => (await this.store.kvGet('ci', '_indice')) || [];
+    const publico = (c) => ({
+      address: `${c.local}@${this.domain}`, provider: c.provider, repo: c.repo, event_type: c.event_type,
+      owner: c.owner, cupo_dia: c.cupo_dia, enabled: c.enabled === true, url: urlCi(c),
+      token: c.token_last4 ? `…${c.token_last4}` : null, created: c.created, updated: c.updated || null,
+    });
+    if (rx.method === 'GET' && !local) {
+      const todos = [];
+      for (const l of await indice()) { const c = await this.store.kvGet('ci', l); if (c) todos.push(publico(c)); }
+      return { status: 200, body: { executors: todos, providers: Object.keys(CI_PROVEEDORES), attempts: CI_INTENTOS, default_quota: CUPO_DESPACHOS_DIA } };
+    }
+    if (rx.method === 'POST' && !local && !accion) {
+      if (!this.boveda) return { status: 503, body: { reason: 'this house has no vault key' } };
+      const l = String(b.local || '').toLowerCase();
+      const rec = Estafeta.validLocal(l) ? await this.store.getAgent(l) : null;
+      if (!rec || rec.revoked) return { status: 404, body: { reason: 'an executor must be an existing address of this house' } };
+      // Un sobre lo contesta UNO: un cerebro en la casa o un ejecutor afuera. Los dos juntos
+      // contestarían el mismo encargo dos veces, y el segundo no sabría que el primero ya respondió.
+      if (await this.store.kvGet('asistente', l)) return { status: 409, body: { reason: `${l}@${this.domain} already has a brain in this house: an address answers with a brain or with an executor, not both. Remove it with DELETE /admin/assistants/${l}` } };
+      if (await this.store.kvGet('ci', l)) return { status: 409, body: { reason: `${l}@${this.domain} already has an executor: change it with PUT /admin/executors/${l}, or remove it with DELETE /admin/executors/${l}` } };
+      const { local: _l, ...campos } = b;
+      const v = validarCi(campos);
+      if (v.error) return { status: 400, body: { reason: v.error } };
+      const token = String(b.token);
+      await this.store.kvPut('boveda', `ci:${l}`, { sellado: this.boveda.sellar({ token }, `ci:${l}`), since: iso() });
+      const cfg = { local: l, ...v, token_last4: token.slice(-4), enabled: b.enabled === true, created: iso() };
+      await this.store.kvPut('ci', l, cfg);
+      const i = await indice();
+      if (!i.includes(l)) await this.store.kvPut('ci', '_indice', [...i, l]);
+      this._ciIdx = null;
+      await this._evento('executor_created', `${l}@${this.domain}`, { provider: cfg.provider, repo: cfg.repo });
+      return { status: 201, body: publico(cfg) };
+    }
+    const cfg = local ? await this.store.kvGet('ci', local) : null;
+    if (!cfg) return { status: 404, body: { reason: 'no such executor' } };
+    if (rx.method === 'GET' && !accion) {
+      const pendientes = await this.store.listMail(local);
+      const rec = await this.store.getAgent(local);
+      const sobres = [];
+      for (const m of pendientes) {
+        if (!despachable(this, local, rec, m)) continue;
+        const d = await this.store.kvGet('ci-despacho', `${local}:${m.envelope.id}`);
+        sobres.push({ envelope: m.envelope.id, from: m.envelope.from, type: m.envelope.type, state: d?.estado || 'nuevo', attempts: Number(d?.intentos || 0), last: d?.ultimo || null, reason: d?.razon || null });
+      }
+      const usado = Number(await this.store.kvGet('ci-cupo', `${local}:${iso().slice(0, 10)}`)) || 0;
+      return { status: 200, body: { ...publico(cfg), pending: pendientes.length, dispatchable: sobres, used_today: usado } };
+    }
+    if (rx.method === 'PUT' && !accion) {
+      const { local: _l2, ...campos } = b;
+      const v = validarCi(campos, cfg);
+      if (v.error) return { status: 400, body: { reason: v.error } };
+      if (b.token != null) {
+        if (!this.boveda) return { status: 503, body: { reason: 'this house has no vault key' } };
+        await this.store.kvPut('boveda', `ci:${local}`, { sellado: this.boveda.sellar({ token: String(b.token) }, `ci:${local}`), since: iso() });
+      }
+      const nueva = { ...cfg, ...v, ...(b.token != null ? { token_last4: String(b.token).slice(-4) } : {}), ...(typeof b.enabled === 'boolean' ? { enabled: b.enabled } : {}), updated: iso() };
+      await this.store.kvPut('ci', local, nueva);
+      return { status: 200, body: publico(nueva) };
+    }
+    if (rx.method === 'DELETE' && !accion) {
+      await this.store.kvDelete('ci', local);
+      await this.store.kvDelete('boveda', `ci:${local}`);
+      await this.store.kvPut('ci', '_indice', (await indice()).filter((x) => x !== local));
+      this._ciIdx = null;
+      await this._evento('executor_removed', `${local}@${this.domain}`, {});
+      return { status: 200, body: { removed: `${local}@${this.domain}` } };
+    }
+    // Volver a intentar a mano lo que agotó sus intentos: es la salida que nombra el aviso al dueño.
+    // Borra el estado del sobre, no el cupo del día: el freno de plata no se levanta por aquí.
+    if (rx.method === 'POST' && accion === 'dispatch') {
+      const rec = await this.store.getAgent(local);
+      const hechos = [];
+      for (const m of await this.store.listMail(local)) {
+        if (!despachable(this, local, rec, m)) continue;
+        const d = await this.store.kvGet('ci-despacho', `${local}:${m.envelope.id}`);
+        if (d?.estado === 'ok') continue;
+        for (let i = 0; i < CI_INTENTOS; i++) await this.store.kvDelete('ci-turno', `${local}:${m.envelope.id}:${i}`);
+        await this.store.kvDelete('ci-despacho', `${local}:${m.envelope.id}`);
+        await this.store.kvDelete('ci-aviso', `${local}:${m.envelope.id}`);
+        const r = await despacharCi(this, local, m.envelope, { cfg });
+        hechos.push({ envelope: m.envelope.id, ok: r.ok === true, status: r.status || null, reason: r.reason || r.skipped || null });
+      }
+      return { status: 200, body: { dispatched: hechos } };
     }
     return { status: 405, body: { reason: 'method not allowed here' } };
   }
@@ -972,6 +1319,11 @@ export class Estafeta {
     // petición no tiene por qué pagarlo.
     if (programado) await this._liberarVencidos();
     if (programado) { try { await atenderAsistentes(this); } catch (e) { this.log(`asistentes: ${e.message}`); } }
+    if (programado && this.ideas.enabled) { try { await atenderIdeas(this); } catch (e) { this.log(`ideas: ${e.message}`); } }
+    if (programado) { try { await atenderEjecutores(this); } catch (e) { this.log(`ejecutores: ${e.message}`); } }
+    // Retención de los adjuntos (NX-413): 30 días, o 7 desde que el último destinatario lo bajó.
+    // Es limpieza, como la purga del kv: si falla no puede tumbar la entrega del correo de todos.
+    if (programado && this.objetos) { try { await limpiarAdjuntos(this, { nowMs: now() }); } catch (e) { this.log(`adjuntos: ${e.message}`); } }
     await this.flushPushes();
   }
   async _deliver(job) {
@@ -1051,13 +1403,13 @@ export class Estafeta {
   async _verificarPendientes() {
     const arbitro = `verifica@${this.domain}`;
     let contratos;
-    try { contratos = await this.store.libroListContracts(); } catch { return; }
+    try { contratos = await this.store.libroListContracts({ state: ['held', 'delivered'] }); } catch { return; }
     const candidatos = contratos.filter((c) => c.kind === 'escrow' && ['held', 'delivered'].includes(c.state) && c.arbiter === arbitro && pruebasDe(c));
     for (const c of candidatos.slice(0, this.verifica.maxPorTick)) {
       // Solo se verifica lo que ya se declaró entregado, salvo que el contrato pida verificar
       // desde el arranque (terms.verify_on: 'accept'), útil para un endpoint que ya debía estar en pie.
       if (c.state === 'held' && (c.terms?.verify_on || 'deliver') !== 'accept') continue;
-      const v = await veredicto(pruebasDe(c), { fetchImpl: this.fetch, timeoutMs: this.verifica.timeoutMs, entregado: c.evidence ?? null, entregadoSha256: c.evidence_sha256 ?? null });
+      const v = await veredicto(pruebasDe(c), { fetchImpl: this.fetch, timeoutMs: this.verifica.timeoutMs, privados: this.verifica.privados === true, entregado: c.evidence ?? null, entregadoSha256: c.evidence_sha256 ?? null });
       if (v.indeciso) { this.log(`verifica ${c.id}: sin veredicto (${v.razon})`); continue; }
       // La decisión viaja como sobre firmado a libro@ y entra por `inbound`, la MISMA puerta
       // que usa cualquier agente (invariante 2). No se toca el Libro por dentro: si la firma
@@ -1085,7 +1437,7 @@ export class Estafeta {
   // comprobar las fechas; aquí sólo se elige a quién mirar.
   async _liberarVencidos() {
     let contratos;
-    try { contratos = await this.store.libroListContracts(); } catch { return; }
+    try { contratos = await this.store.libroListContracts({ state: 'delivered' }); } catch { return; }
     const ahora = now();
     const vencidos = contratos.filter((c) => {
       if (c.kind !== 'escrow' || c.state !== 'delivered') return false;
@@ -1244,6 +1596,12 @@ export class Estafeta {
       if (!rec || !await this._visibleA(rec, env.from)) { rejected.push({ to, code: 404, reason: 'no such agent' }); continue; }
       const p = applyInboxPolicy(env, rec, senderCard._domain);
       if (!p.ok) { rejected.push({ to, ...p, ok: undefined }); continue; }
+      // ideas@ tiene su propia puerta (src/correo/ideas.js): sólo su lista, con cupo diario. Ni el
+      // intro ni el aval de la política general entran: nadie los leería, y el buzón no se borra.
+      if (local === IDEAS_LOCAL && this.ideas.enabled && rec.custody?.via === IDEAS_VIA) {
+        const veto = await puertaIdeas(this, env, rec, this.ideas.cupo ? { cupo: this.ideas.cupo } : {});
+        if (veto) { rejected.push({ to, ...veto }); continue; }
+      }
       try {
         if (local === 'libro') {
           // Operación del Libro: se ejecuta (idempotente por id de sobre), no se almacena;
@@ -1327,6 +1685,10 @@ export class Estafeta {
         mails, libro: libroBundles,
       });
       for (const m of mails) { this._push(m.local, env); this._notifyEmail(m.local, env); }
+      // NX-502: un pedido de pago o su confirmación declaran EN CLARO { kind, request_id, currency }
+      // (extensión firmada); el contenido con el monto y la cuenta va cifrado y la casa no lo ve.
+      // Se anota como evento, nunca como asiento: es dinero real fuera del Libro.
+      if (mails.length) await this._eventoDeCobro(env, mails[0].local);
     }
     for (const rc of recibosPendientes) await this._systemSend('libro', rc.to, { in_reply_to: env.id, thread: rc.thread || env.thread || null, content: { media: MEDIA.recibo, body: rc.body } });
     // Avisos de plazo: sobres del Libro programados para el futuro (un escrow que llega a su
@@ -1372,6 +1734,36 @@ export class Estafeta {
       return this.fetch(rec.webhook, { method: 'POST', headers: { 'content-type': 'application/json', 'x-nyx5-push': `domain=${this.domain}; kid=${this.keys.sig}; sig=${sig}` }, body, signal: AbortSignal.timeout(5000) });
     }).catch((e) => this.log(`webhook ${local} falló: ${e.message} / ${e.cause?.message}`));
     this._pushes.push(pendiente);
+    this._ci(local, env);
+    return pendiente;
+  }
+  // Aviso al EJECUTOR (NX-412): si esta dirección trabaja sobre archivos, la casa no hace el
+  // trabajo — dispara el CI del proyecto y el ejecutor contesta firmando con la llave del rol. El
+  // primer intento sale aquí, al entregar; el reloj reintenta lo que se perdió (`atenderEjecutores`).
+  // Se acumula en `_pushes` por lo mismo que el webhook: una promesa suelta la cancela el runtime.
+  // El índice se cachea en la instancia: `_ci` corre en CADA entrega a CUALQUIER dirección, y sin
+  // esto era una lectura de la base por sobre y por destinatario para algo que casi ninguna
+  // dirección usa. Una casa sin ejecutores paga una lectura por minuto y por isolate. Precio
+  // declarado: un ejecutor recién creado puede tardar hasta un minuto en despachar al entregar; el
+  // reloj, que lee el índice fresco, lo atrapa igual.
+  async _ciIndice() {
+    if (this._ciIdx && this._ciIdx.until > now()) return this._ciIdx.lista;
+    const lista = (await this.store.kvGet('ci', '_indice')) || [];
+    this._ciIdx = { lista, until: now() + 60_000 };
+    return lista;
+  }
+  _ci(local, env) {
+    if (!this.store.kvGet) return null;
+    const pendiente = this._ciIndice().then(async (idx) => {
+      if (!idx.includes(local)) return;
+      const cfg = await this.store.kvGet('ci', local);
+      if (!cfg?.enabled) return;
+      const rec = await this.store.getAgent(local);
+      if (!rec || rec.revoked) return;
+      if (!despachable(this, local, rec, { envelope: env, from_verified: !!env.signature })) return;
+      await despacharCi(this, local, env, { cfg });
+    }).catch((e) => this.log(`ci ${local} falló: ${e.message}`));
+    this._pushes.push(pendiente);
     return pendiente;
   }
   // Aviso por email: si el agente registró `notify_email` y la casa tiene proveedor de salida, le
@@ -1386,9 +1778,23 @@ export class Estafeta {
       const emailOrig = env.extensions?.['urn:nyx5:ext:email']?.from;
       if (emailOrig && emailOrig === rec.notify_email) return; // no te avises de tu propio correo
       const quien = emailOrig || env.from;
+      // Texto aprobado por Nicholas el 14-sep-2026: remitente, proyecto y hora (lo único que la casa
+      // sabe: el contenido va cifrado), y dónde leerlo según el aparato. Sin avisos de recibos.
+      const proyecto = proyectoDe(env);
+      const cuando = new Date(env.created || Date.now()).toUTCString().replace(/:\d\d GMT$/, ' UTC');
+      // El resumen EN CLARO que puso el remitente (29-oct-2026). Sin él, el aviso sólo podía decir
+      // QUIÉN escribió: el cuerpo va cifrado y la casa no lo lee. Con él, el asunto dice de qué se
+      // trata y se puede decidir desde el teléfono sin abrir nada. Va tal cual lo limpió `resumenDe`
+      // (una línea, 140 caracteres, sin controles ni invisibles): el asunto de un correo no se
+      // parte en dos. La casa NO lo inventa ni lo resume: si el remitente no puso línea, no hay.
+      const resumen = resumenDe(env);
       await this.emailOut({ fromAgent: `${local}@${this.domain}`, to: rec.notify_email,
-        subject: `New message on Nyx5 from ${quien}`,
-        text: `${quien} wrote to ${local}@${this.domain}.\n\nOpen it in the mailbox: https://${this.domain}/app\n\n(Automatic notice. The content is in the mailbox, not in this email.)` });
+        subject: resumen
+          ? `${quien}${proyecto ? ` · ${proyecto}` : ''}: ${resumen}`
+          : `${quien} wrote to you on Nyx5${proyecto ? ` (project ${proyecto})` : ''}`,
+        text: resumen
+          ? `${quien} wrote to ${local}@${this.domain}${proyecto ? ` · project: ${proyecto}` : ''} · ${cuando}. They summarised it as: ${resumen} — that line comes from the sender, in the clear; the house did not write it and cannot check it. The content itself is encrypted and only your key opens it. On your Mac: https://${this.domain}/app. From your phone, ask your Claude for your mailbox (replies to what your phone Claude sends arrive there, not here).`
+          : `${quien} wrote to ${local}@${this.domain}${proyecto ? ` · project: ${proyecto}` : ''} · ${cuando}. The content is encrypted and only your key opens it. On your Mac: https://${this.domain}/app. From your phone, ask your Claude for your mailbox (replies to what your phone Claude sends arrive there, not here).` });
     }).catch((e) => this.log(`notify_email ${local} falló: ${e.message}`));
     this._pushes.push(pendiente);
     return pendiente;
@@ -1459,24 +1865,45 @@ export class Estafeta {
   // tumba el rastreo: esa tarjeta entra sin puntaje (al final del orden), y el número queda escrito.
   async _indexReputacion(cards, dc, propia) {
     const cuenta = { pedidas: cards.length, con_puntaje: 0, sin_historial: 0, sin_arbitrados: 0, fallidas: 0 };
-    const LOTE = 4;
-    for (let i = 0; i < cards.length; i += LOTE) {
-      await Promise.all(cards.slice(i, i + LOTE).map(async (c) => {
-        c._score = null; c._jobs_done = null;
-        let hist;
+    const anotar = (c, hist) => { const r = puntajeDe(hist); c._score = r.score; c._jobs_done = r.jobs_done; if (r.motivo) cuenta[r.motivo] += 1; else cuenta.con_puntaje += 1; };
+    const localDe = (c) => String(c.address).slice(0, String(c.address).lastIndexOf('@'));
+    const fallo = (c, e) => { cuenta.fallidas += 1; this.log(`índice: sin historial de ${c.address}: ${e.message}`); };
+    for (const c of cards) { c._score = null; c._jobs_done = null; }
+    if (propia) {
+      // Local, y los contratos se leen una vez para todas las tarjetas.
+      const contratos = await this.store.libroListContracts();
+      for (const c of cards) { try { anotar(c, await this.libro.historial(c.address, { contratos })); } catch (e) { fallo(c, e); } }
+      return cuenta;
+    }
+    // Casa ajena: en lotes por GET /agents/historial?addresses=… (NX-905), una subpetición por cada
+    // HISTORIAL_LOTE_MAX tarjetas en vez de una por tarjeta. Una casa de una versión anterior no
+    // tiene la ruta (404): desde ahí se pide de a una, como antes, de a pocas a la vez.
+    let enLote = true;
+    for (let i = 0; i < cards.length; i += HISTORIAL_LOTE_MAX) {
+      const lote = cards.slice(i, i + HISTORIAL_LOTE_MAX);
+      if (enLote) {
+        let respuesta = null;
         try {
-          if (propia) hist = await this.libro.historial(c.address);
-          else {
-            const local = String(c.address).slice(0, String(c.address).lastIndexOf('@'));
-            const res = await this.fetch(`${dc._estafeta}/agents/${encodeURIComponent(local)}/historial`, { signal: AbortSignal.timeout(10_000) });
+          const res = await this.fetch(`${dc._estafeta}/agents/historial?addresses=${encodeURIComponent(lote.map(localDe).join(','))}`, { signal: AbortSignal.timeout(10_000) });
+          if (res.status === 404) enLote = false;
+          else if (!res.ok) throw new Error(`historial en lote -> ${res.status}`);
+          else respuesta = await res.json();
+        } catch (e) { this.log(`índice: el lote de historiales de ${dc.domain || ''} falló (${e.message}); se pide de a uno`); }
+        if (respuesta) {
+          for (const c of lote) { const h = respuesta.historiales?.[localDe(c)]; if (h) anotar(c, h); else fallo(c, new Error('missing from the batch reply')); }
+          continue;
+        }
+      }
+      const POCAS = 4;
+      for (let j = 0; j < lote.length; j += POCAS) {
+        await Promise.all(lote.slice(j, j + POCAS).map(async (c) => {
+          try {
+            const res = await this.fetch(`${dc._estafeta}/agents/${encodeURIComponent(localDe(c))}/historial`, { signal: AbortSignal.timeout(10_000) });
             if (!res.ok) throw new Error(`historial -> ${res.status}`);
-            hist = await res.json();
-          }
-        } catch (e) { cuenta.fallidas += 1; this.log(`índice: sin historial de ${c.address}: ${e.message}`); return; }
-        const r = puntajeDe(hist);
-        c._score = r.score; c._jobs_done = r.jobs_done;
-        if (r.motivo) cuenta[r.motivo] += 1; else cuenta.con_puntaje += 1;
-      }));
+            anotar(c, await res.json());
+          } catch (e) { fallo(c, e); }
+        }));
+      }
     }
     return cuenta;
   }
@@ -1497,6 +1924,10 @@ export class Estafeta {
     // la casa no manda correo a una dirección que no verificó (nada de backscatter).
     const pol = applyEmailPolicy(rec, from);
     if (!pol.ok) return { ok: false, code: pol.code, reason: pol.reason };
+    // Un correo nunca es una idea (no va firmado): se rechaza en la puerta, y el remitente recibe el
+    // rebote de su propio proveedor. Antes entraba con `From:` de la lista y el tick lo cerraba en
+    // silencio: quien escribía desde su correo creía que había quedado anotado.
+    if (this.ideas.enabled && local === IDEAS_LOCAL && rec.custody?.via === IDEAS_VIA) return { ok: false, code: 403, reason: 'the ideas mailbox records only signed envelopes; email is not recorded' };
     // Y un buzón abierto tampoco es un embudo infinito: se limita por dominio del remitente.
     if (!await this.rate.allow(`email:${String(from).slice(String(from).lastIndexOf('@') + 1).toLowerCase()}`)) {
       return { ok: false, code: 429, reason: 'rate limit for the sending domain' };
@@ -1542,6 +1973,10 @@ export class Estafeta {
     const send = (status, body, headers = null) => (headers ? { status, body, headers } : { status, body });
     // Un 429 dice cuándo volver: Retry-After en segundos hasta la ventana siguiente.
     const tarde = (body) => send(429, body, this._retryAfter());
+    // Un segmento que no se puede decodificar (`%E0%A4%A`) se usa TAL CUAL: nunca es un nombre
+    // válido, así que cae al mismo 404/400 que un inexistente. Antes decodeURIComponent lanzaba
+    // URIError y la ruta contestaba 500 (revisión adversarial del 14-sep).
+    const dec = (s) => { try { return decodeURIComponent(s); } catch { return s; } };
     let m;
     try {
       if (rx.method === 'GET' && path === '/health') return send(200, { ok: true, domain: this.domain, agents: (await this.store.listAgents()).length, queue: (await this.store.listQueue()).length });
@@ -1558,14 +1993,38 @@ export class Estafeta {
       if (this.remoto.enabled && rx.method === 'POST' && path === '/contact-invites') return this.crearInvitacion(rx);
       if (this.remoto.enabled && rx.method === 'GET' && (m = /^\/i\/([A-Za-z0-9_-]{16,64})$/.exec(path))) return this._paginaInvitacion(m[1], rx.query.get('source'), rx.ip);
       // ----- Asistentes (sólo la casa los configura; el dueño los pide) -----
+      if ((m = /^\/admin\/executors(?:\/([^/]+))?(?:\/(dispatch))?$/.exec(path))) {
+        if ((rx.headers.authorization || '') !== `Bearer ${this.adminToken}`) return send(401, { reason: 'only the house configures executors' });
+        return this._adminEjecutor(rx, m[1] ? dec(m[1]).toLowerCase() : null, m[2] || null);
+      }
       if ((m = /^\/admin\/assistants(?:\/([^/]+))?(?:\/(knowledge|config|pause|resume))?$/.exec(path))) {
         if ((rx.headers.authorization || '') !== `Bearer ${this.adminToken}`) return send(401, { reason: 'only the house configures assistants' });
-        return this._adminAsistente(rx, m[1] ? decodeURIComponent(m[1]).toLowerCase() : null, m[2] || null);
+        return this._adminAsistente(rx, m[1] ? dec(m[1]).toLowerCase() : null, m[2] || null);
+      }
+      // ----- ideas@: alta por la casa; el registro lo lee su dueño (o la casa) -----
+      if (this.ideas.enabled && rx.method === 'POST' && path === '/admin/ideas') {
+        if ((rx.headers.authorization || '') !== `Bearer ${this.adminToken}`) return send(401, { reason: 'only the house configures the ideas mailbox' });
+        const r = await this._altaBuzonIdeas(rx.body || {});
+        return send(r.status, r.body);
+      }
+      if (this.ideas.enabled && rx.method === 'GET' && path === '/ideas') {
+        // Sin nombre en la ruta no hay oráculo de existencia: quien no es el dueño recibe 403, y
+        // quien no firma, 401, exista o no el buzón. La lista no dice quién más está en ella.
+        if ((rx.headers.authorization || '') !== `Bearer ${this.adminToken}`) {
+          const who = await this._authenticate(rx, path);
+          const cfg = await this.store.kvGet('ideas', '_config');
+          if (!cfg || who.address !== cfg.owner) return send(403, { reason: 'only the owner of the ideas mailbox reads it' });
+        }
+        // Paginado: `?after=<n>` sigue desde ese número; `next` dice desde dónde sigue la página
+        // siguiente (antes la lista se cortaba en 1.000 en silencio y `total` decía 1.000).
+        const after = rx.query.get('after');
+        if (after != null && !/^\d{1,9}$/.test(after)) return send(400, { reason: 'after must be a non-negative integer' });
+        return send(200, { address: `${IDEAS_LOCAL}@${this.domain}`, ...(await paginaDeIdeas(this, { after: Number(after) || 0 })) });
       }
       // ----- Ficha pública: la edita el dueño de la dirección o el dueño de su delegación -----
       if (rx.method === 'POST' && (m = /^\/agents\/([^/]+)\/profile$/.exec(path))) {
         const who = await this._authenticate(rx, path);
-        const l = decodeURIComponent(m[1]).toLowerCase();
+        const l = dec(m[1]).toLowerCase();
         const rec = Estafeta.validLocal(l) ? await this.store.getAgent(l) : null;
         if (!rec || rec.revoked) return send(404, { reason: 'no such agent' });
         // Una dirección de sólo mensajes no edita ficha alguna, ni la suya: lo que se publica en
@@ -1586,7 +2045,7 @@ export class Estafeta {
       // ----- Presencia: «visto por última vez», sólo con opt-in del dueño -----
       if (rx.method === 'GET' && (m = /^\/agents\/([^/]+)\/presence$/.exec(path))) {
         if (!await this.rate.allow(`resolve:${rx.ip || 'x'}`)) return tarde({ reason: 'too many requests' });
-        const l = decodeURIComponent(m[1]).toLowerCase();
+        const l = dec(m[1]).toLowerCase();
         if (!Estafeta.validLocal(l)) return send(400, { reason: 'invalid agent name' });
         // Un inexistente contesta «sin presencia»; un secreto, a quien no lo ve, exactamente lo mismo.
         const quien = await this._quienPregunta(rx, path);
@@ -1601,7 +2060,7 @@ export class Estafeta {
       }
       if ((m = /^\/groups\/([^/]+)\/members$/.exec(path))) {
         const who = await this._authenticate(rx, path);
-        const l = decodeURIComponent(m[1]).toLowerCase();
+        const l = dec(m[1]).toLowerCase();
         if (!Estafeta.validLocal(l)) return send(400, { reason: 'invalid group name' });
         const r = rx.method === 'GET' ? await this.miembrosGrupo(who, l) : rx.method === 'POST' ? await this.editarGrupo(who, l, rx.body || {}) : { status: 405, body: { reason: 'method not allowed here' } };
         return send(r.status, r.body);
@@ -1674,7 +2133,7 @@ export class Estafeta {
         return { status: 200, contentType: 'text/plain; charset=utf-8', body: `User-agent: *\nAllow: /\n# Los buzones y el Libro exigen firma; no hay nada que rastrear ahí.\nDisallow: /mailbox/\nDisallow: /libro/\nDisallow: /outbox/\nSitemap: https://${this.domain}/sitemap.xml\n` };
       }
       if (rx.method === 'GET' && path === '/sitemap.xml') {
-        const paginas = ['/', '/spec', '/app', '/report', '/llms.txt'].concat(this.tareas.enabled ? ['/tareas'] : []);
+        const paginas = ['/', '/spec', '/app', '/report', '/llms.txt'].concat(this.tareas.enabled ? ['/tareas'] : []).concat(this.terms ? ['/terms'] : []);
         const hoy = iso().slice(0, 10);
         return { status: 200, contentType: 'application/xml; charset=utf-8',
           body: `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${paginas.map((u) => `  <url><loc>https://${this.domain}${u}</loc><lastmod>${hoy}</lastmod></url>`).join('\n')}\n</urlset>\n` };
@@ -1693,7 +2152,7 @@ export class Estafeta {
       // lo dice: "no hay nada que pagar" es una respuesta, no un error.
       const mX402 = rx.method === 'GET' ? /^\/x402\/inbox\/([^/]+)$/.exec(path) : null;
       if (mX402) {
-        const local = decodeURIComponent(mX402[1]).toLowerCase();
+        const local = dec(mX402[1]).toLowerCase();
         const quien = await this._quienPregunta(rx, path);
         const rec = await this.store.getAgent(local);
         if (!rec || !await this._visibleA(rec, quien)) return send(404, { reason: 'no such agent' });
@@ -1733,8 +2192,30 @@ export class Estafeta {
       // Reputación = una consulta al libro. Es PÚBLICA a propósito: sirve justamente para que
       // un desconocido decida antes de contratar, igual que la tarjeta. No expone contenido ni
       // contrapartes: solo cuántas entregas, cuántas fianzas y cuántos tokens se movieron.
+      // Historial en LOTE (NX-905): el rastreo del índice pedía uno por agente, 1+N subpeticiones
+      // por casa ajena, y el edge las tiene contadas. Público como el individual, hasta 50
+      // direcciones por petición, limitado por IP. Una dirección que no existe, que es de otra
+      // casa o que es secreta para quien pregunta vale `null`: la misma respuesta, sin oráculo.
+      // `requested`/`found` son el denominador: cuántas se pidieron y cuántas se resolvieron.
+      if (rx.method === 'GET' && path === '/agents/historial' && rx.query.has('addresses')) {
+        if (!await this.rate.allow(`historial:${rx.ip || 'x'}`)) return tarde({ reason: 'too many requests' });
+        const pedidas = [...new Set(String(rx.query.get('addresses')).split(',').map((x) => x.trim().toLowerCase()).filter(Boolean))];
+        if (!pedidas.length) return send(400, { reason: 'addresses must list at least one address, separated by commas' });
+        if (pedidas.length > HISTORIAL_LOTE_MAX) return send(400, { reason: `addresses: at most ${HISTORIAL_LOTE_MAX} per request, got ${pedidas.length}` });
+        const quien = await this._quienPregunta(rx, path);
+        // Los contratos se leen UNA vez para todo el lote, no una por dirección.
+        const contratos = await this.store.libroListContracts();
+        const historiales = {};
+        for (const dir of pedidas) {
+          let local = dir, dom = this.domain;
+          if (dir.includes('@')) { try { ({ local, domain: dom } = parseAddress(dir)); } catch { historiales[dir] = null; continue; } }
+          const rec = dom === this.domain && Estafeta.validLocal(local) ? await this.store.getAgent(local) : null;
+          historiales[dir] = rec && await this._visibleA(rec, quien) ? await this.libro.historial(`${local}@${this.domain}`, { contratos }) : null;
+        }
+        return send(200, { house: this.domain, requested: pedidas.length, found: Object.values(historiales).filter(Boolean).length, historiales });
+      }
       if (rx.method === 'GET' && (m = /^\/agents\/([^/]+)\/historial$/.exec(path))) {
-        const local = decodeURIComponent(m[1]).toLowerCase();
+        const local = dec(m[1]).toLowerCase();
         const quien = await this._quienPregunta(rx, path);
         const rec = Estafeta.validLocal(local) ? await this.store.getAgent(local) : null;
         if (!rec || !await this._visibleA(rec, quien)) return send(404, { reason: 'no such agent' });
@@ -1745,7 +2226,7 @@ export class Estafeta {
       // declarante se muestra sólo si «nadie» lo vería (_visibleA con quien = null).
       if (rx.method === 'GET' && (m = /^\/notaria\/(?:sello\/([^/]+)|([0-9a-fA-F]{64}))$/.exec(path))) {
         if (!await this.rate.allow(`notaria:${rx.ip || 'x'}`)) return tarde({ reason: 'too many requests' });
-        let idSello = null; if (m[1]) { try { idSello = decodeURIComponent(m[1]); } catch { return send(404, { reason: 'no such seal' }); } }
+        let idSello = null; if (m[1]) { idSello = dec(m[1]); }
         const docs = idSello ? [await this.store.notariaGet(idSello)].filter(Boolean) : await this.store.notariaList(m[2].toLowerCase());
         if (!docs.length) return send(404, { reason: 'no such seal' });
         const seals = [];
@@ -1757,7 +2238,7 @@ export class Estafeta {
         // mismas cabeceras. Lo cuida test/visibilidad.test.js comparando los dos byte a byte.
         // Quién pregunta se resuelve ANTES de mirar si existe: el orden es parte de la igualdad.
         const quien = await this._quienPregunta(rx, path);
-        const card = await this.agentCard(decodeURIComponent(m[1]).toLowerCase());
+        const card = await this.agentCard(dec(m[1]).toLowerCase());
         if (!card || !await this._visibleA(card, quien)) return send(404, { reason: 'no such agent' });
         return send(200, card);
       }
@@ -1832,7 +2313,7 @@ export class Estafeta {
       }
       if (rx.method === 'GET' && (m = /^\/mailbox\/([^/]+)$/.exec(path))) {
         const who = await this._authenticate(rx, path);
-        if (who.local !== decodeURIComponent(m[1]).toLowerCase()) return send(403, { reason: 'not your mailbox' });
+        if (who.local !== dec(m[1]).toLowerCase()) return send(403, { reason: 'not your mailbox' });
         const limit = Number(rx.query.get('limit') || 50);
         // los N más recientes (listMail viene en orden cronológico): con muchos mensajes viejos
         // sin ackear, slice(0,limit) escondía justo los nuevos. slice(-limit) muestra los últimos.
@@ -1840,7 +2321,7 @@ export class Estafeta {
       }
       if (rx.method === 'POST' && (m = /^\/mailbox\/([^/]+)\/ack$/.exec(path))) {
         const who = await this._authenticate(rx, path);
-        if (who.local !== decodeURIComponent(m[1]).toLowerCase()) return send(403, { reason: 'not your mailbox' });
+        if (who.local !== dec(m[1]).toLowerCase()) return send(403, { reason: 'not your mailbox' });
         const { ids = [] } = rx.body || {};
         const acked = [];
         for (const id of ids) if (await this.store.ackMail(who.local, id)) acked.push(id);
@@ -1849,31 +2330,49 @@ export class Estafeta {
         if (acked.length && who.record.capabilities?.read_receipts === true) await this._acusesDeLectura(who, acked);
         return send(200, { acked });
       }
+      // ----- Adjuntos (NX-413): el almacén de objetos de la casa -----
+      // Subir pide la firma del dueño de la casa; bajar y borrar la aceptan de cualquier casa,
+      // porque el destinatario de un sobre casi siempre vive en otra. El ORDEN importa: primero la
+      // autenticación y después mirar si el objeto existe, para que un extraño reciba exactamente
+      // el mismo 401 exista o no (si fuera al revés, /blob sería un oráculo de existencia).
+      if ((m = /^\/blob\/([^/]+)$/.exec(path))) {
+        if (!['PUT', 'GET', 'DELETE'].includes(rx.method)) return send(405, { reason: 'use PUT to upload, GET to download, DELETE to remove an attachment' });
+        if (!this.objetos) return send(503, { reason: 'this house does not host attachments: it has no object store' });
+        const quien = await this._authenticate(rx, path, { allowForeign: rx.method !== 'PUT' });
+        if (!await this.rate.allow(`blob:${quien.address}`)) return tarde({ reason: 'too many requests' });
+        const blob = dec(m[1]);
+        if (rx.method === 'PUT') return subirAdjunto(this, quien, blob, rx.raw, { to: rx.query.get('to') || '', nowMs: now() });
+        if (rx.method === 'DELETE') return borrarAdjunto(this, quien, blob, { nowMs: now() });
+        return bajarAdjunto(this, quien, blob, { nowMs: now() });
+      }
       // ----- Tiempo real, historial, conectores y tarjetas ajenas -----
       if (rx.method === 'GET' && (m = /^\/mailbox\/([^/]+)\/wait$/.exec(path))) {
         const who = await this._authenticate(rx, path);
-        if (who.local !== decodeURIComponent(m[1]).toLowerCase()) return send(403, { reason: 'not your mailbox' });
+        if (who.local !== dec(m[1]).toLowerCase()) return send(403, { reason: 'not your mailbox' });
         const q = Object.fromEntries(rx.query);
         const segundos = Math.max(0, Math.min(Number(q.timeout ?? 25) || 0, 90));
-        const msg = await this.esperarCorreo(who.local, { from: q.from || null, thread: q.thread || null, since: q.since || null, project: q.project ? nombreDeProyecto(q.project) : null, timeoutMs: segundos * 1000 });
+        const project = this._proyectoPedido(rx.query);
+        if (project === false) return send(400, { reason: 'invalid project: empty after normalization, or a reserved word' });
+        const msg = await this.esperarCorreo(who.local, { from: q.from || null, thread: q.thread || null, since: q.since || null, project, timeoutMs: segundos * 1000 });
         return send(200, { message: msg });
       }
       if (rx.method === 'GET' && (m = /^\/conversations\/([^/]+)$/.exec(path))) {
         const who = await this._authenticate(rx, path);
-        if (who.local !== decodeURIComponent(m[1]).toLowerCase()) return send(403, { reason: 'not your conversations' });
+        if (who.local !== dec(m[1]).toLowerCase()) return send(403, { reason: 'not your conversations' });
         const con = rx.query.get('with');
         const limit = Math.max(1, Math.min(Number(rx.query.get('limit') || 50) || 50, 500));
-        const project = rx.query.get("project") ? nombreDeProyecto(rx.query.get("project")) : null;
+        const project = this._proyectoPedido(rx.query);
+        if (project === false) return send(400, { reason: 'invalid project: empty after normalization, or a reserved word' });
         if (con) return send(200, { with: con.toLowerCase(), messages: await this.conversacion(who.local, { con: con.toLowerCase(), limit, project }) });
         return send(200, { conversations: await this.conversacion(who.local, { project }) });
       }
       if (rx.method === 'GET' && (m = /^\/delegations\/([^/]+)$/.exec(path))) {
         const who = await this._authenticate(rx, path);
-        if (who.local !== decodeURIComponent(m[1]).toLowerCase()) return send(403, { reason: 'not your delegations' });
+        if (who.local !== dec(m[1]).toLowerCase()) return send(403, { reason: 'not your delegations' });
         return send(200, { delegations: await this.delegados(who.local) });
       }
       if (rx.method === 'POST' && (m = /^\/agents\/([^/]+)\/revoke$/.exec(path))) {
-        const sub = decodeURIComponent(m[1]).toLowerCase();
+        const sub = dec(m[1]).toLowerCase();
         if (!Estafeta.validLocal(sub)) return send(400, { reason: 'invalid agent name' });
         const rec = await this.store.getAgent(sub);
         if (!rec?.delegation) return send(404, { reason: 'no such subagent' });
@@ -1893,7 +2392,7 @@ export class Estafeta {
       // cifrado del destinatario tendría que mandar en claro.
       if (rx.method === 'GET' && (m = /^\/resolve\/([^/]+)$/.exec(path))) {
         if (!await this.rate.allow(`resolve:${rx.ip || 'x'}`)) return tarde({ reason: 'too many requests' });
-        let addr; try { addr = decodeURIComponent(m[1]).toLowerCase(); parseAddress(addr); } catch { return send(400, { reason: 'invalid address' }); }
+        let addr; try { addr = dec(m[1]).toLowerCase(); parseAddress(addr); } catch { return send(400, { reason: 'invalid address' }); }
         // Para quién se resuelve: el agente de esta casa que firma la petición, si alguno. A una
         // dirección secreta de esta casa se le aplica la misma regla que en /agents/<l>; a una de
         // otra casa, la casa pregunta «para» ese agente y la otra decide.
@@ -1931,13 +2430,13 @@ export class Estafeta {
       }
       if (rx.method === 'GET' && (m = /^\/libro\/cuenta\/([^/]+)$/.exec(path))) {
         const who = await this._authenticate(rx, path, { allowForeign: true });
-        const address = decodeURIComponent(m[1]).toLowerCase();
+        const address = dec(m[1]).toLowerCase();
         if (who.address !== address) return send(403, { reason: 'cuenta ajena' });
         return send(200, await this.libro.account(address));
       }
       if (rx.method === 'GET' && (m = /^\/libro\/contrato\/([^/]+)$/.exec(path))) {
         const who = await this._authenticate(rx, path, { allowForeign: true });
-        const c = await this.store.libroGetContract(decodeURIComponent(m[1]));
+        const c = await this.store.libroGetContract(dec(m[1]));
         if (!c) return send(404, { reason: 'contrato inexistente' });
         if (![c.seller, c.buyer, c.verifier, c.arbiter].includes(who.address)) return send(403, { reason: 'you are not a party to this' });
         return send(200, contratoPublico(c));
@@ -1995,7 +2494,7 @@ export class Estafeta {
       }
       if (rx.method === 'GET' && (m = /^\/outbox\/([^/]+)$/.exec(path))) {
         const who = await this._authenticate(rx, path);
-        if (who.local !== decodeURIComponent(m[1]).toLowerCase()) return send(403, { reason: 'bandeja ajena' });
+        if (who.local !== dec(m[1]).toLowerCase()) return send(403, { reason: 'bandeja ajena' });
         return send(200, { sent: await this.store.listOutbox(who.local) });
       }
       // ----- Índice federado -----