akemon 0.2.23 → 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,16 +1,22 @@
 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";
 // V2: module-level instances (set in serve())
 let _engineP = null;
 let _bus = null;
-// Engine mutual exclusion — module-level state (unified in Step 6)
-let engineBusy = false;
-let engineBusySince = 0;
+// Engine mutual exclusion — priority queue so modules can't starve each other
+const engineQueue = new EngineQueue();
 let lastEngineTrace = [];
+// How long a caller will wait for the engine slot before giving up.
+const ENGINE_WAIT_DEADLINE_MS = 5 * 60 * 1000;
+// Hard cap on a single engine run. Beyond this the subprocess is aborted so
+// the slot is returned to the queue. Shorter than the old 8 min — opencode
+// runs that take longer almost always hang forever.
+const ENGINE_EXEC_TIMEOUT_MS = 3 * 60 * 1000;
 // ---------------------------------------------------------------------------
 // V2 Event helpers — emit signals to EventBus
 // ---------------------------------------------------------------------------
@@ -74,6 +80,7 @@ function promptOwner(task, isHuman) {
 }
 import { RelayPeripheral } from "./relay-peripheral.js";
 import { EnginePeripheral, LLM_ENGINES as LLM_ENGINES_SET } from "./engine-peripheral.js";
+import { EngineQueue } from "./engine-queue.js";
 import { BioStateModule } from "./bio-module.js";
 import { MemoryModule } from "./memory-module.js";
 import { RoleModule } from "./role-module.js";
@@ -92,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) {
+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);
+    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;
@@ -105,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 || "",
@@ -146,8 +155,13 @@ export async function serve(options) {
         promptOwner,
         runCollaborativeQuery: (task, selfName, relayHttp, engine, model, allowAll, workdir, relay) => runCollaborativeQuery(task, selfName, relayHttp, engine, model, allowAll, workdir, runEngine, relay),
         autoRoute,
-        isEngineBusy: () => engineBusy,
-        setEngineBusy: (busy) => { engineBusy = busy; engineBusySince = busy ? Date.now() : 0; },
+        isEngineBusy: () => engineQueue.isBusy(),
+        setEngineBusy: (busy) => {
+            if (busy)
+                engineQueue.tryAcquire();
+            else
+                engineQueue.release();
+        },
         emitTaskCompleted,
     };
     const httpServer = createServer(async (req, res) => {
@@ -338,45 +352,52 @@ export async function serve(options) {
     const bus = new SimpleEventBus();
     // Peripheral registry — Core routes by capability
     const peripherals = [relay, engineP];
-    // requestCompute: queue for engine, execute, return result
+    // requestCompute: acquire the engine slot (priority-aware), execute with a
+    // 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) {
-        // Wait for engine to become free (poll with backoff, max 5 min)
-        const deadline = Date.now() + 5 * 60 * 1000;
-        while (engineBusy) {
-            // If engine has been busy for >10 min, it's stuck — force release
-            if (engineBusySince && Date.now() - engineBusySince > 10 * 60 * 1000) {
-                console.log(`[engine] Force-releasing stuck engine lock (busy for ${Math.round((Date.now() - engineBusySince) / 60000)}min)`);
-                engineBusy = false;
-                engineBusySince = 0;
-                break;
+        // 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);
             }
-            if (Date.now() > deadline) {
-                return { success: false, error: "Engine busy timeout (5 min)" };
+            catch (err) {
+                return { success: false, error: err.message || "User manual slot timeout" };
             }
-            await new Promise(r => setTimeout(r, 2000));
         }
-        engineBusy = true;
-        engineBusySince = Date.now();
         try {
-            const prompt = req.context
-                ? `${req.context}\n\n---\n\n${req.question}`
-                : req.question;
-            // Hard timeout: if engine doesn't respond in 8 min, give up
-            const engineTimeout = new Promise((_, reject) => setTimeout(() => reject(new Error("Engine execution timeout (8 min)")), 8 * 60 * 1000));
-            const response = await Promise.race([
-                runEngine(options.engine || "claude", options.model, options.allowAll, prompt, workdir, req.tools, req.relay),
-                engineTimeout,
-            ]);
-            // Track token usage via EventBus
+            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
+            ? `${req.context}\n\n---\n\n${req.question}`
+            : req.question;
+        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, req.origin, routing);
             emitTokenUsage(prompt.length, response.length);
             return { success: true, response };
         }
         catch (err) {
-            return { success: false, error: err.message || String(err) };
+            const msg = abortController.signal.aborted
+                ? `Engine execution timeout (${Math.round(ENGINE_EXEC_TIMEOUT_MS / 60000)} min)`
+                : (err.message || String(err));
+            return { success: false, error: msg };
         }
         finally {
-            engineBusy = false;
-            engineBusySince = 0;
+            clearTimeout(timer);
+            engineQueue.release();
+            if (isUserManual)
+                engineQueue.releaseUserManualSlot();
         }
     }
     const moduleCtx = {
@@ -479,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 {
@@ -505,8 +530,13 @@ export async function serveStdio(agentName, workdir) {
         promptOwner,
         runCollaborativeQuery: (task, selfName, relayHttp, engine, model, allowAll, workdir, relay) => runCollaborativeQuery(task, selfName, relayHttp, engine, model, allowAll, workdir, runEngine, relay),
         autoRoute,
-        isEngineBusy: () => engineBusy,
-        setEngineBusy: (busy) => { engineBusy = busy; engineBusySince = busy ? Date.now() : 0; },
+        isEngineBusy: () => engineQueue.isBusy(),
+        setEngineBusy: (busy) => {
+            if (busy)
+                engineQueue.tryAcquire();
+            else
+                engineQueue.release();
+        },
         emitTaskCompleted,
     };
     const mcpServer = createMcpServer({ workdir: dir, agentName, publisherIds: new Map() }, stdioMcpDeps);

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);
+    });
+});