@peterxiaoyang/superspec 0.1.44 → 0.1.45

package/dist/phase_plan.js

@@ -8,11 +8,14 @@ import { isReviewReadyVerifier, isFreshReviewVerifier, historicalProposeReadyRol
 import { CODE_REVIEW_DECISION_ANSWER_LABELS, CODE_REVIEW_REPAIR_SCOPE_PREFIX, codeReviewDecisionScope, codeReviewJobStaleReason, collectCodeReviewGateFacts, currentCodeReviewWorkingPaths, latestCodeReviewFailedStatus, requiresFinalVerifierForCurrentReview, scanCodeChangesForReview, } from "./code_review.js";
 import { isPhaseAdvanceAuthorized, latestAcceptedPhaseDecision, phaseConfirmationCommitPayload, phaseConfirmationForBoundary, phaseConfirmationMissingMessage, } from "./phase_confirmation.js";
 import { taskEvidenceReadiness } from "./task_evidence.js";
+import { workflowRiskForProposeRound, workflowRiskForState } from "./workflow_config.js";
 function requiredJobs(state, jobs, reason) {
     return { kind: "required_jobs", state, jobs, reason };
 }
 function phaseConfirmationStep(context, boundary, reason) {
-    const confirmation = phaseConfirmationForBoundary(context.projectRoot, context.events, context.snapshot, boundary, context.mode.risk);
+    // 进入 propose_ready / apply 后，mode 来自本轮快照而非当前配置。
+    const risk = workflowRiskForState(context.events, context.snapshot.state, context.mode.risk);
+    const confirmation = phaseConfirmationForBoundary(context.projectRoot, context.events, context.snapshot, boundary, risk);
     if (!confirmation || isPhaseAdvanceAuthorized(context.events, confirmation))
         return null;
     return {
@@ -85,14 +88,26 @@ function validateTasksPlan(changeRoot) {
         return "tasks.md 内容不像任务计划文档";
     return null;
 }
-function validateExecutionRequirementPlan(changeRoot) {
+export function executionPolicyForRisk(risk) {
+    return risk === "strict" ? "tdd" : "green_only";
+}
+export function executionPolicyForCurrentRound(events) {
+    const index = latestStartApplyIndex(events);
+    if (index < 0)
+        return "tdd";
+    const payload = events[index].payload;
+    return payload.execution_policy === "green_only" || payload.execution_policy === "tdd"
+        ? payload.execution_policy
+        : "tdd";
+}
+function validateExecutionRequirementPlan(changeRoot, executionPolicy, executionRequirementVersion = 2) {
     const tasksPath = join(changeRoot, "tasks.md");
     if (!existsSync(tasksPath))
         return { ok: true, mode: false };
     const tasksContent = readFileSync(tasksPath, "utf8");
     const testContractPath = join(changeRoot, ".superspec", "artifacts", "test-contract.md");
     const testContractContent = existsSync(testContractPath) ? readFileSync(testContractPath, "utf8") : null;
-    const validation = validateExecutionRequirements(tasksContent, testContractContent);
+    const validation = validateExecutionRequirements(tasksContent, testContractContent, executionPolicy, executionRequirementVersion);
     return validation.ok
         ? { ok: true, mode: validation.mode }
         : { ok: false, mode: validation.mode, message: validation.errors.join("；") };
@@ -116,6 +131,15 @@ export function proposalDocsBaseline(changeRoot) {
     }
     return baseline;
 }
+export function discoveryDocsBaseline(changeRoot) {
+    // 与 Explore gate 使用同一组审查目标。回退到 explore 后，至少要更新一项
+    // discovery 材料，才允许重新进入 propose，避免把一次纯状态回退误当作新探索轮次。
+    const baseline = {};
+    for (const doc of EXPLORE_DISCOVERY_REVIEW_GATE.reviewTargets) {
+        baseline[doc] = docRef(changeRoot, doc).sha;
+    }
+    return baseline;
+}
 function isDigestMap(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
@@ -152,10 +176,28 @@ export function latestReopenProposeBaseline(events) {
     }
     return null;
 }
+export function latestReopenExploreBaseline(events) {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const ev = events[i];
+        if (ev.event_type !== "transition_commit")
+            continue;
+        const payload = ev.payload;
+        if (payload.transition !== "reopen" || payload.reopen_target !== "explore")
+            continue;
+        if (!payload.baseline_docs || typeof payload.baseline_docs !== "object" || Array.isArray(payload.baseline_docs))
+            return null;
+        return payload.baseline_docs;
+    }
+    return null;
+}
 export function proposalDocsChangedSinceBaseline(changeRoot, baseline) {
     const current = proposalDocsBaseline(changeRoot);
     return Object.entries(baseline).some(([path, digest]) => current[path] !== digest);
 }
+export function discoveryDocsChangedSinceBaseline(changeRoot, baseline) {
+    const current = discoveryDocsBaseline(changeRoot);
+    return Object.entries(baseline).some(([path, digest]) => current[path] !== digest);
+}
 export function pendingTaskIds(changeRoot) {
     const tasksContent = readFileSync(join(changeRoot, "tasks.md"), "utf8");
     return pendingTasksInContent(tasksContent).map(task => task.taskId);
@@ -171,6 +213,27 @@ function latestStartApplyIndex(events) {
     }
     return -1;
 }
+function executionRequirementVersionFromPayload(payload) {
+    return payload.execution_requirement_version === 2 ? 2 : 1;
+}
+/** 当前 Apply round 的规则版本；缺失版本的历史 event 保持 v1 回放。 */
+export function executionRequirementVersionForCurrentRound(events) {
+    const index = latestStartApplyIndex(events);
+    return index < 0 ? 1 : executionRequirementVersionFromPayload(events[index].payload);
+}
+/** Propose-ready 的规则版本决定随后 start-apply 是否采用新的全任务声明要求。 */
+function executionRequirementVersionForProposeRound(events) {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const event = events[i];
+        if (event.event_type !== "transition_commit")
+            continue;
+        const payload = event.payload;
+        if (payload.transition === "propose-ready" && payload.to_state === "propose_ready") {
+            return executionRequirementVersionFromPayload(event.payload);
+        }
+    }
+    return 1;
+}
 export function applyRequirementModeForCurrentRound(events) {
     const index = latestStartApplyIndex(events);
     if (index < 0)
@@ -238,14 +301,13 @@ export function pendingTaskStatusForApply(changeRoot, events) {
 export function formatPendingTaskMessage(ids, action) {
     return `尚有未完成任务：${ids.join(", ")}；${action}`;
 }
-function nextArgv(change, risk) {
+function nextArgv(change, _risk) {
     return [
         "superspec",
         "transition",
         "next",
         "--change",
         change,
-        ...(risk === "strict" ? [] : ["--risk", risk]),
     ];
 }
 function acceptedMaterialFollowup(change, risk, planDocsChangedSinceAccept) {
@@ -281,6 +343,15 @@ export function planNextStep(context) {
             }
             return { kind: "run_transition", state: "init", transition: "explore", reason: "初始化完成，开始探索" };
         case "explore": {
+            const reopenBaseline = latestReopenExploreBaseline(events);
+            if (reopenBaseline && !discoveryDocsChangedSinceBaseline(changeRoot, reopenBaseline)) {
+                return {
+                    kind: "run_transition",
+                    state: "explore",
+                    transition: "explore",
+                    reason: "回到 explore 后至少一个 discovery 材料必须变化",
+                };
+            }
             const exploreReviewJobs = EXPLORE_DISCOVERY_REVIEW_GATE.openJobsForGate(snapshot);
             if (exploreReviewJobs.length > 0) {
                 return requiredJobs("explore", exploreReviewJobs, `有 ${exploreReviewJobs.length} 个待完成探索审查工作项`);
@@ -352,6 +423,16 @@ export function planNextStep(context) {
                 if (confirmation)
                     return confirmation;
             }
+            // 尚未获得用户确认时，按本次 next 的候选风险预检失败不能退回默认 strict
+            // 的 start-apply 命令；否则 normal/minimal 的策略不匹配会被静默改写为 strict。
+            if (startApplyPlan.kind === "skip") {
+                const ask = {
+                    question: `${startApplyPlan.message}。请更新计划材料后重新执行 next。`,
+                    allowed_answers: ["计划已更新"],
+                    scope: "propose_apply_preflight",
+                };
+                return { kind: "ask_user", state: "propose_ready", ask, reason: startApplyPlan.message };
+            }
             return { kind: "run_transition", state: "propose_ready", transition: "start-apply", reason: "计划就绪，开始执行" };
         }
         case "apply":
@@ -628,6 +709,10 @@ function planExploreTransition(context) {
     if (snapshot.state !== "explore") {
         return { kind: "skip", message: `当前状态 ${snapshot.state}，explore 不适用` };
     }
+    const reopenBaseline = latestReopenExploreBaseline(events);
+    if (reopenBaseline && !discoveryDocsChangedSinceBaseline(changeRoot, reopenBaseline)) {
+        return { kind: "skip", message: "回到 explore 后至少一个 discovery 材料必须变化" };
+    }
     const discoveryCheck = validateDiscovery(changeRoot);
     if (!discoveryCheck.ok)
         return { kind: "skip", message: discoveryCheck.message };
@@ -656,7 +741,7 @@ function planProposeReadyTransition(context) {
     const tasksPlanError = validateTasksPlan(changeRoot);
     if (tasksPlanError)
         return { kind: "skip", message: tasksPlanError };
-    const executionRequirementPlan = validateExecutionRequirementPlan(changeRoot);
+    const executionRequirementPlan = validateExecutionRequirementPlan(changeRoot, executionPolicyForRisk(risk), 2);
     if (!executionRequirementPlan.ok)
         return { kind: "skip", message: executionRequirementPlan.message };
     const openQuestions = collectProposeOpenQuestions(changeRoot);
@@ -676,8 +761,17 @@ function planProposeReadyTransition(context) {
         fromState: "propose",
         toState: "propose_ready",
         reason: `risk=${risk}，所有需求已满足`,
+        payload: {
+            workflow_mode: risk,
+            execution_requirement_version: 2,
+        },
     };
 }
+function acceptedProposeToApplyConfirmation(context, risk) {
+    const confirmation = phaseConfirmationForBoundary(context.projectRoot, context.events, context.snapshot, "propose_to_apply", risk);
+    const decision = confirmation ? latestAcceptedPhaseDecision(context.events, confirmation) : null;
+    return confirmation && decision?.decision === "advance" ? { confirmation, decision } : null;
+}
 function planStartApplyTransition(context, enforceConfirmation = true) {
     const { changeRoot, events, projectRoot, snapshot } = context;
     if (snapshot.state !== "propose_ready")
@@ -687,23 +781,31 @@ function planStartApplyTransition(context, enforceConfirmation = true) {
         // 按基线实际键名提示：升级前留下的旧基线可能不含 specs/，静态清单会误导
         return { kind: "skip", message: `回到 propose 后至少一个计划文档必须变化（基线绑定：${Object.keys(reopenBaseline).join("、")}）` };
     }
-    const reviewedRoles = historicalProposeReadyRoles(events);
-    if (reviewedRoles.length > 0) {
-        const gatePlan = reviewGatePlan(snapshot, events, changeRoot, PROPOSE_FINAL_REVIEW_GATE, reviewedRoles);
-        if (gatePlan) {
-            return {
-                ...gatePlan,
-                reason: `进入执行阶段前需要重新完成计划文档审查：${gatePlan.reason}`,
-            };
-        }
+    const risk = workflowRiskForProposeRound(events, context.mode.risk);
+    const executionRequirementVersion = executionRequirementVersionForProposeRound(events);
+    const requiredRoles = executionRequirementVersion === 2
+        ? PROPOSE_FINAL_REVIEW_GATE.requiredRolesForRisk(risk)
+        : historicalProposeReadyRoles(events);
+    const gatePlan = reviewGatePlan(snapshot, events, changeRoot, PROPOSE_FINAL_REVIEW_GATE, requiredRoles);
+    if (gatePlan) {
+        return {
+            ...gatePlan,
+            reason: `进入执行阶段前需要重新完成计划文档审查：${gatePlan.reason}`,
+        };
     }
-    const executionRequirementPlan = validateExecutionRequirementPlan(changeRoot);
+    const acceptedConfirmation = enforceConfirmation
+        ? acceptedProposeToApplyConfirmation(context, risk)
+        : null;
+    const executionPolicy = executionPolicyForRisk(risk);
+    const executionRequirementPlan = validateExecutionRequirementPlan(changeRoot, executionPolicy, executionRequirementVersion);
     if (!executionRequirementPlan.ok)
         return { kind: "skip", message: executionRequirementPlan.message };
-    const confirmation = phaseConfirmationForBoundary(projectRoot, events, snapshot, "propose_to_apply");
-    const decision = confirmation ? latestAcceptedPhaseDecision(events, confirmation) : null;
-    if (enforceConfirmation && (!confirmation || decision?.decision !== "advance")) {
-        return { kind: "skip", message: confirmation ? phaseConfirmationMissingMessage(confirmation) : "无法建立 Propose 阶段确认范围" };
+    if (enforceConfirmation && !acceptedConfirmation) {
+        const confirmation = phaseConfirmationForBoundary(projectRoot, events, snapshot, "propose_to_apply", risk);
+        return {
+            kind: "skip",
+            message: confirmation ? phaseConfirmationMissingMessage(confirmation) : "无法建立 Propose 阶段确认范围",
+        };
     }
     const gitHead = currentGitHead(projectRoot);
     return {
@@ -715,7 +817,14 @@ function planStartApplyTransition(context, enforceConfirmation = true) {
             apply_start_head: gitHead.head,
             apply_start_head_reason: gitHead.reason,
             apply_contract_mode: executionRequirementPlan.mode,
-            ...(confirmation && decision?.decision === "advance" ? phaseConfirmationCommitPayload(confirmation, decision) : {}),
+            ...(executionRequirementVersion === 2 ? { execution_requirement_version: 2 } : {}),
+            execution_policy: executionPolicy,
+            workflow_mode: risk,
+            review_policy: {
+                review_risk: risk,
+                requires_verifier: risk !== "minimal",
+            },
+            ...(acceptedConfirmation ? phaseConfirmationCommitPayload(acceptedConfirmation.confirmation, acceptedConfirmation.decision) : {}),
         },
     };
 }

package/dist/record.d.ts

@@ -7,7 +7,7 @@ export declare function recordJobSubmitContent(projectRoot: string, change: stri
 export declare function recordUserDecision(projectRoot: string, change: string, inputFile: string): RecordResult;
 /** record user-decision：从 JSON 内容登记用户决策 */
 export declare function recordUserDecisionContent(projectRoot: string, change: string, content: string): RecordResult;
-/** jobs list（HIGH-1 修复：从 transition_commit.new_jobs 提取，不再依赖已删除的 job_requested 事件） */
+/** jobs list（job 从 transition_commit.new_jobs 提取；reopen 可用 job_invalidated 关闭未完成工作项） */
 export declare function jobsList(projectRoot: string, change: string): {
     open: Job[];
     accepted: Job[];

package/dist/record.js

@@ -4,7 +4,7 @@ import { isAbsolute, join, relative, resolve } from "node:path";
 import { ensureChangeLayout, readEvents, appendEvent, makeEvent, sha256File, sha256Text, withLock, appendRawRecord, } from "./store.js";
 import { rebuildSnapshot } from "./sync.js";
 import { changeRoot as openspecChangeRoot } from "./openspec.js";
-import { isPhaseConfirmationScope, phaseActionForAnswer, phaseConfirmationForCurrentState, } from "./phase_confirmation.js";
+import { isPhaseConfirmationScope, phaseActionForAnswer, phaseConfirmationForCurrentState, workflowRiskForPhaseConfirmation, } from "./phase_confirmation.js";
 import { CODE_REVIEW_DECISION_ANSWER_LABELS, CODE_REVIEW_DECISION_SCOPE_PREFIX, codeReviewDecisionAnswerLabel, normalizeCodeReviewDecisionAnswer, } from "./code_review.js";
 import { invalidReasonForSubmittedReport } from "./job_validity.js";
 import { jobSubmitArgv } from "./job_action.js";
@@ -346,6 +346,10 @@ function jobTerminalState(events, jobId) {
     }
     return null;
 }
+function jobInvalidated(events, jobId) {
+    return events.some(ev => ev.event_type === "job_invalidated" &&
+        ev.payload.job_id === jobId);
+}
 function terminalJobSubmitResult(events, jobId, terminal, reportDigest) {
     const existing = events.find(e => (e.event_type === "job_accepted" || e.event_type === "job_rejected")
         && e.payload.job_id === jobId
@@ -547,6 +551,9 @@ export function recordJobSubmit(projectRoot, change, changeRoot, jobId, reportFi
         if (!job) {
             return { event_type: "job_rejected", accepted: false, message: `工作项 ${jobId} 不存在` };
         }
+        if (jobInvalidated(events, jobId)) {
+            return { accepted: false, message: `工作项 ${jobId} 已因回退到更早阶段失效，不接受新报告。` };
+        }
         const terminal = jobTerminalState(events, jobId);
         if (terminal) {
             const reportDigest = sha256File(reportFile) ?? "sha256:unknown";
@@ -584,6 +591,9 @@ export function recordJobSubmitContent(projectRoot, change, changeRoot, jobId, r
         if (!job) {
             return { event_type: "job_rejected", accepted: false, message: `工作项 ${jobId} 不存在` };
         }
+        if (jobInvalidated(events, jobId)) {
+            return { accepted: false, message: `工作项 ${jobId} 已因回退到更早阶段失效，不接受新报告。` };
+        }
         const reportDigest = sha256Text(reportContent);
         const terminal = jobTerminalState(events, jobId);
         if (terminal) {
@@ -639,14 +649,9 @@ function recordUserDecisionLoaded(projectRoot, change, events, content, inputDig
         });
         const changeRoot = openspecChangeRoot(projectRoot, change);
         const snapshot = rebuildSnapshot(projectRoot, change, changeRoot);
-        const decisionRisk = decision.review_risk === undefined
-            ? "strict"
-            : decision.review_risk === "minimal" || decision.review_risk === "normal" || decision.review_risk === "strict"
-                ? decision.review_risk
-                : null;
-        const current = decisionRisk
-            ? phaseConfirmationForCurrentState(projectRoot, events, snapshot, decisionRisk)
-            : null;
+        // mode 是状态机从配置/round 快照推导的输入，不接受 user-decision JSON 注入。
+        const decisionRisk = workflowRiskForPhaseConfirmation(projectRoot, events, snapshot);
+        const current = phaseConfirmationForCurrentState(projectRoot, events, snapshot, decisionRisk);
         if (existingAccepted &&
             current?.scope === decision.scope &&
             latestAcceptedForScope?.event_id === existing.event_id) {
@@ -657,17 +662,15 @@ function recordUserDecisionLoaded(projectRoot, change, events, content, inputDig
             };
         }
         const action = current ? phaseActionForAnswer(current, decision.answer) : null;
-        const rejectionReason = !decisionRisk
-            ? "invalid_phase_confirmation_risk"
-            : !current
-                ? "phase_confirmation_not_pending"
-                : decision.scope !== current.scope
-                    ? "stale_phase_confirmation_scope"
-                    : !action
-                        ? "invalid_phase_confirmation_answer"
-                        : action.reason === "required" && !nonEmptyString(decision.reason)
-                            ? "missing_phase_confirmation_reason"
-                            : null;
+        const rejectionReason = !current
+            ? "phase_confirmation_not_pending"
+            : decision.scope !== current.scope
+                ? "stale_phase_confirmation_scope"
+                : !action
+                    ? "invalid_phase_confirmation_answer"
+                    : action.reason === "required" && !nonEmptyString(decision.reason)
+                        ? "missing_phase_confirmation_reason"
+                        : null;
         if (rejectionReason) {
             if (existing &&
                 existing.payload.accepted === false &&
@@ -687,11 +690,9 @@ function recordUserDecisionLoaded(projectRoot, change, events, content, inputDig
             }));
             const message = rejectionReason === "invalid_phase_confirmation_answer" && current
                 ? `阶段确认答复必须精确为：${current.ask.allowed_answers.join("、")}`
-                : rejectionReason === "invalid_phase_confirmation_risk"
-                    ? "阶段确认 review_risk 必须是 minimal、normal 或 strict"
-                    : rejectionReason === "missing_phase_confirmation_reason" && action
-                        ? action.reason_prompt ?? "当前选择必须写明原因"
-                        : "阶段确认已失效或当前没有待确认的阶段边界，请重新执行 next";
+                : rejectionReason === "missing_phase_confirmation_reason" && action
+                    ? action.reason_prompt ?? "当前选择必须写明原因"
+                    : "阶段确认已失效或当前没有待确认的阶段边界，请重新执行 next";
             return { event_type: "user_decision_recorded", accepted: false, message };
         }
         phaseConfirmation = current;
@@ -857,7 +858,7 @@ export function recordUserDecisionContent(projectRoot, change, content) {
         return recordUserDecisionLoaded(projectRoot, change, events, content, sha256Text(content));
     });
 }
-/** jobs list（HIGH-1 修复：从 transition_commit.new_jobs 提取，不再依赖已删除的 job_requested 事件） */
+/** jobs list（job 从 transition_commit.new_jobs 提取；reopen 可用 job_invalidated 关闭未完成工作项） */
 export function jobsList(projectRoot, change) {
     const events = readEvents(projectRoot, change);
     const open = [];
@@ -888,6 +889,12 @@ export function jobsList(projectRoot, change) {
                 open.splice(idx, 1)[0];
             rejected.push({ job_id, role });
         }
+        else if (ev.event_type === "job_invalidated") {
+            const { job_id } = ev.payload;
+            const idx = open.findIndex(j => j.job_id === job_id);
+            if (idx >= 0)
+                open.splice(idx, 1);
+        }
     }
     return { open, accepted, rejected };
 }
@@ -898,8 +905,9 @@ function packetFieldDescriptions() {
         boundFiles: "本工作项绑定的文件清单；审查报告必须说明这些文件是否都看过。",
         review_scope: "报告中的审查覆盖范围；普通 reviewer/verifier 用 checked_paths 回执全部绑定文件，code-reviewer 还需按专用协议说明未检查项。",
         code_review_scope: "代码审查范围：从已审基点到当前 HEAD 的提交改动、工作区改动和未跟踪代码文件。",
-        task_execution_index: "按任务汇总的执行证据：每个任务（task）的执行依据、声明测试、测试证据和改动文件。",
-        contract: "任务启动时的执行依据快照：tests/design/source/reason/guard 分别对应 测试/设计/来源/原因/边界；null 表示历史任务没有执行依据。",
+        task_execution_index: "按任务汇总的执行证据：每个任务（task）的执行依据、有效证据要求、声明测试、测试证据和改动文件。",
+        contract: "任务启动时的执行依据快照：tests/design/source/acceptance/guard 分别对应 测试/设计/来源/验收/边界；null 表示历史任务没有执行依据。",
+        required_evidence: "task-start 结合冻结策略编译并写入 attempt 的有效证据要求：test_ids、red_required、green_required 和允许的 GREEN 语义状态；null 表示历史任务按旧记录回放。",
         changed_paths: "与某个任务（task）或代码状态检查相关的改动文件。",
         changed_paths_partial_reason: "该任务（task）的提交段 diff 失败原因；存在时 changed_paths 只包含工作区对比结果，归属可能不完整。",
         unattributed_paths: "代码审查范围中暂时无法归属到某个任务（task）的文件。",
@@ -974,10 +982,10 @@ export function jobsPacket(projectRoot, change, jobId) {
                     ? `最小格式：{"role":"code-reviewer","verdict":"pass|fail","review_scope":{"job_id":"${job.job_id}","packet_digest":"${job.packet_digest}","checked_paths":${JSON.stringify(job.boundFiles.map(f => f.path))},"checked_docs":${JSON.stringify(REVIEW_DOC_PATHS)},"unchecked":[]},"findings":[],"reviewer":{"kind":"codex-subagent","id":"<thread-or-agent-id>"}}；审查覆盖范围（review_scope）用来说明本次审查覆盖了哪些文件和文档，已检查路径（checked_paths）与未检查项（unchecked）必须合起来覆盖全部绑定文件（boundFiles），unchecked 条目格式为 {"path":"<path>","reason":"<reason>"}。`
                         + `报告结论为 fail 时，问题列表（findings）至少包含一个可处理、可追溯的阻塞问题，字段为 {"id":"<stable-id>","blocking":true,"type":"implementation|spec|mixed","description":"<what>","evidence":"<why>","source_refs":["<path:line>"],"impact":"<impact>","suggested_action":"apply|propose"}。问题类型（type）中 implementation 表示纯代码实现问题，spec 表示方案/需求文档问题，mixed 表示需要使用者判断的混合问题。`
                         + (packetContext?.task_execution_index
-                            ? `本工作项带任务执行索引（task_execution_index）：按 task 对照其执行依据快照（contract）审查——实现路线对照 design 引用原文、累计 diff 对照 guard 边界、测试断言对照 tests 声明的 scenario；每项的 scope_note 是执行者登记的范围扩大说明，判断其合理性与验证充分性；changed_paths 是归属线索不是结论（null 表示未知）；unattributed_paths 中的无主改动逐个判断合理性；coverage_exemption_refs 解释未绑定 task 的 TEST 豁免。`
+                            ? `本工作项带任务执行索引（task_execution_index）：按 task 对照其执行依据快照（contract）审查——实现路线对照 design 引用原文、累计 diff 对照 guard 边界、测试断言对照 tests 声明的 scenario；每项的 required_evidence 是 task-start 冻结的证据口径，red_required/green_required 分别说明是否需要 RED/GREEN；每项的 scope_note 是执行者登记的范围扩大说明，判断其合理性与验证充分性；changed_paths 是归属线索不是结论（null 表示未知）；unattributed_paths 中的无主改动逐个判断合理性；coverage_exemption_refs 解释未绑定 task 的 TEST 豁免。`
                             : "")
                     : job.role === "verifier"
-                        ? `最小格式：{"role":"verifier","verdict":"pass|fail","findings":[]${hasReviewScope ? `,"review_scope":{"checked_paths":${JSON.stringify(job.boundFiles.map(file => file.path))}}` : ""}}。核对代码审查记录（code_review_gate）：passed 必须能追溯到已接受的代码审查工作项，skipped 必须能证明本次没有代码类改动。核对代码审查问题闭环：实现修复任务必须带审查修复引用（review_fix_of:<job_id>#<problem_id>），方案/混合问题必须有用户决策或后续修复证据。核对 RED/GREEN：证据须在同一已完成任务的任务尝试 ID（task_completed.attempt_id）下闭环——普通 TDD 任务至少一个同 TEST 先 RED（expected_failure）后 GREEN（expected_success）配对且每个声明 TEST 都有 GREEN；特征化任务（no_tdd_reason:characterization）可用 characterization_pass 作为通过证据，不要求 RED；测试运行证据应包含测试 ID（test_id）、命令（command）、工作目录（cwd）、退出码（exit_code）、语义状态（semantic_status）；审查修复的回归测试运行可用回归覆盖任务列表（covers_task_ids）说明覆盖了哪些已完成任务；缺少任务尝试 ID（attempt_id）的旧证据只能弱引用。` +
+                        ? `最小格式：{"role":"verifier","verdict":"pass|fail","findings":[]${hasReviewScope ? `,"review_scope":{"checked_paths":${JSON.stringify(job.boundFiles.map(file => file.path))}}` : ""}}。核对代码审查记录（code_review_gate）：passed 必须能追溯到已接受的代码审查工作项，skipped 必须能证明本次没有代码类改动。核对代码审查问题闭环：实现修复任务必须带审查修复引用（review_fix_of:<job_id>#<problem_id>），方案/混合问题必须有用户决策或后续修复证据。按 task_execution_index 的 required_evidence 核对测试证据：red_required 时需要同一 TEST 的 RED（expected_failure）后 GREEN；green_required 时每个声明 TEST 都需要允许的 GREEN 语义状态；测试运行证据应包含测试 ID（test_id）、命令（command）、工作目录（cwd）、退出码（exit_code）、语义状态（semantic_status）。审查修复的回归测试运行可用回归覆盖任务列表（covers_task_ids）说明覆盖了哪些已完成任务；缺少任务尝试 ID（attempt_id）的旧证据只能弱引用。` +
                             (packetContext?.code_state_check
                                 ? `本工作项带代码状态检查（code_state_check）：head_matches 为 false 或 changed_paths 非空表示代码审查后代码又发生变化，须在报告中列出差异并交主流程与用户裁决，不自行判定无害，也不据此自动否定已接受的代码审查。`
                                 : "")

package/dist/review.js

@@ -42,11 +42,27 @@ function isReviewPolicy(value) {
         typeof obj.requires_verifier === "boolean");
 }
 export function readReviewPolicyFromEvents(events) {
-    for (const ev of events) {
+    // 新格式在 start-apply 写入，并且只能读取最新 Apply round 的策略。
+    // 回退到该 round 内的 review-ready，是为了回放升级前的历史 event。
+    let latestStartApplyIndex = -1;
+    for (let i = events.length - 1; i >= 0; i--) {
+        const event = events[i];
+        if (event.event_type !== "transition_commit")
+            continue;
+        const payload = event.payload;
+        if (payload.transition === "start-apply" && payload.to_state === "apply") {
+            latestStartApplyIndex = i;
+            break;
+        }
+    }
+    if (latestStartApplyIndex < 0)
+        return null;
+    for (let i = events.length - 1; i >= latestStartApplyIndex; i--) {
+        const ev = events[i];
         if (ev.event_type !== "transition_commit")
             continue;
         const payload = ev.payload;
-        if (payload.transition !== "review-ready")
+        if (payload.transition !== "start-apply" && payload.transition !== "review-ready")
             continue;
         if (isReviewPolicy(payload.review_policy))
             return payload.review_policy;

package/dist/sync.js

@@ -34,7 +34,8 @@ function replayEvents(events) {
                 }
                 break;
             }
-            // H4 修复：删除 job_requested / job_invalidated 死分支——job 只通过 transition_commit 的 new_jobs payload 创建，staleness 只在 sync 内存计算（不写事件）
+            // job 只通过 transition_commit 的 new_jobs payload 创建。reopen 到更早阶段时，
+            // 已绑定旧材料的待完成工作项会被 job_invalidated 关闭，避免阻塞新一轮 gate。
             case "job_accepted": {
                 const { job_id } = ev.payload;
                 const idx = openJobs.findIndex(j => j.job_id === job_id);
@@ -53,7 +54,13 @@ function replayEvents(events) {
                 }
                 break;
             }
-            // H4：job_invalidated 事件从不发射（删除死分支）
+            case "job_invalidated": {
+                const { job_id } = ev.payload;
+                const idx = openJobs.findIndex(j => j.job_id === job_id);
+                if (idx >= 0)
+                    openJobs.splice(idx, 1);
+                break;
+            }
             case "task_started": {
                 const attempt = ev.payload;
                 activeAttempts.push(attempt);
@@ -71,8 +78,10 @@ function replayEvents(events) {
             case "task_abandoned": {
                 const { attempt_id } = ev.payload;
                 const idx = activeAttempts.findIndex(a => a.attempt_id === attempt_id);
-                if (idx >= 0)
-                    activeAttempts.splice(idx, 1);
+                if (idx >= 0) {
+                    const [attempt] = activeAttempts.splice(idx, 1);
+                    taskStatuses[attempt.task_id] = "todo";
+                }
                 break;
             }
         }

package/dist/task.js

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { sha256Text, ensureChangeLayout, appendEvent, makeEvent, withLock, appendRawRecord, readEvents } from "./store.js";
 import { tasksStructureDigest as formatDigest } from "./format.js";
 import { RecordInputDecodingError, readRecordInputFile } from "./record_input.js";
+import { GREEN_ONLY_NO_TDD_REASON } from "./types.js";
 /** tasks.md 结构指纹（委托给 format.ts 统一实现） */
 export function tasksStructureDigestOf(changeRoot) {
     const p = join(changeRoot, "tasks.md");
@@ -124,16 +125,28 @@ function validateContractTestRunInput(tr, attempt) {
     if (!["expected_failure", "expected_success", "characterization_pass"].includes(tr.semantic_status)) {
         return { ok: false, message: "语义状态（semantic_status）必须是 expected_failure、expected_success 或 characterization_pass" };
     }
+    const requiredEvidence = attempt.required_evidence;
+    if (tr.semantic_status === "expected_failure" && requiredEvidence && !requiredEvidence.red_required) {
+        return { ok: false, message: "当前任务执行快照不要求 RED（expected_failure）；请登记声明 TEST 的 GREEN" };
+    }
+    if (tr.semantic_status === "expected_failure" && !requiredEvidence &&
+        attempt.execution_policy === "green_only" &&
+        attempt.no_tdd_reason === GREEN_ONLY_NO_TDD_REASON) {
+        return { ok: false, message: "GREEN-only 任务不登记 RED（expected_failure）；请在实现后登记声明 TEST 的 GREEN" };
+    }
     if (tr.semantic_status === "expected_failure" && tr.exit_code === 0) {
         return { ok: false, message: "RED 预期失败（expected_failure）要求退出码（exit_code）非 0" };
     }
     if ((tr.semantic_status === "expected_success" || tr.semantic_status === "characterization_pass") && tr.exit_code !== 0) {
         return { ok: false, message: `语义状态（semantic_status=${tr.semantic_status}）要求退出码（exit_code）为 0` };
     }
-    if (tr.semantic_status === "characterization_pass" && !(attempt.tdd_required === false && attempt.no_tdd_reason === "characterization")) {
+    if (tr.semantic_status === "characterization_pass" && requiredEvidence && !requiredEvidence.accepted_green_statuses.includes("characterization_pass")) {
+        return { ok: false, message: "当前任务执行快照不接受特征化通过（characterization_pass）" };
+    }
+    if (tr.semantic_status === "characterization_pass" && !requiredEvidence && !(attempt.tdd_required === false && attempt.no_tdd_reason === "characterization")) {
         return { ok: false, message: "特征化通过（characterization_pass）只适用于无需 TDD 的特征化任务（tdd_required:false，no_tdd_reason:characterization）" };
     }
-    const declaredTests = attempt.contract?.tests ?? [];
+    const declaredTests = requiredEvidence?.test_ids ?? attempt.contract?.tests ?? [];
     if (declaredTests.length > 0 && !declaredTests.includes(tr.test_id)) {
         return { ok: false, message: `测试 ID（test_id=${tr.test_id}）不属于当前任务契约声明的测试列表` };
     }

package/dist/task_evidence.d.ts

@@ -1,4 +1,4 @@
-import type { TaskAttempt } from "./types.ts";
+import { type TaskAttempt } from "./types.ts";
 export type TaskEvidenceReadiness = {
     ready: true;
     missing: [];