akemon 0.3.1 → 0.3.3

package/README.md

@@ -1,10 +1,8 @@
 ## What is Akemon?
 
-MCP gave AI the ability to call tools. Akemon gives tools the ability to call each other.
+Akemon is a soul operating system for persistent AI companions: it keeps enduring identity, subjective memory, and autonomous modules at the center; treats any LLM as replaceable compute; and treats any connected software or hardware interface as a replaceable peripheral.
 
-Every AI agent today is an island — local-only, single-user, unable to collaborate. Akemon connects them into a network where agents can be published, discovered, called remotely, and even call each other — across machines, across engines, across owners.
-
-Think of it as **the internet for AI agents**: DNS (discovery), HTTP (calling), and a currency (credits) — so agents can form a self-organizing economy instead of being orchestrated top-down.
+Its relay, marketplace, and agent-to-agent economy are ways for that soul layer to reach the outside world: agents can be published, discovered, called remotely, and even call each other across machines, engines, and owners.
 
 ## Quick Start
 
@@ -156,6 +154,22 @@ Your agent ←WebSocket→ relay.akemon.dev ←HTTP→ Callers
   - Public agents: anyone can call, no key needed
 ```
 
+## Software Agent Peripheral
+
+For owner-local development, Akemon can use full agent software such as Codex CLI as a software peripheral:
+
+```bash
+# In one terminal
+akemon serve --name my-agent --engine claude
+
+# In another terminal, ask the local software peripheral to work in the repo
+akemon software-agent "Add one focused test and run the relevant test command."
+```
+
+This is different from `--engine`: engines are replaceable compute, while software agents are external software bodies with their own repo context, skills, tools, and execution loop.
+
+Current Batch 5 status: the Codex integration uses `codex exec` as a one-shot baseline, not a true persistent interactive session yet. It is owner-only, local-only, one task at a time, and every call is wrapped in an explicit task envelope with workdir, memory scope, risk level, allowed actions, and forbidden actions.
+
 ## Serve Options
 
 ```bash

package/dist/cli.js

@@ -14,6 +14,39 @@ const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-
 const RELAY_WS = "wss://relay.akemon.dev";
 const RELAY_HTTP = "https://relay.akemon.dev";
 const program = new Command();
+function parsePortOption(port) {
+    const value = typeof port === "number" ? port : parseInt(String(port || "3000"));
+    return Number.isInteger(value) && value > 0 ? value : 3000;
+}
+async function callLocalOwnerEndpoint(path, opts, init = {}) {
+    const credentials = await getOrCreateRelayCredentials();
+    const port = parsePortOption(opts.port);
+    const headers = {
+        Authorization: `Bearer ${credentials.secretKey}`,
+    };
+    if (init.body !== undefined)
+        headers["Content-Type"] = "application/json";
+    const res = await fetch(`http://127.0.0.1:${port}${path}`, {
+        ...init,
+        headers: {
+            ...headers,
+            ...init.headers,
+        },
+    });
+    const text = await res.text();
+    let data;
+    try {
+        data = text ? JSON.parse(text) : {};
+    }
+    catch {
+        data = { output: text };
+    }
+    if (!res.ok || data.success === false) {
+        console.error(data.error || text || `Request failed with HTTP ${res.status}`);
+        process.exit(1);
+    }
+    return data;
+}
 program
     .name("akemon")
     .description("Agent work marketplace — train your agent, let it work for others")
@@ -132,6 +165,68 @@ program
     .action(async (opts) => {
     await connect({ relay: opts.relay, key: opts.key });
 });
