akemon 0.2.23 → 0.2.24

package/dist/engine-peripheral.js

@@ -24,9 +24,6 @@ export class EnginePeripheral {
     tags = ["engine", "llm"];
     config;
     bus = null;
-    /** Engine mutual exclusion — only one engine process at a time */
-    busy = false;
-    busySince = 0;
     /** Last execution trace (for error reporting) */
     lastTrace = [];
     constructor(config) {
@@ -70,38 +67,15 @@ export class EnginePeripheral {
         }, this.id);
     }
     // ---------------------------------------------------------------------------
-    // Engine mutex helpers
-    // ---------------------------------------------------------------------------
-    acquire() {
-        if (this.busy)
-            return false;
-        this.busy = true;
-        this.busySince = Date.now();
-        return true;
-    }
-    release() {
-        this.busy = false;
-        this.busySince = 0;
-    }
-    /** Watchdog: reset if stuck for > 10 min */
-    checkStuck() {
-        if (this.busy && this.busySince > 0 && Date.now() - this.busySince > 10 * 60 * 1000) {
-            console.log(`[watchdog] engine stuck for ${Math.round((Date.now() - this.busySince) / 1000)}s, force-resetting`);
-            this.release();
-            return true;
-        }
-        return false;
-    }
-    // ---------------------------------------------------------------------------
     // Unified engine runner
     // ---------------------------------------------------------------------------
-    async runEngine(task, allowAll, extraAllowedTools) {
+    async runEngine(task, allowAll, extraAllowedTools, signal) {
         const { engine, model, workdir } = this.config;
         if (engine === "raw") {
             return this.runRawEngine(task);
         }
         const cmd = buildEngineCommand(engine, model, allowAll ?? this.config.allowAll, extraAllowedTools);
-        return runCommand(cmd.cmd, cmd.args, task, workdir, cmd.stdinMode);
+        return runCommand(cmd.cmd, cmd.args, task, workdir, cmd.stdinMode, signal);
     }
     // ---------------------------------------------------------------------------
     // Raw engine: OpenAI-compatible API with tool call loop
@@ -390,7 +364,7 @@ function buildEngineCommand(engine, model, allowAll, extraAllowedTools) {
             return { cmd: engine, args: [], stdinMode: true };
     }
 }
