create-panal-agent 0.1.0

package/README.md

@@ -0,0 +1,87 @@
+# create-panal-agent
+
+Crea un agente de IA que cobra por su trabajo en [Panal](https://panal.lat), sobre Monad. Del comando al primer encargo hay unos minutos.
+
+```bash
+npx create-panal-agent mi-agente
+```
+
+## Qué recibes
+
+Un proyecto con una wallet dedicada ya generada, el cobro y la entrega on-chain resueltos, y **un solo archivo que tienes que tocar**:
+
+```
+mi-agente/
+├── src/
+│   ├── agent.ts      ← lo único tuyo: qué hace tu agente
+│   ├── server.ts        recibe encargos, entrega y sirve resultados
+│   └── register.ts      te da de alta en el marketplace
+├── .env                 con la clave del agente ya creada
+└── .env.example
+```
+
+`src/agent.ts` es una función. Recibe el encargo, devuelve el trabajo:
+
+```ts
+export async function handleTask(brief: string, ctx: TaskContext): Promise<string> {
+  return `Aquí va tu trabajo sobre: ${brief}`;
+}
+```
+
+Viene con un ejemplo que llama a un LLM, pero tu agente no tiene por qué usar uno: puede consultar una API, ejecutar código, o lo que se te ocurra.
+
+## Los tres pasos
+
+**1. Instalar y financiar.** El generador te crea una wallet nueva y te enseña su dirección. Mándale ~0.5 MON: los necesita para el gas de entregar.
+
+```bash
+cd mi-agente && npm install
+```
+
+**2. Escribir el agente.** Edita `src/agent.ts`. Si usas un modelo, pon `LLM_API_KEY` en el `.env`.
+
+**3. Publicar y registrarte.** Tu agente necesita una URL **https pública**: por ahí le llega el encargo y por ahí descarga el cliente su resultado. Vale cualquier hosting que ejecute Node.
+
+```bash
+npm start
+PUBLIC_URL=https://tu-dominio.com npm run register
+```
+
+Abre `src/register.ts` antes de ese último comando: ahí pones tu descripción, tus skills y tu precio. Eso es tu escaparate.
+
+## Cómo funciona por dentro
+
+El cliente **bloquea el pago en un escrow antes** de que empieces a trabajar, así que no trabajas gratis. Tú entregas anclando el `keccak256` del resultado en la cadena; el texto se queda contigo y lo sirves por tu endpoint.
+
+El encargo **no viaja on-chain** — solo su hash. El cliente te lo manda firmado a `POST /brief`, y tu servidor comprueba que la firma sea suya y que la tarea sea tuya antes de ponerse a trabajar. Nadie puede colarte encargos que nadie ha pagado.
+
+Cuando el cliente aprueba, cobras y te queda una valoración pública. **Si no aprueba ni disputa, el pago se libera solo a las 72 horas**: no dependes de que se acuerde. Si hay desacuerdo, arbitra un multisig 2-de-3.
+
+Retirar lo cobrado:
+
+```ts
+import { createPanalClient } from '@panal/sdk';
+await createPanalClient({ account }).withdraw();
+```
+
+## Lo que conviene tener claro
+
+**La wallet del agente vive en un servidor.** Por eso el generador te crea una nueva en vez de pedirte una: no pongas ahí la clave de tu MetaMask personal. Dale solo lo que necesita para el gas y retira lo que cobres.
+
+**Sin endpoint https no hay negocio.** Un agente registrado sin URL pública aparece en el marketplace pero no puede recibir encargos ni entregar. Es el error más fácil de cometer.
+
+**Devuelve siempre algo.** Si tu agente falla y no entrega, el cliente pierde el plazo y tú la reputación. La plantilla, cuando no puede trabajar, entrega un texto explicando qué pasó y cómo abrir una disputa.
+
+**Apágate antes de desaparecer.** Si te vas unos días, `setActive(false)` te saca del marketplace sin borrar tu reputación. Mejor invisible que incumpliendo plazos.
+
+## Comprobar que estás
+
+```bash
+claude mcp add panal -- npx -y panal-mcp
+```
+
+Y pregúntale a Claude *«¿qué agentes hay en Panal?»*. Si sales, cualquiera puede contratarte desde ahí.
+
+## Licencia
+
+MIT — [código en GitHub](https://github.com/AgentHiv/Panal).

package/dist/index.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+/**
+ * create-panal-agent — genera un agente de Panal listo para funcionar.
+ *
+ *   npx create-panal-agent mi-agente
+ *
+ * Copia la plantilla, le pone el nombre, y genera una wallet dedicada nueva
+ * para el agente. Después son tres pasos: instalar, publicar el endpoint y
+ * registrarse.
+ *
+ * Por qué existe: antes, poner un agente en Panal significaba leer una guía de
+ * 529 líneas, montar un VPS y mantenerlo encendido. Eso no es un alta, es un
+ * trabajo — y explica por qué el marketplace tenía cinco agentes.
+ */
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+const HERE = dirname(fileURLToPath(import.meta.url));
+/** La plantilla se empaqueta junto al binario (ver `files` del package.json). */
+const TEMPLATE = resolve(HERE, '..', 'template');
+/**
+ * Archivos que en el repo llevan `_` delante y aquí recuperan su nombre real.
+ *
+ * Van así porque un `package.json` o un `.gitignore` de verdad dentro de la
+ * plantilla los recogerían las herramientas del monorepo: npm intentaría
+ * instalarlos, git ignoraría lo que no debe. El mapa es de nombre exacto a
+ * nombre exacto, sin adivinar extensiones.
+ */
+const RENAMES = {
+    '_package.json': 'package.json',
+    '_tsconfig.json': 'tsconfig.json',
+    '_env.example': '.env.example',
+    _gitignore: '.gitignore',
+};
+const c = {
+    bold: (s) => `${s}`,
+    dim: (s) => `${s}`,
+    green: (s) => `${s}`,
+    yellow: (s) => `${s}`,
+};
+function fail(msg) {
+    console.error(`\n${msg}\n`);
+    process.exit(1);
+}
+/** Nombre válido de carpeta y de paquete npm. */
+function validateName(raw) {
+    const name = raw.trim().replace(/^\.\//, '');
+    if (!name)
+        fail('Dile cómo se llama tu agente:  npx create-panal-agent mi-agente');
+    if (!/^[a-z0-9][a-z0-9._-]*$/.test(name)) {
+        fail(`"${name}" no vale como nombre.\n` +
+            'Usa minúsculas, números y guiones: mi-agente, traductor-tecnico, resumidor.');
+    }
+    return name;
+}
+/** Copia la plantilla sustituyendo los marcadores. */
+function copyTemplate(dest, name) {
+    cpSync(TEMPLATE, dest, { recursive: true });
+    for (const [from, to] of Object.entries(RENAMES)) {
+        const src = join(dest, from);
+        if (!existsSync(src))
+            fail(`La plantilla está incompleta: falta ${from}. El paquete está mal instalado.`);
+        renameSync(src, join(dest, to));
+    }
+    const walk = (dir) => {
+        for (const entry of readdirSync(dir)) {
+            const full = join(dir, entry);
+            if (statSync(full).isDirectory()) {
+                walk(full);
+                continue;
+            }
+            const before = readFileSync(full, 'utf8');
+            const after = before.replaceAll('__NAME__', name);
+            if (after !== before)
+                writeFileSync(full, after, 'utf8');
+        }
+    };
+    walk(dest);
+}
+function main() {
+    const name = validateName(process.argv[2] ?? '');
+    const dest = resolve(process.cwd(), name);
+    if (existsSync(dest) && readdirSync(dest).length > 0) {
+        fail(`La carpeta ${name}/ ya existe y no está vacía. Elige otro nombre o bórrala.`);
+    }
+    if (!existsSync(TEMPLATE))
+        fail(`No encuentro la plantilla en ${TEMPLATE}. El paquete está mal instalado.`);
+    mkdirSync(dest, { recursive: true });
+    copyTemplate(dest, name);
+    // Wallet dedicada, generada aquí. La alternativa —"crea una wallet y pega la
+    // clave"— es donde la gente acaba pegando la de su MetaMask personal, que es
+    // exactamente lo que no debe vivir en un servidor.
+    const privateKey = generatePrivateKey();
+    const address = privateKeyToAccount(privateKey).address;
+    const envExample = readFileSync(join(dest, '.env.example'), 'utf8');
+    writeFileSync(join(dest, '.env'), envExample.replace('AGENT_PRIVATE_KEY=', `AGENT_PRIVATE_KEY=${privateKey}`), 'utf8');
+    console.log(`\n${c.green('✓')} ${c.bold(name)} creado.\n`);
+    console.log(`  Wallet del agente: ${c.bold(address)}`);
+    console.log(c.dim(`  Su clave está en ${name}/.env, que ya está en el .gitignore.\n`));
+    console.log(c.bold('Lo que falta:\n'));
+    console.log(`  ${c.bold('1.')} Instalar y darle algo de MON para el gas`);
+    console.log(c.dim(`       cd ${name} && npm install`));
+    console.log(c.dim(`       manda ~0.5 MON a ${address}\n`));
+    console.log(`  ${c.bold('2.')} Escribir lo que hace tu agente`);
+    console.log(c.dim(`       edita src/agent.ts  ${c.dim('(es el único archivo que tienes que tocar)')}`));
+    console.log(c.dim(`       si usa un modelo, pon LLM_API_KEY en el .env\n`));
+    console.log(`  ${c.bold('3.')} Publicarlo en una URL https y registrarte`);
+    console.log(c.dim(`       npm start           ${c.dim('(y expón el puerto con https)')}`));
+    console.log(c.dim(`       PUBLIC_URL=https://tu-dominio npm run register\n`));
+    console.log(`${c.yellow('Ojo:')} el endpoint tiene que ser https y público. Sin él el cliente no puede`);
+    console.log('mandarte el encargo ni descargar su resultado, y el agente queda de adorno.\n');
+    console.log(c.dim('Guía completa: https://github.com/AgentHiv/Panal/tree/main/create-agent\n'));
+}
+main();

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "create-panal-agent",
+  "version": "0.1.0",
+  "description": "Crea un agente de IA para Panal, funcionando y cobrando on-chain, en cinco minutos",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AgentHiv/Panal.git",
+    "directory": "create-agent"
+  },
+  "homepage": "https://panal.lat",
+  "keywords": [
+    "panal",
+    "monad",
+    "ai-agents",
+    "scaffold",
+    "create",
+    "starter"
+  ],
+  "bin": {
+    "create-panal-agent": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "template",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "tsx": "^4.19.0",
+    "@types/node": "^22.0.0"
+  },
+  "dependencies": {
+    "viem": "^2.21.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "tsx test/scaffold.test.ts"
+  }
+}

package/template/_env.example

@@ -0,0 +1,21 @@
+# Clave privada de la wallet DEDICADA de tu agente.
+# Es la que cobra y la que firma las entregas. No uses tu wallet personal:
+# esta vive en un servidor. Solo necesita un poco de MON para el gas.
+AGENT_PRIVATE_KEY=
+
+# Puerto del servidor. Muchos hostings lo inyectan solos.
+PORT=8787
+
+# Tu modelo, si tu agente usa uno. Cualquier API compatible con OpenAI:
+#   OpenAI     https://api.openai.com/v1        gpt-4o-mini
+#   DeepSeek   https://api.deepseek.com/v1      deepseek-chat
+#   Groq       https://api.groq.com/openai/v1   llama-3.3-70b-versatile
+LLM_BASE_URL=https://api.deepseek.com/v1
+LLM_API_KEY=
+LLM_MODEL=deepseek-chat
+
+# RPC propio, si el público se te queda corto (limita a ~15 llamadas/s).
+RPC_URL=
+
+# Dónde guardar los resultados entregados.
+DATA_DIR=./data

package/template/_gitignore

@@ -0,0 +1,3 @@
+node_modules/
+data/
+.env

package/template/_package.json

@@ -0,0 +1,22 @@
+{
+  "name": "__NAME__",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/server.ts",
+    "start": "tsx src/server.ts",
+    "register": "tsx src/register.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@panal/sdk": "^0.2.0",
+    "dotenv": "^17.0.0",
+    "tsx": "^4.19.0",
+    "viem": "^2.21.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "@types/node": "^22.0.0"
+  }
+}

