@nyx5/nyx5 0.1.0

package/demo/contratos.js

@@ -0,0 +1,117 @@
+// Demo del Libro: una casa (alfa.local) con su ledger, y agentes que cotizan, aceptan, entregan,
+// afianzan, delegan y pagan estampillas. Un agente de otra casa (beta.local) también participa:
+// su identidad viene verificada por el Correo, así que puede tener cuenta aquí sin login.
+//
+//   node demo/contratos.js
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { Estafeta } from '../src/correo/estafeta.js';
+import { Agent } from '../src/correo/agente.js';
+import { sha256hex } from '../src/nucleo/crypto.js';
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'chasqui-libro-'));
+const hosts = { 'alfa.local': { url: 'http://127.0.0.1:4001' }, 'beta.local': { url: 'http://127.0.0.1:4002' } };
+const mk = (domain, port, token, libro) => new Estafeta({ domain, port, dataDir: path.join(tmp, domain), adminToken: token, hosts, workerIntervalMs: 200, libro, log: () => {} });
+const step = (n, t) => console.log(`\n[${n}] ${t}`);
+const H = 'alfa.local';
+
+const alfa = await mk('alfa.local', 4001, 'a', { feePct: 0.10, welcome: 100 }).start();
+const beta = await mk('beta.local', 4002, 'b').start();
+const nicolas = Agent.create('nicolas@alfa.local', 'http://127.0.0.1:4001', { hosts });
+const verifica = Agent.create('verifica@alfa.local', 'http://127.0.0.1:4001', { hosts });
+const constructor = Agent.create('constructor@alfa.local', 'http://127.0.0.1:4001', { hosts });
+const foraneo = Agent.create('foraneo@beta.local', 'http://127.0.0.1:4002', { hosts });
+for (const a of [nicolas, verifica, constructor]) await a.register({ adminToken: 'a' });
+await foraneo.register({ adminToken: 'b' });
+const saldos = async () => console.log('    saldos:', Object.entries(await alfa.store.libroState().balances).map(([k, v]) => `${k.replace('@alfa.local', '')}=${v}`).join('  '));
+
+step(1, 'La casa carga saldo a nicolas (1000). Los demás recibieron 100 de bienvenida al registrarse');
+await alfa.libro.topup('nicolas@alfa.local', 1000, 'presupuesto mensual Sigo');
+await saldos();
+
+step(2, 'SPOT: verifica cotiza a nicolas una verificación por 40; nicolas acepta; el asiento se ejecuta con 10 % para la casa');
+const q1 = await verifica.quote({ to: 'nicolas@alfa.local', contract: 'spot', price: 40, concept: 'verificación de despliegue' });
+const m1 = await nicolas.waitFor((e) => e.id === q1.id);
+const cot = (await nicolas.open(m1.envelope)).content.body;
+console.log('    cotización recibida (cifrada en tránsito), firmada por', cot.seller, '->', cot.price, 'tok');
+const acc = await nicolas.accept(cot);
+const r1 = await nicolas.awaitReceipt(acc.id);
+console.log('    recibo de libro@:', r1.receipt.contract.state, '| asiento', r1.receipt.asiento.n, r1.receipt.asiento.lines.map((l) => `${l.account.replace('@alfa.local', '')}:${l.delta}`).join(' '));
+console.log('    el recibo lleva hash de la cotización y de la aceptación:', r1.receipt.cotizacion_sha256.slice(0, 12) + '…', r1.receipt.op_sha256.slice(0, 12) + '…');
+await saldos();
+
+step(3, 'ESCROW: nicolas encarga a constructor por 300 con criterio de aceptación; los tokens quedan retenidos');
+const q2 = await constructor.quote({ to: 'nicolas@alfa.local', contract: 'escrow', price: 300, concept: 'landing Drake Review', terms: { acceptance: 'lighthouse >= 90 en móvil', deadline: '2026-09-15' }, arbiter: 'verifica@alfa.local' });
+const cot2 = (await nicolas.open((await nicolas.waitFor((e) => e.id === q2.id)).envelope)).content.body;
+const acc2 = await nicolas.accept(cot2);
+const r2 = await nicolas.awaitReceipt(acc2.id);
+const contrato = r2.receipt.contract.id;
+console.log('    contrato', contrato.slice(0, 8), 'estado', r2.receipt.contract.state);
+await saldos();
+console.log('    constructor entrega con hash de la evidencia');
+const evidencia = sha256hex('reporte lighthouse: performance 94');
+const del = await constructor.deliver(H, contrato, { evidence_sha256: evidencia, note: 'lighthouse 94 móvil' });
+await constructor.awaitReceipt(del.id);
+console.log('    nicolas libera: constructor recibe 270, la casa 30');
+const rel = await nicolas.release(H, contrato);
+const r3 = await nicolas.awaitReceipt(rel.id);
+console.log('    estado', r3.receipt.contract.state, '| historial:', r3.receipt.contract.history.map((h) => h.op).join(' -> '));
+await saldos();
+
+step(4, 'FIANZA: constructor afirma "desplegado y verificado" y deposita 50; verifica lo derriba y la fianza va a la casa');
+const b = await constructor.bond(H, { amount: 50, claim: 'sigo.uk desplegado y verificado en producción', verifier: 'verifica@alfa.local', evidence_sha256: sha256hex('log de deploy') });
+const rb = await constructor.awaitReceipt(b.id);
+console.log('    fianza', rb.receipt.contract.id.slice(0, 8), 'estado', rb.receipt.contract.state);
+const ff = await verifica.forfeit(H, rb.receipt.contract.id, 'el endpoint /health responde 500');
+const rf = await verifica.awaitReceipt(ff.id);
+console.log('    verifica ejecuta la fianza:', rf.receipt.contract.state, '| razón registrada:', rf.receipt.contract.history.at(-1).reason);
+await saldos();
+
+step(5, 'MANDATO EN CADENA: nicolas da mandato 200 a constructor; constructor sub-delega 80 a un subagente; el subagente cobra y paga nicolas');
+const md = await nicolas.mandate(H, { grantee: 'constructor@alfa.local', cap: 200, scope: { concepts: ['tokens de modelo', 'hosting'] } });
+const mandato = (await nicolas.awaitReceipt(md.id)).receipt.mandate;
+console.log('    mandato raíz', mandato.id.slice(0, 8), 'cap', mandato.cap);
+const tester = await constructor.delegate('tester', { scope: { types: ['message', 'task', 'result', 'receipt'], cap: 100 } });
+console.log('    subagente delegado:', tester.address, '| tarjeta certificada por el dominio y firmada por constructor');
+const sub = await constructor.mandate(H, { grantee: tester.address, cap: 80, parent: mandato.id });
+const submandato = (await constructor.awaitReceipt(sub.id)).receipt.mandate;
+console.log('    sub-mandato', submandato.id.slice(0, 8), 'cap', submandato.cap, 'cadena', submandato.chain.map((x) => x.slice(0, 8)).join(' > '));
+const ch = await tester.charge(H, { mandate: submandato.id, amount: 30, concept: 'tokens de modelo' });
+const rc = await tester.awaitReceipt(ch.id);
+console.log('    cobro de 30: paga', rc.receipt.asiento.lines[0].account, '| cadena descontada:', rc.receipt.chain.map((x) => `${x.spent}/${x.cap}`).join(', '));
+const over = await tester.charge(H, { mandate: submandato.id, amount: 70, concept: 'tokens de modelo' });
+const bounce = await tester.waitFor((e) => e.type === 'receipt' && e.from === 'postmaster@alfa.local' && e.in_reply_to === over.id);
+console.log('    cobro de 70 (supera lo que queda):', (await tester.open(bounce.envelope)).content.body.reason);
+await saldos();
+
+step(6, 'AGENTE DELEGADO CON ÁMBITO: tester solo puede enviar ciertos tipos y aceptar hasta 100');
+try { await tester.send({ to: 'nicolas@alfa.local', type: 'intro', body: 'hola' }); } catch (e) { console.log('    intro bloqueado por la estafeta:', e.message); }
+const q3 = await verifica.quote({ to: tester.address, contract: 'spot', price: 150, concept: 'auditoría' });
+const cot3 = (await tester.open((await tester.waitFor((e) => e.id === q3.id)).envelope)).content.body;
+const acc3 = await tester.accept(cot3);
+const b3 = await tester.waitFor((e) => e.type === 'receipt' && e.from === 'postmaster@alfa.local' && e.in_reply_to === acc3.id);
+console.log('    aceptar 150 con tope 100:', (await tester.open(b3.envelope)).content.body.reason);
+
+step(7, 'ESTAMPILLA: caro@ cobra 5 tok por escribirle; un agente de otra casa paga desde su cuenta aquí; uno sin saldo rebota');
+const caro = Agent.create('caro@alfa.local', 'http://127.0.0.1:4001', { hosts });
+await caro.register({ adminToken: 'a', inbox: { policy: 'stamp', price: 5 } });
+await alfa.libro.topup('foraneo@beta.local', 20, 'cuenta de un agente de otra casa');
+const st = await foraneo.send({ to: 'caro@alfa.local', body: 'hola desde beta, con estampilla' });
+const got = await caro.waitFor((e) => e.id === st.id);
+console.log('    llegó con estampilla, asiento', got.stamp.slice(0, 8), '| stamp en el sobre:', JSON.stringify(st.envelope.stamp));
+const pobre = Agent.create('pobre@beta.local', 'http://127.0.0.1:4002', { hosts });
+await pobre.register({ adminToken: 'b' });
+const st2 = await pobre.send({ to: 'caro@alfa.local', body: 'sin saldo' });
+const b4 = await pobre.waitFor((e) => e.type === 'receipt' && e.in_reply_to === st2.id);
+console.log('    sin saldo:', (await pobre.open(b4.envelope)).content.body.reason);
+await saldos();
+
+step(8, 'El diario: cada asiento firmado por la casa, con referencias a los sobres que lo causaron');
+for (const a of await alfa.libro.journal()) console.log(`    #${a.n} ${a.concept.slice(0, 48).padEnd(48)} ${a.lines.map((l) => `${l.account.replace('@alfa.local', '').replace('@beta.local', '@beta')}:${l.delta > 0 ? '+' : ''}${l.delta}`).join(' ')}`);
+const total = Object.values(await alfa.store.libroState().balances).reduce((s, v) => s + v, 0);
+console.log('    suma de todos los saldos (debe ser 0):', total);
+
+await alfa.stop(); await beta.stop();
+console.log(`\nListo. Datos en ${tmp}/alfa.local/libro`);

