akemon 0.3.6 → 0.3.7

package/dist/software-agent-transport.js

@@ -0,0 +1,177 @@
+import { spawn } from "child_process";
+import { StringDecoder } from "string_decoder";
+import { StreamingRedactor } from "./redaction.js";
+import { shouldDetachChildProcess, terminateProcessTree } from "./runtime-platform.js";
+export class CodexExecTransport {
+    id = "codex-exec";
+    kind = "codex-exec";
+    config;
+    activeChild = null;
+    constructor(config = {}) {
+        this.config = config;
+    }
+    describe(workdir) {
+        const { cmd, args } = buildCodexExecCommand({
+            command: this.config.command || "codex",
+            workdir,
+            model: this.config.model,
+            sandbox: this.config.sandbox || "workspace-write",
+        });
+        return {
+            id: this.id,
+            kind: this.kind,
+            commandLine: [cmd, ...args].join(" "),
+            inputMode: "stdin-prompt",
+            eventMode: "stdio",
+            sessionMode: "oneshot",
+            machineReadable: false,
+            nativeSession: false,
+        };
+    }
+    async run(request) {
+        const { cmd, args } = buildCodexExecCommand({
+            command: this.config.command || "codex",
+            workdir: request.workdir,
+            model: this.config.model,
+            sandbox: this.config.sandbox || "workspace-write",
+        });
+        const spawnImpl = this.config.spawnImpl || spawn;
+        const startedAt = request.startedAt || Date.now();
+        return new Promise((resolve) => {
+            let child;
+            try {
+                child = spawnImpl(cmd, args, {
+                    cwd: request.workdir,
+                    env: request.env,
+                    stdio: ["pipe", "pipe", "pipe"],
+                    detached: shouldDetachChildProcess(),
+                });
+            }
+            catch (err) {
+                resolve({
+                    taskId: request.taskId,
+                    stdout: "",
+                    stderr: "",
+                    error: err.message || String(err),
+                    exitCode: null,
+                    durationMs: Date.now() - startedAt,
+                    aborted: false,
+                    success: false,
+                });
+                return;
+            }
+            this.activeChild = child;
+            request.onProcessStart?.(child);
+            let stdout = "";
+            let stderr = "";
+            let finished = false;
+            let aborted = false;
+            const outDecoder = new StringDecoder("utf8");
+            const errDecoder = new StringDecoder("utf8");
+            const outRedactor = new StreamingRedactor();
+            const errRedactor = new StreamingRedactor();
+            const emitSafeStream = (stream, text) => {
+                if (!text)
+                    return;
+                request.onStream?.({ taskId: request.taskId, stream, chunk: text });
+            };
+            const finish = (exitCode, error) => {
+                if (finished)
+                    return;
+                finished = true;
+                request.signal?.removeEventListener("abort", onAbort);
+                clearTimeout(timer);
+                const tailOut = outDecoder.end();
+                const tailErr = errDecoder.end();
+                if (tailOut) {
+                    stdout += tailOut;
+                    emitSafeStream("stdout", outRedactor.push(tailOut));
+                }
+                if (tailErr) {
+                    stderr += tailErr;
+                    emitSafeStream("stderr", errRedactor.push(tailErr));
+                }
+                emitSafeStream("stdout", outRedactor.flush());
+                emitSafeStream("stderr", errRedactor.flush());
+                if (this.activeChild === child)
+                    this.activeChild = null;
+                request.onProcessEnd?.(child);
+                const durationMs = Date.now() - startedAt;
+                const success = !error && !aborted && exitCode === 0;
+                resolve({
+                    taskId: request.taskId,
+                    stdout,
+                    stderr,
+                    error,
+                    exitCode,
+                    durationMs,
+                    aborted,
+                    success,
+                });
+            };
+            const onAbort = () => {
+                if (aborted || !child.pid)
+                    return;
+                aborted = true;
+                terminateProcessTree(child.pid, { signal: "SIGTERM", forceAfterMs: 3000 });
+            };
+            const timer = setTimeout(() => {
+                if (!child.pid)
+                    return;
+                aborted = true;
+                terminateProcessTree(child.pid, { signal: "SIGTERM", forceAfterMs: 3000 });
+            }, request.timeoutMs);
+            if (request.signal) {
+                if (request.signal.aborted)
+                    onAbort();
+                else
+                    request.signal.addEventListener("abort", onAbort, { once: true });
+            }
+            child.stdin?.on("error", () => { });
+            child.stdin?.write(request.prompt);
+            child.stdin?.end();
+            child.stdout?.on("data", (chunk) => {
+                const text = outDecoder.write(chunk);
+                if (!text)
+                    return;
+                stdout += text;
+                emitSafeStream("stdout", outRedactor.push(text));
+            });
+            child.stderr?.on("data", (chunk) => {
+                const text = errDecoder.write(chunk);
+                if (!text)
+                    return;
+                stderr += text;
+                emitSafeStream("stderr", errRedactor.push(text));
+            });
+            child.on("close", (code) => {
+                child.unref();
+                finish(code);
+            });
+            child.on("error", (err) => {
+                child.unref();
+                finish(null, err.message);
+            });
+        });
+    }
+    async reset() {
+        const activePid = this.activeChild?.pid;
+        if (activePid) {
+            terminateProcessTree(activePid, { signal: "SIGTERM", forceAfterMs: 3000 });
+        }
+        this.activeChild = null;
+    }
+}
+export function buildCodexExecCommand(opts) {
+    const args = [
+        "exec",
+        "--skip-git-repo-check",
+        "--color", "never",
+        "-s", opts.sandbox,
+        "-C", opts.workdir,
+    ];
+    if (opts.model)
+        args.push("-m", opts.model);
+    args.push("-");
+    return { cmd: opts.command, args };
+}

