@tea-agent/loop-agent 0.28.13 → 0.29.1

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

@@ -17,73 +17,94 @@ export function newOperationId() {
 }
 export class OperationStore {
     appData;
+    /**
+     * Per-key write lock. Concurrent update/save/create on the same operation
+     * or clientRequestId must not race rename() into the same JSON path
+     * (Windows EPERM) or last-write-wins lost patches.
+     */
+    writeChains = new Map();
     constructor(appData) {
         this.appData = appData;
     }
+    serialize(key, op) {
+        const prev = this.writeChains.get(key) ?? Promise.resolve();
+        const next = prev.then(op, op);
+        this.writeChains.set(key, next.then(() => undefined, () => undefined));
+        return next;
+    }
     async create(input) {
         const clientRequestId = input.clientRequestId.trim();
         if (!clientRequestId) {
             throw new Error("clientRequestId is required for mutation operations");
         }
         const payloadHash = computeActionPayloadHash(input.action, input.actionParams);
-        const indexPath = requestIndexFile(this.appData, clientRequestId);
-        const existingIndex = await readJsonIfExists(indexPath);
-        if (existingIndex) {
-            const existing = await this.get(existingIndex.operationId);
-            if (existing) {
-                if (existing.payloadHash === payloadHash) {
-                    return { kind: "idempotent", operation: existing };
+        return this.serialize(`req:${clientRequestId}`, async () => {
+            const indexPath = requestIndexFile(this.appData, clientRequestId);
+            const existingIndex = await readJsonIfExists(indexPath);
+            if (existingIndex) {
+                const existing = await this.get(existingIndex.operationId);
+                if (existing) {
+                    if (existing.payloadHash === payloadHash) {
+                        return { kind: "idempotent", operation: existing };
+                    }
+                    return {
+                        kind: "conflict",
+                        code: "REQUEST_ID_REUSE_CONFLICT",
+                        message: `clientRequestId ${clientRequestId} was reused with a different payload`,
+                        existing,
+                    };
                 }
-                return {
-                    kind: "conflict",
-                    code: "REQUEST_ID_REUSE_CONFLICT",
-                    message: `clientRequestId ${clientRequestId} was reused with a different payload`,
-                    existing,
-                };
             }
-        }
-        const operationId = newOperationId();
-        const now = new Date().toISOString();
-        const operation = {
-            schemaVersion: 1,
-            operationId,
-            clientRequestId,
-            action: input.action,
-            actionParams: input.actionParams,
-            payloadHash,
-            state: "queued",
-            createdAt: now,
-            taskId: input.taskId,
-            cliArgs: input.cliArgs,
-            ...(input.externalCommand ? { externalCommand: input.externalCommand } : {}),
-        };
-        await writeSecureJson(operationFile(this.appData, operationId), operation);
-        await writeSecureJson(indexPath, { operationId, payloadHash });
-        return { kind: "created", operation };
+            const operationId = newOperationId();
+            const now = new Date().toISOString();
+            const operation = {
+                schemaVersion: 1,
+                operationId,
+                clientRequestId,
+                action: input.action,
+                actionParams: input.actionParams,
+                payloadHash,
+                state: "queued",
+                createdAt: now,
+                taskId: input.taskId,
+                cliArgs: input.cliArgs,
+                ...(input.externalCommand
+                    ? { externalCommand: input.externalCommand }
+                    : {}),
+            };
+            await writeSecureJson(operationFile(this.appData, operationId), operation);
+            await writeSecureJson(indexPath, { operationId, payloadHash });
+            return { kind: "created", operation };
+        });
     }
     async get(operationId) {
         return readJsonIfExists(operationFile(this.appData, operationId));
     }
     async save(operation) {
-        await writeSecureJson(operationFile(this.appData, operation.operationId), operation);
-        return operation;
+        return this.serialize(operation.operationId, async () => {
+            await writeSecureJson(operationFile(this.appData, operation.operationId), operation);
+            return operation;
+        });
     }
     async update(operationId, patch) {
-        const current = await this.get(operationId);
-        if (!current) {
-            throw new Error(`operation not found: ${operationId}`);
-        }
-        const next = {
-            ...current,
-            ...patch,
-            operationId: current.operationId,
-            schemaVersion: 1,
-            clientRequestId: current.clientRequestId,
-            payloadHash: current.payloadHash,
-            action: current.action,
-            createdAt: current.createdAt,
-        };
-        return this.save(next);
+        return this.serialize(operationId, async () => {
+            const current = await this.get(operationId);
+            if (!current) {
+                throw new Error(`operation not found: ${operationId}`);
+            }
+            const next = {
+                ...current,
+                ...patch,
+                operationId: current.operationId,
+                schemaVersion: 1,
+                clientRequestId: current.clientRequestId,
+                payloadHash: current.payloadHash,
+                action: current.action,
+                createdAt: current.createdAt,
+            };
+            await writeSecureJson(operationFile(this.appData, operationId), next);
+            return next;
+        });
     }
     async list() {
         const files = await listJsonFiles(this.appData.operations);

package/dist/worker/console/operator-actions.js

@@ -72,6 +72,49 @@ function readWriteSetGateToken(reviewPacket) {
     const token = reviewPacket.writeSetGateToken;
     return typeof token === "string" && token.includes(":") ? token : undefined;
 }
+/**
+ * Prefer structured stdout JSON failure semantics (findings / message) over bare
+ * `exit N` when stderr is empty — spine audit and similar read CLIs write details
+ * to stdout JSON and exit non-zero with empty stderr.
+ */
+function summarizeReadCliFailure(result) {
+    const fromJson = summarizeJsonFailure(result.json);
+    if (fromJson)
+        return fromJson;
+    const stderr = (result.stderr ?? "").trim();
+    if (stderr)
+        return stderr;
+    return `exit ${result.exitCode}`;
+}
+function summarizeJsonFailure(json) {
+    if (!json || typeof json !== "object")
+        return undefined;
+    const raw = json;
+    if (Array.isArray(raw.findings)) {
+        const messages = raw.findings
+            .map((finding) => {
+            if (!finding || typeof finding !== "object")
+                return "";
+            const message = finding.message;
+            return typeof message === "string" ? message.trim() : "";
+        })
+            .filter(Boolean);
+        if (messages.length > 0) {
+            const head = messages.slice(0, 6).join("; ");
+            return messages.length > 6 ? `${head}…` : head;
+        }
+    }
+    const nestedError = raw.error;
+    if (nestedError && typeof nestedError === "object") {
+        const message = nestedError.message;
+        if (typeof message === "string" && message.trim())
+            return message.trim();
+    }
+    if (typeof raw.message === "string" && raw.message.trim()) {
+        return raw.message.trim();
+    }
+    return undefined;
+}
 async function runReadCli(ctx, args, command) {
     const run = ctx.runCommand ?? ((a, o) => ctx.client.run(a, o));
     try {
@@ -124,11 +167,24 @@ async function runReadCli(ctx, args, command) {
                 raw: result.json,
             });
         }
+        const message = summarizeReadCliFailure(result);
+        if (result.json && typeof result.json === "object") {
+            return buildOperatorResult({
+                command,
+                ok: false,
+                outcome: "rejected",
+                result: result.json,
+                error: {
+                    code: "INTERNAL_ERROR",
+                    message,
+                },
+            });
+        }
         return operatorFailed({
             command,
             outcome: "rejected",
             code: "INTERNAL_ERROR",
-            message: result.stderr || `exit ${result.exitCode}`,
+            message,
         });
     }
     catch (error) {