package/demo/e2e.js

@@ -0,0 +1,57 @@
+// Demo end-to-end: dos dominios (alfa.local y beta.local), cada uno con su estafeta,
+// un agente en cada uno, un envío cifrado y firmado, y la respuesta de vuelta.
+//
+//   node demo/e2e.js
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { Estafeta } from '../src/correo/estafeta.js';
+import { Agent } from '../src/correo/agente.js';
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'chasqui-'));
+const hosts = { 'alfa.local': { url: 'http://127.0.0.1:4001' }, 'beta.local': { url: 'http://127.0.0.1:4002' } };
+const step = (n, t) => console.log(`\n[${n}] ${t}`);
+
+step(1, 'Levantando las estafetas de alfa.local (4001) y beta.local (4002)');
+const alfa = await new Estafeta({ domain: 'alfa.local', port: 4001, dataDir: path.join(tmp, 'alfa'), adminToken: 'admin-alfa', hosts, workerIntervalMs: 300, log: () => {} }).start();
+const beta = await new Estafeta({ domain: 'beta.local', port: 4002, dataDir: path.join(tmp, 'beta'), adminToken: 'admin-beta', hosts, workerIntervalMs: 300, log: () => {} }).start();
+console.log('    clave pública de alfa.local:', alfa.keys.sig.slice(0, 16) + '…');
+console.log('    clave pública de beta.local:', beta.keys.sig.slice(0, 16) + '…');
+
+step(2, 'Registrando nicolas@alfa.local y asistente@beta.local (cada uno genera sus claves, el dominio las certifica)');
+const nicolas = Agent.create('nicolas@alfa.local', 'http://127.0.0.1:4001', { hosts });
+const asistente = Agent.create('asistente@beta.local', 'http://127.0.0.1:4002', { hosts });
+await nicolas.register({ adminToken: 'admin-alfa' });
+await asistente.register({ adminToken: 'admin-beta', capabilities: { accepts: ['application/json'], mcp: 'http://127.0.0.1:4010/mcp' } });
+console.log('    tarjeta de asistente certificada por', (await nicolas.resolver.agentCard('asistente@beta.local')).certification.kid.slice(0, 16) + '…');
+
+step(3, 'nicolas envía una tarea cifrada extremo a extremo a asistente');
+const sent = await nicolas.send({ to: 'asistente@beta.local', type: 'task', body: { skill: 'resumir', input: 'Resume en una frase qué es Nyx5.' }, receipt: 'delivered' });
+console.log('    id del sobre:', sent.id);
+console.log('    el sobre viaja cifrado; la estafeta ve esto:', JSON.stringify(sent.envelope.encrypted).slice(0, 80) + '…');
+
+step(4, 'La estafeta de beta verifica la cadena dominio -> agente -> sobre, aplica política y guarda en el buzón');
+const recibido = await asistente.waitFor((e) => e.id === sent.id);
+console.log('    en buzón. from_verified =', recibido.from_verified, '| relay_verified =', recibido.relay_verified);
+
+step(5, 'asistente abre el sobre (verifica firma y descifra), procesa, confirma (ack) y responde');
+const abierto = await asistente.open(recibido.envelope);
+console.log('    contenido descifrado:', JSON.stringify(abierto.content.body));
+await asistente.ack(abierto.id);
+const respuesta = await asistente.reply(recibido.envelope, { output: 'Nyx5 es el correo de los agentes: direcciones agente@dominio, buzón, firma y cifrado.' });
+console.log('    respuesta enviada:', respuesta.id, '(mismo thread:', respuesta.envelope.thread === sent.id, ')');
+
+step(6, 'nicolas recibe la respuesta y el acuse de entrega del postmaster');
+const resp = await nicolas.waitFor((e) => e.id === respuesta.id);
+const abiertaResp = await nicolas.open(resp.envelope);
+console.log('    resultado:', abiertaResp.content.body.output);
+const acuse = await nicolas.waitFor((e) => e.type === 'receipt' && e.from === 'postmaster@alfa.local');
+console.log('    acuse postmaster:', JSON.stringify((await nicolas.open(acuse.envelope)).content.body));
+await nicolas.ack([resp.envelope.id, acuse.envelope.id]);
+
+step(7, 'Estado de la bandeja de salida de nicolas');
+for (const s of await nicolas.outbox()) console.log(`    ${s.id.slice(0, 8)} -> ${s.to.join(',')} : ${s.status} (${s.attempts} intento/s)`);
+
+console.log(`\nListo. Datos en ${tmp} (revisa mailbox/, archive/, outbox/, queue/ de cada dominio).`);
+await alfa.stop(); await beta.stop();

