@tea-agent/loop-agent 0.17.1 → 0.18.0

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

@@ -1,14 +1,20 @@
-import { readFile } from "node:fs/promises";
+import { access, readFile } from "node:fs/promises";
 import { buildOperatorCapabilitiesDocument } from "../../shared/operator/capabilities.js";
 import { operatorFailed, operatorSucceeded, } from "../../shared/operator/envelope.js";
+import { getTaskPaths } from "../../task/runtime.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";
 import { buildObserveDeepLink, } from "./observe-link.js";
+import { resolveLatestDagRunIdForTask } from "./resolve-dag-run-for-task.js";
 import { repoFingerprintV1 } from "./repo-fingerprint.js";
 import { scheduleOperation, } from "./operation-runner.js";
 import { readinessGateFailure, } from "./pi-readiness.js";
 import { isAssessmentFreshForDraft } from "./interview/assessment.js";
+import { applyGrillMeAnswer, draftSummary, emptyDraft, isDraftStructurallyComplete, nextGrillMeQuestion, } from "./interview/grill-me.js";
+import { toCanonicalDraftForCli, } from "./draft-store.js";
+import { normalizeConsoleWorkflowKind } from "./workflow-kinds.js";
+import { deriveTaskIdentityFromPrd, nextTaskIdRevision, } from "./prd-identity.js";
 const MUTATION_OR_LONG = new Set([
     "newTask",
     "importPrd",
@@ -122,7 +128,7 @@ export async function dispatchOperatorAction(ctx, req) {
                 command: "operator",
                 outcome: "invalid",
                 code: "INVALID_INPUT",
-                message: "action is required",
+                message: "缺少 action",
             }),
         };
     }
@@ -225,6 +231,59 @@ export async function dispatchOperatorAction(ctx, req) {
                 }),
             };
         }
+        case "interviewStart": {
+            return dispatchInterviewStart(ctx, p);
+        }
+        case "interviewTurn": {
+            return dispatchInterviewTurn(ctx, p);
+        }
+        case "interviewSkip": {
+            return dispatchInterviewSkip(ctx, p);
+        }
+        case "interviewGet": {
+            const sessionId = str(p.sessionId);
+            if (!sessionId)
+                return invalid(action, "sessionId is required");
+            const session = await ctx.interviews.get(sessionId);
+            if (!session) {
+                return {
+                    kind: "error",
+                    status: 404,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "not-found",
+                        code: "NOT_FOUND",
+                        message: `interview session not found: ${sessionId}`,
+                    }),
+                };
+            }
+            const draftRec = await ctx.drafts.get(session.taskId);
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded("interviewGet", {
+                    session,
+                    draft: draftRec?.draft ?? null,
+                    draftSha256: draftRec?.draftSha256 ?? null,
+                    summary: draftRec ? draftSummary(draftRec.draft) : null,
+                }),
+            };
+        }
+        case "refreshReadiness": {
+            if (ctx.refreshReadiness) {
+                const report = await ctx.refreshReadiness();
+                return {
+                    kind: "sync",
+                    status: 200,
+                    body: operatorSucceeded("refreshReadiness", report),
+                };
+            }
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded("refreshReadiness", ctx.getReadiness?.() ?? ctx.readiness),
+            };
+        }
         case "observeLink": {
             const baseUrl = ctx.observeBaseUrl ?? DEFAULT_OBSERVE_BASE_URL;
             const dagRunId = str(p.dagRunId);
@@ -232,11 +291,22 @@ export async function dispatchOperatorAction(ctx, req) {
             const featureId = str(p.featureId);
             const workerRunId = str(p.workerRunId);
             let target;
+            let resolvedFromTask;
+            let fallbackToTask = false;
+            let openHome = false;
             if (dagRunId) {
                 target = { kind: "dag", dagRunId };
             }
             else if (taskId) {
-                target = { kind: "task", taskId };
+                // Prefer `#/dag/<runId>` when a run exists; otherwise open `#/task/<taskId>`.
+                resolvedFromTask = await resolveLatestDagRunIdForTask(ctx.repoRoot, taskId);
+                if (resolvedFromTask) {
+                    target = { kind: "dag", dagRunId: resolvedFromTask.dagRunId };
+                }
+                else {
+                    target = { kind: "task", taskId };
+                    fallbackToTask = true;
+                }
             }
             else if (featureId) {
                 target = { kind: "feature", featureId };
@@ -245,9 +315,11 @@ export async function dispatchOperatorAction(ctx, req) {
                 target = { kind: "worker", workerRunId };
             }
             else {
-                return invalid(action, "dagRunId, taskId, featureId, or workerRunId required");
+                openHome = true;
             }
-            const requiredCapability = capabilityForObserveTarget(target);
+            const requiredCapability = target
+                ? capabilityForObserveTarget(target)
+                : undefined;
             let localFingerprint;
             try {
                 localFingerprint = repoFingerprintV1(ctx.repoRoot);
@@ -294,14 +366,31 @@ export async function dispatchOperatorAction(ctx, req) {
                     }),
                 };
             }
-            const link = buildObserveDeepLink(baseUrl, target);
+            const link = openHome
+                ? `${baseUrl.replace(/\/+$/, "")}/`
+                : buildObserveDeepLink(baseUrl, target);
             return {
                 kind: "sync",
                 status: 200,
                 body: operatorSucceeded("observeLink", {
                     url: link,
                     status: "match",
-                    requiredCapability,
+                    requiredCapability: requiredCapability ?? null,
+                    dagRunId: target?.kind === "dag"
+                        ? target.dagRunId
+                        : resolvedFromTask?.dagRunId,
+                    taskId: taskId ?? undefined,
+                    home: openHome || undefined,
+                    fallbackToTask: fallbackToTask || undefined,
+                    note: fallbackToTask
+                        ? `任务 ${taskId} 尚无 DAG run，已打开任务页；运行 DAG 后可直达 run 详情`
+                        : undefined,
+                    resolvedFromTask: resolvedFromTask
+                        ? {
+                            dagRunId: resolvedFromTask.dagRunId,
+                            lifecycle: resolvedFromTask.lifecycle,
+                        }
+                        : undefined,
                 }),
             };
         }