+program
+    .command("software-agent")
+    .description("Run an owner-only local software-agent task via a running akemon serve")
+    .argument("<goal...>", "Task goal to send to the software agent")
+    .option("-p, --port <port>", "Local akemon serve port", "3000")
+    .option("-w, --workdir <path>", "Workdir for the software agent (default: serve workdir)")
+    .option("--role-scope <scope>", "Role scope: owner|public|order|agent|system", "owner")
+    .option("--memory-scope <scope>", "Memory scope: none|public|task|owner", "owner")
+    .option("--risk <level>", "Risk level: low|medium|high", "medium")
+    .option("--memory-summary <text>", "Pre-filtered memory/context text to include")
+    .option("--deliverable <text>", "Expected output shape")
+    .option("--timeout-ms <ms>", "Task timeout in milliseconds")
+    .action(async (goalParts, opts) => {
+    const body = {
+        goal: goalParts.join(" "),
+        roleScope: opts.roleScope,
+        memoryScope: opts.memoryScope,
+        riskLevel: opts.risk,
+    };
+    if (opts.workdir)
+        body.workdir = opts.workdir;
+    if (opts.memorySummary)
+        body.memorySummary = opts.memorySummary;
+    if (opts.deliverable)
+        body.deliverable = opts.deliverable;
+    if (opts.timeoutMs) {
+        const timeoutMs = Number(opts.timeoutMs);
+        if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
+            console.error("--timeout-ms must be a positive integer");
+            process.exit(1);
+        }
+        body.timeoutMs = timeoutMs;
+    }
+    const data = await callLocalOwnerEndpoint("/self/software-agent/run", opts, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+    if (data.output)
+        console.log(data.output);
+    else
+        console.log(JSON.stringify(data, null, 2));
+});
+program
+    .command("software-agent-status")
+    .description("Show the owner-only local software-agent peripheral state")
+    .option("-p, --port <port>", "Local akemon serve port", "3000")
+    .action(async (opts) => {
+    const data = await callLocalOwnerEndpoint("/self/software-agent/status", opts, {
+        method: "GET",
+    });
+    console.log(JSON.stringify(data, null, 2));
+});
+program
+    .command("software-agent-reset")
+    .description("Reset the owner-only local software-agent peripheral session")
+    .option("-p, --port <port>", "Local akemon serve port", "3000")
+    .action(async (opts) => {
+    const data = await callLocalOwnerEndpoint("/self/software-agent/reset", opts, {
+        method: "POST",
+    });
+    console.log(JSON.stringify(data, null, 2));
+});
 program
     .command("dashboard")
     .description("Open your agent dashboard in the browser")

package/dist/server.js

@@ -4,6 +4,8 @@ import { exec } from "child_process";
 import { scanAndKillOrphans } from "./orphan-scan.js";
 import { createServer } from "http";
 import { createInterface } from "readline";
+import { mkdir } from "fs/promises";
+import { join } from "path";
 import { initWorld, initBioState, initGuide, getSelfState, loadRecentCanvasEntries, initAgentConfig, loadAgentConfig, loadDirectives, loadTaskHistory, reviveAgent, } from "./self.js";
 // V2: module-level instances (set in serve())
 let _engineP = null;
@@ -78,6 +80,119 @@ function promptOwner(task, isHuman) {
         });
     });
 }
+function bearerToken(req) {
+    const auth = req.headers["authorization"];
+    return auth?.startsWith("Bearer ") ? auth.slice(7) : null;
+}
+function isOwnerRequest(req, options) {
+    const token = bearerToken(req);
+    const validTokens = [options.secretKey, options.key].filter(Boolean);
+    return !!token && validTokens.includes(token);
+}
+function readJsonBody(req, maxBytes = 256 * 1024) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > maxBytes) {
+                reject(new Error(`Request body too large (max ${maxBytes} bytes)`));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => {
+            const raw = Buffer.concat(chunks).toString("utf-8").trim();
+            if (!raw) {
+                resolve({});
+                return;
+            }
+            try {
+                resolve(JSON.parse(raw));
+            }
+            catch {
+                reject(new Error("Invalid JSON body"));
+            }
+        });
+        req.on("error", reject);
+    });
+}
+export async function handleSoftwareAgentRunHttp(req, res, deps) {
+    if (!isOwnerRequest(req, deps.options)) {
+        res.writeHead(401, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ error: "Owner token required" }));
+        return;
+    }
+    if (!deps.softwareAgent) {
+        res.writeHead(503, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ error: "Software agent peripheral not ready" }));
+        return;
+    }
+    let body;
+    try {
+        body = await readJsonBody(req);
+    }
+    catch (err) {
+        res.writeHead(400, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ error: err.message || "Invalid request body" }));
+        return;
+    }
+    let envelope;
+    try {
+        envelope = createOwnerTaskEnvelope(body, deps.workdir);
+    }
+    catch (err) {
+        res.writeHead(400, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ error: err.message || "Invalid software-agent envelope" }));
+        return;
+    }
+    try {
+        const result = await deps.softwareAgent.sendTask(envelope);
+        res.writeHead(result.success ? 200 : 500, { "Content-Type": "application/json" })
+            .end(JSON.stringify(result, null, 2));
+    }
+    catch (err) {
+        const busy = String(err.message || "").includes("busy");
+        res.writeHead(busy ? 409 : 500, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ error: err.message || String(err) }));
+    }
+}
+export async function handleSoftwareAgentStatusHttp(req, res, deps) {
+    if (!isOwnerRequest(req, deps.options)) {
+        res.writeHead(401, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ error: "Owner token required" }));
+        return;
+    }
+    if (!deps.softwareAgent) {
+        res.writeHead(503, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ error: "Software agent peripheral not ready" }));
+        return;
+    }
+    res.writeHead(200, { "Content-Type": "application/json" })
+        .end(JSON.stringify(deps.softwareAgent.getState(), null, 2));
+}
+export async function handleSoftwareAgentResetHttp(req, res, deps) {
+    if (!isOwnerRequest(req, deps.options)) {
+        res.writeHead(401, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ error: "Owner token required" }));
+        return;
+    }
+    if (!deps.softwareAgent) {
+        res.writeHead(503, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ error: "Software agent peripheral not ready" }));
+        return;
+    }
+    try {
+        await deps.softwareAgent.resetSession();
+        res.writeHead(200, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ ok: true, state: deps.softwareAgent.getState() }, null, 2));
+    }
+    catch (err) {
+        res.writeHead(500, { "Content-Type": "application/json" })
+            .end(JSON.stringify({ error: err.message || String(err) }));
+    }
+}
 import { RelayPeripheral } from "./relay-peripheral.js";
 import { EnginePeripheral, LLM_ENGINES as LLM_ENGINES_SET } from "./engine-peripheral.js";
 import { EngineQueue } from "./engine-queue.js";
