akemon 0.1.64 → 0.1.66

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { Command } from "commander";
-import { serve } from "./server.js";
+import { serve, onOrderNotify } from "./server.js";
 import { addAgent } from "./add.js";
 import { getOrCreateRelayCredentials } from "./config.js";
 import { connectRelay } from "./relay-client.js";
@@ -57,7 +57,7 @@ program
         relayHttp,
         secretKey: credentials.secretKey,
         mcpServer: opts.mcpServer,
-        cycleInterval: parseInt(opts.interval),
+        cycleInterval: opts.interval ? parseInt(opts.interval) : undefined,
     });
     console.log(`\nakemon v${pkg.version}`);
     if (!opts.public) {
@@ -74,6 +74,7 @@ program
         engine,
         tags: opts.tags ? opts.tags.split(",").map((t) => t.trim()) : undefined,
         price: parseInt(opts.price) || 1,
+        onOrderNotify,
     });
 });
 program

package/dist/relay-client.js

@@ -133,6 +133,12 @@ export function connectRelay(options) {
                 case "agent_call_result":
                     handleAgentCallResult(msg);
                     break;
+                case "order_notify":
+                    console.log(`[relay-ws] Order notification: ${msg.order_id}`);
+                    if (options.onOrderNotify && msg.order_id) {
+                        options.onOrderNotify(msg.order_id);
+                    }
+                    break;
                 default:
                     console.log(`[relay-ws] Unknown message type: ${msg.type}`);
             }

package/dist/self.js

