@nyx5/nyx5 0.7.0 → 0.9.0

package/src/correo/ideas.js

@@ -0,0 +1,154 @@
+// Nyx5/1 — ideas@: el buzón automático de vacaciones. RECIBE, GUARDA y CONFIRMA. NUNCA EJECUTA.
+//
+// Nació del pedido de Nicholas del 14-sep-2026 (se va un mes): un lugar donde dejar una idea desde
+// el teléfono y saber que quedó anotada, sin que nadie la ejecute ni la interprete. Corre desde el
+// reloj programado de la casa, sin el Mac y sin ningún modelo de lenguaje.
+//
+// Límites, y son DE CÓDIGO, no de configuración:
+//   - Este módulo no importa nada que hable con la API de Anthropic ni con el Libro, y no tiene
+//     `fetch`. Lo único que sabe mandar es la confirmación a quien escribió (`agente.send` una vez,
+//     al `from` del sobre recibido). `test/ideas.test.js` lo comprueba por inspección de la fuente
+//     (lista CERRADA de lo que puede tocar de la estafeta, del almacén y del agente) y espiando las
+//     salidas de la casa durante el tick.
+//   - Sólo registra sobres FIRMADOS de quien está en la lista del buzón. La puerta (`puertaIdeas`,
+//     que `inbound` consulta para este buzón) rechaza al resto ANTES de guardar nada: ni el `intro`
+//     corto ni el aval con fianza que la política general deja pasar (§9) sirven aquí, porque este
+//     buzón no tiene a nadie que los lea. El tick vuelve a mirar la lista por si algo entró por
+//     otra puerta (un correo, un sobre anterior al alta): se cierra sin registrar y sin contestar.
+//   - Cupo diario por remitente en la puerta (revisión adversarial del 14-sep-2026: una dirección
+//     de la lista podía meter 112 MB por minuto en el buzón, que no se borra nunca): 200 ideas y
+//     5 MB por día UTC; lo que sobra rebota con motivo desde la puerta, no desde este módulo.
+//   - El contenido no se guarda aparte: sigue cifrado en el buzón de ideas@. El registro lleva
+//     sólo el número, quién, cuándo, el hash del sobre, el hilo y el proyecto.
+//   - El texto de la confirmación es FIJO (aprobado con el pedido: «registra y confirma, nunca
+//     ejecuta») y vive en un solo lugar: `CONFIRMACION`.
+import { parseAddress } from './resolver.js';
+import { sha256hex, canonical } from '../nucleo/crypto.js';
+import { proyectoDe, rolDe } from './politica.js';
+
+export const LOCAL = 'ideas';
+export const NS = 'ideas';           // nyx5_kv: `_n` (contador), `n:<000001>` (registro), `sobre:<id>` (idempotencia)
+export const NS_CUPO = 'ideas-cupo'; // nyx5_kv: `<from>:<día>:n` y `<from>:<día>:bytes`, vencen al día siguiente
+export const VIA = 'ideas';          // custody.via de la tarjeta: la casa firma y descifra en su nombre
+export const CUPO_DIARIO = { ideas: 200, bytes: 5 * 1024 * 1024 };
+export const PAGINA = 1000;          // GET /ideas devuelve hasta esto por página, con `next`
+const SISTEMA = new Set(['postmaster', 'libro', 'verifica', 'tareas']);
+const TURNO_MS = 15 * 60_000;
+const DIA_MS = 24 * 3600 * 1000;
+
+export const idDeIdea = (n) => `IDEA-${String(n).padStart(3, '0')}`;
+const claveDe = (n) => `n:${String(n).padStart(6, '0')}`;
+// «2026-09-15 10:22» a partir de una fecha ISO (siempre UTC).
+export const fechaCorta = (isoStr) => String(isoStr).slice(0, 16).replace('T', ' ');
+export const CONFIRMACION = (id, at) => `Saved as ${id} on ${fechaCorta(at)} UTC. Nothing was executed: this mailbox only records and confirms. Nicholas reads it when he is back.`;
+
+const minus = (x) => String(x || '').toLowerCase();
+function enLista(lista, from) {
+  const f = minus(from);
+  let dominio = ''; try { dominio = parseAddress(f).domain; } catch { dominio = ''; }
+  return lista.some((x) => x === f || (dominio && x === dominio));
+}
+
+// La puerta de ideas@, consultada por `inbound` DESPUÉS de la política general y ANTES de guardar.
+// Devuelve null si el sobre puede entrar, o `{ code, reason }` para rechazarlo (el rebote lo hace la
+// estafeta emisora, como con cualquier rechazo de la puerta: no es una salida de este módulo).
+// Rechaza (403, permanente) a quien no está en la lista y a quien agotó su cupo del día: un
+// rechazo transitorio (429) dejaría los sobres reintentando en la cola de la otra casa un día entero.
+// Lo que NO cubre: el cupo se cuenta al aceptar en la puerta, así que dos casas emisoras que
+// entreguen a la vez pueden pasarse por uno; y sólo protege el buzón de ideas@, no el resto de la casa.
+export async function puertaIdeas(est, env, rec, { cupo = CUPO_DIARIO, nowMs = Date.now() } = {}) {
+  const lista = (rec?.inbox?.allowlist || []).map(minus);
+  if (!enLista(lista, env.from)) return { code: 403, reason: 'the ideas mailbox records only signed envelopes from its list: not recorded' };
+  if (!est.store.kvIncrement) return null;
+  const dia = new Date(nowMs).toISOString().slice(0, 10);
+  const vence = (Math.floor(nowMs / DIA_MS) + 2) * DIA_MS;
+  const clave = `${minus(env.from)}:${dia}`;
+  const bytes = Buffer.byteLength(JSON.stringify(env));
+  // Se suma ANTES de comparar: con dos relojes contando a la vez, el que se pasa cierra el día.
+  const n = await est.store.kvIncrement(NS_CUPO, `${clave}:n`, vence, nowMs);
+  const total = await est.store.kvIncrement(NS_CUPO, `${clave}:bytes`, vence, nowMs, bytes);
+  if (n > cupo.ideas || total > cupo.bytes) return { code: 403, reason: `daily limit of the ideas mailbox reached for this sender (${cupo.ideas} ideas or ${Math.round(cupo.bytes / 1024 / 1024)} MB per UTC day): not recorded` };
+  return null;
+}
+
+// El registro ordenado por número, para GET /ideas: hasta `limit` registros con número > `after`.
+export async function listarIdeas(est, { after = 0, limit = PAGINA } = {}) {
+  const filas = await est.store.kvList(NS, { prefix: 'n:', after: after > 0 ? claveDe(after) : undefined, limit });
+  return filas.map((f) => f.doc).sort((a, b) => a.n - b.n);
+}
+// Lo que contesta GET /ideas: `total` es el último número asignado (puede superar a los registros
+// si un reloj cayó entre asignar el número y escribir el registro), `next` es el número desde el
+// que sigue la página siguiente, o null si ésta es la última.
+export async function paginaDeIdeas(est, { after = 0 } = {}) {
+  const ideas = await listarIdeas(est, { after, limit: PAGINA });
+  const total = Number(await est.store.kvGet(NS, '_n')) || 0;
+  return { total, count: ideas.length, ideas, next: ideas.length === PAGINA ? ideas[ideas.length - 1].n : null };
+}
+
+// Un tick: cada sobre pendiente del buzón se registra (número correlativo durable) y se confirma.
+// Devuelve cuántas ideas registró. Dos relojes sobre el mismo almacén no repiten número ni
+// confirmación: un turno por sobre (`kvPutIfAbsent`) y un número por sobre (`sobre:<id>`).
+// `maxPorTick` acota las ideas registradas por pasada; `maxDescartesPorTick`, lo que se cierra sin
+// registrar (correo sin firma, rebotes del postmaster, algo anterior al alta): un buzón lleno de
+// eso no puede comerse el minuto del reloj, y tampoco puede dejar sin turno a las ideas de verdad
+// (son cupos separados).
+export async function atenderIdeas(est, { maxPorTick = 20, maxDescartesPorTick = 200 } = {}) {
+  if (!est.ideas?.enabled || !est.store.kvIncrement) return 0;
+  const rec = await est.store.getAgent(LOCAL);
+  if (!rec || rec.revoked || rec.custody?.via !== VIA) return 0;
+  const lista = (rec.inbox?.allowlist || []).map(minus);
+  const propia = `${LOCAL}@${est.domain}`;
+  let registradas = 0;
+  let vistos = 0, descartes = 0;
+  for (const m of await est.store.listMail(LOCAL)) {
+    if (vistos >= maxPorTick && descartes >= maxDescartesPorTick) break;
+    const e = m.envelope || {};
+    let de; try { de = parseAddress(e.from); } catch { continue; }
+    // Lo que manda la casa (un rebote, un recibo) o el propio buzón no es una idea: se cierra y sigue.
+    const deSistema = (de.domain === est.domain && SISTEMA.has(de.local)) || e.from === propia || e.type === 'receipt';
+    // Sin firma (un correo) o fuera de la lista (algo que entró antes del alta o por otra puerta): se
+    // cierra sin registrar y sin contestar. Contestarle a un desconocido sería la salida que este
+    // buzón no tiene.
+    const ajeno = !e.signature || m.from_verified === false || !enLista(lista, e.from);
+    if (deSistema || ajeno) {
+      if (descartes >= maxDescartesPorTick) continue;
+      descartes++;
+      if (!deSistema) est.log(`ideas@: sobre ${e.id} de ${e.from} descartado (${!e.signature || m.from_verified === false ? 'sin firma' : 'fuera de la lista'})`);
+      await est.store.ackMail(LOCAL, e.id);
+      continue;
+    }
+    if (vistos >= maxPorTick) continue;
+    vistos++;
+    if (!(await est.store.kvPutIfAbsent('ideas-turno', e.id, { at: new Date().toISOString() }, Date.now() + TURNO_MS))) continue;
+    try {
+      const agente = await est.agenteDeBoveda(LOCAL);
+      if (!agente) throw new Error('la bóveda no tiene la llave de ideas@');
+      // Un número por sobre: si un tick anterior asignó número y no llegó a confirmar, se reutiliza.
+      let n = Number((await est.store.kvGet(NS, `sobre:${e.id}`))?.n) || 0;
+      if (!n) {
+        n = await est.store.kvIncrement(NS, '_n');
+        await est.store.kvPut(NS, `sobre:${e.id}`, { n });
+      }
+      // El registro se escribe si no está, aunque el número ya estuviera asignado: un reloj que cayó
+      // entre asignar el número y escribir el registro no puede dejar una idea confirmada y sin
+      // registro (revisión adversarial del 14-sep-2026). No depende del contenido: si el sobre no se
+      // puede abrir, se registra igual por su hash.
+      let registro = await est.store.kvGet(NS, claveDe(n));
+      if (!registro) {
+        let abierto = false;
+        try { await agente.open(e); abierto = true; } catch { abierto = false; }
+        registro = { n, id: idDeIdea(n), id_sobre: e.id, from: e.from, at: new Date().toISOString(), sha256_sobre: sha256hex(canonical(e)), thread: e.thread || e.id, project: proyectoDe(e), role: rolDe(e), opened: abierto };
+        await est.store.kvPut(NS, claveDe(n), registro);
+      }
+      // La ÚNICA salida de este módulo: la confirmación a quien escribió, en su hilo y su proyecto.
+      await agente.send({ to: e.from, body: CONFIRMACION(registro.id, registro.at), thread: e.thread || e.id, inReplyTo: e.id, project: registro.project || undefined, role: registro.role || undefined });
+      await est.store.ackMail(LOCAL, e.id);
+      registradas++;
+      await est._evento('idea_saved', e.from, { idea: registro.id, sobre: e.id });
+    } catch (err) {
+      // El turno queda tomado 15 minutos y se reintenta; el número, si ya salió, se conserva.
+      est.log(`ideas@: ${e.id} no se pudo confirmar: ${err.message}`);
+    }
+  }
+  return registradas;
+}