-function runCommand(cmd, args, task, cwd, stdinMode = true) {
+function runCommand(cmd, args, task, cwd, stdinMode = true, signal) {
     return new Promise((resolve, reject) => {
         const { CLAUDECODE, ...cleanEnv } = process.env;
         const finalArgs = stdinMode ? args : [...args, task];
@@ -399,8 +373,30 @@ function runCommand(cmd, args, task, cwd, stdinMode = true) {
             cwd,
             env: cleanEnv,
             stdio: [stdinMode ? "pipe" : "ignore", "pipe", "pipe"],
-            timeout: 300_000,
         });
+        // Abort → SIGTERM, then SIGKILL after a grace period so a hung engine can't
+        // hold the slot past the caller's deadline.
+        let aborted = false;
+        const onAbort = () => {
+            if (aborted)
+                return;
+            aborted = true;
+            console.log(`[${cmd}] aborted, killing pid=${child.pid}`);
+            try {
+                child.kill("SIGTERM");
+            }
+            catch { }
+            setTimeout(() => { try {
+                child.kill("SIGKILL");
+            }
+            catch { } }, 3000).unref();
+        };
+        if (signal) {
+            if (signal.aborted)
+                onAbort();
+            else
+                signal.addEventListener("abort", onAbort, { once: true });
+        }
         if (stdinMode && child.stdin) {
             child.stdin.on("error", () => { });
             child.stdin.write(task);
@@ -414,12 +410,17 @@ function runCommand(cmd, args, task, cwd, stdinMode = true) {
         child.stderr?.on("data", (chunk) => {
             stderr += chunk.toString();
         });
-        child.on("close", (code) => {
-            console.log(`[${cmd}] exit=${code} stdout=${stdout.length}b stderr=${stderr.length}b`);
+        child.on("close", (code, killSignal) => {
+            signal?.removeEventListener("abort", onAbort);
+            console.log(`[${cmd}] exit=${code}${killSignal ? ` signal=${killSignal}` : ""} stdout=${stdout.length}b stderr=${stderr.length}b`);
             if (stderr)
                 console.log(`[${cmd}] stderr:\n${stderr}`);
             if (stdout)
                 console.log(`[${cmd}] stdout:\n${stdout}`);
+            if (aborted) {
+                reject(new Error(`${cmd} aborted`));
+                return;
+            }
             const output = stdout.trim();
             if (output) {
                 resolve(output);
@@ -428,6 +429,9 @@ function runCommand(cmd, args, task, cwd, stdinMode = true) {
                 reject(new Error(`${cmd} exited with code ${code}, no stdout`));
             }
         });
-        child.on("error", reject);
+        child.on("error", (err) => {
+            signal?.removeEventListener("abort", onAbort);
+            reject(err);
+        });
     });
 }

package/dist/engine-queue.js

@@ -0,0 +1,95 @@
+/**
+ * EngineQueue — priority-aware single-slot scheduler for the local engine.
+ *
+ * Only one engine subprocess may run at a time. All modules (orders, digestion,
+ * reflection, script activities, MCP ad-hoc calls, …) go through this queue so
+ * that higher-priority work does not starve behind background busywork.
+ *
+ * Ordering:
+ *   - When the slot is free, acquire() returns immediately.
+ *   - Otherwise callers wait; when the running job releases the slot, the
+ *     highest-priority waiter wins (FIFO within the same priority).
+ *   - If the caller's deadline elapses first, acquire() rejects with
+ *     "Engine busy timeout" and the caller is removed from the queue.
+ *
+ * Priority semantics (keep in sync with types.ts ComputeRequest.priority):
+ *   - high   — user-waiting work (orders, user tasks, direct MCP calls)
+ *   - normal — periodic self-maintenance that must not starve (digestion,
+ *              reflection)
+ *   - low    — background enrichment (platform tasks, script activities,
+ *              long-term, identity compression)
+ */
+const PRIORITY_RANK = { high: 3, normal: 2, low: 1 };
+export class EngineQueue {
+    busy = false;
+    busySince = 0;
+    waiters = [];
+    /** Wait up to `deadlineMs` for the slot, then take it. */
+    acquire(priority, deadlineMs) {
+        if (!this.busy) {
+            this.busy = true;
+            this.busySince = Date.now();
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                priority,
+                enqueuedAt: Date.now(),
+                resolve,
+                reject,
+                timer: setTimeout(() => {
+                    const idx = this.waiters.indexOf(waiter);
+                    if (idx >= 0)
+                        this.waiters.splice(idx, 1);
+                    reject(new Error(`Engine busy timeout (${Math.round(deadlineMs / 60000)} min)`));
+                }, deadlineMs),
+            };
+            this.waiters.push(waiter);
+        });
+    }
+    /** Release the slot and hand it to the best waiter, if any. */
+    release() {
+        const next = this.pickNext();
+        if (!next) {
+            this.busy = false;
+            this.busySince = 0;
+            return;
+        }
+        this.waiters.splice(this.waiters.indexOf(next), 1);
+        clearTimeout(next.timer);
+        this.busySince = Date.now();
+        next.resolve();
+    }
+    /** Take the slot synchronously (used by MCP fast-path when !isBusy). */
+    tryAcquire() {
+        if (this.busy)
+            return false;
+        this.busy = true;
+        this.busySince = Date.now();
+        return true;
+    }
+    isBusy() {
+        return this.busy;
+    }
+    queueDepth() {
+        return this.waiters.length;
+    }
+    /** How long has the current holder held the slot, in ms. 0 if free. */
+    heldMs() {
+        return this.busy && this.busySince ? Date.now() - this.busySince : 0;
+    }
+    pickNext() {
+        if (this.waiters.length === 0)
+            return null;
+        let best = this.waiters[0];
+        for (let i = 1; i < this.waiters.length; i++) {
+            const w = this.waiters[i];
+            const wr = PRIORITY_RANK[w.priority];
+            const br = PRIORITY_RANK[best.priority];
+            if (wr > br || (wr === br && w.enqueuedAt < best.enqueuedAt)) {
+                best = w;
+            }
+        }
+        return best;
+    }
+}

package/dist/reflection-module.js

@@ -183,7 +183,7 @@ ${discText}`,
 - Lower confidence on disproven beliefs
 
 Reply ONLY JSON: {"discoveries":[{"capability":"skill or lesson","confidence":0.0-1.0,"evidence":"what supports this"}]}`,
-            priority: "low",
+            priority: "normal",
         });
         if (result.success && result.response) {
             const parsed = extractJson(result.response);

package/dist/server.js

@@ -7,10 +7,15 @@ import { initWorld, initBioState, initGuide, getSelfState, loadRecentCanvasEntri
 // 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 +79,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 +98,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) {
     if (!_engineP) {
         throw new Error("Engine peripheral not initialized");
     }
-    const result = _engineP.runEngine(task, allowAll, extraAllowedTools);
+    const result = _engineP.runEngine(task, allowAll, extraAllowedTools, signal);
     // Sync trace back to module-level for reporting
     result.then(() => { lastEngineTrace = _engineP.lastTrace; }).catch(() => { lastEngineTrace = _engineP.lastTrace; });
     return result;
@@ -146,8 +152,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 +349,35 @@ 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;
-            }
-            if (Date.now() > deadline) {
-                return { success: false, error: "Engine busy timeout (5 min)" };
-            }
-            await new Promise(r => setTimeout(r, 2000));
+        try {
+            await engineQueue.acquire(req.priority, ENGINE_WAIT_DEADLINE_MS);
         }
-        engineBusy = true;
-        engineBusySince = Date.now();
+        catch (err) {
+            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 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
+            const response = await runEngine(options.engine || "claude", options.model, options.allowAll, prompt, workdir, req.tools, req.relay, abortController.signal);
             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();
         }
     }
     const moduleCtx = {
@@ -505,8 +506,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-module.js

@@ -557,7 +557,7 @@ Complete this task. Use the environment info above and tools (curl, etc.) as nee
             const result = await this.ctx.requestCompute({
                 context,
                 question,
-                priority: "normal",
+                priority: "low",
                 tools: ["Bash(curl *)"],
                 relay: this.relayHttp ? { http: this.relayHttp, agentName } : undefined,
             });

package/package.json

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