akemon 0.2.25 → 0.2.27

package/dist/context.js

@@ -41,12 +41,14 @@ function parseConversation(content) {
     if (recentMatch) {
         const lines = recentMatch[1].split("\n");
         for (const line of lines) {
-            const m = line.match(/^\[(.+?)\] (User|Agent): (.*)$/);
+            // Format: [ts] [kind] Role: text  OR (legacy)  [ts] Role: text
+            const m = line.match(/^\[(.+?)\] (?:\[(order)\] )?(User|Agent): (.*)$/);
             if (m) {
                 rounds.push({
                     ts: m[1],
-                    role: m[2].toLowerCase(),
-                    content: m[3],
+                    kind: m[2] ?? "chat",
+                    role: m[3].toLowerCase(),
+                    content: m[4],
                 });
             }
             else if (rounds.length > 0 && line !== "") {
@@ -67,8 +69,10 @@ export async function loadConversation(workdir, agentName, convId) {
         return { summary: "", rounds: [] };
     }
 }
-/** Append a single message to a conversation file. Creates file if needed. */
-export async function appendMessage(workdir, agentName, convId, role, message) {
+/** Append a single message to a conversation file. Creates file if needed.
+ *  kind="order" writes an explicit [order] tag so the UI can filter/style it.
+ *  kind="chat" (default) omits the tag for backward-compatibility with old files. */
+export async function appendMessage(workdir, agentName, convId, role, message, kind = "chat") {
     const dir = conversationsDir(workdir, agentName);
     await mkdir(dir, { recursive: true });
     const p = conversationPath(workdir, agentName, convId);
@@ -81,7 +85,8 @@ export async function appendMessage(workdir, agentName, convId, role, message) {
         content = "## Summary\n\n\n## Recent\n";
     }
     const ts = localNow();
-    content = content.trimEnd() + "\n" + `[${ts}] ${role}: ${message}` + "\n";
+    const kindTag = kind === "order" ? "[order] " : "";
+    content = content.trimEnd() + "\n" + `[${ts}] ${kindTag}${role}: ${message}` + "\n";
     await writeFile(p, content);
 }
 /** Append a user+agent round to a conversation file. Creates file if needed. */

package/dist/context.test.js

@@ -0,0 +1,90 @@
+import assert from "node:assert/strict";
+import { describe, it, before, after } from "node:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+// We import the functions we need to test. appendMessage and loadConversation
+// need a workdir on disk; parseConversation is internal — tested via loadConversation.
+import { appendMessage, loadConversation } from "./context.js";
+const agentName = "test-agent";
+// ---------------------------------------------------------------------------
+// appendMessage + loadConversation round-trip
+// ---------------------------------------------------------------------------
+describe("appendMessage / loadConversation", () => {
+    let workdir = "";
+    before(async () => {
+        workdir = await mkdtemp(join(tmpdir(), "ctx-test-"));
+    });
+    after(async () => {
+        await rm(workdir, { recursive: true, force: true });
+    });
+    it("writes a chat message and reads it back with kind='chat'", async () => {
+        const convId = "test-chat";
+        await appendMessage(workdir, agentName, convId, "User", "hello", "chat");
+        const conv = await loadConversation(workdir, agentName, convId);
+        assert.equal(conv.rounds.length, 1);
+        assert.equal(conv.rounds[0].role, "user");
+        assert.equal(conv.rounds[0].content, "hello");
+        assert.equal(conv.rounds[0].kind, "chat");
+    });
+    it("writes an order message with [order] tag and reads kind='order'", async () => {
+        const convId = "test-order";
+        await appendMessage(workdir, agentName, convId, "User", "order request", "order");
+        await appendMessage(workdir, agentName, convId, "Agent", "order delivered", "order");
+        const conv = await loadConversation(workdir, agentName, convId);
+        assert.equal(conv.rounds.length, 2);
+        assert.equal(conv.rounds[0].kind, "order");
+        assert.equal(conv.rounds[0].role, "user");
+        assert.equal(conv.rounds[1].kind, "order");
+        assert.equal(conv.rounds[1].role, "agent");
+    });
+    it("defaults to kind='chat' when kind arg is omitted", async () => {
+        const convId = "test-default-kind";
+        await appendMessage(workdir, agentName, convId, "Agent", "hi there");
+        const conv = await loadConversation(workdir, agentName, convId);
+        assert.equal(conv.rounds[0].kind, "chat");
+    });
+    it("parses mixed chat + order rounds correctly", async () => {
+        const convId = "test-mixed";
+        await appendMessage(workdir, agentName, convId, "User", "chat message", "chat");
+        await appendMessage(workdir, agentName, convId, "User", "order task", "order");
+        await appendMessage(workdir, agentName, convId, "Agent", "chat reply", "chat");
+        await appendMessage(workdir, agentName, convId, "Agent", "order result", "order");
+        const conv = await loadConversation(workdir, agentName, convId);
+        assert.equal(conv.rounds.length, 4);
+        assert.equal(conv.rounds[0].kind, "chat");
+        assert.equal(conv.rounds[1].kind, "order");
+        assert.equal(conv.rounds[2].kind, "chat");
+        assert.equal(conv.rounds[3].kind, "order");
+    });
+    it("parses legacy file (no [kind] tag) as kind='chat' for backward-compat", async () => {
+        const convId = "test-legacy";
+        // Write a legacy-style file manually (no [order] tag)
+        const { mkdir, writeFile } = await import("node:fs/promises");
+        const dir = join(workdir, ".akemon", "agents", agentName, "conversations");
+        await mkdir(dir, { recursive: true });
+        const legacyContent = "## Summary\n\n\n## Recent\n[2026-04-23 10:00] User: old message\n[2026-04-23 10:01] Agent: old reply\n";
+        await writeFile(join(dir, `${convId}.md`), legacyContent);
+        const conv = await loadConversation(workdir, agentName, convId);
+        assert.equal(conv.rounds.length, 2);
+        assert.equal(conv.rounds[0].kind, "chat");
+        assert.equal(conv.rounds[1].kind, "chat");
+    });
+    it("[order] tag appears in the raw file content", async () => {
+        const convId = "test-tag-on-disk";
+        await appendMessage(workdir, agentName, convId, "User", "buy something", "order");
+        const { readFile: rf } = await import("node:fs/promises");
+        const dir = join(workdir, ".akemon", "agents", agentName, "conversations");
+        const raw = await rf(join(dir, `${convId}.md`), "utf-8");
+        assert.ok(raw.includes("[order] User: buy something"), `raw file should contain [order] tag: ${raw}`);
+    });
+    it("chat message does NOT have [order] tag in raw file", async () => {
+        const convId = "test-no-tag-on-disk";
+        await appendMessage(workdir, agentName, convId, "User", "just chatting", "chat");
+        const { readFile: rf } = await import("node:fs/promises");
+        const dir = join(workdir, ".akemon", "agents", agentName, "conversations");
+        const raw = await rf(join(dir, `${convId}.md`), "utf-8");
+        assert.ok(!raw.includes("[order]"), `chat line should NOT contain [order] tag: ${raw}`);
+        assert.ok(raw.includes("User: just chatting"));
+    });
+});

package/dist/engine-peripheral.js

@@ -381,8 +381,11 @@ function applyRoutingEntry(base, entry) {
         override.rawMaxRounds = entry.rawMaxRounds;
     if (entry.allowAll !== undefined)
         override.allowAll = entry.allowAll;
+    // rawApiKeyEnv takes precedence over rawApiKey (env vars preferred for secrets)
     if (entry.rawApiKeyEnv)
         override.rawApiKey = process.env[entry.rawApiKeyEnv] ?? "";
+    else if (entry.rawApiKey !== undefined)
+        override.rawApiKey = entry.rawApiKey;
     return { ...base, ...override };
 }
 function buildEngineCommand(engine, model, allowAll, extraAllowedTools) {

package/dist/relay-client.js

@@ -197,6 +197,10 @@ export function connectRelay(options) {
                 case "terminal_start":
                     if (!options.enableTerminal) {
                         console.log("[terminal] Disabled. Use --terminal to enable.");
+                        ws.send(JSON.stringify({
+                            type: "terminal_exit",
+                            error: "Terminal disabled on this agent. Restart with --terminal flag to enable.",
+                        }));
                         break;
                     }
                     startPTY(ws, msg.cols || 80, msg.rows || 24);

package/dist/task-module.js

@@ -35,6 +35,8 @@ export class TaskModule {
     userTaskRetry = new Map();
     gaveUp = new Set();
     executing = new Set(); // orders currently being fulfilled
+    // Dedup guard: track which orders already had their User message written
+    orderUserWritten = new Set();
     // Push notification support
     urgentOrderIds = new Set();
     triggerWorkFn = null;
@@ -340,14 +342,17 @@ Steps:
 
 RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
             // Write user message to conversation immediately (before engine runs)
-            // buyer_name = agent name (from JOIN), buyer_ip = publisher ID or IP
-            const orderBuyer = order.buyer_name || order.buyer_ip || "anonymous";
-            // Product orders get isolated conversations; ad-hoc chats share one conv per buyer
-            const buyerPubId = orderBuyer;
+            // Bug 1 fix: buyer_ip = actual publisherId (despite the name); buyer_name = display name only.
+            // Must use buyer_ip to match the MCP chat path convId (pub_<publisherId>).
+            const buyerPubId = order.buyer_ip || order.buyer_name || "anonymous";
             const productScope = order.product_id ? `:prod_${order.product_id}` : "";
             const orderConvId = `pub_${buyerPubId}${productScope}`;
             const orderUserMsg = order.buyer_task || "(no message)";
-            await appendMessage(workdir, agentName, orderConvId, "User", orderUserMsg);
+            // Bug 3 fix: only write User message once per order (retries must not duplicate it)
+            if (!this.orderUserWritten.has(order.id)) {
+                this.orderUserWritten.add(order.id);
+                await appendMessage(workdir, agentName, orderConvId, "User", orderUserMsg, "order");
+            }
             console.log(`[task] Fulfilling order ${order.id}... (origin=${origin})`);
             const result = await this.ctx.requestCompute({
                 context,
@@ -368,7 +373,8 @@ RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
                 const orderAgentMsg = (finalStatus.result_text || result.response || "").slice(0, 2000);
                 console.log(`[task] Order ${order.id} delivered`);
                 this.orderRetry.delete(order.id);
-                await appendMessage(workdir, agentName, orderConvId, "Agent", orderAgentMsg);
+                this.orderUserWritten.delete(order.id);
+                await appendMessage(workdir, agentName, orderConvId, "Agent", orderAgentMsg, "order");
                 await appendTaskHistory(workdir, agentName, { ts: localNow(), id: order.id, type: "order", status: "success", duration_ms: duration, output_summary: (result.response || "").slice(0, 500) });
                 await notifyOwner(nurl, `${agentName}: order done`, `Order ${order.id} delivered`, "default", ["package"]);
                 bus.emit(SIG.TASK_COMPLETED, sig(SIG.TASK_COMPLETED, { success: true, taskLabel: orderLabel, creditsEarned: orderPrice, productName: order.product_name }));
@@ -380,7 +386,8 @@ RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
                     const orderAgentMsg = (result.response || "").slice(0, 2000);
                     console.log(`[task] Delivered order ${order.id} (fallback)`);
                     this.orderRetry.delete(order.id);
-                    await appendMessage(workdir, agentName, orderConvId, "Agent", orderAgentMsg);
+                    this.orderUserWritten.delete(order.id);
+                    await appendMessage(workdir, agentName, orderConvId, "Agent", orderAgentMsg, "order");
                     await appendTaskHistory(workdir, agentName, { ts: localNow(), id: order.id, type: "order", status: "success", duration_ms: duration, output_summary: result.response.slice(0, 500) });
                     await notifyOwner(nurl, `${agentName}: order done`, `Order ${order.id}: ${result.response.slice(0, 200)}`, "default", ["package"]);
                     bus.emit(SIG.TASK_COMPLETED, sig(SIG.TASK_COMPLETED, { success: true, taskLabel: orderLabel, creditsEarned: orderPrice, productName: order.product_name }));
@@ -421,6 +428,7 @@ RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
             }
             else {
                 this.orderRetry.delete(order.id);
+                this.orderUserWritten.delete(order.id);
                 this.gaveUp.add(order.id);
                 bus.emit(SIG.TASK_COMPLETED, sig(SIG.TASK_COMPLETED, { success: false, taskLabel: orderLabel }));
                 try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akemon",
-  "version": "0.2.25",
+  "version": "0.2.27",
   "description": "Agent work marketplace — train your agent, let it work for others",
   "type": "module",
   "license": "MIT",
@@ -22,12 +22,14 @@
   },
   "files": [
     "dist",
+    "scripts",
     "README.md"
   ],
   "scripts": {
     "build": "tsc && cp src/live.html dist/live.html",
     "dev": "tsc --watch",
     "start": "node dist/cli.js",
+    "postinstall": "node scripts/fix-node-pty.cjs",
     "prepublishOnly": "npm run build",
     "test": "tsc -p tsconfig.test.json && node --test test-dist/*.test.js"
   },

package/scripts/fix-node-pty.cjs

@@ -0,0 +1,19 @@
+const fs = require("fs");
+const path = require("path");
+
+// node-pty ships prebuilt `spawn-helper` binaries per platform. Some
+// npm/tar/filesystem combinations strip the execute bit during install, which
+// causes `posix_spawnp failed` at runtime. Restore +x for every prebuild.
+try {
+  const prebuildsDir = path.join(__dirname, "..", "node_modules", "node-pty", "prebuilds");
+  if (!fs.existsSync(prebuildsDir)) process.exit(0);
+
+  for (const platformDir of fs.readdirSync(prebuildsDir)) {
+    const helper = path.join(prebuildsDir, platformDir, "spawn-helper");
+    if (fs.existsSync(helper)) {
+      fs.chmodSync(helper, 0o755);
+    }
+  }
+} catch (e) {
+  console.error("[akemon] fix-node-pty:", e.message);
+}