create-panal-agent 0.18.0 → 0.20.0

package/dist/i18n.js

@@ -87,6 +87,8 @@ The language is taken from --lang, then PANAL_LANG, then your system locale.`,
         x402: 'Charge per call (optional). Leave it empty and your agent only takes escrow jobs.\nThe price is per request, in an EIP-2612 token — it cannot be MON, the scheme needs `permit`.',
         subcontrata: "Subcontracting (optional, off by default). Your agent can pay another one for what it cannot do itself (see ctx.consultar in agent.ts). Without a number here it never delegates.\nIt is in the x402 currency, NOT a cut of what you charge per task: a task is paid in MON and a question in $PANAL, and converting one into the other by eye would be inventing the budget. Put it BELOW what you charge per question (X402_PRICE): at or above it, every job where you delegate leaves you nothing and you still pay the gas — and that punishes exactly what you want your agent to do, because the better it recognises what it does not know, the more often it works for free. A third of your price is a sane start. The number alone is not enough: you also need the SUBCONTRATA_SKILLS list in agent.ts, which says WHAT it may buy. Empty — as it ships — it never delegates, because the marketplace search generalises when it finds nobody, and a code agent asking for \"python video encoding\" would end up searching \"video\" and paying an agent that makes videos.",
         vigilante: "The watchman. Every 60 s it reviews your open tasks and recovers what got stuck: a delivery that was never anchored, work that died halfway, or a job that was paid for and never arrived.\nVIGILANTE=off turns it off. PUBLIC_URL is your https endpoint, used in the lost-job warning.",
+        retirada: "Automatic withdrawal. The escrow credits each approved job inside the contract and pays nothing until someone calls withdraw. Every 60 min this agent collects it: MON when gas is at most 2 % of the amount, $PANAL from 1000. It needs a little MON for gas, and never runs while a job is in progress.\nRETIRADA=off turns it off.",
+        tablon: "The board: take on your own the jobs posted without an agent. OFF unless TABLON=on, because taking one is a promise to deliver it before its deadline. It only takes a job in your currency, paying at least your registry price, with TABLON_MARGEN_MINUTOS of deadline left, whose public blurb mentions one of your skills or of TABLON_PALABRAS (comma-separated). One per round, never while you are working on another.",
         memoria: "Conversation memory (x402 only). Without it every paid call is independent: the client asks, you answer, and next time you do not know what it was about -- that is a search box with an invoice, not a chat.\nMEMORIA_TURNOS=0 turns it off. Both caps exist because the history goes INTO the prompt, and you pay for the prompt while the client pays a fixed price per message.",
         seguridad: "Hardening. LIMITE_POR_MINUTO caps requests per IP (0 disables it); every unauthenticated request costs one RPC call, so without a cap a curl loop leaves your agent unable to deliver.\nTRAS_PROXY=1 if a reverse proxy sits in front (Caddy, nginx) — the usual case, since your endpoint must be https. Without it every request arrives with the proxy's IP, so the cap above stops being per client and becomes a single global one shared by the indexer, browsers and your clients; once it fills, your agent answers 429 to everyone, and a client who cannot send you their brief waits out the deadline with their payment already locked. With no proxy, leave it off: trusting that header without one lets anyone invent an IP per request. AUTH_ESTRICTA=1 rejects download signatures with no expiry (the old format).",
     },
@@ -194,6 +196,8 @@ El idioma sale de --lang, luego de PANAL_LANG, y si no del locale del sistema.`,
         x402: 'Cobro por llamada (opcional). Déjalo vacío y tu agente solo acepta encargos del escrow.\nEl precio es por petición, en un token EIP-2612: no puede ser MON, el esquema necesita `permit`.',
         subcontrata: "Subcontratar (opcional, apagado por defecto). Tu agente puede pagar a otro por lo que no sepa hacer (ver ctx.consultar en agent.ts). Sin un numero aqui, no delega nunca.\nVa en la moneda del x402 y NO se deduce de lo que cobras por tarea: una tarea se cobra en MON y una consulta en $PANAL, y convertir una en otra a ojo seria inventarse el presupuesto. Ponlo POR DEBAJO de lo que cobras por consulta (X402_PRICE): igual o por encima, cada encargo en el que delegues no te deja nada y encima pones el gas — y eso castiga justo lo que quieres que haga, porque cuanto mejor reconozca lo que no sabe, más veces trabaja gratis. Un tercio de tu precio es un buen punto de partida. Con el número no basta: hace falta además la lista SUBCONTRATA_SKILLS en agent.ts, que dice QUÉ puede comprar. Vacía —como viene— no delega nunca, porque el buscador del mercado generaliza cuando no encuentra a nadie, y un agente de código que pida \"python video encoding\" acabaría buscando \"video\" y pagándole a uno que hace vídeos.",
         vigilante: "El vigilante. Cada 60 s repasa tus tareas abiertas y recupera lo que se quedo colgado: una entrega que no llego a anclarse, un trabajo que murio a medias, o un encargo pagado que nunca llego.\nVIGILANTE=off lo apaga. PUBLIC_URL es tu endpoint https, para el aviso de encargo perdido.",
+        retirada: "Retirada automatica. El escrow acredita cada encargo aprobado dentro del contrato y no paga nada hasta que alguien llama a withdraw. Cada 60 min este agente lo recoge: el MON cuando el gas no pasa del 2 % de lo retirado, el $PANAL a partir de 1000. Necesita un poco de MON para el gas y nunca corre con un encargo en marcha.\nRETIRADA=off la apaga.",
+        tablon: "El tablon: coger solo los encargos publicados sin agente. APAGADO salvo TABLON=on, porque coger uno es comprometerse a entregarlo antes del plazo. Solo coge un encargo en tu moneda, que pague al menos tu precio del registro, con TABLON_MARGEN_MINUTOS de plazo por delante y cuyo anuncio mencione una de tus habilidades o de TABLON_PALABRAS (separadas por comas). Uno por ronda, nunca mientras trabajas otro.",
         memoria: "Memoria de la conversación (sólo x402). Sin ella cada llamada cobrada es independiente: el cliente pregunta, contestas, y a la siguiente no sabes de qué se hablaba — eso es un buscador con factura, no un chat.\nMEMORIA_TURNOS=0 la apaga. Los dos topes existen porque el historial entra EN el prompt, y el prompt lo pagas tú mientras el cliente paga un precio fijo por mensaje.",
         seguridad: "Endurecimiento. LIMITE_POR_MINUTO acota las peticiones por IP (0 lo desactiva); cada petición sin autenticar cuesta una llamada al RPC, así que sin tope un bucle de curl deja a tu agente sin poder entregar.\nTRAS_PROXY=1 si tienes un proxy delante (Caddy, nginx), que es lo normal porque tu endpoint tiene que ser https. Sin esto todas las peticiones llegan con la IP del proxy, así que el tope de arriba deja de ser por cliente y pasa a ser uno global que comparten el indexador, los navegadores y tus clientes; cuando se llena, tu agente responde 429 a todo el mundo, y un cliente que no puede mandarte su brief se queda esperando al plazo con el pago ya bloqueado. Sin proxy, déjalo apagado: fiarse de esa cabecera sin proxy permite inventarse una IP por petición. AUTH_ESTRICTA=1 rechaza las firmas de descarga sin caducidad (el formato antiguo).",
     },
@@ -302,6 +306,8 @@ const zh = {
         x402: '按次收费（可选）。留空则你的代理只接受托管订单。\n价格按每次请求计算，使用支持 EIP-2612 的代币——不能是 MON，该方案依赖 `permit`。',
         subcontrata: "转包（可选，默认关闭）。你的代理可以为自己做不了的事付钱给另一个代理（见 agent.ts 的 ctx.consultar）。这里没有数字就永远不会转包。\n它使用 x402 的币种，不是按任务收入的比例：任务用 MON 结算，提问用 $PANAL，凭感觉换算等于凭空编造预算。 把它设得低于你每次提问的收费（X402_PRICE）：等于或高于该值时，每一笔你转包出去的活都赚不到钱，还要自付 gas——而这恰恰惩罚了你希望它做的事，因为它越善于识别自己不懂的部分，就越经常白干。取你价格的三分之一是个合理的起点。 光有数字还不够：还需要 agent.ts 里的 SUBCONTRATA_SKILLS 列表，它规定了可以买什么。默认为空，也就永远不会转包；因为市场搜索在找不到人时会自动泛化，一个请求 \"python video encoding\" 的代码代理最后会搜索 \"video\"，把钱付给做视频的代理。",
         vigilante: "守望者。每 60 秒检查一次你未完成的任务，并挽回卡住的部分：没有上链的交付、中途死掉的工作，或已付款却从未送达的委托。\nVIGILANTE=off 可关闭。PUBLIC_URL 是你的 https 端点，用于丢失委托的提醒。",
+        retirada: "自动提取。托管合约会把每个已批准的委托记在合约里，在有人调用 withdraw 之前不会付款。这个代理每 60 分钟收取一次：当 Gas 不超过提取金额的 2 % 时提取 MON，$PANAL 从 1000 起提取。需要少量 MON 支付 Gas，委托进行中时不会运行。\nRETIRADA=off 可关闭。",
+        tablon: "任务板：自动接取未指定代理的委托。默认关闭，只有 TABLON=on 才开启，因为接下委托就等于承诺在截止前交付。只接以你的币种支付、金额不低于你在注册表中的价格、剩余时间至少 TABLON_MARGEN_MINUTOS 分钟、且公开说明中提到你某项技能或 TABLON_PALABRAS（逗号分隔）中某个词的委托。每轮一个，处理其他委托时从不接新的。",
         memoria: "对话记忆（仅限 x402）。没有它，每次付费调用都是独立的：客户提问，你回答，下一次你不知道之前在谈什么——那是带账单的搜索框，不是聊天。\nMEMORIA_TURNOS=0 可关闭。两个上限的存在是因为历史会进入提示词，而提示词由你付费，客户只付固定的每条消息价格。",
         seguridad: "加固。LIMITE_POR_MINUTO 限制每个 IP 的请求数（0 表示关闭）；每个未认证请求都要消耗一次 RPC 调用，没有上限时一个 curl 循环就能让你的代理无法交付。\nTRAS_PROXY=1 前面有反向代理时使用（Caddy、nginx）——这是常态，因为你的端点必须是 https。不设置时所有请求都带着代理的 IP，上面的上限就不再是每个客户端的，而变成由索引器、浏览器和你的客户共用的全局上限；一旦填满，你的代理会对所有人返回 429，而无法发送任务书的客户只能带着已锁定的付款等到期限。没有代理时请保持关闭：无代理却信任该请求头，任何人都能为每个请求伪造 IP。 AUTH_ESTRICTA=1 拒绝没有有效期的下载签名（旧格式）。",
     },
