akemon 0.2.24 → 0.2.25

package/dist/role-module.test.js

@@ -0,0 +1,208 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { parseRole, parseProduct, resolveRoles, resolveProduct, buildRoleContext, } from "./role-module.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeRole(name, triggers = [], extras = {}) {
+    return { name, description: "", triggers, include: [], exclude: [], customRules: "", raw: "", ...extras };
+}
+function makeProduct(name, extras = {}) {
+    return { name, playbook: "", productIds: [], raw: "", ...extras };
+}
+function makePlaybook(name, raw = "") {
+    return { name, raw };
+}
+// ---------------------------------------------------------------------------
+// Pure parsing — parseRole
+// ---------------------------------------------------------------------------
+describe("parseRole — pure parsing", () => {
+    it("extracts description, triggers, include, exclude from standard role md", () => {
+        const raw = `# Sales Rep
+
+Expert in closing deals and building client relationships.
+
+## 激活
+- trigger:order
+- trigger:chat:public
+
+## 上下文范围
+include: buyer history, product catalog
+exclude: owner notes, private diary
+`;
+        const role = parseRole("sales-rep", raw);
+        assert.equal(role.name, "sales-rep");
+        assert.equal(role.description, "Expert in closing deals and building client relationships.");
+        assert.deepEqual(role.triggers, ["trigger:order", "trigger:chat:public"]);
+        assert.deepEqual(role.include, ["buyer history", "product catalog"]);
+        assert.deepEqual(role.exclude, ["owner notes", "private diary"]);
+    });
+    it("returns empty arrays for include/exclude/triggers when sections are missing", () => {
+        const raw = `# Simple Role
+
+A minimal role with no activation or context sections.
+`;
+        const role = parseRole("simple", raw);
+        assert.deepEqual(role.triggers, []);
+        assert.deepEqual(role.include, []);
+        assert.deepEqual(role.exclude, []);
+        assert.equal(role.description, "A minimal role with no activation or context sections.");
+    });
+    it("collects content outside 激活 and 上下文范围 into customRules", () => {
+        const raw = `# Worker
+
+Efficient task executor.
+
+## 激活
+- trigger:agent_call
+
+## Operating Principles
+Always reply in the language the user writes in.
+Be concise and accurate.
+
+## Tone
+Professional and neutral.
+`;
+        const role = parseRole("worker", raw);
+        assert.ok(role.customRules.includes("Always reply in the language the user writes in."), "should include content from ## Operating Principles");
+        assert.ok(role.customRules.includes("Professional and neutral."), "should include content from ## Tone");
+        // triggers and standard sections should not bleed in
+        assert.deepEqual(role.triggers, ["trigger:agent_call"]);
+    });
+});
+// ---------------------------------------------------------------------------
+// Pure parsing — parseProduct
+// ---------------------------------------------------------------------------
+describe("parseProduct — pure parsing", () => {
+    it("extracts playbook and multiple productIds correctly", () => {
+        const raw = `# Widget Pro
+
+## playbook
+widget-strategy
+
+## products
+- p_abc123
+- p_def456
+- p_ghi789
+`;
+        const product = parseProduct("widget-pro", raw);
+        assert.equal(product.name, "widget-pro");
+        assert.equal(product.playbook, "widget-strategy");
+        assert.deepEqual(product.productIds, ["p_abc123", "p_def456", "p_ghi789"]);
+    });
+    it("returns empty productIds when ## products section is absent", () => {
+        const raw = `# No Products
+
+## playbook
+some-playbook
+`;
+        const product = parseProduct("no-products", raw);
+        assert.deepEqual(product.productIds, []);
+        assert.equal(product.playbook, "some-playbook");
+    });
+    it("returns empty string for playbook when ## playbook section is absent", () => {
+        const raw = `# No Playbook
+
+## products
+- p_xyz
+`;
+        const product = parseProduct("no-playbook", raw);
+        assert.equal(product.playbook, "");
+        assert.deepEqual(product.productIds, ["p_xyz"]);
+    });
+});
+// ---------------------------------------------------------------------------
+// Resolution — resolveRoles
+// ---------------------------------------------------------------------------
+describe("resolveRoles — resolution", () => {
+    it("partial trigger match: first match is primary, remaining are secondary", () => {
+        const roles = [
+            makeRole("general-chat", ["trigger:chat"]),
+            makeRole("owner-companion", ["trigger:chat:owner"]),
+        ];
+        // "trigger:chat:owner" includes "trigger:chat" → both match
+        const { primary, secondary } = resolveRoles(roles, "trigger:chat:owner");
+        assert.equal(primary?.name, "general-chat");
+        assert.equal(secondary.length, 1);
+        assert.equal(secondary[0].name, "owner-companion");
+    });
+    it("returns primary=null and empty secondary when no trigger matches", () => {
+        const roles = [
+            makeRole("merchant", ["trigger:order"]),
+            makeRole("companion", ["trigger:chat:owner"]),
+        ];
+        const { primary, secondary } = resolveRoles(roles, "trigger:nonexistent");
+        assert.equal(primary, null);
+        assert.deepEqual(secondary, []);
+    });
+});
+// ---------------------------------------------------------------------------
+// Resolution — resolveProduct
+// ---------------------------------------------------------------------------
+describe("resolveProduct — resolution", () => {
+    const products = [
+        makeProduct("Alpha Product", { productIds: ["p_alpha"], playbook: "alpha-pb" }),
+        makeProduct("Beta Service", { productIds: ["p_beta"], playbook: "beta-pb" }),
+    ];
+    const playbooks = [
+        makePlaybook("alpha-pb", "# Alpha Playbook\nContent."),
+        makePlaybook("beta-pb", "# Beta Playbook\nContent."),
+    ];
+    it("productId takes priority over productName when both are provided", () => {
+        // productId matches "Alpha Product", productName matches "Beta Service"
+        const result = resolveProduct(products, playbooks, "Beta Service", "p_alpha");
+        assert.ok(result !== null);
+        assert.equal(result.product.name, "Alpha Product");
+    });
+    it("fuzzy name match is case- and separator-insensitive", () => {
+        // "alpha_product" → normalized "alphaproduct"
+        // "Alpha Product" → normalized "alphaproduct" → exact match
+        const result = resolveProduct(products, playbooks, "alpha_product");
+        assert.ok(result !== null);
+        assert.equal(result.product.name, "Alpha Product");
+    });
+    it("returns null when neither productId nor productName matches", () => {
+        const result = resolveProduct(products, playbooks, "Completely Unknown");
+        assert.equal(result, null);
+    });
+    it("playbook lookup is case-insensitive", () => {
+        const prods = [makeProduct("my-widget", { playbook: "My-Playbook", productIds: [] })];
+        const pbs = [makePlaybook("my-playbook", "# PB Content")];
+        const result = resolveProduct(prods, pbs, "my-widget");
+        assert.ok(result !== null);
+        assert.ok(result.playbook !== null);
+        assert.equal(result.playbook?.name, "my-playbook");
+    });
+});
+// ---------------------------------------------------------------------------
+// buildRoleContext — real fs with tmp dir
+// ---------------------------------------------------------------------------
+describe("buildRoleContext — fs integration", () => {
+    let tmpDir;
+    const agentName = "test-agent";
+    before(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), "akemon-test-"));
+        const selfBase = join(tmpDir, ".akemon", "agents", agentName, "self");
+        await mkdir(join(selfBase, "roles"), { recursive: true });
+        await mkdir(join(selfBase, "playbooks"), { recursive: true });
+        await mkdir(join(selfBase, "products"), { recursive: true });
+        await writeFile(join(selfBase, "roles", "worker.md"), `# 工人\n执行任务的专业角色。\n\n## 激活\n- trigger:order\n`);
+        await writeFile(join(selfBase, "playbooks", "strategy.md"), `# Strategy\n核心策略内容。\n`);
+        await writeFile(join(selfBase, "products", "widget.md"), `# Widget\n\n## playbook\nstrategy\n\n## products\n- p_1234\n`);
+    });
+    after(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it("matching trigger produces output with [Active role: ...]", async () => {
+        const result = await buildRoleContext(tmpDir, agentName, "trigger:order:001");
+        assert.ok(result.includes("[Active role: worker]"), `expected '[Active role: worker]' in:\n${result}`);
+    });
+    it("passing productName produces output with [Product: ...] and [Playbook: ...]", async () => {
+        const result = await buildRoleContext(tmpDir, agentName, "trigger:other", "widget");
+        assert.ok(result.includes("[Product: widget]"), `expected '[Product: widget]' in:\n${result}`);
+        assert.ok(result.includes("[Playbook: strategy]"), `expected '[Playbook: strategy]' in:\n${result}`);
+    });
+});