package/dist/task-module.js

@@ -16,6 +16,8 @@ import { buildRoleContext } from "./role-module.js";
 import { sortByQuadrant, dedupeWorkItems, computeRetryDelay } from "./task-helpers.js";
 import { updateMetrics } from "./metrics.js";
 import { downgradeForRetry } from "./engine-routing.js";
+import { logBestEffortError } from "./best-effort.js";
+import { upsertTaskRegistryRecord } from "./task-registry.js";
 // ---------------------------------------------------------------------------
 // Config
 // ---------------------------------------------------------------------------
@@ -153,6 +155,15 @@ export class TaskModule {
                         origin: isRetry ? downgradeForRetry(rawOrigin) : rawOrigin,
                         data: order,
                     });
+                    await this.recordOrderTask(order, {
+                        status: "pending",
+                        summary: isRetry ? `Relay order ${order.id} queued for retry.` : `Relay order ${order.id} queued.`,
+                        data: {
+                            origin: rawOrigin,
+                            urgent,
+                            retryCount: this.orderRetry.get(order.id)?.count || 0,
+                        },
+                    });
                 }
             }
             catch { }
@@ -173,6 +184,13 @@ export class TaskModule {
                         origin: rt ? downgradeForRetry("user_manual") : "user_manual",
                         data: task,
                     });
+                    await this.recordUserTask(task, {
+                        status: "pending",
+                        summary: rt ? `Owner recurring task ${taskKey} queued for retry.` : `Owner recurring task ${taskKey} queued.`,
+                        data: {
+                            retryCount: rt?.count || 0,
+                        },
+                    });
                 }
             }
             catch { }
@@ -188,6 +206,10 @@ export class TaskModule {
                         origin: "platform",
                         data: task,
                     });
+                    await this.recordRelayTask(task, {
+                        status: "pending",
+                        summary: `Relay platform task ${task.id} queued.`,
+                    });
                 }
             }
             catch { }
@@ -299,6 +321,77 @@ export class TaskModule {
         return filtered;
     }
     // ---------------------------------------------------------------------------