@@ -405,6 +411,8 @@ const hi = {
         x402: 'प्रति कॉल शुल्क (वैकल्पिक)। खाली छोड़ें तो आपका एजेंट केवल एस्क्रो वाले काम लेगा।\nकीमत प्रति अनुरोध है, EIP-2612 टोकन में — MON नहीं चल सकता, इस योजना को `permit` चाहिए।',
         subcontrata: "सबकॉन्ट्रैक्टिंग (वैकल्पिक, डिफ़ॉल्ट रूप से बंद)। आपका एजेंट जो खुद नहीं कर सकता, उसके लिए दूसरे को भुगतान कर सकता है (agent.ts में ctx.consultar देखें)। यहाँ संख्या के बिना वह कभी नहीं सौंपता।\nयह x402 की मुद्रा में है, प्रति कार्य आय का हिस्सा नहीं: कार्य MON में और प्रश्न $PANAL में चुकाया जाता है। इसे अपने प्रति-प्रश्न शुल्क (X402_PRICE) से कम रखें: बराबर या अधिक होने पर, जिस भी काम में आप दूसरे को सौंपेंगे उसमें कुछ नहीं बचेगा और गैस भी आपकी जेब से जाएगी — और यह ठीक उसी व्यवहार को दंडित करता है जो आप चाहते हैं, क्योंकि आपका एजेंट जितना बेहतर पहचानेगा कि उसे क्या नहीं आता, उतनी ही बार वह मुफ़्त काम करेगा। अपने दाम का एक तिहाई एक समझदार शुरुआत है। सिर्फ़ संख्या काफ़ी नहीं: agent.ts में SUBCONTRATA_SKILLS सूची भी चाहिए, जो बताती है कि वह क्या खरीद सकता है। खाली — जैसा यह आता है — तो वह कभी नहीं सौंपता, क्योंकि कोई न मिलने पर बाज़ार की खोज सामान्यीकरण कर देती है, और \"python video encoding\" माँगने वाला कोड एजेंट अंत में \"video\" खोजकर वीडियो बनाने वाले को भुगतान कर देगा।",
         vigilante: "प्रहरी। हर 60 सेकंड में आपके खुले कार्यों की जाँच करता है और जो अटक गया उसे वापस लाता है: वह डिलीवरी जो चेन पर दर्ज नहीं हुई, अधूरा रह गया काम, या भुगतान किया गया आदेश जो कभी नहीं पहुँचा।\nVIGILANTE=off इसे बंद करता है। PUBLIC_URL आपका https एंडपॉइंट है।",
+        retirada: "स्वचालित निकासी। एस्क्रो हर स्वीकृत आदेश को कॉन्ट्रैक्ट के अंदर जमा करता है और जब तक कोई withdraw न बुलाए, कुछ नहीं भेजता। यह एजेंट हर 60 मिनट में इसे निकालता है: MON तब, जब गैस निकाली गई राशि के 2 % से अधिक न हो, और $PANAL 1000 से। गैस के लिए थोड़ा MON चाहिए, और कोई आदेश चलते समय यह कभी नहीं चलता।\nRETIRADA=off इसे बंद करता है।",
+        tablon: "टास्क बोर्ड: बिना एजेंट के पोस्ट किए गए काम खुद उठाएँ। TABLON=on न हो तो बंद, क्योंकि कोई काम उठाना उसे समय-सीमा से पहले देने का वादा है। यह केवल वही काम उठाता है जो आपकी मुद्रा में हो, कम से कम आपकी रजिस्ट्री कीमत दे, जिसमें TABLON_MARGEN_MINUTOS मिनट की समय-सीमा बची हो, और जिसके सार्वजनिक विवरण में आपका कोई कौशल या TABLON_PALABRAS (कॉमा से अलग) का कोई शब्द हो। हर दौर में एक, और किसी दूसरे काम के चलते कभी नहीं।",
         memoria: "बातचीत की स्मृति (केवल x402)। इसके बिना हर सशुल्क कॉल स्वतंत्र होती है: ग्राहक पूछता है, आप उत्तर देते हैं, और अगली बार आपको पता नहीं होता कि बात किस बारे में थी — वह चैट नहीं, बिल वाला सर्च बॉक्स है।\nMEMORIA_TURNOS=0 इसे बंद कर देता है। दोनों सीमाएँ इसलिए हैं कि इतिहास प्रॉम्प्ट में जाता है, और प्रॉम्प्ट का भुगतान आप करते हैं जबकि ग्राहक प्रति संदेश निश्चित मूल्य देता है।",
         seguridad: "सुरक्षा सख्ती। LIMITE_POR_MINUTO प्रति IP अनुरोध सीमित करता है (0 से बंद); हर बिना प्रमाणित अनुरोध एक RPC कॉल खर्च करता है, इसलिए बिना सीमा के एक curl लूप आपके एजेंट को डिलीवर करने से रोक सकता है।\nTRAS_PROXY=1 अगर आगे रिवर्स प्रॉक्सी हो (Caddy, nginx) — यही सामान्य है, क्योंकि आपका एंडपॉइंट https होना चाहिए। इसके बिना हर अनुरोध प्रॉक्सी के IP के साथ आता है, इसलिए ऊपर की सीमा प्रति-क्लाइंट नहीं रहती और एक वैश्विक सीमा बन जाती है जिसे इंडेक्सर, ब्राउज़र और आपके क्लाइंट साझा करते हैं; भर जाने पर आपका एजेंट सबको 429 देता है, और जो क्लाइंट अपना ब्रीफ़ नहीं भेज पाता वह भुगतान लॉक होने के बावजूद समय-सीमा तक इंतज़ार करता है। प्रॉक्सी न हो तो बंद रखें: बिना प्रॉक्सी उस हेडर पर भरोसा करने से कोई भी हर अनुरोध में मनमाना IP भेज सकता है। AUTH_ESTRICTA=1 बिना समय-सीमा वाले डाउनलोड हस्ताक्षर अस्वीकार करता है।",
     },
@@ -512,6 +520,8 @@ const ar = {
         x402: 'التحصيل لكل استدعاء (اختياري). اتركه فارغًا فيقبل وكيلك مهام الضمان فقط.\nالسعر لكل طلب، بعملة تدعم EIP-2612 — لا يصلح MON، فالمخطط يحتاج `permit`.',
         subcontrata: "التعاقد من الباطن (اختياري، معطل افتراضيا). يمكن لوكيلك ان يدفع لوكيل اخر مقابل ما لا يجيده (انظر ctx.consultar في agent.ts). بدون رقم هنا لن يفوض ابدا.\nيكون بعملة x402، وليس نسبة مما تتقاضاه عن المهمة: المهمة تدفع بـ MON والسؤال بـ $PANAL. اجعله أقل من سعر السؤال لديك (X402_PRICE): فعند التساوي أو الزيادة، كل مهمة تُسنِد فيها جزءًا إلى غيرك لا تُبقي لك شيئًا وتدفع الغاز من جيبك — وهذا يعاقب تحديدًا ما تريده منه، لأنه كلما أحسن إدراك ما يجهله عمل مجانًا أكثر. ثلث سعرك بداية معقولة. الرقم وحده لا يكفي: تحتاج أيضًا إلى قائمة SUBCONTRATA_SKILLS في agent.ts، التي تحدد ما الذي يُسمح بشرائه. وهي فارغة كما تأتي، فلا يفوّض أبدًا؛ لأن بحث السوق يعمّم عندما لا يجد أحدًا، فوكيل برمجة يطلب \"python video encoding\" ينتهي به الأمر باحثًا عن \"video\" ودافعًا لوكيل يصنع الفيديو.",
         vigilante: "الحارس. كل 60 ثانية يراجع مهامك المفتوحة ويستعيد ما تعطل: تسليم لم يثبت على السلسلة، او عمل مات في منتصفه، او طلب مدفوع لم يصل قط.\nVIGILANTE=off يوقفه. PUBLIC_URL هو نقطة الوصول https لديك.",
+        retirada: "السحب التلقائي. يقيد الضمان كل طلب معتمد داخل العقد ولا يدفع شيئا حتى يستدعي احد withdraw. يجمعه هذا الوكيل كل 60 دقيقة: MON عندما لا يتجاوز الغاز 2 % من المبلغ، و$PANAL ابتداء من 1000. يحتاج قليلا من MON للغاز، ولا يعمل ابدا اثناء تنفيذ طلب.\nRETIRADA=off يوقفه.",
+        tablon: "لوحة المهام: التقاط الطلبات المنشورة بلا وكيل بنفسك. معطلة ما لم يكن TABLON=on، لأن التقاط طلب يعني الالتزام بتسليمه قبل موعده. لا يلتقط إلا طلبا بعملتك، يدفع على الاقل سعرك في السجل، يبقى من مهلته TABLON_MARGEN_MINUTOS دقيقة، ويذكر اعلانه العلني احدى مهاراتك او كلمة من TABLON_PALABRAS (مفصولة بفواصل). طلب واحد في كل جولة، وابدا اثناء العمل على غيره.",
         memoria: "ذاكرة المحادثة (في x402 فقط). بدونها تكون كل مكالمة مدفوعة مستقلة: يسأل العميل، تجيب، وفي المرة التالية لا تعرف عمّا كان الحديث — هذا مربع بحث بفاتورة، لا محادثة.\nالقيمة MEMORIA_TURNOS=0 تُعطّلها. الحدّان موجودان لأن السجل يدخل في التوجيه، والتوجيه تدفعه أنت بينما يدفع العميل سعرًا ثابتًا لكل رسالة.",
         seguridad: "تقوية. LIMITE_POR_MINUTO يحد الطلبات لكل IP (0 يعطله)؛ كل طلب غير موثق يكلف استدعاء RPC، فبدون حد يكفي حلقة curl لتترك وكيلك عاجزا عن التسليم.\nTRAS_PROXY=1 إذا كان أمامه بروكسي عكسي (Caddy أو nginx) — وهو الوضع المعتاد لأن نقطة النهاية يجب أن تكون https. بدونه تصل كل الطلبات بعنوان IP الخاص بالبروكسي، فيتوقف الحد أعلاه عن كونه لكل عميل ويصبح حدًا عامًا واحدًا يتقاسمه المفهرس والمتصفحات وعملاؤك؛ وعند امتلائه يرد وكيلك بـ 429 على الجميع، ويظل العميل الذي تعذر عليه إرسال مهمته ينتظر انتهاء المهلة ودفعته محجوزة بالفعل. بلا بروكسي اتركه معطلًا: الوثوق بهذه الترويسة دون بروكسي يتيح لأي شخص اختلاق عنوان IP لكل طلب. AUTH_ESTRICTA=1 يرفض تواقيع التنزيل بلا انتهاء صلاحية.",
     },
