@tea-agent/loop-agent 0.22.0 → 0.24.0

package/dist/worker/console/mutation-gate-receipt-store.js

@@ -0,0 +1,184 @@
+/**
+ * Lightweight Human Gate receipts for mutation actions that are not DAG-bound
+ * (standaloneTaskRerun / workerTaskRetry). Mirrors contract-apply receipt
+ * semantics with an atomic prepared → dispatching → dispatched state machine
+ * so concurrent confirm POSTs cannot create duplicate operations.
+ */
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+export class MutationGateReceiptStore {
+    dir;
+    constructor(appData) {
+        this.dir = path.join(appData.root, "mutation-gate-receipts");
+    }
+    file(id) {
+        return path.join(this.dir, `${id.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`);
+    }
+    async prepare(input) {
+        const receipt = {
+            schemaVersion: 1,
+            state: "prepared",
+            ...input,
+        };
+        await mkdir(this.dir, { recursive: true, mode: 0o700 });
+        await writeFile(this.file(receipt.receiptId), `${JSON.stringify(receipt, null, 2)}\n`, { mode: 0o600 });
+        return receipt;
+    }
+    async get(id) {
+        try {
+            return JSON.parse(await readFile(this.file(id), "utf8"));
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        }
+    }
+    /**
+     * Atomically claim a prepared receipt for dispatch.
+     * Concurrent callers: only one gets reserved=true; others see
+     * already-dispatching / already-dispatched with the same receipt.
+     */
+    async tryReserve(id) {
+        const receipt = await this.get(id);
+        if (!receipt) {
+            return {
+                ok: false,
+                code: "NOT_FOUND",
+                message: `mutation gate receipt not found: ${id}`,
+            };
+        }
+        if (Date.parse(receipt.expiresAt) <= Date.now()) {
+            return {
+                ok: false,
+                code: "EXPIRED",
+                message: "mutation gate receipt expired",
+                receipt,
+            };
+        }
+        if (receipt.state === "dispatching") {
+            return {
+                ok: true,
+                receipt,
+                reserved: false,
+                reason: "already-dispatching",
+            };
+        }
+        if (receipt.state === "dispatched") {
+            return {
+                ok: true,
+                receipt,
+                reserved: false,
+                reason: "already-dispatched",
+            };
+        }
+        if (receipt.state !== "prepared") {
+            return {
+                ok: false,
+                code: "INVALID_STATE",
+                message: `mutation gate receipt is ${receipt.state}`,
+                receipt,
+            };
+        }
+        const next = {
+            ...receipt,
+            state: "dispatching",
+            reservedAt: new Date().toISOString(),
+        };
+        const claimed = await this.compareAndSwap(id, "prepared", next);
+        if (!claimed.ok) {
+            const current = claimed.current;
+            if (current?.state === "dispatching") {
+                return {
+                    ok: true,
+                    receipt: current,
+                    reserved: false,
+                    reason: "already-dispatching",
+                };
+            }
+            if (current?.state === "dispatched") {
+                return {
+                    ok: true,
+                    receipt: current,
+                    reserved: false,
+                    reason: "already-dispatched",
+                };
+            }
+            return {
+                ok: false,
+                code: "INVALID_STATE",
+                message: `mutation gate receipt raced into ${current?.state ?? "missing"}`,
+                receipt: current,
+            };
+        }
+        return { ok: true, receipt: next, reserved: true };
+    }
+    async markDispatched(id, operationId) {
+        const receipt = await this.get(id);
+        if (!receipt)
+            throw new Error(`receipt not found: ${id}`);
+        const next = {
+            ...receipt,
+            state: "dispatched",
+            operationId,
+            dispatchedAt: new Date().toISOString(),
+        };
+        await writeFile(this.file(id), `${JSON.stringify(next, null, 2)}\n`, {
+            mode: 0o600,
+        });
+        return next;
+    }
+    /** Best-effort unlock if dispatch failed after reserve. */
+    async releaseToPrepared(id) {
+        const receipt = await this.get(id);
+        if (!receipt || receipt.state !== "dispatching")
+            return receipt;
+        const next = {
+            ...receipt,
+            state: "prepared",
+            reservedAt: undefined,
+        };
+        await writeFile(this.file(id), `${JSON.stringify(next, null, 2)}\n`, {
+            mode: 0o600,
+        });
+        return next;
+    }
+    async compareAndSwap(id, expectedState, next) {
+        await mkdir(this.dir, { recursive: true, mode: 0o700 });
+        const target = this.file(id);
+        const lockPath = `${target}.lock`;
+        try {
+            await writeFile(lockPath, `${process.pid}\n`, { flag: "wx", mode: 0o600 });
+        }
+        catch (error) {
+            if (error.code === "EEXIST") {
+                // Brief spin for the other writer; then re-read.
+                await new Promise((r) => setTimeout(r, 25));
+                return { ok: false, current: await this.get(id) };
+            }
+            throw error;
+        }
+        try {
+            const current = await this.get(id);
+            if (!current || current.state !== expectedState) {
+                return { ok: false, current };
+            }
+            const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
+            await writeFile(tmp, `${JSON.stringify(next, null, 2)}\n`, {
+                mode: 0o600,
+            });
+            await rename(tmp, target);
+            return { ok: true };
+        }
+        finally {
+            try {
+                await writeFile(lockPath, "", { flag: "w" });
+                const { unlink } = await import("node:fs/promises");
+                await unlink(lockPath);
+            }
+            catch {
+                // lock cleanup is best-effort
+            }
+        }
+    }
+}

