@tea-agent/loop-agent 0.35.4-beta.0 → 0.36.0

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

@@ -22,6 +22,7 @@ import { clearSemanticIntakeAttempt } from "../../task/source-prepare/semantic-i
 import nodePath from "node:path";
 import { resolveSiblingAgentWorkerBin } from "./sibling-controller.js";
 import { projectOperationEventSummary, projectOperationForChat, } from "./chat/chat-event-store.js";
+import { OperationWaitError, waitForOperationChange, } from "./operation-wait.js";
 import { MutationGateReceiptStore } from "./mutation-gate-receipt-store.js";
 import { assessAutonomousExecutionEligibility, deriveEligibilityFactsFromDagSpec, } from "./dag-execution-receipt.js";
 import { issueHumanGateToken, mutationGatePayloadHash, verifyHumanGateToken, } from "./human-gate-token.js";
@@ -42,6 +43,7 @@ const MUTATION_OR_LONG = new Set([
     "contractApply",
     "contractAdopt",
     "contractRecover",
+    "taskAdvance",
     "dagRunTask",
     "runDag",
     "dagRerun",
@@ -55,6 +57,13 @@ function paramsOf(req) {
 function str(v) {
     return typeof v === "string" && v.trim() ? v.trim() : undefined;
 }
+const TASK_ID_PLACEHOLDER_RE = /[<>]|^(?:id|task-?id|your-task-id|todo|tbd)$/i;
+const TASK_ADVANCE_ALIAS_ACTIONS = new Set(["promoteRun", "closeoutTask"]);
+function taskIdInputError(taskId) {
+    if (!TASK_ID_PLACEHOLDER_RE.test(taskId))
+        return undefined;
+    return `taskId must be a concrete canonical id; placeholder values are not allowed: ${JSON.stringify(taskId)}`;
+}
 /** Extract write-set gate token from task advance operator JSON. */
 function extractWriteSetGateTokenFromCliJson(json, taskId) {
     if (!json || typeof json !== "object")
@@ -135,7 +144,21 @@ function gateError(action, code, message, details) {
  */
 async function assertAutonomousRerunEligible(ctx, runId, taskId) {
     const report = await runReadCli(ctx, ["dag", "report", "--run-id", runId, "--json"], "dag report");
-    const reportResult = (report.ok ? report.result : undefined);
+    // `dag report --json` emits { schemaVersion, runs: [...] } — the run facts
+    // (primaryFailure / primaryRecovery) live on each entry of `runs`, not on
+    // the envelope top level. Reading them from the top level made every
+    // standaloneTaskRerun call fail closed with "cannot read dagReport run
+    // facts" even though the evidence was present (2026-08-15 parse drift).
+    const reportEnvelope = (report.ok ? report.result : undefined);
+    const reportRuns = reportEnvelope?.runs ?? [];
+    const matchedRun = reportRuns.find((entry) => entry.runId === runId) ?? reportRuns[0];
+    const reportResult = matchedRun ??
+        (reportEnvelope?.primaryFailure
+            ? {
+                primaryFailure: reportEnvelope.primaryFailure,
+                primaryRecovery: reportEnvelope.primaryRecovery,
+            }
+            : undefined);
     const recovery = reportResult?.primaryRecovery;
     if (!report.ok || !reportResult?.primaryFailure || !recovery) {
         return gateError("standaloneTaskRerun", "INVALID_INPUT", "cannot read dagReport run facts; standaloneTaskRerun requires server-side run evidence", { runId });
@@ -519,6 +542,66 @@ export async function dispatchOperatorAction(ctx, req) {
                 }),
             };
         }
+        case "operationWait": {
+            const operationId = str(p.operationId);
+            if (!operationId)
+                return invalid(action, "operationId is required");
+            const rawAfterSeq = p.afterSeq ?? 0;
+            const afterSeq = typeof rawAfterSeq === "number" ? rawAfterSeq : Number(rawAfterSeq);
+            const rawMaxWaitMs = p.maxWaitMs;
+            const maxWaitMs = typeof rawMaxWaitMs === "number"
+                ? rawMaxWaitMs
+                : rawMaxWaitMs === undefined
+                    ? undefined
+                    : Number(rawMaxWaitMs);
+            const rawWakeOn = str(p.wakeOn);
+            const wakeOn = rawWakeOn === "all" || rawWakeOn === "meaningful" ? rawWakeOn : undefined;
+            try {
+                const result = await waitForOperationChange({
+                    operations: ctx.operations,
+                    events: ctx.events,
+                    operationId,
+                    afterSeq,
+                    maxWaitMs,
+                    ...(wakeOn ? { wakeOn } : {}),
+                });
+                return {
+                    kind: "sync",
+                    status: 200,
+                    body: operatorSucceeded(action, result),
+                };
+            }
+            catch (error) {
+                if (error instanceof OperationWaitError) {
+                    if (error.code === "NOT_FOUND") {
+                        return {
+                            kind: "error",
+                            status: 404,
+                            body: operatorFailed({
+                                command: action,
+                                outcome: "not-found",
+                                code: "NOT_FOUND",
+                                message: error.message,
+                            }),
+                        };
+                    }
+                    if (error.code === "EVENT_CURSOR_EXPIRED") {
+                        return {
+                            kind: "error",
+                            status: 410,
+                            body: operatorFailed({
+                                command: action,
+                                outcome: "blocked",
+                                code: "EVENT_CURSOR_EXPIRED",
+                                message: error.message,
+                            }),
+                        };
+                    }
+                    return invalid(action, error.message);
+                }
+                throw error;
+            }
+        }
         case "inspect": {
             const body = await runReadCli(ctx, ["inspect", "--json"], "inspect");
             return { kind: "sync", status: body.ok ? 200 : 400, body };
@@ -1186,8 +1269,24 @@ export async function dispatchOperatorAction(ctx, req) {
                 };
             }
             const reviewPacket = extractReviewPacketFromCliJson(gen.json) ?? {};
+            let parsedDagSpec;
+            try {
+                parsedDagSpec = JSON.parse(dagText);
+            }
+            catch (error) {
+                return {
+                    kind: "error",
+                    status: 409,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "blocked",
+                        code: "DAG_GENERATION_FAILED",
+                        message: `generated DAG is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+                    }),
+                };
+            }
             const derivedFacts = deriveEligibilityFactsFromDagSpec({
-                dagSpec: JSON.parse(dagText),
+                dagSpec: parsedDagSpec,
                 allowedPaths,
                 forbiddenPaths,
             });
@@ -1349,6 +1448,9 @@ export async function dispatchOperatorAction(ctx, req) {
             if (!taskId || !clientRequestId) {
                 return invalid(action, "taskId and clientRequestId are required");
             }
+            const taskIdError = taskIdInputError(taskId);
+            if (taskIdError)
+                return invalid(action, taskIdError);
             return acceptOperation(ctx, {
                 action,
                 actionParams: p,
@@ -1357,6 +1459,38 @@ export async function dispatchOperatorAction(ctx, req) {
                 cliArgs: ["task", "advance", taskId, title, "--json"],
             });
         }
+        case "taskAdvance": {
+            const taskId = str(p.taskId);
+            const clientRequestId = str(req.clientRequestId);
+            if (!taskId || !clientRequestId) {
+                return invalid(action, "taskId and clientRequestId are required");
+            }
+            const taskIdError = taskIdInputError(taskId);
+            if (taskIdError)
+                return invalid(action, taskIdError);
+            const args = ["task", "advance", taskId];
+            const title = str(p.title);
+            if (title)
+                args.push(title);
+            const taskKind = str(p.taskKind);
+            if (taskKind)
+                args.push("--task-kind", taskKind);
+            const featureId = str(p.featureId);
+            if (featureId)
+                args.push("--feature-id", featureId);
+            const profile = str(p.profile);
+            if (profile)
+                args.push("--profile", profile);
+            appendEngineeringCliArgs(args, parseEngineeringBoundaryFromParams(p));
+            args.push("--json");
+            return acceptOperation(ctx, {
+                action,
+                actionParams: p,
+                clientRequestId,
+                taskId,
+                cliArgs: args,
+            });
+        }
         case "bootstrapFromPrd":
             return dispatchBootstrapFromPrd(ctx, p);
         case "importPrd": {
@@ -1367,6 +1501,9 @@ export async function dispatchOperatorAction(ctx, req) {
             if (!taskId || !content) {
                 return invalid(action, "taskId and content are required");
             }
+            const taskIdError = taskIdInputError(taskId);
+            if (taskIdError)
+                return invalid(action, taskIdError);
             const taskKindRaw = str(p.taskKind)?.trim();
             const taskKind = normalizeConsoleWorkflowKind(taskKindRaw, "standard");
             const taskKindExplicit = Boolean(taskKindRaw);
@@ -1561,6 +1698,9 @@ export async function dispatchOperatorAction(ctx, req) {
             if (!taskId || !clientRequestId) {
                 return invalid(action, "taskId and clientRequestId are required");
             }
+            const taskIdError = taskIdInputError(taskId);
+            if (taskIdError)
+                return invalid(action, taskIdError);
             const out = await stageUtf8Text(ctx.appData, "", { extension: ".json" });
             return acceptOperation(ctx, {
                 action,
@@ -2195,6 +2335,14 @@ export async function dispatchOperatorAction(ctx, req) {
                         rawArgs.some((value) => typeof value !== "string"))) {
                     return invalid(action, "args must be an array of strings");
                 }
+                if (TASK_ADVANCE_ALIAS_ACTIONS.has(action) && Array.isArray(rawArgs)) {
+                    const aliasTaskId = str(rawArgs[0]);
+                    const taskIdError = aliasTaskId
+                        ? taskIdInputError(aliasTaskId)
+                        : undefined;
+                    if (taskIdError)
+                        return invalid(action, taskIdError);
+                }
                 if (capability.humanConfirmation === "required") {
                     const confirmationId = str(p.confirmationId);
                     if (!confirmationId)
@@ -2274,6 +2422,9 @@ export async function dispatchOperatorAction(ctx, req) {
                     .replace(/^(loop-agent|agent-worker)\s+/, "")
                     .split(/\s+/);
                 const args = [...prefix, ...(rawArgs ?? [])];
+                if (TASK_ADVANCE_ALIAS_ACTIONS.has(action) && !args.includes("--json")) {
+                    args.push("--json");
+                }
                 if (capability.kind === "read") {
                     if (!args.includes("--json"))
                         args.push("--json");