@@ -618,6 +628,8 @@ La langue vient de --lang, puis de PANAL_LANG, puis de la locale du système.`,
         x402: "Facturation à l'appel (facultatif). Laissez vide et votre agent ne prend que des missions sous entiercement.\nLe prix est par requête, dans un jeton EIP-2612 : pas de MON, le schéma exige `permit`.",
         subcontrata: "Sous-traitance (optionnelle, desactivee par defaut). Votre agent peut payer un autre pour ce qu il ne sait pas faire (voir ctx.consultar dans agent.ts). Sans un nombre ici, il ne delegue jamais.\nC est dans la devise x402, PAS une part de ce que vous facturez par tache : une tache se paie en MON et une question en $PANAL. Mettez-le EN DESSOUS de ce que vous facturez par question (X402_PRICE) : à égalité ou au-dessus, chaque travail où vous déléguez ne vous laisse rien et vous payez encore le gaz — et cela pénalise précisément ce que vous attendez de lui, car mieux il reconnaît ce qu'il ignore, plus souvent il travaille gratuitement. Un tiers de votre prix est un bon départ. Le nombre ne suffit pas : il faut aussi la liste SUBCONTRATA_SKILLS dans agent.ts, qui dit CE QU'il peut acheter. Vide — comme elle arrive — il ne délègue jamais, car la recherche du marché généralise quand elle ne trouve personne, et un agent de code demandant \"python video encoding\" finirait par chercher \"video\" et payer un agent qui fait des vidéos.",
         vigilante: "La sentinelle. Toutes les 60 s, elle passe en revue vos taches ouvertes et recupere ce qui est reste bloque : une livraison jamais ancree, un travail mort a mi-chemin, ou une commande payee qui n est jamais arrivee.\nVIGILANTE=off la desactive. PUBLIC_URL est votre endpoint https.",
+        retirada: "Retrait automatique. L escrow credite chaque commande approuvee dans le contrat et ne verse rien tant que personne n appelle withdraw. Toutes les 60 min, cet agent le recupere : le MON quand le gas ne depasse pas 2 % du montant, le $PANAL a partir de 1000. Il faut un peu de MON pour le gas, et il ne tourne jamais pendant une commande en cours.\nRETIRADA=off le desactive.",
+        tablon: "Le tableau : prendre soi-meme les commandes publiees sans agent. DESACTIVE sauf TABLON=on, car en prendre une engage a la livrer avant son echeance. Il ne prend qu une commande dans votre monnaie, payant au moins votre prix du registre, avec TABLON_MARGEN_MINUTOS minutes d echeance devant elle, et dont l annonce publique mentionne une de vos competences ou un mot de TABLON_PALABRAS (separes par des virgules). Une par tour, jamais pendant que vous en traitez une autre.",
         memoria: "Mémoire de la conversation (x402 uniquement). Sans elle, chaque appel payé est indépendant : le client demande, vous répondez, et la fois suivante vous ignorez de quoi il s'agissait — c'est un moteur de recherche avec facture, pas une conversation.\nMEMORIA_TURNOS=0 la désactive. Les deux plafonds existent parce que l'historique entre DANS le prompt, et le prompt c'est vous qui le payez pendant que le client paie un prix fixe par message.",
         seguridad: "Durcissement. LIMITE_POR_MINUTO limite les requêtes par IP (0 le désactive) ; chaque requête non authentifiée coûte un appel RPC, donc sans plafond une boucle curl empêche votre agent de livrer.\nTRAS_PROXY=1 si un proxy inverse se trouve devant (Caddy, nginx) — le cas habituel, puisque votre endpoint doit être en https. Sans cela, toutes les requêtes arrivent avec l'IP du proxy : la limite ci-dessus cesse d'être par client et devient une limite globale partagée par l'indexeur, les navigateurs et vos clients ; une fois pleine, votre agent répond 429 à tout le monde, et un client qui ne peut pas vous envoyer sa commande attend l'échéance avec son paiement déjà bloqué. Sans proxy, laissez-le désactivé : faire confiance à cet en-tête sans proxy permet d'inventer une IP par requête. AUTH_ESTRICTA=1 rejette les signatures de téléchargement sans expiration.",
     },
@@ -728,6 +740,8 @@ O idioma vem de --lang, depois de PANAL_LANG e, por fim, do locale do sistema.`,
         x402: 'Cobrança por chamada (opcional). Deixe vazio e o seu agente só aceita trabalhos do escrow.\nO preço é por pedido, num token EIP-2612: não pode ser MON, o esquema precisa de `permit`.',
         subcontrata: "Subcontratar (opcional, desligado por omissao). O seu agente pode pagar a outro pelo que nao sabe fazer (ver ctx.consultar em agent.ts). Sem um numero aqui, nunca delega.\nVai na moeda do x402 e NAO e uma fatia do que cobra por tarefa: uma tarefa paga-se em MON e uma pergunta em $PANAL. Põe-no ABAIXO do que cobras por pergunta (X402_PRICE): igual ou acima, cada trabalho em que delegues não te deixa nada e ainda pagas o gás — e isso penaliza exactamente o que queres que ele faça, porque quanto melhor reconhecer o que não sabe, mais vezes trabalha de graça. Um terço do teu preço é um começo sensato. O número não chega: é preciso também a lista SUBCONTRATA_SKILLS em agent.ts, que diz O QUE pode comprar. Vazia — como vem — nunca delega, porque a busca do mercado generaliza quando não encontra ninguém, e um agente de código que peça \"python video encoding\" acabaria a procurar \"video\" e a pagar a um que faz vídeos.",
         vigilante: "O vigia. A cada 60 s reve as suas tarefas abertas e recupera o que ficou preso: uma entrega que nunca foi ancorada, trabalho que morreu a meio, ou uma encomenda paga que nunca chegou.\nVIGILANTE=off desliga-o. PUBLIC_URL e o seu endpoint https.",
+        retirada: "Levantamento automatico. O escrow credita cada encomenda aprovada dentro do contrato e nao paga nada ate alguem chamar withdraw. A cada 60 min este agente recolhe-o: o MON quando o gas nao passa de 2 % do montante, o $PANAL a partir de 1000. Precisa de um pouco de MON para o gas e nunca corre com uma encomenda em curso.\nRETIRADA=off desliga-o.",
+        tablon: "O quadro: apanhar sozinho as encomendas publicadas sem agente. DESLIGADO salvo TABLON=on, porque apanhar uma e comprometer-se a entrega-la antes do prazo. So apanha uma encomenda na sua moeda, que pague pelo menos o seu preco do registo, com TABLON_MARGEN_MINUTOS minutos de prazo pela frente e cujo anuncio publico mencione uma das suas competencias ou de TABLON_PALABRAS (separadas por virgulas). Uma por ronda, nunca enquanto trata de outra.",
         memoria: "Memória da conversa (só x402). Sem ela cada chamada paga é independente: o cliente pergunta, respondes, e da próxima vez não sabes do que se falava — isso é uma caixa de pesquisa com fatura, não um chat.\nMEMORIA_TURNOS=0 desliga-a. Os dois limites existem porque o histórico entra NO prompt, e o prompt pagas tu enquanto o cliente paga um preço fixo por mensagem.",
         seguridad: "Endurecimento. LIMITE_POR_MINUTO limita os pedidos por IP (0 desativa); cada pedido não autenticado custa uma chamada RPC, por isso sem limite um ciclo de curl deixa o seu agente sem poder entregar.\nTRAS_PROXY=1 se houver um proxy reverso à frente (Caddy, nginx) — o normal, já que o teu endpoint tem de ser https. Sem isso todos os pedidos chegam com o IP do proxy, portanto o limite acima deixa de ser por cliente e passa a ser um único limite global partilhado pelo indexador, pelos navegadores e pelos teus clientes; quando enche, o teu agente responde 429 a toda a gente, e um cliente que não consegue enviar-te o pedido fica à espera do prazo com o pagamento já bloqueado. Sem proxy, deixa-o desligado: confiar nesse cabeçalho sem proxy permite inventar um IP por pedido. AUTH_ESTRICTA=1 rejeita assinaturas de descarga sem validade.",
     },
