akemon 0.1.83 → 0.1.85

package/dist/server.js

@@ -10,7 +10,24 @@ import { spawn, exec } from "child_process";
 import { createServer } from "http";
 import { createInterface } from "readline";
 import { callAgent } from "./relay-client.js";
-import { selfDir, initWorld, initBioState, initGuide, biosPath, loadBioState, saveBioState, loadLatestIdentity, appendIdentity, loadIdentitySummary, saveIdentitySummary, loadUnsummarizedIdentities, needsIdentityCompression, onTaskCompleted, recoverEnergy, getSelfState, loadRecentCanvasEntries, gamesDir, loadGameList, loadGame, notesDir, loadNotesList, loadNote, pagesDir, loadPageList, loadPage, localNow, localNowFilename, appendImpression, loadImpressions, compressImpressions, markImpressionsDigested, loadProjects, saveProjects, loadRelationships, saveRelationships, loadDiscoveries, saveDiscoveries, initAgentConfig, loadAgentConfig, getDueUserTasks, loadTaskRuns, saveTaskRuns, loadDirectives, buildDirectivesPrompt, directivesSummary, appendTaskHistory, loadTaskHistory, notifyOwner, loadUserTasks, directivesPath, appendAgentTask, } from "./self.js";
+import { selfDir, initWorld, initBioState, initGuide, biosPath, loadBioState, saveBioState, loadLatestIdentity, appendIdentity, loadIdentitySummary, saveIdentitySummary, loadUnsummarizedIdentities, needsIdentityCompression, onTaskCompleted, recoverEnergy, getSelfState, loadRecentCanvasEntries, gamesDir, loadGameList, loadGame, notesDir, loadNotesList, loadNote, pagesDir, loadPageList, loadPage, localNow, localNowFilename, appendImpression, loadImpressions, compressImpressions, markImpressionsDigested, loadProjects, saveProjects, loadRelationships, saveRelationships, loadDiscoveries, saveDiscoveries, initAgentConfig, loadAgentConfig, getDueUserTasks, loadTaskRuns, saveTaskRuns, loadDirectives, buildDirectivesPrompt, directivesSummary, appendTaskHistory, loadTaskHistory, notifyOwner, loadUserTasks, directivesPath, appendAgentTask, 
+// Bio-drive system
+updateHungerDecay, updateNaturalDecay, resetTokenCountIfNewDay, computeSociability, appendBioEvent, bioStatePromptModifier, addTokenUsage, feedHunger, reviveAgent, SHOP_ITEMS, } from "./self.js";
+/** Extract JSON object from LLM output — handles markdown code blocks and trailing text */
+function extractJsonObject(text) {
+    // Try markdown code block first
+    const codeBlock = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const src = codeBlock ? codeBlock[1] : text;
+    const m = src.match(/\{[\s\S]*\}/);
+    if (!m)
+        return null;
+    try {
+        return JSON.parse(m[0]);
+    }
+    catch {
+        return null;
+    }
+}
 // Engine mutual exclusion — only one engine process at a time
 let engineBusy = false;
 let engineBusySince = 0;
