@tea-agent/loop-agent 0.33.7-beta.0 → 0.34.1

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

@@ -1,7 +1,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 { getTaskPaths, loadTaskConfig } 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";
@@ -16,13 +16,17 @@ import { applyGrillMeAnswer, draftSummary, emptyDraft, isDraftStructurallyComple
 import { toCanonicalDraftForCli, } from "./draft-store.js";
 import { normalizeConsoleWorkflowKind } from "./workflow-kinds.js";
 import { deriveTaskIdentityFromPrd, nextTaskIdRevision, } from "./prd-identity.js";
+import { appendEngineeringCliArgs, buildDraftFromTaskIntake, parseEngineeringBoundaryFromParams, } from "./prd-intake-bridge.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 { assessAutonomousExecutionEligibility, deriveEligibilityFactsFromDagSpec, } from "./dag-execution-receipt.js";
 import { issueHumanGateToken, mutationGatePayloadHash, verifyHumanGateToken, } from "./human-gate-token.js";
 const MUTATION_GATE_ACTIONS = new Set([
-    "standaloneTaskRerun",
-    "workerTaskRetry",
+    // 2026-08-11: standaloneTaskRerun / workerTaskRetry are autonomous (server
+    // run-facts checks). Destructive DAG reconciliation and Night Scheduler
+    // mutations still need the browser Human Gate.
+    "dagReconcileRun",
     "workerAdmissionPrepare",
     "workerSchedulerAdd",
     "workerSchedulerCancel",
@@ -38,6 +42,7 @@ const MUTATION_OR_LONG = new Set([
     "dagRunTask",
     "runDag",
     "dagRerun",
+    "dagReconcileRun",
     "standaloneTaskRerun",
     "workerTaskRetry",
 ]);
@@ -72,6 +77,150 @@ function readWriteSetGateToken(reviewPacket) {
     const token = reviewPacket.writeSetGateToken;
     return typeof token === "string" && token.includes(":") ? token : undefined;
 }
+/** Extract the review packet from a task advance --dag-output operator JSON. */
+function extractReviewPacketFromCliJson(json) {
+    if (!json || typeof json !== "object")
+        return undefined;
+    const envelope = json;
+    const payload = envelope.result && typeof envelope.result === "object"
+        ? envelope.result
+        : envelope;
+    const packet = payload.reviewPacket;
+    return packet && typeof packet === "object"
+        ? packet
+        : undefined;
+}
+/**
+ * Read the live managed Task Contract binding for a task (server-derived).
+ * Returns undefined when the task is not managed or status facts are missing
+ * so callers can fail closed.
+ */
+async function readLiveTaskContractBinding(ctx, taskId) {
+    const showBody = await runReadCli(ctx, ["task", "status", taskId, "--json"], "task status");
+    const statusResult = (showBody.result ?? {});
+    const c = showBody.ok ? statusResult.contract : undefined;
+    if (!c?.canonicalHash || typeof c.revision !== "number")
+        return undefined;
+    return {
+        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,
+    };
+}
+function gateError(action, code, message, details) {
+    const status = code === "NOT_FOUND" ? 404 : code === "INVALID_INPUT" ? 400 : 403;
+    return {
+        kind: "error",
+        status,
+        body: operatorFailed({
+            command: action,
+            outcome: "blocked",
+            code,
+            message,
+            details,
+        }),
+    };
+}
+/**
+ * 2026-08-11 R2 run-facts check for standaloneTaskRerun (read-only CLI
+ * evidence only — no browser Human Gate). Fails closed when facts are missing.
+ */
+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);
+    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 });
+    }
+    if (recovery.humanRequired === true) {
+        return gateError("standaloneTaskRerun", "HUMAN_CONFIRMATION_REQUIRED", `primaryRecovery requires a human decision (action=${recovery.action ?? "?"}); stop autonomous rerun`, { runId });
+    }
+    const nodeId = reportResult.primaryFailure.scope === "node"
+        ? reportResult.primaryFailure.nodeId
+        : undefined;
+    let planEligible;
+    if (nodeId) {
+        const plan = await runReadCli(ctx, [
+            "dag",
+            "rerun",
+            "--run-id",
+            runId,
+            "--from-node",
+            nodeId,
+            "--plan",
+            "--json",
+        ], "dag rerun plan");
+        const planResult = (plan.result ?? {});
+        if (plan.ok && planResult.eligible === true) {
+            return gateError("standaloneTaskRerun", "INVALID_INPUT", `node rerun plan is eligible (planHash=${planResult.planHash ?? "?"}); use dagRerun with the fresh planHash instead of standaloneTaskRerun`, { runId, nodeId });
+        }
+        if (!plan.ok && planResult.eligible === undefined) {
+            return gateError("standaloneTaskRerun", "INVALID_INPUT", "dagRerunPlan run facts unavailable; standaloneTaskRerun fails closed", { runId, nodeId });
+        }
+        planEligible = planResult.eligible;
+    }
+    if (planEligible !== false) {
+        // No ineligible-plan evidence: require an explicit rerun-task recommendation.
+        const recommendsRerunTask = recovery.action === "rerun-after-fix" ||
+            /rerun-task|standalone/i.test(recovery.commandHint ?? "");
+        if (!recommendsRerunTask) {
+            return gateError("standaloneTaskRerun", "HUMAN_CONFIRMATION_REQUIRED", `run facts do not support autonomous standaloneTaskRerun (recovery action=${recovery.action ?? "?"}); stop`, { runId });
+        }
+    }
+    if (taskId) {
+        // Keep the original taskId: the run must still be bound to it.
+        const status = await runReadCli(ctx, ["task", "status", taskId, "--json"], "task status");
+        const statusResult = (status.ok ? status.result : undefined);
+        const boundRunId = statusResult?.activeRun?.runId ?? statusResult?.latestRun?.runId;
+        if (!status.ok || !boundRunId || boundRunId !== runId) {
+            return gateError("standaloneTaskRerun", "INVALID_INPUT", `taskId ${taskId} is not bound to run ${runId}; keep the original taskId for same-task rerun`, { runId, taskId, boundRunId });
+        }
+    }
+    return { kind: "ready" };
+}
+/**
+ * 2026-08-11 read-only facts check for workerTaskRetry: the task must exist
+ * in the pool doctor inventory with status Failed (featureId consistent).
+ */
+async function assertWorkerTaskRetryFacts(ctx, taskId, featureId) {
+    const run = ctx.runCommand ??
+        ((args, options) => ctx.client.runExternal
+            ? ctx.client.runExternal(resolveSiblingAgentWorkerBin(), args, options)
+            : ctx.client.run(args, options));
+    let result;
+    try {
+        result = await run(["pool", "doctor", "--repo", ctx.repoRoot, "--json"], {
+            cwd: ctx.repoRoot,
+            artifactName: "worker-task-retry-facts",
+            expectJson: true,
+        });
+    }
+    catch (error) {
+        return gateError("workerTaskRetry", "INVALID_INPUT", `cannot read pool doctor facts: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!result.ok || result.exitCode !== 0 || !result.json) {
+        return gateError("workerTaskRetry", "INVALID_INPUT", "cannot read pool doctor run facts; workerTaskRetry fails closed");
+    }
+    const doctor = result.json;
+    const v2Entry = (doctor.v2 ?? []).find((entry) => entry.taskId === taskId);
+    const legacyEntry = (doctor.legacy ?? []).find((entry) => entry.taskId === taskId && Boolean(entry.featureId));
+    const entry = v2Entry ?? legacyEntry;
+    if (!entry) {
+        return gateError("workerTaskRetry", "INVALID_INPUT", `task ${taskId} not found in the pool doctor inventory`, { taskId });
+    }
+    if (entry.status !== "Failed") {
+        return gateError("workerTaskRetry", "HUMAN_CONFIRMATION_REQUIRED", `task ${taskId} is ${entry.status}; only Failed tasks are retry-eligible`, { taskId, status: entry.status });
+    }
+    if (featureId && entry.featureId && entry.featureId !== featureId) {
+        return gateError("workerTaskRetry", "INVALID_INPUT", `featureId ${featureId} does not match the pool task ${taskId} (${entry.featureId})`, { taskId, featureId, observedFeatureId: entry.featureId });
+    }
+    return { kind: "ready" };
+}
 /**
  * Prefer structured stdout JSON failure semantics (findings / message) over bare
  * `exit N` when stderr is empty — spine audit and similar read CLIs write details
@@ -889,6 +1038,239 @@ export async function dispatchOperatorAction(ctx, req) {
                 }),
             };
         }
+        case "prepareDagExecution": {
+            const taskId = str(p.taskId);
+            if (!taskId)
+                return invalid(action, "taskId is required");
+            const profile = str(p.profile) ?? "auto";
+            const run = ctx.runCommand ?? ((a, o) => ctx.client.run(a, o));
+            // Server-side generate + strict validate only. The model never supplies
+            // DAG bytes or raw paths (AC-02): everything is re-derived here.
+            const staged = await stageUtf8Text(ctx.appData, "", {
+                extension: ".json",
+            });
+            const gen = await run([
+                "task",
+                "advance",
+                taskId,
+                "--profile",
+                profile,
+                "--dag-output",
+                staged.path,
+                "--json",
+            ], {
+                cwd: ctx.repoRoot,
+                artifactName: "prepare-dag-execution-task-advance",
+                expectJson: true,
+                timeoutMs: 180_000,
+            });
+            if (!gen.ok || gen.exitCode !== 0) {
+                return {
+                    kind: "error",
+                    status: 400,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "invalid",
+                        code: "INVALID_INPUT",
+                        message: gen.stderr?.trim() ||
+                            `task advance (prepare DAG execution) failed with exit ${gen.exitCode}`,
+                        details: {
+                            exitCode: gen.exitCode,
+                            stdoutPreview: (gen.stdout ?? "").slice(0, 1200),
+                        },
+                    }),
+                };
+            }
+            let dagText;
+            try {
+                dagText = await readFile(staged.path, "utf8");
+            }
+            catch {
+                dagText = "";
+            }
+            if (!dagText.trim()) {
+                // Fallback: advance may skip generate-dag when a draft already
+                // exists; still prefer the task DAG over an empty staged file.
+                const taskDagPath = getTaskPaths(ctx.repoRoot, taskId).dagDraftPath;
+                try {
+                    dagText = await readFile(taskDagPath, "utf8");
+                }
+                catch {
+                    dagText = "";
+                }
+            }
+            if (!dagText.trim()) {
+                return {
+                    kind: "error",
+                    status: 400,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "invalid",
+                        code: "INVALID_INPUT",
+                        message: "task advance produced empty DAG output",
+                    }),
+                };
+            }
+            const writeSetGateToken = extractWriteSetGateTokenFromCliJson(gen.json, taskId);
+            const finalStaged = await stageUtf8Text(ctx.appData, dagText, {
+                extension: ".json",
+            });
+            const controller = ctx.client.getIdentity?.()?.packageFingerprint?.value ??
+                "unknown-controller";
+            const draftRec = await ctx.drafts.get(taskId);
+            const sourceBindingSha256 = draftRec
+                ? draftRec.draftSha256
+                : hashDagBytes(`source:${taskId}:${finalStaged.sha256}`);
+            const validateBody = await runReadCli(ctx, ["dag", "validate", "--dag", finalStaged.path, "--json"], "dag validate");
+            if (!validateBody.ok) {
+                return {
+                    kind: "error",
+                    status: 400,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "invalid",
+                        code: "INVALID_INPUT",
+                        message: validateBody.error?.message ??
+                            "dag validate failed; cannot prepare execution for an invalid DAG",
+                        details: {
+                            validateError: validateBody.error ?? null,
+                            dagSha256: finalStaged.sha256,
+                        },
+                    }),
+                };
+            }
+            const validationResultSha256 = hashDagBytes(JSON.stringify({
+                ok: true,
+                command: "dag validate",
+                result: validateBody.result ?? null,
+            }));
+            const taskContractBinding = await readLiveTaskContractBinding(ctx, taskId);
+            if (!taskContractBinding) {
+                return {
+                    kind: "error",
+                    status: 409,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "blocked",
+                        code: "BINDING_DRIFT",
+                        message: "managed Task Contract binding unavailable; apply/adopt before prepareDagExecution",
+                        details: { taskId },
+                    }),
+                };
+            }
+            // G2 deterministic assessment from server-side facts only.
+            let allowedPaths;
+            let forbiddenPaths;
+            try {
+                const taskConfig = await loadTaskConfig(ctx.repoRoot, taskId);
+                allowedPaths = Array.isArray(taskConfig.allowedPaths)
+                    ? taskConfig.allowedPaths
+                    : [];
+                forbiddenPaths = Array.isArray(taskConfig.forbiddenPaths)
+                    ? taskConfig.forbiddenPaths
+                    : [];
+            }
+            catch {
+                return {
+                    kind: "error",
+                    status: 403,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "blocked",
+                        code: "HUMAN_CONFIRMATION_REQUIRED",
+                        message: "task boundary (task.json allowedPaths/forbiddenPaths) unavailable; autonomous execution not permitted",
+                    }),
+                };
+            }
+            const reviewPacket = extractReviewPacketFromCliJson(gen.json) ?? {};
+            const derivedFacts = deriveEligibilityFactsFromDagSpec({
+                dagSpec: JSON.parse(dagText),
+                allowedPaths,
+                forbiddenPaths,
+            });
+            const packetWriters = Array.isArray(reviewPacket.writers)
+                ? reviewPacket.writers.map((writer) => ({
+                    nodeId: writer.nodeId ?? "unknown",
+                    writeSet: Array.isArray(writer.writeSet)
+                        ? writer.writeSet.filter((v) => typeof v === "string")
+                        : [],
+                }))
+                : derivedFacts.writersWriteSets;
+            const packetShellVerification = Array.isArray(reviewPacket.shellVerification)
+                ? reviewPacket.shellVerification.length > 0
+                : derivedFacts.hasStructuredVerification;
+            const eligibility = {
+                writersWriteSets: packetWriters,
+                allowedPaths,
+                forbiddenPaths,
+                broadWriteSetRisk: typeof reviewPacket.broadWriteSetRisk === "boolean"
+                    ? reviewPacket.broadWriteSetRisk
+                    : derivedFacts.broadWriteSetRisk,
+                forbiddenOverlapRisk: typeof reviewPacket.forbiddenOverlapRisk === "boolean"
+                    ? reviewPacket.forbiddenOverlapRisk
+                    : derivedFacts.forbiddenOverlapRisk,
+                hasStructuredVerification: packetShellVerification,
+            };
+            const assessment = assessAutonomousExecutionEligibility(eligibility);
+            if (!assessment.ok) {
+                return {
+                    kind: "error",
+                    status: 403,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "blocked",
+                        code: "HUMAN_CONFIRMATION_REQUIRED",
+                        message: assessment.reason,
+                        details: {
+                            taskId,
+                            dagSha256: finalStaged.sha256,
+                            eligibility: "denied",
+                        },
+                    }),
+                };
+            }
+            const prepared = await ctx.dagExecutionReceipts.prepare({
+                operatorSessionId: ctx.operatorSessionId,
+                taskId,
+                dagHandle: "staged-dag.json",
+                dagBytes: dagText,
+                dagBytesPath: finalStaged.path,
+                sourceBindingSha256,
+                taskContractBinding,
+                controllerFingerprint: controller,
+                validationResultSha256,
+                eligibility,
+                reviewPacket: {
+                    taskId,
+                    dagHandle: "staged-dag.json",
+                    validationOk: true,
+                    ...(writeSetGateToken ? { writeSetGateToken } : {}),
+                },
+            });
+            if (!prepared.ok) {
+                return {
+                    kind: "error",
+                    status: 403,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "blocked",
+                        code: prepared.code,
+                        message: prepared.reason,
+                    }),
+                };
+            }
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded("prepareDagExecution", {
+                    executionId: prepared.receipt.executionId,
+                    eligibility: "approved",
+                    taskId,
+                    dagSha256: finalStaged.sha256,
+                    expiresAt: prepared.receipt.expiresAt,
+                }),
+            };
+        }
         case "confirmDagConfirmation": {
             const confirmationId = str(p.confirmationId);
             const humanGateToken = p.humanGateToken;
@@ -975,23 +1357,106 @@ export async function dispatchOperatorAction(ctx, req) {
         case "bootstrapFromPrd":
             return dispatchBootstrapFromPrd(ctx, p);
         case "importPrd": {
+            // Chat / operator path: same intake bridge as bootstrapFromPrd, but
+            // for an existing taskId (create-if-missing via advance --prd).
             const taskId = str(p.taskId);
             const content = str(p.content) ?? str(p.fileText);
-            const clientRequestId = str(req.clientRequestId);
-            if (!taskId || !content || !clientRequestId) {
-                return invalid(action, "taskId, content, and clientRequestId are required");
+            if (!taskId || !content) {
+                return invalid(action, "taskId and content are required");
             }
+            const taskKind = normalizeConsoleWorkflowKind(str(p.taskKind), "standard");
+            const engineering = parseEngineeringBoundaryFromParams(p);
+            const identity = deriveTaskIdentityFromPrd(content);
+            const title = str(p.title) ?? identity.title;
+            const run = ctx.runCommand ?? ((a, o) => ctx.client.run(a, o));
             const staged = await stageUtf8Text(ctx.appData, content, {
                 extension: ".md",
             });
-            return acceptOperation(ctx, {
-                action,
-                actionParams: { taskId, stagedSha256: staged.sha256 },
-                clientRequestId,
+            const imported = await run([
+                "task",
+                "advance",
                 taskId,
-                // PRD archive via task advance; create if missing.
-                cliArgs: ["task", "advance", taskId, "--prd", staged.path, "--json"],
+                title,
+                "--prd",
+                staged.path,
+                "--role",
+                "requirement",
+                "--json",
+            ], {
+                cwd: ctx.repoRoot,
+                artifactName: "import-prd-task-advance",
+                expectJson: true,
+                timeoutMs: 60_000,
             });
+            if (!imported.ok || imported.exitCode !== 0 || imported.timedOut) {
+                return {
+                    kind: "error",
+                    status: 400,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "rejected",
+                        code: "INTERNAL_ERROR",
+                        message: imported.stderr?.trim() ||
+                            `task advance --prd failed with exit ${imported.exitCode}`,
+                        details: {
+                            exitCode: imported.exitCode,
+                            timedOut: imported.timedOut,
+                            taskId,
+                        },
+                    }),
+                };
+            }
+            const intakeArgs = ["task", "advance", taskId, "--json"];
+            if (taskKind && taskKind !== "standard") {
+                intakeArgs.push("--task-kind", taskKind);
+            }
+            appendEngineeringCliArgs(intakeArgs, engineering);
+            const intake = await run(intakeArgs, {
+                cwd: ctx.repoRoot,
+                artifactName: "import-prd-task-advance-intake",
+                expectJson: true,
+                timeoutMs: 300_000,
+            });
+            const intakeJson = intake.json ?? null;
+            const intakeOk = intake.ok && intake.exitCode === 0 && !intake.timedOut;
+            const bridged = await buildDraftFromTaskIntake({
+                repoRoot: ctx.repoRoot,
+                taskId,
+                title,
+                taskKind,
+                advanceJson: intakeJson,
+                engineering,
+            });
+            const draftSaved = await ctx.drafts.save(bridged.draft);
+            const parseStatus = intakeOk || bridged.parseStatus !== "pending"
+                ? bridged.parseStatus
+                : "failed";
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded(action, {
+                    taskId,
+                    title: draftSaved.draft.title ?? title,
+                    taskKind,
+                    draftSha256: draftSaved.draftSha256,
+                    parseStatus,
+                    semanticIntake: bridged.semanticIntake,
+                    gaps: bridged.gaps,
+                    lifecycleState: bridged.lifecycleState ?? "intake-incomplete",
+                    intake: {
+                        ok: intakeOk,
+                        exitCode: intake.exitCode,
+                        timedOut: intake.timedOut,
+                    },
+                    import: imported.json ?? null,
+                    draftPreview: {
+                        objective: draftSaved.draft.requirement?.objective ?? null,
+                        scope: draftSaved.draft.requirement?.scope ?? [],
+                        acceptanceCriteria: draftSaved.draft.requirement?.acceptanceCriteria ?? [],
+                        allowedPaths: draftSaved.draft.constraints?.allowedPaths ?? [],
+                    },
+                }),
+            };
         }
         case "contractApply": {
             const taskId = str(p.taskId);
@@ -1110,14 +1575,118 @@ export async function dispatchOperatorAction(ctx, req) {
             });
         }
         case "runDag": {
-            // Only confirmationId — never raw dag path from browser
-            const confirmationId = str(p.confirmationId);
+            // Model path (AC-02): only executionId — never a raw dag path from
+            // the model. The browser Human Gate route (chat human-gate dag-run)
+            // still dispatches with confirmationId for the preserved global
+            // Human Gate flow; that path is not model-reachable (the confirmation
+            // must be in "confirmed" state, which requires a server-signed
+            // human-gate token verified by confirmDagConfirmation).
             const clientRequestId = str(req.clientRequestId);
-            if (!confirmationId || !clientRequestId) {
-                return invalid(action, "runDag requires confirmationId and clientRequestId only");
+            const executionId = str(p.executionId);
+            if (!clientRequestId) {
+                return invalid(action, "runDag requires clientRequestId");
             }
-            const conf = await ctx.confirmations.get(confirmationId);
-            if (!conf) {
+            if (executionId && str(p.confirmationId)) {
+                return invalid(action, "runDag accepts either executionId or confirmationId, not both");
+            }
+            if (!executionId) {
+                const confirmationId = str(p.confirmationId);
+                if (!confirmationId) {
+                    return invalid(action, "runDag requires executionId (autonomous) or confirmationId (browser Human Gate)");
+                }
+                // Preserved browser Human Gate flow (dag-confirmation.ts untouched).
+                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}`,
+                        }),
+                    };
+                }
+                // Re-read staged DAG bytes and hash.
+                let dagBytes;
+                try {
+                    dagBytes = 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 staged DAG bytes: ${error instanceof Error ? error.message : String(error)}`,
+                        }),
+                    };
+                }
+                const dagSha256 = hashDagBytes(dagBytes);
+                const controller = ctx.client.getIdentity?.()?.packageFingerprint?.value ??
+                    conf.controllerFingerprint;
+                const consumed = await ctx.confirmations.consume({
+                    confirmationId,
+                    operatorSessionId: ctx.operatorSessionId,
+                    current: {
+                        dagSha256,
+                        sourceBindingSha256: conf.sourceBindingSha256,
+                        taskContractBinding: conf.taskContractBinding,
+                        controllerFingerprint: controller,
+                        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 taskId = conf.taskContractBinding.taskId;
+                const gateToken = readWriteSetGateToken(conf.reviewPacket);
+                if (gateToken) {
+                    return acceptOperation(ctx, {
+                        action,
+                        actionParams: { confirmationId },
+                        clientRequestId,
+                        taskId,
+                        cliArgs: [
+                            "task",
+                            "advance",
+                            taskId,
+                            "--approve-gate",
+                            gateToken,
+                            "--json",
+                        ],
+                    });
+                }
+                return acceptOperation(ctx, {
+                    action,
+                    actionParams: { confirmationId },
+                    clientRequestId,
+                    taskId,
+                    cliArgs: [
+                        "dag",
+                        "execute",
+                        "--dag",
+                        conf.dagBytesPath,
+                        "--cwd",
+                        ctx.repoRoot,
+                        "--json",
+                    ],
+                });
+            }
+            const receipt = await ctx.dagExecutionReceipts.get(executionId);
+            if (!receipt) {
                 return {
                     kind: "error",
                     status: 404,
@@ -1125,40 +1694,45 @@ export async function dispatchOperatorAction(ctx, req) {
                         command: action,
                         outcome: "not-found",
                         code: "NOT_FOUND",
-                        message: `confirmation not found: ${confirmationId}`,
+                        message: `execution receipt not found: ${executionId}`,
                     }),
                 };
             }
-            // Re-read staged DAG bytes and hash
-            let dagBytes;
+            const taskId = receipt.taskId;
+            // Live server-derived bindings only; any drift fails closed inside
+            // consume (staged bytes/hash + controller + task binding + source).
+            const controller = ctx.client.getIdentity?.()?.packageFingerprint?.value ??
+                receipt.controllerFingerprint;
+            let sourceBindingSha256 = receipt.sourceBindingSha256;
             try {
-                dagBytes = await readFile(conf.dagBytesPath, "utf8");
+                const draftRec = await ctx.drafts.get(taskId);
+                if (draftRec)
+                    sourceBindingSha256 = draftRec.draftSha256;
             }
-            catch (error) {
+            catch {
+                // keep the receipt binding; consume will still compare it
+            }
+            const liveBinding = await readLiveTaskContractBinding(ctx, taskId);
+            if (!liveBinding) {
                 return {
                     kind: "error",
                     status: 409,
                     body: operatorFailed({
                         command: action,
-                        outcome: "conflict",
-                        code: "CONFIRMATION_STALE",
-                        message: `cannot re-read staged DAG bytes: ${error instanceof Error ? error.message : String(error)}`,
+                        outcome: "blocked",
+                        code: "BINDING_DRIFT",
+                        message: "managed Task Contract binding unavailable at consume time",
+                        details: { taskId },
                     }),
                 };
             }
-            const dagSha256 = hashDagBytes(dagBytes);
-            const controller = ctx.client.getIdentity?.()?.packageFingerprint?.value ??
-                conf.controllerFingerprint;
-            const consumed = await ctx.confirmations.consume({
-                confirmationId,
+            const consumed = await ctx.dagExecutionReceipts.consume({
+                executionId,
                 operatorSessionId: ctx.operatorSessionId,
-                current: {
-                    dagSha256,
-                    sourceBindingSha256: conf.sourceBindingSha256,
-                    taskContractBinding: conf.taskContractBinding,
-                    controllerFingerprint: controller,
-                    validationResultSha256: conf.validationResultSha256,
-                },
+                controllerFingerprint: controller,
+                taskContractBinding: liveBinding,
+                sourceBindingSha256,
+                validationResultSha256: receipt.validationResultSha256,
             });
             if (!consumed.ok) {
                 return {
@@ -1172,41 +1746,48 @@ 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.
+            const gateToken = readWriteSetGateToken(receipt.reviewPacket);
+            const dispatchRun = async () => {
+                if (gateToken) {
+                    // Standard lifecycle path: the execution receipt replaces the
+                    // browser confirm; the gate token is still consumed by the CLI.
+                    return acceptOperation(ctx, {
+                        action,
+                        actionParams: { executionId },
+                        clientRequestId,
+                        taskId,
+                        cliArgs: [
+                            "task",
+                            "advance",
+                            taskId,
+                            "--approve-gate",
+                            gateToken,
+                            "--json",
+                        ],
+                    });
+                }
+                // Advanced: execute the server-staged DAG bytes (never a model path).
                 return acceptOperation(ctx, {
                     action,
-                    actionParams: { confirmationId },
+                    actionParams: { executionId },
                     clientRequestId,
                     taskId,
                     cliArgs: [
-                        "task",
-                        "advance",
-                        taskId,
-                        "--approve-gate",
-                        gateToken,
+                        "dag",
+                        "execute",
+                        "--dag",
+                        receipt.dagBytesPath,
+                        "--cwd",
+                        ctx.repoRoot,
                         "--json",
                     ],
                 });
+            };
+            const accepted = await dispatchRun();
+            if (accepted.kind === "accepted") {
+                await ctx.dagExecutionReceipts.markDispatched(executionId, accepted.body.operationId);
             }
-            // Advanced: arbitrary staged DagSpec (client-supplied dagText) until dag execute rename.
-            return acceptOperation(ctx, {
-                action,
-                actionParams: { confirmationId },
-                clientRequestId,
-                taskId,
-                cliArgs: [
-                    "dag",
-                    "execute",
-                    "--dag",
-                    conf.dagBytesPath,
-                    "--cwd",
-                    ctx.repoRoot,
-                    "--json",
-                ],
-            });
+            return accepted;
         }
         case "dagRerunPlan": {
             const runId = str(p.runId);
@@ -1256,10 +1837,18 @@ export async function dispatchOperatorAction(ctx, req) {
                 ],
             });
         }
-        case "standaloneTaskRerun": {
+        case "dagReconcileRun": {
+            // S6 Recovery: orphan/interrupted runs — structured reason is the human
+            // confirmation surface (CLI eligibility still fail-closed).
             const runId = str(p.runId);
             const reason = str(p.reason);
             const clientRequestId = str(req.clientRequestId);
+            const reconcileActionRaw = str(p.reconcileAction) ?? "supersede";
+            if (reconcileActionRaw !== "supersede" &&
+                reconcileActionRaw !== "abandon") {
+                return invalid(action, "reconcileAction must be supersede or abandon");
+            }
+            const reconcileAction = reconcileActionRaw;
             if (!runId || !reason || !clientRequestId) {
                 return invalid(action, "runId, reason, and clientRequestId are required");
             }
@@ -1268,6 +1857,41 @@ export async function dispatchOperatorAction(ctx, req) {
                 return gated;
             if (gated.kind === "idempotent")
                 return gated.result;
+            const accepted = await acceptOperation(ctx, {
+                action,
+                actionParams: {
+                    runId,
+                    reason,
+                    reconcileAction,
+                },
+                clientRequestId,
+                cliArgs: [
+                    "dag",
+                    "reconcile-run",
+                    "--run-id",
+                    runId,
+                    "--action",
+                    reconcileAction,
+                    "--reason",
+                    reason,
+                    "--json",
+                ],
+            });
+            await finalizeMutationGateReceipt(ctx, gated.receiptId, accepted);
+            return accepted;
+        }
+        case "standaloneTaskRerun": {
+            const runId = str(p.runId);
+            const reason = str(p.reason);
+            const clientRequestId = str(req.clientRequestId);
+            if (!runId || !reason || !clientRequestId) {
+                return invalid(action, "runId, reason, and clientRequestId are required");
+            }
+            // 2026-08-11: read-only run-facts check replaces the browser Human
+            // Gate (R2). Fails closed when evidence is missing.
+            const gated = await assertAutonomousRerunEligible(ctx, runId, str(p.taskId));
+            if (gated.kind === "error")
+                return gated;
             const profile = str(p.profile);
             const taskId = str(p.taskId);
             const cliArgs = [
@@ -1285,15 +1909,13 @@ export async function dispatchOperatorAction(ctx, req) {
                 cliArgs.push("--profile", profile);
             if (taskId)
                 cliArgs.push("--task-id", taskId);
-            const accepted = await acceptOperation(ctx, {
+            return acceptOperation(ctx, {
                 action,
                 actionParams: p,
                 clientRequestId,
                 taskId,
                 cliArgs,
             });
-            await finalizeMutationGateReceipt(ctx, gated.receiptId, accepted);
-            return accepted;
         }
         case "workerTaskRetry": {
             const taskId = str(p.taskId);
@@ -1303,11 +1925,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);
+            // 2026-08-11: read-only pool facts check replaces the browser Human
+            // Gate (task must exist in Failed state; featureId consistent).
+            const gated = await assertWorkerTaskRetryFacts(ctx, taskId, featureId);
             if (gated.kind === "error")
                 return gated;
-            if (gated.kind === "idempotent")
-                return gated.result;
             const args = [
                 "task",
                 "retry",
@@ -1319,7 +1941,7 @@ export async function dispatchOperatorAction(ctx, req) {
             ];
             if (featureId)
                 args.push("--feature-id", featureId);
-            const accepted = await acceptOperation(ctx, {
+            return acceptOperation(ctx, {
                 action,
                 actionParams: p,
                 clientRequestId,
@@ -1327,8 +1949,6 @@ export async function dispatchOperatorAction(ctx, req) {
                 cliArgs: args,
                 externalCommand: resolveSiblingAgentWorkerBin(),
             });
-            await finalizeMutationGateReceipt(ctx, gated.receiptId, accepted);
-            return accepted;
         }
         case "workerAdmissionPrepare": {
             const featureDir = str(p.featureDir);
@@ -1510,7 +2130,7 @@ export async function dispatchOperatorAction(ctx, req) {
                 return invalid(action, "action and actionParams are required");
             }
             if (!MUTATION_GATE_ACTIONS.has(targetAction)) {
-                return invalid(action, "action must be a mutation-gate target (standaloneTaskRerun | workerTaskRetry | workerAdmissionPrepare | workerSchedulerAdd | workerSchedulerCancel | workerSchedulerHarvest | workerSchedulerDiscard)");
+                return invalid(action, "action must be a mutation-gate target (dagReconcileRun | workerAdmissionPrepare | workerSchedulerAdd | workerSchedulerCancel | workerSchedulerHarvest | workerSchedulerDiscard)");
             }
             const secret = ctx.humanGateSecret;
             if (!secret) {
@@ -1876,6 +2496,7 @@ async function dispatchBootstrapFromPrd(ctx, p) {
     }
     const documents = parsedDocs.documents;
     const taskKind = normalizeConsoleWorkflowKind(str(p.taskKind), "standard");
+    const engineering = parseEngineeringBoundaryFromParams(p);
     const identity = deriveTaskIdentityFromPrd(content);
     let taskId;
     try {
@@ -2004,27 +2625,66 @@ async function dispatchBootstrapFromPrd(ctx, p) {
         }
         importResults.push(imported.json ?? null);
     }
-    const draftSaved = await ctx.drafts.save({
-        ...emptyDraft(taskId, title, { taskKind }),
-        requirement: {
-            objective: title,
-        },
+    // Phase 2 (design 2026-08-11): drive task advance intake after import so
+    // deterministic parse + one-shot Semantic Intake run on archived references.
+    // Timeout is longer than import: Pi MED may take minutes.
+    const intakeArgs = ["task", "advance", taskId, "--json"];
+    if (taskKind && taskKind !== "standard") {
+        intakeArgs.push("--task-kind", taskKind);
+    }
+    appendEngineeringCliArgs(intakeArgs, engineering);
+    const intake = await run(intakeArgs, {
+        cwd: ctx.repoRoot,
+        artifactName: "bootstrap-task-advance-intake",
+        expectJson: true,
+        timeoutMs: 300_000,
+    });
+    const intakeJson = intake.json ?? null;
+    const intakeOk = intake.ok && intake.exitCode === 0 && !intake.timedOut;
+    const bridged = await buildDraftFromTaskIntake({
+        repoRoot: ctx.repoRoot,
+        taskId,
+        title,
+        taskKind,
+        advanceJson: intakeJson,
+        engineering,
     });
+    // Never fall back to grill-me product templates when intake fails.
+    const draftSaved = await ctx.drafts.save(bridged.draft);
+    const parseStatus = intakeOk || bridged.parseStatus !== "pending"
+        ? bridged.parseStatus
+        : "failed";
     return {
         kind: "sync",
         status: 200,
         body: operatorSucceeded("bootstrapFromPrd", {
             taskId,
-            title,
+            title: draftSaved.draft.title ?? title,
             taskKind,
             identitySource: identity.source,
             preferredTaskId: identity.taskId,
             draftSha256: draftSaved.draftSha256,
+            parseStatus,
+            semanticIntake: bridged.semanticIntake,
+            gaps: bridged.gaps,
+            lifecycleState: bridged.lifecycleState ??
+                (intakeOk ? "intake-incomplete" : "intake-incomplete"),
+            intake: {
+                ok: intakeOk,
+                exitCode: intake.exitCode,
+                timedOut: intake.timedOut,
+                json: intakeJson,
+            },
             import: importResults.length === 1 ? importResults[0] : null,
             imports: importResults,
             documentNames: documents && documents.length > 0
                 ? [...documents.map((d) => d.name), "composed"]
                 : undefined,
+            draftPreview: {
+                objective: draftSaved.draft.requirement?.objective ?? null,
+                scope: draftSaved.draft.requirement?.scope ?? [],
+                acceptanceCriteria: draftSaved.draft.requirement?.acceptanceCriteria ?? [],
+            },
         }),
     };
 }
@@ -2206,8 +2866,9 @@ async function dispatchInterviewStart(ctx, p) {
     };
 }
 /**
- * Skip interactive grilling: accept recommendations for remaining gaps and
- * issue a complete assessment so contractApply can proceed.
+ * Skip interactive grilling only when requirement structure is already present
+ * (from PRD intake) and remaining gaps are engineering/taskKind that can take
+ * non-template recommendations. Never invent console product templates.
  */
 async function dispatchInterviewSkip(ctx, p) {
     const taskId = str(p.taskId);
@@ -2216,11 +2877,50 @@ async function dispatchInterviewSkip(ctx, p) {
     const title = str(p.title) ?? taskId;
     const taskKind = str(p.taskKind);
     let { draft } = await ensureDraft(ctx, taskId, title, { taskKind });
+    const requirementGaps = new Set([
+        "objective",
+        "scope",
+        "nonGoals",
+        "acceptanceCriteria",
+    ]);
+    const currentGaps = draftSummary(draft).gaps;
+    const missingRequirement = currentGaps.filter((g) => requirementGaps.has(g));
+    if (missingRequirement.length > 0) {
+        return {
+            kind: "error",
+            status: 400,
+            body: operatorFailed({
+                command: "interviewSkip",
+                outcome: "invalid",
+                code: "REQUIREMENT_INCOMPLETE",
+                message: "无法跳过：需求层尚未结构化（缺 objective/scope/AC 等）。请先导入 PRD 完成 intake，或手动访谈补齐，禁止用模板冒充解析结果。",
+                details: {
+                    gaps: currentGaps,
+                    missingRequirement,
+                },
+            }),
+        };
+    }
     const accepted = [];
+    // Only auto-accept engineering / taskKind recommendations; never product templates.
+    const autoAcceptGaps = new Set([
+        "taskKind",
+        "allowedPaths",
+        "forbiddenPaths",
+        "verifyCommands",
+    ]);
     for (let i = 0; i < 24; i += 1) {
         const question = nextGrillMeQuestion(draft);
         if (!question)
             break;
+        if (!autoAcceptGaps.has(question.gapId))
+            break;
+        // Refuse placeholder recommendations that are not real path/command values.
+        if (question.gapId === "allowedPaths" &&
+            (/请|示例|模板|（/.test(question.recommendation) ||
+                !question.recommendation.includes("*"))) {
+            break;
+        }
         draft = applyGrillMeAnswer(draft, question, {
             response: "accept-recommendation",
         });
@@ -2237,8 +2937,8 @@ async function dispatchInterviewSkip(ctx, p) {
             body: operatorFailed({
                 command: "interviewSkip",
                 outcome: "invalid",
-                code: "INVALID_INPUT",
-                message: "无法跳过：采用推荐后草稿仍不完整，请先补齐需求或手动访谈",
+                code: "ENGINEERING_BOUNDARY_REQUIRED",
+                message: "无法跳过：工程边界（allowedPaths / forbiddenPaths / verify）尚未确认，请在访谈中填写或通过 CLI flags 提供",
                 details: {
                     gaps: draftSummary(saved.draft).gaps,
                     acceptedRecommendations: accepted,