@peterxiaoyang/superspec 0.1.44 → 0.1.45

package/dist/task_evidence.js

@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parseTasksMd } from "./format.js";
 import { readEvents, sha256Text } from "./store.js";
+import { GREEN_ONLY_NO_TDD_REASON } from "./types.js";
 export function taskEvidenceReadiness(projectRoot, change, changeRoot, attempt) {
     if (attempt.contract_mode === true) {
         return contractTaskEvidenceReadiness(projectRoot, change, attempt);
@@ -18,6 +19,9 @@ export function taskEvidenceReadiness(projectRoot, change, changeRoot, attempt)
     if (currentDigest !== attempt.task_structure_digest)
         missing.push("任务结构指纹");
     if (!taskInfo.tddRequired) {
+        if (taskInfo.noTddReason === GREEN_ONLY_NO_TDD_REASON) {
+            missing.push(`${GREEN_ONLY_NO_TDD_REASON} 任务必须使用执行依据模式`);
+        }
         if (!taskInfo.noTddReason)
             missing.push("no_tdd_reason");
         return missing.length === 0
@@ -48,7 +52,76 @@ export function taskEvidenceReadiness(projectRoot, change, changeRoot, attempt)
         : { ready: false, missing, reason: missing.join("、") };
 }
 function contractTaskEvidenceReadiness(projectRoot, change, attempt) {
+    if (attempt.required_evidence) {
+        return effectiveContractTaskEvidenceReadiness(projectRoot, change, attempt);
+    }
+    return legacyContractTaskEvidenceReadiness(projectRoot, change, attempt);
+}
+/** 新执行依据模式：只消费 task-start 冻结的有效证据计划。 */
+function effectiveContractTaskEvidenceReadiness(projectRoot, change, attempt) {
     const missing = [];
+    const required = attempt.required_evidence;
+    const declaredTests = required.test_ids;
+    if (declaredTests.length === 0) {
+        const evidence = attemptLevelEvidence(projectRoot, change, attempt.attempt_id, new Set(required.accepted_green_statuses));
+        if (required.red_required && !evidence.hasRed)
+            missing.push("RED 证据");
+        if (required.green_required && !evidence.hasGreen)
+            missing.push("GREEN 证据");
+        return missing.length === 0
+            ? { ready: true, missing: [] }
+            : { ready: false, missing, reason: missing.join("、") };
+    }
+    const perTest = new Map();
+    for (const testId of declaredTests) {
+        perTest.set(testId, { sawRed: false, sawGreen: false, paired: false });
+    }
+    for (const ev of readEvents(projectRoot, change)) {
+        if (ev.event_type !== "test_run_recorded")
+            continue;
+        const tr = ev.payload;
+        if (tr.attempt_id !== attempt.attempt_id)
+            continue;
+        if (typeof tr.test_id !== "string")
+            continue;
+        const state = perTest.get(tr.test_id);
+        if (!state)
+            continue;
+        if (tr.semantic_status === "expected_failure" && typeof tr.exit_code === "number" && tr.exit_code !== 0) {
+            state.sawRed = true;
+        }
+        const isAcceptedGreen = typeof tr.semantic_status === "string" &&
+            required.accepted_green_statuses.includes(tr.semantic_status) &&
+            tr.exit_code === 0;
+        if (isAcceptedGreen) {
+            if (state.sawRed)
+                state.paired = true;
+            state.sawGreen = true;
+        }
+    }
+    if (required.green_required) {
+        for (const [testId, state] of perTest) {
+            if (!state.sawGreen)
+                missing.push(`${testId} GREEN 证据`);
+        }
+    }
+    if (required.red_required) {
+        const hasPairedTest = [...perTest.values()].some(state => state.paired);
+        if (!hasPairedTest)
+            missing.push("同一 TEST 的 RED/GREEN 配对");
+    }
+    return missing.length === 0
+        ? { ready: true, missing: [] }
+        : { ready: false, missing, reason: missing.join("、") };
+}
+/** 历史执行依据模式仍按当时写入 attempt 的标记回放。 */
+function legacyContractTaskEvidenceReadiness(projectRoot, change, attempt) {
+    const missing = [];
+    const executionPolicy = attempt.execution_policy ?? "tdd";
+    const greenOnly = executionPolicy === "green_only" && attempt.no_tdd_reason === GREEN_ONLY_NO_TDD_REASON;
+    if (attempt.no_tdd_reason === GREEN_ONLY_NO_TDD_REASON && !greenOnly) {
+        missing.push(`${GREEN_ONLY_NO_TDD_REASON} 任务不适用于当前 TDD apply`);
+    }
     const tddRequired = attempt.tdd_required !== false;
     const characterization = attempt.tdd_required === false && attempt.no_tdd_reason === "characterization";
     const declaredTests = attempt.contract?.tests ?? [];
@@ -56,8 +129,11 @@ function contractTaskEvidenceReadiness(projectRoot, change, attempt) {
         missing.push("no_tdd_reason");
     }
     if (declaredTests.length === 0) {
-        if (tddRequired) {
-            const hasAttemptEvidence = attemptLevelRedGreenEvidence(projectRoot, change, attempt.attempt_id);
+        if (greenOnly) {
+            missing.push(`${GREEN_ONLY_NO_TDD_REASON} 任务缺少声明 TEST`);
+        }
+        else if (tddRequired) {
+            const hasAttemptEvidence = attemptLevelEvidence(projectRoot, change, attempt.attempt_id, new Set(["expected_success"]));
             if (!hasAttemptEvidence.hasRed)
                 missing.push("RED 证据");
             if (!hasAttemptEvidence.hasGreen)
@@ -75,16 +151,13 @@ function contractTaskEvidenceReadiness(projectRoot, change, attempt) {
         if (ev.event_type !== "test_run_recorded")
             continue;
         const tr = ev.payload;
-        if (tr.attempt_id !== attempt.attempt_id)
-            continue;
-        if (typeof tr.test_id !== "string")
+        if (tr.attempt_id !== attempt.attempt_id || typeof tr.test_id !== "string")
             continue;
         const state = perTest.get(tr.test_id);
         if (!state)
             continue;
-        if (tr.semantic_status === "expected_failure" && typeof tr.exit_code === "number" && tr.exit_code !== 0) {
+        if (tr.semantic_status === "expected_failure" && typeof tr.exit_code === "number" && tr.exit_code !== 0)
             state.sawRed = true;
-        }
         const isExpectedSuccess = tr.semantic_status === "expected_success" && tr.exit_code === 0;
         const isCharacterizationPass = characterization && tr.semantic_status === "characterization_pass" && tr.exit_code === 0;
         if (isExpectedSuccess || isCharacterizationPass) {
@@ -97,7 +170,7 @@ function contractTaskEvidenceReadiness(projectRoot, change, attempt) {
         if (!state.sawGreen)
             missing.push(`${testId} GREEN 证据`);
     }
-    if (tddRequired) {
+    if (tddRequired && !greenOnly) {
         const hasPairedTest = [...perTest.values()].some(state => state.paired);
         if (!hasPairedTest)
             missing.push("同一 TEST 的 RED/GREEN 配对");
@@ -106,7 +179,7 @@ function contractTaskEvidenceReadiness(projectRoot, change, attempt) {
         ? { ready: true, missing: [] }
         : { ready: false, missing, reason: missing.join("、") };
 }
-function attemptLevelRedGreenEvidence(projectRoot, change, attemptId) {
+function attemptLevelEvidence(projectRoot, change, attemptId, acceptedGreenStatuses) {
     let hasRed = false;
     let hasGreen = false;
     for (const ev of readEvents(projectRoot, change)) {
@@ -118,7 +191,9 @@ function attemptLevelRedGreenEvidence(projectRoot, change, attemptId) {
         if (tr.semantic_status === "expected_failure" && typeof tr.exit_code === "number" && tr.exit_code !== 0) {
             hasRed = true;
         }
-        if (tr.semantic_status === "expected_success" && tr.exit_code === 0) {
+        if (typeof tr.semantic_status === "string" &&
+            acceptedGreenStatuses.has(tr.semantic_status) &&
+            tr.exit_code === 0) {
             hasGreen = true;
         }
     }

package/dist/transition.d.ts

@@ -1,3 +1,4 @@
+import { type ReviewRisk } from "./review.ts";
 import type { Snapshot, State, Job, TransitionResult } from "./types.ts";
 interface Decision {
     fromState: State;
@@ -31,16 +32,16 @@ export declare function commitTransition(projectRoot: string, change: string, ch
     decide: (snapshot: Snapshot) => Decision | SkipDecision | BlockedDecision;
     idempotencyInputs?: Record<string, unknown>;
 }): TransitionResult;
-export declare function proposeReady(projectRoot: string, change: string, changeRoot: string, risk?: "minimal" | "normal" | "strict"): TransitionResult;
+export declare function proposeReady(projectRoot: string, change: string, changeRoot: string, risk?: ReviewRisk): TransitionResult;
 export declare function transitionInit(projectRoot: string, change: string, changeRoot: string): TransitionResult;
-export declare function transitionExplore(projectRoot: string, change: string, changeRoot: string, risk?: "minimal" | "normal" | "strict"): TransitionResult;
+export declare function transitionExplore(projectRoot: string, change: string, changeRoot: string, risk?: ReviewRisk): TransitionResult;
 export declare function startApply(projectRoot: string, change: string, changeRoot: string): TransitionResult;
 export declare function taskStart(projectRoot: string, change: string, changeRoot: string, taskId: string): TransitionResult;
 export declare function reopen(projectRoot: string, change: string, changeRoot: string, to: State, reason: string, opts?: {
     reviewFix?: string;
     reviewFinding?: string;
 }): TransitionResult;
-export declare function reviewReady(projectRoot: string, change: string, changeRoot: string, risk?: "minimal" | "normal" | "strict"): TransitionResult;
+export declare function reviewReady(projectRoot: string, change: string, changeRoot: string, risk?: ReviewRisk): TransitionResult;
 export declare function accept(projectRoot: string, change: string, changeRoot: string): TransitionResult;
 export declare function taskComplete(projectRoot: string, change: string, changeRoot: string, taskId: string, inputContent?: string | null): TransitionResult;
 export {};

package/dist/transition.js

@@ -9,9 +9,10 @@ import { REVIEW_CODE_REVIEW_GATE_ID, REVIEW_FINAL_VERIFIER_GATE_ID, reviewScopeF
 import { codeReviewBoundFiles, codeReviewDecisionScope, codeReviewJobStaleReason, codeReviewPacketContext, codeReviewPacketDigest, collectCodeReviewGateFacts, computeCodeStateCheck, currentCodeReviewWorkingPaths, dismissedCodeReviewSummary, latestCodeReviewDecision, latestCodeReviewFailedStatus, missingCoverageExemptionTestIds, requiresFinalVerifierForCurrentReview, scanCodeChangesForReview, } from "./code_review.js";
 import { taskEvidenceReadiness } from "./task_evidence.js";
 import { adoptedContractForTask, findTaskInLines, isReviewFixTaskId, parseTasksMd, parseTestContractEntries, } from "./format.js";
-import { applyRequirementModeForCurrentRound, blockingJobsForApplyDone, formatPendingTaskMessage, latestAcceptedProposalBaseline, pendingTaskStatusForApply, planTransition, proposalDocsBaseline, } from "./phase_plan.js";
+import { applyRequirementModeForCurrentRound, executionRequirementVersionForCurrentRound, blockingJobsForApplyDone, executionPolicyForCurrentRound, formatPendingTaskMessage, latestAcceptedProposalBaseline, pendingTaskStatusForApply, planTransition, discoveryDocsBaseline, proposalDocsBaseline, } from "./phase_plan.js";
 import { latestAcceptedPhaseDecision, phaseConfirmationCommitPayload, phaseConfirmationForBoundary, phaseConfirmationMissingMessage, } from "./phase_confirmation.js";
-import { currentGitHead, dirtyCodeFiles } from "./git_state.js";
+import { currentGitHead, dirtyCodeFiles, stageProductionJavaFilesSince } from "./git_state.js";
+import { workflowRiskForProject } from "./workflow_config.js";
 let transitionSeq = 0;
 function newTransitionId() { return `T-${Date.now()}-${++transitionSeq}`; }
 let jobSeq = 0;
@@ -81,6 +82,17 @@ function boundarySnapshotPayload(projectRoot) {
         ...(result.reason ? { boundary_snapshot_reason: result.reason } : {}),
     };
 }
+function boundarySnapshotForTaskAttempt(events, attemptId) {
+    const start = events.findLast(event => event.event_type === "task_started" &&
+        event.payload.attempt_id === attemptId);
+    const boundary = start?.payload?.boundary_snapshot;
+    if (!boundary || typeof boundary !== "object" || Array.isArray(boundary))
+        return null;
+    const value = boundary;
+    if (!Array.isArray(value.dirty_files))
+        return null;
+    return value;
+}
 function parseScopeNoteInput(inputContent) {
     if (inputContent == null)
         return { ok: true, value: null, digest: null };
@@ -130,9 +142,41 @@ function parseScopeNoteInput(inputContent) {
         },
     };
 }
-function validateTaskStartContract(changeRoot, taskId, tddRequired, parsedContract) {
-    if (!parsedContract)
+function validateTaskStartContract(changeRoot, taskId, parsedContract) {
+    if (parsedContract.errors.length > 0)
+        return parsedContract.errors.join("；");
+    if (!parsedContract.declaredFields.includes("tests"))
+        return `${taskId} 的执行依据缺少测试字段`;
+    if (!parsedContract.contract.design)
+        return `${taskId} 的执行依据缺少设计`;
+    if (parsedContract.contract.source.length === 0)
+        return `${taskId} 的执行依据缺少来源`;
+    if (!parsedContract.contract.acceptance)
+        return `${taskId} 的执行依据缺少验收目标`;
+    if (!parsedContract.contract.guard)
+        return `${taskId} 的执行依据缺少边界`;
+    if (parsedContract.contract.tests.length === 0)
         return null;
+    const testContractPath = join(changeRoot, ".superspec", "artifacts", "test-contract.md");
+    if (!existsSync(testContractPath))
+        return "test-contract.md 不存在，无法校验执行依据测试引用";
+    const parsed = parseTestContractEntries(readFileSync(testContractPath, "utf8"));
+    if (!parsed.ok)
+        return parsed.message;
+    const known = new Set(parsed.entries.map(entry => entry.test_id));
+    const missing = parsedContract.contract.tests.filter(testId => !known.has(testId));
+    return missing.length > 0 ? `执行依据引用了不存在的 TEST ID：${missing.join(", ")}` : null;
+}
+/**
+ * v1 只回放旧 contract 约束：普通 TDD task 必须保有执行依据和 TEST 引用，
+ * 但不要求 v2 新增的五字段，避免阻断历史 documentation-only task。
+ */
+function validateLegacyTaskStartContract(changeRoot, taskId, tddRequired, parsedContract) {
+    if (!parsedContract) {
+        return tddRequired && !isReviewFixTaskId(taskId)
+            ? `执行依据模式下，普通 TDD 任务 ${taskId} 缺少执行依据`
+            : null;
+    }
     if (parsedContract.errors.length > 0)
         return parsedContract.errors.join("；");
     if (tddRequired && !isReviewFixTaskId(taskId) && parsedContract.contract.tests.length === 0) {
@@ -150,6 +194,21 @@ function validateTaskStartContract(changeRoot, taskId, tddRequired, parsedContra
     const missing = parsedContract.contract.tests.filter(testId => !known.has(testId));
     return missing.length > 0 ? `执行依据引用了不存在的 TEST ID：${missing.join(", ")}` : null;
 }
+/**
+ * 只在 task-start 编译新模式 task 的有效证据要求。Propose 只声明 TEST，
+ * RED 是否要求由这里读取已冻结的 execution_policy 决定，之后不再依赖 tasks.md。
+ */
+function compileRequiredEvidence(executionPolicy, testIds, requiresVerificationWithoutDeclaredTest) {
+    // REVIEW-FIX 没有计划阶段声明的 TEST，但仍必须登记一次真实回归验证。
+    // 是否需要 RED 始终由已冻结的 execution_policy 决定。
+    const requiresVerification = testIds.length > 0 || requiresVerificationWithoutDeclaredTest;
+    return {
+        test_ids: testIds,
+        red_required: executionPolicy === "tdd" && requiresVerification,
+        green_required: requiresVerification,
+        accepted_green_statuses: ["expected_success"],
+    };
+}
 function hasRejectedReviewReadyVerifier(events) {
     const reviewReadyVerifierIds = new Set();
     for (const ev of events) {
@@ -235,7 +294,7 @@ function appendReviewFixTask(changeRoot, ref, finding) {
     const description = typeof finding.description === "string" && finding.description.trim()
         ? finding.description.trim().replace(/\s+/g, " ")
         : `修复代码审查问题 ${ref.findingId}`;
-    const line = `- [ ] ${reviewFixTaskId(ref)} ${description} tdd_required:true ${marker}`;
+    const line = `- [ ] ${reviewFixTaskId(ref)} ${description} ${marker}`;
     const suffix = content.endsWith("\n") ? "" : "\n";
     writeFileSync(tasksPath, `${content}${suffix}${line}\n`);
     return "created";
@@ -416,7 +475,7 @@ function evaluateFinalVerifierGate(input) {
     return { skip: true, message: "已在 review 状态，最终验证仍然有效" };
 }
 function authorizePhaseAdvance(input) {
-    const confirmation = phaseConfirmationForBoundary(input.projectRoot, input.events, input.snapshot, input.boundary);
+    const confirmation = phaseConfirmationForBoundary(input.projectRoot, input.events, input.snapshot, input.boundary, input.risk);
     const phaseDecision = confirmation
         ? latestAcceptedPhaseDecision(input.events, confirmation)
         : null;
@@ -540,7 +599,7 @@ export function commitTransition(projectRoot, change, changeRoot, opts) {
     });
 }
 // ===== propose-ready =====
-export function proposeReady(projectRoot, change, changeRoot, risk = "strict") {
+export function proposeReady(projectRoot, change, changeRoot, risk = workflowRiskForProject(projectRoot)) {
     return commitTransition(projectRoot, change, changeRoot, {
         name: "propose-ready", idempotencyInputs: { risk },
         decide: (snapshot) => {
@@ -570,7 +629,7 @@ export function transitionInit(projectRoot, change, changeRoot) {
     });
 }
 // ===== explore =====
-export function transitionExplore(projectRoot, change, changeRoot, risk = "strict") {
+export function transitionExplore(projectRoot, change, changeRoot, risk = workflowRiskForProject(projectRoot)) {
     return commitTransition(projectRoot, change, changeRoot, {
         name: "explore", idempotencyInputs: { phase: "explore", risk },
         decide: (snapshot) => {
@@ -599,7 +658,7 @@ export function startApply(projectRoot, change, changeRoot) {
                 changeRoot,
                 events,
                 snapshot,
-                mode: { kind: "risk", risk: "strict" },
+                mode: { kind: "risk", risk: workflowRiskForProject(projectRoot) },
             });
             return transitionPlanToDecision(snapshot, changeRoot, change, plan, events);
         },
@@ -620,6 +679,8 @@ export function taskStart(projectRoot, change, changeRoot, taskId) {
             if (taskLineIdx < 0)
                 return { skip: true, message: `任务 ${taskId} 不存在` };
             const contractMode = applyRequirementModeForCurrentRound(events);
+            const executionRequirementVersion = executionRequirementVersionForCurrentRound(events);
+            const executionPolicy = executionPolicyForCurrentRound(events);
             if (contractMode && pendingTaskStatusForApply(changeRoot, events).completedByEvent.includes(taskId)) {
                 return { skip: true, message: `任务 ${taskId} 已通过完成事件完成` };
             }
@@ -634,23 +695,38 @@ export function taskStart(projectRoot, change, changeRoot, taskId) {
             // 统一出口：adopted.contract 非 null 当且仅当契约模式下有绑定块；
             // legacy 轮即使 task 带执行依据文本也输出 null，避免"看似契约、实按 legacy 校验"的误导态
             const adopted = adoptedContractForTask(tasksContent, taskId, contractMode);
-            if (contractMode && taskInfo.tddRequired && !isReviewFixTaskId(taskId) && !adopted.parsed) {
-                return { skip: true, message: `执行依据模式下，普通 TDD 任务 ${taskId} 缺少执行依据` };
+            const reviewFix = isReviewFixTaskId(taskId);
+            if (contractMode && executionRequirementVersion === 2 && !reviewFix && !adopted.parsed) {
+                return { skip: true, message: `执行依据模式下，任务 ${taskId} 缺少执行依据` };
+            }
+            if (contractMode && executionRequirementVersion === 2 && !reviewFix && adopted.parsed) {
+                const contractError = validateTaskStartContract(changeRoot, taskId, adopted.parsed);
+                if (contractError)
+                    return { skip: true, message: contractError };
             }
-            if (contractMode) {
-                const contractError = validateTaskStartContract(changeRoot, taskId, taskInfo.tddRequired, adopted.parsed);
+            if (contractMode && executionRequirementVersion === 1) {
+                const contractError = validateLegacyTaskStartContract(changeRoot, taskId, taskInfo.tddRequired, adopted.parsed);
                 if (contractError)
                     return { skip: true, message: contractError };
             }
             const structureDigest = sha256Text(tasksContent.replace(/- \[[xX]\]/g, "- [ ]"));
+            const effectivePolicy = executionPolicy;
+            const requiredEvidence = contractMode && executionRequirementVersion === 2
+                ? compileRequiredEvidence(effectivePolicy, adopted.contract?.tests ?? [], reviewFix)
+                : null;
             const attempt = {
                 attempt_id: `ATT-${taskId}-${Date.now()}-${++attemptSeq}`,
                 task_id: taskId, state: "active",
                 task_structure_digest: structureDigest,
                 contract_mode: contractMode,
                 contract: adopted.contract,
-                tdd_required: taskInfo.tddRequired,
-                no_tdd_reason: taskInfo.noTddReason,
+                ...(requiredEvidence ? { required_evidence: requiredEvidence } : {
+                    // 历史模式以及 v1 契约轮继续使用 task 行标记回放；v2 只消费快照。
+                    tdd_required: taskInfo.tddRequired,
+                    no_tdd_reason: taskInfo.noTddReason,
+                }),
+                // REVIEW-FIX 没有计划阶段测试契约，但有效证据要求仍由本轮冻结策略编译。
+                execution_policy: effectivePolicy,
                 declared_write_scope: [], pre_edit_source_fingerprint: null,
                 pre_edit_red_ref: null, executor_packet_digest: null,
                 executor_result_ref: null, post_edit_green_ref: null,
@@ -667,7 +743,9 @@ export function taskStart(projectRoot, change, changeRoot, taskId) {
                 details: {
                     attempt_id: attempt.attempt_id,
                     task_id: taskId,
+                    execution_policy: effectivePolicy,
                     contract: adopted.contract,
+                    ...(requiredEvidence ? { required_evidence: requiredEvidence } : {}),
                     // legacy 轮统一标注历史模式（无论有无执行依据文本）；契约轮无块时标 false（如 REVIEW-FIX）
                     ...(adopted.contract ? {} : { legacy_contract: !contractMode }),
                 },
@@ -676,6 +754,42 @@ export function taskStart(projectRoot, change, changeRoot, taskId) {
     });
 }
 // ===== reopen =====
+function abandonActiveTaskAttempts(snapshot, to, reason) {
+    return snapshot.active_task_attempts
+        .filter(attempt => attempt.state === "active")
+        .map(attempt => ({
+        type: "task_abandoned",
+        payload: {
+            attempt_id: attempt.attempt_id,
+            task_id: attempt.task_id,
+            reason: `reopen --to ${to}：${reason}`,
+        },
+    }));
+}
+function invalidateOpenJobs(snapshot, to, reason) {
+    return snapshot.open_jobs.map(job => ({
+        type: "job_invalidated",
+        payload: {
+            job_id: job.job_id,
+            role: job.role,
+            reason: `reopen --to ${to}：${reason}`,
+        },
+    }));
+}
+function planningReopenExtraEvents(snapshot, to, reason) {
+    return [
+        ...invalidateOpenJobs(snapshot, to, reason),
+        ...abandonActiveTaskAttempts(snapshot, to, reason),
+    ];
+}
+function canReopenToExplore(from) {
+    return from === "propose" || from === "propose_ready" || from === "apply" ||
+        from === "apply_done" || from === "review" || from === "accepted";
+}
+function canReopenToPropose(from) {
+    return from === "propose_ready" || from === "apply" || from === "apply_done" ||
+        from === "review" || from === "accepted";
+}
 export function reopen(projectRoot, change, changeRoot, to, reason, opts = {}) {
     return commitTransition(projectRoot, change, changeRoot, {
         name: "reopen", idempotencyInputs: { to, reason, reviewFix: opts.reviewFix ?? "", reviewFinding: opts.reviewFinding ?? "" },
@@ -751,22 +865,36 @@ export function reopen(projectRoot, change, changeRoot, to, reason, opts = {}) {
                     },
                 };
             }
+            if (to === "explore") {
+                if (!canReopenToExplore(snapshot.state)) {
+                    return { skip: true, message: `当前状态 ${snapshot.state}，不能 reopen 到 explore` };
+                }
+                return {
+                    fromState: snapshot.state,
+                    toState: "explore",
+                    outcome: "advanced",
+                    reason: reason.trim(),
+                    commitPayload: {
+                        reopen_target: "explore",
+                        reopen_source: snapshot.state,
+                        baseline_docs: discoveryDocsBaseline(changeRoot),
+                    },
+                    extraEvents: planningReopenExtraEvents(snapshot, "explore", reason.trim()),
+                };
+            }
             if (to === "propose") {
-                if (snapshot.state !== "accepted") {
-                    return {
-                        skip: true,
-                        message: `当前状态 ${snapshot.state}，主动 reopen --to propose 只允许从 accepted 发起；apply_done 的代码审查问题请使用 --review-finding`,
-                    };
+                if (!canReopenToPropose(snapshot.state)) {
+                    return { skip: true, message: `当前状态 ${snapshot.state}，不能 reopen 到 propose` };
                 }
-                if (snapshot.open_jobs.length > 0) {
+                if (snapshot.state === "accepted" && snapshot.open_jobs.length > 0) {
                     return {
                         blocked: true,
-                        reason: `状态未推进；accepted 仍有 ${snapshot.open_jobs.length} 个待完成工作项`,
+                        reason: `状态未推进；accepted 状态仍有 ${snapshot.open_jobs.length} 个待完成工作项`,
                         jobs: snapshot.open_jobs,
                     };
                 }
-                const acceptedBaseline = latestAcceptedProposalBaseline(events);
                 const currentBaseline = proposalDocsBaseline(changeRoot);
+                const acceptedBaseline = snapshot.state === "accepted" ? latestAcceptedProposalBaseline(events) : null;
                 // 旧版 accepted 事件的基线可能缺少后来纳入 Propose gate 的材料。保留其已冻结
                 // 的摘要，并用 reopen 当刻的摘要补齐缺项，确保本轮之后对任一审查目标的修改都能被检测。
                 const baselineNeedsBackfill = acceptedBaseline !== null && Object.keys(currentBaseline)
@@ -778,20 +906,21 @@ export function reopen(projectRoot, change, changeRoot, to, reason, opts = {}) {
                     ]))
                     : currentBaseline;
                 return {
-                    fromState: "accepted",
+                    fromState: snapshot.state,
                     toState: "propose",
                     outcome: "advanced",
                     reason: reason.trim(),
                     commitPayload: {
                         reopen_target: "propose",
-                        reopen_source: "accepted",
+                        reopen_source: snapshot.state,
                         baseline_source: acceptedBaseline ? (baselineNeedsBackfill ? "accepted_backfill" : "accepted") : "reopen_fallback",
                         baseline_docs: baselineDocs,
                     },
+                    extraEvents: planningReopenExtraEvents(snapshot, "propose", reason.trim()),
                 };
             }
             if (to !== "apply")
-                return { skip: true, message: `reopen 当前只支持 --to apply 或 --to propose，不支持 ${to}` };
+                return { skip: true, message: `reopen 当前只支持 --to explore、--to propose 或 --to apply，不支持 ${to}` };
             if (snapshot.state !== "apply_done" && snapshot.state !== "review") {
                 return { skip: true, message: `当前状态 ${snapshot.state}，不能 reopen 到 apply` };
             }
@@ -808,7 +937,7 @@ export function reopen(projectRoot, change, changeRoot, to, reason, opts = {}) {
     });
 }
 // ===== review-ready =====
-export function reviewReady(projectRoot, change, changeRoot, risk = "strict") {
+export function reviewReady(projectRoot, change, changeRoot, risk = workflowRiskForProject(projectRoot)) {
     return commitTransition(projectRoot, change, changeRoot, {
         name: "review-ready", idempotencyInputs: { phase: "review-ready", risk },
         decide: (snapshot) => {
@@ -863,6 +992,7 @@ export function reviewReady(projectRoot, change, changeRoot, risk = "strict") {
                         events,
                         snapshot,
                         boundary: "apply_to_review",
+                        risk: policy.review_risk,
                         decision: codeReviewDecision,
                     });
                 }
@@ -897,7 +1027,7 @@ export function accept(projectRoot, change, changeRoot) {
                 changeRoot,
                 events,
                 snapshot,
-                mode: { kind: "risk", risk: "strict" },
+                mode: { kind: "risk", risk: workflowRiskForProject(projectRoot) },
             });
             return transitionPlanToDecision(snapshot, changeRoot, change, plan, events);
         },
@@ -919,9 +1049,11 @@ export function taskComplete(projectRoot, change, changeRoot, taskId, inputConte
             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 completedPayload = {
                 task_id: taskId,
                 attempt_id: attempt.attempt_id,
+                execution_policy: attempt.execution_policy ?? "tdd",
                 ...boundarySnapshotPayload(projectRoot),
                 checkbox_update: { status: "pending" },
                 ...(scopeInput.value ? { scope_note: scopeInput.value } : {}),
@@ -930,7 +1062,8 @@ export function taskComplete(projectRoot, change, changeRoot, taskId, inputConte
                 fromState: "apply", toState: "apply", outcome: "advanced",
                 reason: `任务 ${taskId} 完成`,
                 extraEvents: [{ type: "task_completed", payload: completedPayload }],
-                postCommit: (_pr, _ch, cr) => {
+                postCommit: (pr, _ch, cr) => {
+                    completedPayload.java_staging = stageProductionJavaFilesSince(pr, taskStartBoundary);
                     const lines = readFileSync(join(cr, "tasks.md"), "utf8").split("\n");
                     const idx = findTaskLine(lines, taskId);
                     if (idx < 0) {

package/dist/types.d.ts

@@ -1,4 +1,6 @@
 export type State = "init" | "explore" | "propose" | "propose_ready" | "apply" | "apply_done" | "review" | "accepted" | "archive" | "abandoned";
+export type ExecutionPolicy = "tdd" | "green_only";
+export declare const GREEN_ONLY_NO_TDD_REASON = "green-only";
 export declare const PHASE1_STATES: ReadonlySet<State>;
 export type Ref = {
     path: string;
@@ -35,9 +37,19 @@ export interface ExecutionContract {
     tests: string[];
     design: string | null;
     source: string[];
-    reason: string | null;
+    acceptance: string | null;
     guard: string | null;
 }
+/**
+ * task-start 将计划中的声明和本轮已冻结策略编译出的有效证据要求。
+ * 这是 attempt 的不可变快照；Apply 与 task-complete 只消费它，不再解释任务行的 TDD 标记。
+ */
+export interface EffectiveEvidencePlan {
+    test_ids: string[];
+    red_required: boolean;
+    green_required: boolean;
+    accepted_green_statuses: Array<"expected_success" | "characterization_pass">;
+}
 export interface DirtyFileFingerprint {
     path: string;
     status: "added" | "modified" | "deleted";
@@ -69,9 +81,11 @@ export interface CodeStateCheck {
 export interface TaskExecutionIndexEntry {
     task_id: string;
     attempt_id: string;
+    execution_policy: ExecutionPolicy;
     changed_paths: string[] | null;
     changed_paths_partial_reason?: string;
     contract: ExecutionContract | null;
+    required_evidence: EffectiveEvidencePlan | null;
     declared_tests: string[];
     scope_note: Record<string, unknown> | null;
     test_evidence: Record<string, unknown>[];
@@ -169,8 +183,14 @@ export interface TransitionCommitPayload {
         material_digest: string;
         scope: string;
         decision_event_id: string;
+        review_risk?: "minimal" | "normal" | "strict";
     };
     accepted_baseline_docs?: Record<string, string>;
+    /** Propose-ready / start-apply 写入的本轮 workflow mode，后续阶段只读该快照。 */
+    workflow_mode?: "minimal" | "normal" | "strict";
+    /** v2 起所有普通任务必须有五字段执行依据；缺失表示旧 change，沿用旧规则回放。 */
+    execution_requirement_version?: 2;
+    execution_policy?: ExecutionPolicy;
 }
 export interface Snapshot {
     change_id: string;
@@ -195,8 +215,11 @@ export interface TaskAttempt {
     task_structure_digest: string;
     contract?: ExecutionContract | null;
     contract_mode?: boolean;
+    /** task-start 编译出的有效执行要求；缺失表示历史 attempt，按旧字段回放。 */
+    required_evidence?: EffectiveEvidencePlan | null;
     tdd_required?: boolean;
     no_tdd_reason?: string | null;
+    execution_policy?: ExecutionPolicy;
     declared_write_scope: string[];
     pre_edit_source_fingerprint: string | null;
     pre_edit_red_ref: string | null;

package/dist/types.js

@@ -1,3 +1,4 @@
 // SuperSpec 流程引擎 — 核心类型定义
+export const GREEN_ONLY_NO_TDD_REASON = "green-only";
 // Phase 1 只实现前 4 个
 export const PHASE1_STATES = new Set(["init", "explore", "propose", "propose_ready"]);

package/dist/workflow_config.d.ts

@@ -0,0 +1,24 @@
+import type { ReviewRisk } from "./review.ts";
+import type { Event, State } from "./types.ts";
+export declare const WORKFLOW_CONFIG_PATH = ".superspec/config.json";
+/** 新安装项目写入配置时采用的默认档位。 */
+export declare const DEFAULT_WORKFLOW_RISK: ReviewRisk;
+export declare class WorkflowConfigError extends Error {
+    constructor(message: string);
+}
+/**
+ * Propose-ready 是一个 planning round 的冻结点。配置只影响尚未冻结的计划；
+ * 已就绪计划必须沿用当时的 mode，直到 reopen 回到 propose 后创建新 round。
+ */
+export declare function workflowRiskForProposeRound(events: Event[], fallback: ReviewRisk): ReviewRisk;
+/** 是否已经由当前引擎在 propose-ready 冻结 mode；缺失时是历史 planning round。 */
+export declare function hasFrozenWorkflowModeForProposeRound(events: Event[]): boolean;
+/** Apply round 从 start-apply 起冻结；兼容首批事件中只写 review_policy 的格式。 */
+export declare function workflowRiskForApplyRound(events: Event[], fallback: ReviewRisk): ReviewRisk;
+/** 供阶段确认和登记共用，避免任何调用者从 JSON/CLI 注入本轮 mode。 */
+export declare function workflowRiskForState(events: Event[], state: State, fallback: ReviewRisk): ReviewRisk;
+/**
+ * 读取项目默认模式。新安装项目由配置提供 normal；缺少配置的旧项目保留 strict。
+ * 配置格式：{ "workflow": { "mode": "normal" } }
+ */
+export declare function workflowRiskForProject(projectRoot: string): ReviewRisk;