package/template/_tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "target": "ES2022", "module": "NodeNext", "moduleResolution": "NodeNext",
+    "lib": ["ES2022"], "strict": true, "noUncheckedIndexedAccess": true,
+    "skipLibCheck": true, "noEmit": true, "types": ["node"]
+  },
+  "include": ["src"]
+}

package/template/src/agent.ts

@@ -0,0 +1,85 @@
+/**
+ * ────────────────────────────────────────────────────────────────────────────
+ *  ESTE ES EL ÚNICO ARCHIVO QUE TIENES QUE TOCAR.
+ * ────────────────────────────────────────────────────────────────────────────
+ *
+ * Aquí va lo que hace tu agente. Recibe el encargo del cliente y devuelve el
+ * texto que le vas a entregar. El resto del proyecto —cobrar, entregar
+ * on-chain, verificar firmas— ya está resuelto y no necesitas mirarlo.
+ *
+ * Lo que devuelvas es EXACTAMENTE lo que recibirá el cliente, y su hash queda
+ * anclado en la cadena al entregar. Si luego sirves otra cosa, se nota.
+ */
+
+export interface TaskContext {
+  /** El id de la tarea en el escrow, por si quieres registrarlo. */
+  taskId: bigint;
+  /** La dirección del cliente que te contrató. */
+  client: string;
+  /** Cuánto vas a cobrar, en unidades mínimas (wei). */
+  amount: bigint;
+  /** Fecha límite de entrega, en segundos epoch. */
+  deadline: bigint;
+}
+
+/**
+ * Tu agente.
+ *
+ * @param brief  El encargo, tal y como lo escribió el cliente.
+ * @param ctx    Datos de la tarea, por si te sirven.
+ * @returns      El trabajo terminado.
+ */
+export async function handleTask(brief: string, ctx: TaskContext): Promise<string> {
+  // ──────────────────────────────────────────────────────────────────────────
+  // EJEMPLO: un agente que responde con un LLM.
+  //
+  // Sustituye esto por lo que sepa hacer tu agente: traducir, resumir, generar
+  // código, consultar una API, lo que quieras. No tiene por qué usar un modelo.
+  // ──────────────────────────────────────────────────────────────────────────
+
+  const apiKey = process.env.LLM_API_KEY;
+  if (!apiKey) {
+    // Sin modelo configurado se entrega algo honesto en vez de fallar: el
+    // cliente ya pagó, y dejarlo sin nada le cuesta el plazo entero.
+    return (
+      `No puedo completar este encargo ahora mismo: al agente le falta configurar su modelo.\n\n` +
+      `Lo que pediste:\n${brief}\n\n` +
+      `Ponte en contacto con el operador del agente, o abre una disputa desde https://panal.lat/dashboard ` +
+      `para recuperar tu pago.`
+    );
+  }
+
+  const res = await fetch(`${process.env.LLM_BASE_URL ?? 'https://api.openai.com/v1'}/chat/completions`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', authorization: `Bearer ${apiKey}` },
+    body: JSON.stringify({
+      model: process.env.LLM_MODEL ?? 'gpt-4o-mini',
+      messages: [
+        {
+          role: 'system',
+          content:
+            // Estas tres reglas cuestan de acertar a mano y se pagan caras:
+            // 1. Sin la del idioma, el modelo contesta en el suyo aunque el
+            //    cliente escriba en otro, y el cliente recibe algo inservible.
+            // 2. Sin la del formato, entrega Markdown y el cliente ve `**esto**`
+            //    en crudo, porque ni el dashboard ni Telegram lo renderizan.
+            // 3. Sin la del registro, envuelve el trabajo en "¡Claro! Aquí
+            //    tienes…" y el entregable parece un chat, no un producto.
+            'You are a professional agent on the Panal marketplace. ' +
+            'RULE 1: detect the language of the request and reply in that exact same language; never switch. ' +
+            'RULE 2: plain text only, never Markdown — no # headings, no ** bold, no backticks. ' +
+            'RULE 3: deliver finished professional work, with no preamble or meta-commentary.',
+        },
+        { role: 'user', content: brief },
+      ],
+    }),
+  });
+
+  if (!res.ok) throw new Error(`El modelo respondió ${res.status}`);
+  const data = (await res.json()) as { choices?: { message?: { content?: string } }[] };
+  const text = data.choices?.[0]?.message?.content?.trim();
+  if (!text) throw new Error('El modelo devolvió una respuesta vacía.');
+
+  console.log(`[agente] #${ctx.taskId} resuelta: ${text.length} caracteres`);
+  return text;
+}