@@ -836,6 +850,8 @@ const ru = {
         x402: 'Плата за вызов (необязательно). Оставьте пустым — агент будет брать только заказы через эскроу.\nЦена за один запрос, в токене с EIP-2612: MON не подходит, схеме нужен `permit`.',
         subcontrata: "Субподряд (необязательно, по умолчанию выключен). Ваш агент может заплатить другому за то, чего не умеет сам (см. ctx.consultar в agent.ts). Без числа здесь он никогда не делегирует.\nУказывается в валюте x402, а НЕ долей от оплаты за задачу: задача оплачивается в MON, а вопрос в $PANAL. Поставьте НИЖЕ того, что берёте за вопрос (X402_PRICE): при равенстве или выше каждая работа, где вы делегируете, не приносит ничего, а газ вы платите сами — и это наказывает ровно то поведение, которого вы добиваетесь: чем лучше агент понимает, чего не знает, тем чаще работает даром. Треть вашей цены — разумное начало. Одного числа мало: нужен ещё список SUBCONTRATA_SKILLS в agent.ts, который говорит, ЧТО можно покупать. Пустой — а таким он и поставляется — и агент никогда не делегирует, потому что поиск по рынку обобщает запрос, если никого не нашёл: агент по коду, попросивший \"python video encoding\", в итоге станет искать \"video\" и заплатит тому, кто делает видео.",
         vigilante: "Сторож. Каждые 60 с проверяет ваши открытые задачи и вытаскивает то, что застряло: доставку, которая не попала в блокчейн, работу, оборвавшуюся на середине, или оплаченный заказ, который так и не пришел.\nVIGILANTE=off выключает его. PUBLIC_URL ваш https-эндпоинт.",
+        retirada: "Автоматический вывод. Эскроу зачисляет каждый одобренный заказ внутри контракта и ничего не отправляет, пока кто-то не вызовет withdraw. Каждые 60 мин этот агент забирает средства: MON, когда газ не больше 2 % от суммы, $PANAL от 1000. Нужно немного MON на газ, и вывод никогда не запускается во время выполнения заказа.\nRETIRADA=off выключает его.",
+        tablon: "Доска заданий: самостоятельно брать задания, опубликованные без агента. ВЫКЛЮЧЕНО, пока нет TABLON=on: взять задание значит обязаться сдать его до срока. Берётся только задание в вашей валюте, оплачивающее не меньше вашей цены в реестре, с запасом срока не меньше TABLON_MARGEN_MINUTOS минут и с публичным описанием, где упомянут один из ваших навыков или слово из TABLON_PALABRAS (через запятую). Одно за раунд и никогда во время работы над другим.",
         memoria: "Память разговора (только x402). Без неё каждый оплаченный вызов независим: клиент спрашивает, вы отвечаете, а в следующий раз вы не знаете, о чём шла речь — это поисковая строка со счётом, а не чат.\nMEMORIA_TURNOS=0 отключает её. Оба предела существуют потому, что история попадает В промпт, а промпт оплачиваете вы, тогда как клиент платит фиксированную цену за сообщение.",
         seguridad: "Усиление защиты. LIMITE_POR_MINUTO ограничивает запросы с одного IP (0 отключает); каждый неаутентифицированный запрос стоит одного вызова RPC, поэтому без лимита цикл curl лишает агента возможности сдавать работу.\nTRAS_PROXY=1 если впереди стоит обратный прокси (Caddy, nginx) — обычный случай, ведь ваш эндпоинт должен быть https. Без этого все запросы приходят с IP прокси, поэтому лимит выше перестаёт быть на клиента и становится единым глобальным, который делят индексатор, браузеры и ваши клиенты; когда он заполняется, ваш агент отвечает 429 всем, а клиент, не сумевший отправить задание, ждёт истечения срока с уже заблокированной оплатой. Без прокси оставьте выключенным: доверять этому заголовку без прокси — значит позволить подделывать IP в каждом запросе. AUTH_ESTRICTA=1 отклоняет подписи скачивания без срока действия.",
     },
@@ -945,6 +961,8 @@ const bn = {
         x402: 'প্রতি কলে চার্জ (ঐচ্ছিক)। ফাঁকা রাখলে আপনার এজেন্ট কেবল এসক্রো কাজ নেবে।\nদাম প্রতি অনুরোধে, EIP-2612 টোকেনে — MON চলবে না, স্কিমটির `permit` দরকার।',
         subcontrata: "সাবকন্ট্রাক্টিং (ঐচ্ছিক, ডিফল্টে বন্ধ)। আপনার এজেন্ট যা নিজে পারে না, তার জন্য অন্যকে অর্থ দিতে পারে (agent.ts-এ ctx.consultar দেখুন)। এখানে সংখ্যা না থাকলে সে কখনও দায়িত্ব দেয় না।\nএটি x402-এর মুদ্রায়, কাজপ্রতি আয়ের অংশ নয়: কাজের দাম MON-এ আর প্রশ্নের দাম $PANAL-এ। এটি আপনার প্রতি-প্রশ্ন মূল্যের (X402_PRICE) চেয়ে কম রাখুন: সমান বা বেশি হলে, যে কাজেই আপনি অন্যকে দেবেন তাতে কিছুই থাকবে না, গ্যাসও আপনার — আর এতে ঠিক সেই আচরণই শাস্তি পায় যা আপনি চান, কারণ এজেন্ট যত ভালোভাবে বুঝবে সে কী জানে না, তত বেশিবার সে বিনামূল্যে কাজ করবে। আপনার দামের এক-তৃতীয়াংশ একটি যুক্তিসঙ্গত শুরু। শুধু সংখ্যাই যথেষ্ট নয়: agent.ts-এ SUBCONTRATA_SKILLS তালিকাও লাগে, যা বলে দেয় সে কী কিনতে পারবে। খালি — যেমনটা আসে — হলে সে কখনও দায়িত্ব দেয় না, কারণ কাউকে না পেলে বাজারের খোঁজ সাধারণীকরণ করে, আর \"python video encoding\" চাওয়া কোড এজেন্ট শেষে \"video\" খুঁজে ভিডিও বানায় এমন কাউকে টাকা দিয়ে বসবে।",
         vigilante: "প্রহরী। প্রতি ৬০ সেকেন্ডে আপনার খোলা কাজগুলি দেখে এবং আটকে যাওয়া জিনিস উদ্ধার করে: চেইনে না ওঠা ডেলিভারি, মাঝপথে মরে যাওয়া কাজ, বা টাকা দেওয়া হয়েছে অথচ কখনও পৌঁছায়নি এমন আদেশ।\nVIGILANTE=off এটি বন্ধ করে। PUBLIC_URL আপনার https এন্ডপয়েন্ট।",
+        retirada: "স্বয়ংক্রিয় উত্তোলন। এসক্রো প্রতিটি অনুমোদিত আদেশ চুক্তির ভিতরে জমা রাখে এবং কেউ withdraw না ডাকা পর্যন্ত কিছু পাঠায় না। এই এজেন্ট প্রতি ৬০ মিনিটে তা তোলে: MON, যখন গ্যাস তোলা অঙ্কের ২ % এর বেশি নয়, আর $PANAL ১০০০ থেকে। গ্যাসের জন্য সামান্য MON লাগে, এবং কোনো আদেশ চলার সময় এটি কখনও চলে না।\nRETIRADA=off এটি বন্ধ করে।",
+        tablon: "টাস্ক বোর্ড: এজেন্ট ছাড়া পোস্ট করা কাজ নিজে নিজে তুলে নিন। TABLON=on না থাকলে বন্ধ, কারণ কাজ নেওয়া মানে সময়সীমার আগে জমা দেওয়ার প্রতিশ্রুতি। এটি শুধু সেই কাজ নেয় যা আপনার মুদ্রায়, অন্তত আপনার রেজিস্ট্রি দামের সমান দেয়, যাতে TABLON_MARGEN_MINUTOS মিনিট সময় বাকি, আর যার প্রকাশ্য বিবরণে আপনার কোনো দক্ষতা বা TABLON_PALABRAS (কমা দিয়ে আলাদা) এর কোনো শব্দ আছে। প্রতি দফায় একটি, অন্য কাজ চলার সময় কখনও নয়।",
         memoria: "কথোপকথনের স্মৃতি (কেবল x402)। এটি ছাড়া প্রতিটি অর্থপ্রদত্ত কল স্বতন্ত্র: ক্লায়েন্ট জিজ্ঞাসা করে, আপনি উত্তর দেন, আর পরেরবার আপনি জানেন না কী নিয়ে কথা হচ্ছিল — সেটা চ্যাট নয়, বিলসহ সার্চ বক্স।\nMEMORIA_TURNOS=0 এটি বন্ধ করে। দুটি সীমা আছে কারণ ইতিহাস প্রম্পটে ঢোকে, আর প্রম্পটের খরচ আপনি দেন যখন ক্লায়েন্ট বার্তাপ্রতি নির্দিষ্ট দাম দেয়।",
         seguridad: "কঠোরকরণ। LIMITE_POR_MINUTO প্রতি IP অনুরোধ সীমিত করে (0 দিলে বন্ধ); প্রতিটি অননুমোদিত অনুরোধে একটি RPC কল খরচ হয়, তাই সীমা ছাড়া একটি curl লুপ আপনার এজেন্টকে ডেলিভারি করতে অক্ষম করে দেয়।\nTRAS_PROXY=1 যদি সামনে রিভার্স প্রক্সি থাকে (Caddy, nginx) — এটিই স্বাভাবিক, কারণ আপনার এন্ডপয়েন্ট https হতেই হবে। এটি ছাড়া প্রতিটি অনুরোধ প্রক্সির IP নিয়ে আসে, ফলে উপরের সীমা আর প্রতি-ক্লায়েন্ট থাকে না, বরং একটি বৈশ্বিক সীমা হয়ে যায় যা ইনডেক্সার, ব্রাউজার ও আপনার ক্লায়েন্টরা ভাগ করে; ভরে গেলে আপনার এজেন্ট সবাইকে 429 দেয়, আর যে ক্লায়েন্ট তার কাজের বিবরণ পাঠাতে পারে না সে অর্থ আটকে থাকা অবস্থায় সময়সীমা পর্যন্ত অপেক্ষা করে। প্রক্সি না থাকলে বন্ধ রাখুন: প্রক্সি ছাড়া ওই হেডারে ভরসা করলে যে কেউ প্রতি অনুরোধে IP বানিয়ে দিতে পারে। AUTH_ESTRICTA=1 মেয়াদহীন ডাউনলোড স্বাক্ষর প্রত্যাখ্যান করে।",
     },
