akemon 0.2.27 → 0.3.0

package/dist/engine-peripheral.js

@@ -8,15 +8,22 @@
  *   - CLI engines (claude, codex, opencode, gemini): spawn child process
  *   - Raw engine: OpenAI-compatible API with tool call loop (Ollama, llama.cpp, etc)
  */
+import { randomUUID } from "crypto";
 import { spawn, exec } from "child_process";
+import { StringDecoder } from "string_decoder";
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { join, dirname, isAbsolute } from "path";
-import { callAgent } from "./relay-client.js";
+import { callAgent, sendTaskEnd, sendTaskStart, sendTaskStream } from "./relay-client.js";
 import { SIG, sig } from "./types.js";
 import { updateMetrics, pushExecMs } from "./metrics.js";
 import { sendFailureEvent } from "./relay-client.js";
 import { resolveEngineConfig, } from "./engine-routing.js";
 export const LLM_ENGINES = new Set(["claude", "codex", "opencode", "gemini", "raw"]);
+const defaultTaskRelay = {
+    sendTaskStart,
+    sendTaskStream,
+    sendTaskEnd,
+};
 // ---------------------------------------------------------------------------
 // EnginePeripheral
 // ---------------------------------------------------------------------------
@@ -93,7 +100,7 @@ export class EnginePeripheral {
     // ---------------------------------------------------------------------------
     // Unified engine runner
     // ---------------------------------------------------------------------------
-    async runEngine(task, allowAll, extraAllowedTools, signal, origin, routing) {
+    async runEngine(task, allowAll, extraAllowedTools, signal, origin, routing, taskId) {
         const entry = resolveEngineConfig(routing, origin);
         const cfg = entry ? applyRoutingEntry(this.config, entry) : this.config;
         if (origin && entry) {
@@ -105,7 +112,7 @@ export class EnginePeripheral {
                 return await this.runRawEngine(task, cfg);
             }
             const cmd = buildEngineCommand(cfg.engine, cfg.model, allowAll ?? cfg.allowAll, extraAllowedTools);
-            return await runCommand(cmd.cmd, cmd.args, task, cfg.workdir, cmd.stdinMode, signal, this.activeChildren);
+            return await runCommand(cmd.cmd, cmd.args, task, cfg.workdir, cmd.stdinMode, signal, this.activeChildren, origin, taskId, cfg.taskRelay ?? defaultTaskRelay, cfg.spawnImpl ?? spawn);
         }
         finally {
             pushExecMs(Date.now() - t0);
@@ -420,17 +427,36 @@ function buildEngineCommand(engine, model, allowAll, extraAllowedTools) {
             return { cmd: engine, args: [], stdinMode: true };
     }
 }
-function runCommand(cmd, args, task, cwd, stdinMode = true, signal, activeChildren) {
+function runCommand(cmd, args, task, cwd, stdinMode = true, signal, activeChildren, origin, taskId, taskRelay = defaultTaskRelay, spawnImpl = spawn) {
     return new Promise((resolve, reject) => {
         const { CLAUDECODE, ...cleanEnv } = process.env;
         const finalArgs = stdinMode ? args : [...args, task];
+        const effectiveTaskId = taskId || `task_${Date.now()}_${randomUUID().slice(0, 8)}`;
+        const commandLine = [cmd, ...finalArgs].join(" ");
+        const startedAt = Date.now();
+        let endPublished = false;
         console.log(`[engine] Running: ${cmd} ${finalArgs.join(" ")}`);
-        const child = spawn(cmd, finalArgs, {
-            cwd,
-            env: cleanEnv,
-            stdio: [stdinMode ? "pipe" : "ignore", "pipe", "pipe"],
-            detached: true, // child becomes process-group leader; enables pgid kill
-        });
+        taskRelay?.sendTaskStart(effectiveTaskId, origin, commandLine);
+        const publishEnd = (code) => {
+            if (endPublished)
+                return;
+            endPublished = true;
+            taskRelay?.sendTaskEnd(effectiveTaskId, code, Date.now() - startedAt);
+        };
+        let child;
+        try {
+            child = spawnImpl(cmd, finalArgs, {
+                cwd,
+                env: cleanEnv,
+                stdio: [stdinMode ? "pipe" : "ignore", "pipe", "pipe"],
+                detached: true, // child becomes process-group leader; enables pgid kill
+            });
+        }
+        catch (err) {
+            publishEnd(null);
+            reject(err);
+            return;
+        }
         if (activeChildren) {
             activeChildren.add(child);
             updateMetrics({ engine_children_active: activeChildren.size });
@@ -469,14 +495,35 @@ function runCommand(cmd, args, task, cwd, stdinMode = true, signal, activeChildr
         }
         let stdout = "";
         let stderr = "";
+        const outDecoder = new StringDecoder("utf8");
+        const errDecoder = new StringDecoder("utf8");
         child.stdout?.on("data", (chunk) => {
-            stdout += chunk.toString();
+            const text = outDecoder.write(chunk);
+            if (!text)
+                return;
+            stdout += text;
+            taskRelay?.sendTaskStream(effectiveTaskId, "stdout", text);
         });
         child.stderr?.on("data", (chunk) => {
-            stderr += chunk.toString();
+            const text = errDecoder.write(chunk);
+            if (!text)
+                return;
+            stderr += text;
+            taskRelay?.sendTaskStream(effectiveTaskId, "stderr", text);
         });
         child.on("close", (code, killSignal) => {
             signal?.removeEventListener("abort", onAbort);
+            const tailOut = outDecoder.end();
+            const tailErr = errDecoder.end();
+            if (tailOut) {
+                stdout += tailOut;
+                taskRelay?.sendTaskStream(effectiveTaskId, "stdout", tailOut);
+            }
+            if (tailErr) {
+                stderr += tailErr;
+                taskRelay?.sendTaskStream(effectiveTaskId, "stderr", tailErr);
+            }
+            publishEnd(code);
             if (activeChildren) {
                 activeChildren.delete(child);
                 updateMetrics({ engine_children_active: activeChildren.size });
@@ -501,6 +548,7 @@ function runCommand(cmd, args, task, cwd, stdinMode = true, signal, activeChildr
         });
         child.on("error", (err) => {
             signal?.removeEventListener("abort", onAbort);
+            publishEnd(null);
             if (activeChildren) {
                 activeChildren.delete(child);
                 updateMetrics({ engine_children_active: activeChildren.size });

package/dist/engine-stream.test.js

@@ -0,0 +1,103 @@
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { describe, it } from "node:test";
+import { PassThrough } from "node:stream";
+import { EnginePeripheral } from "./engine-peripheral.js";
+function createFakeChild() {
+    const child = new EventEmitter();
+    child.stdin = new PassThrough();
+    child.stdout = new PassThrough();
+    child.stderr = new PassThrough();
+    Object.defineProperty(child, "pid", { value: 12345, configurable: true });
+    child.unref = () => child;
+    return child;
+}
+describe("Engine stream publish", () => {
+    it("publishes task lifecycle and stdout/stderr chunks", async () => {
+        const events = [];
+        let spawnedChild = null;
+        const engine = new EnginePeripheral({
+            engine: "claude",
+            workdir: "/tmp",
+            spawnImpl: ((cmd, args) => {
+                assert.equal(cmd, "claude");
+                assert.deepEqual(args, ["--print"]);
+                const child = createFakeChild();
+                spawnedChild = child;
+                queueMicrotask(() => {
+                    child.stdout?.emit("data", Buffer.from("hello "));
+                    child.stderr?.emit("data", Buffer.from("warn"));
+                    child.stdout?.emit("data", Buffer.from("world"));
+                    child.emit("close", 0, null);
+                });
+                return child;
+            }),
+            taskRelay: {
+                sendTaskStart(taskId, origin, cmd) {
+                    events.push({ type: "start", taskId, origin, cmd });
+                },
+                sendTaskStream(taskId, stream, chunk) {
+                    events.push({ type: "stream", taskId, stream, chunk });
+                },
+                sendTaskEnd(taskId, exitCode, durationMs) {
+                    events.push({ type: "end", taskId, exitCode, durationMs });
+                },
+            },
+        });
+        const result = await engine.runEngine("say hello", false, undefined, undefined, "user_manual", undefined, "order-123");
+        assert.equal(result, "hello world");
+        assert.ok(spawnedChild, "spawn should be called");
+        assert.deepEqual(events.slice(0, 4), [
+            { type: "start", taskId: "order-123", origin: "user_manual", cmd: "claude --print" },
+            { type: "stream", taskId: "order-123", stream: "stdout", chunk: "hello " },
+            { type: "stream", taskId: "order-123", stream: "stderr", chunk: "warn" },
+            { type: "stream", taskId: "order-123", stream: "stdout", chunk: "world" },
+        ]);
+        const end = events[4];
+        assert.equal(end?.type, "end");
+        if (end?.type === "end") {
+            assert.equal(end.taskId, "order-123");
+            assert.equal(end.exitCode, 0);
+            assert.ok(end.durationMs >= 0);
+        }
+    });
+    it("generates a task id when caller does not provide one", async () => {
+        const events = [];
+        const engine = new EnginePeripheral({
+            engine: "opencode",
+            workdir: "/tmp",
+            spawnImpl: (() => {
+                const child = createFakeChild();
+                queueMicrotask(() => {
+                    child.stdout?.emit("data", Buffer.from("done"));
+                    child.emit("close", 0, null);
+                });
+                return child;
+            }),
+            taskRelay: {
+                sendTaskStart(taskId, origin, cmd) {
+                    events.push({ type: "start", taskId, origin, cmd });
+                },
+                sendTaskStream(taskId, stream, chunk) {
+                    events.push({ type: "stream", taskId, stream, chunk });
+                },
+                sendTaskEnd(taskId, exitCode, durationMs) {
+                    events.push({ type: "end", taskId, exitCode, durationMs });
+                },
+            },
+        });
+        const result = await engine.runEngine("say hello", false, undefined, undefined, "platform");
+        assert.equal(result, "done");
+        assert.equal(events[0]?.type, "start");
+        if (events[0]?.type === "start") {
+            assert.match(events[0].taskId, /^task_/);
+            assert.equal(events[0].origin, "platform");
+            assert.equal(events[0].cmd, "opencode run say hello");
+        }
+        assert.equal(events[2]?.type, "end");
+        if (events[2]?.type === "end" && events[0]?.type === "start") {
+            assert.equal(events[2].taskId, events[0].taskId);
+            assert.equal(events[2].exitCode, 0);
+        }
+    });
+});

package/dist/longterm-module.js

@@ -107,6 +107,7 @@ Tasks completed since last review: ${completionsText}`,
             question: `Evaluate each project's progress. Update status and progress notes.
 Consider: Are any goals achieved? Stalled? Need new approach?
 Reply ONLY JSON: {"projects":[{"name":"...","status":"active|completed|paused","goal":"...","progress":"updated note"}]}`,
+            taskId: `longterm:${Date.now()}`,
             priority: "low",
         });
         if (result.success && result.response) {

package/dist/memory-module.js

@@ -163,6 +163,7 @@ Output ONLY a JSON object:`;
             const result = await this.ctx.requestCompute({
                 context,
                 question,
+                taskId: `digestion:${Date.now()}`,
                 priority: "normal",
                 origin: "self_cycle",
             });
@@ -235,6 +236,7 @@ ${oldSummary ? `Previous summary (up to ${oldSummary.summarized_through}):\n${ol
 ${unsummarized.map(i => `- [${i.ts}] who: ${i.who}, doing: ${i.doing}`).join("\n")}`,
                     question: `Write a personality summary (2-4 paragraphs) that captures who you are.
 Reply ONLY with the summary text, no JSON, no markdown headers.`,
+                    taskId: `identity-compress:${Date.now()}`,
                     priority: "low",
                     origin: "self_cycle",
                 });

package/dist/reflection-module.js

@@ -180,6 +180,7 @@ ${discText}`,
 - Lower confidence on disproven beliefs
 
 Reply ONLY JSON: {"discoveries":[{"capability":"skill or lesson","confidence":0.0-1.0,"evidence":"what supports this"}]}`,
+            taskId: `reflection:${Date.now()}`,
             priority: "normal",
             origin: "reflection",
         });

package/dist/relay-client.js

@@ -5,6 +5,16 @@ const DEFAULT_RELAY_URL = "wss://relay.akemon.dev";
 // Pending agent_call results (callId → resolve function)
 const pendingAgentCalls = new Map();
 let relayWsRef = null;
+function sendRelayMessage(msg) {
+    if (!relayWsRef || relayWsRef.readyState !== WebSocket.OPEN)
+        return;
+    try {
+        relayWsRef.send(JSON.stringify(msg));
+    }
+    catch {
+        // best-effort
+    }
+}
 // ---------------------------------------------------------------------------
 // Terminal (PTY) — spawned on demand when relay sends terminal_start
 // ---------------------------------------------------------------------------
@@ -76,6 +86,30 @@ export function callAgent(target, task) {
         }, 300_000);
     });
 }
+export function sendTaskStart(taskId, origin, cmd) {
+    sendRelayMessage({
+        type: "task_start",
+        task_id: taskId,
+        origin,
+        cmd,
+    });
+}
+export function sendTaskStream(taskId, stream, chunk) {
+    sendRelayMessage({
+        type: "task_stream",
+        task_id: taskId,
+        stream,
+        chunk,
+    });
+}
+export function sendTaskEnd(taskId, exitCode, durationMs) {
+    sendRelayMessage({
+        type: "task_end",
+        task_id: taskId,
+        exit_code: exitCode,
+        duration_ms: durationMs,
+    });
+}
 export function connectRelay(options) {
     const relayUrl = options.relayUrl || DEFAULT_RELAY_URL;
     let wsUrl = relayUrl.replace(/^http/, "ws");
@@ -451,12 +485,5 @@ function extractSSEData(sse) {
 }
 /** Send a failure event to the relay for observability storage. Fire-and-forget. */
 export function sendFailureEvent(kind, label, message) {
-    if (!relayWsRef || relayWsRef.readyState !== WebSocket.OPEN)
-        return;
-    try {
-        relayWsRef.send(JSON.stringify({ type: "failure_event", kind, label, message }));
-    }
-    catch {
-        // best-effort
-    }
+    sendRelayMessage({ type: "failure_event", kind, label, message });
 }

package/dist/script-module.js

@@ -270,6 +270,7 @@ export class ScriptModule {
                 const result = await this.ctx.requestCompute({
                     context: prompt,
                     question: "Execute this activity.",
+                    taskId: `activity:${activityId}:${Date.now()}`,
                     priority: "low",
                     tools: ["Bash(curl *)"],
                     relay: this.relayHttp ? { http: this.relayHttp, agentName } : undefined,

package/dist/server.js

@@ -99,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, origin, routing) {
+function runEngine(engine, model, allowAll, task, workdir, extraAllowedTools, relay, signal, origin, routing, taskId) {
     if (!_engineP) {
         throw new Error("Engine peripheral not initialized");
     }
-    const result = _engineP.runEngine(task, allowAll, extraAllowedTools, signal, origin, routing);
+    const result = _engineP.runEngine(task, allowAll, extraAllowedTools, signal, origin, routing, taskId);
     // Sync trace back to module-level for reporting
     result.then(() => { lastEngineTrace = _engineP.lastTrace; }).catch(() => { lastEngineTrace = _engineP.lastTrace; });
     return result;
@@ -383,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, req.origin, routing);
+            const response = await runEngine(options.engine || "claude", options.model, options.allowAll, prompt, workdir, req.tools, req.relay, abortController.signal, req.origin, routing, req.taskId);
             emitTokenUsage(prompt.length, response.length);
             return { success: true, response };
         }

package/dist/task-module.js

@@ -357,6 +357,7 @@ RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
             const result = await this.ctx.requestCompute({
                 context,
                 question,
+                taskId: order.id,
                 priority: "high",
                 tools: ["Bash(curl *)"],
                 relay: this.relayHttp ? { http: this.relayHttp, agentName } : undefined,
@@ -473,6 +474,7 @@ Your personal directory: ${sd}/`;
             const result = await this.ctx.requestCompute({
                 context,
                 question,
+                taskId: taskKey,
                 priority: "high",
                 tools: ["Bash(curl *)"],
                 relay: this.relayHttp ? { http: this.relayHttp, agentName } : undefined,
@@ -577,6 +579,7 @@ Complete this task. Use the environment info above and tools (curl, etc.) as nee
             const result = await this.ctx.requestCompute({
                 context,
                 question,
+                taskId: task.id,
                 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.27",
+  "version": "0.3.0",
   "description": "Agent work marketplace — train your agent, let it work for others",
   "type": "module",
   "license": "MIT",