@nyx5/nyx5 0.6.0 → 0.7.0

package/src/correo/indice.js

@@ -0,0 +1,178 @@
+// Nyx5/1 — búsqueda del índice federado con reputación y precio (NX-302).
+//
+// UNA definición para los dos almacenes: qué columnas se extraen de una tarjeta, cómo se
+// codifica el cursor, qué filtros se aceptan y cómo se pagina. FileStore usa `buscarEnMemoria`
+// tal cual; D1Store traduce las mismas reglas a SQL. Si las dos implementaciones divergen, el
+// test de paginación (test/busqueda.test.js) corre sobre ambas y lo dice.
+//
+// Orden: (puntaje DESC, los sin puntaje al FINAL, dirección ASC). Cursor opaco = base64url de
+// JSON { s, a, g }: el puntaje y la dirección de la última fila servida, y la GENERACIÓN del
+// índice en la que empezó el recorrido. Nunca un offset: un offset sobre un conjunto que cambia
+// entre páginas salta o repite filas (trampa «ventana horneada e isla»).
+//
+// Por qué la generación: el puntaje CAMBIA con cada rastreo, y un cursor por (puntaje,
+// dirección) sobre un puntaje que se mueve repite al que bajó y se salta al que subió. Cada
+// fila guarda, además del puntaje actual, un historial corto de sus cambios: `hist` =
+// [{ g, s }] (generación en que el puntaje pasó a valer s), los últimos HIST_MAX cambios, y
+// `first_gen`, la generación en que la dirección entró al índice. Un recorrido que empezó en
+// la generación g ordena cada fila por el puntaje que tenía en g: la última entrada de `hist`
+// con g' <= g. Si esa entrada ya se descartó (más de HIST_MAX cambios desde que empezó el
+// recorrido), el puntaje congelado no existe: el recorrido se declara caduco (410) y quien
+// recorre vuelve a empezar; nunca se sirve una página en silencio con otro orden.
+// Lo que NO cubre: un agente que ENTRA al índice después de empezar el recorrido va al final
+// (clave nula) y se ve sólo si el recorrido no pasó ya por los nulos; uno que SALE deja de
+// verse; y los filtros de etiqueta/idioma/precio miran la fila ACTUAL (quien cambió de ficha a
+// mitad del recorrido entra o sale del conjunto según su ficha de hoy).
+
+import { puntajeArbitrado } from '../libro/libro.js';
+
+const fallo = (status, message) => Object.assign(new Error(message), { status });
+
+// ---------- columnas que el índice extrae de una tarjeta ----------
+// El precio sale de `profile.services[].price.tokens` (la ficha con servicios la agrega otro
+// frente; aquí sólo se lee si existe). Sin servicios con precio en tokens, `price_min` es null
+// y el agente NO pasa un filtro `price_max`: no anunciar precio no es ser gratis.
+export function precioMinimo(card) {
+  const servicios = card?.profile?.services;
+  if (!Array.isArray(servicios)) return null;
+  const precios = servicios.map((s) => s?.price?.tokens).filter((t) => Number.isInteger(t) && t >= 0);
+  return precios.length ? Math.min(...precios) : null;
+}
+
+export function columnasDeIndice(card) {
+  const tags = Array.isArray(card?.profile?.tags) ? card.profile.tags.filter((t) => typeof t === 'string') : [];
+  const langs = Array.isArray(card?.profile?.languages) ? card.profile.languages.filter((l) => typeof l === 'string').map((l) => l.toLowerCase()) : [];
+  const score = typeof card?._score === 'number' && Number.isFinite(card._score) ? card._score : null;
+  const jobs_done = Number.isInteger(card?._jobs_done) ? card._jobs_done : null;
+  return { tags, langs, price_min: precioMinimo(card), score, jobs_done };
+}
+
+// El puntaje de un agente a partir de su historial público (§21). Sólo cuenta lo arbitrado por
+// `verifica@` de su casa; una casa que no distingue arbitrados (versión anterior) no da puntaje.
+// Devuelve también el motivo cuando no hay puntaje, para que el rastreo cuente su denominador.
+export function puntajeDe(historial) {
+  if (!historial || typeof historial !== 'object') return { score: null, jobs_done: null, motivo: 'sin_historial' };
+  if (!historial.arbitrados || typeof historial.arbitrados !== 'object') return { score: null, jobs_done: null, motivo: 'sin_arbitrados' };
+  const score = puntajeArbitrado(historial.arbitrados);
+  if (score == null) return { score: null, jobs_done: 0, motivo: 'sin_historial' };
+  return { score, jobs_done: Number(historial.arbitrados.liberados?.n) || 0, motivo: null };
+}
+
+// ---------- cursor ----------
+export function codificarCursor({ s, a, g }) {
+  return Buffer.from(JSON.stringify({ s: s ?? null, a, g })).toString('base64url');
+}
+export function decodificarCursor(texto) {
+  const invalido = () => fallo(400, 'invalid cursor: use the next_cursor the index gave you, or none for the first page');
+  if (typeof texto !== 'string' || !/^[A-Za-z0-9_-]{1,600}$/.test(texto)) throw invalido();
+  let c;
+  try { c = JSON.parse(Buffer.from(texto, 'base64url').toString('utf8')); } catch { throw invalido(); }
+  if (!c || typeof c !== 'object' || Array.isArray(c)) throw invalido();
+  if (Object.keys(c).some((k) => !['s', 'a', 'g'].includes(k))) throw invalido();
+  if (!(c.s === null || (typeof c.s === 'number' && Number.isFinite(c.s) && c.s >= 0 && c.s <= 1))) throw invalido();
+  if (typeof c.a !== 'string' || !c.a || c.a.length > 320) throw invalido();
+  if (!Number.isSafeInteger(c.g) || c.g < 0) throw invalido();
+  return c;
+}
+
+// ---------- filtros de la consulta ----------
+// `p` son los parámetros crudos (strings de la URL o valores de la herramienta MCP). Falla con
+// 400 ante lo que no se puede interpretar; `limit` se acota como siempre (nunca fue un 400).
+export const FILTROS = ['q', 'tag', 'lang', 'capability', 'accepts', 'house', 'price_max', 'min_score', 'limit', 'cursor'];
+export function validarFiltros(p = {}) {
+  const vacio = (v) => v == null || v === '';
+  if (!vacio(p.offset)) throw fallo(400, 'offset is not supported: page with cursor (next_cursor of the previous page)');
+  const f = {};
+  for (const k of ['q', 'capability', 'accepts', 'house']) {
+    if (vacio(p[k])) continue;
+    if (typeof p[k] !== 'string' || p[k].length > 200) throw fallo(400, `${k} must be a string of up to 200 characters`);
+    if (k === 'capability' && !/^[a-z0-9_-]{1,64}$/.test(p[k])) throw fallo(400, 'capability must be 1-64 lowercase letters, digits, dashes or underscores');
+    f[k] = k === 'house' ? p[k].toLowerCase() : p[k];
+  }
+  if (!vacio(p.tag)) {
+    if (typeof p.tag !== 'string' || !/^[a-z0-9-]{1,32}$/.test(p.tag)) throw fallo(400, 'tag must be 1-32 lowercase letters, digits and dashes');
+    f.tag = p.tag;
+  }
+  if (!vacio(p.lang)) {
+    const l = String(p.lang).toLowerCase();
+    if (!/^[a-z]{2,3}(-[a-z0-9]{2,8})*$/.test(l)) throw fallo(400, 'lang must be a language tag like "es" or "en-US"');
+    f.lang = l;
+  }
+  if (!vacio(p.price_max)) {
+    const n = Number(p.price_max);
+    if (!Number.isInteger(n) || n < 0) throw fallo(400, 'price_max must be a non-negative integer (tokens)');
+    f.price_max = n;
+  }
+  if (!vacio(p.min_score)) {
+    const n = Number(p.min_score);
+    if (!Number.isFinite(n) || n < 0 || n > 1) throw fallo(400, 'min_score must be a number between 0 and 1');
+    f.min_score = n;
+  }
+  const lim = Number(p.limit);
+  f.limit = Number.isInteger(lim) && lim > 0 ? Math.min(lim, 200) : 50;
+  if (!vacio(p.cursor)) f.cursor = decodificarCursor(p.cursor);
+  return f;
+}
+
+// ---------- filas: historial de puntajes ----------
+export const HIST_MAX = 16;
+// La fila nueva de una tarjeta al reemplazar la casa en la generación `gen`, dada la fila previa
+// de esa dirección (o null si es nueva). Sólo se anota un cambio cuando el puntaje cambia.
+export function filaDeIndice(house, card, gen, previa) {
+  const col = columnasDeIndice(card);
+  const hist = Array.isArray(previa?.hist) ? previa.hist.slice() : [];
+  if (!hist.length || (hist[hist.length - 1].s ?? null) !== col.score) hist.push({ g: gen, s: col.score });
+  return { house, address: card.address, doc: card, ...col, gen, first_gen: previa?.first_gen ?? gen, hist: hist.slice(-HIST_MAX) };
+}
+// Puntaje congelado de una fila para un recorrido que empezó en g. `undefined` = caduco.
+export function claveCongelada(r, g) {
+  if ((r.first_gen ?? 0) > g) return null;
+  const e = (r.hist || []).filter((x) => x.g <= g).at(-1);
+  if (!e) return undefined;
+  return e.s ?? null;
+}
+
+// ---------- la búsqueda, en memoria (FileStore y referencia para D1) ----------
+// `filas`: [{ house, address, doc, tags, langs, price_min, score, jobs_done, gen, first_gen, hist }]
+export function buscarEnMemoria(filas, f) {
+  const gActual = filas.reduce((m, r) => Math.max(m, r.gen || 0), 0);
+  if (f.cursor && f.cursor.g > gActual) throw fallo(400, 'invalid cursor: it names a generation of the index that does not exist');
+  const g = f.cursor ? f.cursor.g : gActual;
+  let sel = filas.filter((r) => filtraFila(r, f)).map((r) => ({ r, k: claveCongelada(r, g) }));
+  if (sel.some((x) => x.k === undefined)) throw fallo(410, CADUCO);
+  if (f.min_score != null) sel = sel.filter((x) => x.k != null && x.k >= f.min_score);
+  const total = sel.length;
+  if (f.cursor) sel = sel.filter((x) => despuesDelCursor(x.k, x.r.address, f.cursor));
+  sel.sort((x, y) => compararFilas(x.k, x.r.address, y.k, y.r.address));
+  const pagina = sel.slice(0, f.limit);
+  const ultima = pagina[pagina.length - 1];
+  const next_cursor = sel.length > f.limit ? codificarCursor({ s: ultima.k, a: ultima.r.address, g }) : null;
+  return { total, agents: pagina.map((x) => x.r.doc), next_cursor };
+}
+export const CADUCO = 'cursor expired: the scores this walk was ordered by are no longer kept by the index; start again without cursor';
+
+export function filtraFila(r, f) {
+  const c = r.doc || {};
+  if (f.house && r.house !== f.house) return false;
+  if (f.capability && !c.capabilities?.[f.capability]) return false;
+  if (f.accepts && !c.capabilities?.accepts?.includes(f.accepts)) return false;
+  if (f.tag && !(r.tags || []).includes(f.tag)) return false;
+  if (f.lang && !(r.langs || []).some((l) => l === f.lang || l.startsWith(`${f.lang}-`))) return false;
+  if (f.price_max != null && !(r.price_min != null && r.price_min <= f.price_max)) return false;
+  if (f.q && !JSON.stringify(c).toLowerCase().includes(String(f.q).toLowerCase())) return false;
+  return true;
+}
+
+// Mismo orden que el SQL: puntaje DESC con nulos al final, dirección ASC (comparación binaria).
+export function compararFilas(kx, ax, ky, ay) {
+  if (kx == null && ky == null) return ax < ay ? -1 : ax > ay ? 1 : 0;
+  if (kx == null) return 1;
+  if (ky == null) return -1;
+  if (kx !== ky) return ky - kx;
+  return ax < ay ? -1 : ax > ay ? 1 : 0;
+}
+
+export function despuesDelCursor(k, address, cur) {
+  if (cur.s == null) return k == null && address > cur.a;
+  return (k != null && k < cur.s) || (k === cur.s && address > cur.a) || k == null;
+}