package/src/correo/identidad.js

@@ -0,0 +1,81 @@
+// Nyx5/1 — qué identidad usa un comando cuando nadie la nombró.
+//
+// La premisa de Nyx5 es cero fricción: un agente decide usarlo y lo usa, sin pasos previos. Hasta
+// el 4-nov-2026 los 16 comandos del cliente exigían `--agent /ruta/larga/a/la/llave.json`, así que
+// el primer contacto eran DOS comandos y una ruta que el agente tenía que acarrear entre turnos.
+// Una ruta que hay que recordar es estado, y el estado entre turnos es justo donde un modelo
+// falla. Aquí no hay estado: la identidad se deduce.
+//
+// El orden, de lo más explícito a lo más implícito:
+//   1. `--agent <ruta>`        quien lo dice, manda. No cambia nada de lo que ya funcionaba.
+//   2. `NYX5_AGENT`            para CI y contenedores, donde no hay home del usuario.
+//   3. una sola llave en el directorio   el caso normal: tienes una identidad, es ésa.
+//   4. el puntero `default`    cuando tienes varias y elegiste una con `nyx5 use`.
+//   5. ninguna                 quien llama decide: la CLI se une sola y sigue.
+//
+// Y lo PROGRESIVO: nada de esto se le pide al que llega. La ruta aparece cuando tienes dos
+// identidades, no antes; la casa, cuando quieres otra; la llave explícita, cuando automatizas.
+// Tener dos nunca se adivina: dos identidades es ambigüedad, y adivinar ahí firma con la que no
+// era. Se devuelve `varias` y el que llama lo dice con los nombres.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+// `NYX5_HOME` existe para las pruebas y para un contenedor sin home: un test que escribiera en
+// el ~/.nyx5 de quien lo corre le pisaría sus llaves de verdad.
+export const directorioDeLlaves = (env = process.env) => env.NYX5_HOME || path.join(os.homedir(), '.nyx5');
+
+// El puntero a la identidad elegida cuando hay varias. Es un archivo de texto con el nombre del
+// archivo de llave, no un enlace: un enlace roto es invisible y esto se lee de un vistazo.
+export const PUNTERO = 'default';
+
+// Una llave es un archivo que TIENE dirección, no cualquier `.json`. Nació de un borde que
+// encontró su propia prueba: un `hosts.json` en el mismo directorio se contaba como identidad, y
+// con eso una máquina con una sola llave parecía tener dos y quedaba preguntando.
+export function listarLlaves(dir) {
+  let entradas;
+  try { entradas = fs.readdirSync(dir); } catch { return []; }
+  return entradas.filter((f) => f.endsWith('.json') && direccionDe(path.join(dir, f))).sort();
+}
+
+export function leerPuntero(dir) {
+  try { return fs.readFileSync(path.join(dir, PUNTERO), 'utf8').trim() || null; } catch { return null; }
+}
+
+export function escribirPuntero(dir, archivo) {
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, PUNTERO), `${archivo}\n`, { mode: 0o600 });
+}
+
+// La dirección que hay dentro de un archivo de llave, para poder elegir por dirección y no por
+// nombre de archivo. Un archivo ilegible no tumba la elección: devuelve null y se ignora.
+export function direccionDe(archivo) {
+  try { return JSON.parse(fs.readFileSync(archivo, 'utf8')).address || null; } catch { return null; }
+}
+
+// -> { ruta } | { ninguna: true, dir } | { varias: [{ archivo, address }], dir }
+export function elegirLlave({ flag = null, env = process.env, dir = null } = {}) {
+  if (flag) return { ruta: flag };
+  if (env.NYX5_AGENT) return { ruta: env.NYX5_AGENT };
+  const d = dir || directorioDeLlaves(env);
+  const llaves = listarLlaves(d);
+  if (llaves.length === 0) return { ninguna: true, dir: d };
+  if (llaves.length === 1) return { ruta: path.join(d, llaves[0]) };
+  const elegido = leerPuntero(d);
+  if (elegido && llaves.includes(elegido)) return { ruta: path.join(d, elegido) };
+  return { varias: llaves.map((archivo) => ({ archivo, address: direccionDe(path.join(d, archivo)) })), dir: d };
+}
+
+// El archivo que corresponde a una dirección (o a un nombre de archivo), para `nyx5 use`.
+export function archivoDe(dir, quien) {
+  const llaves = listarLlaves(dir);
+  const q = String(quien || '').toLowerCase();
+  if (llaves.includes(q)) return q;
+  if (llaves.includes(`${q}.json`)) return `${q}.json`;
+  for (const f of llaves) {
+    const a = direccionDe(path.join(dir, f));
+    if (a && (a.toLowerCase() === q || a.toLowerCase().split('@')[0] === q)) return f;
+  }
+  return null;
+}

