@tea-agent/loop-agent 0.34.0 → 0.34.1

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

@@ -16,6 +16,7 @@ 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";
@@ -23,8 +24,9 @@ import { assessAutonomousExecutionEligibility, deriveEligibilityFactsFromDagSpec
 import { issueHumanGateToken, mutationGatePayloadHash, verifyHumanGateToken, } from "./human-gate-token.js";
 const MUTATION_GATE_ACTIONS = new Set([
     // 2026-08-11: standaloneTaskRerun / workerTaskRetry are autonomous (server
-    // run-facts checks); only Night Scheduler mutations still need the browser
-    // Human Gate.
+    // run-facts checks). Destructive DAG reconciliation and Night Scheduler
+    // mutations still need the browser Human Gate.
+    "dagReconcileRun",
     "workerAdmissionPrepare",
     "workerSchedulerAdd",
     "workerSchedulerCancel",
@@ -40,6 +42,7 @@ const MUTATION_OR_LONG = new Set([
     "dagRunTask",
     "runDag",
     "dagRerun",
+    "dagReconcileRun",
     "standaloneTaskRerun",
     "workerTaskRetry",
 ]);
@@ -1354,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,
+                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,
-                // PRD archive via task advance; create if missing.
-                cliArgs: ["task", "advance", taskId, "--prd", staged.path, "--json"],
+                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);
@@ -1751,6 +1837,49 @@ export async function dispatchOperatorAction(ctx, req) {
                 ],
             });
         }
+        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");
+            }
+            const gated = await consumeMutationGateReceipt(ctx, action, p);
+            if (gated.kind === "error")
+                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);
@@ -2001,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 (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) {
@@ -2367,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 {
@@ -2495,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 ?? [],
+            },
         }),
     };
 }
@@ -2697,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);
@@ -2707,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",
         });
@@ -2728,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,