@peterxiaoyang/superspec 0.1.48 → 0.1.49

package/dist/phase_plan.d.ts

@@ -106,6 +106,8 @@ export interface ApplyPendingTaskStatus {
 export declare function executionPolicyForRisk(risk: ReviewRisk): ExecutionPolicy;
 export declare function executionPolicyForCurrentRound(events: Event[]): ExecutionPolicy;
 export declare function proposalDocsBaseline(changeRoot: string): Record<string, string>;
+export declare function applyPlanningBaseline(changeRoot: string): Record<string, string>;
+export declare function applyPlanningDocsChangedSinceBaseline(changeRoot: string, baseline: Record<string, string>): boolean;
 export declare function discoveryDocsBaseline(changeRoot: string): Record<string, string>;
 /** 新 Explore 轮次冻结已有已确认事项，避免把历史答复当作本轮遗漏。 */
 export declare function exploreAnswerRegistrationPayloadForChange(changeRoot: string): ReturnType<typeof exploreAnswerRegistrationPayload>;

package/dist/phase_plan.js

@@ -25,14 +25,14 @@ function freeTextDecisionAsk(change, question, scope) {
         required_fields: ["answer"],
     };
 }
-function requiredArtifact(projectRoot, change, changeRoot, state, kind, fileName, risk) {
-    const artifactPath = relative(projectRoot, join(changeRoot, ".superspec", "artifacts", fileName)).replaceAll("\\", "/");
+function requiredArtifact(projectRoot, change, changeRoot, state, kind, canonicalPath, risk) {
+    const artifactPath = relative(projectRoot, join(changeRoot, canonicalPath)).replaceAll("\\", "/");
     return {
         kind: "artifact_required",
         state,
         artifact: { kind, path: artifactPath, operation: "create_or_update" },
         resume: { argv: nextArgv(change, risk) },
-        reason: `${fileName} 不存在`,
+        reason: `${canonicalPath.split("/").at(-1)} 不存在`,
     };
 }
 function phaseConfirmationStep(context, boundary, reason) {
@@ -244,6 +244,15 @@ export function proposalDocsBaseline(changeRoot) {
     }
     return baseline;
 }
+export function applyPlanningBaseline(changeRoot) {
+    const baseline = proposalDocsBaseline(changeRoot);
+    delete baseline["tasks.md"];
+    return baseline;
+}
+export function applyPlanningDocsChangedSinceBaseline(changeRoot, baseline) {
+    const current = applyPlanningBaseline(changeRoot);
+    return Object.entries(baseline).some(([path, digest]) => current[path] !== digest);
+}
 export function discoveryDocsBaseline(changeRoot) {
     // 与 Explore gate 使用同一组审查目标。回退到 explore 后，至少要更新一项
     // discovery 材料，才允许重新进入 propose，避免把一次纯状态回退误当作新探索轮次。
@@ -476,6 +485,20 @@ export function pendingTaskStatusForApply(changeRoot, events) {
         completedByEvent,
     };
 }
+function isPostApplyPlanOnlyRepair(changeRoot, events) {
+    // Propose 返工发生在新 Apply round 之前，旧 round 的 task_completed 不能覆盖
+    // 当前计划明确重新打开的 checkbox；这里以当前 tasks.md 为准。
+    if (pendingTaskIds(changeRoot).length > 0)
+        return false;
+    const roundId = currentProposeRoundId(events);
+    const roundEvent = events.find(event => event.event_id === roundId);
+    if (roundEvent?.event_type !== "transition_commit")
+        return false;
+    const payload = roundEvent.payload;
+    return payload.transition === "reopen"
+        && payload.reopen_target === "propose"
+        && ["apply", "apply_done", "review", "accepted"].includes(String(payload.reopen_source));
+}
 export function formatPendingTaskMessage(ids, action) {
     return `尚有未完成任务：${ids.join(", ")}；${action}`;
 }
@@ -532,7 +555,7 @@ export function planNextStep(context) {
             }
             const discoveryPath = join(changeRoot, ".superspec", "artifacts", "discovery.md");
             if (!existsSync(discoveryPath)) {
-                return requiredArtifact(projectRoot, change, changeRoot, "explore", "discovery", "discovery.md", mode.risk);
+                return requiredArtifact(projectRoot, change, changeRoot, "explore", "discovery", ".superspec/artifacts/discovery.md", mode.risk);
             }
             const discoveryCheck = validateDiscovery(changeRoot);
             if (!discoveryCheck.ok) {
@@ -616,7 +639,10 @@ export function planNextStep(context) {
             }
             const testContractPath = join(changeRoot, ".superspec", "artifacts", "test-contract.md");
             if (!existsSync(testContractPath)) {
-                return requiredArtifact(projectRoot, change, changeRoot, "propose", "test_contract", "test-contract.md", mode.risk);
+                return requiredArtifact(projectRoot, change, changeRoot, "propose", "test_contract", ".superspec/artifacts/test-contract.md", mode.risk);
+            }
+            if (!existsSync(join(changeRoot, "tasks.md"))) {
+                return requiredArtifact(projectRoot, change, changeRoot, "propose", "tasks", "tasks.md", mode.risk);
             }
             const planningProfile = planningValidationProfileForPendingProposeRound(events);
             const preflight = validatePlanningPreflight(projectRoot, change, changeRoot, mode.risk, executionPolicyForRisk(mode.risk), planningProfile);
@@ -646,7 +672,8 @@ export function planNextStep(context) {
                 return requiredJobs("propose_ready", proposalReviewJobs, `有 ${proposalReviewJobs.length} 个待完成 proposal 审查工作项`);
             }
             const startApplyPlan = planStartApplyTransition(context, false);
-            if (startApplyPlan.kind === "advance") {
+            const planOnlyRepair = isPostApplyPlanOnlyRepair(changeRoot, events);
+            if (startApplyPlan.kind === "advance" && !planOnlyRepair) {
                 const confirmation = phaseConfirmationStep(context, "propose_to_apply", "计划阶段完成，等待用户确认开始实现");
                 if (confirmation)
                     return confirmation;
@@ -661,7 +688,12 @@ export function planNextStep(context) {
                 };
                 return { kind: "ask_user", state: "propose_ready", ask, reason: startApplyPlan.message };
             }
-            return { kind: "run_transition", state: "propose_ready", transition: "start-apply", reason: "计划就绪，开始执行" };
+            return {
+                kind: "run_transition",
+                state: "propose_ready",
+                transition: "start-apply",
+                reason: planOnlyRepair ? "计划材料已修正且没有待实施任务，跳过重复的 Apply 确认" : "计划就绪，开始执行",
+            };
         }
         case "apply":
             return planApplyNext(context);
@@ -1061,10 +1093,12 @@ function planStartApplyTransition(context, enforceConfirmation = true) {
             reason: `进入执行阶段前需要重新完成计划文档审查：${gatePlan.reason}`,
         };
     }
+    const planOnlyRepair = isPostApplyPlanOnlyRepair(changeRoot, events);
     const acceptedConfirmation = enforceConfirmation
+        && !planOnlyRepair
         ? acceptedProposeToApplyConfirmation(context, risk)
         : null;
-    if (enforceConfirmation && !acceptedConfirmation) {
+    if (enforceConfirmation && !acceptedConfirmation && !planOnlyRepair) {
         const confirmation = phaseConfirmationForBoundary(projectRoot, events, snapshot, "propose_to_apply", risk);
         return {
             kind: "skip",
@@ -1076,7 +1110,7 @@ function planStartApplyTransition(context, enforceConfirmation = true) {
         kind: "advance",
         fromState: "propose_ready",
         toState: "apply",
-        reason: "进入执行阶段",
+        reason: planOnlyRepair ? "计划材料修正完成且没有待实施任务" : "进入执行阶段",
         payload: {
             apply_start_head: gitHead.head,
             apply_start_head_reason: gitHead.reason,
@@ -1088,6 +1122,7 @@ function planStartApplyTransition(context, enforceConfirmation = true) {
                 review_risk: risk,
                 requires_verifier: risk !== "minimal",
             },
+            apply_planning_baseline: applyPlanningBaseline(changeRoot),
             ...(acceptedConfirmation ? phaseConfirmationCommitPayload(acceptedConfirmation.confirmation, acceptedConfirmation.decision) : {}),
         },
     };

package/dist/transition.js

@@ -9,7 +9,7 @@ import { REVIEW_CODE_REVIEW_GATE_ID, REVIEW_FINAL_VERIFIER_GATE, REVIEW_FINAL_VE
 import { codeReviewBoundFiles, codeReviewDecisionScope, codeReviewJobStaleReason, codeReviewPacketContext, codeReviewPacketDigest, collectCodeReviewGateFacts, computeCodeStateCheck, currentCodeReviewWorkingPaths, dismissedCodeReviewSummary, effectiveCoverageExemptionRefsFromEvents, latestCodeReviewGateEvidence, latestCodeReviewDecision, latestCodeReviewFailedStatus, missingCoverageExemptionTestIds, requiresFinalVerifierForCurrentReview, scanCodeChangesForReview, taskExecutionIndexForReview, } from "./code_review.js";
 import { taskEvidenceReadiness } from "./task_evidence.js";
 import { adoptedContractForTask, findTaskInLines, isFixTaskId, parseTasksMd, parseTestContractEntries, } from "./format.js";
-import { applyRequirementModeForCurrentRound, executionRequirementVersionForCurrentRound, blockingJobsForApplyDone, executionPolicyForCurrentRound, formatPendingTaskMessage, latestAcceptedProposalBaseline, pendingTaskStatusForApply, planningValidationProfileForNewRound, planTransition, discoveryDocsBaseline, exploreAnswerRegistrationPayloadForChange, proposeAnswerRegistrationPayloadForChange, proposalDocsBaseline, } from "./phase_plan.js";
+import { applyRequirementModeForCurrentRound, applyPlanningDocsChangedSinceBaseline, executionRequirementVersionForCurrentRound, blockingJobsForApplyDone, executionPolicyForCurrentRound, formatPendingTaskMessage, latestAcceptedProposalBaseline, pendingTaskStatusForApply, planningValidationProfileForNewRound, planTransition, discoveryDocsBaseline, exploreAnswerRegistrationPayloadForChange, proposeAnswerRegistrationPayloadForChange, proposalDocsBaseline, } from "./phase_plan.js";
 import { latestAcceptedPhaseDecision, phaseConfirmationCommitPayload, phaseConfirmationForBoundary, phaseConfirmationMissingMessage, } from "./phase_confirmation.js";
 import { currentGitHead, dirtyCodeFiles, stageProductionJavaFilesSince } from "./git_state.js";
 import { workflowRiskForProject } from "./workflow_config.js";
@@ -209,8 +209,8 @@ function compileRequiredEvidence(executionPolicy, testIds, requiresVerificationW
         accepted_green_statuses: ["expected_success"],
     };
 }
-function evidenceActionsForAttempt(change, attemptId, required) {
-    const testIds = required.test_ids.length > 0 ? required.test_ids : [undefined];
+function evidenceActionsForAttempt(change, attemptId, fallbackTestId, required) {
+    const testIds = required.test_ids.length > 0 ? required.test_ids : [fallbackTestId];
     const statuses = [];
     if (required.red_required)
         statuses.push("expected_failure");
@@ -218,10 +218,10 @@ function evidenceActionsForAttempt(change, attemptId, required) {
         statuses.push(required.accepted_green_statuses[0] ?? "expected_success");
     return testIds.flatMap(testId => statuses.map(semanticStatus => ({
         kind: "test_run",
-        ...(testId ? { test_id: testId } : {}),
+        test_id: testId,
         record_argv: ["superspec", "record", "test-run", "--change", change, "--input", "-"],
         record_input: {
-            ...(testId ? { test_id: testId } : {}),
+            test_id: testId,
             attempt_id: attemptId,
             command: null,
             cwd: null,
@@ -820,6 +820,9 @@ export function taskStart(projectRoot, change, changeRoot, taskId) {
             if (snapshot.state !== "apply")
                 return { skip: true, message: `当前状态 ${snapshot.state}，需要 apply` };
             const events = readEvents(projectRoot, change);
+            if (applyPlanningMaterialsChanged(changeRoot, events)) {
+                return { skip: true, message: "Apply 期间计划材料已变化；请回到 Propose 核对并重新批准计划后再继续任务" };
+            }
             const tasksContent = readFileSync(join(changeRoot, "tasks.md"), "utf8");
             const lines = tasksContent.split("\n");
             const taskLineIdx = findTaskLine(lines, taskId);
@@ -890,7 +893,7 @@ export function taskStart(projectRoot, change, changeRoot, taskId) {
                 ...boundarySnapshotPayload(projectRoot),
             };
             const evidenceActions = requiredEvidence
-                ? evidenceActionsForAttempt(change, attempt.attempt_id, requiredEvidence)
+                ? evidenceActionsForAttempt(change, attempt.attempt_id, taskId, requiredEvidence)
                 : null;
             return {
                 fromState: "apply", toState: "apply", outcome: "advanced",
@@ -934,6 +937,36 @@ function invalidateOpenJobs(snapshot, to, reason) {
         },
     }));
 }
+function latestApplyPlanningBaseline(events) {
+    for (let index = events.length - 1; index >= 0; index--) {
+        const event = events[index];
+        if (event.event_type !== "transition_commit")
+            continue;
+        const payload = event.payload;
+        if (payload.transition !== "start-apply")
+            continue;
+        const baseline = payload.apply_planning_baseline;
+        if (!baseline || typeof baseline !== "object" || Array.isArray(baseline))
+            return null;
+        const entries = Object.entries(baseline);
+        return entries.every(([, digest]) => typeof digest === "string")
+            ? Object.fromEntries(entries)
+            : null;
+    }
+    return null;
+}
+function applyPlanningMaterialsChanged(changeRoot, events) {
+    const baseline = latestApplyPlanningBaseline(events);
+    return baseline != null && applyPlanningDocsChangedSinceBaseline(changeRoot, baseline);
+}
+function proposalReopenBaseline(changeRoot, events, source) {
+    const applyBaseline = ["apply", "apply_done", "review"].includes(source)
+        ? latestApplyPlanningBaseline(events)
+        : null;
+    return applyBaseline
+        ? { baseline: { ...proposalDocsBaseline(changeRoot), ...applyBaseline }, source: "apply" }
+        : { baseline: proposalDocsBaseline(changeRoot), source: "reopen_fallback" };
+}
 function planningReopenExtraEvents(snapshot, to, reason) {
     return [
         ...invalidateOpenJobs(snapshot, to, reason),
@@ -1004,6 +1037,9 @@ export function reopen(projectRoot, change, changeRoot, to, reason, opts = {}) {
                     return { skip: true, message: "--review-fix 只能用于回到实现阶段（reopen --to apply）" };
                 if (snapshot.state !== "apply_done")
                     return { skip: true, message: `当前状态 ${snapshot.state}，不能通过代码审查修复回到实现阶段` };
+                if (applyPlanningMaterialsChanged(changeRoot, events)) {
+                    return { skip: true, message: "计划材料已变化，不能作为纯实现问题回到 Apply；请 reopen --to propose" };
+                }
                 const ref = parseCodeReviewFindingRef(opts.reviewFix);
                 if (!ref)
                     return { skip: true, message: "--review-fix 必须是 <job_id>#<finding_id>" };
@@ -1045,6 +1081,9 @@ export function reopen(projectRoot, change, changeRoot, to, reason, opts = {}) {
                     return { skip: true, message: `当前状态 ${snapshot.state}，不能通过自测问题回到实现阶段` };
                 }
                 const parentTaskId = opts.selfTestFix.trim();
+                if (applyPlanningMaterialsChanged(changeRoot, events)) {
+                    return { skip: true, message: "计划材料已变化，不能作为纯实现问题创建 self-test 修复；请 reopen --to propose" };
+                }
                 const parentTask = parseTasksMd(readFileSync(join(changeRoot, "tasks.md"), "utf8"))
                     .find(task => task.taskId === parentTaskId);
                 if (!parentTask)
@@ -1118,12 +1157,13 @@ export function reopen(projectRoot, change, changeRoot, to, reason, opts = {}) {
                 // 的摘要，并用 reopen 当刻的摘要补齐缺项，确保本轮之后对任一审查目标的修改都能被检测。
                 const baselineNeedsBackfill = acceptedBaseline !== null && Object.keys(currentBaseline)
                     .some(path => !Object.prototype.hasOwnProperty.call(acceptedBaseline, path));
+                const applyReopenBaseline = acceptedBaseline ? null : proposalReopenBaseline(changeRoot, events, snapshot.state);
                 const baselineDocs = acceptedBaseline
                     ? Object.fromEntries(Object.entries(currentBaseline).map(([path, digest]) => [
                         path,
                         Object.prototype.hasOwnProperty.call(acceptedBaseline, path) ? acceptedBaseline[path] : digest,
                     ]))
-                    : currentBaseline;
+                    : applyReopenBaseline.baseline;
                 return {
                     fromState: snapshot.state,
                     toState: "propose",
@@ -1132,7 +1172,9 @@ export function reopen(projectRoot, change, changeRoot, to, reason, opts = {}) {
                     commitPayload: {
                         reopen_target: "propose",
                         reopen_source: snapshot.state,
-                        baseline_source: acceptedBaseline ? (baselineNeedsBackfill ? "accepted_backfill" : "accepted") : "reopen_fallback",
+                        baseline_source: acceptedBaseline
+                            ? (baselineNeedsBackfill ? "accepted_backfill" : "accepted")
+                            : applyReopenBaseline.source,
                         baseline_docs: baselineDocs,
                         planning_validation_version: 2,
                         planning_validation_profile: planningValidationProfileForNewRound(projectRoot),
@@ -1145,6 +1187,9 @@ export function reopen(projectRoot, change, changeRoot, to, reason, opts = {}) {
             if (snapshot.state !== "apply_done" && snapshot.state !== "review") {
                 return { skip: true, message: `当前状态 ${snapshot.state}，不能 reopen 到 apply` };
             }
+            if (applyPlanningMaterialsChanged(changeRoot, events)) {
+                return { skip: true, message: "计划材料已变化，不能直接回到 Apply；请 reopen --to propose" };
+            }
             const pending = pendingTaskStatusForApply(changeRoot, events).pending;
             if (pending.length === 0)
                 return { skip: true, message: "没有未完成任务，不能 reopen 到 apply" };
@@ -1167,6 +1212,9 @@ export function reviewReady(projectRoot, change, changeRoot, risk = workflowRisk
             const policy = storedPolicy ?? reviewPolicyForRisk(risk);
             const policyPayload = storedPolicy ? {} : { review_policy: policy };
             const currentEvidenceDigest = reviewEvidenceDigest(events);
+            if (snapshot.state === "apply" && applyPlanningMaterialsChanged(changeRoot, events)) {
+                return { skip: true, message: "Apply 期间计划材料已变化，不能进入 Review；请回到 Propose 核对并重新批准计划" };
+            }
             // 检查是否所有任务已完成
             const pending = pendingTaskStatusForApply(changeRoot, events).pending;
             if (pending.length > 0)
@@ -1267,10 +1315,14 @@ export function taskComplete(projectRoot, change, changeRoot, taskId, inputConte
             const attempt = snapshot.active_task_attempts?.find(a => a.task_id === taskId && a.state === "active");
             if (!attempt)
                 return { skip: true, message: `任务 ${taskId} 无活跃执行尝试` };
+            const events = readEvents(projectRoot, change);
+            if (applyPlanningMaterialsChanged(changeRoot, events)) {
+                return { skip: true, message: "Apply 期间计划材料已变化，不能完成当前任务；请回到 Propose 核对并重新批准计划" };
+            }
             const readiness = taskEvidenceReadiness(projectRoot, change, changeRoot, attempt);
             if (!readiness.ready)
                 return { skip: true, message: `任务 ${taskId} 无法完成：${readiness.reason}` };
-            const taskStartBoundary = boundarySnapshotForTaskAttempt(readEvents(projectRoot, change), attempt.attempt_id);
+            const taskStartBoundary = boundarySnapshotForTaskAttempt(events, attempt.attempt_id);
             const completedPayload = {
                 task_id: taskId,
                 attempt_id: attempt.attempt_id,

package/dist/types.d.ts

@@ -226,6 +226,8 @@ export interface TransitionCommitPayload {
         review_risk?: "minimal" | "normal" | "strict";
     };
     accepted_baseline_docs?: Record<string, string>;
+    /** Apply 开始时冻结的计划材料摘要；tasks.md 由状态机维护，不参与冻结。 */
+    apply_planning_baseline?: Record<string, string>;
     /** Propose-ready / start-apply 写入的本轮 workflow mode，后续阶段只读该快照。 */
     workflow_mode?: "minimal" | "normal" | "strict";
     /** v2 起所有普通任务必须有五字段执行依据；缺失表示旧 change，沿用旧规则回放。 */
@@ -342,7 +344,7 @@ export interface AcceptedMaterialFollowupContinuation {
     };
     plan_docs_changed_since_accept: boolean | null;
 }
-export type WorkflowArtifactKind = "discovery" | "test_contract";
+export type WorkflowArtifactKind = "discovery" | "test_contract" | "tasks";
 export interface RequiredWorkflowArtifact {
     kind: WorkflowArtifactKind;
     /** Repository-relative canonical path owned by the workflow engine. */
@@ -357,10 +359,10 @@ export interface MaterialUpdateRequiredResume {
 }
 export interface TestEvidenceAction {
     kind: "test_run";
-    test_id?: string;
+    test_id: string;
     record_argv: string[];
     record_input: {
-        test_id?: string;
+        test_id: string;
         attempt_id: string;
         command: null;
         cwd: null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peterxiaoyang/superspec",
-  "version": "0.1.48",
+  "version": "0.1.49",
   "description": "SuperSpec 流程引擎 — transition engine with lightweight fact-sync",
   "type": "module",
   "engines": {

package/templates/workflow/AGENTS.md

@@ -1,6 +1,8 @@
 <!-- SUPERSPEC:AGENTS:START -->
 只有当用户显式调用 `superspec-*`，或明确要求继续处理某个已有 SuperSpec change 时，才进入或续转 SuperSpec 工作流。普通开发、修复、排查、测试或审查请求，即使项目已安装 SuperSpec，也不得自行启动工作流、创建 change、执行 `transition next`，或切换到某个 `superspec-*` 阶段。
 
+以下规则仅适用于已经显式启动或明确指定的 SuperSpec change。没有活跃 SuperSpec change 时，本区块除上述工作流激活边界外均不适用，按项目常规开发指令执行。
+
 一旦用户已显式启动工作流或明确指定 change，使用 `superspec-*` 工作流时一律以 `superspec transition next --change "<change>"` 返回的下一步推进；主流程执行内部命令，不要求用户手动运行工作流命令。流程完成前不得跳阶段、不得自称完成。
 
 每完成 `next` 返回的当前事项（材料更新、用户答复回写、实现、验证、审查或修复时），立即再次运行 `superspec transition next --change "<change>"` 并继续处理。完成单个事项不等于完成整个 change；只有工作流明确需要用户决定、当前独立工作项尚未返回结果、遇到真实阻塞或整个 change 已完成时才暂停。
@@ -13,6 +15,8 @@ Explore 中需要用户决定业务、验收、范围或关键取舍时，先简
 
 当前 change 的自测、联调或用户指出的问题若仍能由既有 task 的批准行为、边界和验收解释，就在同一 change 内处理：
 
+计划材料没有枚举某个类、继承关系、方法或局部实现细节，不等于计划遗漏。只要正确修法能够由既有 task、已批准行为和仓库事实唯一推导，仍属于 Apply；只有需要重新决定公共接口、数据归属、迁移兼容、实现路线、验收或 task 边界时才回 Propose。
+
 - 当前 task 尚未完成时，在其范围内直接修复；不要为同一实现问题新增 task 或回 propose。
 - 所有 task 已完成后，若问题仍能关联一个已完成 task、且不改变已批准行为和方案，主流程执行 `superspec transition reopen --change "<change>" --to apply --self-test-fix "<task>" --reason "<reason>"`，让工作流创建修复事项；随后继续 `next`，不得手改 tasks。
 - 无法关联既有 task，或需要改变行为、验收、接口、数据语义或实现路线时，才回 propose。

package/templates/workflow/skills/superspec-propose/SKILL.md

@@ -186,6 +186,8 @@ metadata:
 
 Propose 以已确认的 Discovery 为需求边界。范围、业务行为、验收、数据语义或安全仍不明确时，回同一 change 的 Explore 澄清，不静默采用默认业务语义。
 
+用户补充与已经核实的代码、运行行为、接口契约或外部系统事实冲突时，不通过改写事实材料来消除冲突。若用户明确要求改变真实行为，将相应实现、迁移和验证影响纳入计划；若是否改变真实行为仍不明确，保留冲突并交给用户确认。
+
 当需求结果已经明确，但多个可行技术路线会让使用者承担不同的迁移、兼容、数据归属、发布、成本或长期维护边界时，不替使用者静默选择。在 `design.md` 的 `## 待用户确认` 中保留当前高影响设计决定，说明已知事实、候选结果、推荐及依据和会受影响的交付；内部命名、文件组织、局部实现和不改变这些结果的技术选择由模型自主决定。没有这类取舍时不制造问答。
 
 每项使用 `DEC-xxx` 标识并只表达一个决定。工作流一次返回当前一项；用户答复后按工作流反馈处理，勾选时保留决定项原文，将最终选择与影响写入相邻正文及相关 design、specs、tasks 和测试契约，并按新方案重新判断后续事项。审查角色只能依据本次目标和直接证据指出缺失的决定，不能把个人偏好或更理想的架构升级为用户义务。