@peterxiaoyang/superspec 0.1.42 → 0.1.44

package/dist/format.d.ts

@@ -40,7 +40,6 @@ export interface ParsedExecutionRequirement {
 export interface TestContractEntry {
     test_id: string;
     scenario: string;
-    invariant: string;
 }
 export type TestContractParseResult = {
     ok: true;

package/dist/format.js

@@ -320,7 +320,6 @@ export function parseTestContractEntries(content) {
         if (!isMarkdownTableSeparator(lines[i + 1]))
             continue;
         sawMatchingHeader = true;
-        const invariantIdx = normalizedHeader.indexOf("invariant");
         for (let rowIndex = i + 2; rowIndex < lines.length; rowIndex++) {
             const row = splitMarkdownTableRow(lines[rowIndex]);
             if (row.length === 0)
@@ -335,7 +334,6 @@ export function parseTestContractEntries(content) {
             entries.push({
                 test_id: testId,
                 scenario: (row[scenarioIdx] ?? "").trim(),
-                invariant: invariantIdx >= 0 ? (row[invariantIdx] ?? "").trim() : "",
             });
         }
     }
@@ -450,21 +448,13 @@ export function validateUserDecision(d) {
         return { ok: false, message: "决策文件缺少答复内容（answer）" };
     return { ok: true, message: "" };
 }
-// ===== business-invariants.md =====
-//
-// 格式（propose skill 定义）：
-//   # Business Invariants
-//   - INV-001 用户密码必须加密存储
-//
-// 引擎行为：Phase 1-5 只校验文件存在性（轻量）。
-// 内部结构（INV-XXX 编号）是 agent 指引，引擎不逐行解析。
 // ===== test-contract.md =====
 //
 // 格式（propose skill 定义）：
 //   # Test Contract
-//   | test_id | invariant | scenario |
-//   |---|---|---|
-//   | TEST-001 | INV-001 | 注册时密码被加密 |
+//   | test_id | scenario |
+//   |---|---|
+//   | TEST-001 | 注册时密码被加密 |
 //
 // 引擎行为：Phase 1-5 只校验文件存在性（轻量）。
 // 表格结构是 agent 指引，引擎不逐行解析。

package/dist/git_state.js

@@ -3,7 +3,7 @@ import { existsSync, lstatSync, readdirSync, readlinkSync, statSync } from "node
 import { extname, join } from "node:path";
 import { sha256File, sha256Text } from "./store.js";
 const PROCESS_DOC_RE = /^(?:openspec\/changes\/[^/]+\/)?(?:proposal|design|tasks)\.md$/;
-const PROCESS_ARTIFACT_RE = /^(?:openspec\/changes\/[^/]+\/)?\.superspec\/artifacts\/(?:discovery|business-invariants|test-contract)\.md$/;
+const PROCESS_ARTIFACT_RE = /^(?:openspec\/changes\/[^/]+\/)?\.superspec\/artifacts\/(?:discovery|test-contract)\.md$/;
 const CODE_EXTENSIONS = new Set([
     ".c", ".cc", ".cpp", ".cs", ".css", ".go", ".h", ".hpp", ".html", ".java", ".js", ".jsx",
     ".json", ".kt", ".mjs", ".mts", ".php", ".py", ".rb", ".rs", ".scss", ".sh", ".sql",

package/dist/phase_confirmation.js

@@ -1,5 +1,7 @@
 import { currentGitHead, dirtyCodeFiles } from "./git_state.js";
-import { reviewEvidenceDigest } from "./review.js";
+import { historicalProposeReadyRoles, reviewEvidenceDigest, reviewGateRoleResolution } from "./review.js";
+import { EXPLORE_DISCOVERY_REVIEW_GATE, PROPOSE_FINAL_REVIEW_GATE } from "./review_job_gates.js";
+import { changeRoot as openspecChangeRoot } from "./openspec.js";
 import { findLatestEvent, sha256Text } from "./store.js";
 export const PHASE_CONFIRMATION_SCOPE_PREFIX = "phase_confirmation:";
 function latestTransition(events, predicate) {
@@ -63,7 +65,12 @@ function boundaryForState(state) {
         default: return null;
     }
 }
-function materialDigest(projectRoot, events, snapshot) {
+function ordinaryReviewRolesForBoundary(events, boundary, gate, risk) {
+    return boundary === "propose_to_apply"
+        ? historicalProposeReadyRoles(events)
+        : gate.requiredRolesForRisk(risk);
+}
+function materialDigest(projectRoot, events, snapshot, boundary, risk) {
     const head = currentGitHead(projectRoot);
     const dirty = dirtyCodeFiles(projectRoot);
     const acceptedJobs = snapshot.accepted_jobs
@@ -77,10 +84,31 @@ function materialDigest(projectRoot, events, snapshot) {
         .sort((a, b) => a.job_id.localeCompare(b.job_id));
     const documents = Object.entries(snapshot.document_digests)
         .sort(([left], [right]) => left.localeCompare(right));
+    const ordinaryReviewGate = boundary === "explore_to_propose"
+        ? EXPLORE_DISCOVERY_REVIEW_GATE
+        : boundary === "propose_to_apply"
+            ? PROPOSE_FINAL_REVIEW_GATE
+            : null;
+    const currentChangeRoot = openspecChangeRoot(projectRoot, snapshot.change_id);
+    const overriddenReviewJobs = ordinaryReviewGate
+        ? ordinaryReviewRolesForBoundary(events, boundary, ordinaryReviewGate, risk)
+            .map(role => reviewGateRoleResolution(events, currentChangeRoot, ordinaryReviewGate, role))
+            .filter(resolution => resolution.kind === "overridden")
+            .map(resolution => ({
+            job_id: resolution.override.job_id,
+            role: resolution.override.role,
+            gate_id: resolution.override.gate_id,
+            packet_digest: resolution.override.packet_digest,
+            decision_event_id: resolution.override.decision_event_id,
+            decision_event_digest: resolution.override.decision_event_digest,
+        }))
+            .sort((left, right) => `${left.gate_id}\u0000${left.role}\u0000${left.job_id}`.localeCompare(`${right.gate_id}\u0000${right.role}\u0000${right.job_id}`))
+        : [];
     return sha256Text(JSON.stringify({
         documents,
         tasks_structure_digest: snapshot.tasks_structure_digest,
         accepted_jobs: acceptedJobs,
+        ...(overriddenReviewJobs.length > 0 ? { overridden_review_jobs: overriddenReviewJobs } : {}),
         review_evidence_digest: reviewEvidenceDigest(events),
         code_state: {
             head: head.head,
@@ -126,7 +154,7 @@ function buildActions(change, boundary, scope, question, specs, risk) {
         reason: spec.reason,
         ...(spec.reasonPrompt ? { reason_prompt: spec.reasonPrompt } : {}),
         record_argv: phaseRecordArgv(change),
-        record_input: { scope, question, answer: spec.label },
+        record_input: { scope, question, answer: spec.label, review_risk: risk },
         resume: spec.resume.kind === "next"
             ? { kind: "next", argv: nextArgv(change, risk) }
             : spec.resume.kind === "continue_current_phase"
@@ -147,7 +175,7 @@ export function phaseConfirmationForBoundary(projectRoot, events, snapshot, boun
         return null;
     const epoch = spec.epoch(events);
     const epochEventId = epoch?.event_id ?? `legacy-${spec.state}`;
-    const digest = materialDigest(projectRoot, events, snapshot);
+    const digest = materialDigest(projectRoot, events, snapshot, boundary, risk);
     const scope = `${spec.scopePrefix}:${epochEventId}:${digest}`;
     const actions = buildActions(snapshot.change_id, boundary, scope, spec.question, spec.actions, risk);
     return {

package/dist/phase_plan.d.ts

@@ -64,6 +64,7 @@ export type TransitionDecisionPlan = {
     kind: "blocked";
     jobs: Job[];
     reason: string;
+    details?: Record<string, unknown>;
 } | {
     kind: "create_gate_jobs";
     gate: ReviewGateRule;
@@ -86,7 +87,6 @@ export declare function proposalDocsBaseline(changeRoot: string): Record<string,
 export declare function latestAcceptedProposalBaseline(events: Event[]): Record<string, string> | null;
 export declare function latestReopenProposeBaseline(events: Event[]): Record<string, string> | null;
 export declare function proposalDocsChangedSinceBaseline(changeRoot: string, baseline: Record<string, string>): boolean;
-export declare function historicalProposeReadyRoles(events: Event[]): JobRole[];
 export declare function pendingTaskIds(changeRoot: string): string[];
 export declare function applyRequirementModeForCurrentRound(events: Event[]): boolean;
 export declare function pendingTaskStatusForApply(changeRoot: string, events: Event[]): ApplyPendingTaskStatus;

package/dist/phase_plan.js

@@ -4,7 +4,7 @@ import { EXPLORE_DISCOVERY_REVIEW_GATE, PROPOSE_FINAL_REVIEW_GATE } from "./revi
 import { collectProposeOpenQuestions, countDiscoveryOpenQuestions, parseTasksMd, pendingTasksInContent, validateDiscovery, validateExecutionRequirements, } from "./format.js";
 import { currentGitHead } from "./git_state.js";
 import { docRef, sha256File } from "./store.js";
-import { isReviewReadyVerifier, isFreshReviewVerifier, readReviewPolicyFromEvents, reviewEvidenceDigest, } from "./review.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";
@@ -22,16 +22,49 @@ function phaseConfirmationStep(context, boundary, reason) {
         reason,
     };
 }
-function reviewGatePlan(snapshot, gate, requiredRoles) {
+function reviewGatePlan(snapshot, events, changeRoot, gate, requiredRoles) {
     const missingRoles = [];
     for (const role of requiredRoles) {
         const openForRole = snapshot.open_jobs.find(job => gate.isJobForGate(job) && job.role === role);
         if (openForRole) {
             return { kind: "blocked", reason: `状态未推进；已有待完成工作项 ${role}（${openForRole.job_id}）`, jobs: [openForRole] };
         }
-        const acceptedForRole = snapshot.accepted_jobs.find(job => gate.isJobForGate(job) && job.role === role);
-        if (!acceptedForRole)
-            missingRoles.push({ role, reason: `需求 ${role} 无已接受的工作项` });
+        const resolution = reviewGateRoleResolution(events, changeRoot, gate, role);
+        if (resolution.kind === "accepted" || resolution.kind === "overridden")
+            continue;
+        if (resolution.kind === "rejected_pending") {
+            const terminal = resolution.terminal;
+            const overrideScope = reviewRejectionOverrideScope(terminal.job.job_id);
+            return {
+                kind: "blocked",
+                jobs: [],
+                reason: `状态未推进；${role} 审查工作项 ${terminal.job.job_id} 已拒绝。请修改绑定材料、在整份报告没有有效 blocker 时登记整体裁决，或在涉及业务决定时询问用户`,
+                details: {
+                    review_rejection: {
+                        job_id: terminal.job.job_id,
+                        role,
+                        gate_id: gate.gate_id,
+                        packet_digest: terminal.job.packet_digest,
+                        result_kind: terminal.result_kind,
+                        reason: terminal.reason ?? "报告结论为 fail，工作项未通过",
+                        override_scope: overrideScope,
+                        allowed_actions: ["modify_materials", "record_override", "ask_user"],
+                        record_input: {
+                            scope: overrideScope,
+                            answer: "do_not_block",
+                            reason: "<说明整份报告为何没有有效 blocker>",
+                            decision_source: "main_process",
+                        },
+                    },
+                },
+            };
+        }
+        const reason = resolution.kind === "stale"
+            ? `需求 ${role} 的最新审查工作项已过期：${resolution.stale_reason}`
+            : resolution.kind === "rejected_invalid"
+                ? `需求 ${role} 的最新审查报告无效，不能通过整体裁决绕过`
+                : `需求 ${role} 无已接受的工作项`;
+        missingRoles.push({ role, reason });
     }
     if (missingRoles.length > 0) {
         return {
@@ -68,7 +101,7 @@ function missingBaseArtifact(changeRoot, risk) {
     if (risk === "minimal")
         return null;
     const artifactsDir = join(changeRoot, ".superspec", "artifacts");
-    for (const doc of ["discovery.md", "business-invariants.md", "test-contract.md"]) {
+    for (const doc of ["discovery.md", "test-contract.md"]) {
         if (!existsSync(join(artifactsDir, doc)))
             return `基础职责缺失：${doc} 不存在（risk=${risk} 需要）`;
     }
@@ -123,20 +156,6 @@ export function proposalDocsChangedSinceBaseline(changeRoot, baseline) {
     const current = proposalDocsBaseline(changeRoot);
     return Object.entries(baseline).some(([path, digest]) => current[path] !== digest);
 }
-export function historicalProposeReadyRoles(events) {
-    const roles = new Set();
-    for (const ev of events) {
-        if (ev.event_type !== "transition_commit")
-            continue;
-        const newJobs = ev.payload.new_jobs ?? [];
-        for (const job of newJobs) {
-            if (PROPOSE_FINAL_REVIEW_GATE.isJobForGate(job) &&
-                (job.role === "critic" || job.role === "architect" || job.role === "test-engineer"))
-                roles.add(job.role);
-        }
-    }
-    return [...roles];
-}
 export function pendingTaskIds(changeRoot) {
     const tasksContent = readFileSync(join(changeRoot, "tasks.md"), "utf8");
     return pendingTasksInContent(tasksContent).map(task => task.taskId);
@@ -286,7 +305,7 @@ export function planNextStep(context) {
                 return { kind: "ask_user", state: "explore", ask, reason: `有 ${openQs} 个未确认问题` };
             }
             const requiredRoles = EXPLORE_DISCOVERY_REVIEW_GATE.requiredRolesForRisk(mode.risk);
-            if (!reviewGatePlan(snapshot, EXPLORE_DISCOVERY_REVIEW_GATE, requiredRoles)) {
+            if (!reviewGatePlan(snapshot, events, changeRoot, EXPLORE_DISCOVERY_REVIEW_GATE, requiredRoles)) {
                 const confirmation = phaseConfirmationStep(context, "explore_to_propose", "探索完成，等待用户确认进入计划阶段");
                 if (confirmation)
                     return confirmation;
@@ -613,10 +632,10 @@ function planExploreTransition(context) {
     if (!discoveryCheck.ok)
         return { kind: "skip", message: discoveryCheck.message };
     const requiredRoles = EXPLORE_DISCOVERY_REVIEW_GATE.requiredRolesForRisk(mode.risk);
-    const gatePlan = reviewGatePlan(snapshot, EXPLORE_DISCOVERY_REVIEW_GATE, requiredRoles);
+    const gatePlan = reviewGatePlan(snapshot, events, changeRoot, EXPLORE_DISCOVERY_REVIEW_GATE, requiredRoles);
     if (gatePlan)
         return gatePlan;
-    const confirmation = phaseConfirmationForBoundary(projectRoot, events, snapshot, "explore_to_propose");
+    const confirmation = phaseConfirmationForBoundary(projectRoot, events, snapshot, "explore_to_propose", mode.risk);
     const decision = confirmation ? latestAcceptedPhaseDecision(events, confirmation) : null;
     if (!confirmation || decision?.decision !== "advance") {
         return { kind: "skip", message: confirmation ? phaseConfirmationMissingMessage(confirmation) : "无法建立 Explore 阶段确认范围" };
@@ -649,10 +668,15 @@ function planProposeReadyTransition(context) {
     if (missingArtifact)
         return { kind: "skip", message: missingArtifact };
     const requiredRoles = PROPOSE_FINAL_REVIEW_GATE.requiredRolesForRisk(risk);
-    const gatePlan = reviewGatePlan(snapshot, PROPOSE_FINAL_REVIEW_GATE, requiredRoles);
+    const gatePlan = reviewGatePlan(snapshot, context.events, changeRoot, PROPOSE_FINAL_REVIEW_GATE, requiredRoles);
     if (gatePlan)
         return gatePlan;
-    return { kind: "advance", fromState: "propose", toState: "propose_ready", reason: `risk=${risk}，所有需求已满足` };
+    return {
+        kind: "advance",
+        fromState: "propose",
+        toState: "propose_ready",
+        reason: `risk=${risk}，所有需求已满足`,
+    };
 }
 function planStartApplyTransition(context, enforceConfirmation = true) {
     const { changeRoot, events, projectRoot, snapshot } = context;
@@ -665,7 +689,7 @@ function planStartApplyTransition(context, enforceConfirmation = true) {
     }
     const reviewedRoles = historicalProposeReadyRoles(events);
     if (reviewedRoles.length > 0) {
-        const gatePlan = reviewGatePlan(snapshot, PROPOSE_FINAL_REVIEW_GATE, reviewedRoles);
+        const gatePlan = reviewGatePlan(snapshot, events, changeRoot, PROPOSE_FINAL_REVIEW_GATE, reviewedRoles);
         if (gatePlan) {
             return {
                 ...gatePlan,

package/dist/record.js

@@ -8,7 +8,7 @@ import { isPhaseConfirmationScope, phaseActionForAnswer, phaseConfirmationForCur
 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";
-import { REVIEW_DOC_PATHS } from "./review.js";
+import { REVIEW_DOC_PATHS, REVIEW_REJECTION_OVERRIDE_SCOPE_PREFIX, REVIEW_REJECTION_OVERRIDE_ANSWER, parseReviewRejectionOverrideScope, reviewGateRoleResolution, reviewRejectionOverrideScope, } from "./review.js";
 import { EXPLORE_DISCOVERY_REVIEW_GATE, PROPOSE_FINAL_REVIEW_GATE } from "./review_job_gates.js";
 import { RecordInputDecodingError, readRecordInputFile } from "./record_input.js";
 const REVIEW_REPORT_REQUIRED_FIELDS = ["role", "verdict", "findings"];
@@ -63,8 +63,8 @@ function previousRejectionInstruction(job) {
         return "";
     const reason = `上一次同角色审查没有形成可推进结论，原因：${previous.reason}。`;
     if (!previous.findings || previous.findings.length === 0)
-        return `${reason}完成全部材料覆盖和角色分析后，再针对该原因复核，`;
-    return `${reason}完成全部材料覆盖和角色分析后，再逐项复核本工作项附带的上一次同角色审查尚未闭环问题：同一问题仍存在时复用原 finding ID；legacy finding 没有 ID 时沿用其原始语义并补一个稳定 ID；已解决的问题不要重复报告，不得通过更换 ID、标题或措辞重复同一问题；新增问题必须提供与历史问题不同的具体证据。`;
+        return `${reason}本轮是修复复核；完整读取材料只用于核对当前修正和直接一致性，不得借复核重新审计与修正无关的历史设计，`;
+    return `${reason}本轮是修复复核：逐项判断本工作项附带的上一次同角色 finding 是否仍成立。Finding 中的 recommendation 只是非绑定建议，不是需求或验收标准；先独立核对 underlying problem、直接证据和本次验收，不得因原建议指定了某种架构就要求照做。同一问题仍存在时复用原 finding ID；legacy finding 没有 ID 时沿用其原始语义并补一个稳定 ID；已解决或已由等价证据闭环的问题不要重复报告，不得通过更换 ID、标题或措辞重复同一问题。默认只复核历史 finding；新 blocker 仅允许是本次修正直接引入的回归，并必须说明“修正动作 → 新问题”的因果链，不得展开无关的故障模型、消费者或架构议题。`;
 }
 function ordinaryReviewerFindingInstruction(job) {
     if (!isOrdinaryReviewer(job.role))
@@ -90,14 +90,14 @@ function reviewScopeInstruction(job, reviewTargets, readOnlyRefs) {
     }
     const targets = reviewTargets.length > 0 ? `本 gate 可提出修改建议的审查目标为 ${reviewTargets.join(", ")}。` : "";
     const refs = readOnlyRefs.length > 0
-        ? `只读上游引用为 ${readOnlyRefs.join(", ")}；只允许读取和核对一致性，不得要求在当前阶段修改、追加、删除、重排或格式化这些文件，不得把修改只读引用列为本阶段 required fix。只读引用自身的缺失、错误或矛盾可在 risks 或 open_questions 中上报给主流程，但不得单独作为本 gate 的 fail。只有能定位到审查目标的不一致，才能作为 fail 并指向该审查目标的修复。`
+        ? `只读上游引用为 ${readOnlyRefs.join(", ")}；只允许读取和核对一致性，不得要求在当前阶段修改、追加、删除、重排或格式化这些文件。只读引用中与本次目标或绑定上游事实无直接因果关系的历史质量问题不得作为本 gate 的 fail。如果本次审查目标或 boundFiles 中绑定的上游事实直接造成变更包跨文档不一致，并且会影响明确验收或实施落地，可以 fail；finding 必须锚定为当前变更包未完成一致性闭环，required outcome 只要求消除矛盾，不得指定必须修改哪份文档或采用哪种技术方案。`
         : "";
     return targets + refs;
 }
 function reviewCoverageInstruction(job) {
     if (!requiresReviewScope(job))
         return "";
-    return `审查顺序固定为：先建立覆盖索引，按文件和标题/行段完整浏览全部 boundFiles 至文件末尾；长文档必须分段读取，每段只保留短锚点和候选风险，不能在发现第一个 blocker 时提交。随后按本角色职责进行跨文件分析；最后才复核历史 findings 并去重，一次性提交当前快照下发现的全部 blocker。报告中的 review_scope.checked_paths 必须列出全部已浏览的 boundFiles；它只是覆盖回执，不能代替语义审查。`;
+    return `审查顺序固定为：先建立覆盖索引，按文件和标题/行段完整浏览全部 boundFiles 至文件末尾；长文档必须分段读取，不能在发现第一个 blocker 时停止覆盖。read_only_refs 按本次问题需要读取，用于核对目标与上下游一致性，不要求机械全文遍历或写入 checked_paths。完整读取只用于核对本次 change 的目标、直接修改及跨文档一致性，不等于允许重新审计全部历史设计。若 proposal.md 存在“需求变化”，以其中记录的受影响能力、直接修改章节和保持不变范围作为本轮增量审查的权威锚点；本轮新 finding 必须由该需求变化、为接入变化所做的直接修改，或这些修改造成的跨文档矛盾引起，并说明因果链。此前已通过且被明确记录为保持不变的设计不得重新打开为 blocker；不要凭通用风险类别猜测变化范围。注意事项和故障类别是条件式检查项，不是必须穷举的清单。Recommendation 只能描述需要补足的结果、契约或证据，不得把未经 proposal、design 或用户决定选定的新基础设施写成 required fix。报告中的 review_scope.checked_paths 必须列出全部已浏览的 boundFiles；它只是覆盖回执，不能代替语义审查，也不扩大可报告问题的范围。`;
 }
 function migrationEvidenceInstruction(job) {
     const isProposeReview = PROPOSE_FINAL_REVIEW_GATE.isJobForGate(job);
@@ -321,6 +321,21 @@ function findJob(events, jobId) {
     }
     return null;
 }
+function ordinaryReviewGateForJob(job) {
+    return [EXPLORE_DISCOVERY_REVIEW_GATE, PROPOSE_FINAL_REVIEW_GATE]
+        .find(gate => gate.isJobForGate(job)) ?? null;
+}
+function invalidReviewRejectionOverrideResult(projectRoot, change, inputDigest, decision, reason, message) {
+    appendEvent(projectRoot, change, makeEvent(change, "user_decision_recorded", {
+        accepted: false,
+        scope: decision.scope,
+        answer: decision.answer,
+        ...(decision.decision_source !== undefined ? { decision_source: decision.decision_source } : {}),
+        reason,
+        input_digest: inputDigest,
+    }));
+    return { event_type: "user_decision_recorded", accepted: false, message };
+}
 /** 检查 job 是否已终态 */
 function jobTerminalState(events, jobId) {
     for (const ev of events) {
@@ -610,6 +625,7 @@ function recordUserDecisionLoaded(projectRoot, change, events, content, inputDig
     }
     let phaseConfirmation = null;
     let phaseAction = null;
+    let phaseReviewRisk = null;
     if (isPhaseConfirmationScope(decision.scope)) {
         const existingAccepted = existing &&
             existing.payload.accepted !== false;
@@ -623,7 +639,14 @@ function recordUserDecisionLoaded(projectRoot, change, events, content, inputDig
         });
         const changeRoot = openspecChangeRoot(projectRoot, change);
         const snapshot = rebuildSnapshot(projectRoot, change, changeRoot);
-        const current = phaseConfirmationForCurrentState(projectRoot, events, snapshot);
+        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;
         if (existingAccepted &&
             current?.scope === decision.scope &&
             latestAcceptedForScope?.event_id === existing.event_id) {
@@ -634,15 +657,17 @@ function recordUserDecisionLoaded(projectRoot, change, events, content, inputDig
             };
         }
         const action = current ? phaseActionForAnswer(current, decision.answer) : 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;
+        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;
         if (rejectionReason) {
             if (existing &&
                 existing.payload.accepted === false &&
@@ -662,13 +687,16 @@ function recordUserDecisionLoaded(projectRoot, change, events, content, inputDig
             }));
             const message = rejectionReason === "invalid_phase_confirmation_answer" && current
                 ? `阶段确认答复必须精确为：${current.ask.allowed_answers.join("、")}`
-                : rejectionReason === "missing_phase_confirmation_reason" && action
-                    ? action.reason_prompt ?? "当前选择必须写明原因"
-                    : "阶段确认已失效或当前没有待确认的阶段边界，请重新执行 next";
+                : rejectionReason === "invalid_phase_confirmation_risk"
+                    ? "阶段确认 review_risk 必须是 minimal、normal 或 strict"
+                    : rejectionReason === "missing_phase_confirmation_reason" && action
+                        ? action.reason_prompt ?? "当前选择必须写明原因"
+                        : "阶段确认已失效或当前没有待确认的阶段边界，请重新执行 next";
             return { event_type: "user_decision_recorded", accepted: false, message };
         }
         phaseConfirmation = current;
         phaseAction = action;
+        phaseReviewRisk = decisionRisk;
     }
     if (existing && !phaseAction) {
         const accepted = existing.payload.accepted !== false;
@@ -678,6 +706,59 @@ function recordUserDecisionLoaded(projectRoot, change, events, content, inputDig
             message: accepted ? "幂等返回：同一用户决策已登记" : "幂等返回：同一无效用户决策已登记",
         };
     }
+    let reviewRejectionOverride = null;
+    let reviewRejectionDecisionSource = null;
+    if (decision.scope.startsWith(REVIEW_REJECTION_OVERRIDE_SCOPE_PREFIX)) {
+        const jobId = parseReviewRejectionOverrideScope(decision.scope);
+        if (!jobId) {
+            return invalidReviewRejectionOverrideResult(projectRoot, change, inputDigest, { scope: decision.scope, answer: decision.answer, decision_source: decision.decision_source }, "invalid_review_rejection_override_scope", "审查拒绝裁决 scope 必须包含有效 job ID");
+        }
+        if (decision.scope !== reviewRejectionOverrideScope(jobId)) {
+            return invalidReviewRejectionOverrideResult(projectRoot, change, inputDigest, { scope: decision.scope, answer: decision.answer, decision_source: decision.decision_source }, "invalid_review_rejection_override_scope", `审查拒绝裁决 scope 必须精确为 ${reviewRejectionOverrideScope(jobId)}`);
+        }
+        if (decision.answer !== REVIEW_REJECTION_OVERRIDE_ANSWER) {
+            return invalidReviewRejectionOverrideResult(projectRoot, change, inputDigest, { scope: decision.scope, answer: decision.answer, decision_source: decision.decision_source }, "invalid_review_rejection_override_answer", `审查拒绝裁决 answer 必须是 ${REVIEW_REJECTION_OVERRIDE_ANSWER}`);
+        }
+        if (decision.decision_source !== "main_process" && decision.decision_source !== "user") {
+            return invalidReviewRejectionOverrideResult(projectRoot, change, inputDigest, { scope: decision.scope, answer: decision.answer, decision_source: decision.decision_source }, "invalid_review_rejection_override_source", "审查拒绝裁决 decision_source 必须是 main_process 或 user");
+        }
+        if (!nonEmptyString(decision.reason)) {
+            return invalidReviewRejectionOverrideResult(projectRoot, change, inputDigest, { scope: decision.scope, answer: decision.answer, decision_source: decision.decision_source }, "missing_review_rejection_override_reason", "审查拒绝裁决必须写明原因");
+        }
+        const job = findJob(events, jobId);
+        const gate = job ? ordinaryReviewGateForJob(job) : null;
+        if (!job || !gate || !isOrdinaryReviewer(job.role)) {
+            return invalidReviewRejectionOverrideResult(projectRoot, change, inputDigest, { scope: decision.scope, answer: decision.answer, decision_source: decision.decision_source }, "review_rejection_override_job_not_found", "审查拒绝裁决必须指向当前 Explore / Propose gate 的普通 Reviewer job");
+        }
+        const changeRoot = openspecChangeRoot(projectRoot, change);
+        const snapshot = rebuildSnapshot(projectRoot, change, changeRoot);
+        const gateIsCurrent = gate.gate_id === EXPLORE_DISCOVERY_REVIEW_GATE.gate_id
+            ? snapshot.state === "explore"
+            : snapshot.state === "propose" || snapshot.state === "propose_ready";
+        if (!gateIsCurrent) {
+            return invalidReviewRejectionOverrideResult(projectRoot, change, inputDigest, { scope: decision.scope, answer: decision.answer, decision_source: decision.decision_source }, "review_rejection_override_gate_not_current", "审查拒绝裁决只能在对应 Explore / Propose gate 仍为当前阶段时登记");
+        }
+        const resolution = reviewGateRoleResolution(events, changeRoot, gate, job.role);
+        if (resolution.kind === "none" || resolution.terminal.job.job_id !== job.job_id) {
+            return invalidReviewRejectionOverrideResult(projectRoot, change, inputDigest, { scope: decision.scope, answer: decision.answer, decision_source: decision.decision_source }, "review_rejection_override_not_latest_terminal", "审查拒绝裁决只能指向当前 gate cycle 中该角色最新的 terminal job");
+        }
+        if (resolution.kind === "stale") {
+            return invalidReviewRejectionOverrideResult(projectRoot, change, inputDigest, { scope: decision.scope, answer: decision.answer, decision_source: decision.decision_source }, "stale_review_rejection_override_job", `审查拒绝裁决指向的 job 已过期：${resolution.stale_reason}`);
+        }
+        if (resolution.kind === "accepted") {
+            return invalidReviewRejectionOverrideResult(projectRoot, change, inputDigest, { scope: decision.scope, answer: decision.answer, decision_source: decision.decision_source }, "review_rejection_override_job_not_rejected", "审查拒绝裁决只能指向 rejected job");
+        }
+        if (resolution.kind === "rejected_invalid") {
+            return invalidReviewRejectionOverrideResult(projectRoot, change, inputDigest, { scope: decision.scope, answer: decision.answer, decision_source: decision.decision_source }, "review_rejection_override_not_review_failed", "只有 result_kind=review_failed 的拒绝报告可以裁决；无效报告必须修正后重新提交");
+        }
+        reviewRejectionOverride = {
+            job_id: job.job_id,
+            role: job.role,
+            gate_id: gate.gate_id,
+            packet_digest: job.packet_digest,
+        };
+        reviewRejectionDecisionSource = decision.decision_source;
+    }
     if (decision.scope.startsWith(CODE_REVIEW_DECISION_SCOPE_PREFIX)) {
         const normalizedAnswer = normalizeCodeReviewDecisionAnswer(decision.answer);
         if (!normalizedAnswer) {
@@ -721,10 +802,13 @@ function recordUserDecisionLoaded(projectRoot, change, events, content, inputDig
             ? phaseAction.label
             : normalizedAnswer ? codeReviewDecisionAnswerLabel(normalizedAnswer) : decision.answer,
         ...(typeof decision.reason === "string" ? { reason: decision.reason.trim() } : {}),
+        ...(reviewRejectionDecisionSource ? { decision_source: reviewRejectionDecisionSource } : {}),
+        ...(reviewRejectionOverride ? { review_rejection_override: reviewRejectionOverride } : {}),
         ...(phaseAction ? {
             phase_confirmation: {
                 boundary: phaseAction.boundary,
                 decision: phaseAction.decision,
+                review_risk: phaseReviewRisk ?? "strict",
             },
         } : {}),
     };

package/dist/review.d.ts

@@ -1,5 +1,5 @@
 import { type ReviewGateRule } from "./review_job_gates.ts";
-import type { Event, Job, JobRole, Ref, ReviewPreviousRejection } from "./types.ts";
+import type { CodeReviewResultKind, Event, Job, JobRole, Ref, ReviewPreviousRejection } from "./types.ts";
 export type ReviewRisk = "minimal" | "normal" | "strict";
 export interface ReviewPolicy {
     review_risk: ReviewRisk;
@@ -9,7 +9,54 @@ export declare const REVIEW_DOC_PATHS: string[];
 export declare function assertCommitPayloadExtension(payload: Record<string, unknown>): void;
 export declare function reviewPolicyForRisk(risk: ReviewRisk): ReviewPolicy;
 export declare function readReviewPolicyFromEvents(events: Event[]): ReviewPolicy | null;
+export declare const REVIEW_REJECTION_OVERRIDE_SCOPE_PREFIX = "review_rejection_override:";
+export declare const REVIEW_REJECTION_OVERRIDE_ANSWER = "do_not_block";
+export type ReviewRejectionDecisionSource = "main_process" | "user";
+export interface ReviewRejectionOverrideAudit {
+    job_id: string;
+    role: JobRole;
+    gate_id: ReviewGateRule["gate_id"];
+    packet_digest: string;
+    decision_source: ReviewRejectionDecisionSource;
+    reason: string;
+    decision_event_id: string;
+    decision_event_digest: string;
+}
+export declare function reviewRejectionOverrideScope(jobId: string): string;
+export declare function parseReviewRejectionOverrideScope(scope: string): string | null;
+export interface ReviewTerminalResult {
+    job: Job;
+    event: Event;
+    state: "accepted" | "rejected";
+    result_kind?: CodeReviewResultKind;
+    reason?: string;
+    findings?: unknown[];
+}
+export declare function latestReviewTerminalForGateRole(events: Event[], gate: ReviewGateRule, role: JobRole): ReviewTerminalResult | null;
+export declare function effectiveReviewRejectionOverride(events: Event[], gate: ReviewGateRule, terminal: ReviewTerminalResult): ReviewRejectionOverrideAudit | null;
+export type ReviewGateRoleResolution = {
+    kind: "none";
+} | {
+    kind: "stale";
+    terminal: ReviewTerminalResult;
+    stale_reason: string;
+} | {
+    kind: "accepted";
+    terminal: ReviewTerminalResult;
+} | {
+    kind: "rejected_invalid";
+    terminal: ReviewTerminalResult;
+} | {
+    kind: "rejected_pending";
+    terminal: ReviewTerminalResult;
+} | {
+    kind: "overridden";
+    terminal: ReviewTerminalResult;
+    override: ReviewRejectionOverrideAudit;
+};
+export declare function reviewGateRoleResolution(events: Event[], changeRoot: string, gate: ReviewGateRule, role: JobRole): ReviewGateRoleResolution;
 export declare function latestReviewHistoryForGateRole(events: Event[], gate: ReviewGateRule, role: JobRole): ReviewPreviousRejection | null;
+export declare function historicalProposeReadyRoles(events: Event[]): JobRole[];
 export declare function isReviewReadyVerifier(job: Job): boolean;
 export declare function reviewBoundFiles(changeRoot: string): Ref[];
 export declare function reviewEvidenceDigest(events: Event[]): string;