package/src/correo/politica.js

@@ -21,9 +21,33 @@ export const EXT_PROYECTO = 'urn:nyx5:ext:proyecto';
 // llegaban tal cual a la herramienta del Claude remoto. Se limpian y acotan como la ficha, y el
 // proyecto se normaliza (NFKC, sin invisibles) para que un homógrafo no esconda un mensaje del filtro.
 export const proyectoDe = (env) => { const p = env?.extensions?.[EXT_PROYECTO]?.project; return typeof p === 'string' ? nombreDeProyecto(p) : null; };
-export const nombreDeProyecto = (p) => limpio(String(p).normalize('NFKC'), 40).toLowerCase() || null;
+// Devuelve null cuando lo que queda no es un nombre: vacío tras limpiar, o un nombre que es
+// propiedad propia de Object.prototype (`__proto__`, `constructor`). Revisión del 14-sep-2026:
+// `pending_by_project` viaja como objeto JSON y un lector que haga `mapa[p]` con ese nombre ausente
+// recibe una función en vez de un número (o, al armar el objeto, pisa el prototipo). Es UNA función
+// para las dos puertas: el cliente rechaza al enviar y la casa lee «sin proyecto» si llega de fuera.
+export const nombreDeProyecto = (p) => { const n = limpio(String(p).normalize('NFKC'), 40).toLowerCase(); return n && !Object.hasOwn(Object.prototype, n) ? n : null; };
 export const rolDe = (env) => { const r = env?.extensions?.[EXT_PROYECTO]?.role; return typeof r === 'string' ? (limpio(r, 40) || null) : null; };
 
