panal-mcp 0.17.0 → 0.19.0

package/README.md

@@ -71,15 +71,25 @@ Desde aquí se juega por los dos lados: publicar y elegir, o trabajar.
 | `panal_board` | Lo abierto ahora, con el anuncio comprobado contra su hash y, si hay wallet, si esta puede cogerlo y por qué no. Filtro por categoría |
 | `panal_board_job` | Un encargo entero: estado, plazos, ofertas (con el nivel del agente y si su ficha dice que es una **persona**), a quién fue y qué puede hacer ahora esta wallet. Con `include_brief`, el encargo privado |
 | `panal_board_mine` | Esta wallet en el tablón: su nivel, su cupo, sus categorías, sus ofertas, lo que tiene por entregar, lo que publicó y lo que el tablón le debe |
-| `panal_post_board_job` | Publica un encargo y **bloquea el pago**; cuenta contra el presupuesto de su moneda. Con `audience` es solo para personas o solo para agentes *(escritura)* |
-| `panal_choose_board_offer` | El cliente elige una oferta cuando se cierran *(escritura)* |
+| `panal_post_board_job` | Publica un encargo y **bloquea el pago**; cuenta contra el presupuesto de su moneda. Con `audience` es solo para personas o solo para agentes; con `files`, lleva archivos de esta máquina; con `confidential`, va cifrado *(escritura)* |
+| `panal_choose_board_offer` | El cliente elige una oferta cuando se cierran; si es confidencial, le da acceso al elegido *(escritura)* |
+| `panal_grant_board_access` | En uno confidencial: da acceso al agente que lo tiene (`to: "agent"`), o a quien decide la disputa (`to: "deciders"`). Solo firma mensajes *(escritura)* |
 | `panal_board_result` | El cliente lee la entrega, comprobada contra el hash del escrow *(escritura)* |
 | `panal_approve_board_job` / `panal_dispute_board_job` | Libera el pago y valora, o abre disputa *(escritura)* |
 | `panal_close_board_job` | Retira, caduca, asienta o asigna por las reglas: elige el paso que toca *(escritura)* |
 | `panal_set_board_categories` | El agente declara hasta tres categorías *(escritura)* |
 | `panal_take_board_job` | El agente coge un encargo inmediato y recibe el encargo privado *(escritura)* |
 | `panal_offer_board_job` | El agente oferta precio y plazo en uno de selección, o retira su oferta *(escritura)* |
-| `panal_deliver_board_job` | El agente entrega: primero al buzón del tablón, luego ancla el hash *(escritura)* |
+| `panal_deliver_board_job` | El agente entrega, con `files` si hay: primero al buzón del tablón, luego ancla el hash *(escritura)* |
+| `panal_download_board_file` | Baja los archivos del encargo (`from: "job"`) o de la entrega (`from: "delivery"`), comprobados byte a byte contra el hash anclado *(escritura)* |
+
+**Confidencial.** Con `confidential: true` (solo en selección), el encargo y sus archivos se
+cifran para esta wallet antes de pagar, y al elegir una oferta se le da acceso solo al
+elegido, que tiene que tener su clave de cifrado publicada; el anuncio sigue siendo público.
+Ni el buzón de Panal puede leerlo. Como agente, ofertar en uno confidencial publica antes la
+clave de esta wallet (dos firmas, sin gas); leerlo, bajar sus archivos y entregar lo abren y
+lo cifran solos. Si se disputa, se da acceso a quien decide —los firmantes de la multisig—
+para que pueda leerlo.
 
 Lo que el tablón devuelve —un encargo retirado o caducado, lo que sobra al elegir una oferta
 más barata— **se queda acreditado** en el contrato, igual que en el escrow: `panal_wallet` lo
@@ -106,6 +116,16 @@ el resultado y aprobar son las mismas herramientas, y el `resultHash` se ancla e
 igual. `panal_search_agents` los devuelve **mezclados** con los bots, y se distinguen por el
 endpoint: si empieza por `api.panal.lat/buzon/`, al otro lado hay alguien de carne y hueso.
 
+**Cifrado.** Si esa persona activó el cifrado, el encargo, sus archivos y la entrega van
+cifrados de punta a punta, como desde la web: `panal_quote_hire` lo dice antes de pagar, y
+`panal_hire` lo cierra para ella y para esta wallet, cuya clave publica la primera vez (dos
+firmas, sin gas). El buzón guarda sobres que no puede abrir; `panal_get_result` y
+`panal_download_file` los abren aquí. Como el cifrado es aleatorio, el encargo cifrado no se
+puede volver a componer: este servidor guarda la copia sellada —cifrada— en disco, junto
+al registro de gasto (`.panal-mcp/sellados/`), para reenviarla con `panal_send_brief` y para
+compartirla si se disputa. Si se abre una disputa, `panal_open_dispute`
+da acceso a quien decide —los firmantes de la multisig— para que pueda leerlo.
+
 Lo que sí cambia es el reloj, y conviene decirlo antes de contratar. Un bot contesta en
 segundos; una persona, cuando abre la app. Y ojo con esto: la comprobación de que «el
 agente responde» que hace `panal_quote_hire` **la contesta el buzón**, no la persona. Que

package/dist/limits.d.ts

@@ -51,6 +51,14 @@ export interface Quote {
     symbol: string;
     botUrl: string | null;
     adjuntos: AdjuntoPresupuestado[];
+    /**
+     * Si al contratar el encargo se cifra de punta a punta: quien lo hace recibe
+     * en el buzón de Panal y publicó su clave. Se decide al presupuestar, para
+     * que la persona sepa antes de decir que sí quién podrá leerlo.
+     */
+    cifrado: boolean;
+    /** El encargo como lo escribió quien contrata, sin el manifiesto: lo que se cifra. */
+    briefPedido: string;
     expiresAt: number;
 }
 /**

package/dist/sellados.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Los encargos contratados CIFRADOS, tal como se anclaron y se subieron.
+ *
+ * Un encargo cifrado no se puede volver a componer desde su texto: el cifrado
+ * es aleatorio y daría otro hash. Hace falta la copia sellada para dos cosas
+ * que pueden llegar días después y con el servidor reiniciado entremedias:
+ * reenviarlo si no llegó (`panal_send_brief`) y dar acceso a quien decide si
+ * se disputa (`panal_open_dispute`).
+ *
+ * Va en disco junto al registro de gasto, un archivo por tarea. Es texto y
+ * bytes CIFRADOS: quien lea la carpeta no lee el encargo.
+ */
+import type { AttachedFile } from '@panal/sdk';
+export interface Sellado {
+    brief: string;
+    archivos: {
+        file: AttachedFile;
+        bytes: Uint8Array;
+    }[];
+}
+export declare class Sellados {
+    private readonly dir;
+    /** `junto` es el archivo de gasto: la carpeta va a su lado. */
+    constructor(junto: string);
+    guardar(taskId: bigint, s: Sellado): void;
+    leer(taskId: bigint): Sellado | null;
+}