@@ -317,16 +406,70 @@ export async function dispatchOperatorAction(ctx, req) {
             return { kind: "sync", status: body.ok ? 200 : 400, body };
         }
         case "prepareDagConfirmation": {
-            const dagText = str(p.dagText) ?? str(p.dagJson);
             const dagHandle = str(p.dagHandle) ?? "staged-dag.json";
             const taskId = str(p.taskId);
-            if (!dagText)
-                return invalid(action, "dagText is required");
             if (!taskId)
                 return invalid(action, "taskId is required");
-            const staged = await stageUtf8Text(ctx.appData, dagText, {
-                extension: ".json",
-            });
+            let dagText = str(p.dagText) ?? str(p.dagJson);
+            let staged;
+            if (!dagText) {
+                // Happy Path: generate a real DAG via CLI; never confirm an 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",
+                    taskId,
+                    "--profile",
+                    profile,
+                    "-o",
+                    staged.path,
+                ], {
+                    cwd: ctx.repoRoot,
+                    artifactName: "prepare-dag-run-task",
+                    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() ||
+                                `dag run-task failed with exit ${gen.exitCode}`,
+                            details: {
+                                exitCode: gen.exitCode,
+                                stdoutPreview: (gen.stdout ?? "").slice(0, 1200),
+                            },
+                        }),
+                    };
+                }
+                dagText = await readFile(staged.path, "utf8");
+                if (!dagText.trim()) {
+                    return {
+                        kind: "error",
+                        status: 400,
+                        body: operatorFailed({
+                            command: action,
+                            outcome: "invalid",
+                            code: "INVALID_INPUT",
+                            message: "dag run-task produced empty DAG output",
+                        }),
+                    };
+                }
+                staged = await stageUtf8Text(ctx.appData, dagText, {
+                    extension: ".json",
+                });
+            }
+            else {
+                staged = await stageUtf8Text(ctx.appData, dagText, {
+                    extension: ".json",
+                });
+            }
             const controller = ctx.client.getIdentity?.()?.packageFingerprint?.value ??
                 "unknown-controller";
             // Server-derived bindings only: never trust browser-supplied hashes as success defaults.
@@ -343,9 +486,11 @@ export async function dispatchOperatorAction(ctx, req) {
                         command: action,
                         outcome: "invalid",
                         code: "INVALID_INPUT",
-                        message: "dag validate failed; cannot prepare confirmation for an invalid DAG",
+                        message: validateBody.error?.message ??
+                            "dag validate failed; cannot prepare confirmation for an invalid DAG",
                         details: {
                             validateError: validateBody.error ?? null,
+                            validateResult: validateBody.result ?? null,
                             dagSha256: staged.sha256,
                         },
                     }),
