@tea-agent/loop-agent 0.26.5-beta.2 → 0.27.0

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

@@ -2,6 +2,7 @@ import { access, readFile } from "node:fs/promises";
 import { buildOperatorCapabilitiesDocument } from "../../shared/operator/capabilities.js";
 import { buildOperatorResult, operatorFailed, operatorSucceeded, } from "../../shared/operator/envelope.js";
 import { getTaskPaths } from "../../task/runtime.js";
+import { diffTaskContract, validateDraftForTask, } from "../../task/contract/index.js";
 import { stageUtf8Text } from "./app-data.js";
 import { ALL_CONFIRMATION_CHALLENGES, hashDagBytes, } from "./dag-confirmation.js";
 import { capabilityForObserveTarget, DEFAULT_OBSERVE_BASE_URL, OBSERVE_START_COMMAND, probeAndClassifyObserve, } from "./observe-health-match.js";
@@ -41,6 +42,31 @@ function paramsOf(req) {
 function str(v) {
     return typeof v === "string" && v.trim() ? v.trim() : undefined;
 }
+/** Extract write-set gate token from task advance operator JSON. */
+function extractWriteSetGateTokenFromCliJson(json, taskId) {
+    if (!json || typeof json !== "object")
+        return undefined;
+    const envelope = json;
+    const payload = envelope.result && typeof envelope.result === "object"
+        ? envelope.result
+        : envelope;
+    const gate = payload.gate && typeof payload.gate === "object"
+        ? payload.gate
+        : undefined;
+    const id = typeof gate?.id === "string" ? gate.id : undefined;
+    const digest = typeof gate?.digest === "string" ? gate.digest : undefined;
+    if (!id || !digest)
+        return undefined;
+    // taskId kept for future binding checks / logging symmetry with worker.
+    void taskId;
+    return `${id}:${digest}`;
+}
+function readWriteSetGateToken(reviewPacket) {
+    if (!reviewPacket)
+        return undefined;
+    const token = reviewPacket.writeSetGateToken;
+    return typeof token === "string" && token.includes(":") ? token : undefined;
+}
 async function runReadCli(ctx, args, command) {
     const run = ctx.runCommand ?? ((a, o) => ctx.client.run(a, o));
     try {
@@ -55,7 +81,9 @@ async function runReadCli(ctx, args, command) {
             if (env.schemaVersion === 1 && typeof env.ok === "boolean") {
                 return env;
             }
-            if (command === "dag rerun plan" && raw.plan && typeof raw.plan === "object") {
+            if (command === "dag rerun plan" &&
+                raw.plan &&
+                typeof raw.plan === "object") {
                 const plan = raw.plan;
                 if (raw.ok === true) {
                     return operatorSucceeded(command, plan);
@@ -114,7 +142,9 @@ async function acceptOperation(ctx, input) {
         actionParams: input.actionParams,
         taskId: input.taskId,
         cliArgs: input.cliArgs,
-        ...(input.externalCommand ? { externalCommand: input.externalCommand } : {}),
+        ...(input.externalCommand
+            ? { externalCommand: input.externalCommand }
+            : {}),
     });
     if (created.kind === "conflict") {
         return {
@@ -297,7 +327,7 @@ export async function dispatchOperatorAction(ctx, req) {
             if (!taskId) {
                 return invalid(action, "taskId is required");
             }
-            const body = await runReadCli(ctx, ["status", taskId, "--json"], "status");
+            const body = await runReadCli(ctx, ["task", "status", taskId, "--json"], "task status");
             return {
                 kind: "sync",
                 status: body.ok ? 200 : body.outcome === "not-found" ? 404 : 400,
@@ -322,11 +352,38 @@ export async function dispatchOperatorAction(ctx, req) {
             const taskId = str(p.taskId);
             if (!taskId)
                 return invalid(action, "taskId is required");
-            const body = await runReadCli(ctx, ["task", "contract", "show", taskId, "--json"], "task contract show");
+            const body = await runReadCli(ctx, ["task", "status", taskId, "--json"], "task status");
+            const snap = (body.result ?? {});
+            const c = snap.contract;
+            const reshaped = {
+                ...body,
+                command: "contractShow",
+                result: {
+                    taskId,
+                    state: {
+                        effectiveStatus: c?.effectiveStatus ?? "legacy-unversioned",
+                        observedCanonicalHash: c?.observedCanonicalHash ?? undefined,
+                        ref: c?.canonicalHash && typeof c.revision === "number"
+                            ? {
+                                schemaVersion: 1,
+                                taskId,
+                                revision: c.revision,
+                                canonicalHash: c.canonicalHash,
+                                taskConfigSha256: c.taskConfigSha256 ?? undefined,
+                                projectionVersion: c.projectionVersion ?? undefined,
+                                canonicalizerVersion: c.canonicalizerVersion ?? undefined,
+                                taskConfigSchemaVersion: c.taskConfigSchemaVersion ?? undefined,
+                            }
+                            : undefined,
+                    },
+                    snapshot: snap,
+                },
+            };
+            const notFound = body.ok === true && snap.exists === false;
             return {
                 kind: "sync",
-                status: body.ok ? 200 : body.outcome === "not-found" ? 404 : 400,
-                body,
+                status: notFound ? 404 : body.ok ? 200 : body.outcome === "not-found" ? 404 : 400,
+                body: reshaped,
             };
         }
         case "contractValidate":
@@ -565,11 +622,15 @@ export async function dispatchOperatorAction(ctx, req) {
             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"))) {
+            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");
+                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");
             }
@@ -577,22 +638,25 @@ export async function dispatchOperatorAction(ctx, req) {
                 return invalid(action, "taskId is required");
             let dagText = str(p.dagText) ?? str(p.dagJson);
             let staged;
+            // When generated via lifecycle, store writeSet gate token for runDag approve path.
+            let writeSetGateToken;
             if (!dagText) {
-                // Happy Path: generate a real DAG via CLI; never confirm an empty stub.
+                // Happy Path: generate + strict-validate via task advance; never confirm empty stub.
                 staged = await stageUtf8Text(ctx.appData, "", { extension: ".json" });
                 const profile = str(p.profile) ?? "auto";
                 const run = ctx.runCommand ?? ((a, o) => ctx.client.run(a, o));
                 const gen = await run([
-                    "dag",
-                    "run-task",
+                    "task",
+                    "advance",
                     taskId,
                     "--profile",
                     profile,
-                    "-o",
+                    "--dag-output",
                     staged.path,
+                    "--json",
                 ], {
                     cwd: ctx.repoRoot,
-                    artifactName: "prepare-dag-run-task",
+                    artifactName: "prepare-dag-task-advance",
                     expectJson: true,
                     timeoutMs: 180_000,
                 });
@@ -605,7 +669,7 @@ export async function dispatchOperatorAction(ctx, req) {
                             outcome: "invalid",
                             code: "INVALID_INPUT",
                             message: gen.stderr?.trim() ||
-                                `dag run-task failed with exit ${gen.exitCode}`,
+                                `task advance (prepare DAG) failed with exit ${gen.exitCode}`,
                             details: {
                                 exitCode: gen.exitCode,
                                 stdoutPreview: (gen.stdout ?? "").slice(0, 1200),
@@ -622,10 +686,11 @@ export async function dispatchOperatorAction(ctx, req) {
                             command: action,
                             outcome: "invalid",
                             code: "INVALID_INPUT",
-                            message: "dag run-task produced empty DAG output",
+                            message: "task advance produced empty DAG output",
                         }),
                     };
                 }
+                writeSetGateToken = extractWriteSetGateTokenFromCliJson(gen.json, taskId);
                 staged = await stageUtf8Text(ctx.appData, dagText, {
                     extension: ".json",
                 });
@@ -667,9 +732,25 @@ export async function dispatchOperatorAction(ctx, req) {
                 result: validateBody.result ?? null,
             }));
             // Prefer live managed contract observation over client-supplied binding fields.
-            const showBody = await runReadCli(ctx, ["task", "contract", "show", taskId, "--json"], "task contract show");
-            const showResult = (showBody.result ?? {});
-            const ref = showBody.ok ? showResult.state?.ref : undefined;
+            const showBody = await runReadCli(ctx, ["task", "status", taskId, "--json"], "task status");
+            const statusResult = (showBody.result ?? {});
+            const c = showBody.ok ? statusResult.contract : undefined;
+            const ref = c?.canonicalHash && typeof c.revision === "number"
+                ? {
+                    revision: c.revision,
+                    canonicalHash: c.canonicalHash,
+                    taskConfigSha256: c.taskConfigSha256 ?? undefined,
+                    projectionVersion: c.projectionVersion ?? undefined,
+                    canonicalizerVersion: c.canonicalizerVersion ?? undefined,
+                    taskConfigSchemaVersion: c.taskConfigSchemaVersion ?? undefined,
+                }
+                : undefined;
+            const showResult = {
+                state: {
+                    effectiveStatus: c?.effectiveStatus,
+                    ref,
+                },
+            };
             if (!ref?.canonicalHash || typeof ref.revision !== "number") {
                 return {
                     kind: "error",
@@ -710,7 +791,13 @@ export async function dispatchOperatorAction(ctx, req) {
                     taskId,
                     dagHandle,
                     validationOk: true,
-                    ...(operatorAction ? { operatorAction, operatorActionArgs: operatorActionArgs ?? [] } : {}),
+                    ...(writeSetGateToken ? { writeSetGateToken } : {}),
+                    ...(operatorAction
+                        ? {
+                            operatorAction,
+                            operatorActionArgs: operatorActionArgs ?? [],
+                        }
+                        : {}),
                 },
             });
             return {
@@ -803,7 +890,7 @@ export async function dispatchOperatorAction(ctx, req) {
                 actionParams: p,
                 clientRequestId,
                 taskId,
-                cliArgs: ["new-task", taskId, title, "--json"],
+                cliArgs: ["task", "advance", taskId, title, "--json"],
             });
         }
         case "bootstrapFromPrd": {
@@ -824,7 +911,8 @@ export async function dispatchOperatorAction(ctx, req) {
                 actionParams: { taskId, stagedSha256: staged.sha256 },
                 clientRequestId,
                 taskId,
-                cliArgs: ["import-prd", taskId, "--file", staged.path, "--json"],
+                // PRD archive via task advance; create if missing.
+                cliArgs: ["task", "advance", taskId, "--prd", staged.path, "--json"],
             });
         }
         case "contractApply": {
@@ -888,15 +976,10 @@ export async function dispatchOperatorAction(ctx, req) {
                 };
             }
             const staged = await stageUtf8Text(ctx.appData, JSON.stringify(toCanonicalDraftForCli(draftRec.draft), null, 2), { extension: ".json" });
-            // Optimistic concurrency: observe live revision/hash; never default to "unknown".
-            const showBody = await runReadCli(ctx, ["task", "contract", "show", taskId, "--json"], "task contract show");
-            const showState = (showBody.result ?? {}).state;
-            const emptyObservedHash = "0".repeat(64);
-            const expectedRevision = String(p.expectedRevision ?? showState?.ref?.revision ?? 0);
-            const expectedHash = str(p.expectedObservedHash) ??
-                showState?.observedCanonicalHash ??
-                emptyObservedHash;
-            // CLI validates --request-payload-sha256 against input file bytes, not draft projection hash.
+            // Lifecycle apply via task advance --from-draft (managed contract projection).
+            // Optimistic concurrency remains inside applyTaskContract via prepareTaskSource.
+            const statusBody = await runReadCli(ctx, ["task", "status", taskId, "--json"], "task status");
+            const statusContract = (statusBody.result ?? {}).contract;
             const payloadSha = staged.sha256;
             return acceptOperation(ctx, {
                 action,
@@ -905,28 +988,20 @@ export async function dispatchOperatorAction(ctx, req) {
                     assessmentId,
                     draftSha256: draftRec.draftSha256,
                     requestPayloadSha256: payloadSha,
-                    expectedRevision: Number(expectedRevision),
-                    expectedObservedHash: expectedHash,
-                    effectiveStatus: showState?.effectiveStatus,
+                    expectedRevision: Number(p.expectedRevision ?? statusContract?.revision ?? 0),
+                    expectedObservedHash: str(p.expectedObservedHash) ??
+                        statusContract?.observedCanonicalHash ??
+                        null,
+                    effectiveStatus: statusContract?.effectiveStatus,
                 },
                 clientRequestId,
                 taskId,
                 cliArgs: [
                     "task",
-                    "contract",
-                    "apply",
-                    "--task",
+                    "advance",
                     taskId,
-                    "--input",
+                    "--from-draft",
                     staged.path,
-                    "--expected-revision",
-                    expectedRevision,
-                    "--expected-observed-hash",
-                    expectedHash,
-                    "--request-id",
-                    clientRequestId,
-                    "--request-payload-sha256",
-                    payloadSha,
                     "--json",
                 ],
             });
@@ -943,14 +1018,16 @@ export async function dispatchOperatorAction(ctx, req) {
                 actionParams: p,
                 clientRequestId,
                 taskId,
+                // Lifecycle generate + strict validate; stops at writeSet gate.
                 cliArgs: [
-                    "dag",
-                    "run-task",
+                    "task",
+                    "advance",
                     taskId,
                     "--profile",
                     str(p.profile) ?? "auto",
-                    "-o",
+                    "--dag-output",
                     out.path,
+                    "--json",
                 ],
             });
         }
@@ -1017,13 +1094,34 @@ export async function dispatchOperatorAction(ctx, req) {
                     }),
                 };
             }
+            const taskId = conf.taskContractBinding.taskId;
+            const gateToken = readWriteSetGateToken(conf.reviewPacket);
+            if (gateToken) {
+                // Standard lifecycle path: human confirmation maps to writeSet gate approve.
+                return acceptOperation(ctx, {
+                    action,
+                    actionParams: { confirmationId },
+                    clientRequestId,
+                    taskId,
+                    cliArgs: [
+                        "task",
+                        "advance",
+                        taskId,
+                        "--approve-gate",
+                        gateToken,
+                        "--json",
+                    ],
+                });
+            }
+            // Advanced: arbitrary staged DagSpec (client-supplied dagText) until dag execute rename.
             return acceptOperation(ctx, {
                 action,
                 actionParams: { confirmationId },
                 clientRequestId,
-                taskId: conf.taskContractBinding.taskId,
+                taskId,
                 cliArgs: [
-                    "run-dag",
+                    "dag",
+                    "execute",
                     "--dag",
                     conf.dagBytesPath,
                     "--cwd",
@@ -1156,7 +1254,9 @@ export async function dispatchOperatorAction(ctx, req) {
         }
         case "prepareMutationGate": {
             const targetAction = str(p.action);
-            const actionParams = p.actionParams && typeof p.actionParams === "object" && !Array.isArray(p.actionParams)
+            const actionParams = p.actionParams &&
+                typeof p.actionParams === "object" &&
+                !Array.isArray(p.actionParams)
                 ? p.actionParams
                 : undefined;
             if (!targetAction || !actionParams) {
@@ -1213,10 +1313,13 @@ export async function dispatchOperatorAction(ctx, req) {
             // 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"));
+            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"))) {
+                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") {
@@ -1228,7 +1331,12 @@ export async function dispatchOperatorAction(ctx, req) {
                         return {
                             kind: "error",
                             status: 404,
-                            body: operatorFailed({ command: action, outcome: "not-found", code: "NOT_FOUND", message: `confirmation not found: ${confirmationId}` }),
+                            body: operatorFailed({
+                                command: action,
+                                outcome: "not-found",
+                                code: "NOT_FOUND",
+                                message: `confirmation not found: ${confirmationId}`,
+                            }),
                         };
                     }
                     const confirmedArgs = conf.reviewPacket?.operatorActionArgs;
@@ -1240,7 +1348,12 @@ export async function dispatchOperatorAction(ctx, req) {
                         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" }),
+                            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;
@@ -1251,7 +1364,12 @@ export async function dispatchOperatorAction(ctx, req) {
                         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)}` }),
+                            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({
@@ -1261,7 +1379,8 @@ export async function dispatchOperatorAction(ctx, req) {
                             dagSha256: hashDagBytes(receiptBytes),
                             sourceBindingSha256: conf.sourceBindingSha256,
                             taskContractBinding: conf.taskContractBinding,
-                            controllerFingerprint: ctx.client.getIdentity?.()?.packageFingerprint?.value ?? conf.controllerFingerprint,
+                            controllerFingerprint: ctx.client.getIdentity?.()?.packageFingerprint?.value ??
+                                conf.controllerFingerprint,
                             validationResultSha256: conf.validationResultSha256,
                         },
                     });
@@ -1269,11 +1388,18 @@ export async function dispatchOperatorAction(ctx, req) {
                         return {
                             kind: "error",
                             status: confirmationErrorStatus(consumed.code),
-                            body: operatorFailed({ command: action, outcome: "rejected", code: consumed.code, message: consumed.message }),
+                            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 prefix = capability.cli
+                    .replace(/^(loop-agent|agent-worker)\s+/, "")
+                    .split(/\s+/);
                 const args = [...prefix, ...(rawArgs ?? [])];
                 if (capability.kind === "read") {
                     if (!args.includes("--json"))
@@ -1418,7 +1544,11 @@ async function consumeMutationGateReceipt(ctx, action, p) {
     if (!reserved.ok) {
         return {
             kind: "error",
-            status: reserved.code === "NOT_FOUND" ? 404 : reserved.code === "EXPIRED" ? 410 : 409,
+            status: reserved.code === "NOT_FOUND"
+                ? 404
+                : reserved.code === "EXPIRED"
+                    ? 410
+                    : 409,
             body: operatorFailed({
                 command: action,
                 outcome: "rejected",
@@ -1518,13 +1648,16 @@ async function dispatchBootstrapFromPrd(ctx, p) {
     }
     const title = identity.title;
     const run = ctx.runCommand ?? ((a, o) => ctx.client.run(a, o));
-    // new-task prints a path, not operator JSON — do not expectJson (that flips ok=false).
-    const created = await run(["new-task", taskId, title], {
+    // Standard lifecycle entry: task advance create + PRD import(s).
+    const advanceCreate = await run(["task", "advance", taskId, title, "--json"], {
         cwd: ctx.repoRoot,
-        artifactName: "bootstrap-new-task",
+        artifactName: "bootstrap-task-advance-create",
+        expectJson: true,
         timeoutMs: 60_000,
     });
-    if (created.exitCode !== 0 || created.timedOut) {
+    if (!advanceCreate.ok ||
+        advanceCreate.exitCode !== 0 ||
+        advanceCreate.timedOut) {
         return {
             kind: "error",
             status: 400,
@@ -1532,37 +1665,36 @@ async function dispatchBootstrapFromPrd(ctx, p) {
                 command: "bootstrapFromPrd",
                 outcome: "rejected",
                 code: "INTERNAL_ERROR",
-                message: created.stderr?.trim() ||
-                    `new-task failed with exit ${created.exitCode}`,
+                message: advanceCreate.stderr?.trim() ||
+                    `task advance (create) failed with exit ${advanceCreate.exitCode}`,
                 details: {
-                    exitCode: created.exitCode,
-                    timedOut: created.timedOut,
+                    exitCode: advanceCreate.exitCode,
+                    timedOut: advanceCreate.timedOut,
                     taskId,
                     title,
-                    stdoutPreview: (created.stdout ?? "").slice(0, 400),
+                    stdoutPreview: (advanceCreate.stdout ?? "").slice(0, 400),
                 },
             }),
         };
     }
     const succeededImports = [];
     const importResults = [];
-    const runImportPrd = async (label, text, name) => {
+    const runImportViaAdvance = async (label, text, name) => {
         const staged = await stageUtf8Text(ctx.appData, text, {
             extension: ".md",
         });
         const imported = await run([
-            "import-prd",
+            "task",
+            "advance",
             taskId,
-            "--file",
+            "--prd",
             staged.path,
-            "--name",
-            name,
             "--role",
             "requirement",
             "--json",
         ], {
             cwd: ctx.repoRoot,
-            artifactName: `bootstrap-import-prd-${label}`,
+            artifactName: `bootstrap-task-advance-prd-${label}`,
             expectJson: true,
             timeoutMs: 60_000,
         });
@@ -1575,7 +1707,7 @@ async function dispatchBootstrapFromPrd(ctx, p) {
                     outcome: "rejected",
                     code: "INTERNAL_ERROR",
                     message: imported.stderr?.trim() ||
-                        `import-prd failed for "${name}" with exit ${imported.exitCode}. 任务已创建但不完整，请用 CLI 补 import-prd 或换 taskId 重试。`,
+                        `task advance --prd failed for "${name}" with exit ${imported.exitCode}. 任务已创建但不完整，请用 CLI 补 PRD 或换 taskId 重试。`,
                     details: {
                         exitCode: imported.exitCode,
                         taskId,
@@ -1591,11 +1723,11 @@ async function dispatchBootstrapFromPrd(ctx, p) {
     };
     if (documents && documents.length > 0) {
         for (const doc of documents) {
-            const failure = await runImportPrd(doc.name, doc.content, doc.name);
+            const failure = await runImportViaAdvance(doc.name, doc.content, doc.name);
             if (failure)
                 return failure;
         }
-        const composedFailure = await runImportPrd("composed", content, "composed");
+        const composedFailure = await runImportViaAdvance("composed", content, "composed");
         if (composedFailure)
             return composedFailure;
     }
@@ -1603,9 +1735,9 @@ async function dispatchBootstrapFromPrd(ctx, p) {
         const staged = await stageUtf8Text(ctx.appData, content, {
             extension: ".md",
         });
-        const imported = await run(["import-prd", taskId, "--file", staged.path, "--json"], {
+        const imported = await run(["task", "advance", taskId, "--prd", staged.path, "--json"], {
             cwd: ctx.repoRoot,
-            artifactName: "bootstrap-import-prd",
+            artifactName: "bootstrap-task-advance-prd",
             expectJson: true,
             timeoutMs: 60_000,
         });
@@ -1618,7 +1750,7 @@ async function dispatchBootstrapFromPrd(ctx, p) {
                     outcome: "rejected",
                     code: "INTERNAL_ERROR",
                     message: imported.stderr?.trim() ||
-                        `import-prd failed with exit ${imported.exitCode}`,
+                        `task advance --prd failed with exit ${imported.exitCode}`,
                     details: { exitCode: imported.exitCode, taskId },
                 }),
             };
@@ -2037,24 +2169,85 @@ async function dispatchContractValidateOrDiff(ctx, action, p) {
     const draftText = str(p.draftJson) ?? str(p.inputText);
     if (!taskId)
         return invalid(action, "taskId is required");
-    let inputPath;
-    if (!draftText) {
-        const stored = await ctx.drafts.get(taskId);
-        if (!stored) {
-            return invalid(action, "draftJson or stored draft required");
+    let draft;
+    try {
+        if (!draftText) {
+            const stored = await ctx.drafts.get(taskId);
+            if (!stored) {
+                return invalid(action, "draftJson or stored draft required");
+            }
+            draft = toCanonicalDraftForCli(stored.draft);
+        }
+        else {
+            draft = JSON.parse(draftText);
         }
-        const staged = await stageUtf8Text(ctx.appData, JSON.stringify(toCanonicalDraftForCli(stored.draft), null, 2), { extension: ".json" });
-        inputPath = staged.path;
     }
-    else {
-        const staged = await stageUtf8Text(ctx.appData, draftText, {
-            extension: ".json",
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            kind: "error",
+            status: 400,
+            body: operatorFailed({
+                command: action,
+                outcome: "invalid",
+                code: "INVALID_INPUT",
+                message: `invalid draft JSON: ${message}`,
+            }),
+        };
+    }
+    try {
+        if (action === "contractValidate") {
+            const validation = await validateDraftForTask({
+                repoRoot: ctx.repoRoot,
+                taskId,
+                draft: draft,
+            });
+            if (!validation.ok) {
+                return {
+                    kind: "sync",
+                    status: 400,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "invalid",
+                        code: "INVALID_INPUT",
+                        message: validation.errors.join("; "),
+                        details: { errors: validation.errors },
+                    }),
+                };
+            }
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded(action, {
+                    taskId,
+                    warnings: validation.warnings,
+                }),
+            };
+        }
+        const diff = await diffTaskContract({
+            repoRoot: ctx.repoRoot,
+            taskId,
+            draft: draft,
         });
-        inputPath = staged.path;
+        return {
+            kind: "sync",
+            status: 200,
+            body: operatorSucceeded(action, { taskId, diff }),
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            kind: "error",
+            status: 400,
+            body: operatorFailed({
+                command: action,
+                outcome: "blocked",
+                code: "INTERNAL_ERROR",
+                message,
+            }),
+        };
     }
-    const sub = action === "contractValidate" ? "validate" : "diff";
-    const body = await runReadCli(ctx, ["task", "contract", sub, "--task", taskId, "--input", inputPath, "--json"], `task contract ${sub}`);
-    return { kind: "sync", status: body.ok ? 200 : 400, body };
 }
 export function isMutationAction(action) {
     return MUTATION_OR_LONG.has(action);