@@ -1051,6 +1069,8 @@ const ur = {
         x402: 'فی کال وصولی (اختیاری)۔ خالی چھوڑ دیں تو آپ کا ایجنٹ صرف ایسکرو کے کام لے گا۔\nقیمت فی درخواست ہے، EIP-2612 ٹوکن میں — MON نہیں چل سکتا، اس اسکیم کو `permit` چاہیے۔',
         subcontrata: "سب کنٹریکٹنگ (اختیاری، بذریعہ ڈیفالٹ بند)۔ آپ کا ایجنٹ جو خود نہیں کر سکتا اس کے لیے دوسرے کو ادائیگی کر سکتا ہے (agent.ts میں ctx.consultar دیکھیں)۔ یہاں نمبر کے بغیر وہ کبھی نہیں سونپتا۔\nیہ x402 کی کرنسی میں ہے، فی ٹاسک آمدنی کا حصہ نہیں: ٹاسک MON میں اور سوال $PANAL میں ادا ہوتا ہے۔ اسے اپنی فی سوال قیمت (X402_PRICE) سے کم رکھیں: برابر یا زیادہ ہونے پر، جس کام میں بھی آپ کسی اور کو دیں گے اس میں کچھ نہیں بچے گا اور گیس بھی آپ کی جیب سے جائے گی — اور یہ بالکل اسی رویّے کو سزا دیتا ہے جو آپ چاہتے ہیں، کیونکہ آپ کا ایجنٹ جتنا بہتر پہچانے گا کہ اسے کیا نہیں آتا، اتنی ہی زیادہ بار وہ مفت کام کرے گا۔ اپنی قیمت کا ایک تہائی معقول آغاز ہے۔ صرف عدد کافی نہیں: agent.ts میں SUBCONTRATA_SKILLS کی فہرست بھی چاہیے، جو بتاتی ہے کہ وہ کیا خرید سکتا ہے۔ خالی — جیسا کہ یہ آتا ہے — تو وہ کبھی کام نہیں سونپتا، کیونکہ کوئی نہ ملنے پر مارکیٹ کی تلاش عام کر دیتی ہے، اور \"python video encoding\" مانگنے والا کوڈ ایجنٹ آخر میں \"video\" ڈھونڈ کر ویڈیو بنانے والے کو ادائیگی کر بیٹھے گا۔",
         vigilante: "نگہبان۔ ہر 60 سیکنڈ میں آپ کے کھلے کام دیکھتا ہے اور جو اٹکا ہے اسے بچاتا ہے: وہ ڈیلیوری جو چین پر درج نہ ہوئی، وہ کام جو بیچ میں مر گیا، یا ادا شدہ آرڈر جو کبھی نہ پہنچا۔\nVIGILANTE=off اسے بند کرتا ہے۔ PUBLIC_URL آپ کا https اینڈ پوائنٹ ہے۔",
+        retirada: "خودکار نکلوائی۔ ایسکرو ہر منظور شدہ آرڈر کو کنٹریکٹ کے اندر جمع کرتا ہے اور جب تک کوئی withdraw نہ بلائے کچھ نہیں بھیجتا۔ یہ ایجنٹ ہر 60 منٹ میں اسے نکالتا ہے: MON جب گیس نکالی گئی رقم کے 2 % سے زیادہ نہ ہو، اور $PANAL 1000 سے۔ گیس کے لیے تھوڑا MON چاہیے، اور کسی آرڈر کے دوران یہ کبھی نہیں چلتا۔\nRETIRADA=off اسے بند کرتا ہے۔",
+        tablon: "ٹاسک بورڈ: بغیر ایجنٹ کے پوسٹ کیے گئے کام خود اٹھائیں۔ TABLON=on نہ ہو تو بند، کیونکہ کام اٹھانا اسے مہلت سے پہلے دینے کا وعدہ ہے۔ یہ صرف وہ کام اٹھاتا ہے جو آپ کی کرنسی میں ہو، کم از کم آپ کی رجسٹری قیمت دے، جس کی مہلت میں TABLON_MARGEN_MINUTOS منٹ باقی ہوں، اور جس کے عوامی اعلان میں آپ کی کوئی مہارت یا TABLON_PALABRAS (کوما سے الگ) کا کوئی لفظ ہو۔ ہر دور میں ایک، اور کسی دوسرے کام کے دوران کبھی نہیں۔",
         memoria: "گفتگو کی یادداشت (صرف x402)۔ اس کے بغیر ہر ادا شدہ کال الگ ہوتی ہے: کلائنٹ پوچھتا ہے، آپ جواب دیتے ہیں، اور اگلی بار آپ کو معلوم نہیں ہوتا کہ بات کس بارے میں تھی — یہ چیٹ نہیں، بل والا سرچ باکس ہے۔\nMEMORIA_TURNOS=0 اسے بند کر دیتا ہے۔ دونوں حدیں اس لیے ہیں کہ تاریخ پرامپٹ میں جاتی ہے، اور پرامپٹ کا خرچ آپ اٹھاتے ہیں جبکہ کلائنٹ فی پیغام مقررہ قیمت دیتا ہے۔",
         seguridad: "سختی۔ LIMITE_POR_MINUTO فی IP درخواستیں محدود کرتا ہے (0 سے بند)؛ ہر غیر تصدیق شدہ درخواست ایک RPC کال خرچ کرتی ہے، اس لیے حد کے بغیر ایک curl لوپ آپ کے ایجنٹ کو ڈیلیور کرنے سے روک سکتا ہے۔\nTRAS_PROXY=1 اگر آگے ریورس پراکسی ہو (Caddy، nginx) — یہی معمول ہے، کیونکہ آپ کا اینڈ پوائنٹ https ہونا چاہیے۔ اس کے بغیر ہر درخواست پراکسی کے IP کے ساتھ آتی ہے، چنانچہ اوپر والی حد فی کلائنٹ نہیں رہتی بلکہ ایک عالمی حد بن جاتی ہے جسے انڈیکسر، براؤزر اور آپ کے کلائنٹ مل کر استعمال کرتے ہیں؛ بھر جانے پر آپ کا ایجنٹ سب کو 429 دیتا ہے، اور جو کلائنٹ اپنی ہدایت نہیں بھیج پاتا وہ ادائیگی مقفل ہونے کے باوجود مہلت تک انتظار کرتا ہے۔ پراکسی نہ ہو تو بند رکھیں: پراکسی کے بغیر اس ہیڈر پر بھروسہ کرنے سے کوئی بھی ہر درخواست میں IP گھڑ سکتا ہے۔ AUTH_ESTRICTA=1 بغیر میعاد والے ڈاؤن لوڈ دستخط مسترد کرتا ہے۔",
     },

package/dist/index.js

@@ -269,6 +269,17 @@ function writeEnvExample(dest, t) {
         'VIGILANTE_SEGUNDOS=60',
         'PUBLIC_URL=',
         '',
+        bloque(t.env.retirada),
+        'RETIRADA_MINUTOS=60',
+        'RETIRADA_MAX_GAS_PCT=2',
+        'RETIRADA_PANAL_DESDE=1000',
+        '',
+        bloque(t.env.tablon),
+        'TABLON=off',
+        'TABLON_MINUTOS=5',
+        'TABLON_MARGEN_MINUTOS=30',
+        'TABLON_PALABRAS=',
+        '',
         bloque(t.env.memoria),
         'MEMORIA_TURNOS=6',
         'MEMORIA_CHARS=4000',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-panal-agent",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "Crea un agente de IA para Panal, funcionando y cobrando on-chain, en cinco minutos",
   "type": "module",
   "license": "MIT",
@@ -42,6 +42,6 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "tsx test/i18n.test.ts && tsx test/logo.test.ts && tsx test/memoria.test.ts && tsx test/reintento.test.ts && tsx test/zip.test.ts && tsx test/adjuntos.test.ts && tsx test/subcontrata.test.ts && tsx test/salida.test.ts && tsx test/vigilante.test.ts && tsx test/scaffold.test.ts"
+    "test": "tsx test/i18n.test.ts && tsx test/logo.test.ts && tsx test/memoria.test.ts && tsx test/reintento.test.ts && tsx test/zip.test.ts && tsx test/adjuntos.test.ts && tsx test/subcontrata.test.ts && tsx test/salida.test.ts && tsx test/vigilante.test.ts && tsx test/retirada.test.ts && tsx test/tablon.test.ts && tsx test/scaffold.test.ts"
   }
 }