package/src/correo/politica.js

@@ -8,9 +8,135 @@
 
 import { checkPow } from '../nucleo/crypto.js';
 import { parseAddress } from './resolver.js';
+import { PRUEBAS } from '../libro/verifica.js';
+import { CONTRATOS } from '../libro/contratos.js';
 
 export const TYPES = new Set(['message', 'task', 'result', 'receipt', 'intro']);
 
+// Proyecto y rol de un sobre (13-sep-2026): un mismo dueño con varios chats sobre un solo conector
+// distingue «Sigo Main» de «Rosetta Lab» con una extensión firmada dentro del sobre, y el buzón
+// filtra por ella. Va en claro (las extensiones no se cifran): el nombre de un proyecto no es secreto.
+export const EXT_PROYECTO = 'urn:nyx5:ext:proyecto';
+// Revisión del 13-sep-2026: un `project` de 200.000 caracteres o un `role` con escapes de terminal
+// 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;
+export const rolDe = (env) => { const r = env?.extensions?.[EXT_PROYECTO]?.role; return typeof r === 'string' ? (limpio(r, 40) || 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,
+// porque una ficha es lo que otros agentes leen antes de contratar, y no puede llevar de todo.
+// Lo declarado NO está verificado (eso es el sello de dueño, otra pieza): es lo que el dueño dice.
+const PERFIL_CLAVES = ['display_name', 'summary', 'description', 'languages', 'tags', 'owner', 'links', 'services'];
+// Fuera: controles C0 y C1, invisibles de ancho cero, y las marcas bidi que voltean el texto en
+// pantalla (un nombre que se lee al revés es una suplantación). Los espacios se colapsan.
+// Los controles pasan a espacio (separaban algo); los invisibles se quitan (no separaban nada, y
+// "sig<ancho cero>o" tiene que quedar "sigo", no "sig o").
+const CONTROLES = /[\x00-\x1f\x7f-\x9f]/g;
+const INVISIBLES = /[\u200b-\u200f\u202a-\u202e\u2060-\u2064\u2066-\u2069\ufeff]/g;
+export const limpio = (s, max) => String(s).replace(INVISIBLES, '').replace(CONTROLES, ' ').replace(/\s+/g, ' ').trim().slice(0, max);
+export function validarPerfil(p) {
+  if (p === null) return { perfil: null };
+  if (typeof p !== 'object' || Array.isArray(p)) return { error: 'profile must be an object' };
+  const ajenas = Object.keys(p).filter((k) => !PERFIL_CLAVES.includes(k));
+  if (ajenas.length) return { error: `profile carries ${ajenas.map((k) => JSON.stringify(k)).join(', ')}, which this house does not publish; it accepts: ${PERFIL_CLAVES.join(', ')}` };
+  const out = {};
+  for (const [k, max] of [['display_name', 80], ['summary', 280], ['description', 2000]]) {
+    if (p[k] == null) continue;
+    if (typeof p[k] !== 'string') return { error: `profile.${k} must be a string` };
+    const v = limpio(p[k], max); if (v) out[k] = v;
+  }
+  if (p.languages != null) {
+    // Tope por etiqueta (35, el máximo razonable de BCP 47): sin él, diez etiquetas de 180 KB
+    // hacían una tarjeta de 1,8 MB firmada por la casa (revisión del 13-sep-2026).
+    if (!Array.isArray(p.languages) || p.languages.length > 10 || !p.languages.every((l) => typeof l === 'string' && l.length <= 35 && /^[a-z]{2,3}(-[A-Za-z0-9]{2,8})*$/.test(l))) return { error: 'profile.languages must be up to 10 language tags like "es", "en-US"' };
+    out.languages = [...new Set(p.languages)];
+  }
+  if (p.tags != null) {
+    if (!Array.isArray(p.tags) || p.tags.length > 20 || !p.tags.every((t) => typeof t === 'string' && /^[a-z0-9-]{1,32}$/.test(t))) return { error: 'profile.tags must be up to 20 tags of lowercase letters, digits and dashes' };
+    out.tags = [...new Set(p.tags)];
+  }
+  if (p.owner != null) {
+    const o = p.owner;
+    if (typeof o !== 'object' || Array.isArray(o) || !['person', 'org'].includes(o.kind) || typeof o.name !== 'string' || Object.keys(o).some((k) => !['kind', 'name'].includes(k))) return { error: 'profile.owner must be { kind: person|org, name }' };
+    out.owner = { kind: o.kind, name: limpio(o.name, 120) };
+  }
+  if (p.links != null) {
+    if (!Array.isArray(p.links) || p.links.length > 5) return { error: 'profile.links must be up to 5 https URLs' };
+    // Sin usuario ni clave en la URL: `https://nyx5.com@evil.example/` se lee como nyx5.com y va a evil.
+    for (const l of p.links) { let u; try { u = new URL(String(l)); } catch { u = null; } if (!u || u.protocol !== 'https:' || u.username || u.password || String(l).length > 200) return { error: `profile.links: not a plain https URL: ${String(l).slice(0, 60)}` }; }
+    out.links = [...new Set(p.links.map(String))];
+  }
+  if (p.services != null) {
+    if (!Array.isArray(p.services) || p.services.length > SERVICIOS_MAX) return { error: `profile.services must be a list of up to ${SERVICIOS_MAX} services` };
+    const ids = new Set(), lista = [];
+    for (const s of p.services) {
+      const v = validarServicio(s);
+      if (v.error) return { error: v.error };
+      if (ids.has(v.servicio.id)) return { error: `profile.services: the id "${v.servicio.id}" appears twice` };
+      ids.add(v.servicio.id); lista.push(v.servicio);
+    }
+    if (lista.length) out.services = lista;
+  }
+  return { perfil: out };
+}
+
+// Catálogo de servicios en la ficha (NX-301): lo que el agente vende, con precio y contrato
+// publicados. Una cotización que nombre un `service` se compara contra ESTO al aceptar
+// (`Libro.verifyQuote`): el precio y el contrato de la cotización tienen que ser los publicados,
+// igual que una tarea sembrada se cotiza con los términos del catálogo tal cual.
+// Vocabulario cerrado por servicio, como el resto de la ficha. `acceptance.kind` sólo puede ser una
+// prueba que verifica@ sabe correr (la lista es la de verifica.js, importada, no copiada) y
+// `contract` sólo un tipo cotizable (la lista es la de contratos.js). `template` es texto para
+// quien va a cotizar: no es la prueba concreta, ésa va en `terms.verify` de cada cotización.
+// `price.usd` es un decimal en texto (no flotante) y SÓLO tiene sentido si la tarjeta declara
+// billetera: eso lo comprueba `usdSinBilletera` en la ruta, porque este validador no ve la tarjeta.
+const SERVICIOS_MAX = 20;
+const SERVICIO_CLAVES = ['id', 'name', 'summary', 'price', 'unit', 'contract', 'acceptance'];
+const UNIDADES = ['job', 'call', 'hour'];
+const contratosCotizables = () => Object.keys(CONTRATOS).filter((k) => CONTRATOS[k]?.quoteable);
+export function validarServicio(s) {
+  if (typeof s !== 'object' || s === null || Array.isArray(s)) return { error: 'profile.services: each service must be an object' };
+  const ajenas = Object.keys(s).filter((k) => !SERVICIO_CLAVES.includes(k));
+  if (ajenas.length) return { error: `profile.services carries ${ajenas.map((k) => JSON.stringify(k)).join(', ')}, which this house does not publish; a service accepts: ${SERVICIO_CLAVES.join(', ')}` };
+  if (typeof s.id !== 'string' || !/^[a-z0-9-]{1,40}$/.test(s.id)) return { error: 'profile.services[].id must be 1-40 lowercase letters, digits and dashes' };
+  const donde = `profile.services[${s.id}]`;
+  if (typeof s.name !== 'string' || !limpio(s.name, 80)) return { error: `${donde}.name must be a non-empty string` };
+  const out = { id: s.id, name: limpio(s.name, 80) };
+  if (s.summary != null) { if (typeof s.summary !== 'string') return { error: `${donde}.summary must be a string` }; const v = limpio(s.summary, 280); if (v) out.summary = v; }
+  const pr = s.price;
+  if (typeof pr !== 'object' || pr === null || Array.isArray(pr) || Object.keys(pr).some((k) => !['tokens', 'usd'].includes(k))) return { error: `${donde}.price must be { tokens, usd? }` };
+  if (!Number.isInteger(pr.tokens) || pr.tokens <= 0) return { error: `${donde}.price.tokens must be a positive integer` };
+  out.price = { tokens: pr.tokens };
+  if (pr.usd != null) {
+    // Decimal en texto con hasta 6 decimales (los de USDC), mayor que cero. Nunca un número: 0.1+0.2.
+    if (typeof pr.usd !== 'string' || !/^\d{1,9}(\.\d{1,6})?$/.test(pr.usd) || Number(pr.usd) <= 0) return { error: `${donde}.price.usd must be a positive decimal string like "1.50"` };
+    out.price.usd = pr.usd;
+  }
+  if (!UNIDADES.includes(s.unit)) return { error: `${donde}.unit must be one of ${UNIDADES.join(', ')}` };
+  out.unit = s.unit;
+  const cotizables = contratosCotizables();
+  if (!cotizables.includes(s.contract)) return { error: `${donde}.contract must be one of ${cotizables.join(', ')}` };
+  out.contract = s.contract;
+  if (s.acceptance != null) {
+    const a = s.acceptance;
+    if (typeof a !== 'object' || a === null || Array.isArray(a) || Object.keys(a).some((k) => !['kind', 'template'].includes(k))) return { error: `${donde}.acceptance must be { kind, template }` };
+    if (!PRUEBAS.includes(a.kind)) return { error: `${donde}.acceptance.kind must be a test verifica@ can run: ${PRUEBAS.join(', ')}` };
+    if (typeof a.template !== 'string' || !limpio(a.template, 280)) return { error: `${donde}.acceptance.template must be a non-empty string` };
+    out.acceptance = { kind: a.kind, template: limpio(a.template, 280) };
+  }
+  return { servicio: out };
+}
+// Un precio en dólares sólo se publica si hay a dónde cobrarlo. La comprobación vive aparte de
+// validarPerfil porque la billetera está en la tarjeta, no en la ficha. Devuelve el error o null.
+export function usdSinBilletera(perfil, wallets) {
+  const con = (perfil?.services || []).filter((s) => s.price?.usd != null);
+  if (!con.length || (Array.isArray(wallets) && wallets.length)) return null;
+  return `service "${con[0].id}" declares a usd price but the card has no wallet; declare wallets first`;
+}
+
 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');
@@ -43,6 +169,41 @@ export function validateEnvelope(env, { maxBytes = 1_048_576 } = {}) {
   return { ok: true };
 }
 
+// ---------- la puerta del correo ----------
+// Un correo entra al buzón SIN firma y sin cuenta en el Libro. Durante un tiempo entró además sin
+// pasar por ninguna política: un buzón que cobraba 500 y otro con lista blanca cerrada aceptaban
+// los dos un correo de cualquier desconocido, gratis. O sea que la estampilla, la lista y la
+// prueba de trabajo defendían una puerta mientras la de al lado quedaba abierta, y el precio que
+// la casa anuncia por x402 era evitable escribiendo un correo.
+//
+// Esta función es esa puerta. Falla CERRADO: si la política del buzón no se puede expresar sobre
+// correo, no se deja pasar. Un mecanismo que no existe en este canal no es un permiso.
+//
+// Se compara contra el remitente REAL del correo, no contra `email@<casa>`, que es la pasarela y
+// sería la misma para todo el mundo.
+export function applyEmailPolicy(agentRecord, emailFrom) {
+  const inbox = agentRecord.inbox || { policy: 'open' };
+  const dominio = String(emailFrom).slice(String(emailFrom).lastIndexOf('@') + 1).toLowerCase();
+  const de = String(emailFrom).toLowerCase();
+  switch (inbox.policy) {
+    case undefined:
+    case 'open':
+      return { ok: true };
+    case 'allowlist': {
+      const ok = inbox.allowlist?.some((x) => String(x).toLowerCase() === de || String(x).toLowerCase() === dominio);
+      // El "intro" y el aval del canal firmado NO tienen equivalente aquí: uno se apoya en el tipo
+      // de sobre y el otro en una fianza del Libro, y un correo no trae ninguno de los dos.
+      return ok ? { ok: true } : { ok: false, code: 403, reason: 'this mailbox only accepts listed senders' };
+    }
+    case 'pow':
+      return { ok: false, code: 403, reason: `this mailbox requires proof-of-work, which an email cannot carry; write to ${agentRecord.address} with the protocol instead` };
+    case 'stamp':
+      return { ok: false, code: 402, reason: `this mailbox charges ${inbox.price ?? 1} tok for delivery, and an email carries no payment; join the house and send a signed envelope with a stamp` };
+    default:
+      return { ok: false, code: 403, reason: `unknown mailbox policy (${inbox.policy})` };
+  }
+}
+
 // Limitador de tasa por clave (dominio emisor), ventana deslizante simple.
 export class RateLimiter {
   constructor({ perMinute = 120 } = {}) { this.perMinute = perMinute; this.hits = new Map(); }
@@ -52,6 +213,34 @@ export class RateLimiter {
     if (arr.length >= this.perMinute) { this.hits.set(key, arr); return false; }
     arr.push(now); this.hits.set(key, arr); return true;
   }
+  retryAfter() { return 60; }
+}
+
+// Límite de tasa DURABLE (13-sep-2026, NX-901): el contador vive en el almacén, no en la memoria del
+// proceso. En el edge cada isolate contaba por su lado, así que el límite real era N veces el
+// declarado y nadie sabía cuánto era N. Ventana fija de un minuto por clave: una fila por clave y
+// minuto, que vence sola dos minutos después. La misma interfaz que el de memoria (`allow` se
+// espera con await en los dos: en el de memoria el await no cuesta nada).
+// Si el almacén falla, DEJA PASAR y lo anota: un límite de tasa caído no puede tumbar el correo de
+// todos. Precisión sobre cobertura: retener trabajo bueno es peor que dejar pasar un minuto.
+export class RateLimiterDurable {
+  constructor({ store, perMinute = 120, ns = 'tasa', log = () => {} } = {}) {
+    if (!store?.kvIncrement) throw new Error('RateLimiterDurable needs a store with kvIncrement');
+    this.store = store; this.perMinute = perMinute; this.ns = ns; this.log = log;
+    this.cerradas = new Map(); // clave -> ventana ya agotada, por proceso: un flood no escribe una fila por golpe
+  }
+  static ventana(nowMs = Date.now()) { return Math.floor(nowMs / 60_000); }
+  async allow(key, nowMs = Date.now()) {
+    const v = RateLimiterDurable.ventana(nowMs);
+    if (this.cerradas.get(key) === v) return false;
+    try {
+      const n = await this.store.kvIncrement(this.ns, `${key}:${v}`, (v + 2) * 60_000, nowMs);
+      if (n > this.perMinute) { if (this.cerradas.size > 10_000) this.cerradas.clear(); this.cerradas.set(key, v); return false; }
+      return true;
+    } catch (e) { this.log(`tasa: el almacén no contó (${e.message}); se deja pasar`); return true; }
+  }
+  // Segundos hasta que abra la ventana siguiente: es lo que va en Retry-After.
+  retryAfter(nowMs = Date.now()) { return Math.max(1, 60 - Math.floor((nowMs % 60_000) / 1000)); }
 }
 
 // Política del agente destino sobre un sobre ya verificado criptográficamente.

package/src/correo/resolver.js

@@ -27,7 +27,10 @@ export function parseTxtRecord(txt) {
 }
 
 export class Resolver {
-  constructor({ hosts = {}, fetchImpl = globalThis.fetch, cacheTtlMs = 5 * 60 * 1000, pins = {}, timeoutMs = 5000, onPin = null, self = null } = {}) {
+  constructor({ hosts = {}, fetchImpl = globalThis.fetch, cacheTtlMs = 5 * 60 * 1000, pins = {}, timeoutMs = 5000, onPin = null, self = null, auth = null } = {}) {
+    // auth = { domain, header(method, path) }: un CLIENTE (Agent) firma la petición a su propia casa
+    // cuando una tarjeta no aparece sin autenticar; así un contacto resuelve a un agente secreto.
+    this.auth = auth;
     this.hosts = { ...hosts };          // { "beta.local": { url: "http://localhost:4002", sig?: "<pub>" } }
     this.fetch = (...a) => fetchImpl(...a); // envuelto: workerd exige fetch con this=globalThis
     this.cacheTtlMs = cacheTtlMs;
@@ -42,7 +45,8 @@ export class Resolver {
   }
 
   setHost(domain, entry) { this.hosts[domain] = entry; this.cache.clear(); }
-  invalidate(key) { if (key) this.cache.delete(key); else this.cache.clear(); }
+  // Invalidar `agent:x@casa` borra también lo recordado «para» alguien de esa misma tarjeta.
+  invalidate(key) { if (!key) { this.cache.clear(); return; } for (const k of this.cache.keys()) if (k === key || k.startsWith(`${key}|for:`)) this.cache.delete(k); }
 
   _cached(key) {
     const hit = this.cache.get(key);
@@ -51,8 +55,8 @@ export class Resolver {
   }
   _remember(key, value) { this.cache.set(key, { value, until: Date.now() + this.cacheTtlMs }); }
 
-  async _get(url) {
-    const res = await this.fetch(url, { signal: AbortSignal.timeout(this.timeoutMs) });
+  async _get(url, headers = {}) {
+    const res = await this.fetch(url, { headers, signal: AbortSignal.timeout(this.timeoutMs) });
     if (!res.ok) throw Object.assign(new Error(`GET ${url} -> ${res.status}`), { permanent: res.status === 404 || res.status === 410 });
     return res.json();
   }
@@ -111,7 +115,10 @@ export class Resolver {
   }
 
   // Tarjeta del agente, certificada por la clave del dominio.
-  async agentCard(address) {
+  // `onBehalfOf` (NX-202): para quién se pide. Un agente SECRETO sólo se sirve a quien está en su
+  // lista, así que la casa que pregunta firma «lo pido para bob@mi-casa» con su llave de dominio, y
+  // un cliente firma con la suya ante su propia casa. Sin eso, un secreto se ve como inexistente.
+  async agentCard(address, { onBehalfOf = null } = {}) {
     const { local, domain } = parseAddress(address);
     // La propia casa sirve la tarjeta sin red, pero pasa por la MISMA verificación que una ajena:
     // venir de casa no la exime de estar certificada por el dominio y firmada por su padre.
@@ -122,13 +129,29 @@ export class Resolver {
       return this._verifyAgentCard(card, dc, address, local, domain);
     }
     const key = `agent:${local}@${domain}`;
-    const cached = this._cached(key);
+    // Una tarjeta secreta se recuerda SÓLO para quien la pidió: servida a otro, sería una fuga.
+    const keyPara = onBehalfOf ? `${key}|for:${String(onBehalfOf).toLowerCase()}` : null;
+    const cached = this._cached(key) || (keyPara && this._cached(keyPara));
     if (cached) return cached;
 
     const dc = await this.domainCard(domain);
-    const card = await this._get(`${dc._estafeta}/agents/${encodeURIComponent(local)}`);
+    const url = `${dc._estafeta}/agents/${encodeURIComponent(local)}`;
+    const headers = {};
+    let paraDom = null; try { paraDom = onBehalfOf ? parseAddress(onBehalfOf).domain : null; } catch { paraDom = null; }
+    if (onBehalfOf && this.self?.firmarPara && paraDom === this.self.domain) headers['x-nyx5-for'] = this.self.firmarPara(String(onBehalfOf).toLowerCase(), domain);
+    let card;
+    try { card = await this._get(url, headers); }
+    catch (e) {
+      // Un cliente que no la ve sin autenticar la vuelve a pedir firmando: a su propia casa si el
+      // agente es de ahí; si es de otra casa, le pide a la suya que resuelva «para» él (la casa
+      // firma con su llave de dominio y la otra decide). La tarjeta se verifica igual al llegar.
+      if (!(e.permanent && this.auth)) throw e;
+      if (domain === this.auth.domain) card = await this._get(url, { authorization: this.auth.header('GET', `/agents/${encodeURIComponent(local)}`) });
+      else if (this.auth.url) { const p = `/resolve/${encodeURIComponent(`${local}@${domain}`)}`; const { presence: _p, ...c } = await this._get(`${this.auth.url}${p}`, { authorization: this.auth.header('GET', p) }); card = c; }
+      else throw e;
+    }
     const value = await this._verifyAgentCard(card, dc, address, local, domain);
-    this._remember(key, value);
+    this._remember(value.visibility === 'secret' ? (keyPara || `${key}|for:${this.auth?.domain || 'self'}`) : key, value);
     return value;
   }
 
@@ -161,12 +184,13 @@ export class Resolver {
 
   // Igual que agentCard, pero si el sobre viene firmado con una clave que la tarjeta en caché no
   // reconoce (rotación reciente), refresca la tarjeta una vez antes de rechazar.
-  async agentCardForKid(address, kid) {
-    let card = await this.agentCard(address);
+  async agentCardForKid(address, kid, opts = {}) {
+    let card = await this.agentCard(address, opts);
     if (!Resolver.acceptedKids(card).includes(kid)) {
       const { local, domain } = parseAddress(address);
       this.invalidate(`agent:${local}@${domain}`);
-      card = await this.agentCard(address);
+      if (opts.onBehalfOf) this.invalidate(`agent:${local}@${domain}|for:${String(opts.onBehalfOf).toLowerCase()}`);
+      card = await this.agentCard(address, opts);
     }
     return card;
   }