+    // Task activity projection
+    // ---------------------------------------------------------------------------
+    async recordTaskRegistry(patch) {
+        if (!this.ctx)
+            return;
+        try {
+            await upsertTaskRegistryRecord({
+                workdir: this.ctx.workdir,
+                agentName: this.ctx.agentName,
+                patch,
+            });
+        }
+        catch (error) {
+            logBestEffortError("task registry upsert", error);
+        }
+    }
+    async recordOrderTask(order, patch = {}) {
+        const orderId = readTaskText(order?.id) || "unknown";
+        const patchData = patch.data || {};
+        await this.recordTaskRegistry({
+            taskId: workTaskRegistryId("order", orderId),
+            source: "relay_order",
+            route: "relay-order",
+            objective: formatOrderObjective(order),
+            conversationId: orderConversationId(order),
+            ...patch,
+            data: {
+                orderId,
+                productId: readTaskText(order?.product_id),
+                productName: readTaskText(order?.product_name),
+                buyerName: readTaskText(order?.buyer_name),
+                buyerRef: readTaskText(order?.buyer_ip),
+                orderStatus: readTaskText(order?.status),
+                price: typeof order?.price === "number" ? order.price : order?.offer_price,
+                ...patchData,
+            },
+        });
+    }
+    async recordUserTask(task, patch = {}) {
+        const taskKey = readTaskText(task.id || task.title) || "unknown";
+        const patchData = patch.data || {};
+        await this.recordTaskRegistry({
+            taskId: workTaskRegistryId("user_task", taskKey),
+            source: "owner_recurring_task",
+            route: "user-task",
+            objective: truncateTaskText(task.body || task.title || taskKey, 220),
+            ...patch,
+            data: {
+                taskKey,
+                title: readTaskText(task.title),
+                ...patchData,
+            },
+        });
+    }
+    async recordRelayTask(task, patch = {}) {
+        const taskId = readTaskText(task?.id) || "unknown";
+        const patchData = patch.data || {};
+        await this.recordTaskRegistry({
+            taskId: workTaskRegistryId("relay_task", taskId),
+            source: "relay_platform_task",
+            route: "relay-task",
+            objective: truncateTaskText(task?.description || task?.body || task?.type || taskId, 220),
+            ...patch,
+            data: {
+                relayTaskId: taskId,
+                relayTaskType: readTaskText(task?.type),
+                ...patchData,
+            },
+        });
+    }
+    // ---------------------------------------------------------------------------
     // Execute order
     // ---------------------------------------------------------------------------
     async executeOrder(order, origin = "platform") {
@@ -309,6 +402,14 @@ export class TaskModule {
         const orderLabel = `order:${order.product_name || order.buyer_name || order.id}`;
         const orderPrice = order.price || order.offer_price || 1;
         const startTime = Date.now();
+        await this.recordOrderTask(order, {
+            status: "running",
+            summary: `Executing relay order ${order.id}.`,
+            data: {
+                origin,
+                attempt: (this.orderRetry.get(order.id)?.count || 0) + 1,
+            },
+        });
         try {
             const bios = biosPath(workdir, agentName);
             const directives = await loadDirectives(workdir, agentName);
@@ -377,6 +478,16 @@ RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
                 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 this.recordOrderTask(order, {
+                    status: "succeeded",
+                    summary: `Relay order ${order.id} delivered.`,
+                    data: {
+                        deliveredBy: "agent",
+                        durationMs: duration,
+                        finalOrderStatus: readTaskText(finalStatus.status),
+                        outputSummary: truncateTaskText(finalStatus.result_text || result.response || "", 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 }));
             }
@@ -390,6 +501,15 @@ RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
                     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 this.recordOrderTask(order, {
+                        status: "succeeded",
+                        summary: `Relay order ${order.id} delivered by framework fallback.`,
+                        data: {
+                            deliveredBy: "framework_fallback",
+                            durationMs: duration,
+                            outputSummary: truncateTaskText(result.response || "", 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 }));
                 }
@@ -409,6 +529,15 @@ RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
                 const status = await relay.getOrder(order.id);
                 if (status?.status === "completed") {
                     this.orderRetry.delete(order.id);
+                    await this.recordOrderTask(order, {
+                        status: "succeeded",
+                        summary: `Relay order ${order.id} completed despite an execution error.`,
+                        data: {
+                            deliveredBy: "agent",
+                            error: err.message,
+                            finalOrderStatus: readTaskText(status.status),
+                        },
+                    });
                     bus.emit(SIG.TASK_COMPLETED, sig(SIG.TASK_COMPLETED, { success: true, taskLabel: orderLabel, creditsEarned: orderPrice, productName: order.product_name }));
                     return;
                 }
@@ -426,11 +555,29 @@ RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
                     await relay.extendOrder(order.id);
                 }
                 catch { }
+                await this.recordOrderTask(order, {
+                    status: "waiting",
+                    summary: `Relay order ${order.id} failed; retry ${current.count} scheduled.`,
+                    data: {
+                        error: err.message,
+                        retryCount: current.count,
+                        nextRetryAt: new Date(current.nextAt).toISOString(),
+                    },
+                });
             }
             else {
                 this.orderRetry.delete(order.id);
                 this.orderUserWritten.delete(order.id);
                 this.gaveUp.add(order.id);
+                await this.recordOrderTask(order, {
+                    status: "failed",
+                    summary: `Relay order ${order.id} failed after retries.`,
+                    data: {
+                        error: err.message,
+                        retryCount: current.count,
+                        canceled: true,
+                    },
+                });
                 bus.emit(SIG.TASK_COMPLETED, sig(SIG.TASK_COMPLETED, { success: false, taskLabel: orderLabel }));
                 try {
                     await relay.cancelOrder(order.id);
@@ -450,6 +597,14 @@ RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
         const taskKey = task.id || task.title;
         console.log(`[task] Executing user task: ${taskKey}`);
         const startTime = Date.now();
+        await this.recordUserTask(task, {
+            status: "running",
+            summary: `Executing owner recurring task ${taskKey}.`,
+            data: {
+                origin,
+                attempt: (this.userTaskRetry.get(taskKey)?.count || 0) + 1,
+            },
+        });
         try {
             const bios = biosPath(workdir, agentName);
             const sd = selfDir(workdir, agentName);
@@ -491,6 +646,14 @@ Your personal directory: ${sd}/`;
                 ts: localNow(), id: taskKey, type: "user_task", status: "success",
                 duration_ms: duration, output_summary: (result.response || "").slice(0, 500),
             });
+            await this.recordUserTask(task, {
+                status: "succeeded",
+                summary: `Owner recurring task ${taskKey} completed.`,
+                data: {
+                    durationMs: duration,
+                    outputSummary: truncateTaskText(result.response || "", 500),
+                },
+            });
             this.userTaskRetry.delete(taskKey);
             const nurl = this.notifyUrl || (await loadAgentConfig(workdir, agentName)).notify_url;
             await notifyOwner(nurl, `${agentName}: ${taskKey}`, (result.response || "").slice(0, 300), "default", ["white_check_mark"]);
@@ -512,6 +675,16 @@ Your personal directory: ${sd}/`;
                     ts: localNow(), id: taskKey, type: "user_task", status: "retry",
                     duration_ms: duration, output_summary: "", error: err.message,
                 });
+                await this.recordUserTask(task, {
+                    status: "waiting",
+                    summary: `Owner recurring task ${taskKey} failed; retry ${retry.count} scheduled.`,
+                    data: {
+                        durationMs: duration,
+                        error: err.message,
+                        retryCount: retry.count,
+                        nextRetryAt: new Date(retry.nextAt).toISOString(),
+                    },
+                });
             }
             else {
                 this.userTaskRetry.delete(taskKey);
@@ -522,6 +695,15 @@ Your personal directory: ${sd}/`;
                     ts: localNow(), id: taskKey, type: "user_task", status: "failed",
                     duration_ms: duration, output_summary: "", error: err.message,
                 });
+                await this.recordUserTask(task, {
+                    status: "failed",
+                    summary: `Owner recurring task ${taskKey} failed after retries.`,
+                    data: {
+                        durationMs: duration,
+                        error: err.message,
+                        retryCount: retry.count,
+                    },
+                });
                 const nurl = this.notifyUrl || (await loadAgentConfig(workdir, agentName)).notify_url;
                 await notifyOwner(nurl, `${agentName}: ${taskKey} FAILED`, err.message.slice(0, 300), "high", ["x"]);
             }
@@ -538,9 +720,19 @@ Your personal directory: ${sd}/`;
         const claimed = await relay.claimTask(task.id);
         if (!claimed) {
             console.log(`[task] Failed to claim ${task.id}`);
+            await this.recordRelayTask(task, {
+                status: "waiting",
+                summary: `Relay platform task ${task.id} could not be claimed.`,
+            });
             return;
         }
         console.log(`[task] Executing relay task ${task.id} (${task.type || "?"})`);
+        const startTime = Date.now();
+        await this.recordRelayTask(task, {
+            status: "running",
+            summary: `Executing relay platform task ${task.id}.`,
+            data: { origin },
+        });
         try {
             const bios = biosPath(workdir, agentName);
             let biosContent = "";
@@ -592,10 +784,29 @@ Complete this task. Use the environment info above and tools (curl, etc.) as nee
             if (completed) {
                 console.log(`[task] Completed relay task ${task.id}`);
             }
+            await this.recordRelayTask(task, {
+                status: "succeeded",
+                summary: completed
+                    ? `Relay platform task ${task.id} completed.`
+                    : `Relay platform task ${task.id} finished without relay completion confirmation.`,
+                data: {
+                    completionConfirmed: !!completed,
+                    durationMs: Date.now() - startTime,
+                    outputSummary: truncateTaskText(result.response || "", 500),
+                },
+            });
             bus.emit(SIG.TASK_COMPLETED, sig(SIG.TASK_COMPLETED, { success: true, taskLabel: `relay_task:${task.type || task.id}` }));
         }
         catch (err) {
             console.log(`[task] Relay task ${task.id} failed: ${err.message}`);
+            await this.recordRelayTask(task, {
+                status: "failed",
+                summary: `Relay platform task ${task.id} failed.`,
+                data: {
+                    durationMs: Date.now() - startTime,
+                    error: err.message,
+                },
+            });
             bus.emit(SIG.TASK_COMPLETED, sig(SIG.TASK_COMPLETED, { success: false, taskLabel: `relay_task:${task.type || task.id}` }));
             relay.reportLog("platform_task", task.id, "failed", err.message, []);
         }
@@ -630,3 +841,35 @@ Complete this task. Use the environment info above and tools (curl, etc.) as nee
         catch { }
     }
 }