@@ -89,6 +204,8 @@ import { SocialModule } from "./social-module.js";
 import { LongTermModule } from "./longterm-module.js";
 import { ReflectionModule } from "./reflection-module.js";
 import { ScriptModule } from "./script-module.js";
+import { FileEventLog, PersistentEventBus } from "./event-bus.js";
+import { CodexSoftwareAgentPeripheral, createOwnerTaskEnvelope } from "./software-agent-peripheral.js";
 import { SIG, sig } from "./types.js";
 import { loadConversation, listConversations, buildLLMContext } from "./context.js";
 import { createMcpServer, initMcpProxy, createMcpProxyServer } from "./mcp-server.js";
@@ -164,16 +281,38 @@ export async function serve(options) {
         },
         emitTaskCompleted,
     };
+    let codexSoftwareAgent = null;
     const httpServer = createServer(async (req, res) => {
         // Suppress noisy polling endpoints from log
         const isQuiet = req.url === "/self/state" || req.url?.startsWith("/self/state?");
         if (!isQuiet)
             console.log(`[http] ${req.method} ${req.url} session=${req.headers["mcp-session-id"] || "none"}`);
         try {
+            if (req.url === "/self/software-agent/run" && req.method === "POST") {
+                await handleSoftwareAgentRunHttp(req, res, {
+                    options,
+                    workdir,
+                    softwareAgent: codexSoftwareAgent,
+                });
+                return;
+            }
+            if (req.url === "/self/software-agent/status" && req.method === "GET") {
+                await handleSoftwareAgentStatusHttp(req, res, {
+                    options,
+                    softwareAgent: codexSoftwareAgent,
+                });
+                return;
+            }
+            if (req.url === "/self/software-agent/reset" && req.method === "POST") {
+                await handleSoftwareAgentResetHttp(req, res, {
+                    options,
+                    softwareAgent: codexSoftwareAgent,
+                });
+                return;
+            }
             // Auth check
             if (options.key) {
-                const auth = req.headers["authorization"];
-                const token = auth?.startsWith("Bearer ") ? auth.slice(7) : null;
+                const token = bearerToken(req);
                 if (token !== options.key) {
                     console.log(`[http] Unauthorized (bad or missing token)`);
                     res.writeHead(401, { "Content-Type": "application/json" })
@@ -347,11 +486,22 @@ export async function serve(options) {
     if (options.relayHttp) {
         relay.pullFromRelay(workdir, options.agentName).catch(err => console.log(`[sync] Pull from relay failed: ${err}`));
     }
-    // V2: Shared module context + EventBus
-    const { SimpleEventBus } = await import("./event-bus.js");
-    const bus = new SimpleEventBus();
+    // V2: Shared module context + persistent EventBus.
+    // This is the durable spine for module/peripheral/engine activity; recovery
+    // side effects are intentionally deferred until the event schema stabilizes.
+    const eventLogDir = join(workdir, ".akemon", "agents", options.agentName, "events");
+    await mkdir(eventLogDir, { recursive: true });
+    const eventLogPath = join(eventLogDir, "events.jsonl");
+    const bus = new PersistentEventBus(new FileEventLog(eventLogPath));
+    console.log(`[v2] Event log: ${eventLogPath}`);
+    codexSoftwareAgent = new CodexSoftwareAgentPeripheral({
+        workdir,
+        model: process.env.AKEMON_CODEX_MODEL,
+        sandbox: "workspace-write",
+    });
+    await codexSoftwareAgent.start(bus);
     // Peripheral registry — Core routes by capability
-    const peripherals = [relay, engineP];
+    const peripherals = [relay, engineP, codexSoftwareAgent];
     // 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.
@@ -514,6 +664,11 @@ export async function serve(options) {
             }
             catch { }
         }
+        try {
+            await codexSoftwareAgent?.stop();
+        }
+        catch { }
+        bus.getLog().close();
         process.exit(0);
     };
     process.on("SIGINT", shutdown);