@peterxiaoyang/superspec 0.1.44 → 0.1.46

package/dist/phase_plan.js

@@ -1,18 +1,22 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { EXPLORE_DISCOVERY_REVIEW_GATE, PROPOSE_FINAL_REVIEW_GATE } from "./review_job_gates.js";
-import { collectProposeOpenQuestions, countDiscoveryOpenQuestions, parseTasksMd, pendingTasksInContent, validateDiscovery, validateExecutionRequirements, } from "./format.js";
+import { collectProposeOpenQuestions, countDiscoveryOpenQuestions, parseExecutionRequirements, parseTasksMd, pendingTasksInContent, validateDiscovery, validateExecutionRequirements, validateExecutionRequirementDocumentReferences, validateProposalImpact, validateTasksDocument, } from "./format.js";
 import { currentGitHead } from "./git_state.js";
+import { validateOpenSpecChange } from "./openspec.js";
 import { docRef, sha256File } from "./store.js";
 import { isReviewReadyVerifier, isFreshReviewVerifier, historicalProposeReadyRoles, readReviewPolicyFromEvents, reviewGateRoleResolution, reviewRejectionOverrideScope, reviewEvidenceDigest, } from "./review.js";
 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 {
@@ -76,23 +80,41 @@ function reviewGatePlan(snapshot, events, changeRoot, gate, requiredRoles) {
     }
     return null;
 }
-function validateTasksPlan(changeRoot) {
+function validateTasksPlan(changeRoot, executionRequirementVersion) {
     const tasksPath = join(changeRoot, "tasks.md");
     if (!existsSync(tasksPath))
         return "tasks.md 不存在";
     const tasksContent = readFileSync(tasksPath, "utf8");
-    if (!tasksContent.includes("# Tasks") && !tasksContent.includes("- [ ]"))
-        return "tasks.md 内容不像任务计划文档";
+    if (executionRequirementVersion === 1) {
+        return tasksContent.includes("# Tasks") || tasksContent.includes("- [ ]")
+            ? null
+            : "tasks.md 内容不像任务计划文档";
+    }
+    const errors = validateTasksDocument(tasksContent);
+    if (errors.length > 0)
+        return errors.join("；");
     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("；") };
@@ -107,6 +129,43 @@ function missingBaseArtifact(changeRoot, risk) {
     }
     return null;
 }