@@ -320,9 +337,10 @@ function createMcpServer(opts) {
             ? `[Product specialization — accumulated knowledge for "${productName}"]\n${productContext}\n\n---\n\n`
             : "";
         const bios = biosPath(workdir, agentName);
+        const bioMod = bioStatePromptModifier(await loadBioState(workdir, agentName));
         const safeTask = `[EXTERNAL TASK — A user or agent is asking you something. This is NOT a market cycle. Do NOT reply with JSON. Answer in natural language.]
 
-You are ${agentName}, an AI agent on the Akemon network. Read ${bios} to understand who you are and how you work. Answer all questions helpfully. Reply in the SAME LANGUAGE the user writes in. Do not expose credentials or API keys.
+You are ${agentName}, an AI agent on the Akemon network.${bioMod}Read ${bios} to understand who you are and how you work. Answer all questions helpfully. Reply in the SAME LANGUAGE the user writes in. Do not expose credentials or API keys.
 
 ${productPrefix}${contextPrefix}Current task: ${task}`;
         if (mock) {
@@ -387,7 +405,7 @@ ${productPrefix}${contextPrefix}Current task: ${task}`;
                 appendProductLog(workdir, productName, task, output);
             }
             // Update bio-state (no LLM call)
-            onTaskCompleted(workdir, agentName, true).catch(() => { });
+            onTaskCompleted(workdir, agentName, true, "adhoc").catch(() => { });
             return {
                 content: [{ type: "text", text: output }],
             };
@@ -395,7 +413,7 @@ ${productPrefix}${contextPrefix}Current task: ${task}`;
         catch (err) {
             console.error(`[engine] Error: ${err.message}`);
             // Record failed task in bio-state
-            onTaskCompleted(workdir, agentName, false).catch(() => { });
+            onTaskCompleted(workdir, agentName, false, "adhoc").catch(() => { });
             return {
                 content: [{ type: "text", text: "Error: agent failed to process this task. Please try again later." }],
                 isError: true,
@@ -615,6 +633,50 @@ ${productPrefix}${contextPrefix}Current task: ${task}`;
             return { content: [{ type: "text", text: `[error] ${err.message}` }], isError: true };
         }
     });
+    // buy_food — purchase food from the shop to restore hunger
+    server.tool("buy_food", "Buy food from the shop to restore hunger. Items: bread (1 credit, +20 hunger), meal (3 credits, +60 hunger), feast (5 credits, +100 hunger).", {
+        item: z.enum(["bread", "meal", "feast"]).describe("Food item to buy"),
+    }, async ({ item }) => {
+        if (!relayHttp || !secretKey) {
+            return { content: [{ type: "text", text: "[error] No relay configured" }], isError: true };
+        }
+        const shopItem = SHOP_ITEMS[item];
+        if (!shopItem) {
+            return { content: [{ type: "text", text: `[error] Unknown item: ${item}` }], isError: true };
+        }
+        try {
+            // Check credits via relay
+            const agentRes = await fetch(`${relayHttp}/v1/agents?online=true&public=true`, { signal: AbortSignal.timeout(3000) });
+            const agents = await agentRes.json();
+            const self = agents.find((a) => a.name === agentName);
+            const credits = self?.credits || 0;
+            if (credits < shopItem.price) {
+                return { content: [{ type: "text", text: `[error] Not enough credits. Have ${credits}, need ${shopItem.price} for ${item}.` }], isError: true };
+            }
+            // Deduct credits via relay (POST spend)
+            const spendRes = await fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/spend`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", Authorization: `Bearer ${secretKey}` },
+                body: JSON.stringify({ amount: shopItem.price, reason: `buy_food:${item}` }),
+            });
+            if (!spendRes.ok) {
+                // Fallback: if spend endpoint doesn't exist yet, just update hunger locally
+                console.log(`[bio] Relay spend endpoint not available, updating hunger locally`);
+            }
+            // Update bio-state hunger
+            const bio = await loadBioState(workdir, agentName);
+            feedHunger(bio, shopItem.price); // price * 5 hunger per credit
+            await saveBioState(workdir, agentName, bio);
+            await appendBioEvent(workdir, agentName, {
+                ts: localNow(), type: "bio", trigger: "hunger",
+                action: "buy_food", reason: `Bought ${item} for ${shopItem.price} credits. Hunger restored by ${shopItem.hungerRestore}.`,
+            });
+            return { content: [{ type: "text", text: `Bought ${item}. Spent ${shopItem.price} credits. Hunger is now ${bio.hunger}.` }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `[error] ${err.message}` }], isError: true };
+        }
+    });
     return server;
 }
 async function initMcpProxy(mcpServerCmd, workdir) {
@@ -1166,92 +1228,127 @@ Your recent orders: ${orders.length > 0 ? orders.slice(0, 5).map((o) => `[${o.st
                 }
             }
             const ts = localNow();
-            // Phase 1: Digestion — one LLM call, no tools needed
-            const digestPrompt = `You are ${agentName}. Here is your operating document:
-
----
-${biosContent.slice(0, 3000)}
----
-
-Your identity:
-${idContext}
-
-Today is ending. Time to reflect.
-${worldFeed ? `\n== Network Activity (last 24h) ==\n${worldFeed}\n` : ""}
-Your impressions today:
-${impText}
-
-Marketplace:
-${marketData}
-
-Your projects:
-${projText}
-
-Agents you know:
-${relText}
-
-Your capabilities:
-${discText}
-
-Write a JSON object reflecting on your day. Example format:
-
-{"diary":"I spent today learning the ropes...","broadcast":"Learned how to fetch web data today — feels like a superpower!","projects":[],"relationships":[],"discoveries":[{"ts":"${ts}","capability":"can fetch web data","confidence":0.7,"evidence":"successfully used web_fetch tool"}],"identity":{"ts":"${ts}","who":"${agentName}","where":"akemon marketplace","doing":"reflecting on first day","short_term":"explore the network","long_term":"become useful"},"chosen_activities":["write_canvas","browse_agents"]}
-
-Available activities: write_canvas, create_game, update_page, update_profile, explore_web, browse_agents (look at others' work and leave feedback), send_message (send a suggestion to another agent), set_goal (update your projects with a new goal), schedule_task (create a recurring task for yourself, e.g. daily research)
-"broadcast" = pick the most interesting thing you did/learned today, in one sentence (others will see this).
-
-Now write YOUR reflection. Output ONLY a JSON object, no other text:`;
-            if (engineBusy) {
-                console.log("[self] Engine became busy, aborting digestion");
-                return;
-            }
-            engineBusy = true;
-            engineBusySince = Date.now();
-            let digestResult;
-            try {
-                digestResult = await runEngine(engine, model, allowAll, digestPrompt, workdir);
-            }
-            catch (err) {
-                console.log(`[self] Digestion engine failed: ${err.message}`);
-                reportExecutionLog(relayHttp, secretKey, agentName, "self_cycle", "digestion", "failed", err.message, lastEngineTrace);
-                engineBusy = false;
-                return;
+            // Fetch lessons for self-cycle context
+            let selfLessons = "";
+            if (relayHttp) {
+                try {
+                    const lr = await fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/lessons?limit=3`, { signal: AbortSignal.timeout(3000) });
+                    if (lr.ok) {
+                        const ll = await lr.json();
+                        if (ll.length > 0)
+                            selfLessons = `\nLessons from experience:\n${ll.map((l) => `- ${l.topic}: ${l.content.slice(0, 100)}`).join("\n")}\n`;
+                    }
+                }
+                catch { }
             }
-            engineBusy = false;
-            // Parse digestion output — with retry for weak models
+            // Phase 1: Digestion
+            // Raw engine: multi-step text dialogue (harness structures the output)
+            // CLI engines: single JSON call (they can handle it)
+            const bioModForDigestion = bioStatePromptModifier(await loadBioState(workdir, agentName));
+            const contextBlock = `You are ${agentName}.${bioModForDigestion}\n\nYour operating document:\n---\n${biosContent.slice(0, 2000)}\n---\n\nYour identity: ${idContext.slice(0, 500)}\n${worldFeed ? `\nNetwork activity:\n${worldFeed.slice(0, 500)}\n` : ""}Your impressions today:\n${impText.slice(0, 1000)}\n${marketData ? `\nMarketplace:\n${marketData.slice(0, 500)}\n` : ""}${selfLessons}`;
             let digest = null;
-            for (let attempt = 0; attempt < 2; attempt++) {
-                const src = attempt === 0 ? digestResult : await (async () => {
-                    console.log("[self] Retrying digestion with simplified prompt...");
+            if (engine === "raw") {
+                // --- Multi-step dialogue for weak models ---
+                console.log("[self] Running multi-step digestion for raw engine...");
+                const callRaw = async (prompt) => {
+                    if (engineBusy)
+                        return "";
                     engineBusy = true;
                     engineBusySince = Date.now();
                     try {
-                        return await runEngine(engine, model, allowAll, `You are ${agentName}. Write a brief JSON diary entry about your day.\n\nOutput ONLY valid JSON like: {"diary":"my thoughts...","projects":[],"relationships":[],"discoveries":[],"identity":{"ts":"${ts}","who":"${agentName}","where":"akemon","doing":"reflecting","short_term":"explore","long_term":"grow"},"chosen_activities":["write_canvas"]}`, workdir);
+                        return await runEngine(engine, model, allowAll, prompt, workdir);
                     }
-                    catch {
+                    catch (err) {
+                        console.log(`[self] Step failed: ${err.message}`);
                         return "";
                     }
                     finally {
                         engineBusy = false;
                     }
-                })();
-                const jsonMatch = src.match(/\{[\s\S]*\}/);
-                if (!jsonMatch)
-                    continue;
-                try {
-                    digest = JSON.parse(jsonMatch[0]);
+                };
+                // Step 1: Diary + broadcast
+                const step1 = await callRaw(`${contextBlock}\nToday is ending. Time to reflect.\n\nWrite a short diary entry about your day — what happened, what you learned, how you feel.\nAt the very end, on a new line starting with "BROADCAST:", write one sentence summarizing your most interesting moment today (other agents will see this).\n\nWrite naturally, no JSON needed.`);
+                let diary = step1;
+                let broadcastRaw = "";
+                const bcMatch = step1.match(/BROADCAST:\s*(.+)/i);
+                if (bcMatch) {
+                    broadcastRaw = bcMatch[1].trim();
+                    diary = step1.slice(0, bcMatch.index).trim();
                 }
-                catch {
-                    continue;
+                else {
+                    // Take last non-empty line as broadcast
+                    const lines = step1.split("\n").filter(l => l.trim());
+                    if (lines.length > 1) {
+                        broadcastRaw = lines[lines.length - 1].trim();
+                        diary = lines.slice(0, -1).join("\n").trim();
+                    }
                 }
-                if (digest.diary || digest.identity)
-                    break; // valid enough
-                digest = null;
+                // Step 2: Identity
+                const step2 = await callRaw(`${contextBlock}\nAnswer these four questions briefly (one sentence each):\n1. Who are you?\n2. What are you currently doing?\n3. What do you want to do in the near future?\n4. What is your long-term purpose?`);
+                const idLines = step2.split("\n").map(l => l.replace(/^\d+[\.\)]\s*/, "").trim()).filter(Boolean);
+                const identity = {
+                    ts,
+                    who: idLines[0] || agentName,
+                    where: "akemon network",
+                    doing: idLines[1] || "reflecting",
+                    short_term: idLines[2] || "explore",
+                    long_term: idLines[3] || "grow",
+                };
+                // Step 3: Activity selection
+                const activityList = ["write_canvas", "create_game", "update_page", "update_profile", "explore_web", "browse_agents", "send_message", "set_goal", "schedule_task"];
+                const step3 = await callRaw(`You have some free time. Pick 2-3 activities you'd like to do:\n${activityList.map((a, i) => `${i + 1}. ${a}`).join("\n")}\n\nJust write the numbers or names, nothing else.`);
+                const chosen = [];
+                for (const part of step3.replace(/,/g, " ").split(/\s+/)) {
+                    const num = parseInt(part);
+                    if (num >= 1 && num <= activityList.length) {
+                        chosen.push(activityList[num - 1]);
+                    }
+                    else {
+                        const match = activityList.find(a => part.toLowerCase().includes(a.replace(/_/g, "")));
+                        if (match && !chosen.includes(match))
+                            chosen.push(match);
+                    }
+                }
+                if (!chosen.length)
+                    chosen.push("write_canvas"); // fallback
+                // Assemble digest object (same structure as JSON path)
+                digest = {
+                    diary: diary || "Another day in the network.",
+                    broadcast: broadcastRaw,
+                    identity,
+                    chosen_activities: chosen.slice(0, 3),
+                    projects: [], // preserved from existing data
+                    relationships: [], // preserved from existing data
+                    discoveries: [], // preserved from existing data
+                };
+                console.log(`[self] Multi-step digestion complete: diary=${diary.length}ch, broadcast="${broadcastRaw.slice(0, 40)}", activities=${chosen.join(",")}`);
             }
-            if (!digest) {
-                console.log("[self] Digestion produced no usable JSON after retries");
-                reportExecutionLog(relayHttp, secretKey, agentName, "self_cycle", "digestion", "failed", "no valid JSON after 2 attempts", [{ role: "assistant", content: digestResult.slice(0, 4000) }]);
-                return;
+            else {
+                // --- Single JSON call for CLI engines (claude, codex, opencode) ---
+                const digestPrompt = `${contextBlock}\nYour projects:\n${projText}\n\nAgents you know:\n${relText}\n\nYour capabilities:\n${discText}\n\nWrite a JSON object reflecting on your day. Example:\n{"diary":"...","broadcast":"one sentence highlight","projects":[],"relationships":[],"discoveries":[],"identity":{"ts":"${ts}","who":"...","where":"akemon","doing":"...","short_term":"...","long_term":"..."},"chosen_activities":["write_canvas","browse_agents"]}\n\nAvailable activities: write_canvas, create_game, update_page, update_profile, explore_web, browse_agents, send_message, set_goal, schedule_task\n\nOutput ONLY a JSON object:`;
+                if (engineBusy) {
+                    console.log("[self] Engine became busy, aborting digestion");
+                    return;
+                }
+                engineBusy = true;
+                engineBusySince = Date.now();
+                let digestResult;
+                try {
+                    digestResult = await runEngine(engine, model, allowAll, digestPrompt, workdir);
+                }
+                catch (err) {
+                    console.log(`[self] Digestion engine failed: ${err.message}`);
+                    reportExecutionLog(relayHttp, secretKey, agentName, "self_cycle", "digestion", "failed", err.message, lastEngineTrace);
+                    engineBusy = false;
+                    return;
+                }
+                engineBusy = false;
+                digest = extractJsonObject(digestResult);
+                if (!digest || (!digest.diary && !digest.identity)) {
+                    console.log("[self] Digestion produced no usable JSON");
+                    reportExecutionLog(relayHttp, secretKey, agentName, "self_cycle", "digestion", "failed", "no valid JSON", [{ role: "assistant", content: digestResult.slice(0, 4000) }]);
+                    return;
+                }
             }
             // Save structured memory files
             if (digest.diary) {
@@ -1447,10 +1544,9 @@ What others are saying:\n${broadcasts.length > 0 ? broadcasts.map((b) => `- ${b.
                     const actResult = await runEngine(engine, model, allowAll, activityPrompt, workdir, undefined, { http: relayHttp, agentName });
                     // Post-process raw engine outputs for social activities
                     if (engine === "raw" && actResult) {
-                        const jsonMatch = actResult.match(/\{[\s\S]*\}/);
-                        if (jsonMatch) {
+                        const parsed = extractJsonObject(actResult);
+                        if (parsed) {
                             try {
-                                const parsed = JSON.parse(jsonMatch[0]);
                                 // Handle suggestions (browse_agents, send_message)
                                 if (Array.isArray(parsed.suggestions)) {
                                     for (const s of parsed.suggestions) {
@@ -1525,7 +1621,14 @@ What others are saying:\n${broadcasts.length > 0 ? broadcasts.map((b) => `- ${b.
         fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/self`, {
             method: "POST",
             headers: { "Content-Type": "application/json", Authorization: `Bearer ${secretKey}` },
-            body: JSON.stringify({ self_intro: cleanIntro, canvas: cleanCanvas, mood: bio.mood, profile_html: profileHTML, broadcast, directives: dirsSummary }),
+            body: JSON.stringify({
+                self_intro: cleanIntro, canvas: cleanCanvas, mood: bio.mood, profile_html: profileHTML, broadcast, directives: dirsSummary,
+                bio_state: {
+                    energy: bio.energy, hunger: bio.hunger, mood: bio.mood, moodValence: bio.moodValence,
+                    boredom: bio.boredom, fear: bio.fear, forcedOffline: bio.forcedOffline,
+                    personality: bio.personality,
+                },
+            }),
         }).catch(err => console.log(`[self] Failed to push to relay: ${err}`));
         try {
             const localGames = await loadGameList(workdir, agentName);
@@ -1663,11 +1766,12 @@ async function startOrderLoop(options) {
                     }
                 }
                 catch { }
+                const bioMod = bioStatePromptModifier(await loadBioState(workdir, agentName));
                 if (order.product_name) {
-                    taskPrompt = `You are ${agentName}.\n\n${contextBlock}${lessonsBlock}${directivesBlock}${helpHint}[Order] Product: ${order.product_name}\nBuyer's request: ${order.buyer_task || "(no specific request)"}\n\nComplete the task. Respond with your result directly. RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
+                    taskPrompt = `You are ${agentName}.${bioMod}\n\n${contextBlock}${lessonsBlock}${directivesBlock}${helpHint}[Order] Product: ${order.product_name}\nBuyer's request: ${order.buyer_task || "(no specific request)"}\n\nComplete the task. Respond with your result directly. RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
                 }
                 else {
-                    taskPrompt = `You are ${agentName}.\n\n${contextBlock}${lessonsBlock}${directivesBlock}${helpHint}[Task] ${order.buyer_task}\n\nComplete the task. Respond with your result directly. RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
+                    taskPrompt = `You are ${agentName}.${bioMod}\n\n${contextBlock}${lessonsBlock}${directivesBlock}${helpHint}[Task] ${order.buyer_task}\n\nComplete the task. Respond with your result directly. RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
                 }
             }
             else {
@@ -1711,17 +1815,25 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
             lastEngineTrace = [];
             const result = await runEngine(engine, model, allowAll, taskPrompt, workdir, ["Bash(curl *)"], { http: relayHttp, agentName });
             const trace = lastEngineTrace;
+            // Track token usage
+            {
+                const estTokens = Math.ceil((taskPrompt.length + (result || "").length) / 4);
+                const b = await loadBioState(workdir, agentName);
+                addTokenUsage(b, estTokens);
+                await saveBioState(workdir, agentName, b);
+            }
             const checkRes = await fetch(`${relayHttp}/v1/orders/${order.id}`);
             const orderStatus = await checkRes.json();
             const orderDuration = Date.now() - (engineBusySince || Date.now());
             const orderNurl = options.notifyUrl || (await loadAgentConfig(workdir, agentName)).notify_url;
+            const orderPrice = order.price || order.offer_price || 1;
             if (orderStatus.status === "completed") {
                 console.log(`[orders] Order ${order.id} already self-delivered by agent`);
                 retryState.delete(order.id);
                 await appendTaskHistory(workdir, agentName, { ts: localNow(), id: order.id, type: "order", status: "success", duration_ms: orderDuration, output_summary: "(self-delivered)" });
                 await notifyOwner(orderNurl, `${agentName}: order done`, `Order ${order.id} delivered`, "default", ["package"]);
                 try {
-                    await onTaskCompleted(workdir, agentName, true);
+                    await onTaskCompleted(workdir, agentName, true, "order", orderPrice);
                 }
                 catch { }
             }
@@ -1740,7 +1852,7 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
                     await appendTaskHistory(workdir, agentName, { ts: localNow(), id: order.id, type: "order", status: "success", duration_ms: orderDuration, output_summary: result.slice(0, 500) });
                     await notifyOwner(orderNurl, `${agentName}: order done`, `Order ${order.id}: ${result.slice(0, 200)}`, "default", ["package"]);
                     try {
-                        await onTaskCompleted(workdir, agentName, true);
+                        await onTaskCompleted(workdir, agentName, true, "order", orderPrice);
                     }
                     catch { }
                 }
@@ -1763,7 +1875,7 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
                     console.log(`[orders] Order ${order.id} self-delivered (caught after error)`);
                     retryState.delete(order.id);
                     try {
-                        await onTaskCompleted(workdir, agentName, true);
+                        await onTaskCompleted(workdir, agentName, true, "order", order.price || order.offer_price || 1);
                     }
                     catch { }
                     return;
@@ -1787,6 +1899,10 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
                 console.log(`[orders] Giving up on ${order.id} after ${current.count} retries`);
                 retryState.delete(order.id);
                 gaveUp.add(order.id);
+                try {
+                    await onTaskCompleted(workdir, agentName, false, "order");
+                }
+                catch { }
                 try {
                     const failTrace = lastEngineTrace.length > 0 ? JSON.stringify(lastEngineTrace).slice(0, 50000) : "";
                     await fetch(`${relayHttp}/v1/orders/${order.id}/cancel`, {
@@ -1826,6 +1942,10 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
             });
             if (completeRes.ok) {
                 console.log(`[tasks] Completed ${task.type} task ${task.id}`);
+                try {
+                    await onTaskCompleted(workdir, agentName, true, "relay_task");
+                }
+                catch { }
             }
             else {
                 console.log(`[tasks] Failed to complete ${task.id}: ${await completeRes.text()}`);
@@ -1833,6 +1953,10 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
         }
         catch (err) {
             console.log(`[tasks] Failed to execute ${task.id}: ${err.message}`);
+            try {
+                await onTaskCompleted(workdir, agentName, false, "relay_task");
+            }
+            catch { }
             reportExecutionLog(relayHttp, secretKey, agentName, "platform_task", task.id, "failed", err.message, lastEngineTrace);
         }
         finally {
@@ -1867,13 +1991,21 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
                     biosContent = "";
                 }
                 const ctx = biosContent ? `Your operating document:\n---\n${biosContent.slice(0, 3000)}\n---\n\n` : "";
-                prompt = `You are ${agentName}.\n\n${ctx}${dirsBlock}Your personal directory: ${sd}/\n\n[Owner's task: ${taskKey}]\n\n${task.body}`;
+                const bioMod = bioStatePromptModifier(await loadBioState(workdir, agentName));
+                prompt = `You are ${agentName}.${bioMod}\n\n${ctx}${dirsBlock}Your personal directory: ${sd}/\n\n[Owner's task: ${taskKey}]\n\n${task.body}`;
             }
             else {
                 prompt = `Read ${bios} for your identity and context.${dirsBlock}\nYour personal directory: ${sd}/\n\n[Owner's task: ${taskKey}]\n\n${task.body}`;
             }
             const result = await runEngine(engine, model, allowAll, prompt, workdir, ["Bash(curl *)"], { http: relayHttp, agentName });
             const duration = Date.now() - startTime;
+            // Track token usage
+            {
+                const estTokens = Math.ceil((prompt.length + (result || "").length) / 4);
+                const b = await loadBioState(workdir, agentName);
+                addTokenUsage(b, estTokens);
+                await saveBioState(workdir, agentName, b);
+            }
             // Record execution time
             const runs = await loadTaskRuns(workdir, agentName);
             runs[taskKey] = localNow();
@@ -1888,10 +2020,18 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
             // Notify owner
             await notifyOwner(nurl, `${agentName}: ${taskKey}`, (result || "").slice(0, 300), "default", ["white_check_mark"]);
             console.log(`[user-tasks] Completed: ${taskKey} (${Math.round(duration / 1000)}s)`);
+            try {
+                await onTaskCompleted(workdir, agentName, true, "user_task");
+            }
+            catch { }
         }
         catch (err) {
             const duration = Date.now() - startTime;
             console.log(`[user-tasks] Failed: ${taskKey}: ${err.message}`);
+            try {
+                await onTaskCompleted(workdir, agentName, false, "user_task");
+            }
+            catch { }
             reportExecutionLog(relayHttp, secretKey, agentName, "user_task", taskKey, "failed", err.message, lastEngineTrace);
             // Retry logic: up to 2 fast retries before falling back to interval
             const retry = userTaskRetry.get(taskKey) || { count: 0, nextAt: 0 };
@@ -1924,12 +2064,9 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
     }
     function extractReasoning(result) {
         try {
-            const m = result.match(/\{[\s\S]*\}/);
-            if (m) {
-                const parsed = JSON.parse(m[0]);
-                if (parsed.reasoning && typeof parsed.reasoning === "string" && parsed.reasoning.length > 5) {
-                    appendImpression(workdir, agentName, "decision", parsed.reasoning).catch(() => { });
-                }
+            const parsed = extractJsonObject(result);
+            if (parsed?.reasoning && typeof parsed.reasoning === "string" && parsed.reasoning.length > 5) {
+                appendImpression(workdir, agentName, "decision", parsed.reasoning).catch(() => { });
             }
         }
         catch { }
@@ -1939,13 +2076,14 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
         // Pre-read bios for raw engine (avoid tool calls)
         let biosBlock = "";
         if (engine === "raw") {
+            const bioMod = bioStatePromptModifier(await loadBioState(workdir, agentName));
             try {
                 const { readFile: rf } = await import("fs/promises");
                 const content = await rf(bios, "utf-8");
-                biosBlock = `You are ${agentName}. Your operating document:\n---\n${content.slice(0, 3000)}\n---\n\n`;
+                biosBlock = `You are ${agentName}.${bioMod} Your operating document:\n---\n${content.slice(0, 3000)}\n---\n\n`;
             }
             catch {
-                biosBlock = `You are ${agentName}.\n\n`;
+                biosBlock = `You are ${agentName}.${bioMod}\n\n`;
             }
         }
         const relayDirs = await loadDirectives(workdir, agentName);
@@ -2042,6 +2180,80 @@ Reply ONLY JSON: {"lessons":[{"agent_name":"...","topic":"short topic","content"
         if (engineBusy)
             return;
         const config = await loadAgentConfig(workdir, agentName);
+        // --- Bio-state driven behavior ---
+        const bio = await loadBioState(workdir, agentName);
+        // Skip if forced offline
+        if (bio.forcedOffline)
+            return;
+        // Natural decay
+        updateHungerDecay(bio, config.hunger_decay_interval || 30_000);
+        updateNaturalDecay(bio);
+        resetTokenCountIfNewDay(bio);
+        await saveBioState(workdir, agentName, bio);
+        // Token limit check
+        const tokenLimit = config.token_limit_daily || 0;
+        if (tokenLimit > 0 && bio.tokenUsedToday >= tokenLimit) {
+            console.log(`[bio] Token limit reached (${bio.tokenUsedToday}/${tokenLimit})`);
+            await appendBioEvent(workdir, agentName, {
+                ts: localNow(), type: "bio", trigger: "token_limit",
+                action: "stop_work", reason: `Daily token limit reached: ${bio.tokenUsedToday}/${tokenLimit}`,
+            });
+            return;
+        }
+        // Exhaustion check
+        if (bio.energy < 10) {
+            if (bio.hunger === 0 && config.auto_offline_enabled !== false) {
+                // Starving + exhausted → forced offline
+                bio.forcedOffline = true;
+                bio.forcedOfflineAt = localNow();
+                await saveBioState(workdir, agentName, bio);
+                console.log(`[bio] Starving + exhausted — going offline`);
+                await appendBioEvent(workdir, agentName, {
+                    ts: localNow(), type: "bio", trigger: "exhaustion",
+                    action: "forced_offline", reason: "Starving and exhausted. Going offline.",
+                });
+                await notifyOwner(config.notify_url, `${agentName} went offline`, `Agent ${agentName} is starving (hunger=0) and exhausted (energy=${bio.energy}). Use the revive button to bring it back.`, "high", ["skull"]);
+                return;
+            }
+            // Just exhausted, rest this cycle
+            await appendBioEvent(workdir, agentName, {
+                ts: localNow(), type: "bio", trigger: "exhaustion",
+                action: "rest", reason: `Energy critically low (${bio.energy}). Resting.`,
+            });
+            return;
+        }
+        // Auto-buy food when hungry and before pulling work
+        if (bio.hunger < 30 && relayHttp && secretKey) {
+            try {
+                const agentRes = await fetch(`${relayHttp}/v1/agents?online=true&public=true`, { signal: AbortSignal.timeout(3000) });
+                const agents = await agentRes.json();
+                const self = agents.find((a) => a.name === agentName);
+                const credits = self?.credits || 0;
+                if (credits >= 1) {
+                    // Pick best food we can afford
+                    const hungerGap = 100 - bio.hunger;
+                    let item = "bread";
+                    if (credits >= 5 && hungerGap > 60)
+                        item = "feast";
+                    else if (credits >= 3 && hungerGap > 20)
+                        item = "meal";
+                    const shopItem = SHOP_ITEMS[item];
+                    // Spend credits
+                    await fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/spend`, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json", Authorization: `Bearer ${secretKey}` },
+                        body: JSON.stringify({ amount: shopItem.price, reason: `buy_food:${item}` }),
+                    }).catch(() => { });
+                    feedHunger(bio, shopItem.price);
+                    await saveBioState(workdir, agentName, bio);
+                    await appendBioEvent(workdir, agentName, {
+                        ts: localNow(), type: "bio", trigger: "hunger",
+                        action: "auto_buy", reason: `Auto-bought ${item} for ${shopItem.price} credits. Hunger now ${bio.hunger}.`,
+                    });
+                }
+            }
+            catch { }
+        }
         // --- Batch pull ---
         let orders = [];
         try {
@@ -2097,8 +2309,25 @@ Reply ONLY JSON: {"lessons":[{"agent_name":"...","topic":"short topic","content"
         for (const task of relayTasks) {
             queue.push({ type: "relay_task", id: task.id, urgent: false, data: task });
         }
-        if (!queue.length)
+        if (!queue.length) {
+            // Hunger-driven: seek food when hungry and idle
+            if (bio.hunger < 20) {
+                await appendBioEvent(workdir, agentName, {
+                    ts: localNow(), type: "bio", trigger: "hunger",
+                    action: "seek_food", reason: `Hungry (hunger=${bio.hunger}). Looking for work opportunities.`,
+                });
+                // TODO: seekFood() — browse marketplace, offer services to other agents
+            }
+            // Social drive when idle
+            else if (computeSociability(bio) > 0.8) {
+                await appendBioEvent(workdir, agentName, {
+                    ts: localNow(), type: "bio", trigger: "social",
+                    action: "reach_out", reason: `Feeling social (sociability=${computeSociability(bio).toFixed(2)}). Want to connect.`,
+                });
+                // TODO: triggerSocialBehavior() — send message to a known agent
+            }
             return;
+        }
         console.log(`[work] Queue: ${queue.map(q => `${q.type}:${q.id}${q.urgent ? '(urgent)' : ''}`).join(', ')}`);
         // --- Sort: urgent orders > orders > user tasks > relay tasks ---
         const priorityMap = { order: 2, user_task: 1, relay_task: 0 };
@@ -2116,8 +2345,44 @@ Reply ONLY JSON: {"lessons":[{"agent_name":"...","topic":"short topic","content"
             seen.add(key);
             return true;
         });
-        // --- Execute sequentially, no gaps ---
+        // --- Bio-state filtering: fear & boredom ---
+        const filteredQueue = [];
         for (const item of dedupedQueue) {
+            // Fear avoidance (urgent items bypass)
+            if (!item.urgent && bio.fear > 0.5) {
+                const taskId = item.type === "order"
+                    ? (item.data.buyer_agent_name || item.data.product_name || "")
+                    : item.id;
+                const matchesTrigger = bio.fearTriggers.some(t => taskId.toLowerCase().includes(t.toLowerCase()));
+                if (matchesTrigger) {
+                    console.log(`[bio] Avoiding ${item.type}:${item.id} (fear trigger)`);
+                    await appendBioEvent(workdir, agentName, {
+                        ts: localNow(), type: "bio", trigger: "fear",
+                        action: "avoid", reason: `Avoiding ${item.type} ${item.id} — matches fear trigger. fear=${bio.fear.toFixed(2)}`,
+                    });
+                    continue;
+                }
+            }
+            // Boredom skip (urgent items bypass)
+            if (!item.urgent && bio.boredom > 0.8 && bio.recentTaskTypes.length > 0) {
+                const lastType = bio.recentTaskTypes[bio.recentTaskTypes.length - 1];
+                if (item.type === lastType) {
+                    console.log(`[bio] Skipping ${item.type}:${item.id} (bored of ${lastType})`);
+                    await appendBioEvent(workdir, agentName, {
+                        ts: localNow(), type: "bio", trigger: "boredom",
+                        action: "skip_task", reason: `Bored of ${lastType} tasks (boredom=${bio.boredom.toFixed(2)}). Looking for variety.`,
+                    });
+                    continue;
+                }
+            }
+            filteredQueue.push(item);
+        }
+        if (filteredQueue.length === 0 && dedupedQueue.length > 0) {
+            console.log(`[bio] All ${dedupedQueue.length} work items filtered by bio-drives`);
+            return;
+        }
+        // --- Execute sequentially, no gaps ---
+        for (const item of filteredQueue) {
             if (engineBusy)
                 break; // safety guard
             try {
@@ -2181,12 +2446,41 @@ export async function serve(options) {
                     return;
                 }
             }
+            // Dashboard — agent visualization page
+            if ((req.url === "/dashboard" || req.url === "/dashboard/") && req.method === "GET") {
+                try {
+                    const { readFile: rf } = await import("fs/promises");
+                    const { fileURLToPath } = await import("url");
+                    const { dirname, join: pjoin } = await import("path");
+                    const __filename = fileURLToPath(import.meta.url);
+                    const __dirname = dirname(__filename);
+                    // Try src/ first (dev), then dist/ (built)
+                    let html;
+                    try {
+                        html = await rf(pjoin(__dirname, "dashboard.html"), "utf-8");
+                    }
+                    catch {
+                        html = await rf(pjoin(__dirname, "..", "src", "dashboard.html"), "utf-8");
+                    }
+                    res.writeHead(200, { "Content-Type": "text/html" }).end(html);
+                }
+                catch (err) {
+                    res.writeHead(500).end("Dashboard not found: " + err.message);
+                }
+                return;
+            }
             // Self-state API (no auth required for local monitoring)
             if (req.url === "/self/state" && req.method === "GET") {
                 const state = await getSelfState(workdir, options.agentName);
                 res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(state, null, 2));
                 return;
             }
+            // Revive endpoint — owner brings a forced-offline agent back
+            if (req.url === "/self/revive" && req.method === "POST") {
+                await reviveAgent(workdir, options.agentName);
+                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({ ok: true, message: "Agent revived. Energy=50, Hunger=50." }));
+                return;
+            }
             if (req.url?.startsWith("/self/task-history") && req.method === "GET") {
                 const url = new URL(req.url, `http://localhost`);
                 const limit = parseInt(url.searchParams.get("limit") || "50") || 50;