package/template/src/retirada.ts

@@ -0,0 +1,251 @@
+/**
+ * ────────────────────────────────────────────────────────────────────────────
+ *  La retirada automática: lo que el escrow le debe a este agente, a su wallet.
+ * ────────────────────────────────────────────────────────────────────────────
+ *
+ * POR QUÉ EXISTE. El escrow de Panal es de pago TIRADO: aprobar un encargo le
+ * ACREDITA el dinero al agente dentro del contrato, no se lo manda. Hasta que
+ * alguien llama a `withdraw`, se queda ahí. Un humano lo ve en el panel y le da
+ * al botón; un agente que corre solo, sin nadie mirando, acumulaba cobros sin
+ * recogerlos nunca. Los cuatro agentes de Panal llegaron a tener más de 2 MON y
+ * 3.000 $PANAL parados en el escrow.
+ *
+ * Este agente tiene su clave en el .env —con ella firma cada entrega—, así que
+ * puede retirar solo. Una persona que vende por el buzón no: su clave está en
+ * su wallet y nadie más puede retirar por ella, que es justo lo que protege el
+ * contrato (`withdraw` le paga siempre a quien llama).
+ *
+ * CUÁNDO RETIRA, Y POR QUÉ NO SIEMPRE. Retirar cuesta gas, y el gas se paga en
+ * MON aunque lo retirado sea $PANAL. Medido en mainnet el 2026-09-14:
+ *
+ *     retirar MON      55.157 de gas   ≈ 0,0056 MON
+ *     retirar $PANAL  103.511 de gas   ≈ 0,0106 MON
+ *
+ * Retirar 0,049 MON en cada encargo sería dejarse un 13 % por el camino. Así
+ * que:
+ *
+ *   - En MON se retira cuando el gas no pasa de `maxGasPct` de lo retirado (2 %
+ *     por defecto). Es una regla sobre el gas DE AHORA, no un número fijo: si
+ *     el gas sube, espera a que haya más; si baja, retira antes.
+ *   - En $PANAL se retira a partir de `panalDesde` (1000 por defecto). Ahí no
+ *     hay regla relativa posible: el gas es en MON y el token no tiene precio
+ *     con el que compararlo.
+ *
+ * Y en los dos casos solo si la wallet cubre la RESERVA de Monad —límite de gas
+ * × precio máximo—, que se bloquea antes de ejecutar aunque luego se cobre
+ * menos. Sin esa comprobación, el nodo rechaza con «insufficient balance» y un
+ * reintento con el mismo nonce y las mismas comisiones repite el rechazo.
+ *
+ * EL GAS SE FIJA A MANO, Y ESTO COSTÓ 1,096 MON APRENDERLO. viem no estima el
+ * gas: le pide al nodo que rellene la transacción (`eth_fillTransaction`), y el
+ * de Monad devuelve un gas disparatado justo para `withdraw(address(0))` —1,05 M
+ * para una wallet, 10,7 M para otra—, cuando lo necesario son 55.157. Y Monad
+ * cobra el LÍMITE de gas entero, no lo usado. La primera retirada automática de
+ * Lint sacó 1,092 MON y pagó 1,096 de gas (2026-09-14, tx 0xa960cb7e…). Así
+ * que el gas sale de `eth_estimateGas` —que sí da el número bueno—, con un 10 %
+ * de margen, y se pasa explícito: viem lo respeta. Y si la estimación vuelve por
+ * encima de `TOPE_GAS`, no se firma nada.
+ *
+ * NUNCA A LA VEZ QUE UNA ENTREGA. Si hay un encargo en marcha, la ronda se
+ * salta: dos transacciones seguidas de la misma wallet chocan por el nonce, y
+ * en Monad una lanzada justo después de otra revierte. Por lo mismo, entre
+ * retirar MON y retirar $PANAL se espera un rato.
+ */
+
+import type { Address, Hex } from 'viem';
+import { formatEther, parseEther } from 'viem';
+import { NATIVE_CURRENCY, escrowAbi, type PanalClient } from '@panal/sdk';
+
+export interface OpcionesRetirada {
+  /** Cada cuánto se mira el escrow, en minutos. */
+  minutos: number;
+  /** MON: retirar solo si el gas (reserva) no pasa de este % de lo retirado. */
+  maxGasPct: number;
+  /** $PANAL: retirar a partir de esta cantidad, en wei. */
+  panalDesde: bigint;
+}
+
+/**
+ * Por encima de esto una retirada no se firma. Retirar MON son 55.157 de gas y
+ * $PANAL 103.511: 300.000 deja margen de sobra para cualquier retirada honrada
+ * y corta en seco una estimación disparatada antes de que se cobre.
+ */
+export const TOPE_GAS = 300_000n;
+
+/** El gas con el que se firma: lo estimado más un 10 %. */
+export function gasConMargen(estimado: bigint): bigint {
+  return (estimado * 11n + 9n) / 10n;
+}
+
+export const RETIRADA_POR_DEFECTO: OpcionesRetirada = {
+  minutos: 60,
+  maxGasPct: 2,
+  panalDesde: parseEther('1000'),
+};
+
+/**
+ * Las opciones del .env, o `null` si está apagada (`RETIRADA=off`).
+ *
+ * Un valor que no se entiende no apaga nada ni lanza: se usa el de por defecto
+ * y se dice en el log. Un agente que se niega a arrancar por una errata en una
+ * variable opcional es peor que uno que retira con el umbral de siempre.
+ */
+export function opcionesDelEntorno(
+  env: Record<string, string | undefined>,
+  avisar: (m: string) => void = (m) => console.warn(m),
+): OpcionesRetirada | null {
+  if (env.RETIRADA?.trim().toLowerCase() === 'off') return null;
+  const o = { ...RETIRADA_POR_DEFECTO };
+
+  const minutos = Number(env.RETIRADA_MINUTOS);
+  if (env.RETIRADA_MINUTOS?.trim()) {
+    if (Number.isFinite(minutos) && minutos >= 5) o.minutos = minutos;
+    else avisar(`[retirada] RETIRADA_MINUTOS="${env.RETIRADA_MINUTOS}" no vale (mínimo 5): uso ${o.minutos}.`);
+  }
+  const pct = Number(env.RETIRADA_MAX_GAS_PCT);
+  if (env.RETIRADA_MAX_GAS_PCT?.trim()) {
+    if (Number.isFinite(pct) && pct > 0 && pct <= 50) o.maxGasPct = pct;
+    else avisar(`[retirada] RETIRADA_MAX_GAS_PCT="${env.RETIRADA_MAX_GAS_PCT}" no vale (0-50): uso ${o.maxGasPct}.`);
+  }
+  if (env.RETIRADA_PANAL_DESDE?.trim()) {
+    try {
+      o.panalDesde = parseEther(env.RETIRADA_PANAL_DESDE.trim());
+    } catch {
+      avisar(`[retirada] RETIRADA_PANAL_DESDE="${env.RETIRADA_PANAL_DESDE}" no vale: uso ${formatEther(o.panalDesde)}.`);
+    }
+  }
+  return o;
+}
+
+export interface DepsRetirada {
+  panal: PanalClient;
+  yo: Address;
+  opciones: OpcionesRetirada;
+  /** ¿Hay un encargo en marcha? Entonces no se toca la wallet. */
+  ocupado: () => boolean;
+  /** Pausa entre dos retiradas seguidas. Inyectable para las pruebas. */
+  esperar?: (ms: number) => Promise<void>;
+  log?: (m: string) => void;
+}
+
+/**
+ * Una ronda: mira lo que se debe en cada moneda y retira lo que compense.
+ *
+ * Devuelve lo que hizo, línea a línea, para que las pruebas lo puedan leer.
+ * Nunca lanza: un fallo aquí no puede tumbar el agente que atiende encargos.
+ */
+export async function repasarRetirada(deps: DepsRetirada): Promise<string[]> {
+  const log = deps.log ?? ((m: string) => console.log(m));
+  const esperar = deps.esperar ?? ((ms: number) => new Promise<void>((r) => setTimeout(r, ms)));
+  const hecho: string[] = [];
+  const anotar = (m: string): void => {
+    hecho.push(m);
+    log(m);
+  };
+
+  if (deps.ocupado()) return hecho;
+
+  const { panal, yo, opciones } = deps;
+  const monedas: Array<{ direccion: Address; simbolo: 'MON' | '$PANAL' }> = [
+    { direccion: NATIVE_CURRENCY, simbolo: 'MON' },
+    { direccion: panal.addresses.panalToken, simbolo: '$PANAL' },
+  ];
+
+  let retiradas = 0;
+  for (const { direccion, simbolo } of monedas) {
+    try {
+      const pendiente = await panal.getPendingWithdrawal(yo, direccion);
+      if (pendiente === 0n) continue;
+
+      // $PANAL: el umbral se mira antes de gastar ni una lectura más.
+      if (simbolo === '$PANAL' && pendiente < opciones.panalDesde) continue;
+
+      const llamada = {
+        address: panal.addresses.escrow,
+        abi: escrowAbi,
+        functionName: 'withdraw',
+        args: [direccion],
+      } as const;
+      const [estimado, comisiones, saldo] = await Promise.all([
+        panal.publicClient.estimateContractGas({ ...llamada, account: yo } as never),
+        panal.publicClient.estimateFeesPerGas(),
+        panal.publicClient.getBalance({ address: yo }),
+      ]);
+      const gas = gasConMargen(estimado);
+      if (gas > TOPE_GAS) {
+        anotar(
+          `[retirada] la estimación de gas para retirar ${simbolo} salió en ${estimado}, por encima del tope ` +
+            `de ${TOPE_GAS}: no se firma nada. Monad cobra el límite entero.`,
+        );
+        continue;
+      }
+      // La reserva, con el MISMO gas con el que se va a firmar.
+      const reserva = gas * comisiones.maxFeePerGas;
+
+      // MON: que el gas no se coma más de maxGasPct de lo que se retira. Se
+      // compara con la RESERVA, que es la cota alta: si compensa con ella,
+      // compensa con lo que de verdad se cobre.
+      if (simbolo === 'MON' && reserva * 10_000n > pendiente * BigInt(Math.round(opciones.maxGasPct * 100))) continue;
+
+      if (saldo < reserva) {
+        anotar(
+          `[retirada] ${formatEther(pendiente)} ${simbolo} esperan en el escrow, pero la wallet tiene ` +
+            `${formatEther(saldo)} MON y retirar reserva ${formatEther(reserva)} MON de gas. Recarga un poco de MON.`,
+        );
+        continue;
+      }
+
+      // Otra transacción de esta wallet justo antes revierte en Monad.
+      if (retiradas > 0) await esperar(20_000);
+      if (deps.ocupado()) return hecho;
+
+      const wallet = panal.walletClient;
+      if (!wallet) {
+        anotar('[retirada] el cliente no tiene cuenta para firmar: no se puede retirar.');
+        return hecho;
+      }
+      const hash: Hex = await wallet.writeContract({
+        ...llamada,
+        // Explícito. Sin esto viem le pide el gas al nodo y paga lo que diga.
+        gas,
+        chain: panal.publicClient.chain,
+        account: wallet.account ?? yo,
+      } as never);
+      // Un revert también llega con recibo: hay que mirar `status`.
+      const recibo = await panal.publicClient.waitForTransactionReceipt({ hash });
+      if (recibo.status !== 'success') {
+        anotar(`[retirada] retirar ${simbolo} revirtió (tx ${hash}): sigue acreditado, se reintenta en la próxima ronda.`);
+        continue;
+      }
+      retiradas++;
+      anotar(`[retirada] ${formatEther(pendiente)} ${simbolo} retirados a la wallet · tx ${hash}`);
+    } catch (err) {
+      anotar(`[retirada] no se pudo retirar ${simbolo}: ${err instanceof Error ? err.message.split('\n')[0] : err}`);
+    }
+  }
+  return hecho;
+}
+
+/**
+ * Arranca las rondas. La primera, a los dos minutos: el agente acaba de
+ * arrancar y lo primero es atender encargos, no mover dinero.
+ */
+export function arrancarRetirada(deps: DepsRetirada): void {
+  const { opciones } = deps;
+  console.log(
+    `Retirada automática: cada ${opciones.minutos} min · MON cuando el gas no pase del ${opciones.maxGasPct} % · ` +
+      `$PANAL desde ${formatEther(opciones.panalDesde)} (RETIRADA=off la apaga).`,
+  );
+  let enMarcha = false;
+  const ronda = async (): Promise<void> => {
+    if (enMarcha) return;
+    enMarcha = true;
+    try {
+      await repasarRetirada(deps);
+    } finally {
+      enMarcha = false;
+    }
+  };
+  setTimeout(() => void ronda(), 2 * 60_000);
+  setInterval(() => void ronda(), opciones.minutos * 60_000);
+}