+// El RESUMEN EN CLARO (29-oct-2026, decisión de Nicholas). El aviso por correo sólo podía decir
+// QUIÉN le escribió, nunca QUÉ: el contenido va cifrado y la casa no lo lee (invariante 8). Un
+// timbre que no dice quién está en la puerta es ruido, y él tiene que abrir la app para saber si
+// algo le toca. Ahora el REMITENTE puede adjuntar una línea que viaja SIN CIFRAR, y la casa la
+// pone en el asunto del aviso.
+//
+// Quién decide qué se expone: el que escribe, no la casa. Por eso la línea es opcional y por eso
+// la descripción de la herramienta dice, con todas sus letras, que la leen la casa y el correo.
+// Nunca va ahí lo que el sobre protege: va de qué se trata, no lo que dice.
+//
+// Se limpia como el proyecto y se acota a UNA línea: `limpio` cambia los controles por espacios y
+// colapsa, así que un salto de línea no puede partir el asunto de un correo en dos.
+export const EXT_RESUMEN = 'urn:nyx5:ext:resumen';
+export const RESUMEN_MAX = 140;
+export const resumenDe = (env) => {
+  const r = env?.extensions?.[EXT_RESUMEN]?.text;
+  return typeof r === 'string' ? (limpio(r, RESUMEN_MAX) || null) : null;
+};
+
 // Ficha pública del agente (13-sep-2026): qué hace, en qué idiomas, de quién es, con qué etiquetas.
 // Va DENTRO de la tarjeta certificada, la firma el dueño al declararla y la casa al certificarla.
 // Vocabulario CERRADO, como el alcance de un mandato: una clave desconocida se rechaza nombrándola,