@@ -408,6 +553,7 @@ export async function dispatchOperatorAction(ctx, req) {
                 body: operatorSucceeded("prepareDagConfirmation", {
                     confirmation,
                     requiredChallenges: ALL_CONFIRMATION_CHALLENGES,
+                    dagSha256: staged.sha256,
                 }),
             };
         }
@@ -494,6 +640,9 @@ export async function dispatchOperatorAction(ctx, req) {
                 cliArgs: ["new-task", taskId, title, "--json"],
             });
         }
+        case "bootstrapFromPrd": {
+            return dispatchBootstrapFromPrd(ctx, p);
+        }
         case "importPrd": {
             const taskId = str(p.taskId);
             const content = str(p.content) ?? str(p.fileText);
@@ -528,7 +677,7 @@ export async function dispatchOperatorAction(ctx, req) {
                         command: action,
                         outcome: "invalid",
                         code: "INVALID_INPUT",
-                        message: "no Console draft for task; save draft first",
+                        message: "该任务尚无 Console 草稿，请先保存草稿",
                     }),
                 };
             }
@@ -555,7 +704,7 @@ export async function dispatchOperatorAction(ctx, req) {
                         command: action,
                         outcome: "blocked",
                         code: "HUMAN_CONFIRMATION_REQUIRED",
-                        message: "assessment not found",
+                        message: "未找到评估结果",
                     }),
                 };
             }
@@ -572,9 +721,15 @@ export async function dispatchOperatorAction(ctx, req) {
                     }),
                 };
             }
-            const staged = await stageUtf8Text(ctx.appData, JSON.stringify(draftRec.draft, null, 2), { extension: ".json" });
-            const expectedRevision = String(p.expectedRevision ?? "0");
-            const expectedHash = str(p.expectedObservedHash) ?? "unknown";
+            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.
             const payloadSha = staged.sha256;
             return acceptOperation(ctx, {
@@ -584,6 +739,9 @@ export async function dispatchOperatorAction(ctx, req) {
                     assessmentId,
                     draftSha256: draftRec.draftSha256,
                     requestPayloadSha256: payloadSha,
+                    expectedRevision: Number(expectedRevision),
+                    expectedObservedHash: expectedHash,
+                    effectiveStatus: showState?.effectiveStatus,
                 },
                 clientRequestId,
                 taskId,
@@ -721,6 +879,437 @@ export async function dispatchOperatorAction(ctx, req) {
             };
     }
 }