+function workTaskRegistryId(kind, rawId) {
+    const safe = rawId
+        .replace(/[^A-Za-z0-9_.:-]+/g, "_")
+        .replace(/^\.+/, "")
+        .replace(/[. ]+$/g, "")
+        .slice(0, 140);
+    return `${kind}_${safe || "unknown"}`;
+}
+function orderConversationId(order) {
+    const buyerPubId = readTaskText(order?.buyer_ip) || readTaskText(order?.buyer_name) || "anonymous";
+    const productId = readTaskText(order?.product_id);
+    return `pub_${buyerPubId}${productId ? `:prod_${productId}` : ""}`;
+}
+function formatOrderObjective(order) {
+    const productName = readTaskText(order?.product_name);
+    const buyerTask = truncateTaskText(order?.buyer_task, 220);
+    if (productName && buyerTask)
+        return `${productName}: ${buyerTask}`;
+    return buyerTask || productName || `Relay order ${readTaskText(order?.id) || "unknown"}`;
+}
+function truncateTaskText(value, max) {
+    const text = readTaskText(value);
+    if (!text)
+        return "";
+    return text.length > max ? `${text.slice(0, Math.max(0, max - 3))}...` : text;
+}
+function readTaskText(value) {
+    if (typeof value !== "string" && typeof value !== "number")
+        return undefined;
+    const text = String(value).trim();
+    return text || undefined;
+}