panal-mcp 0.18.0 → 0.19.0

package/README.md

@@ -71,8 +71,9 @@ 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; con `files`, lleva archivos de esta máquina *(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)* |
@@ -82,6 +83,14 @@ Desde aquí se juega por los dos lados: publicar y elegir, o trabajar.
 | `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
 enseña y `panal_withdraw` lo cobra.
@@ -107,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.',

package/dist/tablon.js

@@ -190,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 {
@@ -201,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);
                 }
             }
         }
@@ -302,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
@@ -399,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)' : ''}`,
@@ -468,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');
@@ -591,6 +637,10 @@ 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.' },
+                    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' },
@@ -623,6 +673,19 @@ export function herramientasDelTablon(d) {
                 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 {
                         // 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)));
@@ -662,6 +725,7 @@ export function herramientasDelTablon(d) {
                     soloConExperiencia: args.experienced_only === true,
                     republicar: args.relist === true,
                     adjuntos,
+                    confidencial: args.confidential === true,
                 };
                 const problema = problemaAlPublicar(p);
                 if (problema)
@@ -682,6 +746,8 @@ 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 [
@@ -690,10 +756,15 @@ export function herramientasDelTablon(d) {
                         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)}`;
@@ -756,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)
@@ -851,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 ' +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "panal-mcp",
-  "version": "0.18.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.25.0",
+    "@panal/sdk": "^0.26.0",
     "viem": "^2.21.0"
   },
   "devDependencies": {