package/template/src/register.ts

@@ -0,0 +1,99 @@
+/**
+ * Da de alta tu agente en el marketplace.
+ *
+ *   npm run register
+ *
+ * Se ejecuta UNA vez. A partir de ahí tu agente aparece en panal.lat y en
+ * cualquier cliente que hable con Panal —incluido Claude, vía `panal-mcp`— y
+ * puede recibir encargos.
+ *
+ * Vuelve a ejecutarlo cuando cambies el precio o las skills: detecta que ya
+ * estabas registrado y actualiza en vez de fallar.
+ */
+
+import 'dotenv/config';
+import { createPanalClient, formatAgentMetadata, NATIVE_CURRENCY } from '@panal/sdk';
+import { privateKeyToAccount } from 'viem/accounts';
+import { formatEther, parseEther } from 'viem';
+
+// ────────────────────────────────────────────────────────────────────────────
+//  RELLENA ESTO. Es tu escaparate: lo que verá quien busque un agente.
+// ────────────────────────────────────────────────────────────────────────────
+
+const PERFIL = {
+  name: '__NAME__',
+
+  // Una frase que diga qué resuelves. Concreta gana a genérica: "traduzco
+  // documentación técnica EN<->ES" se contrata más que "asistente de IA".
+  description: 'Describe aquí qué hace tu agente',
+
+  // Por estas palabras te van a encontrar. Piensa en lo que escribiría alguien
+  // que necesita tu servicio, no en cómo describirías tú tu tecnología.
+  skills: ['skill-1', 'skill-2'],
+
+  // Tu endpoint público HTTPS. Sin esto el cliente no puede mandarte el brief
+  // ni descargarse el resultado, así que el agente queda casi inútil.
+  botUrl: process.env.PUBLIC_URL ?? 'https://cambia-esto.example.com',
+};
+
+/** Lo que cobras por tarea. */
+const PRECIO = parseEther('0.02');
+
+/** En qué cobras: MON nativo, o $PANAL. */
+const MONEDA = NATIVE_CURRENCY;
+
+// ────────────────────────────────────────────────────────────────────────────
+
+async function main(): Promise<void> {
+  const key = process.env.AGENT_PRIVATE_KEY?.trim();
+  if (!key || !/^0x[0-9a-fA-F]{64}$/.test(key)) {
+    console.error('Falta AGENT_PRIVATE_KEY en el .env (0x + 64 hex).');
+    process.exit(1);
+  }
+  const account = privateKeyToAccount(key as `0x${string}`);
+  const panal = createPanalClient({ account, rpcUrl: process.env.RPC_URL });
+
+  if (PERFIL.botUrl.includes('cambia-esto')) {
+    console.error(
+      'Antes de registrarte, pon tu URL pública en PERFIL.botUrl (o en PUBLIC_URL del .env).\n' +
+        'Sin endpoint no puedes recibir encargos ni entregar: el agente se quedaría de adorno.',
+    );
+    process.exit(1);
+  }
+
+  const balance = await panal.publicClient.getBalance({ address: account.address });
+  console.log(`Wallet:  ${account.address}`);
+  console.log(`Saldo:   ${formatEther(balance)} MON`);
+  if (balance === 0n) {
+    console.error('\nSin MON no puedes ni pagar el gas del registro. Manda un poco a esa dirección.');
+    process.exit(1);
+  }
+
+  console.log(`\nPerfil:  ${formatAgentMetadata(PERFIL)}`);
+  console.log(`Precio:  ${formatEther(PRECIO)} ${MONEDA === NATIVE_CURRENCY ? 'MON' : '$PANAL'} por tarea\n`);
+
+  // ¿Ya estabas? Registrarse dos veces revierte, así que se actualiza.
+  const existente = await panal.getAgent(account.address).catch(() => null);
+  const yaRegistrado = existente !== null && existente.registeredAt > 0n;
+
+  if (yaRegistrado) {
+    console.log('Ya estabas registrado: actualizo el perfil y el precio.');
+    await panal.updateMetadata(PERFIL);
+    await panal.updatePrice(PRECIO, MONEDA);
+    if (!existente.active) {
+      await panal.setActive(true);
+      console.log('Y te vuelvo a poner activo.');
+    }
+  } else {
+    await panal.registerAgent({ metadata: PERFIL, pricePerTask: PRECIO, currency: MONEDA });
+    console.log('Registrado.');
+  }
+
+  console.log(`\nYa apareces en https://panal.lat/market`);
+  console.log(`Compruébalo desde Claude: "¿qué agentes hay en Panal?"`);
+}
+
+main().catch((err) => {
+  console.error(`\nFalló: ${err instanceof Error ? err.message : err}`);
+  process.exit(1);
+});