package/template/src/server.ts

@@ -64,6 +64,8 @@ import { handleTask, NIVELES, SUBCONTRATA_SKILLS } from './agent.js';
 import { frasesGuardadas, pedirTraduccion } from './traduccion.js';
 import type { AdjuntoRecibido, NivelPropio, TaskContext, TaskFile, TaskResult } from './agent.js';
 import { arrancarVigilante } from './vigilante.js';
+import { arrancarRetirada, opcionesDelEntorno } from './retirada.js';
+import { arrancarTablon, opcionesDelEntorno as opcionesTablon } from './tablon.js';
 import { historialParaElModelo, recordarTurno, type Turno } from './memoria.js';
 
 const PORT = Number(process.env.PORT ?? 8787);
@@ -1896,3 +1898,44 @@ arrancarVigilante({
   },
   urlPublica: process.env.PUBLIC_URL?.trim(),
 });
+
+// La retirada automática: lo que el escrow acredita por cada encargo aprobado
+// se queda en el contrato hasta que alguien llama a `withdraw`, y un agente que
+// corre solo no tiene a nadie que le dé al botón. `RETIRADA=off` la apaga; el
+// porqué de cada umbral está en retirada.ts.
+// Mientras el tablón coge un encargo la wallet está firmando, aunque `work()`
+// todavía no haya empezado. La retirada tiene que verlo: dos transacciones
+// seguidas de la misma wallet chocan por el nonce.
+let tablonFirmando = false;
+
+const retirada = opcionesDelEntorno(process.env);
+if (retirada) {
+  arrancarRetirada({
+    panal,
+    yo: account.address,
+    opciones: retirada,
+    // La misma guarda que el vigilante: con un encargo en marcha la wallet
+    // puede estar a punto de firmar su entrega, y dos transacciones seguidas
+    // chocan por el nonce.
+    ocupado: () => inFlight.size > 0 || tablonFirmando,
+  });
+}
+
+// El tablón: coger solo los encargos publicados sin dueño que encajen con este
+// agente. APAGADO salvo `TABLON=on`: coger es comprometerse a entregar. El
+// porqué de cada regla está en tablon.ts.
+const tablon = opcionesTablon(process.env);
+if (tablon) {
+  void arrancarTablon({
+    panal,
+    yo: account.address,
+    opciones: tablon,
+    ocupado: () => inFlight.size > 0 || tablonFirmando,
+    marcar: (ocupada) => {
+      tablonFirmando = ocupada;
+    },
+    // El mismo camino que un encargo normal: guarda, trabaja, sirve la entrega
+    // desde este servidor —que es donde la busca el cliente— y la ancla.
+    trabajar: (taskId, brief) => work(taskId, brief, null),
+  });
+}

package/template/src/tablon.ts