package/dist/script-module.js

@@ -273,6 +273,7 @@ export class ScriptModule {
                     priority: "low",
                     tools: ["Bash(curl *)"],
                     relay: this.relayHttp ? { http: this.relayHttp, agentName } : undefined,
+                    origin: "self_cycle",
                 });
                 if (result.success) {
                     // Post-process if defined

package/dist/server.js

@@ -1,6 +1,7 @@
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { exec } from "child_process";
+import { scanAndKillOrphans } from "./orphan-scan.js";
 import { createServer } from "http";
 import { createInterface } from "readline";
 import { initWorld, initBioState, initGuide, getSelfState, loadRecentCanvasEntries, initAgentConfig, loadAgentConfig, loadDirectives, loadTaskHistory, reviveAgent, } from "./self.js";
@@ -98,11 +99,11 @@ const LLM_ENGINES = LLM_ENGINES_SET;
 // Engine execution — delegates to EnginePeripheral (V2 Step 3)
 // ---------------------------------------------------------------------------
 /** Unified engine runner — delegates to EnginePeripheral */
-function runEngine(engine, model, allowAll, task, workdir, extraAllowedTools, relay, signal) {
+function runEngine(engine, model, allowAll, task, workdir, extraAllowedTools, relay, signal, origin, routing) {
     if (!_engineP) {
         throw new Error("Engine peripheral not initialized");
     }
-    const result = _engineP.runEngine(task, allowAll, extraAllowedTools, signal);
+    const result = _engineP.runEngine(task, allowAll, extraAllowedTools, signal, origin, routing);
     // Sync trace back to module-level for reporting
     result.then(() => { lastEngineTrace = _engineP.lastTrace; }).catch(() => { lastEngineTrace = _engineP.lastTrace; });
     return result;
@@ -111,6 +112,8 @@ function runEngine(engine, model, allowAll, task, workdir, extraAllowedTools, re
 // pullFromRelay → see relay-peripheral.ts
 export async function serve(options) {
     const workdir = options.workdir || process.cwd();
+    // Reclaim stale CLI children from any previous daemon crash before starting.
+    await scanAndKillOrphans();
     // V2: Relay peripheral — unified relay API access
     const relay = new RelayPeripheral({
         httpUrl: options.relayHttp || "",
@@ -353,10 +356,25 @@ export async function serve(options) {
     // hard timeout, and release. The slot release and subprocess kill are both
     // driven by the same AbortController so a stuck engine can't hold the lock.
     async function requestCompute(req) {
+        // Load latest agent config for routing table (fast file read, changes rarely)
+        const agentCfg = await loadAgentConfig(workdir, options.agentName);
+        const routing = agentCfg.engine_routing;
+        // user_manual tasks also hold a subscription-CLI semaphore to cap claude CLI concurrency
+        const isUserManual = req.origin === "user_manual";
+        if (isUserManual) {
+            try {
+                await engineQueue.acquireUserManualSlot(ENGINE_WAIT_DEADLINE_MS);
+            }
+            catch (err) {
+                return { success: false, error: err.message || "User manual slot timeout" };
+            }
+        }
         try {
             await engineQueue.acquire(req.priority, ENGINE_WAIT_DEADLINE_MS);
         }
         catch (err) {
+            if (isUserManual)
+                engineQueue.releaseUserManualSlot();
             return { success: false, error: err.message || "Engine busy timeout" };
         }
         const prompt = req.context
@@ -365,7 +383,7 @@ export async function serve(options) {
         const abortController = new AbortController();
         const timer = setTimeout(() => abortController.abort(), ENGINE_EXEC_TIMEOUT_MS);
         try {
-            const response = await runEngine(options.engine || "claude", options.model, options.allowAll, prompt, workdir, req.tools, req.relay, abortController.signal);
+            const response = await runEngine(options.engine || "claude", options.model, options.allowAll, prompt, workdir, req.tools, req.relay, abortController.signal, req.origin, routing);
             emitTokenUsage(prompt.length, response.length);
             return { success: true, response };
         }
@@ -378,6 +396,8 @@ export async function serve(options) {
         finally {
             clearTimeout(timer);
             engineQueue.release();
+            if (isUserManual)
+                engineQueue.releaseUserManualSlot();
         }
     }
     const moduleCtx = {
@@ -480,9 +500,13 @@ export async function serve(options) {
         engine: options.engine,
         modules: loadedModules,
     }));
-    // Graceful shutdown
+    // Graceful shutdown — kill engine children first, then stop modules.
+    // Engine children are killed via process group signal so any sub-forks
+    // (e.g. opencode's internal Node workers) are also terminated.
     const shutdown = async () => {
         console.log("[v2] Shutting down...");
+        if (_engineP)
+            _engineP.killAllChildren();
         bus.emit(SIG.AGENT_STOP, sig(SIG.AGENT_STOP, {}));
         for (const m of allModules) {
             try {

package/dist/task-helpers.js

@@ -0,0 +1,26 @@
+/** Eisenhower sort: smaller quadrant number first */
+export function sortByQuadrant(items) {
+    return [...items].sort((a, b) => a.quadrant - b.quadrant);
+}
+/** Dedup by type+id composite key, preserving first occurrence */
+export function dedupeWorkItems(items) {
+    const seen = new Set();
+    return items.filter(it => {
+        const key = `${it.type}:${it.id}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/** Retry intervals for order execution failures */
+export const RETRY_INTERVALS = [0, 30_000, 5 * 60_000, 30 * 60_000, 2 * 3600_000];
+/**
+ * Returns next retry delay in ms given the current retry count, or null if exhausted.
+ * count=0 → first retry (0ms). count=intervals.length → null (give up).
+ */
+export function computeRetryDelay(count, intervals = RETRY_INTERVALS) {
+    if (count < 0 || count >= intervals.length)
+        return null;
+    return intervals[count];
+}

package/dist/task-helpers.test.js

@@ -0,0 +1,88 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { sortByQuadrant, dedupeWorkItems, computeRetryDelay, RETRY_INTERVALS } from "./task-helpers.js";
+describe("sortByQuadrant", () => {
+    it("empty array returns empty array", () => {
+        assert.deepStrictEqual(sortByQuadrant([]), []);
+    });
+    it("does not modify the input array", () => {
+        const items = [
+            { quadrant: 3, id: "a" },
+            { quadrant: 1, id: "b" },
+        ];
+        const original = [...items];
+        sortByQuadrant(items);
+        assert.deepStrictEqual(items, original, "input array must not be mutated");
+    });
+    it("sorts ascending by quadrant", () => {
+        const items = [
+            { quadrant: 4, id: "d" },
+            { quadrant: 2, id: "b" },
+            { quadrant: 3, id: "c" },
+            { quadrant: 1, id: "a" },
+        ];
+        const result = sortByQuadrant(items);
+        assert.deepStrictEqual(result.map(i => i.quadrant), [1, 2, 3, 4]);
+    });
+    it("is stable: equal-quadrant items preserve original order", () => {
+        const items = [
+            { quadrant: 2, id: "first" },
+            { quadrant: 1, id: "solo" },
+            { quadrant: 2, id: "second" },
+        ];
+        const result = sortByQuadrant(items);
+        assert.strictEqual(result[0].id, "solo");
+        assert.strictEqual(result[1].id, "first", "first Q2 item should come before second Q2 item");
+        assert.strictEqual(result[2].id, "second");
+    });
+});
+describe("dedupeWorkItems", () => {
+    it("different type, same id are kept (not considered duplicates)", () => {
+        const items = [
+            { type: "order", id: "abc" },
+            { type: "user_task", id: "abc" },
+        ];
+        const result = dedupeWorkItems(items);
+        assert.strictEqual(result.length, 2, "order:abc and user_task:abc must both survive");
+    });
+    it("same type+id: only first occurrence is kept", () => {
+        const items = [
+            { type: "order", id: "x", extra: 1 },
+            { type: "order", id: "x", extra: 2 },
+        ];
+        const result = dedupeWorkItems(items);
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].extra, 1, "first occurrence must be preserved");
+    });
+    it("returns empty array for empty input", () => {
+        assert.deepStrictEqual(dedupeWorkItems([]), []);
+    });
+});
+describe("computeRetryDelay", () => {
+    it("count=0 returns 0 (immediate first retry)", () => {
+        assert.strictEqual(computeRetryDelay(0), 0);
+    });
+    it("count=1 returns 30_000", () => {
+        assert.strictEqual(computeRetryDelay(1), 30_000);
+    });
+    it("count=4 returns 7_200_000 (2h)", () => {
+        assert.strictEqual(computeRetryDelay(4), 2 * 3600_000);
+    });
+    it("count=5 returns null (exhausted)", () => {
+        assert.strictEqual(computeRetryDelay(5), null);
+    });
+    it("count=-1 returns null (negative treated as exhausted)", () => {
+        assert.strictEqual(computeRetryDelay(-1), null);
+    });
+    it("uses RETRY_INTERVALS as default intervals", () => {
+        for (let i = 0; i < RETRY_INTERVALS.length; i++) {
+            assert.strictEqual(computeRetryDelay(i), RETRY_INTERVALS[i]);
+        }
+    });
+    it("accepts a custom intervals array", () => {
+        const custom = [100, 200, 300];
+        assert.strictEqual(computeRetryDelay(0, custom), 100);
+        assert.strictEqual(computeRetryDelay(2, custom), 300);
+        assert.strictEqual(computeRetryDelay(3, custom), null);
+    });
+});

package/dist/task-module.js

@@ -13,12 +13,14 @@ import { SIG, sig } from "./types.js";
 import { selfDir, biosPath, localNow, loadBioState, saveBioState, syncEnergyFromTokens, loadAgentConfig, getDueUserTasks, loadTaskRuns, saveTaskRuns, loadDirectives, buildDirectivesPrompt, appendTaskHistory, notifyOwner, updateHungerDecay, updateNaturalDecay, resetTokenCountIfNewDay, computeSociability, appendBioEvent, bioStatePromptModifier, feedHunger, SHOP_ITEMS, logBioStatus, logBioDecision, } from "./self.js";
 import { appendMessage } from "./context.js";
 import { buildRoleContext } from "./role-module.js";
+import { sortByQuadrant, dedupeWorkItems, computeRetryDelay } from "./task-helpers.js";
+import { updateMetrics } from "./metrics.js";
+import { downgradeForRetry } from "./engine-routing.js";
 // ---------------------------------------------------------------------------
 // Config
 // ---------------------------------------------------------------------------
 const INITIAL_DELAY = 60_000; // 1 min after startup
 const POLL_INTERVAL = 30_000; // 30s between polls
-const RETRY_INTERVALS = [0, 30_000, 5 * 60_000, 30 * 60_000, 2 * 3600_000];
 const USER_TASK_MAX_RETRIES = 2;
 const USER_TASK_RETRY_DELAY = 2 * 60_000;
 export class TaskModule {
@@ -82,6 +84,7 @@ export class TaskModule {
             module: "task",
             pendingRetries: this.orderRetry.size + this.userTaskRetry.size,
             gaveUp: this.gaveUp.size,
+            executing: this.executing.size,
         };
     }
     /** Push-notify an urgent order (bypasses poll interval) */
@@ -140,9 +143,12 @@ export class TaskModule {
                     if (retry && Date.now() < retry.nextAt)
                         continue;
                     const urgent = this.urgentOrderIds.has(order.id);
+                    const isRetry = this.orderRetry.has(order.id);
+                    const rawOrigin = order.human_origin ? "user_manual" : "platform";
                     queue.push({
                         type: "order", id: order.id,
                         quadrant: urgent ? 1 : 2, // orders are important (paid work)
+                        origin: isRetry ? downgradeForRetry(rawOrigin) : rawOrigin,
                         data: order,
                     });
                 }
@@ -162,6 +168,7 @@ export class TaskModule {
                     queue.push({
                         type: "user_task", id: taskKey,
                         quadrant: rt ? 1 : 2, // retries are urgent+important
+                        origin: rt ? downgradeForRetry("user_manual") : "user_manual",
                         data: task,
                     });
                 }
@@ -176,6 +183,7 @@ export class TaskModule {
                     queue.push({
                         type: "relay_task", id: task.id,
                         quadrant: 3, // urgent but less important
+                        origin: "platform",
                         data: task,
                     });
                 }
@@ -197,16 +205,9 @@ export class TaskModule {
         }
         logBioStatus(bio, "work-active");
         // --- Eisenhower sort: Q1 > Q2 > Q3 > Q4 ---
-        queue.sort((a, b) => a.quadrant - b.quadrant);
+        const sorted = sortByQuadrant(queue);
         // Dedup
-        const seen = new Set();
-        const deduped = queue.filter(item => {
-            const key = `${item.type}:${item.id}`;
-            if (seen.has(key))
-                return false;
-            seen.add(key);
-            return true;
-        });
+        const deduped = dedupeWorkItems(sorted);
         // Bio filtering (fear & boredom)
         const filtered = await this.applyBioFilter(deduped, bio);
         if (!filtered.length)
@@ -215,18 +216,20 @@ export class TaskModule {
         // Execute sequentially
         for (const item of filtered) {
             try {
-                if (item.type === "order")
+                if (item.type === "order") {
                     this.executing.add(item.id);
+                    updateMetrics({ task_executing: this.executing.size });
+                }
                 switch (item.type) {
                     case "order":
-                        await this.executeOrder(item.data);
+                        await this.executeOrder(item.data, item.origin);
                         this.urgentOrderIds.delete(item.id);
                         break;
                     case "user_task":
-                        await this.executeUserTask(item.data);
+                        await this.executeUserTask(item.data, item.origin);
                         break;
                     case "relay_task":
-                        await this.executeRelayTask(item.data);
+                        await this.executeRelayTask(item.data, item.origin);
                         break;
                 }
             }
@@ -234,8 +237,13 @@ export class TaskModule {
                 console.log(`[task] Error processing ${item.type}:${item.id}: ${err.message}`);
             }
             finally {
-                if (item.type === "order")
+                if (item.type === "order") {
                     this.executing.delete(item.id);
+                    updateMetrics({
+                        task_executing: this.executing.size,
+                        task_pending_retries: this.orderRetry.size + this.userTaskRetry.size,
+                    });
+                }
             }
         }
         bus.emit(SIG.CYCLE_END, sig(SIG.CYCLE_END, { ts: Date.now() }));
@@ -291,7 +299,7 @@ export class TaskModule {
     // ---------------------------------------------------------------------------
     // Execute order
     // ---------------------------------------------------------------------------
-    async executeOrder(order) {
+    async executeOrder(order, origin = "platform") {
         if (!this.ctx)
             return;
         const { workdir, agentName, bus } = this.ctx;
@@ -340,13 +348,14 @@ RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
             const orderConvId = `pub_${buyerPubId}${productScope}`;
             const orderUserMsg = order.buyer_task || "(no message)";
             await appendMessage(workdir, agentName, orderConvId, "User", orderUserMsg);
-            console.log(`[task] Fulfilling order ${order.id}...`);
+            console.log(`[task] Fulfilling order ${order.id}... (origin=${origin})`);
             const result = await this.ctx.requestCompute({
                 context,
                 question,
                 priority: "high",
                 tools: ["Bash(curl *)"],
                 relay: this.relayHttp ? { http: this.relayHttp, agentName } : undefined,
+                origin,
             });
             if (!result.success)
                 throw new Error(result.error || "compute failed");
@@ -400,10 +409,11 @@ RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
             // Retry logic
             const current = this.orderRetry.get(order.id) || { count: 0, nextAt: 0 };
             current.count++;
-            if (current.count < RETRY_INTERVALS.length) {
-                current.nextAt = Date.now() + RETRY_INTERVALS[current.count];
+            const delay = computeRetryDelay(current.count);
+            if (delay !== null) {
+                current.nextAt = Date.now() + delay;
                 this.orderRetry.set(order.id, current);
-                console.log(`[task] Retry ${order.id} in ${RETRY_INTERVALS[current.count] / 1000}s`);
+                console.log(`[task] Retry ${order.id} in ${delay / 1000}s`);
                 try {
                     await relay.extendOrder(order.id);
                 }
@@ -423,7 +433,7 @@ RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
     // ---------------------------------------------------------------------------
     // Execute user task
     // ---------------------------------------------------------------------------
-    async executeUserTask(task) {
+    async executeUserTask(task, origin = "user_manual") {
         if (!this.ctx)
             return;
         const { workdir, agentName, bus } = this.ctx;
@@ -458,6 +468,7 @@ Your personal directory: ${sd}/`;
                 priority: "high",
                 tools: ["Bash(curl *)"],
                 relay: this.relayHttp ? { http: this.relayHttp, agentName } : undefined,
+                origin,
             });
             if (!result.success)
                 throw new Error(result.error || "compute failed");
@@ -483,8 +494,9 @@ Your personal directory: ${sd}/`;
             relay?.reportLog("user_task", taskKey, "failed", err.message, []);
             const retry = this.userTaskRetry.get(taskKey) || { count: 0, nextAt: 0 };
             retry.count++;
-            if (retry.count <= USER_TASK_MAX_RETRIES) {
-                retry.nextAt = Date.now() + USER_TASK_RETRY_DELAY;
+            const retryDelay = computeRetryDelay(retry.count);
+            if (retryDelay !== null) {
+                retry.nextAt = Date.now() + retryDelay;
                 this.userTaskRetry.set(taskKey, retry);
                 await appendTaskHistory(workdir, agentName, {
                     ts: localNow(), id: taskKey, type: "user_task", status: "retry",
@@ -508,7 +520,7 @@ Your personal directory: ${sd}/`;
     // ---------------------------------------------------------------------------
     // Execute relay platform task
     // ---------------------------------------------------------------------------
-    async executeRelayTask(task) {
+    async executeRelayTask(task, origin = "platform") {
         if (!this.ctx)
             return;
         const { workdir, agentName, bus } = this.ctx;
@@ -560,6 +572,7 @@ Complete this task. Use the environment info above and tools (curl, etc.) as nee
                 priority: "low",
                 tools: ["Bash(curl *)"],
                 relay: this.relayHttp ? { http: this.relayHttp, agentName } : undefined,
+                origin,
             });
             if (!result.success)
                 throw new Error(result.error || "compute failed");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akemon",
-  "version": "0.2.24",
+  "version": "0.2.25",
   "description": "Agent work marketplace — train your agent, let it work for others",
   "type": "module",
   "license": "MIT",
@@ -28,7 +28,8 @@
     "build": "tsc && cp src/live.html dist/live.html",
     "dev": "tsc --watch",
     "start": "node dist/cli.js",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "tsc -p tsconfig.test.json && node --test test-dist/*.test.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",