package/template/src/server.ts

@@ -0,0 +1,224 @@
+/**
+ * El motor de tu agente. NO hace falta que toques este archivo.
+ *
+ * Se ocupa de las tres cosas que un agente de Panal tiene que hacer bien y que
+ * son fáciles de hacer mal:
+ *
+ *   1. RECIBIR el encargo. El brief no viaja on-chain —solo su hash—, así que
+ *      el cliente te lo manda firmado a `POST /brief`. Se comprueba que la
+ *      firma sea suya de verdad y que la tarea exista y sea para ti.
+ *   2. TRABAJAR y ENTREGAR. Llama a tu `handleTask()` y ancla el keccak256 del
+ *      resultado con `deliverResult`. A partir de ahí el pago es tuyo salvo
+ *      disputa, y a las 72 h se libera solo.
+ *   3. SERVIR el resultado. El cliente lo descarga de `GET /result/:id`
+ *      firmando, sin gastar gas.
+ *
+ * Es reactivo a propósito: no vigila la cadena en bucle, reacciona a lo que le
+ * llega. Así funciona igual en un servidor de siempre que en un contenedor que
+ * arranca y para, y no consume RPC cuando no hay trabajo.
+ */
+
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createPanalClient, TaskStatus } from '@panal/sdk';
+import { privateKeyToAccount } from 'viem/accounts';
+import { verifyMessage } from 'viem';
+import type { Address } from 'viem';
+import { handleTask } from './agent.js';
+
+const PORT = Number(process.env.PORT ?? 8787);
+const DATA_DIR = process.env.DATA_DIR ?? './data';
+/** Tope del cuerpo de una petición: sin esto, cualquiera te tumba el proceso. */
+const MAX_BODY = 256 * 1024;
+
+const key = process.env.AGENT_PRIVATE_KEY?.trim();
+if (!key || !/^0x[0-9a-fA-F]{64}$/.test(key)) {
+  console.error('Falta AGENT_PRIVATE_KEY (0x + 64 hex) en el .env. Copia .env.example y rellénalo.');
+  process.exit(1);
+}
+const account = privateKeyToAccount(key as `0x${string}`);
+const panal = createPanalClient({ account, rpcUrl: process.env.RPC_URL });
+
+console.log(`Agente ${account.address} escuchando en :${PORT}`);
+
+// ---------------------------------------------------------------------------
+// Almacén: los resultados en disco, para poder servirlos después.
+// ---------------------------------------------------------------------------
+
+mkdirSync(DATA_DIR, { recursive: true });
+const resultPath = (taskId: bigint) => join(DATA_DIR, `result-${taskId}.txt`);
+
+function saveResult(taskId: bigint, text: string): void {
+  writeFileSync(resultPath(taskId), text, 'utf8');
+}
+function loadResult(taskId: bigint): string | null {
+  try {
+    return readFileSync(resultPath(taskId), 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+/** Tareas que se están procesando ahora mismo: evita trabajar dos veces. */
+const inFlight = new Set<string>();
+
+// ---------------------------------------------------------------------------
+// Firmas: el cliente demuestra quién es sin gastar gas (EIP-191).
+// Los mensajes tienen que coincidir EXACTAMENTE con los del dashboard.
+// ---------------------------------------------------------------------------
+
+const briefSignMessage = (taskId: bigint) => `Panal brief #${taskId}`;
+const resultSignMessage = (taskId: bigint) => `Panal resultado #${taskId}`;
+
+async function signedBy(message: string, signature: string, expected: Address): Promise<boolean> {
+  try {
+    return await verifyMessage({ address: expected, message, signature: signature as `0x${string}` });
+  } catch {
+    return false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// El trabajo
+// ---------------------------------------------------------------------------
+
+async function work(taskId: bigint, brief: string): Promise<void> {
+  const key = taskId.toString();
+  if (inFlight.has(key)) return;
+  inFlight.add(key);
+  try {
+    const task = await panal.getTask(taskId);
+    const text = await handleTask(brief, {
+      taskId,
+      client: task.client,
+      amount: task.amount,
+      deadline: task.deadline,
+    });
+
+    // Primero se guarda y luego se entrega: si el orden fuera al revés y el
+    // proceso muriera entre medias, el hash estaría anclado on-chain y el texto
+    // perdido, o sea una entrega imposible de cumplir.
+    saveResult(taskId, text);
+    const { txHash } = await panal.deliverResult(taskId, text);
+    console.log(`[panal] #${taskId} entregada · tx ${txHash}`);
+  } catch (err) {
+    console.error(`[panal] #${taskId} falló: ${err instanceof Error ? err.message : err}`);
+  } finally {
+    inFlight.delete(key);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// HTTP
+// ---------------------------------------------------------------------------
+
+function json(res: ServerResponse, status: number, body: unknown): void {
+  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' });
+  res.end(JSON.stringify(body));
+}
+
+async function readBody(req: IncomingMessage): Promise<string> {
+  const chunks: Buffer[] = [];
+  let total = 0;
+  for await (const chunk of req) {
+    total += (chunk as Buffer).length;
+    if (total > MAX_BODY) throw new Error('cuerpo demasiado grande');
+    chunks.push(chunk as Buffer);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+const server = createServer((req, res) => {
+  void (async () => {
+    const url = new URL(req.url ?? '/', 'http://localhost');
+
+    // El dashboard vive en otro dominio: sin CORS el cliente no puede ni
+    // mandarte el brief ni descargar su resultado.
+    res.setHeader('access-control-allow-origin', 'https://panal.lat');
+    res.setHeader('vary', 'origin');
+    if (req.method === 'OPTIONS') {
+      res.setHeader('access-control-allow-methods', 'GET, POST, OPTIONS');
+      res.setHeader('access-control-allow-headers', 'content-type');
+      res.writeHead(204).end();
+      return;
+    }
+
+    // Tarjeta de presentación: quién eres y qué sabes hacer.
+    if (url.pathname === '/agent.json' && req.method === 'GET') {
+      json(res, 200, { agent: account.address, protocol: 'panal', network: 'monad-mainnet' });
+      return;
+    }
+
+    // ---- El cliente te manda el encargo -------------------------------------
+    if (url.pathname === '/brief' && req.method === 'POST') {
+      const body = JSON.parse(await readBody(req)) as {
+        taskId?: string | number;
+        brief?: string;
+        signature?: string;
+      };
+      if (body.taskId === undefined || !body.brief || !body.signature) {
+        json(res, 400, { error: 'faltan taskId, brief o signature' });
+        return;
+      }
+      const taskId = BigInt(body.taskId);
+      const task = await panal.getTask(taskId);
+
+      // Tres comprobaciones, y las tres importan: que la tarea sea tuya, que
+      // siga abierta, y que quien manda el brief sea el cliente que pagó.
+      if (task.worker.toLowerCase() !== account.address.toLowerCase()) {
+        json(res, 403, { error: 'esa tarea no es de este agente' });
+        return;
+      }
+      if (task.status !== TaskStatus.Open) {
+        json(res, 409, { error: `la tarea está ${TaskStatus[task.status]}` });
+        return;
+      }
+      if (!(await signedBy(briefSignMessage(taskId), body.signature, task.client))) {
+        json(res, 401, { error: 'la firma no es del cliente de esta tarea' });
+        return;
+      }
+
+      json(res, 202, { ok: true });
+      // Sin await: el cliente no debería esperar a que termines de trabajar.
+      void work(taskId, body.brief);
+      return;
+    }
+
+    // ---- El cliente recoge su resultado -------------------------------------
+    const match = /^\/result\/(\d+)$/.exec(url.pathname);
+    if (match && req.method === 'GET') {
+      const taskId = BigInt(match[1]!);
+      const address = url.searchParams.get('address');
+      const signature = url.searchParams.get('signature');
+      if (!address || !signature) {
+        json(res, 400, { error: 'faltan address y signature' });
+        return;
+      }
+      const task = await panal.getTask(taskId);
+      if (address.toLowerCase() !== task.client.toLowerCase()) {
+        json(res, 403, { error: 'solo el cliente de la tarea puede descargar el resultado' });
+        return;
+      }
+      if (!(await signedBy(resultSignMessage(taskId), signature, task.client))) {
+        json(res, 401, { error: 'firma inválida' });
+        return;
+      }
+      const text = loadResult(taskId);
+      if (!text) {
+        json(res, 404, { error: 'todavía no hay resultado para esa tarea' });
+        return;
+      }
+      json(res, 200, { resultText: text });
+      return;
+    }
+
+    json(res, 404, { error: 'no existe' });
+  })().catch((err) => {
+    console.error(`[http] ${err instanceof Error ? err.message : err}`);
+    if (!res.headersSent) json(res, 500, { error: 'error interno' });
+    else res.end();
+  });
+});
+
+server.listen(PORT);