+async function taskExistsOnDisk(repoRoot, taskId) {
+    try {
+        await access(getTaskPaths(repoRoot, taskId).taskConfigPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function allocateUniqueTaskId(repoRoot, preferredId) {
+    for (let revision = 1; revision <= 50; revision += 1) {
+        const candidate = nextTaskIdRevision(preferredId, revision);
+        if (!(await taskExistsOnDisk(repoRoot, candidate)))
+            return candidate;
+    }
+    throw new Error(`unable to allocate unique taskId near ${preferredId}`);
+}
+async function dispatchBootstrapFromPrd(ctx, p) {
+    const content = str(p.content) ?? str(p.fileText);
+    if (!content) {
+        return invalid("bootstrapFromPrd", "content is required");
+    }
+    const taskKind = normalizeConsoleWorkflowKind(str(p.taskKind), "standard");
+    const identity = deriveTaskIdentityFromPrd(content);
+    let taskId;
+    try {
+        taskId = await allocateUniqueTaskId(ctx.repoRoot, identity.taskId);
+    }
+    catch (error) {
+        return {
+            kind: "error",
+            status: 409,
+            body: operatorFailed({
+                command: "bootstrapFromPrd",
+                outcome: "conflict",
+                code: "REQUEST_ID_REUSE_CONFLICT",
+                message: error instanceof Error ? error.message : String(error),
+            }),
+        };
+    }
+    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], {
+        cwd: ctx.repoRoot,
+        artifactName: "bootstrap-new-task",
+        timeoutMs: 60_000,
+    });
+    if (created.exitCode !== 0 || created.timedOut) {
+        return {
+            kind: "error",
+            status: 400,
+            body: operatorFailed({
+                command: "bootstrapFromPrd",
+                outcome: "rejected",
+                code: "INTERNAL_ERROR",
+                message: created.stderr?.trim() ||
+                    `new-task failed with exit ${created.exitCode}`,
+                details: {
+                    exitCode: created.exitCode,
+                    timedOut: created.timedOut,
+                    taskId,
+                    title,
+                    stdoutPreview: (created.stdout ?? "").slice(0, 400),
+                },
+            }),
+        };
+    }
+    const staged = await stageUtf8Text(ctx.appData, content, {
+        extension: ".md",
+    });
+    const imported = await run(["import-prd", taskId, "--file", staged.path, "--json"], {
+        cwd: ctx.repoRoot,
+        artifactName: "bootstrap-import-prd",
+        expectJson: true,
+        timeoutMs: 60_000,
+    });
+    if (!imported.ok || imported.exitCode !== 0) {
+        return {
+            kind: "error",
+            status: 400,
+            body: operatorFailed({
+                command: "bootstrapFromPrd",
+                outcome: "rejected",
+                code: "INTERNAL_ERROR",
+                message: imported.stderr?.trim() ||
+                    `import-prd failed with exit ${imported.exitCode}`,
+                details: { exitCode: imported.exitCode, taskId },
+            }),
+        };
+    }
+    const draftSaved = await ctx.drafts.save({
+        ...emptyDraft(taskId, title, { taskKind }),
+        requirement: {
+            objective: title,
+        },
+    });
+    return {
+        kind: "sync",
+        status: 200,
+        body: operatorSucceeded("bootstrapFromPrd", {
+            taskId,
+            title,
+            taskKind,
+            identitySource: identity.source,
+            preferredTaskId: identity.taskId,
+            draftSha256: draftSaved.draftSha256,
+            import: imported.json ?? null,
+        }),
+    };
+}
+async function ensureDraft(ctx, taskId, title, options) {
+    const existing = await ctx.drafts.get(taskId);
+    if (existing) {
+        const seededKind = str(options?.taskKind);
+        if (seededKind && !existing.draft.taskKind?.trim()) {
+            const saved = await ctx.drafts.save({
+                ...existing.draft,
+                taskKind: normalizeConsoleWorkflowKind(seededKind),
+            });
+            return { draft: saved.draft, draftSha256: saved.draftSha256 };
+        }
+        return { draft: existing.draft, draftSha256: existing.draftSha256 };
+    }
+    const created = await ctx.drafts.save(emptyDraft(taskId, title, { taskKind: options?.taskKind }));
+    return { draft: created.draft, draftSha256: created.draftSha256 };
+}
+async function finalizeInterviewIfComplete(ctx, sessionId, draft) {
+    const question = nextGrillMeQuestion(draft);
+    if (question) {
+        const session = await ctx.interviews.setCurrentQuestion(sessionId, {
+            id: question.id,
+            text: `${question.text}\n\n推荐：${question.recommendation}`,
+            affectsFields: question.affectsFields,
+            risk: question.risk,
+        }, "eliciting");
+        const saved = await ctx.drafts.save(draft);
+        return {
+            session,
+            draft: saved.draft,
+            draftSha256: saved.draftSha256,
+            question,
+        };
+    }
+    if (!isDraftStructurallyComplete(draft)) {
+        const saved = await ctx.drafts.save({
+            ...draft,
+            openQuestions: listResidualNotes(draft),
+        });
+        const current = await ctx.interviews.get(sessionId);
+        if (!current) {
+            return {
+                session: undefined,
+                draft: saved.draft,
+                draftSha256: saved.draftSha256,
+            };
+        }
+        const blocked = await ctx.interviews.save({
+            ...current,
+            state: "validation-blocked",
+            currentQuestion: undefined,
+        });
+        return {
+            session: blocked,
+            draft: saved.draft,
+            draftSha256: saved.draftSha256,
+        };
+    }
+    const saved = await ctx.drafts.save({
+        ...draft,
+        openQuestions: [],
+    });
+    const assessment = await ctx.assessments.create({
+        draft: saved.draft,
+        instructionVersion: "grill-me@1",
+        provider: "console",
+        model: "deterministic-integrity-v1",
+        sessionId,
+        turnId: `turn_${saved.draftSha256.slice(0, 12)}`,
+        outcome: "complete",
+    });
+    const withRef = await ctx.drafts.save({
+        ...saved.draft,
+        interviewAssessmentRef: {
+            assessmentId: assessment.assessmentId,
+            draftSha256: saved.draftSha256,
+        },
+    });
+    const session = await ctx.interviews.markDraftReady(sessionId, withRef.draft, withRef.draftSha256);
+    await ctx.interviews.save({
+        ...session,
+        assessmentId: assessment.assessmentId,
+        state: "draft-ready",
+        currentQuestion: undefined,
+    });
+    const ready = await ctx.interviews.get(sessionId);
+    return {
+        session: ready,
+        draft: withRef.draft,
+        draftSha256: withRef.draftSha256,
+        assessmentId: assessment.assessmentId,
+    };
+}
+function listResidualNotes(draft) {
+    return [
+        `validation-blocked: Draft still missing required Interview fields: ${JSON.stringify(draftSummary(draft).gaps)}`,
+    ];
+}
+async function dispatchInterviewStart(ctx, p) {
+    const taskId = str(p.taskId);
+    if (!taskId)
+        return invalid("interviewStart", "taskId is required");
+    const title = str(p.title) ?? taskId;
+    const taskKind = str(p.taskKind);
+    const { draft } = await ensureDraft(ctx, taskId, title, { taskKind });
+    const session = await ctx.interviews.create({
+        taskId,
+        operatorSessionId: ctx.operatorSessionId,
+        instructionVersion: "grill-me@1",
+    });
+    const finalized = await finalizeInterviewIfComplete(ctx, session.sessionId, draft);
+    return {
+        kind: "sync",
+        status: 200,
+        body: operatorSucceeded("interviewStart", {
+            session: finalized.session,
+            draft: finalized.draft,
+            draftSha256: finalized.draftSha256,
+            assessmentId: finalized.assessmentId ?? null,
+            question: finalized.question
+                ? {
+                    id: finalized.question.id,
+                    text: finalized.question.text,
+                    recommendation: finalized.question.recommendation,
+                    affectsFields: finalized.question.affectsFields,
+                    risk: finalized.question.risk,
+                    gapId: finalized.question.gapId,
+                }
+                : null,
+            summary: draftSummary(finalized.draft),
+            zeroExtraQuestions: !finalized.question && Boolean(finalized.assessmentId),
+        }),
+    };
+}
+/**
+ * Skip interactive grilling: accept recommendations for remaining gaps and
+ * issue a complete assessment so contractApply can proceed.
+ */
+async function dispatchInterviewSkip(ctx, p) {
+    const taskId = str(p.taskId);
+    if (!taskId)
+        return invalid("interviewSkip", "taskId is required");
+    const title = str(p.title) ?? taskId;
+    const taskKind = str(p.taskKind);
+    let { draft } = await ensureDraft(ctx, taskId, title, { taskKind });
+    const accepted = [];
+    for (let i = 0; i < 24; i += 1) {
+        const question = nextGrillMeQuestion(draft);
+        if (!question)
+            break;
+        draft = applyGrillMeAnswer(draft, question, {
+            response: "accept-recommendation",
+        });
+        accepted.push(question.gapId);
+    }
+    if (!isDraftStructurallyComplete(draft)) {
+        const saved = await ctx.drafts.save({
+            ...draft,
+            openQuestions: listResidualNotes(draft),
+        });
+        return {
+            kind: "error",
+            status: 400,
+            body: operatorFailed({
+                command: "interviewSkip",
+                outcome: "invalid",
+                code: "INVALID_INPUT",
+                message: "无法跳过：采用推荐后草稿仍不完整，请先补齐需求或手动访谈",
+                details: {
+                    gaps: draftSummary(saved.draft).gaps,
+                    acceptedRecommendations: accepted,
+                },
+            }),
+        };
+    }
+    const session = await ctx.interviews.create({
+        taskId,
+        operatorSessionId: ctx.operatorSessionId,
+        instructionVersion: "grill-me@1+skip",
+    });
+    const priorAssumptions = Array.isArray(draft.assumptions)
+        ? draft.assumptions
+        : [];
+    const finalized = await finalizeInterviewIfComplete(ctx, session.sessionId, {
+        ...draft,
+        assumptions: [
+            ...priorAssumptions,
+            "operator skipped interactive interview; grill-me recommendations applied",
+        ],
+    });
+    if (!finalized.assessmentId) {
+        return {
+            kind: "error",
+            status: 400,
+            body: operatorFailed({
+                command: "interviewSkip",
+                outcome: "invalid",
+                code: "INVALID_INPUT",
+                message: "跳过访谈后未能签发完整评估",
+                details: { gaps: draftSummary(finalized.draft).gaps },
+            }),
+        };
+    }
+    // Re-tag assessment provenance as explicit skip (finalize uses deterministic model).
+    const assessment = await ctx.assessments.get(finalized.assessmentId);
+    if (assessment) {
+        await ctx.assessments.save({
+            ...assessment,
+            provider: "console-skip",
+            model: "accept-recommendations-v1",
+            instructionVersion: "grill-me@1+skip",
+        });
+    }
+    return {
+        kind: "sync",
+        status: 200,
+        body: operatorSucceeded("interviewSkip", {
+            session: finalized.session,
+            draft: finalized.draft,
+            draftSha256: finalized.draftSha256,
+            assessmentId: finalized.assessmentId,
+            question: null,
+            summary: draftSummary(finalized.draft),
+            skipped: true,
+            acceptedRecommendations: accepted,
+            complete: true,
+        }),
+    };
+}
+async function dispatchInterviewTurn(ctx, p) {
+    const sessionId = str(p.sessionId);
+    if (!sessionId)
+        return invalid("interviewTurn", "sessionId is required");
+    const session = await ctx.interviews.get(sessionId);
+    if (!session) {
+        return {
+            kind: "error",
+            status: 404,
+            body: operatorFailed({
+                command: "interviewTurn",
+                outcome: "not-found",
+                code: "NOT_FOUND",
+                message: `interview session not found: ${sessionId}`,
+            }),
+        };
+    }
+    const questionId = str(p.questionId) ?? session.currentQuestion?.id;
+    if (!questionId || !session.currentQuestion) {
+        return invalid("interviewTurn", "no open question; call interviewStart or interviewGet");
+    }
+    if (session.currentQuestion.id !== questionId) {
+        return invalid("interviewTurn", "questionId does not match open question");
+    }
+    const response = str(p.response) ??
+        (str(p.acceptRecommendation) === "true"
+            ? "accept-recommendation"
+            : str(p.text)
+                ? "override"
+                : "accept-recommendation");
+    const text = str(p.text);
+    const draftRec = await ctx.drafts.get(session.taskId);
+    const draft = draftRec?.draft ?? emptyDraft(session.taskId);
+    const gapId = questionId.replace(/^q-/, "");
+    const question = nextGrillMeQuestion(draft)?.id === questionId
+        ? nextGrillMeQuestion(draft)
+        : {
+            id: questionId,
+            gapId,
+            text: session.currentQuestion.text,
+            recommendation: extractRecommendation(session.currentQuestion.text),
+            affectsFields: session.currentQuestion.affectsFields,
+            risk: session.currentQuestion.risk ?? "medium",
+        };
+    if (response === "defer" && question.risk === "high") {
+        return {
+            kind: "error",
+            status: 403,
+            body: operatorFailed({
+                command: "interviewTurn",
+                outcome: "blocked",
+                code: "HUMAN_CONFIRMATION_REQUIRED",
+                message: "高风险访谈问题不可暂缓",
+                details: { questionId, risk: question.risk },
+            }),
+        };
+    }
+    await ctx.interviews.recordAnswer(sessionId, {
+        questionId,
+        response,
+        text,
+        at: new Date().toISOString(),
+    });
+    const updatedDraft = applyGrillMeAnswer(draft, question, { response, text });
+    const finalized = await finalizeInterviewIfComplete(ctx, sessionId, updatedDraft);
+    return {
+        kind: "sync",
+        status: 200,
+        body: operatorSucceeded("interviewTurn", {
+            session: finalized.session,
+            draft: finalized.draft,
+            draftSha256: finalized.draftSha256,
+            assessmentId: finalized.assessmentId ?? null,
+            question: finalized.question
+                ? {
+                    id: finalized.question.id,
+                    text: finalized.question.text,
+                    recommendation: finalized.question.recommendation,
+                    affectsFields: finalized.question.affectsFields,
+                    risk: finalized.question.risk,
+                    gapId: finalized.question.gapId,
+                }
+                : null,
+            summary: draftSummary(finalized.draft),
+            complete: Boolean(finalized.assessmentId),
+        }),
+    };
+}
+function extractRecommendation(questionText) {
+    const m = questionText.match(/推荐[：:]\s*(.+)$/m);
+    return m?.[1]?.trim() || "";
+}
 function invalid(action, message) {
     return {
         kind: "error",
@@ -751,7 +1340,7 @@ async function dispatchContractValidateOrDiff(ctx, action, p) {
         if (!stored) {
             return invalid(action, "draftJson or stored draft required");
         }
-        const staged = await stageUtf8Text(ctx.appData, JSON.stringify(stored.draft, null, 2), { extension: ".json" });
+        const staged = await stageUtf8Text(ctx.appData, JSON.stringify(toCanonicalDraftForCli(stored.draft), null, 2), { extension: ".json" });
         inputPath = staged.path;
     }
     else {