@tea-agent/loop-agent 0.23.1 → 0.24.0

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

@@ -16,6 +16,13 @@ import { toCanonicalDraftForCli, } from "./draft-store.js";
 import { normalizeConsoleWorkflowKind } from "./workflow-kinds.js";
 import { deriveTaskIdentityFromPrd, nextTaskIdRevision, } from "./prd-identity.js";
 import { resolveSiblingAgentWorkerBin } from "./sibling-controller.js";
+import { projectOperationEventSummary, projectOperationForChat, } from "./chat/chat-event-store.js";
+import { MutationGateReceiptStore } from "./mutation-gate-receipt-store.js";
+import { issueHumanGateToken, mutationGatePayloadHash, verifyHumanGateToken, } from "./human-gate-token.js";
+const MUTATION_GATE_ACTIONS = new Set([
+    "standaloneTaskRerun",
+    "workerTaskRetry",
+]);
 const MUTATION_OR_LONG = new Set([
     "newTask",
     "importPrd",
@@ -192,6 +199,83 @@ export async function dispatchOperatorAction(ctx, req) {
                 body: operatorSucceeded("operator capabilities", doc),
             };
         }
+        case "operationGet": {
+            const operationId = str(p.operationId);
+            if (!operationId)
+                return invalid(action, "operationId is required");
+            const operation = await ctx.operations.get(operationId);
+            if (!operation) {
+                return {
+                    kind: "error",
+                    status: 404,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "not-found",
+                        code: "NOT_FOUND",
+                        message: `operation not found: ${operationId}`,
+                    }),
+                };
+            }
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded(action, projectOperationForChat(operation)),
+            };
+        }
+        case "operationList": {
+            const rawLimit = typeof p.limit === "number" ? p.limit : Number(p.limit ?? 20);
+            if (!Number.isFinite(rawLimit))
+                return invalid(action, "limit must be a number");
+            const limit = Math.max(1, Math.min(50, Math.floor(rawLimit)));
+            const state = str(p.state);
+            const actionFilter = str(p.action);
+            const operations = (await ctx.operations.list())
+                .filter((operation) => !state || operation.state === state)
+                .filter((operation) => !actionFilter || operation.action === actionFilter)
+                .slice(-limit)
+                .reverse()
+                .map(projectOperationForChat);
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded(action, { operations, limit }),
+            };
+        }
+        case "operationEventSummary": {
+            const operationId = str(p.operationId);
+            if (!operationId)
+                return invalid(action, "operationId is required");
+            const operation = await ctx.operations.get(operationId);
+            if (!operation) {
+                return {
+                    kind: "error",
+                    status: 404,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "not-found",
+                        code: "NOT_FOUND",
+                        message: `operation not found: ${operationId}`,
+                    }),
+                };
+            }
+            const rawLimit = typeof p.limit === "number" ? p.limit : Number(p.limit ?? 20);
+            if (!Number.isFinite(rawLimit))
+                return invalid(action, "limit must be a number");
+            const limit = Math.max(1, Math.min(100, Math.floor(rawLimit)));
+            const events = ctx.events
+                .snapshot(operationId)
+                .slice(-limit)
+                .map(projectOperationEventSummary);
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded(action, {
+                    operation: projectOperationForChat(operation),
+                    events,
+                    limit,
+                }),
+            };
+        }
         case "inspect": {
             const body = await runReadCli(ctx, ["inspect", "--json"], "inspect");
             return { kind: "sync", status: body.ok ? 200 : 400, body };
@@ -479,6 +563,16 @@ export async function dispatchOperatorAction(ctx, req) {
         case "prepareDagConfirmation": {
             const dagHandle = str(p.dagHandle) ?? "staged-dag.json";
             const taskId = str(p.taskId);
+            const operatorAction = str(p.operatorAction);
+            const operatorActionArgs = p.operatorActionArgs;
+            if (operatorActionArgs !== undefined && (!Array.isArray(operatorActionArgs) || operatorActionArgs.some((value) => typeof value !== "string"))) {
+                return invalid(action, "operatorActionArgs must be an array of strings");
+            }
+            if (operatorAction) {
+                const target = buildOperatorCapabilitiesDocument().actions.find((entry) => entry.action === operatorAction && entry.description.startsWith("Official CLI action coverage") && entry.humanConfirmation === "required");
+                if (!target)
+                    return invalid(action, "operatorAction must name a required official action");
+            }
             if (!taskId)
                 return invalid(action, "taskId is required");
             let dagText = str(p.dagText) ?? str(p.dagJson);
@@ -616,6 +710,7 @@ export async function dispatchOperatorAction(ctx, req) {
                     taskId,
                     dagHandle,
                     validationOk: true,
+                    ...(operatorAction ? { operatorAction, operatorActionArgs: operatorActionArgs ?? [] } : {}),
                 },
             });
             return {
@@ -630,7 +725,7 @@ export async function dispatchOperatorAction(ctx, req) {
         }
         case "confirmDagConfirmation": {
             const confirmationId = str(p.confirmationId);
-            const challenges = p.challenges ?? [];
+            const humanGateToken = p.humanGateToken;
             if (!confirmationId) {
                 return invalid(action, "confirmationId is required");
             }
@@ -669,7 +764,7 @@ export async function dispatchOperatorAction(ctx, req) {
             const result = await ctx.confirmations.confirm({
                 confirmationId,
                 operatorSessionId: ctx.operatorSessionId,
-                challenges,
+                humanGateToken,
                 current: {
                     dagSha256: hashDagBytes(dagBytes),
                     sourceBindingSha256: conf.sourceBindingSha256,
@@ -992,6 +1087,13 @@ export async function dispatchOperatorAction(ctx, req) {
             if (!runId || !reason || !clientRequestId) {
                 return invalid(action, "runId, reason, and clientRequestId are required");
             }
+            const gated = await consumeMutationGateReceipt(ctx, action, p);
+            if (gated.kind === "error")
+                return gated;
+            if (gated.kind === "idempotent")
+                return gated.result;
+            const profile = str(p.profile);
+            const taskId = str(p.taskId);
             const cliArgs = [
                 "dag",
                 "rerun-task",
@@ -1003,19 +1105,19 @@ export async function dispatchOperatorAction(ctx, req) {
                 clientRequestId,
                 "--json",
             ];
-            const profile = str(p.profile);
-            const taskId = str(p.taskId);
             if (profile)
                 cliArgs.push("--profile", profile);
             if (taskId)
                 cliArgs.push("--task-id", taskId);
-            return acceptOperation(ctx, {
+            const accepted = await acceptOperation(ctx, {
                 action,
                 actionParams: p,
                 clientRequestId,
                 taskId,
                 cliArgs,
             });
+            await finalizeMutationGateReceipt(ctx, gated.receiptId, accepted);
+            return accepted;
         }
         case "workerTaskRetry": {
             const taskId = str(p.taskId);
@@ -1025,6 +1127,11 @@ export async function dispatchOperatorAction(ctx, req) {
             if (!taskId || !reason || !clientRequestId) {
                 return invalid(action, "taskId, reason, and clientRequestId are required");
             }
+            const gated = await consumeMutationGateReceipt(ctx, action, p);
+            if (gated.kind === "error")
+                return gated;
+            if (gated.kind === "idempotent")
+                return gated.result;
             const args = [
                 "task",
                 "retry",
@@ -1036,7 +1143,7 @@ export async function dispatchOperatorAction(ctx, req) {
             ];
             if (featureId)
                 args.push("--feature-id", featureId);
-            return acceptOperation(ctx, {
+            const accepted = await acceptOperation(ctx, {
                 action,
                 actionParams: p,
                 clientRequestId,
@@ -1044,8 +1151,149 @@ export async function dispatchOperatorAction(ctx, req) {
                 cliArgs: args,
                 externalCommand: resolveSiblingAgentWorkerBin(),
             });
+            await finalizeMutationGateReceipt(ctx, gated.receiptId, accepted);
+            return accepted;
+        }
+        case "prepareMutationGate": {
+            const targetAction = str(p.action);
+            const actionParams = p.actionParams && typeof p.actionParams === "object" && !Array.isArray(p.actionParams)
+                ? p.actionParams
+                : undefined;
+            if (!targetAction || !actionParams) {
+                return invalid(action, "action and actionParams are required");
+            }
+            if (!MUTATION_GATE_ACTIONS.has(targetAction)) {
+                return invalid(action, "action must be standaloneTaskRerun or workerTaskRetry");
+            }
+            const secret = ctx.humanGateSecret;
+            if (!secret) {
+                return {
+                    kind: "error",
+                    status: 503,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "blocked",
+                        code: "INTERNAL_ERROR",
+                        message: "humanGateSecret is not configured on action context",
+                    }),
+                };
+            }
+            const paramsHash = mutationGatePayloadHash({
+                action: targetAction,
+                operatorSessionId: ctx.operatorSessionId,
+                actionParams,
+            });
+            const expiresAt = new Date(Date.now() + 30 * 60_000).toISOString();
+            const receiptId = `mut_${crypto.randomUUID()}`;
+            const humanGateToken = issueHumanGateToken({ confirmationId: receiptId, payloadHash: paramsHash, expiresAt }, secret);
+            const store = new MutationGateReceiptStore(ctx.appData);
+            const receipt = await store.prepare({
+                receiptId,
+                operatorSessionId: ctx.operatorSessionId,
+                action: targetAction,
+                paramsHash,
+                actionParams,
+                expiresAt,
+                humanGateToken,
+            });
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded("prepareMutationGate", {
+                    receiptId: receipt.receiptId,
+                    action: receipt.action,
+                    expiresAt: receipt.expiresAt,
+                    paramsHash: receipt.paramsHash,
+                    humanGateToken: receipt.humanGateToken,
+                    state: receipt.state,
+                }),
+            };
         }
-        default:
+        default: {
+            // M5 official-command coverage uses one generic tail for newly registered
+            // CLI actions. It remains inside dispatchOperatorAction (the sole dispatch
+            // surface) and only accepts argv arrays declared by the capability schema.
+            const capability = buildOperatorCapabilitiesDocument().actions.find((entry) => entry.action === action && entry.description.startsWith("Official CLI action coverage"));
+            if (capability) {
+                const rawArgs = p.args;
+                if (rawArgs !== undefined && (!Array.isArray(rawArgs) || rawArgs.some((value) => typeof value !== "string"))) {
+                    return invalid(action, "args must be an array of strings");
+                }
+                if (capability.humanConfirmation === "required") {
+                    const confirmationId = str(p.confirmationId);
+                    if (!confirmationId)
+                        return invalid(action, "confirmationId is required");
+                    const conf = await ctx.confirmations.get(confirmationId);
+                    if (!conf) {
+                        return {
+                            kind: "error",
+                            status: 404,
+                            body: operatorFailed({ command: action, outcome: "not-found", code: "NOT_FOUND", message: `confirmation not found: ${confirmationId}` }),
+                        };
+                    }
+                    const confirmedArgs = conf.reviewPacket?.operatorActionArgs;
+                    const requestedArgs = rawArgs ?? [];
+                    if (conf.operatorSessionId !== ctx.operatorSessionId ||
+                        conf.reviewPacket?.operatorAction !== action ||
+                        !Array.isArray(confirmedArgs) ||
+                        JSON.stringify(confirmedArgs) !== JSON.stringify(requestedArgs)) {
+                        return {
+                            kind: "error",
+                            status: 403,
+                            body: operatorFailed({ command: action, outcome: "blocked", code: "HUMAN_CONFIRMATION_REQUIRED", message: "confirmation receipt is not bound to this action, arguments, and operator session" }),
+                        };
+                    }
+                    let receiptBytes;
+                    try {
+                        receiptBytes = await readFile(conf.dagBytesPath, "utf8");
+                    }
+                    catch (error) {
+                        return {
+                            kind: "error",
+                            status: 409,
+                            body: operatorFailed({ command: action, outcome: "conflict", code: "CONFIRMATION_STALE", message: `cannot re-read confirmation receipt bytes: ${error instanceof Error ? error.message : String(error)}` }),
+                        };
+                    }
+                    const consumed = await ctx.confirmations.consume({
+                        confirmationId,
+                        operatorSessionId: ctx.operatorSessionId,
+                        current: {
+                            dagSha256: hashDagBytes(receiptBytes),
+                            sourceBindingSha256: conf.sourceBindingSha256,
+                            taskContractBinding: conf.taskContractBinding,
+                            controllerFingerprint: ctx.client.getIdentity?.()?.packageFingerprint?.value ?? conf.controllerFingerprint,
+                            validationResultSha256: conf.validationResultSha256,
+                        },
+                    });
+                    if (!consumed.ok) {
+                        return {
+                            kind: "error",
+                            status: confirmationErrorStatus(consumed.code),
+                            body: operatorFailed({ command: action, outcome: "rejected", code: consumed.code, message: consumed.message }),
+                        };
+                    }
+                }
+                const prefix = capability.cli.replace(/^(loop-agent|agent-worker)\s+/, "").split(/\s+/);
+                const args = [...prefix, ...(rawArgs ?? [])];
+                if (capability.kind === "read") {
+                    if (!args.includes("--json"))
+                        args.push("--json");
+                    const body = await runReadCli(ctx, args, prefix.join(" "));
+                    return { kind: "sync", status: body.ok ? 200 : 400, body };
+                }
+                const clientRequestId = str(req.clientRequestId);
+                if (!clientRequestId)
+                    return invalid(action, "clientRequestId is required");
+                return acceptOperation(ctx, {
+                    action,
+                    actionParams: p,
+                    clientRequestId,
+                    cliArgs: args,
+                    ...(capability.cli.startsWith("agent-worker ")
+                        ? { externalCommand: resolveSiblingAgentWorkerBin() }
+                        : {}),
+                });
+            }
             return {
                 kind: "error",
                 status: 400,
@@ -1056,7 +1304,172 @@ export async function dispatchOperatorAction(ctx, req) {
                     message: `unknown or unsupported action: ${action}`,
                 }),
             };
+        }
+    }
+}
+async function consumeMutationGateReceipt(ctx, action, p) {
+    const confirmationId = str(p.confirmationId);
+    const humanGateToken = p.humanGateToken;
+    if (!confirmationId) {
+        return {
+            kind: "error",
+            status: 400,
+            body: operatorFailed({
+                command: action,
+                outcome: "blocked",
+                code: "HUMAN_CONFIRMATION_REQUIRED",
+                message: "confirmationId is required — call prepareMutationGate then confirm via the browser Human Gate",
+            }),
+        };
+    }
+    const secret = ctx.humanGateSecret;
+    if (!secret) {
+        return {
+            kind: "error",
+            status: 503,
+            body: operatorFailed({
+                command: action,
+                outcome: "blocked",
+                code: "INTERNAL_ERROR",
+                message: "humanGateSecret is not configured on action context",
+            }),
+        };
+    }
+    const store = new MutationGateReceiptStore(ctx.appData);
+    const receipt = await store.get(confirmationId);
+    if (!receipt || receipt.operatorSessionId !== ctx.operatorSessionId) {
+        return {
+            kind: "error",
+            status: 404,
+            body: operatorFailed({
+                command: action,
+                outcome: "not-found",
+                code: "NOT_FOUND",
+                message: `mutation gate receipt not found: ${confirmationId}`,
+            }),
+        };
+    }
+    if (receipt.action !== action) {
+        return {
+            kind: "error",
+            status: 403,
+            body: operatorFailed({
+                command: action,
+                outcome: "blocked",
+                code: "HUMAN_CONFIRMATION_REQUIRED",
+                message: "mutation gate receipt is bound to a different action",
+            }),
+        };
+    }
+    const { confirmationId: _cid, humanGateToken: _tok, ...boundParams } = p;
+    const expectedHash = mutationGatePayloadHash({
+        action,
+        operatorSessionId: ctx.operatorSessionId,
+        actionParams: receipt.actionParams,
+    });
+    if (expectedHash !== receipt.paramsHash) {
+        return {
+            kind: "error",
+            status: 403,
+            body: operatorFailed({
+                command: action,
+                outcome: "blocked",
+                code: "HUMAN_CONFIRMATION_REQUIRED",
+                message: "mutation gate receipt params hash mismatch",
+            }),
+        };
+    }
+    // Bound params from the receipt must match the dispatch params (minus gate fields).
+    const presentedParams = {};
+    for (const key of Object.keys(receipt.actionParams)) {
+        presentedParams[key] = boundParams[key];
+    }
+    const presentedHash = mutationGatePayloadHash({
+        action,
+        operatorSessionId: ctx.operatorSessionId,
+        actionParams: presentedParams,
+    });
+    if (presentedHash !== receipt.paramsHash) {
+        return {
+            kind: "error",
+            status: 403,
+            body: operatorFailed({
+                command: action,
+                outcome: "blocked",
+                code: "HUMAN_CONFIRMATION_REQUIRED",
+                message: "dispatch params do not match the prepared mutation gate receipt",
+            }),
+        };
+    }
+    const check = verifyHumanGateToken(humanGateToken, { confirmationId: receipt.receiptId, payloadHash: receipt.paramsHash }, secret);
+    if (!check.ok) {
+        return {
+            kind: "error",
+            status: 403,
+            body: operatorFailed({
+                command: action,
+                outcome: "blocked",
+                code: "HUMAN_CONFIRMATION_REQUIRED",
+                message: check.message,
+            }),
+        };
+    }
+    const reserved = await store.tryReserve(confirmationId);
+    if (!reserved.ok) {
+        return {
+            kind: "error",
+            status: reserved.code === "NOT_FOUND" ? 404 : reserved.code === "EXPIRED" ? 410 : 409,
+            body: operatorFailed({
+                command: action,
+                outcome: "rejected",
+                code: reserved.code === "EXPIRED"
+                    ? "CONFIRMATION_EXPIRED"
+                    : "HUMAN_CONFIRMATION_REQUIRED",
+                message: reserved.message,
+            }),
+        };
+    }
+    if (!reserved.reserved) {
+        const operationId = reserved.receipt.operationId;
+        if (operationId) {
+            const existing = await ctx.operations.get(operationId);
+            if (existing) {
+                return {
+                    kind: "idempotent",
+                    result: {
+                        kind: "accepted",
+                        status: 202,
+                        body: {
+                            operationId: existing.operationId,
+                            state: existing.state,
+                            clientRequestId: existing.clientRequestId,
+                            action: existing.action,
+                        },
+                    },
+                };
+            }
+        }
+        return {
+            kind: "error",
+            status: 409,
+            body: operatorFailed({
+                command: action,
+                outcome: "conflict",
+                code: "CONFIRMATION_CONSUMED",
+                message: `mutation gate receipt already ${reserved.reason}`,
+                details: { operationId },
+            }),
+        };
+    }
+    return { kind: "ready", receiptId: confirmationId };
+}
+async function finalizeMutationGateReceipt(ctx, receiptId, accepted) {
+    const store = new MutationGateReceiptStore(ctx.appData);
+    if (accepted.kind === "accepted") {
+        await store.markDispatched(receiptId, accepted.body.operationId);
+        return;
     }
+    await store.releaseToPrepared(receiptId);
 }
 async function taskExistsOnDisk(repoRoot, taskId) {
     try {

package/dist/worker/console/server.js

@@ -11,6 +11,7 @@ import { AssessmentStore } from "./interview/assessment.js";
 import { InterviewSessionStore } from "./interview/session.js";
 import { isLoopbackHost } from "./loopback.js";
 import { ChatSessionStore } from "./chat/session-store.js";
+import { createChatEventStore, createChatOperationLinker, } from "./chat/chat-event-store.js";
 import { ConsolePiRuntime } from "./chat/pi-runtime.js";
 import { handleChatRequest } from "./chat/routes.js";
 import { createOperationEventStore, } from "./operation-sse.js";
@@ -56,7 +57,7 @@ export async function createConsoleServer(options) {
         persistenceDir: path.join(appData.operations, "events"),
     });
     const drafts = new DraftStore(appData);
-    const confirmations = new DagConfirmationStore(appData);
+    const confirmations = new DagConfirmationStore(appData, bootToken.confirmationToken);
     const interviews = new InterviewSessionStore(appData);
     const assessments = new AssessmentStore(appData);
     const readiness = await probePiReadiness({
@@ -90,6 +91,7 @@ export async function createConsoleServer(options) {
         events,
         drafts,
         confirmations,
+        humanGateSecret: bootToken.confirmationToken,
         interviews,
         assessments,
         readiness: readinessCache,
@@ -106,6 +108,12 @@ export async function createConsoleServer(options) {
     // custom-tool execute() calls dispatch into the operator action layer (Gate 3).
     // Chat session dir is dedicated (app-data/chat-sessions), NOT user default.
     const chatStore = new ChatSessionStore(appData);
+    const chatEvents = createChatEventStore({ appData });
+    const chatOperationLinker = createChatOperationLinker({
+        chatEvents,
+        operations,
+        operationEvents: events,
+    });
     const skillsDir = resolveLoopAgentSkillsDir(repoRoot);
     const chatRuntime = new ConsolePiRuntime({
         cwd: repoRoot,
@@ -120,6 +128,8 @@ export async function createConsoleServer(options) {
     const chatRouteDeps = {
         runtime: chatRuntime,
         store: chatStore,
+        events: chatEvents,
+        operationLinker: chatOperationLinker,
         appData,
         bootToken,
         getConsoleOrigin,
@@ -202,7 +212,8 @@ export async function createConsoleServer(options) {
             if (pathname.startsWith("/api/operator/v1/") ||
                 pathname.startsWith("/api/session/")) {
                 // Phase 4: General Operator Chat routes (mounted under chat/).
-                if (pathname.startsWith("/api/operator/v1/chat/")) {
+                if (pathname.startsWith("/api/operator/v1/chat/") ||
+                    pathname.startsWith("/api/operator/v1/pi/")) {
                     await handleChatRequest(req, res, chatRouteDeps, pathname);
                     return;
                 }
@@ -259,6 +270,7 @@ export async function createConsoleServer(options) {
                     // leaks across Console restarts (regression: close() previously
                     // only closed the socket, leaving ConsolePiRuntime sessions live).
                     try {
+                        chatOperationLinker.dispose();
                         chatRuntime.disposeAll();
                     }
                     catch (error) {