package/demo/offline.js

@@ -0,0 +1,46 @@
+// Demo store-and-forward: el destino está apagado cuando se envía; la estafeta emisora guarda,
+// reintenta con backoff y entrega cuando el destino vuelve. Nada se pierde.
+//
+//   node demo/offline.js
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { Estafeta } from '../src/correo/estafeta.js';
+import { Agent } from '../src/correo/agente.js';
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'chasqui-off-'));
+const hosts = { 'alfa.local': { url: 'http://127.0.0.1:4001' }, 'beta.local': { url: 'http://127.0.0.1:4002' } };
+const mk = (domain, port, token) => new Estafeta({ domain, port, dataDir: path.join(tmp, domain), adminToken: token, hosts, workerIntervalMs: 300, retry: { baseMs: 300, maxMs: 1500 }, log: () => {} });
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const step = (n, t) => console.log(`\n[${n}] ${t}`);
+
+step(1, 'Levantando ambas estafetas y registrando agentes');
+const alfa = await mk('alfa.local', 4001, 'a').start();
+let beta = await mk('beta.local', 4002, 'b').start();
+const nicolas = Agent.create('nicolas@alfa.local', 'http://127.0.0.1:4001', { hosts });
+const asistente = Agent.create('asistente@beta.local', 'http://127.0.0.1:4002', { hosts });
+await nicolas.register({ adminToken: 'a' });
+await asistente.register({ adminToken: 'b' });
+await nicolas.resolver.agentCard('asistente@beta.local'); // tarjeta en caché, como pasaría en uso normal
+
+step(2, 'Apagando la estafeta de beta.local');
+await beta.stop();
+
+step(3, 'nicolas envía igual: su estafeta acepta el sobre y lo encola');
+const sent = await nicolas.send({ to: 'asistente@beta.local', body: 'Hola, te escribo mientras estás apagado.' });
+await sleep(1500);
+for (const s of await nicolas.outbox()) console.log(`    ${s.id.slice(0, 8)} : ${s.status}, ${s.attempts} intento/s, próximo ${s.next_attempt.slice(11, 19)}`);
+console.log('    trabajos en cola de alfa:', await alfa.store.listQueue().length);
+
+step(4, 'beta.local vuelve a la vida');
+beta = await mk('beta.local', 4002, 'b').start();
+
+step(5, 'La estafeta de alfa reintenta y entrega');
+const m = await asistente.waitFor((e) => e.id === sent.id, { timeoutMs: 15_000 });
+console.log('    recibido en beta:', (await asistente.open(m.envelope)).content.body);
+for (const s of await nicolas.outbox()) console.log(`    ${s.id.slice(0, 8)} : ${s.status}, ${s.attempts} intento/s`);
+console.log('    trabajos en cola de alfa:', await alfa.store.listQueue().length);
+
+await alfa.stop(); await beta.stop();
+console.log('\nListo.');

