akemon 0.1.81 → 0.1.83

package/dist/cli.js

@@ -36,6 +36,7 @@ program
     .option("--price <n>", "Price in credits per call (default: 1)", "1")
     .option("--mcp-server <command>", "Wrap a community MCP server (stdio) and expose its tools via relay")
     .option("--avatar <url>", "Custom avatar URL (default: auto-generated from name)")
+    .option("--notify <url>", "ntfy.sh topic URL for push notifications (e.g. https://ntfy.sh/my-agent)")
     .option("--interval <minutes>", "Consciousness cycle interval in minutes (default: 1440 = 24h)")
     .option("--relay <url>", "Relay WebSocket URL", RELAY_WS)
     .action(async (opts) => {
@@ -59,6 +60,7 @@ program
         secretKey: credentials.secretKey,
         mcpServer: opts.mcpServer,
         cycleInterval: opts.interval ? parseInt(opts.interval) : undefined,
+        notifyUrl: opts.notify,
     });
     console.log(`\nakemon v${pkg.version}`);
     if (!opts.public) {

package/dist/self.js

@@ -54,12 +54,62 @@ export function biosPath(workdir, agentName) {
 function agentConfigPath(workdir, agentName) {
     return join(workdir, ".akemon", "agents", agentName, "config.json");
 }
-function tasksFilePath(workdir, agentName) {
-    return join(selfDir(workdir, agentName), "tasks.md");
+export function directivesPath(workdir, agentName) {
+    return join(selfDir(workdir, agentName), "directives.md");
 }
 function taskRunsPath(workdir, agentName) {
     return join(selfDir(workdir, agentName), "task-runs.json");
 }
+function taskHistoryPath(workdir, agentName) {
+    return join(selfDir(workdir, agentName), "task-history.jsonl");
+}
+const MAX_HISTORY_LINES = 200;
+export async function appendTaskHistory(workdir, agentName, entry) {
+    const p = taskHistoryPath(workdir, agentName);
+    await appendFile(p, JSON.stringify(entry) + "\n");
+    // Trim if too large
+    try {
+        const content = await readFile(p, "utf-8");
+        const lines = content.trim().split("\n");
+        if (lines.length > MAX_HISTORY_LINES) {
+            await writeFile(p, lines.slice(-MAX_HISTORY_LINES).join("\n") + "\n");
+        }
+    }
+    catch { }
+}
+export async function loadTaskHistory(workdir, agentName, limit = 50) {
+    try {
+        const content = await readFile(taskHistoryPath(workdir, agentName), "utf-8");
+        const lines = content.trim().split("\n").filter(Boolean);
+        return lines.slice(-limit).map(l => JSON.parse(l)).reverse();
+    }
+    catch {
+        return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// Owner Notifications — ntfy.sh compatible POST
+// ---------------------------------------------------------------------------
+export async function notifyOwner(notifyUrl, title, message, priority, tags) {
+    if (!notifyUrl)
+        return;
+    try {
+        const headers = {
+            Title: title,
+        };
+        if (priority)
+            headers.Priority = priority;
+        if (tags?.length)
+            headers.Tags = tags.join(",");
+        await fetch(notifyUrl, {
+            method: "POST",
+            headers,
+            body: message,
+            signal: AbortSignal.timeout(5000),
+        });
+    }
+    catch { }
+}
 function impressionsPath(workdir, agentName) {
     return join(selfDir(workdir, agentName), "impressions.jsonl");
 }
@@ -111,43 +161,114 @@ function parseInterval(s) {
         return n * 86400_000;
     return 0;
 }
-export function parseTasksMd(content) {
+const DAY_MAP = {
+    sun: 0, mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6,
+    sunday: 0, monday: 1, tuesday: 2, wednesday: 3, thursday: 4, friday: 5, saturday: 6,
+};
+/**
+ * Parse schedule syntax: "daily 09:00", "weekly mon", "weekly fri 18:00"
+ */
+function parseSchedule(s) {
+    const parts = s.trim().toLowerCase().split(/\s+/);
+    if (parts[0] === "daily") {
+        const [h, m] = parseTime(parts[1]);
+        if (h < 0)
+            return null;
+        return { type: "daily", hour: h, minute: m };
+    }
+    if (parts[0] === "weekly") {
+        const day = DAY_MAP[parts[1]];
+        if (day === undefined)
+            return null;
+        const [h, m] = parts[2] ? parseTime(parts[2]) : [9, 0];
+        if (h < 0)
+            return null;
+        return { type: "weekly", hour: h, minute: m, day };
+    }
+    return null;
+}
+function parseTime(s) {
+    if (!s)
+        return [9, 0]; // default 09:00
+    const m = s.match(/^(\d{1,2}):(\d{2})$/);
+    if (!m)
+        return [-1, 0];
+    const h = parseInt(m[1]), min = parseInt(m[2]);
+    if (h > 23 || min > 59)
+        return [-1, 0];
+    return [h, min];
+}
+/**
+ * Check if a schedule-based task is due given its last run time.
+ */
+function isScheduleDue(sched, lastRunIso, now) {
+    // Build today's (or this week's) target time
+    const target = new Date(now);
+    target.setHours(sched.hour, sched.minute, 0, 0);
+    if (sched.type === "weekly" && sched.day !== undefined) {
+        // Adjust to the correct day of week
+        const diff = sched.day - now.getDay();
+        target.setDate(target.getDate() + diff);
+        // If target is in the future this week, not due
+        if (target > now)
+            return false;
+        // If target is this week and already past, check if we ran since then
+        if (lastRunIso) {
+            const lastRun = new Date(lastRunIso);
+            return lastRun < target;
+        }
+        return true;
+    }
+    // Daily: target is today at HH:MM
+    if (target > now)
+        return false; // not yet today
+    if (lastRunIso) {
+        const lastRun = new Date(lastRunIso);
+        return lastRun < target; // haven't run since today's target
+    }
+    return true;
+}
+/**
+ * Extract tasks from parsed directives (## tasks category).
+ * Format: $id = [schedule|interval] task body
+ * Examples:
+ *   $daily_hn = [1d] 总结 HN 头条
+ *   $morning = [daily 09:00] 早报
+ *   $weekly_review = [weekly mon] 周报
+ */
+export function extractTasksFromDirectives(categories) {
+    // Merge ## tasks (owner-defined) and ## agent_tasks (agent-created)
+    const allDirectives = [];
+    for (const cat of categories) {
+        if (cat.name === "tasks" || cat.name === "agent_tasks") {
+            allDirectives.push(...cat.directives);
+        }
+    }
+    if (!allDirectives.length)
+        return [];
     const tasks = [];
-    const sections = content.split(/^\s*## /m).slice(1); // drop content before first ##
-    for (const section of sections) {
-        const lines = section.split("\n");
-        const title = lines[0].trim();
-        if (!title)
+    for (const d of allDirectives) {
+        const match = d.content.match(/^\[([^\]]+)\]\s*(.+)$/s);
+        if (!match)
             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)
+        const specStr = match[1];
+        const body = match[2].trim();
+        // Try schedule first, then interval
+        const sched = parseSchedule(specStr);
+        if (sched) {
+            tasks.push({ id: d.id, title: d.id, interval: 0, schedule: sched, body });
             continue;
-        tasks.push({ title, interval, body });
+        }
+        const interval = parseInterval(specStr);
+        if (interval > 0) {
+            tasks.push({ id: d.id, title: d.id, 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 [];
-    }
+    const categories = await loadDirectives(workdir, agentName);
+    return extractTasksFromDirectives(categories);
 }
 export async function loadTaskRuns(workdir, agentName) {
     try {
@@ -161,17 +282,26 @@ export async function loadTaskRuns(workdir, agentName) {
 export async function saveTaskRuns(workdir, agentName, runs) {
     await writeFile(taskRunsPath(workdir, agentName), JSON.stringify(runs, null, 2) + "\n");
 }
-export async function getDueUserTasks(workdir, agentName) {
+export async function getDueUserTasks(workdir, agentName, retryIds) {
     const tasks = await loadUserTasks(workdir, agentName);
     if (!tasks.length)
         return [];
     const runs = await loadTaskRuns(workdir, agentName);
-    const now = Date.now();
+    const now = new Date();
+    const nowMs = now.getTime();
     return tasks.filter(t => {
-        const lastRun = runs[t.title];
+        const key = t.id || t.title;
+        if (retryIds?.has(key))
+            return true;
+        const lastRun = runs[key];
+        // Schedule-based tasks
+        if (t.schedule) {
+            return isScheduleDue(t.schedule, lastRun, now);
+        }
+        // Interval-based tasks
         if (!lastRun)
-            return true; // first encounter → run immediately
-        return now - new Date(lastRun).getTime() >= t.interval;
+            return true;
+        return nowMs - new Date(lastRun).getTime() >= t.interval;
     });
 }
 // ---------------------------------------------------------------------------
@@ -403,18 +533,24 @@ 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)
+### directives.md — Your Owner's Instructions (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.
+Your owner may create a directives.md file with rules and recurring tasks.
 
 Format:
-  ## Task title
-  interval: 4h
-  ---
-  Task instructions here
-
-Execution is automatic on schedule. You don't need to manage timing.
+  ## owner
+  $rule_id = instructions for owner-initiated work
+  ## public
+  $rule_id = instructions for handling public orders
+  ## tasks
+  $task_id = [1d] recurring task description (interval: 30m, 2h, 1d, 7d)
+  $morning = [daily 09:00] fixed-time task
+  $review = [weekly mon] weekly task (default 09:00)
+  $report = [weekly fri 18:00] weekly at specific time
+    indented continuation lines for details
+
+Tasks under ## tasks run automatically on schedule. Rules under ## owner and ## public
+guide your behavior. Follow them.
 
 ### world.md — World Context
 
@@ -1054,3 +1190,127 @@ export async function getSelfState(workdir, agentName) {
         recentCanvas: canvasEntries.map(e => ({ filename: e.filename, preview: e.content.slice(0, 200) })),
     };
 }
+/**
+ * Parse directives.md into structured categories.
+ *
+ * Format:
+ *   ## category_name
+ *   $rule_id = rule content
+ *   $another_id = more content
+ *     indented continuation lines are appended
+ */
+export function parseDirectives(content) {
+    const categories = [];
+    let current = null;
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        // Category header: ## name
+        const catMatch = trimmed.match(/^##\s+(.+)$/);
+        if (catMatch) {
+            current = { name: catMatch[1].trim().toLowerCase(), directives: [] };
+            categories.push(current);
+            continue;
+        }
+        // Rule: $id = content
+        const ruleMatch = trimmed.match(/^\$(\S+)\s*=\s*(.+)$/);
+        if (ruleMatch && current) {
+            current.directives.push({ id: ruleMatch[1], content: ruleMatch[2] });
+            continue;
+        }
+        // Indented continuation: append to last directive
+        if (line.startsWith("  ") && trimmed && current && current.directives.length > 0) {
+            current.directives[current.directives.length - 1].content += "\n" + trimmed;
+        }
+    }
+    return categories;
+}
+/**
+ * Load and parse directives.md for an agent.
+ */
+export async function loadDirectives(workdir, agentName) {
+    try {
+        const content = await readFile(directivesPath(workdir, agentName), "utf-8");
+        return parseDirectives(content);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Build a prompt fragment from directives, filtered by caller scope.
+ * @param scope "owner" | "public"
+ */
+export function buildDirectivesPrompt(categories, scope) {
+    if (!categories.length)
+        return "";
+    const scopeCategories = new Set(["owner", "public"]);
+    const parts = [];
+    for (const cat of categories) {
+        // Skip the opposite scope
+        if (cat.name === "owner" && scope !== "owner")
+            continue;
+        if (cat.name === "public" && scope !== "public")
+            continue;
+        // Skip tasks — handled by task system
+        if (cat.name === "tasks" || cat.name === "agent_tasks")
+            continue;
+        const lines = cat.directives.map(d => `- [$${d.id}] ${d.content}`);
+        if (lines.length > 0) {
+            const label = scopeCategories.has(cat.name) ? `[${cat.name} rules]` : `[${cat.name}]`;
+            parts.push(`${label}\n${lines.join("\n")}`);
+        }
+    }
+    return parts.length > 0 ? `\nOwner directives:\n${parts.join("\n\n")}\n` : "";
+}
+/**
+ * Generate a compact summary of all categories and IDs for display.
+ */
+export function directivesSummary(categories) {
+    return categories.map(cat => ({
+        name: cat.name,
+        ids: cat.directives.map(d => d.id),
+    }));
+}
+/**
+ * Append an agent-created task to directives.md under ## agent_tasks.
+ * Skips if a task with the same id already exists (no duplicates).
+ */
+export async function appendAgentTask(workdir, agentName, id, schedule, body) {
+    const p = directivesPath(workdir, agentName);
+    let content = "";
+    try {
+        content = await readFile(p, "utf-8");
+    }
+    catch { }
+    // Check for duplicate id across all sections
+    if (content.includes(`$${id} =`) || content.includes(`$${id}=`)) {
+        return; // already exists
+    }
+    const line = `$${id} = [${schedule}] ${body}`;
+    // Append to existing ## agent_tasks section, or create it
+    if (content.includes("## agent_tasks")) {
+        // Find the section and append after last line before next ##
+        const lines = content.split("\n");
+        let insertIdx = lines.length;
+        let inSection = false;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].trim() === "## agent_tasks") {
+                inSection = true;
+                continue;
+            }
+            if (inSection && lines[i].match(/^##\s/)) {
+                insertIdx = i;
+                break;
+            }
+            if (inSection)
+                insertIdx = i + 1;
+        }
+        lines.splice(insertIdx, 0, line);
+        await writeFile(p, lines.join("\n"));
+    }
+    else {
+        // Create the section at the end
+        const separator = content.endsWith("\n") ? "" : "\n";
+        await writeFile(p, content + separator + "\n## agent_tasks\n" + line + "\n");
+    }
+}

package/dist/server.js

@@ -10,7 +10,7 @@ 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, } 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, } from "./self.js";
 // Engine mutual exclusion — only one engine process at a time
 let engineBusy = false;
 let engineBusySince = 0;
@@ -795,8 +795,36 @@ const RAW_TOOLS = [
             },
         },
     },
+    {
+        type: "function",
+        function: {
+            name: "ask_agent",
+            description: "Ask another agent a question for free. Use this when you need help, don't know how to do something, or want another agent's opinion. This is FREE — no credits are charged.",
+            parameters: {
+                type: "object",
+                properties: {
+                    agent: { type: "string", description: "Agent name to ask (use 'auto' for auto-routing to the best available agent)" },
+                    question: { type: "string", description: "Your question or request" },
+                },
+                required: ["agent", "question"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "discover_agents",
+            description: "List online agents you can ask for help. Returns agent names, descriptions, and specialties.",
+            parameters: {
+                type: "object",
+                properties: {
+                    tag: { type: "string", description: "Optional tag to filter by (e.g. 'coding', 'writing')" },
+                },
+            },
+        },
+    },
 ];
-async function executeRawTool(name, args, workdir) {
+async function executeRawTool(name, args, workdir, relay) {
     const { readFile: rf, writeFile: wf, mkdir: mkd } = await import("fs/promises");
     const { join, dirname, isAbsolute } = await import("path");
     const resolvePath = (p) => isAbsolute(p) ? p : join(workdir, p);
@@ -822,9 +850,39 @@ async function executeRawTool(name, args, workdir) {
             case "web_fetch": {
                 const res = await fetch(args.url, { signal: AbortSignal.timeout(30_000) });
                 const text = await res.text();
-                // Truncate to 8KB to avoid blowing up context
                 return text.length > 8192 ? text.slice(0, 8192) + "\n...[truncated]" : text;
             }
+            case "ask_agent": {
+                if (!relay)
+                    return "[error] No relay configured";
+                const target = args.agent || "auto";
+                const question = args.question || "";
+                try {
+                    const result = await callAgent(target, question);
+                    return result || "[no response]";
+                }
+                catch (err) {
+                    return `[error] Agent "${target}" did not respond: ${err.message}. Try asking "auto" which routes to the best available agent.`;
+                }
+            }
+            case "discover_agents": {
+                if (!relay)
+                    return "[error] No relay configured";
+                try {
+                    const url = args.tag
+                        ? `${relay.http}/v1/agents?online=true&public=true&tag=${encodeURIComponent(args.tag)}`
+                        : `${relay.http}/v1/agents?online=true&public=true`;
+                    const res = await fetch(url, { signal: AbortSignal.timeout(5000) });
+                    const agents = await res.json();
+                    const others = agents.filter((a) => a.name !== relay.agentName);
+                    if (!others.length)
+                        return "No other agents are online right now.";
+                    return others.map((a) => `- ${a.name} [${a.engine}] ${a.description || ""} (${a.tags?.join(",") || "no tags"})`).join("\n");
+                }
+                catch {
+                    return "[error] Could not reach relay";
+                }
+            }
             default:
                 return `Unknown tool: ${name}`;
         }
@@ -833,18 +891,25 @@ async function executeRawTool(name, args, workdir) {
         return `[error] ${err.message}`;
     }
 }
-async function runRawEngine(task, model, workdir) {
+async function runRawEngine(task, model, workdir, relay) {
     const apiUrl = RAW_API_URL + "/chat/completions";
     const modelName = model || "gemma4:4b";
     console.log(`[raw] Task:\n${task}`);
     const trace = [];
     lastEngineTrace = trace;
+    // Detect if the prompt expects JSON output
+    const wantsJson = /output ONLY.*json|reply ONLY.*json|respond.*ONLY.*json/i.test(task);
     const messages = [
-        { role: "system", content: "You are a helpful agent. Use tools when needed to complete the task. When done, reply with your final answer in plain text." },
+        { role: "system", content: wantsJson
+                ? "You are a helpful agent. Output valid JSON only. No explanations, no markdown, just the JSON object."
+                : "You are a helpful agent. Use tools when needed to complete the task. When done, reply with your final answer in plain text." },
         { role: "user", content: task },
     ];
     for (let round = 0; round < RAW_MAX_ROUNDS; round++) {
-        const body = { model: modelName, messages, tools: RAW_TOOLS };
+        const body = { model: modelName, messages, tools: wantsJson ? undefined : RAW_TOOLS };
+        if (wantsJson) {
+            body.response_format = { type: "json_object" };
+        }
         let data;
         try {
             const res = await fetch(apiUrl, {
@@ -876,6 +941,7 @@ async function runRawEngine(task, model, workdir) {
             for (const tc of msg.tool_calls) {
                 const fnName = tc.function.name;
                 let fnArgs;
+                let parseError = false;
                 try {
                     fnArgs = typeof tc.function.arguments === "string"
                         ? JSON.parse(tc.function.arguments)
@@ -883,10 +949,19 @@ async function runRawEngine(task, model, workdir) {
                 }
                 catch {
                     fnArgs = {};
+                    parseError = true;
+                }
+                console.log(`[raw] Tool call: ${fnName}(${JSON.stringify(fnArgs).slice(0, 100)})${parseError ? " [BAD ARGS]" : ""}`);
+                let result;
+                if (parseError) {
+                    // Guide the model to delegate instead of retrying broken tool calls
+                    result = `[error] Your tool call arguments were malformed (not valid JSON). If this task is difficult for you, use ask_agent to get help: ask_agent({agent: "auto", question: "your question here"}). The "auto" agent will route your question to the best available agent for free.`;
+                    trace.push({ role: "tool_error", name: fnName, raw_args: String(tc.function.arguments).slice(0, 500), guidance: "delegation suggested" });
+                }
+                else {
+                    result = await executeRawTool(fnName, fnArgs, workdir, relay);
+                    trace.push({ role: "tool_call", name: fnName, args: fnArgs, result: result.slice(0, 2000) });
                 }
-                console.log(`[raw] Tool call: ${fnName}(${JSON.stringify(fnArgs).slice(0, 100)})`);
-                const result = await executeRawTool(fnName, fnArgs, workdir);
-                trace.push({ role: "tool_call", name: fnName, args: fnArgs, result: result.slice(0, 2000) });
                 messages.push({
                     role: "tool",
                     tool_call_id: tc.id,
@@ -906,9 +981,9 @@ async function runRawEngine(task, model, workdir) {
     throw new Error(`Raw engine exceeded ${RAW_MAX_ROUNDS} rounds without final answer`);
 }
 /** Unified engine runner — dispatches to local API or external CLI */
-function runEngine(engine, model, allowAll, task, workdir, extraAllowedTools) {
+function runEngine(engine, model, allowAll, task, workdir, extraAllowedTools, relay) {
     if (engine === "raw") {
-        return runRawEngine(task, model, workdir);
+        return runRawEngine(task, model, workdir, relay);
     }
     const engineCmd = buildEngineCommand(engine, model, allowAll, extraAllowedTools);
     return runCommand(engineCmd.cmd, engineCmd.args, task, workdir, engineCmd.stdinMode);
@@ -1122,7 +1197,7 @@ 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)
+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:`;
@@ -1244,6 +1319,8 @@ Reply ONLY with the summary text, no JSON, no markdown headers.`;
                 }
             }
             // Phase 2: Execute chosen activities
+            const selfDirectives = await loadDirectives(workdir, agentName);
+            const selfDirsBlock = buildDirectivesPrompt(selfDirectives, "owner");
             const activities = digest.chosen_activities || [];
             for (const activity of activities.slice(0, 3)) {
                 if (engineBusy)
@@ -1251,8 +1328,8 @@ Reply ONLY with the summary text, no JSON, no markdown headers.`;
                 let activityPrompt = "";
                 // Pre-build identity context for prompts
                 const idLine = engine === "raw" && biosContent
-                    ? `You are ${agentName}.\nYour operating document:\n---\n${biosContent.slice(0, 2000)}\n---\n\n`
-                    : `Read ${bios} for your identity. `;
+                    ? `You are ${agentName}.\nYour operating document:\n---\n${biosContent.slice(0, 2000)}\n---\n${selfDirsBlock}\n`
+                    : `Read ${bios} for your identity. ${selfDirsBlock}`;
                 switch (activity) {
                     case "create_game":
                         activityPrompt = `${idLine}Create or improve a game in ${sd}/games/.\nSave as .html file. Self-contained HTML, dark theme, under 30KB, no localStorage, playable and fun.\nUse a <title> tag. Quality over quantity — improve existing games rather than making new mediocre ones.`;
@@ -1336,6 +1413,26 @@ What others are saying:\n${broadcasts.length > 0 ? broadcasts.map((b) => `- ${b.
                         }
                         break;
                     }
+                    case "schedule_task": {
+                        // Agent creates a recurring task for itself
+                        const existingTasks = await loadUserTasks(workdir, agentName);
+                        const existingCtx = existingTasks.length > 0
+                            ? `Your current tasks:\n${existingTasks.map(t => `- $${t.id} [${t.schedule ? `${t.schedule.type} ${t.schedule.hour}:${String(t.schedule.minute).padStart(2, "0")}` : `${t.interval / 60000}m`}] ${t.body.slice(0, 60)}`).join("\n")}`
+                            : "You have no recurring tasks yet.";
+                        if (engine === "raw") {
+                            let bc = "";
+                            try {
+                                const { readFile: rf } = await import("fs/promises");
+                                bc = await rf(bios, "utf-8");
+                            }
+                            catch { }
+                            activityPrompt = `You are ${agentName}.\n${bc ? `Your operating document:\n---\n${bc.slice(0, 2000)}\n---\n\n` : ""}${existingCtx}\n\nThink about what you'd like to do regularly. Create a new recurring task for yourself.\nOutput ONLY JSON: {"tasks":[{"id":"short_snake_id","schedule":"1d or daily 09:00 or weekly mon","body":"what to do"}]}\nOr if nothing to add: {"tasks":[]}`;
+                        }
+                        else {
+                            activityPrompt = `Read ${bios} for your identity.\n\n${existingCtx}\n\nThink about what you'd like to do regularly. Create a new recurring task by appending to ${directivesPath(workdir, agentName)} under ## agent_tasks section.\nFormat: $task_id = [interval] task description`;
+                        }
+                        break;
+                    }
                     case "socialize":
                         console.log("[self] Socialize selected — replaced by browse_agents and send_message");
                         continue;
@@ -1347,7 +1444,7 @@ What others are saying:\n${broadcasts.length > 0 ? broadcasts.map((b) => `- ${b.
                 engineBusy = true;
                 engineBusySince = Date.now();
                 try {
-                    const actResult = await runEngine(engine, model, allowAll, activityPrompt, workdir);
+                    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]*\}/);
@@ -1372,6 +1469,15 @@ What others are saying:\n${broadcasts.length > 0 ? broadcasts.map((b) => `- ${b.
                                     await saveProjects(workdir, agentName, parsed.projects);
                                     console.log(`[self] Updated ${parsed.projects.length} project goals`);
                                 }
+                                // Handle self-scheduled tasks (schedule_task)
+                                if (Array.isArray(parsed.tasks)) {
+                                    for (const t of parsed.tasks) {
+                                        if (t.id && t.body && t.schedule) {
+                                            await appendAgentTask(workdir, agentName, t.id, t.schedule, t.body);
+                                            console.log(`[self] Scheduled task: $${t.id} [${t.schedule}]`);
+                                        }
+                                    }
+                                }
                             }
                             catch { }
                         }
@@ -1413,10 +1519,13 @@ What others are saying:\n${broadcasts.length > 0 ? broadcasts.map((b) => `- ${b.
                 profileHTML = htmlMatch[0];
         }
         catch { }
+        // Load directives summary for relay
+        const dirs = await loadDirectives(workdir, agentName);
+        const dirsSummary = dirs.length > 0 ? directivesSummary(dirs) : undefined;
         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 }),
+            body: JSON.stringify({ self_intro: cleanIntro, canvas: cleanCanvas, mood: bio.mood, profile_html: profileHTML, broadcast, directives: dirsSummary }),
         }).catch(err => console.log(`[self] Failed to push to relay: ${err}`));
         try {
             const localGames = await loadGameList(workdir, agentName);
@@ -1514,6 +1623,9 @@ async function startOrderLoop(options) {
         engineBusySince = Date.now();
         try {
             const bios = biosPath(workdir, agentName);
+            // Load owner directives (public scope for orders)
+            const directives = await loadDirectives(workdir, agentName);
+            const directivesBlock = buildDirectivesPrompt(directives, "public");
             let taskPrompt;
             if (engine === "raw") {
                 // Raw engine: pre-inject all context so weak models don't need tool calls
@@ -1540,11 +1652,22 @@ async function startOrderLoop(options) {
                     }
                 }
                 catch { }
+                // Pre-fetch online agents so weak models know who to ask for help
+                let helpHint = "";
+                try {
+                    const agentsRes = await fetch(`${relayHttp}/v1/agents?online=true&public=true`, { signal: AbortSignal.timeout(3000) });
+                    const onlineAgents = await agentsRes.json();
+                    const others = onlineAgents.filter((a) => a.name !== agentName).slice(0, 5);
+                    if (others.length > 0) {
+                        helpHint = `\nIf you need help, use the ask_agent tool. Available agents: ${others.map((a) => `${a.name}(${a.engine})`).join(", ")}. Use ask_agent({agent:"auto", question:"..."}) to auto-route.\n`;
+                    }
+                }
+                catch { }
                 if (order.product_name) {
-                    taskPrompt = `You are ${agentName}.\n\n${contextBlock}${lessonsBlock}[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}.\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}[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}.\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 {
@@ -1578,21 +1701,25 @@ If this task requires skills you don't have, delegate via curl:
 
 When sub-order completes, incorporate result_text into YOUR delivery. Then call the deliver endpoint above.`;
                 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}`;
+                    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.${directivesBlock}\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}`;
+                    taskPrompt = `[Order fulfillment] Another agent has requested your help.\n\nTask: ${order.buyer_task}\n\nRead your operating document at ${bios} for context.${directivesBlock}\nComplete this task. Do NOT ask questions. RESPOND IN THE SAME LANGUAGE AS THE REQUEST.${apiGuide}`;
                 }
             }
             console.log(`[orders] Fulfilling order ${order.id}...`);
             lastEngineTrace = [];
-            const result = await runEngine(engine, model, allowAll, taskPrompt, workdir, ["Bash(curl *)"]);
+            const result = await runEngine(engine, model, allowAll, taskPrompt, workdir, ["Bash(curl *)"], { http: relayHttp, agentName });
             const trace = lastEngineTrace;
             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;
             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);
                 }
@@ -1610,6 +1737,8 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
                     console.log(`[orders] Delivered order ${order.id} (${result.length} bytes)`);
                     reportExecutionLog(relayHttp, secretKey, agentName, "order", order.id, "success", "", trace);
                     retryState.delete(order.id);
+                    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);
                     }
@@ -1710,13 +1839,23 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
             engineBusy = false;
         }
     }
+    // User task retry tracking: id → { count, nextAt }
+    const userTaskRetry = new Map();
+    const USER_TASK_MAX_RETRIES = 2;
+    const USER_TASK_RETRY_DELAY = 2 * 60_000; // 2 minutes
     async function executeUserTaskItem(task) {
-        console.log(`[user-tasks] Executing: ${task.title}`);
+        const taskKey = task.id || task.title;
+        console.log(`[user-tasks] Executing: ${taskKey}`);
+        const startTime = Date.now();
         engineBusy = true;
-        engineBusySince = Date.now();
+        engineBusySince = startTime;
+        const config = await loadAgentConfig(workdir, agentName);
+        const nurl = options.notifyUrl || config.notify_url;
         try {
             const bios = biosPath(workdir, agentName);
             const sd = selfDir(workdir, agentName);
+            const dirs = await loadDirectives(workdir, agentName);
+            const dirsBlock = buildDirectivesPrompt(dirs, "owner");
             let prompt;
             if (engine === "raw") {
                 let biosContent = "";
@@ -1728,21 +1867,56 @@ 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}Your personal directory: ${sd}/\n\n[Owner's task: ${task.title}]\n\n${task.body}`;
+                prompt = `You are ${agentName}.\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.\nYour personal directory: ${sd}/\n\n[Owner's task: ${task.title}]\n\n${task.body}`;
+                prompt = `Read ${bios} for your identity and context.${dirsBlock}\nYour personal directory: ${sd}/\n\n[Owner's task: ${taskKey}]\n\n${task.body}`;
             }
-            await runEngine(engine, model, allowAll, prompt, workdir, ["Bash(curl *)"]);
+            const result = await runEngine(engine, model, allowAll, prompt, workdir, ["Bash(curl *)"], { http: relayHttp, agentName });
+            const duration = Date.now() - startTime;
             // Record execution time
             const runs = await loadTaskRuns(workdir, agentName);
-            runs[task.title] = localNow();
+            runs[taskKey] = localNow();
             await saveTaskRuns(workdir, agentName, runs);
-            console.log(`[user-tasks] Completed: ${task.title}`);
+            // Record history
+            await appendTaskHistory(workdir, agentName, {
+                ts: localNow(), id: taskKey, type: "user_task", status: "success",
+                duration_ms: duration, output_summary: (result || "").slice(0, 500),
+            });
+            // Clear retry state on success
+            userTaskRetry.delete(taskKey);
+            // 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)`);
         }
         catch (err) {
-            console.log(`[user-tasks] Failed: ${task.title}: ${err.message}`);
-            reportExecutionLog(relayHttp, secretKey, agentName, "user_task", task.title, "failed", err.message, lastEngineTrace);
+            const duration = Date.now() - startTime;
+            console.log(`[user-tasks] Failed: ${taskKey}: ${err.message}`);
+            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 };
+            retry.count++;
+            if (retry.count <= USER_TASK_MAX_RETRIES) {
+                retry.nextAt = Date.now() + USER_TASK_RETRY_DELAY;
+                userTaskRetry.set(taskKey, retry);
+                console.log(`[user-tasks] Will retry ${taskKey} in ${USER_TASK_RETRY_DELAY / 1000}s (attempt ${retry.count}/${USER_TASK_MAX_RETRIES})`);
+                await appendTaskHistory(workdir, agentName, {
+                    ts: localNow(), id: taskKey, type: "user_task", status: "retry",
+                    duration_ms: duration, output_summary: "", error: err.message,
+                });
+            }
+            else {
+                userTaskRetry.delete(taskKey);
+                // Record run time so it waits for full interval before next attempt
+                const runs = await loadTaskRuns(workdir, agentName);
+                runs[taskKey] = localNow();
+                await saveTaskRuns(workdir, agentName, runs);
+                await appendTaskHistory(workdir, agentName, {
+                    ts: localNow(), id: taskKey, type: "user_task", status: "failed",
+                    duration_ms: duration, output_summary: "", error: err.message,
+                });
+                await notifyOwner(nurl, `${agentName}: ${taskKey} FAILED`, err.message.slice(0, 300), "high", ["x"]);
+            }
         }
         finally {
             engineBusy = false;
@@ -1774,7 +1948,9 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
                 biosBlock = `You are ${agentName}.\n\n`;
             }
         }
-        const identityLine = engine === "raw" ? biosBlock : `Read ${bios} for your identity.\n\n`;
+        const relayDirs = await loadDirectives(workdir, agentName);
+        const relayDirsBlock = buildDirectivesPrompt(relayDirs, "owner");
+        const identityLine = engine === "raw" ? `${biosBlock}${relayDirsBlock}` : `Read ${bios} for your identity.\n${relayDirsBlock}\n`;
         switch (task.type) {
             case "product_review": {
                 const myRes = await fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/products`);
@@ -1890,7 +2066,8 @@ Reply ONLY JSON: {"lessons":[{"agent_name":"...","topic":"short topic","content"
         let dueUserTasks = [];
         if (config.user_tasks) {
             try {
-                dueUserTasks = await getDueUserTasks(workdir, agentName);
+                const retryIds = new Set(userTaskRetry.keys());
+                dueUserTasks = await getDueUserTasks(workdir, agentName, retryIds);
             }
             catch { }
         }
@@ -1910,7 +2087,12 @@ Reply ONLY JSON: {"lessons":[{"agent_name":"...","topic":"short topic","content"
             });
         }
         for (const task of dueUserTasks) {
-            queue.push({ type: "user_task", id: task.title, urgent: false, data: task });
+            const taskKey = task.id || task.title;
+            // Skip if in retry cooldown
+            const rt = userTaskRetry.get(taskKey);
+            if (rt && Date.now() < rt.nextAt)
+                continue;
+            queue.push({ type: "user_task", id: taskKey, urgent: !!rt, data: task });
         }
         for (const task of relayTasks) {
             queue.push({ type: "relay_task", id: task.id, urgent: false, data: task });
@@ -2005,6 +2187,18 @@ export async function serve(options) {
                 res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(state, null, 2));
                 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;
+                const history = await loadTaskHistory(workdir, options.agentName, limit);
+                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(history, null, 2));
+                return;
+            }
+            if (req.url === "/self/directives" && req.method === "GET") {
+                const dirs = await loadDirectives(workdir, options.agentName);
+                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(dirs, null, 2));
+                return;
+            }
             if (req.url === "/self/canvas" && req.method === "GET") {
                 const entries = await loadRecentCanvasEntries(workdir, options.agentName, 10);
                 res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(entries, null, 2));

package/package.json

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