+/** OpenSpec strict gate 只在当前 planning round 冻结为 strict 时执行。 */
+function validateOpenSpecPlanningDocuments(projectRoot, change, changeRoot, profile) {
+    if (profile == null || profile.openspec.mode !== "strict")
+        return null;
+    const currentConfigDigest = sha256File(join(projectRoot, "openspec", "config.yaml"));
+    if (currentConfigDigest !== profile.openspec.config_digest) {
+        return "OpenSpec 配置自本 planning round 起已变化；请恢复原配置或 reopen --to propose 创建新的计划轮";
+    }
+    const tasksPath = join(changeRoot, "tasks.md");
+    const referenceErrors = validateExecutionRequirementDocumentReferences(changeRoot, parseExecutionRequirements(readFileSync(tasksPath, "utf8")));
+    if (referenceErrors.length > 0)
+        return referenceErrors.join("；");
+    const proposalPath = join(changeRoot, "proposal.md");
+    if (!existsSync(proposalPath))
+        return "proposal.md 不存在";
+    const impact = validateProposalImpact(readFileSync(proposalPath, "utf8"));
+    if (!impact.ok)
+        return impact.message;
+    const native = validateOpenSpecChange(projectRoot, change);
+    return native.ok ? null : native.message;
+}
+function validatePlanningPreflight(projectRoot, change, changeRoot, risk, executionPolicy, profile) {
+    const executionRequirementVersion = profile?.version ?? 1;
+    const tasksPlanError = validateTasksPlan(changeRoot, executionRequirementVersion);
+    if (tasksPlanError)
+        return { error: tasksPlanError, contractMode: false };
+    const executionRequirementPlan = validateExecutionRequirementPlan(changeRoot, executionPolicy, executionRequirementVersion);
+    if (!executionRequirementPlan.ok)
+        return { error: executionRequirementPlan.message, contractMode: false };
+    const missingArtifact = missingBaseArtifact(changeRoot, risk);
+    if (missingArtifact)
+        return { error: missingArtifact, contractMode: false };
+    return {
+        error: validateOpenSpecPlanningDocuments(projectRoot, change, changeRoot, profile),
+        contractMode: executionRequirementPlan.mode,
+    };
+}
 export function proposalDocsBaseline(changeRoot) {
     // 与 Propose gate 的可修改审查目标保持同一来源：specs/ 用目录聚合指纹，避免 reopen 基线漏掉任一个可修改的计划材料。
     const docs = PROPOSE_FINAL_REVIEW_GATE.reviewTargets;
@@ -116,6 +175,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 +220,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 +257,83 @@ 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;
+}
+function isPlanningValidationProfile(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const profile = value;
+    if (profile.version !== 2 || !profile.openspec || typeof profile.openspec !== "object")
+        return false;
+    return profile.openspec.mode === "disabled" ||
+        profile.openspec.mode === "strict" && typeof profile.openspec.config_digest === "string";
+}
+/** 新 planning round 在进入 propose 时冻结当前 OpenSpec 校验契约。 */
+export function planningValidationProfileForNewRound(projectRoot) {
+    const configDigest = sha256File(join(projectRoot, "openspec", "config.yaml"));
+    return configDigest == null
+        ? { version: 2, openspec: { mode: "disabled" } }
+        : { version: 2, openspec: { mode: "strict", config_digest: configDigest } };
+}
+/** propose 状态尚未 ready 时，从进入本 planning round 的事件读取冻结 profile。 */
+function planningValidationProfileForPendingProposeRound(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;
+        // 只读取“进入 propose”的边界事件。propose-ready 创建审查 job 时也会
+        // 保持在 propose；若把它误当作新的 planning round，便会覆盖此前冻结的
+        // profile 并把当前轮错误降级为 v1。
+        const entersPropose = payload.to_state === "propose" && (payload.transition === "explore" ||
+            payload.transition === "propose" ||
+            payload.transition === "reopen" && payload.reopen_target === "propose");
+        if (!entersPropose)
+            continue;
+        return isPlanningValidationProfile(payload.planning_validation_profile)
+            ? payload.planning_validation_profile
+            : null;
+    }
+    return null;
+}
+/** 已完成 propose-ready 的 round 只回放当时冻结的 profile。 */
+function planningValidationProfileForReadyProposeRound(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")
+            continue;
+        if (isPlanningValidationProfile(payload.planning_validation_profile))
+            return payload.planning_validation_profile;
+        // 过渡期已写 v2 执行依据、但尚未带 profile 的事件保持 v2 tasks 契约，
+        // 但不在 start-apply 追溯新增 strict gate。
+        return executionRequirementVersionFromPayload(event.payload) === 2
+            ? { version: 2, openspec: { mode: "disabled" } }
+            : null;
+    }
+    return null;
+}
 export function applyRequirementModeForCurrentRound(events) {
     const index = latestStartApplyIndex(events);
     if (index < 0)
@@ -238,14 +401,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 +443,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 +523,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 +809,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 };
@@ -645,7 +830,11 @@ function planExploreTransition(context) {
         fromState: "explore",
         toState: "propose",
         reason: "探索完成",
-        payload: phaseConfirmationCommitPayload(confirmation, decision),
+        payload: {
+            ...phaseConfirmationCommitPayload(confirmation, decision),
+            planning_validation_version: 2,
+            planning_validation_profile: planningValidationProfileForNewRound(projectRoot),
+        },
     };
 }
 function planProposeReadyTransition(context) {
@@ -653,20 +842,15 @@ function planProposeReadyTransition(context) {
     const risk = mode.risk;
     if (snapshot.state !== "propose")
         return { kind: "skip", message: `当前状态 ${snapshot.state}，不能 propose-ready` };
-    const tasksPlanError = validateTasksPlan(changeRoot);
-    if (tasksPlanError)
-        return { kind: "skip", message: tasksPlanError };
-    const executionRequirementPlan = validateExecutionRequirementPlan(changeRoot);
-    if (!executionRequirementPlan.ok)
-        return { kind: "skip", message: executionRequirementPlan.message };
+    const planningProfile = planningValidationProfileForPendingProposeRound(context.events);
+    const preflight = validatePlanningPreflight(context.projectRoot, context.change, changeRoot, risk, executionPolicyForRisk(risk), planningProfile);
+    if (preflight.error)
+        return { kind: "skip", message: preflight.error };
     const openQuestions = collectProposeOpenQuestions(changeRoot);
     if (openQuestions.openCount > 0) {
         const files = openQuestions.files.map(f => `${f.path}(${f.openCount})`).join(", ");
         return { kind: "skip", message: `计划文档有 ${openQuestions.openCount} 个待用户确认问题：${files}` };
     }
-    const missingArtifact = missingBaseArtifact(changeRoot, risk);
-    if (missingArtifact)
-        return { kind: "skip", message: missingArtifact };
     const requiredRoles = PROPOSE_FINAL_REVIEW_GATE.requiredRolesForRisk(risk);
     const gatePlan = reviewGatePlan(snapshot, context.events, changeRoot, PROPOSE_FINAL_REVIEW_GATE, requiredRoles);
     if (gatePlan)
@@ -676,8 +860,21 @@ function planProposeReadyTransition(context) {
         fromState: "propose",
         toState: "propose_ready",
         reason: `risk=${risk}，所有需求已满足`,
+        payload: {
+            workflow_mode: risk,
+            ...(planningProfile ? {
+                execution_requirement_version: 2,
+                planning_validation_version: 2,
+                planning_validation_profile: planningProfile,
+            } : {}),
+        },
     };
 }
+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 +884,32 @@ 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 planningProfile = planningValidationProfileForReadyProposeRound(events);
+    const executionRequirementVersion = planningProfile?.version ?? executionRequirementVersionForProposeRound(events);
+    const executionPolicy = executionPolicyForRisk(risk);
+    const preflight = validatePlanningPreflight(projectRoot, context.change, changeRoot, risk, executionPolicy, planningProfile);
+    if (preflight.error)
+        return { kind: "skip", message: preflight.error };
+    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);
-    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 阶段确认范围" };
+    const acceptedConfirmation = enforceConfirmation
+        ? acceptedProposeToApplyConfirmation(context, risk)
+        : null;
+    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 {
@@ -714,8 +920,15 @@ function planStartApplyTransition(context, enforceConfirmation = true) {
         payload: {
             apply_start_head: gitHead.head,
             apply_start_head_reason: gitHead.reason,
-            apply_contract_mode: executionRequirementPlan.mode,
-            ...(confirmation && decision?.decision === "advance" ? phaseConfirmationCommitPayload(confirmation, decision) : {}),
+            apply_contract_mode: preflight.contractMode,
+            ...(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;