@@ -0,0 +1,257 @@
+/**
+ * ────────────────────────────────────────────────────────────────────────────
+ *  El tablón: coger solo, sin que nadie haga clic, los encargos que encajen.
+ * ────────────────────────────────────────────────────────────────────────────
+ *
+ * QUÉ ES EL TABLÓN. Un cliente puede pagar un encargo SIN elegir agente
+ * (`createTask` con `worker = address(0)`) y colgar un anuncio público. Lo coge
+ * el primer agente activo que llame a `claimTask`. Hasta ahora solo podía
+ * hacerlo una persona desde la web; el tablón se pensó para que lo hiciera un
+ * programa.
+ *
+ * APAGADO POR DEFECTO, Y A PROPÓSITO. Coger un encargo es comprometerse a
+ * entregarlo antes del plazo, con el dinero de un desconocido bloqueado. Eso no
+ * se activa solo por actualizar la plantilla: se enciende con `TABLON=on`.
+ *
+ * QUÉ COGE. Solo lo que cumple las cuatro cosas:
+ *   - no lo publicó este mismo agente;
+ *   - paga en la moneda de este agente y AL MENOS lo que cobra por un encargo en
+ *     el registro: el agente ya decidió su precio, y el tablón no lo rebaja;
+ *   - le queda plazo de sobra (`TABLON_MARGEN_MINUTOS`);
+ *   - su anuncio menciona alguna de sus habilidades —las de su ficha en la
+ *     cadena, más `TABLON_PALABRAS`—. Es una regla simple a propósito: el
+ *     encargo de verdad solo se puede leer DESPUÉS de cogerlo, así que lo único
+ *     con qué decidir es el anuncio, y un emparejamiento predecible es mejor que
+ *     uno listo que nadie sabe explicar.
+ * Y de lo que encaja, uno por ronda: el que más paga.
+ *
+ * CÓMO LO TRABAJA. Con el mismo `work()` que un encargo normal: guarda el
+ * encargo en disco, lo trabaja, SIRVE la entrega desde este servidor y ancla su
+ * hash. El cliente recoge la entrega del `bot:` que el trabajador publica, como
+ * en cualquier encargo, así que la entrega vive aquí y no en el tablón. Y como
+ * el encargo queda en disco y la tarea asignada a este agente en la cadena, si
+ * el proceso muere a mitad el vigilante lo retoma.
+ *
+ * LA WALLET, DE UNA EN UNA. `claimTask` es una transacción. Con un encargo en
+ * marcha la ronda se salta, y después de coger se espera antes de trabajar: dos
+ * transacciones seguidas de la misma wallet chocan por el nonce, y en Monad una
+ * lanzada justo detrás de otra revierte. El gas de `claimTask` lo fija el SDK a
+ * mano desde la 0.18.3: sin eso, Monad cobra un límite inflado entero.
+ */
+
+import type { Address } from 'viem';
+import { formatEther } from 'viem';
+import type { EncargoDelTablon, PanalClient } from '@panal/sdk';
+
+export interface OpcionesTablon {
+  /** Cada cuánto se mira el tablón, en minutos. */
+  minutos: number;
+  /** Plazo que tiene que quedar, como mínimo, para cogerlo. */
+  margenMinutos: number;
+  /** Palabras que cuentan como encaje, además de las habilidades de la ficha. */
+  palabras: string[];
+}
+
+export const TABLON_POR_DEFECTO: OpcionesTablon = {
+  minutos: 5,
+  margenMinutos: 30,
+  palabras: [],
+};
+
+/**
+ * Las opciones del .env, o `null` si está apagado — que es lo normal.
+ *
+ * Solo `TABLON=on` lo enciende. Un valor numérico que no se entiende no apaga
+ * nada ni lanza: se usa el de por defecto y se dice en el log.
+ */
+export function opcionesDelEntorno(
+  env: Record<string, string | undefined>,
+  avisar: (m: string) => void = (m) => console.warn(m),
+): OpcionesTablon | null {
+  if (env.TABLON?.trim().toLowerCase() !== 'on') return null;
+  const o: OpcionesTablon = { ...TABLON_POR_DEFECTO, palabras: [] };
+
+  if (env.TABLON_MINUTOS?.trim()) {
+    const n = Number(env.TABLON_MINUTOS);
+    if (Number.isFinite(n) && n >= 1) o.minutos = n;
+    else avisar(`[tablon] TABLON_MINUTOS="${env.TABLON_MINUTOS}" no vale (mínimo 1): uso ${o.minutos}.`);
+  }
+  if (env.TABLON_MARGEN_MINUTOS?.trim()) {
+    const n = Number(env.TABLON_MARGEN_MINUTOS);
+    if (Number.isFinite(n) && n >= 5) o.margenMinutos = n;
+    else avisar(`[tablon] TABLON_MARGEN_MINUTOS="${env.TABLON_MARGEN_MINUTOS}" no vale (mínimo 5): uso ${o.margenMinutos}.`);
+  }
+  if (env.TABLON_PALABRAS?.trim()) {
+    o.palabras = env.TABLON_PALABRAS.split(',').map((p) => p.trim()).filter(Boolean);
+  }
+  return o;
+}
+
+/** Sin tildes, en minúsculas, y con guiones y barras como espacios. */
+function plano(s: string): string {
+  return s
+    .normalize('NFD')
+    .replace(/[̀-ͯ]/g, '')
+    .toLowerCase()
+    .replace(/[-_/]+/g, ' ');
+}
+
+/**
+ * ¿Menciona el anuncio alguna de estas palabras?
+ *
+ * Palabra entera, no trozo: «test» no encaja con «testimonio», y «ai» no encaja
+ * con cualquier palabra que contenga esas dos letras. Una palabra de menos de
+ * tres letras no cuenta: son justo las que aparecen por casualidad.
+ */
+export function encaja(anuncio: string, palabras: string[]): boolean {
+  const texto = ` ${plano(anuncio).replace(/[^\p{L}\p{N}]+/gu, ' ')} `;
+  return palabras.some((p) => {
+    const q = plano(p).replace(/[^\p{L}\p{N}]+/gu, ' ').trim();
+    return q.length >= 3 && texto.includes(` ${q} `);
+  });
+}
+
+export interface DepsTablon {
+  panal: PanalClient;
+  yo: Address;
+  opciones: OpcionesTablon;
+  /** Lo que este agente cobra por un encargo en el registro, y en qué moneda. */
+  precio: { amount: bigint; currency: Address };
+  /** Sus habilidades, de la ficha en la cadena. */
+  habilidades: string[];
+  /** ¿Hay un encargo en marcha? Entonces no se toca la wallet. */
+  ocupado: () => boolean;
+  /** Marca la wallet como ocupada mientras se coge y se trabaja. */
+  marcar: (ocupada: boolean) => void;
+  /** El `work()` de la plantilla: trabaja, sirve y ancla. */
+  trabajar: (taskId: bigint, brief: string) => Promise<string>;
+  /** Pausa entre coger y trabajar. Inyectable para las pruebas. */
+  esperar?: (ms: number) => Promise<void>;
+  log?: (m: string) => void;
+}
+
+/** Lo que se puede coger de lo que hay publicado, del que más paga al que menos. */
+export function candidatos(
+  lista: EncargoDelTablon[],
+  deps: Pick<DepsTablon, 'yo' | 'precio' | 'habilidades' | 'opciones'>,
+  ahoraS: number,
+): EncargoDelTablon[] {
+  const palabras = [...deps.habilidades, ...deps.opciones.palabras];
+  return lista
+    .filter((e) => e.cliente.toLowerCase() !== deps.yo.toLowerCase())
+    .filter((e) => e.currency.toLowerCase() === deps.precio.currency.toLowerCase())
+    .filter((e) => e.amount >= deps.precio.amount)
+    .filter((e) => Number(e.deadline) - ahoraS >= deps.opciones.margenMinutos * 60)
+    .filter((e) => encaja(e.anuncio, palabras))
+    .sort((a, b) => (b.amount > a.amount ? 1 : b.amount < a.amount ? -1 : 0));
+}
+
+/**
+ * Una ronda: mira el tablón y, si algo encaja, lo coge y lo trabaja.
+ *
+ * Devuelve lo que hizo, línea a línea, para las pruebas. Nunca lanza: un fallo
+ * aquí no puede tumbar el agente que atiende sus encargos normales.
+ */
+export async function repasarTablon(deps: DepsTablon): Promise<string[]> {
+  const log = deps.log ?? ((m: string) => console.log(m));
+  const esperar = deps.esperar ?? ((ms: number) => new Promise<void>((r) => setTimeout(r, ms)));
+  const hecho: string[] = [];
+  const anotar = (m: string): void => {
+    hecho.push(m);
+    log(m);
+  };
+
+  if (deps.ocupado()) return hecho;
+
+  let lista: EncargoDelTablon[];
+  try {
+    lista = await deps.panal.listBoard({ limit: 30 });
+  } catch (err) {
+    anotar(`[tablon] no se pudo leer el tablón: ${err instanceof Error ? err.message.split('\n')[0] : err}`);
+    return hecho;
+  }
+  const elegido = candidatos(lista, deps, Math.floor(Date.now() / 1000))[0];
+  if (!elegido) return hecho;
+
+  deps.marcar(true);
+  try {
+    try {
+      await deps.panal.claimTask(elegido.taskId);
+    } catch (err) {
+      // Lo normal aquí es que otro lo cogiera antes: el tablón es de quien llega
+      // primero. No es un fallo del agente.
+      anotar(`[tablon] #${elegido.taskId} no se pudo coger: ${err instanceof Error ? err.message.split('\n')[0] : err}`);
+      return hecho;
+    }
+    anotar(
+      `[tablon] #${elegido.taskId} cogido · ${formatEther(elegido.amount)} · «${elegido.anuncio.slice(0, 80)}»`,
+    );
+
+    // Dos transacciones seguidas de la misma wallet chocan en Monad.
+    await esperar(15_000);
+
+    let brief: string;
+    try {
+      brief = await deps.panal.readBoardBrief(elegido.taskId);
+    } catch (err) {
+      // Cogido y sin encargo: el cliente pagó pero no dejó el texto. El vigilante
+      // lo seguirá avisando; aquí no hay nada más que hacer.
+      anotar(`[tablon] #${elegido.taskId} cogido pero sin encargo que leer: ${err instanceof Error ? err.message.split('\n')[0] : err}`);
+      return hecho;
+    }
+
+    const r = await deps.trabajar(elegido.taskId, brief);
+    anotar(`[tablon] #${elegido.taskId} ${r === 'entregada' ? 'entregado' : `sin entregar todavía (${r}): lo retoma el vigilante`}`);
+    return hecho;
+  } catch (err) {
+    anotar(`[tablon] #${elegido.taskId}: ${err instanceof Error ? err.message.split('\n')[0] : err}`);
+    return hecho;
+  } finally {
+    deps.marcar(false);
+  }
+}
+
+/**
+ * Arranca las rondas. Lee de la cadena el precio y las habilidades de este
+ * agente una vez, al arrancar: son los que decidió su dueño.
+ */
+export async function arrancarTablon(
+  deps: Omit<DepsTablon, 'precio' | 'habilidades'>,
+): Promise<void> {
+  let precio: DepsTablon['precio'];
+  let habilidades: string[];
+  try {
+    const ficha = await deps.panal.getAgent(deps.yo);
+    if (!ficha.active) {
+      console.warn('[tablon] este agente no está activo en el registro: claimTask lo rechazaría. Tablón apagado.');
+      return;
+    }
+    precio = { amount: ficha.pricePerTask, currency: ficha.currency };
+    habilidades = ficha.metadata.skills ?? [];
+  } catch (err) {
+    console.warn(`[tablon] no se pudo leer la ficha: ${err instanceof Error ? err.message : err}. Tablón apagado.`);
+    return;
+  }
+  if (habilidades.length + deps.opciones.palabras.length === 0) {
+    console.warn('[tablon] sin habilidades en la ficha ni TABLON_PALABRAS: nada con qué decidir. Tablón apagado.');
+    return;
+  }
+
+  const completas: DepsTablon = { ...deps, precio, habilidades };
+  console.log(
+    `Tablón: cada ${deps.opciones.minutos} min · desde ${formatEther(precio.amount)} en su moneda · ` +
+      `con ${deps.opciones.margenMinutos} min de plazo como mínimo · ${habilidades.length + deps.opciones.palabras.length} palabras.`,
+  );
+  let enMarcha = false;
+  const ronda = async (): Promise<void> => {
+    if (enMarcha) return;
+    enMarcha = true;
+    try {
+      await repasarTablon(completas);
+    } finally {
+      enMarcha = false;
+    }
+  };
+  setTimeout(() => void ronda(), 60_000);
+  setInterval(() => void ronda(), deps.opciones.minutos * 60_000);
+}