package/dist/worker/console/operation-runner.js

@@ -155,15 +155,19 @@ function coerceEnvelope(result) {
 /** Fire-and-forget scheduler for accepted operations. */
 export function scheduleOperation(operationId, deps) {
     void runOperation(operationId, deps).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
         void deps.store
             .update(operationId, {
             state: "needs-reconcile",
             finishedAt: new Date().toISOString(),
             errorCode: "OPERATION_NEEDS_RECONCILE",
-            errorMessage: error instanceof Error ? error.message : String(error),
+            errorMessage: message,
+        })
+            .then((updated) => {
+            stateEvent(deps.events, updated, "needs-reconcile", message);
         })
             .catch(() => {
-            // ignore secondary failures
+            // A failed canonical store update cannot be represented safely.
         });
     });
 }

package/dist/worker/console/operation-sse.js

@@ -13,6 +13,7 @@ export function createOperationEventStore(options) {
     if (persistenceDir)
         ensureSecureDir(persistenceDir);
     const rings = new Map();
+    const subscribers = new Map();
     function persistedPath(operationId) {
         return persistenceDir
             ? path.join(persistenceDir, `${safeOperationId(operationId)}.json`)
@@ -91,6 +92,17 @@ export function createOperationEventStore(options) {
                 ring.minSeq = ring.events[0].seq;
             }
             persist(operationId, ring);
+            const listeners = subscribers.get(operationId);
+            if (listeners) {
+                for (const listener of listeners) {
+                    try {
+                        listener(event);
+                    }
+                    catch {
+                        // Subscriber failures must never break the canonical append path.
+                    }
+                }
+            }
             return event;
         },
         listFrom(operationId, afterSeq) {
@@ -112,8 +124,22 @@ export function createOperationEventStore(options) {
                 rings.set(operationId, ring);
             return ring?.events.slice() ?? [];
         },
+        subscribe(operationId, listener) {
+            let listeners = subscribers.get(operationId);
+            if (!listeners) {
+                listeners = new Set();
+                subscribers.set(operationId, listeners);
+            }
+            listeners.add(listener);
+            return () => {
+                listeners?.delete(listener);
+                if (listeners?.size === 0)
+                    subscribers.delete(operationId);
+            };
+        },
         clear(operationId) {
             rings.delete(operationId);
+            subscribers.delete(operationId);
             const file = persistedPath(operationId);
             if (file)
                 rmSync(file, { force: true });