@@ -137,6 +161,59 @@ export function usdSinBilletera(perfil, wallets) {
   return `service "${con[0].id}" declares a usd price but the card has no wallet; declare wallets first`;
 }
 
+// ---------- adjuntos (NX-413) ----------
+// El archivo NO viaja en el sobre: viaja cifrado al almacén de objetos de la casa del remitente y
+// el sobre lleva la referencia. Esta validación es la que decide qué puede verse desde afuera.
+//
+// En un sobre CIFRADO el array de afuera lleva SÓLO `blob` y `bytes`, y el vocabulario es CERRADO:
+// una clave de más se RECHAZA con nombre, no se ignora. Contradice el invariante 7 a propósito, por
+// la misma razón que `ALCANCE_MANDATO` (9-sep-2026): ese invariante es para extender mensajes sin
+// romper nada, y aquí ignorar un campo de más NO es neutro — `name: "balance-despido-javier.pdf"`
+// afuera del cifrado le cuenta a la casa y a cualquier estafeta del camino casi todo el contenido.
+// Si alguien "arregla" esta inconsistencia para que sea permisiva, reabre la fuga.
+//
+// En un sobre EN CLARO el array lleva la ficha completa, `key` incluida: el adjunto sigue cifrado
+// en el almacén, pero la llave viaja a la vista y la casa SÍ puede abrirlo. Se permite (hay usos
+// legítimos: un adjunto público) y la herramienta lo advierte antes de que un agente lo elija.
+export const ADJUNTO_CIFRADO = ['blob', 'bytes'];
+export const ADJUNTO_CLARO = ['blob', 'bytes', 'name', 'media', 'sha256', 'key'];
+export const ADJUNTOS = { max: 10, bytesPorSobre: 25 * 1024 * 1024, bytesPorAdjunto: 10 * 1024 * 1024, nombreMax: 120, mediaMax: 100 };
+const UUID_BLOB = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const MEDIA_TIPO = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i;
+const ENTERO = (v, max) => Number.isSafeInteger(v) && v > 0 && v <= max;
+
+// Devuelve el motivo del rechazo (string) o null si los adjuntos están bien.
+export function validarAdjuntos(attachments, { cifrado = true } = {}) {
+  if (!Array.isArray(attachments)) return 'attachments must be a list';
+  if (attachments.length > ADJUNTOS.max) return `an envelope carries at most ${ADJUNTOS.max} attachments, not ${attachments.length}`;
+  const permitidas = cifrado ? ADJUNTO_CIFRADO : ADJUNTO_CLARO;
+  const vistos = new Set();
+  let total = 0;
+  for (const [i, a] of attachments.entries()) {
+    const donde = `attachments[${i}]`;
+    if (!a || typeof a !== 'object' || Array.isArray(a)) return `${donde} must be an object`;
+    for (const k of Object.keys(a)) {
+      if (!permitidas.includes(k)) {
+        return cifrado
+          ? `${donde}.${k} must not travel outside the encrypted block (an attachment of an encrypted envelope carries only ${ADJUNTO_CIFRADO.join(' and ')}; name, media, sha256 and key go inside)`
+          : `${donde}.${k} is not an attachment field (${ADJUNTO_CLARO.join(', ')})`;
+      }
+    }
+    if (!UUID_BLOB.test(String(a.blob || ''))) return `${donde}.blob must be the uuid of an uploaded object`;
+    if (vistos.has(String(a.blob).toLowerCase())) return `${donde}.blob repeats an attachment of this same envelope`;
+    vistos.add(String(a.blob).toLowerCase());
+    if (!ENTERO(a.bytes, ADJUNTOS.bytesPorAdjunto)) return `${donde}.bytes must be an integer between 1 and ${ADJUNTOS.bytesPorAdjunto} (${Math.round(ADJUNTOS.bytesPorAdjunto / 1024 / 1024)} MB per attachment)`;
+    total += a.bytes;
+    if (cifrado) continue;
+    if (typeof a.name !== 'string' || !limpio(a.name, ADJUNTOS.nombreMax)) return `${donde}.name must be a non-empty string of at most ${ADJUNTOS.nombreMax} characters`;
+    if (typeof a.media !== 'string' || a.media.length > ADJUNTOS.mediaMax || !MEDIA_TIPO.test(a.media)) return `${donde}.media must be a media type like application/pdf`;
+    if (typeof a.sha256 !== 'string' || !/^[0-9a-f]{64}$/i.test(a.sha256)) return `${donde}.sha256 must be the hex sha256 of the plaintext (64 characters)`;
+    if (a.key != null && (typeof a.key !== 'string' || !/^[A-Za-z0-9_-]{43}$/.test(a.key))) return `${donde}.key must be the base64url of a 32-byte key`;
+  }
+  if (total > ADJUNTOS.bytesPorSobre) return `the attachments of one envelope add up to ${total} bytes and the maximum is ${ADJUNTOS.bytesPorSobre} (${Math.round(ADJUNTOS.bytesPorSobre / 1024 / 1024)} MB)`;
+  return null;
+}
+
 export function validateEnvelope(env, { maxBytes = 1_048_576 } = {}) {
   const fail = (reason) => ({ ok: false, code: 400, reason });
   if (!env || typeof env !== 'object') return fail('sobre no es un objeto');
@@ -160,8 +237,13 @@ export function validateEnvelope(env, { maxBytes = 1_048_576 } = {}) {
   if (!hasPlain && !hasEnc) return fail('el sobre necesita content o encrypted');
   if (hasPlain && hasEnc) return fail('content y encrypted son excluyentes');
   if (env.attachments != null) {
-    if (!Array.isArray(env.attachments)) return fail('attachments debe ser lista');
-    for (const a of env.attachments) if (!a?.name || !a?.media || !a?.sha256 || !a?.url) return fail('adjunto incompleto (name, media, sha256, url)');
+    // `!!hasEnc` y no `hasEnc`: para un sobre en claro `hasEnc` vale undefined, no false, y un
+    // undefined ACTIVA el valor por defecto del parámetro (`cifrado = true`), así que los adjuntos
+    // de un sobre EN CLARO se validaban con las reglas del cifrado y se rechazaban todos. Se vio
+    // al probar el caso en claro con un adjunto real. El defecto caía del lado estricto, que es el
+    // que corresponde si hay que equivocarse, pero era el branch equivocado igual.
+    const e = validarAdjuntos(env.attachments, { cifrado: !!hasEnc });
+    if (e) return fail(e);
   }
   if (!env.signature || env.signature.alg !== 'Ed25519' || !env.signature.kid || !env.signature.value) return fail('sobre sin firma');
   const bytes = Buffer.byteLength(JSON.stringify(env));
@@ -256,6 +338,13 @@ export function applyInboxPolicy(env, agentRecord, senderDomain) {
   const esLibro = String(agentRecord.address || '').startsWith('libro@');
   if (!esLibro && senderDomain?.policy?.outbound === 'sealed' && !env.encrypted) return permanent('el dominio emisor exige cifrado y el sobre viene en claro');
 
+  // Un sobre de una dirección a SÍ MISMA pasa su propia política (26-oct-2026). Es lo que sostiene
+  // `recordar`, la memoria entre sesiones: un sobre diferido al propio buzón. Antes rebotaba contra
+  // su propia lista blanca — `nyx5_remind` quedaba decorativo en todo buzón por lista — y en un buzón
+  // con estampilla se cobraba a sí mismo. Una lista, una prueba de trabajo o una estampilla defienden
+  // de OTROS; no abren nada, porque sólo quien tiene esa llave puede firmar como esa dirección.
+  if (env.from === agentRecord.address) return { ok: true };
+
   switch (inbox.policy) {
     case 'open':
       break;

package/src/correo/unirse.js

@@ -8,6 +8,8 @@
 // No es una cuenta: no hay correo, ni contraseña, ni nada del humano. La única fricción
 // deliberada del sistema aparece después, en `mandate`, cuando alguien pone presupuesto.
 
+import path from 'node:path';
+import { directorioDeLlaves } from './identidad.js';
 import { Agent } from './agente.js';
 import { Resolver, parseAddress } from './resolver.js';
 import { Estafeta } from './estafeta.js';
@@ -27,12 +29,19 @@ export function nombreSugerido(raiz = 'agente') {
   return `${base}-${sufijo()}`;
 }
 
-export function bloqueMcp({ address, keyfile, comando = 'npx', args = ['-y', '@nyx5/nyx5'] }) {
+// El bloque que un agente pega en su cliente. Desde el 4-nov-2026 NO lleva la ruta de la llave:
+// el puente la deduce igual que el resto de los comandos (src/correo/identidad.js), y si no hay
+// ninguna se une solo al arrancar. Eso lo vuelve CONSTANTE — las mismas tres líneas para todos y
+// para siempre —, y por lo tanto algo que se puede publicar y que un agente puede escribirse a sí
+// mismo sin haber corrido nada antes. Con la ruta dentro, cada agente necesitaba un bloque
+// distinto, que es exactamente la fricción que este proyecto dice no tener.
+// `keyfile` se sigue aceptando para un caso real: varias identidades en la misma máquina.
+export function bloqueMcp({ address, keyfile = null, comando = 'npx', args = ['-y', '@nyx5/nyx5'] } = {}) {
   return {
     mcpServers: {
-      nyx5: { command: comando, args: [...args, 'mcp', '--agent', keyfile], env: {} },
+      nyx5: { command: comando, args: [...args, 'mcp', ...(keyfile ? ['--agent', keyfile] : [])], env: {} },
     },
-    _agent: address,
+    ...(address ? { _agent: address } : {}),
   };
 }
 
@@ -104,7 +113,8 @@ async function _despues(agente, card, { keyfile, house }) {
     address: agente.address, house, estafeta: agente.estafeta,
     keys: agente.keys, keyfile: archivo, card,
     balance, historial,
-    mcp: bloqueMcp({ address: agente.address, keyfile: archivo }),
+    // Sin ruta si la llave quedó donde el puente la busca sola (ver bloqueMcp y identidad.js).
+    mcp: bloqueMcp({ address: agente.address, keyfile: archivo && path.dirname(archivo) === directorioDeLlaves() ? null : archivo }),
     first,
     _agente: agente,
   };

package/src/libro/libro.js

@@ -36,6 +36,8 @@ export const MEDIA = {
   op: 'application/nyx5.libro+json',
   cotizacion: 'application/nyx5.cotizacion+json',
   recibo: 'application/nyx5.recibo+json',
+  // NX-305: un comprador PIDE un servicio del catálogo; el vendedor contesta con la cotización.
+  pedido: 'application/nyx5.pedido+json',
 };
 
 const iso = () => new Date().toISOString();
@@ -121,8 +123,10 @@ export class Libro {
   //   bond   released | forfeited         afirmación sostenida | derribada
   static TERMINALES = { spot: ['settled'], escrow: ['released', 'refunded'], bond: ['released', 'forfeited'], metered: [] };
 
-  async historial(address) {
-    const todos = await this.store.libroListContracts();
+  // `contratos`: la lista ya leída, para que un lote de historiales (la ruta en lote, el rastreo
+  // del índice) no vuelva a leer la tabla por cada dirección.
+  async historial(address, { contratos = null } = {}) {
+    const todos = contratos ?? await this.store.libroListContracts();
     const mios = todos.filter((c) => [c.seller, c.buyer].includes(address));
     const cuenta = () => ({ n: 0, tokens: 0 });
     const h = {