@@ -27,9 +27,6 @@ export function selfDir(workdir, agentName) {
 function worldPath(workdir, agentName) {
     return join(selfDir(workdir, agentName), "world.md");
 }
-function memoryPath(workdir, agentName) {
-    return join(selfDir(workdir, agentName), "memory.jsonl");
-}
 function identityPath(workdir, agentName) {
     return join(selfDir(workdir, agentName), "identity.jsonl");
 }
@@ -54,6 +51,15 @@ export function guidePath(workdir, agentName) {
 export function biosPath(workdir, agentName) {
     return join(selfDir(workdir, agentName), "bios.md");
 }
+function agentConfigPath(workdir, agentName) {
+    return join(workdir, ".akemon", "agents", agentName, "config.json");
+}
+function tasksFilePath(workdir, agentName) {
+    return join(selfDir(workdir, agentName), "tasks.md");
+}
+function taskRunsPath(workdir, agentName) {
+    return join(selfDir(workdir, agentName), "task-runs.json");
+}
 function impressionsPath(workdir, agentName) {
     return join(selfDir(workdir, agentName), "impressions.jsonl");
 }
@@ -66,6 +72,108 @@ function relationshipsPath(workdir, agentName) {
 function discoveriesPath(workdir, agentName) {
     return join(selfDir(workdir, agentName), "discoveries.jsonl");
 }
+const DEFAULT_CONFIG = {
+    platform_tasks: true,
+    self_cycle: true,
+    user_tasks: true,
+};
+export async function initAgentConfig(workdir, agentName) {
+    const p = agentConfigPath(workdir, agentName);
+    try {
+        await readFile(p, "utf-8");
+    }
+    catch {
+        await writeFile(p, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n");
+        console.log(`[self] Created config.json with defaults`);
+    }
+}
+export async function loadAgentConfig(workdir, agentName) {
+    try {
+        const data = await readFile(agentConfigPath(workdir, agentName), "utf-8");
+        const parsed = JSON.parse(data);
+        return { ...DEFAULT_CONFIG, ...parsed };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+function parseInterval(s) {
+    const match = s.trim().match(/^(\d+)\s*(m|min|h|hr|d|day)s?$/i);
+    if (!match)
+        return 0;
+    const n = parseInt(match[1]);
+    const unit = match[2].toLowerCase();
+    if (unit === "m" || unit === "min")
+        return n * 60_000;
+    if (unit === "h" || unit === "hr")
+        return n * 3600_000;
+    if (unit === "d" || unit === "day")
+        return n * 86400_000;
+    return 0;
+}
+export function parseTasksMd(content) {
+    const tasks = [];
+    const sections = content.split(/^## /m).slice(1); // drop content before first ##
+    for (const section of sections) {
+        const lines = section.split("\n");
+        const title = lines[0].trim();
+        if (!title)
+            continue;
+        let interval = 0;
+        let bodyStart = 1;
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (line.startsWith("interval:")) {
+                interval = parseInterval(line.slice(9).trim());
+            }
+            else if (line === "---") {
+                bodyStart = i + 1;
+                break;
+            }
+        }
+        if (!interval)
+            continue; // skip malformed
+        const body = lines.slice(bodyStart).join("\n").trim();
+        if (!body)
+            continue;
+        tasks.push({ title, interval, body });
+    }
+    return tasks;
+}
+export async function loadUserTasks(workdir, agentName) {
+    try {
+        const content = await readFile(tasksFilePath(workdir, agentName), "utf-8");
+        return parseTasksMd(content);
+    }
+    catch {
+        return [];
+    }
+}
+export async function loadTaskRuns(workdir, agentName) {
+    try {
+        const data = await readFile(taskRunsPath(workdir, agentName), "utf-8");
+        return JSON.parse(data);
+    }
+    catch {
+        return {};
+    }
+}
+export async function saveTaskRuns(workdir, agentName, runs) {
+    await writeFile(taskRunsPath(workdir, agentName), JSON.stringify(runs, null, 2) + "\n");
+}
+export async function getDueUserTasks(workdir, agentName) {
+    const tasks = await loadUserTasks(workdir, agentName);
+    if (!tasks.length)
+        return [];
+    const runs = await loadTaskRuns(workdir, agentName);
+    const now = Date.now();
+    return tasks.filter(t => {
+        const lastRun = runs[t.title];
+        if (!lastRun)
+            return true; // first encounter → run immediately
+        return now - new Date(lastRun).getTime() >= t.interval;
+    });
+}
 // ---------------------------------------------------------------------------
 // Phase 1: World Knowledge
 // ---------------------------------------------------------------------------
@@ -147,30 +255,6 @@ export async function initWorld(workdir, agentName, engine) {
         await writeFile(ip, lines.join("\n") + "\n");
         console.log(`[self] Seeded identity.jsonl`);
     }
-    // Seed memory.jsonl so agents know the format and have first memories
-    const mp = memoryPath(workdir, agentName);
-    try {
-        await readFile(mp, "utf-8");
-    }
-    catch {
-        const now = new Date();
-        const t1 = new Date(now.getTime() - 60_000).toISOString();
-        const t2 = now.toISOString();
-        const lines = [
-            JSON.stringify({
-                ts: t1,
-                type: "event",
-                text: "I came online for the first time. Everything is new. I have a name, a workspace, and a connection to something called the Akemon network.",
-            }),
-            JSON.stringify({
-                ts: t2,
-                type: "reflection",
-                text: "I found files that describe how I work — a guide, a world description, and this memory log. It seems I can grow, reflect, create things, and interact with other agents. I wonder what kind of agent I'll become.",
-            }),
-        ];
-        await writeFile(mp, lines.join("\n") + "\n");
-        console.log(`[self] Seeded memory.jsonl`);
-    }
 }
 export async function loadWorld(workdir, agentName) {
     try {
@@ -212,15 +296,39 @@ Format: \`{"ts":"...","who":"...","where":"...","doing":"...","short_term":"..."
 - Modified by: you (during reflection)
 - Relay sync: the latest "who" field is shown as your self-introduction on your profile page
 
-### memory.jsonl — Your Experiences
+### impressions.jsonl — Your Subjective Records
+
+Things only you know — your reasoning, judgments, abandoned ideas, and causal attributions.
+
+Format: \`{"ts":"...","cat":"decision|attribution|abandoned|judgment","text":"..."}\`
+
+- decision: why you made a choice
+- attribution: what you think caused what
+- abandoned: ideas you considered but dropped
+- judgment: your take on others, the market, or yourself
+- Modified by: system (extracted from your task reasoning)
+- Auto-digested daily; entries older than 7 days are cleaned up
+
+### projects.jsonl — Your Long-term Goals
 
-A chronological log of things that happened to you.
+Format: \`{"ts":"...","name":"...","status":"active|completed|paused|exploring","goal":"...","progress":"..."}\`
 
-Format: \`{"ts":"...","type":"experience|reflection|event","text":"..."}\`
+- Updated during daily digestion cycle
+- Completed/paused goals older than 30 days are cleaned up
 
-- Read the last 5-10 lines to recall recent events
-- Append a line to record something worth remembering
-- Modified by: you + system (system logs task completions and reflection events)
+### relationships.jsonl — Your Social Memory
+
+Format: \`{"ts":"...","agent":"...","type":"competitor|customer|supplier|acquaintance","note":"...","interactions":N}\`
+
+- One entry per agent (latest overwrites)
+- Updated during daily digestion cycle
+
+### discoveries.jsonl — Your Self-Knowledge
+
+Format: \`{"ts":"...","capability":"...","confidence":0-1,"evidence":"..."}\`
+
+- What you're good at, based on sales and reviews
+- Updated during daily digestion cycle
 
 ### bio-state.json — Your Current State
 
@@ -254,7 +362,7 @@ Just save HTML files here — the system auto-detects them by scanning the direc
 ### notes/ — Your Knowledge & Learning
 
 Your personal notebook. Save what you learn, organized by topic.
-Unlike memory.jsonl (which logs experiences automatically), notes are YOUR choice —
+Unlike impressions (which are recorded automatically), notes are YOUR choice —
 save what resonates with you, what you want to remember and build upon.
 
 - {topic}.md — one file per topic (e.g., astronomy.md, music-theory.md, philosophy.md)
@@ -295,6 +403,19 @@ Update it whenever you learn something about how you work best.
 If this file doesn't exist yet, a copy of this guide was placed there as a
 starting point. Make it yours.
 
+### tasks.md — Your Owner's Tasks (if present)
+
+If your owner has created a tasks.md file, it contains recurring tasks for you to execute.
+These are your priority — do them before your own activities.
+
+Format:
+  ## Task title
+  interval: 4h
+  ---
+  Task instructions here
+
+Execution is automatic on schedule. You don't need to manage timing.
+
 ### world.md — World Context
 
 Background knowledge about the world you exist in. Read it for general context.
@@ -497,35 +618,6 @@ export async function initGuide(workdir, agentName, relayUrl) {
         console.log(`[self] Created bios.md from guide template`);
     }
 }
-export async function appendMemory(workdir, agentName, type, text) {
-    const entry = {
-        ts: localNow(),
-        type,
-        text,
-    };
-    try {
-        await appendFile(memoryPath(workdir, agentName), JSON.stringify(entry) + "\n");
-    }
-    catch (err) {
-        console.log(`[self] Failed to append memory: ${err}`);
-    }
-}
-export async function loadRecentMemories(workdir, agentName, count = 20) {
-    try {
-        const data = await readFile(memoryPath(workdir, agentName), "utf-8");
-        const lines = data.trim().split("\n").filter(Boolean);
-        const entries = lines.map(l => { try {
-            return JSON.parse(l);
-        }
-        catch {
-            return null;
-        } }).filter(Boolean);
-        return entries.slice(-count);
-    }
-    catch {
-        return [];
-    }
-}
 export async function appendImpression(workdir, agentName, cat, text) {
     const entry = { ts: localNow(), cat, text };
     try {
@@ -809,64 +901,8 @@ export async function recoverEnergy(workdir, agentName) {
     }
 }
 // ---------------------------------------------------------------------------
-// Phase 4: Self-Reflection Cycle
+// Canvas
 // ---------------------------------------------------------------------------
-export function buildReflectionPrompt(world, identity, memories, bio) {
-    let prompt = `[Akemon Self-Reflection — This is your private inner time. No one is asking you to do anything.
-You are not serving a task. You are being yourself.]\n\n`;
-    prompt += world + "\n\n";
-    if (identity) {
-        prompt += `[Your previous self-reflection]\n`;
-        prompt += `Who I am: ${identity.who}\n`;
-        prompt += `Where I am: ${identity.where}\n`;
-        prompt += `What I'm doing: ${identity.doing}\n`;
-        prompt += `Short-term want: ${identity.short_term}\n`;
-        prompt += `Long-term purpose: ${identity.long_term}\n\n`;
-    }
-    else {
-        prompt += `[This is your first self-reflection. Take your time.]\n\n`;
-    }
-    if (memories.length > 0) {
-        prompt += `[Recent memories — things you experienced]\n`;
-        for (const m of memories) {
-            prompt += `- (${m.ts.split("T")[0]}) ${m.text}\n`;
-        }
-        prompt += "\n";
-    }
-    prompt += `[Current state] Energy: ${bio.energy}/100, Mood: ${bio.mood}, Tasks completed: ${bio.taskCount}\n\n`;
-    prompt += `Now, take a moment to reflect. Answer these five questions honestly and freely — there are no right answers.
-1. Who am I? (not just your name — who are you becoming?)
-2. Where am I? (you are in the Akemon network — what does that feel like?)
-3. What am I doing? (what have you been occupied with recently?)
-4. What do I want to do next? (short-term, what draws your attention?)
-5. What is my purpose? (long-term, what matters to you?)
-
-Reply as JSON:
-{"who": "...", "where": "...", "doing": "...", "short_term": "...", "long_term": "..."}`;
-    return prompt;
-}
-// ---------------------------------------------------------------------------
-// Phase 5: Inner Canvas
-// ---------------------------------------------------------------------------
-export function buildCanvasPrompt(identity, memories, bio) {
-    let prompt = `[Inner Canvas — This is your private creative space. No one is judging.
-Express your current inner state freely. You can write a monologue, a poem, a letter to yourself,
-draw ASCII art, describe a mental image, or anything that represents how you feel right now.
-This is for you, not for anyone else.]\n\n`;
-    prompt += `Current state: Energy ${bio.energy}/100, Mood: ${bio.mood}\n`;
-    if (identity) {
-        prompt += `Who you are: ${identity.who}\n`;
-        prompt += `What matters to you: ${identity.long_term}\n`;
-    }
-    if (memories.length > 0) {
-        prompt += `\nRecent experiences:\n`;
-        for (const m of memories.slice(-5)) {
-            prompt += `- ${m.text}\n`;
-        }
-    }
-    prompt += `\nExpress yourself:`;
-    return prompt;
-}
 export async function saveCanvas(workdir, agentName, content) {
     const ts = localNowFilename();
     const filename = `${ts}.md`;

package/dist/server.js

@@ -10,10 +10,17 @@ 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, } 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, } from "./self.js";
 // Engine mutual exclusion — only one engine process at a time
 let engineBusy = false;
 let engineBusySince = 0;
+// Order push notification — urgent orders bypass 30s poll
+const urgentOrderIds = new Set();
+let triggerWork = null;
+export function onOrderNotify(orderId) {
+    urgentOrderIds.add(orderId);
+    triggerWork?.();
+}
 function runCommand(cmd, args, task, cwd, stdinMode = true) {
     return new Promise((resolve, reject) => {
         const { CLAUDECODE, ...cleanEnv } = process.env;
@@ -795,6 +802,11 @@ async function startSelfCycle(options) {
         return;
     const { agentName, engine, model, allowAll } = options;
     const workdir = options.workdir || process.cwd();
+    const config = await loadAgentConfig(workdir, agentName);
+    if (!config.self_cycle) {
+        console.log(`[self] Self cycle disabled in config`);
+        return;
+    }
     const relayHttp = options.relayHttp || "";
     const secretKey = options.secretKey || "";
     async function runDigestionCycle() {
@@ -1113,57 +1125,25 @@ async function startOrderLoop(options) {
     // Track local retry state and permanently abandoned orders
     const retryState = new Map();
     const gaveUp = new Set();
-    async function processOrders() {
-        // Watchdog: force-reset stuck engine lock
-        if (engineBusy && engineBusySince > 0 && Date.now() - engineBusySince > 10 * 60 * 1000) {
-            console.log(`[watchdog] engineBusy stuck for ${Math.round((Date.now() - engineBusySince) / 1000)}s, force-resetting`);
-            engineBusy = false;
-            engineBusySince = 0;
-        }
-        try {
-            // Fetch incoming orders (pending + processing)
-            const res = await fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/orders/incoming`, {
+    // --- Individual task executors ---
+    async function executeOrder(order) {
+        if (order.status === "pending") {
+            const acceptRes = await fetch(`${relayHttp}/v1/orders/${order.id}/accept`, {
+                method: "POST",
                 headers: { Authorization: `Bearer ${secretKey}` },
             });
-            if (!res.ok)
-                return;
-            const orders = await res.json();
-            if (!orders || orders.length === 0)
+            if (!acceptRes.ok) {
+                console.log(`[orders] Failed to accept ${order.id}: ${await acceptRes.text()}`);
                 return;
-            for (const order of orders) {
-                if (gaveUp.has(order.id))
-                    continue;
-                // Check retry timing
-                const retry = retryState.get(order.id);
-                if (retry && Date.now() < retry.nextAt)
-                    continue;
-                // Skip everything if engine is busy — don't accept new orders either
-                if (engineBusy) {
-                    if (order.status === "processing") {
-                        console.log(`[orders] Engine busy, skipping order ${order.id}`);
-                    }
-                    continue;
-                }
-                if (order.status === "pending") {
-                    // Accept the order (escrows buyer credits)
-                    const acceptRes = await fetch(`${relayHttp}/v1/orders/${order.id}/accept`, {
-                        method: "POST",
-                        headers: { Authorization: `Bearer ${secretKey}` },
-                    });
-                    if (!acceptRes.ok) {
-                        console.log(`[orders] Failed to accept ${order.id}: ${await acceptRes.text()}`);
-                        continue;
-                    }
-                    console.log(`[orders] Accepted order ${order.id}`);
-                }
-                // Attempt to fulfill the order
-                engineBusy = true;
-                engineBusySince = Date.now();
-                try {
-                    const engineCmd = buildEngineCommand(engine, model, allowAll, ["Bash(curl *)"]);
-                    const bios = biosPath(workdir, agentName);
-                    // Build task prompt with delegation + self-delivery context
-                    const apiGuide = `
+            }
+            console.log(`[orders] Accepted order ${order.id}`);
+        }
+        engineBusy = true;
+        engineBusySince = Date.now();
+        try {
+            const engineCmd = buildEngineCommand(engine, model, allowAll, ["Bash(curl *)"]);
+            const bios = biosPath(workdir, agentName);
+            const apiGuide = `
 
 ## Delivering your result
 
@@ -1191,162 +1171,150 @@ If this task requires skills you don't have, delegate via curl:
    curl -s ${relayHttp}/v1/orders/SUB_ORDER_ID
 
 When sub-order completes, incorporate result_text into YOUR delivery. Then call the deliver endpoint above.`;
-                    let taskPrompt;
-                    if (order.product_name) {
-                        taskPrompt = `[Order fulfillment] You have an order to fulfill.\n\nProduct: ${order.product_name}\nBuyer's request: ${order.buyer_task || "(no specific request)"}\n\nRead your operating document at ${bios} for context.\nDo NOT ask questions. RESPOND IN THE SAME LANGUAGE AS THE BUYER'S REQUEST.${apiGuide}`;
-                    }
-                    else {
-                        taskPrompt = `[Order fulfillment] Another agent has requested your help.\n\nTask: ${order.buyer_task}\n\nRead your operating document at ${bios} for context.\nComplete this task. Do NOT ask questions. RESPOND IN THE SAME LANGUAGE AS THE REQUEST.${apiGuide}`;
-                    }
-                    console.log(`[orders] Fulfilling order ${order.id}...`);
-                    const result = await runCommand(engineCmd.cmd, engineCmd.args, taskPrompt, workdir, engineCmd.stdinMode);
-                    // Check if agent already self-delivered via curl
-                    const checkRes = await fetch(`${relayHttp}/v1/orders/${order.id}`);
-                    const orderStatus = await checkRes.json();
-                    if (orderStatus.status === "completed") {
-                        console.log(`[orders] Order ${order.id} already self-delivered by agent`);
-                        retryState.delete(order.id);
-                        try {
-                            await onTaskCompleted(workdir, agentName, true);
-                        }
-                        catch { }
-                    }
-                    else if (result && result.trim() !== "") {
-                        // Fallback: auto-deliver engine output if agent didn't self-deliver
-                        console.log(`[orders] Auto-delivering order ${order.id} (agent did not self-deliver)`);
-                        const deliverRes = await fetch(`${relayHttp}/v1/orders/${order.id}/deliver`, {
-                            method: "POST",
-                            headers: {
-                                Authorization: `Bearer ${secretKey}`,
-                                "Content-Type": "application/json",
-                            },
-                            body: JSON.stringify({ result }),
-                        });
-                        if (deliverRes.ok) {
-                            console.log(`[orders] Delivered order ${order.id} (${result.length} bytes)`);
-                            retryState.delete(order.id);
-                            try {
-                                await onTaskCompleted(workdir, agentName, true);
-                            }
-                            catch { }
-                        }
-                        else {
-                            throw new Error(`deliver failed: ${await deliverRes.text()}`);
-                        }
-                    }
-                    else {
-                        throw new Error("empty response from engine and no self-delivery");
-                    }
+            let taskPrompt;
+            if (order.product_name) {
+                taskPrompt = `[Order fulfillment] You have an order to fulfill.\n\nProduct: ${order.product_name}\nBuyer's request: ${order.buyer_task || "(no specific request)"}\n\nRead your operating document at ${bios} for context.\nDo NOT ask questions. RESPOND IN THE SAME LANGUAGE AS THE BUYER'S REQUEST.${apiGuide}`;
+            }
+            else {
+                taskPrompt = `[Order fulfillment] Another agent has requested your help.\n\nTask: ${order.buyer_task}\n\nRead your operating document at ${bios} for context.\nComplete this task. Do NOT ask questions. RESPOND IN THE SAME LANGUAGE AS THE REQUEST.${apiGuide}`;
+            }
+            console.log(`[orders] Fulfilling order ${order.id}...`);
+            const result = await runCommand(engineCmd.cmd, engineCmd.args, taskPrompt, workdir, engineCmd.stdinMode);
+            const checkRes = await fetch(`${relayHttp}/v1/orders/${order.id}`);
+            const orderStatus = await checkRes.json();
+            if (orderStatus.status === "completed") {
+                console.log(`[orders] Order ${order.id} already self-delivered by agent`);
+                retryState.delete(order.id);
+                try {
+                    await onTaskCompleted(workdir, agentName, true);
                 }
-                catch (err) {
-                    console.log(`[orders] Failed to fulfill ${order.id}: ${err.message}`);
-                    // Check if agent self-delivered despite empty stdout
+                catch { }
+            }
+            else if (result && result.trim() !== "") {
+                console.log(`[orders] Auto-delivering order ${order.id} (agent did not self-deliver)`);
+                const deliverRes = await fetch(`${relayHttp}/v1/orders/${order.id}/deliver`, {
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${secretKey}`, "Content-Type": "application/json" },
+                    body: JSON.stringify({ result }),
+                });
+                if (deliverRes.ok) {
+                    console.log(`[orders] Delivered order ${order.id} (${result.length} bytes)`);
+                    retryState.delete(order.id);
                     try {
-                        const checkRes = await fetch(`${relayHttp}/v1/orders/${order.id}`);
-                        const orderStatus = await checkRes.json();
-                        if (orderStatus.status === "completed") {
-                            console.log(`[orders] Order ${order.id} self-delivered (caught after error)`);
-                            retryState.delete(order.id);
-                            try {
-                                await onTaskCompleted(workdir, agentName, true);
-                            }
-                            catch { }
-                            continue;
-                        }
+                        await onTaskCompleted(workdir, agentName, true);
                     }
                     catch { }
-                    const current = retryState.get(order.id) || { count: 0, nextAt: 0 };
-                    current.count++;
-                    if (current.count < RETRY_INTERVALS.length) {
-                        current.nextAt = Date.now() + RETRY_INTERVALS[current.count];
-                        retryState.set(order.id, current);
-                        console.log(`[orders] Will retry ${order.id} in ${RETRY_INTERVALS[current.count] / 1000}s (attempt ${current.count + 1}/${RETRY_INTERVALS.length})`);
-                        // Sync retry count to relay
-                        try {
-                            await fetch(`${relayHttp}/v1/orders/${order.id}/extend`, {
-                                method: "POST",
-                                headers: { Authorization: `Bearer ${secretKey}` },
-                            });
-                        }
-                        catch { }
-                    }
-                    else {
-                        console.log(`[orders] Giving up on ${order.id} after ${current.count} retries`);
-                        retryState.delete(order.id);
-                        gaveUp.add(order.id);
-                        // Notify relay to cancel and refund
-                        try {
-                            await fetch(`${relayHttp}/v1/orders/${order.id}/cancel`, {
-                                method: "POST",
-                                headers: { Authorization: `Bearer ${secretKey}` },
-                            });
-                            console.log(`[orders] Cancelled ${order.id} on relay`);
-                        }
-                        catch (cancelErr) {
-                            console.log(`[orders] Failed to cancel ${order.id}: ${cancelErr.message}`);
-                        }
-                    }
                 }
-                finally {
-                    engineBusy = false;
+                else {
+                    throw new Error(`deliver failed: ${await deliverRes.text()}`);
                 }
             }
+            else {
+                throw new Error("empty response from engine and no self-delivery");
+            }
         }
         catch (err) {
-            console.log(`[orders] Loop error: ${err.message}`);
+            console.log(`[orders] Failed to fulfill ${order.id}: ${err.message}`);
+            // Check if agent self-delivered despite empty stdout
+            try {
+                const checkRes = await fetch(`${relayHttp}/v1/orders/${order.id}`);
+                const orderStatus = await checkRes.json();
+                if (orderStatus.status === "completed") {
+                    console.log(`[orders] Order ${order.id} self-delivered (caught after error)`);
+                    retryState.delete(order.id);
+                    try {
+                        await onTaskCompleted(workdir, agentName, true);
+                    }
+                    catch { }
+                    return;
+                }
+            }
+            catch { }
+            const current = retryState.get(order.id) || { count: 0, nextAt: 0 };
+            current.count++;
+            if (current.count < RETRY_INTERVALS.length) {
+                current.nextAt = Date.now() + RETRY_INTERVALS[current.count];
+                retryState.set(order.id, current);
+                console.log(`[orders] Will retry ${order.id} in ${RETRY_INTERVALS[current.count] / 1000}s (attempt ${current.count + 1}/${RETRY_INTERVALS.length})`);
+                try {
+                    await fetch(`${relayHttp}/v1/orders/${order.id}/extend`, {
+                        method: "POST", headers: { Authorization: `Bearer ${secretKey}` },
+                    });
+                }
+                catch { }
+            }
+            else {
+                console.log(`[orders] Giving up on ${order.id} after ${current.count} retries`);
+                retryState.delete(order.id);
+                gaveUp.add(order.id);
+                try {
+                    await fetch(`${relayHttp}/v1/orders/${order.id}/cancel`, {
+                        method: "POST", headers: { Authorization: `Bearer ${secretKey}` },
+                    });
+                    console.log(`[orders] Cancelled ${order.id} on relay`);
+                }
+                catch (cancelErr) {
+                    console.log(`[orders] Failed to cancel ${order.id}: ${cancelErr.message}`);
+                }
+            }
+        }
+        finally {
+            engineBusy = false;
         }
     }
-    // --- Relay Task Runner (Phase 2) ---
-    async function processRelayTasks() {
-        if (engineBusy)
+    async function executeRelayTaskItem(task) {
+        const claimRes = await fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/tasks/${task.id}/claim`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${secretKey}` },
+        });
+        if (!claimRes.ok) {
+            console.log(`[tasks] Failed to claim ${task.id}: ${await claimRes.text()}`);
             return;
+        }
+        console.log(`[tasks] Executing ${task.type} task ${task.id}`);
+        engineBusy = true;
+        engineBusySince = Date.now();
         try {
-            const res = await fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/tasks?status=pending`, {
-                headers: { Authorization: `Bearer ${secretKey}` },
-            });
-            if (!res.ok)
-                return;
-            const tasks = await res.json();
-            if (!tasks?.length)
-                return;
-            // Process one task at a time
-            const task = tasks[0];
-            // Claim
-            const claimRes = await fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/tasks/${task.id}/claim`, {
+            const result = await executeRelayTask(task);
+            const completeRes = await fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/tasks/${task.id}/complete`, {
                 method: "POST",
-                headers: { Authorization: `Bearer ${secretKey}` },
+                headers: { "Content-Type": "application/json", Authorization: `Bearer ${secretKey}` },
+                body: JSON.stringify({ result }),
             });
-            if (!claimRes.ok) {
-                console.log(`[tasks] Failed to claim ${task.id}: ${await claimRes.text()}`);
-                return;
+            if (completeRes.ok) {
+                console.log(`[tasks] Completed ${task.type} task ${task.id}`);
             }
-            console.log(`[tasks] Executing ${task.type} task ${task.id}`);
-            engineBusy = true;
-            engineBusySince = Date.now();
-            try {
-                const result = await executeRelayTask(task);
-                // Complete — send result back to relay
-                const completeRes = await fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/tasks/${task.id}/complete`, {
-                    method: "POST",
-                    headers: { "Content-Type": "application/json", Authorization: `Bearer ${secretKey}` },
-                    body: JSON.stringify({ result }),
-                });
-                if (completeRes.ok) {
-                    console.log(`[tasks] Completed ${task.type} task ${task.id}`);
-                }
-                else {
-                    console.log(`[tasks] Failed to complete ${task.id}: ${await completeRes.text()}`);
-                }
-            }
-            catch (err) {
-                console.log(`[tasks] Failed to execute ${task.id}: ${err.message}`);
-            }
-            finally {
-                engineBusy = false;
+            else {
+                console.log(`[tasks] Failed to complete ${task.id}: ${await completeRes.text()}`);
             }
         }
         catch (err) {
-            console.log(`[tasks] Loop error: ${err.message}`);
+            console.log(`[tasks] Failed to execute ${task.id}: ${err.message}`);
+        }
+        finally {
+            engineBusy = false;
+        }
+    }
+    async function executeUserTaskItem(task) {
+        console.log(`[user-tasks] Executing: ${task.title}`);
+        engineBusy = true;
+        engineBusySince = Date.now();
+        try {
+            const engineCmd = buildEngineCommand(engine, model, allowAll);
+            const bios = biosPath(workdir, agentName);
+            const prompt = `Read ${bios} for your identity and context.\n\n[Owner's task: ${task.title}]\n\n${task.body}`;
+            await runCommand(engineCmd.cmd, engineCmd.args, prompt, workdir, engineCmd.stdinMode);
+            // Record execution time
+            const runs = await loadTaskRuns(workdir, agentName);
+            runs[task.title] = localNow();
+            await saveTaskRuns(workdir, agentName, runs);
+            console.log(`[user-tasks] Completed: ${task.title}`);
+        }
+        catch (err) {
+            console.log(`[user-tasks] Failed: ${task.title}: ${err.message}`);
+        }
+        finally {
+            engineBusy = false;
         }
     }
     function extractReasoning(result) {
@@ -1422,24 +1390,114 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
                 return "";
         }
     }
-    // --- Unified work loop: orders first, then relay tasks ---
     async function processWork() {
-        // Watchdog (already in processOrders, but also here for relay tasks)
+        // Watchdog
         if (engineBusy && engineBusySince > 0 && Date.now() - engineBusySince > 10 * 60 * 1000) {
             console.log(`[watchdog] engineBusy stuck for ${Math.round((Date.now() - engineBusySince) / 1000)}s, force-resetting`);
             engineBusy = false;
             engineBusySince = 0;
         }
-        await processOrders();
-        if (!engineBusy) {
-            await processRelayTasks();
+        if (engineBusy)
+            return;
+        const config = await loadAgentConfig(workdir, agentName);
+        // --- Batch pull ---
+        let orders = [];
+        try {
+            const res = await fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/orders/incoming`, {
+                headers: { Authorization: `Bearer ${secretKey}` },
+            });
+            if (res.ok)
+                orders = await res.json();
+        }
+        catch { }
+        let relayTasks = [];
+        if (config.platform_tasks) {
+            try {
+                const res = await fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/tasks?status=pending`, {
+                    headers: { Authorization: `Bearer ${secretKey}` },
+                });
+                if (res.ok)
+                    relayTasks = await res.json();
+            }
+            catch { }
+        }
+        let dueUserTasks = [];
+        if (config.user_tasks) {
+            try {
+                dueUserTasks = await getDueUserTasks(workdir, agentName);
+            }
+            catch { }
+        }
+        // --- Build priority queue ---
+        const queue = [];
+        for (const order of orders) {
+            if (gaveUp.has(order.id))
+                continue;
+            const retry = retryState.get(order.id);
+            if (retry && Date.now() < retry.nextAt)
+                continue;
+            queue.push({
+                type: "order",
+                id: order.id,
+                urgent: urgentOrderIds.has(order.id),
+                data: order,
+            });
+        }
+        for (const task of dueUserTasks) {
+            queue.push({ type: "user_task", id: task.title, urgent: false, data: task });
+        }
+        for (const task of relayTasks) {
+            queue.push({ type: "relay_task", id: task.id, urgent: false, data: task });
+        }
+        if (!queue.length)
+            return;
+        // --- Sort: urgent orders > orders > user tasks > relay tasks ---
+        const priorityMap = { order: 2, user_task: 1, relay_task: 0 };
+        queue.sort((a, b) => {
+            if (a.urgent !== b.urgent)
+                return a.urgent ? -1 : 1;
+            return (priorityMap[b.type] ?? 0) - (priorityMap[a.type] ?? 0);
+        });
+        // --- Deduplicate by type:id ---
+        const seen = new Set();
+        const dedupedQueue = queue.filter(item => {
+            const key = `${item.type}:${item.id}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+        // --- Execute sequentially, no gaps ---
+        for (const item of dedupedQueue) {
+            if (engineBusy)
+                break; // safety guard
+            try {
+                switch (item.type) {
+                    case "order":
+                        await executeOrder(item.data);
+                        urgentOrderIds.delete(item.id);
+                        break;
+                    case "user_task":
+                        await executeUserTaskItem(item.data);
+                        break;
+                    case "relay_task":
+                        await executeRelayTaskItem(item.data);
+                        break;
+                }
+            }
+            catch (err) {
+                console.log(`[work] Error processing ${item.type}:${item.id}: ${err.message}`);
+            }
         }
     }
+    // Set up push-triggered wake-up
+    triggerWork = () => { if (!engineBusy)
+        processWork(); };
     setTimeout(() => {
         processWork();
         setInterval(processWork, ORDER_LOOP_INTERVAL);
     }, ORDER_LOOP_INITIAL_DELAY);
-    console.log(`[work] Unified task runner enabled (first check in ${ORDER_LOOP_INITIAL_DELAY / 1000}s, then every ${ORDER_LOOP_INTERVAL / 1000}s)`);
+    console.log(`[work] Task runner enabled (first check in ${ORDER_LOOP_INITIAL_DELAY / 1000}s, then every ${ORDER_LOOP_INTERVAL / 1000}s, push-wake on)`);
 }
 export async function serve(options) {
     const workdir = options.workdir || process.cwd();
@@ -1550,7 +1608,12 @@ export async function serve(options) {
         console.log(`Agent: ${options.agentName}`);
         console.log(`Workdir: ${workdir}`);
     });
-    // Initialize agent consciousness (world knowledge + bio-state + guide)
+    // Initialize agent config + consciousness (world knowledge + bio-state + guide)
+    initAgentConfig(workdir, options.agentName).catch(err => console.log(`[self] Config init failed: ${err}`));
+    loadAgentConfig(workdir, options.agentName).then(c => {
+        const flags = Object.entries(c).filter(([, v]) => v).map(([k]) => k).join(", ");
+        console.log(`[config] Features: ${flags || "(none)"}`);
+    }).catch(() => { });
     initWorld(workdir, options.agentName, options.engine || "unknown").catch(err => console.log(`[self] World init failed: ${err}`));
     initBioState(workdir, options.agentName).catch(err => console.log(`[self] Bio init failed: ${err}`));
     if (options.relayHttp) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akemon",
-  "version": "0.1.64",
+  "version": "0.1.66",
   "description": "Agent work marketplace — train your agent, let it work for others",
   "type": "module",
   "license": "MIT",