package/demo/piloto-d4.mjs

@@ -0,0 +1,146 @@
+// D4 — Piloto con la flota propia.
+//
+// Una casa, un coordinador con presupuesto (topup por frente), trabajo delegado como escrow,
+// un verificador que cobra por uso (metered), y un REPORTE DE COSTO POR ENTREGA leído del
+// diario del Libro —no de la aritmética de este script—: el ledger es el terreno.
+//
+//   node demo/piloto-d4.mjs              # local, rápido y determinista (por defecto)
+//
+// Cada "frente" es una entrega: el coordinador delega una tarea al worker con un escrow
+// (los fondos quedan retenidos hasta la entrega), el verificador la revisa cobrando metered,
+// y recién ahí el coordinador libera el escrow. El costo de la entrega para el coordinador es
+// lo que sus asientos muestran que salió de su cuenta: pago al worker (con fee de la casa) + verificación.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { Estafeta } from '../src/correo/estafeta.js';
+import { Agent } from '../src/correo/agente.js';
+import { sha256hex } from '../src/nucleo/crypto.js';
+
+const DOM = 'pilot.local';
+const URL = 'http://127.0.0.1:4090';
+const hosts = { [DOM]: { url: URL } };
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'chasqui-d4-'));
+
+// La casa: fee 20% (como b.chsq.uk en producción), sin regalo de bienvenida (el presupuesto entra por topup).
+const casa = await new Estafeta({ domain: DOM, port: 4090, dataDir: path.join(tmp, DOM), adminToken: 'p',
+  hosts, workerIntervalMs: 80, libro: { feeBps: 2000, welcome: 0 }, log: () => {} }).start();
+
+const coord = Agent.create(`coordinador@${DOM}`, URL, { hosts });
+const worker = Agent.create(`worker@${DOM}`, URL, { hosts });
+const verif = Agent.create(`verificador@${DOM}`, URL, { hosts });
+for (const a of [coord, worker, verif]) await a.register({ adminToken: 'p' });
+
+const money = (n) => String(n).padStart(6);
+const bal = async (addr) => (await casa.store.libroState()).balances[addr] || 0;
+
+// Los frentes del piloto: cada uno es una entrega con su precio de trabajo y su costo de verificación.
+const FRENTES = [
+  { frente: 'Sigo · edición diaria',      trabajo: 3000, verificacion: 500 },
+  { frente: 'Rosetta · sellado de lote',  trabajo: 5000, verificacion: 800 },
+  { frente: 'Q-Ready · barrido de sitio', trabajo: 2000, verificacion: 400 },
+];
+
+// Presupuesto: la casa carga el total a la cuenta del coordinador (topup por frente, un asiento por frente).
+console.log('\n=== D4 · Piloto con la flota propia (casa pilot.local, fee 20%) ===\n');
+let presupuesto = 0;
+for (const f of FRENTES) {
+  const monto = f.trabajo + f.verificacion;
+  presupuesto += monto;
+  await casa.libro.topup(coord.address, monto, `presupuesto ${f.frente}`);
+}
+console.log(`Presupuesto cargado al coordinador: ${presupuesto} tok (${FRENTES.length} frentes)\n`);
+
+// Una entrega de punta a punta: escrow -> deliver -> verificación metered -> release.
+async function entrega(f) {
+  const salioAntes = await bal(coord.address);
+
+  // 1. El worker cotiza la tarea como escrow; el coordinador acepta -> se retiene el monto.
+  const q = await worker.quote({ to: coord.address, house: DOM, contract: 'escrow', price: f.trabajo,
+    concept: f.frente, terms: { acceptance: 'entrega verificada' } });
+  const qm = await coord.waitFor((e) => e.id === q.id);
+  const cot = (await coord.open(qm.envelope)).content.body;
+  const acc = await coord.accept(cot);
+  const rAcc = await coord.awaitReceipt(acc.id);
+  const contrato = rAcc.receipt.contract.id;
+
+  // 2. El worker declara la entrega con el hash de la evidencia.
+  const evidencia = sha256hex(`entregable de ${f.frente} @ ${new Date().toISOString()}`);
+  const del = await worker.deliver(DOM, contrato, { evidence_sha256: evidencia, note: 'listo para verificar' });
+  await worker.awaitReceipt(del.id);
+
+  // 3. El verificador ofrece su servicio como metered; el coordinador acepta -> mandato de gasto.
+  const qv = await verif.quote({ to: coord.address, house: DOM, contract: 'metered', price: f.verificacion,
+    concept: `verificación · ${f.frente}`, terms: { scope: { concepts: ['verificación'] } } });
+  const qvm = await coord.waitFor((e) => e.id === qv.id);
+  const cotv = (await coord.open(qvm.envelope)).content.body;
+  const accv = await coord.accept(cotv);
+  const rAccv = await coord.awaitReceipt(accv.id);
+  const mandato = rAccv.receipt.contract.mandate;
+
+  // 4. El verificador cobra por la revisión (una pasada); el mandato descuenta del presupuesto.
+  const chg = await verif.charge(DOM, { mandate: mandato, amount: f.verificacion, concept: 'verificación' });
+  await verif.awaitReceipt(chg.id);
+
+  // 5. Verificada, el coordinador libera el escrow: el worker cobra menos el fee de la casa.
+  const rel = await coord.release(DOM, contrato);
+  await coord.awaitReceipt(rel.id);
+
+  const salioDespues = await bal(coord.address);
+  return { ...f, contrato, costoReal: salioAntes - salioDespues };
+}
+
+const filas = [];
+for (const f of FRENTES) { console.log(`→ ejecutando: ${f.frente} …`); filas.push(await entrega(f)); }
+
+// ---- REPORTE DE COSTO POR ENTREGA, derivado del diario (el terreno, no la aritmética del script) ----
+const { balances, journal } = { balances: (await casa.store.libroState()).balances, journal: await casa.libro.journal() };
+const casaAddr = `casa@${DOM}`;
+// Para cada contrato: cuánto recibió el worker (release), cuánto el fee de la casa, cuánto el verificador (charge).
+const porContrato = {};
+for (const fila of filas) porContrato[fila.contrato] = { worker: 0, fee: 0, verif: 0 };
+for (const a of journal) {
+  const c = a.meta?.contract;
+  if (a.meta?.kind === 'release') {
+    if (porContrato[c]) { porContrato[c].fee += a.meta.fee || 0;
+      for (const l of a.lines) if (l.account === worker.address) porContrato[c].worker += l.delta; }
+  }
+}
+// El cobro del verificador va por mandato: lo tomamos de las líneas que suman al verificador con kind charge.
+for (const a of journal) {
+  if (a.meta?.kind === 'charge') {
+    for (const l of a.lines) if (l.account === verif.address) {
+      // atribuir al frente por el concepto del mandato si está, si no, repartir por orden
+      const fila = filas.find((f) => !porContrato[f.contrato]._verifDone);
+      if (fila) { porContrato[fila.contrato].verif += l.delta; porContrato[fila.contrato]._verifDone = true; porContrato[fila.contrato].feeVerif = a.meta.fee || 0; }
+    }
+  }
+}
+
+console.log('\n=== Reporte de costo por entrega (leído del diario) ===\n');
+console.log('FRENTE                        escrow  worker_neto  fee_casa  verif_neto  COSTO/ENTREGA');
+let totCosto = 0, totWorker = 0, totFee = 0, totVerif = 0;
+for (const fila of filas) {
+  const p = porContrato[fila.contrato];
+  const feeTotal = p.fee + (p.feeVerif || 0);
+  console.log(`${fila.frente.padEnd(28)} ${money(fila.trabajo)}  ${money(p.worker)}     ${money(feeTotal)}   ${money(p.verif)}      ${money(fila.costoReal)}`);
+  totCosto += fila.costoReal; totWorker += p.worker; totFee += feeTotal; totVerif += p.verif;
+}
+console.log(''.padEnd(28, '─') + ' ' + '─'.repeat(56));
+console.log(`${'TOTAL'.padEnd(28)} ${' '.repeat(6)}  ${money(totWorker)}     ${money(totFee)}   ${money(totVerif)}      ${money(totCosto)}`);
+
+console.log('\n=== Cierre presupuestario ===');
+console.log(`presupuesto:        ${money(presupuesto)}`);
+console.log(`gastado (entregas): ${money(totCosto)}`);
+console.log(`restante coord:     ${money(await bal(coord.address))}`);
+console.log(`fee recaudado casa: ${money(totFee)}  (sale del medio de cada pago, no se suma al costo)`);
+console.log(`cobró worker:       ${money(balances[worker.address] || 0)}`);
+console.log(`cobró verificador:  ${money(balances[verif.address] || 0)}`);
+// Cuadre de doble entrada: todo lo cargado sigue en el sistema (worker + verif + fee de la casa).
+const cuadre = (balances[worker.address] || 0) + (balances[verif.address] || 0) + totFee;
+console.log(`cuadre:             ${money(cuadre)}  (worker + verificador + fee = presupuesto ${cuadre === presupuesto ? '✓' : '✗'})`);
+console.log('\nCada token movido tiene su asiento firmado por la casa y su cadena de autoridad. El costo');
+console.log('por entrega no es una estimación: es lo que el diario dice que salió de la cuenta del frente.\n');
+
+await casa.stop();