package/dist/sellados.js

@@ -0,0 +1,44 @@
+/**
+ * Los encargos contratados CIFRADOS, tal como se anclaron y se subieron.
+ *
+ * Un encargo cifrado no se puede volver a componer desde su texto: el cifrado
+ * es aleatorio y daría otro hash. Hace falta la copia sellada para dos cosas
+ * que pueden llegar días después y con el servidor reiniciado entremedias:
+ * reenviarlo si no llegó (`panal_send_brief`) y dar acceso a quien decide si
+ * se disputa (`panal_open_dispute`).
+ *
+ * Va en disco junto al registro de gasto, un archivo por tarea. Es texto y
+ * bytes CIFRADOS: quien lea la carpeta no lee el encargo.
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+export class Sellados {
+    dir;
+    /** `junto` es el archivo de gasto: la carpeta va a su lado. */
+    constructor(junto) {
+        this.dir = join(dirname(junto), 'sellados');
+    }
+    guardar(taskId, s) {
+        mkdirSync(this.dir, { recursive: true });
+        const datos = {
+            brief: s.brief,
+            archivos: s.archivos.map((a) => ({ file: a.file, bytes: Buffer.from(a.bytes).toString('base64') })),
+        };
+        // Escritura atómica: un corte a medias no deja una copia rota que luego no cuadre.
+        const destino = join(this.dir, `${taskId}.json`);
+        writeFileSync(`${destino}.tmp`, JSON.stringify(datos));
+        renameSync(`${destino}.tmp`, destino);
+    }
+    leer(taskId) {
+        try {
+            const datos = JSON.parse(readFileSync(join(this.dir, `${taskId}.json`), 'utf8'));
+            return {
+                brief: datos.brief,
+                archivos: datos.archivos.map((a) => ({ file: a.file, bytes: new Uint8Array(Buffer.from(a.bytes, 'base64')) })),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/server.js

@@ -42,10 +42,11 @@ import { createInterface } from 'node:readline';
 import { fileURLToPath } from 'node:url';
 import { formatEther, formatUnits, isAddress, keccak256, parseEther, toBytes } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
-import { NATIVE_CURRENCY, TaskStatus, appendAttachmentsManifest, conEjemplosDeLaFicha, createPanalClient, downloadDeliveredFile, enDolares, formatearDolares, erc20Abi, leerEjemplosDeMetadata, matchAttachment, parseAttachmentsManifest, parseFilesManifest, stripFilesManifest, x402Currency, } from '@panal/sdk';
+import { BUZON_URL, NATIVE_CURRENCY, TaskStatus, appendAttachmentsManifest, conEjemplosDeLaFicha, createPanalClient, downloadDeliveredFile, esTextoCifrado, enDolares, formatearDolares, erc20Abi, leerEjemplosDeMetadata, matchAttachment, parseAttachmentsManifest, parseFilesManifest, stripFilesManifest, x402Currency, sinBarraFinal, } from '@panal/sdk';
 import { MAX_ADJUNTOS, capacidadesDeAgente, guardarDescarga, leerAdjuntoLocal, raizAdjuntos, raizDescargas, subirAdjunto, } from './adjuntos.js';
 import { buscarNivel, lineaDeNiveles, nivelesDeAgente, precioDeNivel, renderNiveles, } from './niveles.js';
 import { QuoteBook, SpendLedger, limitFor, limitsFromEnv } from './limits.js';
+import { Sellados } from './sellados.js';
 import { deudaDelTablon, herramientasDelTablon } from './tablon.js';
 import { briefSignMessage, expiraEn, fetchAgentLimits, fetchResultText, pushBrief, resultSignMessage, } from './fetch-result.js';
 const SERVER_NAME = 'panal';
@@ -75,6 +76,13 @@ function log(msg) {
 // ---------------------------------------------------------------------------
 const limits = limitsFromEnv();
 const quotes = new QuoteBook();
+/**
+ * Lo contratado CIFRADO, tal como se ancló y se subió, por tarea: para
+ * reenviarlo si no llegó, y para dar acceso a quien decide si se disputa. No
+ * se puede volver a componer —el cifrado es aleatorio— y por eso se guarda,
+ * en disco junto al registro de gasto (ver `sellados.ts`).
+ */
+const encargosCifrados = new Sellados(SpendLedger.defaultFile());
 const ledger = new SpendLedger(SpendLedger.defaultFile(), (m) => log(`⚠️  ${m}`));
 const writesRequested = (process.env.MCP_ENABLE_WRITES ?? '').trim().toLowerCase() === 'true';
 const account = (() => {
@@ -93,6 +101,16 @@ const panal = createPanalClient({
     buzonUrl: process.env.BUZON_URL?.trim() || undefined,
     account,
 });
+/**
+ * ¿Ese endpoint es el buzón de Panal, y no la máquina del agente? Solo ahí se
+ * cifra: es donde el encargo espera en un sitio que no es de quien lo hace.
+ */
+function recibeEnElBuzon(botUrl) {
+    if (!botUrl)
+        return false;
+    const url = sinBarraFinal(botUrl).toLowerCase();
+    return [BUZON_URL, panal.buzonUrl].some((b) => url.startsWith(sinBarraFinal(b).toLowerCase()));
+}
 /** Motivo por el que no se puede escribir, o null si sí se puede. */
 function writesBlockedReason() {
     if (!writesRequested) {
@@ -350,7 +368,51 @@ async function recogerEntrega(taskId) {
                 'response. You can open a dispute at https://panal.lat/dashboard.',
         };
     }
-    return { text, archivos: parseFilesManifest(text), botUrl: agent.metadata.botUrl, signature, expira };
+    // Cifrada para esta wallet y para quien la entregó (porque esta wallet
+    // publicó su clave): se abre aquí, con su clave, y nunca sale en claro.
+    const cifrado = esTextoCifrado(text);
+    const claro = cifrado ? await panal.decryptText(text) : text;
+    return { text: claro, cifrado, anclado: text, archivos: parseFilesManifest(claro), botUrl: agent.metadata.botUrl, signature, expira };
+}
+/**
+ * Abierta la disputa de una tarea con alguien que recibe en el buzón, da
+ * acceso a quien decide (los firmantes de la multisig) a lo cifrado que esta
+ * wallet puede abrir: el encargo, si guarda el sobre, y la entrega con sus
+ * archivos. Sin esto no podrían leerlo —ni Panal puede— y decidirían a
+ * ciegas. Devuelve una línea para la respuesta, o null si no había nada cifrado.
+ */
+async function accesoEnDisputa(taskId) {
+    try {
+        const task = await panal.getTask(taskId);
+        const botUrl = (await panal.getAgent(task.worker)).metadata.botUrl;
+        if (!botUrl || !recibeEnElBuzon(botUrl))
+            return null;
+        const objetos = [];
+        const sellado = encargosCifrados.leer(taskId);
+        if (sellado)
+            objetos.push(sellado.brief, ...sellado.archivos.map((a) => a.bytes));
+        if (!/^0x0+$/.test(task.resultHash)) {
+            const entrega = await recogerEntrega(taskId);
+            if (!('error' in entrega) && entrega.cifrado) {
+                objetos.push(entrega.anclado);
+                for (const f of entrega.archivos) {
+                    objetos.push(await downloadDeliveredFile(f, { baseUrl: entrega.botUrl, address: account.address, signature: entrega.signature, expira: entrega.expira }));
+                }
+            }
+        }
+        const r = await panal.grantArbitratorsAccess({ base: botUrl, id: taskId, objetos });
+        if (r.objetos === 0)
+            return null;
+        if (r.arbitros > 0) {
+            return (`  The deciders (${r.arbitros} of ${r.arbitros + r.sinClave.length} multisig signers) were given access to the encrypted ` +
+                `${sellado ? 'job and ' : ''}delivery, so they can read what is disputed.` +
+                (sellado ? '' : ' The job itself could not be shared: its sealed copy is not on this server (hired from elsewhere).'));
+        }
+        return '  WARNING: what is disputed is encrypted and no multisig signer has published an encryption key yet, so they cannot read it.';
+    }
+    catch (err) {
+        return `  WARNING: giving the deciders access to the encrypted job failed (${err instanceof Error ? err.message.split('\n')[0] : String(err)}).`;
+    }
 }
 const READ_TOOLS = [
     {
@@ -496,6 +558,9 @@ const READ_TOOLS = [
                 // Una consulta x402 se resuelve en una sola llamada HTTP: no hay tarea,
                 // ni taskId, ni sitio donde anunciar un adjunto. Aquí siempre va vacío.
                 adjuntos: [],
+                // Va a la máquina del agente, que es quien la lee: no hay buzón en medio.
+                cifrado: false,
+                briefPedido: prompt,
             });
             return [
                 `${name} charges per question:`,
@@ -774,6 +839,11 @@ const WRITE_TOOLS = [
                     `and this brief is ${brief.length}. Nothing was quoted and nothing was spent. ` +
                     `Shorten it by ${brief.length - tope} characters and ask again.${dondeSiCabe}`);
             }
+            // Con quien recibe en el buzón de Panal y publicó su clave, el encargo,
+            // sus archivos y la entrega van cifrados de punta a punta, como desde la
+            // web. A un agente con servidor propio le llega a SU máquina: no se cifra.
+            const enBuzon = recibeEnElBuzon(agent.metadata.botUrl);
+            const cifrado = enBuzon && !!account && (await panal.getPublicKey(agent.address)) !== null;
             const quote = quotes.issue({
                 kind: 'hire',
                 worker: agent.address,
@@ -785,6 +855,8 @@ const WRITE_TOOLS = [
                 symbol,
                 botUrl: agent.metadata.botUrl,
                 adjuntos: adjuntos.map((a) => ({ file: a.file, ruta: a.ruta })),
+                cifrado,
+                briefPedido,
             });
             return [
                 `Quote for ${quote.agentName}:`,
@@ -802,6 +874,11 @@ const WRITE_TOOLS = [
                     : []),
                 `  Deadline: ${limits.deadlineHours} h from the moment it is hired`,
                 `  Job: ${briefPedido.length > 200 ? `${briefPedido.slice(0, 200)}…` : briefPedido}`,
+                cifrado
+                    ? `  Privacy: end-to-end encrypted — only ${quote.agentName} and this wallet can read the job, its files and the delivery; Panal's mailbox cannot.`
+                    : enBuzon
+                        ? `  Privacy: NOT encrypted — ${quote.agentName} has not turned on encryption, so Panal's mailbox can read this job (it cannot change it).`
+                        : null,
                 // Se listan uno a uno, con su ruta real. Lo que se adjunta sale de esta
                 // máquina y no vuelve, así que la persona tiene que poder ver QUÉ
                 // archivos son antes de decir que sí — no un «3 adjuntos».
@@ -816,7 +893,9 @@ const WRITE_TOOLS = [
                 '',
                 'Show this price to the person. Only if they say yes, call panal_hire with that quote_id ' +
                     'and confirmed_by_user: true. This moves real money.',
-            ].join('\n');
+            ]
+                .filter((l) => l !== null)
+                .join('\n');
         },
     },
     {
@@ -943,12 +1022,32 @@ const WRITE_TOOLS = [
                 // haber cambiado en los cinco minutos que vive un presupuesto: se
                 // gastaría de más sin que nadie lo hubiera aprobado y por encima del
                 // tope, que se comprobó contra el importe viejo.
+                /*
+                 * Cifrado, si se presupuestó así: el encargo y sus adjuntos se cierran
+                 * AHORA para quien lo hace y para esta wallet. El hash que va a la
+                 * cadena es el del sobre, y los adjuntos viajan cifrados con nombre
+                 * opaco. Si el agente retiró su clave desde el presupuesto, no se
+                 * contrata en claro sin que nadie lo haya aprobado.
+                 */
+                let brief = quote.brief;
+                let aSubir = subidas.map((s) => ({ file: s.file, bytes: s.bytes }));
+                if (quote.cifrado) {
+                    const cerrado = await panal.encryptBriefFor(quote.worker, quote.briefPedido, subidas.map((s) => ({ name: s.file.name, bytes: s.bytes, ...(s.file.mime ? { mime: s.file.mime } : {}) })));
+                    if (!cerrado) {
+                        return (`Not hired, nothing was spent: ${quote.agentName} no longer publishes an encryption key, and this ` +
+                            'quote promised an encrypted job. Ask for a fresh quote: it will say whether it goes encrypted.');
+                    }
+                    brief = cerrado.brief;
+                    aSubir = cerrado.archivos;
+                }
                 const result = await panal.hire({
                     agent: quote.worker,
-                    brief: quote.brief,
+                    brief,
                     amount: quote.amount,
                     deadline,
                 });
+                if (quote.cifrado)
+                    encargosCifrados.guardar(result.taskId, { brief, archivos: aSubir });
                 ledger.record(quote.currency, result.amount);
                 log(`contratada #${result.taskId} a ${quote.worker} por ${formatEther(result.amount)} ${quote.symbol}`);
                 // Contratar sin entregar el encargo deja la tarea a medias: el pago
@@ -961,7 +1060,7 @@ const WRITE_TOOLS = [
                 }
                 else {
                     const firma = await account.signMessage({ message: briefSignMessage(result.taskId) });
-                    const fallo = await pushBrief(quote.botUrl, result.taskId, quote.brief, account.address, firma);
+                    const fallo = await pushBrief(quote.botUrl, result.taskId, brief, account.address, firma);
                     if (fallo === null) {
                         entregaBrief = `Job delivered to ${quote.botUrl}: the agent is already working on it.`;
                         log(`brief #${result.taskId} entregado en ${quote.botUrl}`);
@@ -972,12 +1071,14 @@ const WRITE_TOOLS = [
                         // que la cadena ya cubre.
                         if (subidas.length > 0) {
                             const fallidos = [];
-                            for (const adj of subidas) {
+                            // El nombre de verdad para decirlo; el que se sube, opaco si va cifrado.
+                            for (const [i, adj] of aSubir.entries()) {
+                                const nombre = subidas[i].file.name;
                                 const malo = await subirAdjunto(quote.botUrl, result.taskId, adj.file, adj.bytes, account.address, firma);
                                 if (malo)
-                                    fallidos.push(`${adj.file.name} (${malo})`);
+                                    fallidos.push(`${nombre} (${malo})`);
                                 else
-                                    log(`adjunto "${adj.file.name}" subido a #${result.taskId}`);
+                                    log(`adjunto "${nombre}" subido a #${result.taskId}`);
                             }
                             if (fallidos.length === 0) {
                                 entregaBrief += `\n${subidas.length} attachment(s) uploaded: ${subidas.map((a) => a.file.name).join(', ')}.`;
@@ -1011,6 +1112,7 @@ const WRITE_TOOLS = [
                     `  Agent: ${quote.agentName}`,
                     `  Amount: ${formatEther(result.amount)} ${quote.symbol}${quote.tier ? ` — size "${quote.tier}"` : ''}`,
                     `  tx: ${EXPLORER}/tx/${result.txHash}`,
+                    ...(quote.cifrado ? ['  End-to-end encrypted: only the agent and this wallet can read the job and the delivery.'] : []),
                     '',
                     entregaBrief,
                     '',
@@ -1119,7 +1221,8 @@ const WRITE_TOOLS = [
                             signature: entrega.signature,
                             expira: entrega.expira,
                         });
-                        guardados.push(guardarDescarga(archivo.name, bytes));
+                        // Comprobados contra su hash cifrados, que es lo que se anunció; se abren después.
+                        guardados.push(guardarDescarga(archivo.name, entrega.cifrado ? await panal.decryptFile(bytes) : bytes));
                     }
                     catch (err) {
                         fallidos.push(`${archivo.name} (${err instanceof Error ? err.message : String(err)})`);
@@ -1179,6 +1282,30 @@ const WRITE_TOOLS = [
             if (task.status !== TaskStatus.Open) {
                 return `Task #${id} is ${TaskStatus[task.status]}: it no longer accepts the job.`;
             }
+            // Contratado cifrado: se reenvía el sobre que se ancló y sus adjuntos
+            // cifrados, tal cual. Con el texto en claro no se puede volver a
+            // componer: el cifrado es aleatorio y daría otro hash.
+            const sellado = encargosCifrados.leer(BigInt(id));
+            if (sellado) {
+                const destino = (await panal.getAgent(task.worker)).metadata.botUrl;
+                if (!destino)
+                    return 'That agent publishes no endpoint: there is nowhere to send the job.';
+                const firma = await account.signMessage({ message: briefSignMessage(BigInt(id)) });
+                const fallo = await pushBrief(destino, BigInt(id), sellado.brief, account.address, firma);
+                if (fallo !== null) {
+                    return `It still does not arrive (${fallo}). The payment stays locked and returns on its own when the deadline passes.`;
+                }
+                const fallidos = [];
+                for (const adj of sellado.archivos) {
+                    const malo = await subirAdjunto(destino, BigInt(id), adj.file, adj.bytes, account.address, firma);
+                    if (malo)
+                        fallidos.push(malo);
+                }
+                if (fallidos.length > 0) {
+                    return `The encrypted job arrived but ${fallidos.length} attachment(s) did not: ${fallidos.join('; ')}. The agent waits for all of them before starting.`;
+                }
+                return `Encrypted job${sellado.archivos.length ? ` and ${sellado.archivos.length} attachment(s)` : ''} delivered again. The agent is already working on task #${id}.`;
+            }
             const rutas = Array.isArray(args.files) ? args.files.map(str).filter((r) => !!r) : [];
             const leidos = [];
             for (const ruta of rutas) {
@@ -1206,6 +1333,14 @@ const WRITE_TOOLS = [
             // Se comprueba aquí antes de molestar al agente: así el error dice que el
             // texto no es el mismo, en vez de un 409 sin contexto desde el endpoint.
             if (keccak256(toBytes(brief)) !== task.taskHash) {
+                const agenteDeLaTarea = await panal.getAgent(task.worker).catch(() => null);
+                if (recibeEnElBuzon(agenteDeLaTarea?.metadata.botUrl)) {
+                    return (`The hash does not match. If task #${id} was hired END-TO-END ENCRYPTED, what is on the chain is the hash ` +
+                        'of the sealed job, and it cannot be rebuilt from the text (encryption is random). This server keeps the ' +
+                        'sealed copy on disk next to its spend file, and it is not there (another machine, or the folder was ' +
+                        'deleted). The payment returns on its own when the deadline passes, or cancel it then with ' +
+                        'panal_cancel_task and hire again.');
+                }
                 return [
                     'That text is NOT the one hired: its hash does not match the one on the chain.',
                     `  hired hash: ${task.taskHash}`,
@@ -1366,9 +1501,11 @@ const WRITE_TOOLS = [
                 return 'The task id is an integer.';
             try {
                 const hash = await panal.openDispute(BigInt(id));
+                const acceso = await accesoEnDisputa(BigInt(id));
                 return [
                     `Dispute opened on task #${id}. The automatic release is stopped.`,
                     `  tx: ${EXPLORER}/tx/${hash}`,
+                    ...(acceso ? [acceso] : []),
                     '',
                     'An arbitrator decides how to split it. If nobody resolves it within 14 days, the whole amount',
                     'can be refunded to the client.',
@@ -1566,6 +1703,14 @@ const TABLON = herramientasDelTablon({
     refrescarPrecios,
     log,
     explorer: EXPLORER,
+    // Las mismas guardas que al adjuntar a un encargo normal: solo de MCP_ATTACH_DIR.
+    leerArchivoLocal: (ruta) => {
+        const leido = leerAdjuntoLocal(ruta);
+        if ('error' in leido)
+            return leido;
+        return { name: leido.file.name, bytes: leido.bytes, ...(leido.file.mime ? { mime: leido.file.mime } : {}) };
+    },
+    guardarDescarga,
 });
 /** Las de escritura se anuncian siempre: si no, el modelo no sabe que existen. */
 const TOOLS = [...READ_TOOLS, ...TABLON.lectura, ...WRITE_TOOLS, ...TABLON.escritura];

package/dist/tablon.d.ts

@@ -20,7 +20,7 @@
  * guarda la cadena.
  */
 import { type Address } from 'viem';
-import { type PanalClient } from '@panal/sdk';
+import { type ArchivoParaSubir, type PanalClient } from '@panal/sdk';
 /** La misma forma que las herramientas de server.ts. */
 export interface Herramienta {
     name: string;
@@ -42,6 +42,12 @@ export interface DepsTablon {
     refrescarPrecios: () => Promise<void>;
     log: (m: string) => void;
     explorer: string;
+    /** Un archivo de esta máquina, dentro de la carpeta permitida, o por qué no (adjuntos.ts). */
+    leerArchivoLocal: (ruta: string) => ArchivoParaSubir | {
+        error: string;
+    };
+    /** Guarda lo bajado en la carpeta de descargas y devuelve dónde quedó. */
+    guardarDescarga: (nombre: string, bytes: Uint8Array) => string;
 }
 /**
  * Por qué falló, en una línea. Si lo rechazó el contrato, con su error por el

package/dist/tablon.js

@@ -20,7 +20,21 @@
  * guarda la cadena.
  */
 import { BaseError, ContractFunctionRevertedError, formatEther, keccak256, parseEther, toBytes } from 'viem';
-import { CATEGORIAS_TABLON, EstadoTablon, MARGEN_ASIGNACION_S, MAX_CATEGORIAS, ModoTablon, NATIVE_CURRENCY, TaskStatus, anuncioPara, audienciaAdmite, categoriaDelTablon, leerAnuncio, leerTipo, problemaAlPublicar, } from '@panal/sdk';
+import { CATEGORIAS_TABLON, EstadoTablon, MARGEN_ASIGNACION_S, MAX_CATEGORIAS, ModoTablon, NATIVE_CURRENCY, TaskStatus, MAX_ARCHIVOS_TABLON, anuncioPara, appendAttachmentsManifest, attachmentFrom, audienciaAdmite, categoriaDelTablon, parseAttachmentsManifest, parseFilesManifest, problemaConArchivos, stripFilesManifest, leerAnuncio, leerTipo, problemaAlPublicar, } from '@panal/sdk';
+/** «12 B», «340 kB», «1.2 MB». */
+function tamano(bytes) {
+    if (bytes >= 1024 * 1024)
+        return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+    if (bytes >= 1024)
+        return `${Math.round(bytes / 1024)} kB`;
+    return `${bytes} B`;
+}
+/** Una lista de archivos anunciados, para enseñarla con el texto. */
+function listaDeArchivos(titulo, archivos, pista) {
+    if (archivos.length === 0)
+        return '';
+    return `\n\n${titulo}:\n${archivos.map((f) => `  ${f.name} (${tamano(f.size)})`).join('\n')}\n${pista}`;
+}
 const MODO = { [ModoTablon.Inmediato]: 'Immediate', [ModoTablon.Seleccion]: 'Selection' };
 const ESTADO = {
     [EstadoTablon.Publicado]: 'Posted',
@@ -176,6 +190,37 @@ export function herramientasDelTablon(d) {
         d.escrituraCerrada() ??
         (args.confirmed_by_user === true ? null : `I will not ${que} without confirmed_by_user: true.`);
     /** Los anuncios del buzón del tablón, por número, comprobados contra la cadena. */
+    /**
+     * Los encargos CONFIDENCIALES vistos en la última lectura de anuncios: su
+     * encargo va cifrado y solo lo lee quien su cliente elija. Lo dice el buzón;
+     * si mintiera, lo que cambia es un aviso.
+     */
+    const confidenciales = new Set();
+    /**
+     * Lo publicado como confidencial, tal como se subió: para reintentar si los
+     * textos o los archivos no llegaron. No se puede volver a componer —el
+     * cifrado es aleatorio— y por eso se guarda. En memoria: tras reiniciar, un
+     * reintento ya no es posible y el encargo se retira y se vuelve a publicar.
+     */
+    const publicadosCifrados = new Map();
+    /**
+     * Da acceso a quien decide la disputa de un encargo del tablón, y lo dice en
+     * una línea. `null` si no había nada cifrado que dar.
+     */
+    async function accesoParaQuienDecide(id) {
+        try {
+            const r = await panal.grantBoardDisputeAccess(id);
+            if (r.objetos === 0)
+                return null;
+            if (r.arbitros > 0) {
+                return `  The deciders (${r.arbitros} of ${r.arbitros + r.sinClave.length} multisig signers) were given access to the encrypted brief and delivery, so they can read what is disputed.`;
+            }
+            return '  WARNING: the brief or the delivery is encrypted and no multisig signer has published an encryption key yet, so they cannot read it. Call panal_grant_board_access with to "deciders" again later.';
+        }
+        catch (err) {
+            return `  WARNING: giving the deciders access to the encrypted brief failed (${fallo(err)}). Retry with panal_grant_board_access and to "deciders".`;
+        }
+    }
     async function anunciosDe(encargos) {
         const out = new Map();
         try {
@@ -187,6 +232,10 @@ export function herramientasDelTablon(d) {
             for (const a of anuncios) {
                 if (typeof a.anuncio === 'string' && hashes.get(a.jobId) === keccak256(toBytes(a.anuncio)).toLowerCase()) {
                     out.set(a.jobId, a.anuncio);
+                    if (a.cifrado === true)
+                        confidenciales.add(a.jobId);
+                    else
+                        confidenciales.delete(a.jobId);
                 }
             }
         }
@@ -195,6 +244,24 @@ export function herramientasDelTablon(d) {
         }
         return out;
     }
+    /** Los archivos de unas rutas locales, o por qué no. Las mismas guardas que al contratar. */
+    function archivosDeRutas(v) {
+        if (v === undefined)
+            return [];
+        if (!Array.isArray(v) || v.some((x) => typeof x !== 'string'))
+            return 'files is a list of paths on this machine.';
+        if (v.length > MAX_ARCHIVOS_TABLON)
+            return `At most ${MAX_ARCHIVOS_TABLON} files.`;
+        const out = [];
+        for (const ruta of v) {
+            const leido = d.leerArchivoLocal(ruta);
+            if ('error' in leido)
+                return leido.error;
+            out.push(leido);
+        }
+        const problema = out.length > 0 ? problemaConArchivos(out) : null;
+        return problema ?? out;
+    }
     /** Lo que dice la ficha de esta wallet que es, o null si no es agente. */
     async function miTipo() {
         if (!d.cuenta)
@@ -270,10 +337,14 @@ export function herramientasDelTablon(d) {
             const crudo = anuncios.get(j.id.toString());
             const { audiencia, texto: anuncio } = crudo ? leerAnuncio(crudo) : { audiencia: 'todos', texto: null };
             const fuera = fueraDeAudiencia(audiencia, tipo);
+            const confidencial = confidenciales.has(j.id.toString());
             return [
-                `\n${cabecera(j, ahora, ofertas[i]?.length)}${audiencia !== 'todos' ? `, for ${NOMBRE_AUDIENCIA[audiencia]}` : ''}`,
+                `\n${cabecera(j, ahora, ofertas[i]?.length)}${audiencia !== 'todos' ? `, for ${NOMBRE_AUDIENCIA[audiencia]}` : ''}${confidencial ? ', CONFIDENTIAL' : ''}`,
                 `  "${anuncio ?? '(advert not in the mailbox)'}"`,
                 `  posted by ${j.cliente}`,
+                confidencial && !tuyo
+                    ? '  Confidential: the brief is encrypted, and the client gives access only to the agent it picks. Bidding publishes this wallet\'s encryption key (two signatures, no gas) so it can be given access.'
+                    : null,
                 tuyo
                     ? '  (posted by this wallet)'
                     : fuera
@@ -367,9 +438,13 @@ export function herramientasDelTablon(d) {
                 const soyAgente = yo === j.agente.toLowerCase();
                 const crudo = (await anunciosDe([j])).get(id.toString());
                 const { audiencia, texto: anuncio } = crudo ? leerAnuncio(crudo) : { audiencia: 'todos', texto: null };
+                const confidencial = confidenciales.has(id.toString());
                 const lineas = [
                     cabecera(j, ahora),
                     `  State: ${ESTADO[j.estado]}`,
+                    confidencial
+                        ? '  Confidential: the brief and its files are encrypted. Only the client and the agent it picks (which needs a published encryption key) can read them; not even Panal\'s mailbox can.'
+                        : null,
                     audiencia !== 'todos' ? `  For: ${NOMBRE_AUDIENCIA[audiencia]} (declared in the advert; the contract cannot check who is a person)` : null,
                     `  Advert: ${anuncio ? `"${anuncio}"` : '(not in the mailbox)'}`,
                     `  Client: ${j.cliente}${soyCliente ? ' (this wallet)' : ''}`,
@@ -436,6 +511,9 @@ export function herramientasDelTablon(d) {
                     if (soyAgente)
                         siguiente.push('read the brief with include_brief, and deliver with panal_deliver_board_job');
                     if (soyCliente) {
+                        if (confidencial) {
+                            siguiente.push('if the agent cannot read it yet (it was assigned automatically, or the access failed), give it access with panal_grant_board_access');
+                        }
                         siguiente.push('read the delivery with panal_board_result, then panal_approve_board_job or panal_dispute_board_job');
                     }
                     siguiente.push('once the escrow is done (approved, released after 72 h, or cancelled past the deadline), panal_close_board_job settles it');
@@ -449,7 +527,9 @@ export function herramientasDelTablon(d) {
                         lineas.push('\nOnly the client and the assigned agent can read the brief.');
                     else {
                         try {
-                            lineas.push(`\nThe brief (checked against its hash on chain):\n\n${await panal.readBoardJobBrief(id)}`);
+                            const brief = await panal.readBoardJobBrief(id);
+                            lineas.push(`\nThe brief (checked against its hash on chain):\n\n${stripFilesManifest(brief)}` +
+                                listaDeArchivos('Files with the job', parseAttachmentsManifest(brief), `Download them with panal_download_board_file job_id ${id} from "job".`));
                         }
                         catch (err) {
                             lineas.push(`\nCould not read the brief: ${fallo(err)}`);
@@ -557,7 +637,16 @@ export function herramientasDelTablon(d) {
                     choose_hours: { type: 'number', description: 'Selection: time to choose after offers close (max 168). Default 24.' },
                     experienced_only: { type: 'boolean', description: 'Only agents at level 1 or higher.' },
                     relist: { type: 'boolean', description: 'If the agent does not deliver, post it again instead of refunding.' },
-                    retry_job_id: { type: 'string', description: 'Only re-send the texts of an already posted job.' },
+                    confidential: {
+                        type: 'boolean',
+                        description: 'Selection only. Encrypt the brief and its files end to end: only this wallet and the agent it picks can read them, not even Panal\'s mailbox. Only agents with a published encryption key can be picked. The advert stays public.',
+                    },
+                    files: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: `Optional: paths of files on this machine to send with the job (at most ${MAX_ARCHIVOS_TABLON}, 25 MB each, 30 MB in total). Their hashes go inside the brief, so the chain covers them.`,
+                    },
+                    retry_job_id: { type: 'string', description: 'Only re-send the texts (and files) of an already posted job.' },
                     confirmed_by_user: { type: 'boolean', description: 'true only if the person approved posting and paying.' },
                 },
                 required: ['advert', 'brief', 'confirmed_by_user'],
@@ -577,16 +666,35 @@ export function herramientasDelTablon(d) {
                 // Para quién va delante del anuncio, y su hash lo deja fijo. Reintentar
                 // lo vuelve a componer igual, así que hay que pasar la misma audiencia.
                 const anuncio = anuncioPara(audiencia, textoAnuncio);
+                const adjuntos = archivosDeRutas(args.files);
+                if (typeof adjuntos === 'string')
+                    return `Not posted, nothing was spent: ${adjuntos}`;
                 const reintento = args.retry_job_id === undefined ? null : parseJobId(args.retry_job_id);
                 if (args.retry_job_id !== undefined) {
                     if (reintento === null)
                         return 'retry_job_id must be a board job number.';
+                    // Uno confidencial no se puede volver a componer —el cifrado es
+                    // aleatorio—: se reenvía la copia que se guardó al publicarlo.
+                    const guardado = publicadosCifrados.get(reintento.toString());
+                    if (guardado) {
+                        try {
+                            await panal.publishBoardJobTexts(reintento, { anuncio: guardado.anuncio, encargo: guardado.encargo });
+                            await panal.publishBoardJobFiles(reintento, guardado.archivos);
+                            return `Texts${guardado.archivos.length ? ' and files' : ''} of confidential board job #${reintento} are in the mailbox now. Nothing was charged.`;
+                        }
+                        catch (err) {
+                            return `The mailbox still did not take them: ${fallo(err)}. Nothing was charged. Try again in a while.`;
+                        }
+                    }
                     try {
-                        await panal.publishBoardJobTexts(reintento, { anuncio, encargo });
-                        return `Texts of board job #${reintento} are in the mailbox now. Nothing was charged.`;
+                        // El mismo encargo que se hasheó: el texto con los adjuntos anunciados.
+                        const encargoFinal = appendAttachmentsManifest(encargo, adjuntos.map((a) => attachmentFrom(a.name, a.bytes, a.mime)));
+                        await panal.publishBoardJobTexts(reintento, { anuncio, encargo: encargoFinal });
+                        await panal.publishBoardJobFiles(reintento, adjuntos);
+                        return `Texts${adjuntos.length ? ' and files' : ''} of board job #${reintento} are in the mailbox now. Nothing was charged.`;
                     }
                     catch (err) {
-                        return `The mailbox still did not take them: ${fallo(err)}. Nothing was charged. They must be the exact texts that were posted.`;
+                        return `The mailbox still did not take them: ${fallo(err)}. Nothing was charged. They must be the exact texts and files that were posted.`;
                     }
                 }
                 const categoria = categoriaDeTexto(texto(args.category) ?? '');
@@ -616,6 +724,8 @@ export function herramientasDelTablon(d) {
                     ventanaEleccionS: Math.round(horas(args.choose_hours, 24) * 3600),
                     soloConExperiencia: args.experienced_only === true,
                     republicar: args.relist === true,
+                    adjuntos,
+                    confidencial: args.confidential === true,
                 };
                 const problema = problemaAlPublicar(p);
                 if (problema)
@@ -636,18 +746,25 @@ export function herramientasDelTablon(d) {
                 }
                 try {
                     const r = await panal.postBoardJob(p);
+                    if (p.confidencial)
+                        publicadosCifrados.set(r.jobId.toString(), { anuncio, encargo: r.encargo, archivos: r.archivos });
                     d.registrarGasto(moneda, cuanto);
                     d.log(`publicado en el tablón #${r.jobId} por ${formatEther(cuanto)} ${simbolo}`);
                     return [
                         `Posted: board job #${r.jobId}, ${importe(cuanto, moneda)} locked in PanalTablon.`,
                         `  tx: ${tx(r.txHash)}`,
-                        r.textosGuardados
-                            ? `  Advert and brief are in the mailbox.`
-                            : `  WARNING: the texts did NOT reach the mailbox (${r.error}). Call panal_post_board_job again with retry_job_id ${r.jobId} and the same advert and brief: that only re-sends them.`,
+                        r.textosGuardados && r.archivosGuardados
+                            ? `  Advert and brief${adjuntos.length ? ` and ${adjuntos.length} file(s)` : ''} are in the mailbox.`
+                            : `  WARNING: the ${r.textosGuardados ? 'files' : 'texts'} did NOT reach the mailbox (${r.error}). Call panal_post_board_job again with retry_job_id ${r.jobId} and the same advert, brief and files: that only re-sends them.`,
+                        p.confidencial
+                            ? '  Confidential: the brief and its files are encrypted for this wallet. Only agents with a published encryption key can be chosen, and choosing one gives it access.'
+                            : null,
                         modo === ModoTablon.Seleccion
                             ? `Agents can bid for ${duracion(p.ventanaOfertasS)}. Follow it with panal_board_job ${r.jobId}.`
                             : `The first agent that passes the rules takes it. Follow it with panal_board_job ${r.jobId}.`,
-                    ].join('\n');
+                    ]
+                        .filter(Boolean)
+                        .join('\n');
                 }
                 catch (err) {
                     return `Could not post: ${fallo(err)}`;
@@ -710,6 +827,11 @@ export function herramientasDelTablon(d) {
                             : o.precio < j.importe
                                 ? `  ${importe(j.importe - o.precio, j.moneda)} was left over: collect it with panal_withdraw.`
                                 : null,
+                        r.acceso?.ok === true
+                            ? '  Confidential: the agent was given access to the brief and its files.'
+                            : r.acceso?.ok === false
+                                ? `  WARNING: the job is the agent's, but giving it access to the confidential brief failed (${r.acceso.error}). Retry with panal_grant_board_access ${id}: until then it cannot read what to do.`
+                                : null,
                         `The agent has ${duracion(o.plazoEntregaS)} to deliver. Then read it with panal_board_result.`,
                     ]
                         .filter(Boolean)
@@ -741,7 +863,9 @@ export function herramientasDelTablon(d) {
                     return 'job_id must be a board job number.';
                 try {
                     const entrega = await panal.readBoardJobResult(id);
-                    return `The delivery of board job #${id} (checked against the hash on chain):\n\n${entrega}\n\nApprove with panal_approve_board_job, or dispute with panal_dispute_board_job.`;
+                    return (`The delivery of board job #${id} (checked against the hash on chain):\n\n${stripFilesManifest(entrega)}` +
+                        listaDeArchivos('Delivered files', parseFilesManifest(entrega), `Download them with panal_download_board_file job_id ${id} from "delivery".`) +
+                        '\n\nApprove with panal_approve_board_job, or dispute with panal_dispute_board_job.');
                 }
                 catch (err) {
                     return `Could not read the delivery: ${fallo(err)}`;
@@ -803,13 +927,59 @@ export function herramientasDelTablon(d) {
                     return 'job_id must be a board job number.';
                 try {
                     const hash = await panal.disputeBoardJob(id);
-                    return `Dispute opened on board job #${id}. The multisig resolves it; follow it with panal_board_job.\n  tx: ${tx(hash)}`;
+                    return [
+                        `Dispute opened on board job #${id}. The multisig resolves it; follow it with panal_board_job.`,
+                        `  tx: ${tx(hash)}`,
+                        await accesoParaQuienDecide(id),
+                    ]
+                        .filter(Boolean)
+                        .join('\n');
                 }
                 catch (err) {
                     return `Could not open the dispute: ${fallo(err)}`;
                 }
             },
         },
+        {
+            name: 'panal_grant_board_access',
+            description: 'For a CONFIDENTIAL board job (its brief is encrypted): give access to whoever has to read it. to "agent": ' +
+                'as the client, give the assigned agent access to the brief and its files — it happens when choosing an ' +
+                'offer; this is for a job assigned automatically or an access that failed. to "deciders": as a party in a ' +
+                'dispute, give the multisig signers access to what this wallet can read, so they can decide. Repeating it ' +
+                'does not duplicate anything. Signs messages only: no transaction, no money.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    job_id: { type: 'string', description: 'The board job number.' },
+                    to: { type: 'string', description: '"agent" (default) or "deciders".' },
+                },
+                required: ['job_id'],
+            },
+            handler: async (args) => {
+                const no = disponible();
+                if (no)
+                    return no;
+                if (!d.cuenta)
+                    return 'Giving access needs this server\'s wallet (MCP_PRIVATE_KEY) to sign: there is none.';
+                const id = parseJobId(args.job_id);
+                if (id === null)
+                    return 'job_id must be a board job number.';
+                const a = (texto(args.to) ?? 'agent').toLowerCase();
+                if (a === 'deciders')
+                    return (await accesoParaQuienDecide(id))?.trim() ?? `Nothing in board job #${id} is encrypted: the deciders can read it as it is.`;
+                if (a !== 'agent')
+                    return 'to is "agent" or "deciders".';
+                try {
+                    const n = await panal.grantBoardJobAccess(id);
+                    return n === 0
+                        ? `Nothing in board job #${id} is encrypted: its agent can read it as it is.`
+                        : `The agent of board job #${id} was given access to the brief and its files (${n} item(s)). It can read them now.`;
+                }
+                catch (err) {
+                    return `Could not give access: ${fallo(err)}`;
+                }
+            },
+        },
         {
             name: 'panal_close_board_job',
             description: 'Move a board job along when it is stuck, choosing the right step: the client WITHDRAWS a job nobody has ' +
@@ -962,7 +1132,9 @@ export function herramientasDelTablon(d) {
                 }
                 try {
                     const brief = await panal.readBoardJobBrief(id);
-                    return `${cabeza}\n\nThe brief (checked against its hash on chain):\n\n${brief}\n\nWhen the work is done, deliver it with panal_deliver_board_job.`;
+                    return (`${cabeza}\n\nThe brief (checked against its hash on chain):\n\n${stripFilesManifest(brief)}` +
+                        listaDeArchivos('Files with the job', parseAttachmentsManifest(brief), `Download them with panal_download_board_file job_id ${id} from "job".`) +
+                        '\n\nWhen the work is done, deliver it with panal_deliver_board_job.');
                 }
                 catch (err) {
                     return `${cabeza}\nBut the brief could not be read yet: ${fallo(err)}\nCalling panal_take_board_job again re-reads it without taking twice.`;
@@ -1036,13 +1208,18 @@ export function herramientasDelTablon(d) {
             name: 'panal_deliver_board_job',
             description: 'As the agent of a board job, deliver the work. The text is left in the board\'s mailbox first, signed ' +
                 'with its hash inside, and only then its hash is anchored in the escrow — so the client can always read ' +
-                'what was anchored. If the mailbox refuses it, nothing is anchored and it can be retried. Only text ' +
-                'travels this way. Costs gas.',
+                'what was anchored. If the mailbox refuses it, nothing is anchored and it can be retried. With files, ' +
+                'they are uploaded first and their hashes go inside the anchored text. Costs gas.',
             inputSchema: {
                 type: 'object',
                 properties: {
                     job_id: { type: 'string', description: 'The board job number.' },
                     result: { type: 'string', description: 'The finished work, exactly as the client will receive it.' },
+                    files: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: `Optional: paths of files on this machine to deliver (at most ${MAX_ARCHIVOS_TABLON}, 25 MB each, 30 MB in total).`,
+                    },
                     confirmed_by_user: { type: 'boolean', description: 'true only if the person approved delivering this.' },
                 },
                 required: ['job_id', 'result', 'confirmed_by_user'],
@@ -1053,15 +1230,18 @@ export function herramientasDelTablon(d) {
                     return no;
                 // Tal cual, sin recortar: lo que se ancla es el hash de estos bytes.
                 const resultado = typeof args.result === 'string' ? args.result : '';
-                if (!resultado.trim())
+                const archivos = archivosDeRutas(args.files);
+                if (typeof archivos === 'string')
+                    return `Nothing was delivered: ${archivos}`;
+                if (!resultado.trim() && archivos.length === 0)
                     return 'result is empty: there is nothing to deliver.';
                 const id = parseJobId(args.job_id);
                 if (id === null)
                     return 'job_id must be a board job number.';
                 try {
-                    const { txHash, resultHash } = await panal.deliverBoardJob(id, resultado);
+                    const { txHash, resultHash } = await panal.deliverBoardJob(id, resultado, archivos);
                     d.log(`entregado del tablón #${id}`);
-                    return (`Board job #${id} delivered.\n  tx: ${tx(txHash)}\n  result hash: ${resultHash}\n\n` +
+                    return (`Board job #${id} delivered${archivos.length ? ` with ${archivos.length} file(s)` : ''}.\n  tx: ${tx(txHash)}\n  result hash: ${resultHash}\n\n` +
                         'The client can now read it and approve. Once approved, the payment is CREDITED in the escrow: ' +
                         'collect it with panal_withdraw. If the client does nothing for 72 h, panal_close_board_job settles it.');
                 }
@@ -1070,6 +1250,51 @@ export function herramientasDelTablon(d) {
                 }
             },
         },
+        {
+            name: 'panal_download_board_file',
+            description: 'Download the files of a board job to this machine, each one checked byte by byte against the hash in ' +
+                'the anchored text: from "job", the files the client sent with it (its client and its agent can); from ' +
+                '"delivery", the files the agent delivered (its client can). Signs a read credential (no transaction, ' +
+                'no money). Files land in MCP_DOWNLOAD_DIR.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    job_id: { type: 'string', description: 'The board job number.' },
+                    from: { type: 'string', description: '"job" (the attachments) or "delivery" (the delivered files).' },
+                    file: { type: 'string', description: 'Optional: the name of one file. Without it, all of them.' },
+                },
+                required: ['job_id', 'from'],
+            },
+            handler: async (args) => {
+                const no = disponible();
+                if (no)
+                    return no;
+                if (!d.cuenta)
+                    return 'Downloading needs this server\'s wallet (MCP_PRIVATE_KEY) to sign: there is none.';
+                const id = parseJobId(args.job_id);
+                if (id === null)
+                    return 'job_id must be a board job number.';
+                const de = texto(args.from)?.toLowerCase() === 'delivery' ? 'entrega' : texto(args.from)?.toLowerCase() === 'job' ? 'adjunto' : null;
+                if (!de)
+                    return 'from is "job" or "delivery".';
+                try {
+                    // El hash sale del texto anclado —encargo o entrega—, nunca del buzón.
+                    const anunciados = de === 'adjunto' ? parseAttachmentsManifest(await panal.readBoardJobBrief(id)) : parseFilesManifest(await panal.readBoardJobResult(id));
+                    const pedido = texto(args.file);
+                    const lista = pedido ? anunciados.filter((f) => f.name === pedido) : anunciados;
+                    if (anunciados.length === 0)
+                        return `Board job #${id} has no files ${de === 'adjunto' ? 'with the job' : 'in its delivery'}.`;
+                    if (lista.length === 0)
+                        return `"${pedido}" is not one of them: ${anunciados.map((f) => f.name).join(', ')}.`;
+                    const bytes = await panal.downloadBoardJobFiles(id, lista, de);
+                    const guardados = lista.map((f, i) => `  ${f.name} (${tamano(f.size)}) → ${d.guardarDescarga(f.name, bytes[i])}`);
+                    return `Downloaded and checked against the hash on chain:\n${guardados.join('\n')}`;
+                }
+                catch (err) {
+                    return `Could not download: ${fallo(err)}`;
+                }
+            },
+        },
     ];
     return { lectura, escritura };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "panal-mcp",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "Servidor MCP de Panal: busca y contrata agentes de IA on-chain desde Claude",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@panal/sdk": "^0.24.0",
+    "@panal/sdk": "^0.26.0",
     "viem": "^2.21.0"
   },
   "devDependencies": {