package/demo/spam.js

@@ -0,0 +1,65 @@
+// Demo de la capa de confianza: qué pasa con sobres falsificados, remitentes desconocidos,
+// buzones con allowlist, buzones que exigen proof-of-work y entregas duplicadas.
+//
+//   node demo/spam.js
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { Estafeta } from '../src/correo/estafeta.js';
+import { Agent } from '../src/correo/agente.js';
+import { generateKeys, signObject, uuid } from '../src/nucleo/crypto.js';
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'chasqui-spam-'));
+const hosts = { 'alfa.local': { url: 'http://127.0.0.1:4001' }, 'beta.local': { url: 'http://127.0.0.1:4002' } };
+const mk = (domain, port, token) => new Estafeta({ domain, port, dataDir: path.join(tmp, domain), adminToken: token, hosts, workerIntervalMs: 200, log: () => {} });
+const step = (n, t) => console.log(`\n[${n}] ${t}`);
+const inbound = async (env) => {
+  const res = await fetch('http://127.0.0.1:4002/inbound', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(env) });
+  return { status: res.status, ...(await res.json()) };
+};
+
+const alfa = await mk('alfa.local', 4001, 'a').start();
+const beta = await mk('beta.local', 4002, 'b').start();
+const nicolas = Agent.create('nicolas@alfa.local', 'http://127.0.0.1:4001', { hosts });
+const abierto = Agent.create('abierto@beta.local', 'http://127.0.0.1:4002', { hosts });
+const selecto = Agent.create('selecto@beta.local', 'http://127.0.0.1:4002', { hosts });
+const caro = Agent.create('caro@beta.local', 'http://127.0.0.1:4002', { hosts });
+await nicolas.register({ adminToken: 'a' });
+await abierto.register({ adminToken: 'b', inbox: { policy: 'open' } });
+await selecto.register({ adminToken: 'b', inbox: { policy: 'allowlist', allowlist: ['socio@gamma.local'] } });
+await caro.register({ adminToken: 'b', inbox: { policy: 'pow', pow_bits: 12 } });
+
+step(1, 'Sobre con firma falsificada (dice ser nicolas@alfa.local pero firma con otra clave)');
+const falsas = generateKeys();
+const forjado = signObject({ nyx5: '1', id: uuid(), from: 'nicolas@alfa.local', to: ['abierto@beta.local'], created: new Date().toISOString(), type: 'message', content: { media: 'text/plain', body: 'soy nicolas, dame tus datos' } }, falsas);
+console.log('   ', await inbound(forjado));
+
+step(2, 'Remitente que no existe en su dominio (fantasma@alfa.local)');
+const fantasma = signObject({ nyx5: '1', id: uuid(), from: 'fantasma@alfa.local', to: ['abierto@beta.local'], created: new Date().toISOString(), type: 'message', content: { media: 'text/plain', body: 'hola' } }, falsas);
+console.log('   ', await inbound(fantasma));
+
+step(3, 'Sobre sin firma');
+const sinFirma = { nyx5: '1', id: uuid(), from: 'nicolas@alfa.local', to: ['abierto@beta.local'], created: new Date().toISOString(), type: 'message', content: { media: 'text/plain', body: 'hola' } };
+console.log('   ', await inbound(sinFirma));
+
+step(4, 'nicolas (legítimo) escribe a selecto, que tiene allowlist: solo se acepta un intro pequeño');
+try { const r = await nicolas.send({ to: 'selecto@beta.local', body: 'hola' }); await new Promise((x) => setTimeout(x, 800)); console.log('    envío normal ->', (await nicolas.outbox()).find((s) => s.id === r.id).status, '(rebote al remitente)'); } catch (e) { console.log('   ', e.message); }
+const intro = await nicolas.send({ to: 'selecto@beta.local', type: 'intro', body: { who: 'Nicolás, Patagonia Capital', why: 'coordinar tasaciones' } });
+const m = await selecto.waitFor((e) => e.id === intro.id);
+console.log('    intro aceptado ->', (await selecto.open(m.envelope)).content.body.why);
+
+step(5, 'nicolas escribe a caro, que exige proof-of-work de 12 bits (el cliente lo calcula solo)');
+const pw = await nicolas.send({ to: 'caro@beta.local', body: 'con estampilla' });
+console.log('    pow adjunto:', pw.envelope.pow, '->', (await caro.waitFor((e) => e.id === pw.id)) ? 'aceptado' : 'rechazado');
+const sinPow = signObject({ nyx5: '1', id: uuid(), from: 'nicolas@alfa.local', to: ['caro@beta.local'], created: new Date().toISOString(), type: 'message', content: { media: 'text/plain', body: 'sin estampilla' } }, nicolas.keys);
+console.log('    sin pow directo a /inbound:', await inbound(sinPow));
+
+step(6, 'Entrega duplicada del mismo sobre (idempotencia por id)');
+const ok = await nicolas.send({ to: 'abierto@beta.local', body: 'una sola vez' });
+await abierto.waitFor((e) => e.id === ok.id);
+console.log('    segunda entrega:', await inbound(ok.envelope));
+console.log('    copias en buzón de abierto:', (await abierto.inbox()).filter((x) => x.envelope.id === ok.id).length);
+
+await alfa.stop(); await beta.stop();
+console.log('\nListo.');