@peterxiaoyang/superspec 0.1.46 → 0.1.47

package/dist/cli.js

@@ -514,7 +514,7 @@ transition 子命令：
   init / explore / sync / next / propose-ready / start-apply
   task-start --task <T> / task-complete --task <T> [--input -]
   reopen --to explore|propose|apply --reason <TEXT>
-  reopen --to apply --reason <TEXT> [--review-fix <JOB#FINDING>]
+  reopen --to apply --reason <TEXT> [--review-fix <JOB#FINDING>|--self-test-fix <TASK>]
   reopen --to propose --reason <TEXT> [--review-finding <JOB#FINDING>]
   review-ready / accept
 
@@ -735,6 +735,7 @@ jobs 子命令：
                         const result = reopen(projectRoot, change, cr, to, reason, {
                             ...(opts["review-fix"] ? { reviewFix: opts["review-fix"] } : {}),
                             ...(opts["review-finding"] ? { reviewFinding: opts["review-finding"] } : {}),
+                            ...(opts["self-test-fix"] ? { selfTestFix: opts["self-test-fix"] } : {}),
                         });
                         console.log(JSON.stringify(result, null, 2));
                         return transitionExitCode(result);

package/dist/code_review.d.ts

@@ -1,4 +1,4 @@
-import type { CodeReviewResultKind, CodeReviewScope, CodeStateCheck, CoverageExemptionRef, Event, Job, JobPacketContext, Ref, ReviewPreviousRejection } from "./types.ts";
+import type { CodeReviewGateEvidence, CodeReviewResultKind, CodeReviewScope, CodeStateCheck, CoverageExemptionRef, Event, Job, JobPacketContext, Ref, ReviewPreviousRejection, TaskExecutionIndexEntry } from "./types.ts";
 export declare const CODE_REVIEW_REPAIR_SCOPE_PREFIX = "code_reviewer_report_repair:";
 export declare const CODE_REVIEW_DECISION_SCOPE_PREFIX = "code_review_decision:";
 export declare const TEST_COVERAGE_EXEMPTION_SCOPE_PREFIX = "test_coverage_exemption:";
@@ -68,7 +68,15 @@ export declare function codeReviewPacketDigest(input: {
 export declare function codeReviewPacketContext(changeRoot: string, projectRoot: string, scope: CodeReviewScope, events: Event[]): JobPacketContext;
 export declare function effectiveCoverageExemptionRefsFromEvents(events: Event[]): CoverageExemptionRef[];
 export declare function missingCoverageExemptionTestIds(changeRoot: string, events: Event[]): string[];
+/** Read-only execution evidence projected for code review and final verification. */
+export declare function taskExecutionIndexForReview(projectRoot: string, events: Event[]): TaskExecutionIndexEntry[];
 export declare function codeReviewDecisionScope(jobId: string, findingId: string): string;
+export interface CodeReviewDecisionScopeRef {
+    jobId: string;
+    findingId: string;
+}
+/** 只接受状态机生成的 <job>#<finding> 决策范围。 */
+export declare function parseCodeReviewDecisionScope(scope: string): CodeReviewDecisionScopeRef | null;
 export declare function isCodeReviewDecisionAnswer(value: unknown): value is CodeReviewDecisionAnswer;
 export declare function codeReviewDecisionAnswerLabel(answer: CodeReviewDecisionAnswer): string;
 export declare function normalizeCodeReviewDecisionAnswer(value: unknown): CodeReviewDecisionAnswer | null;
@@ -82,5 +90,7 @@ export declare function latestApplyDoneToReviewGate(events: Event[]): {
     job_id?: string;
     reason?: string;
 } | null;
+/** Latest code-review gate fact for the current review cycle, frozen into verifier packets. */
+export declare function latestCodeReviewGateEvidence(events: Event[]): CodeReviewGateEvidence | null;
 export declare function requiresFinalVerifierForCurrentReview(events: Event[]): boolean;
 export declare function computeCodeStateCheck(projectRoot: string, events: Event[], ignoredCodePaths?: string[]): CodeStateCheck;

package/dist/code_review.js

@@ -418,6 +418,7 @@ function taskExecutionIndexFromEvents(projectRoot, events) {
             entries.push({
                 task_id: payload.task_id,
                 attempt_id: payload.attempt_id,
+                ...(attempt?.fix ? { fix: attempt.fix } : {}),
                 execution_policy: attempt?.execution_policy ?? "tdd",
                 changed_paths: changedResult ? changedResult.paths : null,
                 ...(changedResult?.partial_reason ? { changed_paths_partial_reason: changedResult.partial_reason } : {}),
@@ -435,6 +436,10 @@ function taskExecutionIndexFromEvents(projectRoot, events) {
     entries.sort((a, b) => a.task_id.localeCompare(b.task_id) || a.attempt_id.localeCompare(b.attempt_id));
     return entries;
 }
+/** Read-only execution evidence projected for code review and final verification. */
+export function taskExecutionIndexForReview(projectRoot, events) {
+    return taskExecutionIndexFromEvents(projectRoot, events);
+}
 function isCodeReviewerJob(job) {
     return job.role === "code-reviewer" && REVIEW_CODE_REVIEW_GATE.isJobForGate(job);
 }
@@ -446,6 +451,18 @@ function codeReviewResultKind(value) {
 export function codeReviewDecisionScope(jobId, findingId) {
     return `${CODE_REVIEW_DECISION_SCOPE_PREFIX}${jobId}#${findingId}`;
 }
+/** 只接受状态机生成的 <job>#<finding> 决策范围。 */
+export function parseCodeReviewDecisionScope(scope) {
+    if (!scope.startsWith(CODE_REVIEW_DECISION_SCOPE_PREFIX))
+        return null;
+    const value = scope.slice(CODE_REVIEW_DECISION_SCOPE_PREFIX.length);
+    const separator = value.indexOf("#");
+    if (separator <= 0 || separator === value.length - 1)
+        return null;
+    const jobId = value.slice(0, separator);
+    const findingId = value.slice(separator + 1);
+    return jobId.trim() !== "" && findingId.trim() !== "" ? { jobId, findingId } : null;
+}
 export function isCodeReviewDecisionAnswer(value) {
     return value === "reopen_propose" || value === "reopen_apply" || value === "dismiss";
 }
@@ -622,6 +639,29 @@ export function latestApplyDoneToReviewGate(events) {
     }
     return null;
 }
+/** Latest code-review gate fact for the current review cycle, frozen into verifier packets. */
+export function latestCodeReviewGateEvidence(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 !== "review-ready" || payload.from_state !== "apply_done" || payload.to_state !== "review")
+            continue;
+        const gate = payload.code_review_gate;
+        if (!gate || (gate.decision !== "passed" && gate.decision !== "skipped"))
+            return null;
+        return {
+            decision: gate.decision,
+            job_id: typeof gate.job_id === "string" ? gate.job_id : null,
+            packet_digest: typeof gate.packet_digest === "string" ? gate.packet_digest : null,
+            ...(gate.reason === "no_code_changes" ? { reason: gate.reason } : {}),
+            event_id: event.event_id,
+            event_digest: event.event_digest,
+        };
+    }
+    return null;
+}
 export function requiresFinalVerifierForCurrentReview(events) {
     return latestApplyDoneToReviewGate(events) != null;
 }

package/dist/explore_round.d.ts

@@ -0,0 +1,23 @@
+import { type DiscoveryQuestion } from "./format.ts";
+import type { Event } from "./types.ts";
+/**
+ * 当前 Explore 轮次的稳定标识。
+ *
+ * 同一轮内补充调查或创建审查工作项不会使当前确认事项失效；只有首次进入
+ * Explore 或从后续阶段重新打开 Explore 时，才开始新的确认轮次。
+ */
+export declare function currentExploreRoundId(events: readonly Event[]): string;
+/** 在进入新 Explore 轮次时冻结已有已确认事项，避免升级时追溯历史答复。 */
+export declare function exploreAnswerRegistrationPayload(discoveryContent: string | null): {
+    explore_answer_registration: {
+        version: number;
+        baseline_closed_question_keys: string[];
+    };
+};
+/** 当前确认事项已通过本轮主流程登记过答复。 */
+export declare function exploreAnswerWasRecorded(events: readonly Event[], roundId: string, question: Pick<DiscoveryQuestion, "id" | "ordinal">, discoveryContent: string): boolean;
+/**
+ * 新协议轮次中，被回写为已确认的事项必须有对应答复记录。
+ * 进入本轮前已经关闭的事项作为基线保留，历史 change 因缺少协议标记整体兼容。
+ */
+export declare function unregisteredClosedExploreQuestions(events: readonly Event[], discoveryContent: string): DiscoveryQuestion[];

package/dist/explore_round.js

@@ -0,0 +1,94 @@
+import { discoveryQuestionContextFingerprint, discoveryQuestionKey, parseDiscoveryQuestions, } from "./format.js";
+const EXPLORE_ANSWER_REGISTRATION_VERSION = 1;
+function isExploreRoundEntry(event) {
+    if (event.event_type !== "transition_commit")
+        return false;
+    const payload = event.payload;
+    return payload.transition === "explore" && payload.from_state === "init" && payload.to_state === "explore" ||
+        payload.transition === "reopen" && payload.reopen_target === "explore";
+}
+function currentExploreRoundEntry(events) {
+    for (let index = events.length - 1; index >= 0; index--) {
+        const event = events[index];
+        if (isExploreRoundEntry(event))
+            return { event, roundId: event.event_id };
+    }
+    return null;
+}
+/**
+ * 当前 Explore 轮次的稳定标识。
+ *
+ * 同一轮内补充调查或创建审查工作项不会使当前确认事项失效；只有首次进入
+ * Explore 或从后续阶段重新打开 Explore 时，才开始新的确认轮次。
+ */
+export function currentExploreRoundId(events) {
+    return currentExploreRoundEntry(events)?.roundId ?? "legacy-explore-round";
+}
+/** 在进入新 Explore 轮次时冻结已有已确认事项，避免升级时追溯历史答复。 */
+export function exploreAnswerRegistrationPayload(discoveryContent) {
+    const baselineClosedQuestionKeys = discoveryContent == null
+        ? []
+        : parseDiscoveryQuestions(discoveryContent)
+            .filter(question => question.status === "closed")
+            .map(discoveryQuestionKey)
+            .sort();
+    return {
+        explore_answer_registration: {
+            version: EXPLORE_ANSWER_REGISTRATION_VERSION,
+            baseline_closed_question_keys: baselineClosedQuestionKeys,
+        },
+    };
+}
+function currentExploreAnswerRegistration(events) {
+    const entry = currentExploreRoundEntry(events);
+    if (!entry) {
+        return {
+            enabled: false,
+            roundId: "legacy-explore-round",
+            baselineClosedQuestionKeys: new Set(),
+        };
+    }
+    const payload = entry.event.payload;
+    const registration = payload.explore_answer_registration;
+    if (registration?.version !== EXPLORE_ANSWER_REGISTRATION_VERSION || !Array.isArray(registration.baseline_closed_question_keys)) {
+        return {
+            enabled: false,
+            roundId: entry.roundId,
+            baselineClosedQuestionKeys: new Set(),
+        };
+    }
+    return {
+        enabled: true,
+        roundId: entry.roundId,
+        baselineClosedQuestionKeys: new Set(registration.baseline_closed_question_keys.filter((key) => typeof key === "string")),
+    };
+}
+/** 当前确认事项已通过本轮主流程登记过答复。 */
+export function exploreAnswerWasRecorded(events, roundId, question, discoveryContent) {
+    const currentContextFingerprint = discoveryQuestionContextFingerprint(discoveryContent, question);
+    if (!currentContextFingerprint)
+        return false;
+    return events.some(event => {
+        if (event.event_type !== "user_decision_recorded")
+            return false;
+        const payload = event.payload;
+        const recorded = payload.explore_open_question;
+        return payload.accepted === true &&
+            recorded?.round_id === roundId &&
+            recorded.question_id === question.id &&
+            recorded.question_ordinal === question.ordinal &&
+            recorded.context_fingerprint === currentContextFingerprint;
+    });
+}
+/**
+ * 新协议轮次中，被回写为已确认的事项必须有对应答复记录。
+ * 进入本轮前已经关闭的事项作为基线保留，历史 change 因缺少协议标记整体兼容。
+ */
+export function unregisteredClosedExploreQuestions(events, discoveryContent) {
+    const registration = currentExploreAnswerRegistration(events);
+    if (!registration.enabled)
+        return [];
+    return parseDiscoveryQuestions(discoveryContent).filter(question => question.status === "closed" &&
+        !registration.baselineClosedQuestionKeys.has(discoveryQuestionKey(question)) &&
+        !exploreAnswerWasRecorded(events, registration.roundId, question, discoveryContent));
+}

package/dist/format.d.ts

@@ -1,5 +1,44 @@
 import { type ExecutionContract, type ExecutionPolicy } from "./types.ts";
-/** 从 discovery.md 提取"待确认问题"段内的未确认项数量 */
+export declare const EXPLORE_OPEN_QUESTION_SCOPE_PREFIX = "explore_open_question:";
+/**
+ * Discovery 的未确认项是用户决策的唯一候选来源。这里保留原有的“仅指定段落内
+ * checkbox 有效”语义；ID 缺失的历史文档按所有 checklist 在该段落中的稳定顺序
+ * 使用 item-N，避免升级时要求迁移历史 change。
+ */
+export interface DiscoveryOpenQuestion {
+    /** Q-xxx；历史材料没有 ID 时为 item-N。 */
+    id: string;
+    /** 在“待确认问题”段落中所有 checklist 的 1-based 顺序。 */
+    ordinal: number;
+    /** 去掉 markdown checkbox 后的原始内容，用于留痕与内部匹配。 */
+    text: string;
+    /** 包含 checkbox 的原始 Markdown 行，供诊断和测试使用。 */
+    raw: string;
+    /** 当前完整 discovery.md 的内容指纹，避免只改决策依据时沿用旧答复。 */
+    documentFingerprint: string;
+}
+/** Discovery 待确认段中的一项；状态机需要同时识别待答复和已回写的项。 */
+export interface DiscoveryQuestion extends DiscoveryOpenQuestion {
+    status: "open" | "closed";
+}
+/**
+ * 当前文档中同一确认事项的稳定键。结合 Q-ID、顺序和原文，避免把本轮开始前
+ * 已经确认的旧事项误认为新答复。
+ */
+export declare function discoveryQuestionKey(question: Pick<DiscoveryQuestion, "id" | "ordinal" | "text">): string;
+/**
+ * 计算某一确认事项之外的 Discovery 决策上下文。回写时该事项本身会从问题改为
+ * 结论，因此只归一化这一行；其余事实、证据和其它待确认项的改动都会使指纹失效。
+ */
+export declare function discoveryQuestionContextFingerprint(content: string, question: Pick<DiscoveryQuestion, "id" | "ordinal">): string | null;
+/** 按文档顺序提取 discovery.md 的全部确认事项。 */
+export declare function parseDiscoveryQuestions(content: string): DiscoveryQuestion[];
+/** 按文档顺序提取 discovery.md 中尚未确认的问题。 */
+export declare function parseDiscoveryOpenQuestions(content: string): DiscoveryOpenQuestion[];
+export declare function discoveryOpenQuestionScope(question: Pick<DiscoveryOpenQuestion, "id" | "documentFingerprint">, exploreRoundId: string): string;
+/** 面向用户展示时隐藏 Q-xxx 这一内部编号；历史无编号问题保持原文。 */
+export declare function discoveryOpenQuestionDisplayText(question: Pick<DiscoveryOpenQuestion, "id" | "text">): string;
+/** 从 discovery.md 提取“待确认问题”段内的未确认项数量。 */
 export declare function countDiscoveryOpenQuestions(content: string): number;
 export interface DiscoveryChainCoverageCheck {
     ok: boolean;
@@ -9,7 +48,10 @@ export interface DiscoveryChainCoverageCheck {
 export declare function splitMarkdownTableRow(line: string): string[];
 /** 轻量校验 discovery.md 的链路五要素段。只校验结构和阻塞未知，不判断业务真假。 */
 export declare function validateDiscoveryChainCoverage(content: string): DiscoveryChainCoverageCheck;
-/** 完整校验 discovery.md：存在 + 非空 + 无未确认问题 */
+/**
+ * 校验 discovery.md 的可解析结构。未确认问题不是格式错误：next 会把第一个问题
+ * 作为当前用户决策返回；只有缺文档、空文档或已声明链路的结构错误才在此阻断。
+ */
 export declare function validateDiscovery(changeRoot: string): {
     ok: boolean;
     message: string;
@@ -66,6 +108,13 @@ export declare function adoptedContractForTask(content: string, taskId: string,
     parsed: ParsedExecutionRequirement | null;
     contract: ExecutionContract | null;
 };
+/**
+ * Fix task 由状态机从已批准的实现范围派生；它没有 proposal 阶段执行依据块。
+ * REVIEW-FIX-* 是发布前已有的持久化 task ID，FIX-SELFTEST-* 是当前引擎生成的
+ * 自测修复 task。不能把通用 FIX-* 前缀保留为内部命名空间。
+ */
+export declare function isFixTaskId(taskId: string): boolean;
+/** @deprecated 新代码使用 isFixTaskId；保留给旧扩展和历史调用。 */
 export declare function isReviewFixTaskId(taskId: string): boolean;
 export declare function isCharacterizationTask(task: ParsedTask): boolean;
 export declare function parseTestContractEntries(content: string): TestContractParseResult;

package/dist/format.js

@@ -4,6 +4,7 @@
 // 生成与语义判断，不得自行充当格式校验器或在其它地方重复解析。
 import { readFileSync, existsSync, realpathSync } from "node:fs";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { sha256Text } from "./store.js";
 import { GREEN_ONLY_NO_TDD_REASON } from "./types.js";
 // ===== discovery.md =====
 //
@@ -24,7 +25,7 @@ function countOpenChecklistItemsInSection(content, headings) {
     const matches = sectionBody.match(/^\s*-\s+\[ \]/gm);
     return matches ? matches.length : 0;
 }
-function sectionBodyByHeadings(content, headings) {
+function sectionRangeByHeadings(content, headings) {
     const headingPattern = headings.map(escapeRegex).join("|");
     const sectionMatch = new RegExp(`^#{1,6}\\s*(?:${headingPattern})\\s*$`, "im").exec(content);
     if (!sectionMatch)
@@ -33,11 +34,90 @@ function sectionBodyByHeadings(content, headings) {
     // 截取到下一个标题或文件末尾
     const restContent = content.slice(sectionStart);
     const nextHeadingMatch = restContent.match(/^#{1,6}\s+/m);
-    return nextHeadingMatch ? restContent.slice(0, nextHeadingMatch.index) : restContent;
+    return {
+        start: sectionStart,
+        end: nextHeadingMatch ? sectionStart + nextHeadingMatch.index : content.length,
+    };
+}
+function sectionBodyByHeadings(content, headings) {
+    const range = sectionRangeByHeadings(content, headings);
+    return range ? content.slice(range.start, range.end) : null;
+}
+const DISCOVERY_QUESTION_HEADINGS = ["待确认问题", "Open Questions", "Pending Questions"];
+export const EXPLORE_OPEN_QUESTION_SCOPE_PREFIX = "explore_open_question:";
+/**
+ * 当前文档中同一确认事项的稳定键。结合 Q-ID、顺序和原文，避免把本轮开始前
+ * 已经确认的旧事项误认为新答复。
+ */
+export function discoveryQuestionKey(question) {
+    return sha256Text(`${question.id}\n${question.ordinal}\n${question.text}`);
+}
+/**
+ * 计算某一确认事项之外的 Discovery 决策上下文。回写时该事项本身会从问题改为
+ * 结论，因此只归一化这一行；其余事实、证据和其它待确认项的改动都会使指纹失效。
+ */
+export function discoveryQuestionContextFingerprint(content, question) {
+    const range = sectionRangeByHeadings(content, DISCOVERY_QUESTION_HEADINGS);
+    if (!range)
+        return null;
+    const sectionBody = content.slice(range.start, range.end);
+    const checklist = /^\s*-\s+\[([ xX])\]\s+(.*?)\s*$/gm;
+    let ordinal = 0;
+    for (const match of sectionBody.matchAll(checklist)) {
+        ordinal += 1;
+        if (ordinal !== question.ordinal)
+            continue;
+        const lineStart = range.start + match.index;
+        const lineEnd = lineStart + match[0].length;
+        const placeholder = `- [ ] <discovery-question:${question.id}:${question.ordinal}>`;
+        return sha256Text(`${content.slice(0, lineStart)}${placeholder}${content.slice(lineEnd)}`);
+    }
+    return null;
+}
+/** 按文档顺序提取 discovery.md 的全部确认事项。 */
+export function parseDiscoveryQuestions(content) {
+    const sectionBody = sectionBodyByHeadings(content, DISCOVERY_QUESTION_HEADINGS);
+    if (sectionBody == null)
+        return [];
+    const documentFingerprint = sha256Text(content);
+    const questions = [];
+    const checklist = /^\s*-\s+\[([ xX])\]\s+(.*?)\s*$/gm;
+    let ordinal = 0;
+    for (const match of sectionBody.matchAll(checklist)) {
+        ordinal += 1;
+        const text = match[2];
+        const idMatch = /^\s*(Q-[A-Za-z0-9][A-Za-z0-9_-]*)\b/.exec(text);
+        questions.push({
+            id: idMatch?.[1] ?? `item-${ordinal}`,
+            ordinal,
+            text,
+            raw: match[0],
+            documentFingerprint,
+            status: match[1] === " " ? "open" : "closed",
+        });
+    }
+    return questions;
+}
+/** 按文档顺序提取 discovery.md 中尚未确认的问题。 */
+export function parseDiscoveryOpenQuestions(content) {
+    return parseDiscoveryQuestions(content)
+        .filter(question => question.status === "open")
+        .map(({ status: _status, ...question }) => question);
+}
+export function discoveryOpenQuestionScope(question, exploreRoundId) {
+    const fingerprint = sha256Text(`${exploreRoundId}\n${question.documentFingerprint}`);
+    return `${EXPLORE_OPEN_QUESTION_SCOPE_PREFIX}${fingerprint}:${question.id}`;
+}
+/** 面向用户展示时隐藏 Q-xxx 这一内部编号；历史无编号问题保持原文。 */
+export function discoveryOpenQuestionDisplayText(question) {
+    if (question.id.startsWith("Q-") && question.text.startsWith(question.id)) {
+        return question.text.slice(question.id.length).replace(/^[\s:：—–-]+/, "").trim();
+    }
+    return question.text.trim();
 }
-/** 从 discovery.md 提取"待确认问题"段内的未确认项数量 */
+/** 从 discovery.md 提取“待确认问题”段内的未确认项数量。 */
 export function countDiscoveryOpenQuestions(content) {
-    return countOpenChecklistItemsInSection(content, ["待确认问题", "Open Questions", "Pending Questions"]);
+    return parseDiscoveryOpenQuestions(content).length;
 }
 const DISCOVERY_CHAIN_HEADINGS = ["链路五要素"];
 const DISCOVERY_CHAIN_REQUIRED_COLUMNS = [
@@ -105,7 +185,10 @@ export function validateDiscoveryChainCoverage(content) {
     }
     return { ok: true, message: "链路五要素就绪", present: true };
 }
-/** 完整校验 discovery.md：存在 + 非空 + 无未确认问题 */
+/**
+ * 校验 discovery.md 的可解析结构。未确认问题不是格式错误：next 会把第一个问题
+ * 作为当前用户决策返回；只有缺文档、空文档或已声明链路的结构错误才在此阻断。
+ */
 export function validateDiscovery(changeRoot) {
     const path = join(changeRoot, ".superspec", "artifacts", "discovery.md");
     if (!existsSync(path))
@@ -117,9 +200,11 @@ export function validateDiscovery(changeRoot) {
     if (!chainCoverage.ok)
         return { ok: false, message: chainCoverage.message, openCount: -1 };
     const openCount = countDiscoveryOpenQuestions(content);
-    if (openCount > 0)
-        return { ok: false, message: `discovery.md 有 ${openCount} 个未确认问题`, openCount };
-    return { ok: true, message: "discovery.md 就绪", openCount: 0 };
+    return {
+        ok: true,
+        message: openCount > 0 ? `discovery.md 结构有效，有 ${openCount} 个待确认问题` : "discovery.md 就绪",
+        openCount,
+    };
 }
 const PROPOSE_CONFIRMATION_DOCS = [
     "proposal.md",
@@ -327,8 +412,17 @@ export function adoptedContractForTask(content, taskId, contractMode) {
     const parsed = executionRequirementForTask(content, taskId);
     return { parsed, contract: contractMode ? parsed?.contract ?? null : null };
 }
+/**
+ * Fix task 由状态机从已批准的实现范围派生；它没有 proposal 阶段执行依据块。
+ * REVIEW-FIX-* 是发布前已有的持久化 task ID，FIX-SELFTEST-* 是当前引擎生成的
+ * 自测修复 task。不能把通用 FIX-* 前缀保留为内部命名空间。
+ */
+export function isFixTaskId(taskId) {
+    return taskId.startsWith("REVIEW-FIX-") || taskId.startsWith("FIX-SELFTEST-");
+}
+/** @deprecated 新代码使用 isFixTaskId；保留给旧扩展和历史调用。 */
 export function isReviewFixTaskId(taskId) {
-    return taskId.startsWith("REVIEW-FIX-");
+    return isFixTaskId(taskId);
 }
 export function isCharacterizationTask(task) {
     return task.tddRequired === false && task.noTddReason === "characterization";
@@ -510,7 +604,7 @@ export function validateExecutionRequirements(content, testContractContent, exec
     const hasLegacyGreenOnlyTask = tasks.some(task => task.noTddReason === GREEN_ONLY_NO_TDD_REASON);
     // v2 不允许“所有任务都没有执行依据”这一静默回退：新 Propose 的每个普通
     // task 都必须显式声明五字段。v1 的缺失版本仍保留旧的按需契约语义。
-    const hasV2OrdinaryTask = executionRequirementVersion === 2 && tasks.some(task => !isReviewFixTaskId(task.taskId));
+    const hasV2OrdinaryTask = executionRequirementVersion === 2 && tasks.some(task => !isFixTaskId(task.taskId));
     const mode = hasTaskBoundExecutionRequirements(content) || hasLegacyGreenOnlyTask || hasV2OrdinaryTask;
     const contracts = parseExecutionRequirements(content);
     // 孤儿检测必须在 mode=false 的 early return 之前：全部块都悬空时 mode=false，
@@ -532,11 +626,11 @@ export function validateExecutionRequirements(content, testContractContent, exec
         }
         // v2 是本次改造后的新计划：每个普通 task 必须声明完整五字段，
         // `测试:` 可显式为空以表达非行为任务。旧计划只保持原 TDD 契约要求。
-        if (executionRequirementVersion === 2 && !isReviewFixTaskId(task.taskId) && !contract) {
+        if (executionRequirementVersion === 2 && !isFixTaskId(task.taskId) && !contract) {
             errors.push(`${task.taskId} 缺少执行依据`);
             continue;
         }
-        if (executionRequirementVersion === 1 && task.tddRequired && !isReviewFixTaskId(task.taskId) && !contract) {
+        if (executionRequirementVersion === 1 && task.tddRequired && !isFixTaskId(task.taskId) && !contract) {
             errors.push(`${task.taskId} 缺少执行依据`);
             continue;
         }

package/dist/openspec.js

@@ -1,8 +1,26 @@
 // SuperSpec 流程引擎 — OpenSpec 探测
-import { execSync, execFileSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { createHash } from "node:crypto";
+function isTestMode() {
+    return process.env.SUPERSPEC_TEST_MODE === "1" || process.env.NODE_ENV === "test";
+}
+function runtimePlatform() {
+    return isTestMode() ? process.env.SUPERSPEC_TEST_PLATFORM ?? process.platform : process.platform;
+}
+function windowsCommandHost() {
+    return process.env.ComSpec ?? "cmd.exe";
+}
+/**
+ * 在 Windows 上，npm 安装的 CLI 是 .cmd 启动器，不能被 execFileSync 直接执行。
+ * 保留数组参数传递；只有启动器这一层通过 cmd.exe 运行。
+ */
+function execOpenSpec(args, options) {
+    if (runtimePlatform() !== "win32")
+        return execFileSync("openspec", args, options);
+    return execFileSync(windowsCommandHost(), ["/d", "/s", "/c", "openspec.cmd", ...args], options);
+}
 /** B2 修复：校验 change 字符集，防 shell 注入 */
 function validateChange(change) {
     if (!/^[A-Za-z0-9._-]+$/.test(change)) {
@@ -11,7 +29,10 @@ function validateChange(change) {
 }
 export function probeOpenSpec(projectRoot, change) {
     try {
-        const version = execSync("openspec --version 2>/dev/null", { encoding: "utf8" }).trim();
+        const version = execOpenSpec(["--version"], {
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "ignore"],
+        }).trim();
         let changeExists = false;
         if (change) {
             validateChange(change);
@@ -26,8 +47,8 @@ export function probeOpenSpec(projectRoot, change) {
 export function openspecStatus(projectRoot, change) {
     validateChange(change);
     try {
-        // B2 修复：用 execFileSync 数组传参，彻底避免 shell 解析
-        const result = execFileSync("openspec", ["status", "--change", change, "--json"], {
+        // B2 修复：参数始终走数组；Windows 仅通过 cmd.exe 运行 .cmd 启动器。
+        const result = execOpenSpec(["status", "--change", change, "--json"], {
             encoding: "utf8", cwd: projectRoot, stdio: ["pipe", "pipe", "ignore"],
         });
         return "sha256:" + createHash("sha256").update(result).digest("hex");
@@ -45,7 +66,7 @@ export function openspecStatus(projectRoot, change) {
 export function validateOpenSpecChange(projectRoot, change) {
     validateChange(change);
     try {
-        execFileSync("openspec", ["validate", change, "--type", "change", "--strict", "--no-interactive"], {
+        execOpenSpec(["validate", change, "--type", "change", "--strict", "--no-interactive"], {
             cwd: projectRoot,
             encoding: "utf8",
             stdio: ["pipe", "pipe", "pipe"],

package/dist/phase_confirmation.js

@@ -1,10 +1,75 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import { currentGitHead, dirtyCodeFiles } from "./git_state.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";
+import { parseExecutionRequirements, parseTasksMd, parseTestContractEntries } from "./format.js";
 import { hasFrozenWorkflowModeForProposeRound, workflowRiskForProject, workflowRiskForState, } from "./workflow_config.js";
 export const PHASE_CONFIRMATION_SCOPE_PREFIX = "phase_confirmation:";
+function taskTitle(content, task) {
+    const line = content.split("\n")[task.lineIdx] ?? "";
+    return line.replace(/^-\s+\[[ xX]\]\s+\S+\s*/, "").trim() || task.taskId;
+}
+function taskSummaryField(lines, task, labels) {
+    for (let index = task.lineIdx + 1; index < lines.length; index++) {
+        const line = lines[index];
+        if (/^-\s+\[[ xX]\]\s+\S+/.test(line) || /^#{1,6}\s+/.test(line))
+            break;
+        const match = /^\s*-\s*([^:：]+)\s*[:：]\s*(.+?)\s*$/.exec(line);
+        if (match && labels.includes(match[1].trim()))
+            return match[2].trim();
+    }
+    return null;
+}
+/**
+ * 这是阶段确认的临时阅读面，不是新的计划格式或 gate。优先读取 task 已声明的
+ * 交付/依赖/验收；缺省项如实标为未声明，避免将任务顺序臆造成真实依赖。
+ */
+function proposeTaskDeliverySummary(changeRoot) {
+    const tasksPath = join(changeRoot, "tasks.md");
+    if (!existsSync(tasksPath))
+        return null;
+    const tasksContent = readFileSync(tasksPath, "utf8");
+    const tasks = parseTasksMd(tasksContent);
+    if (tasks.length === 0)
+        return null;
+    const contracts = new Map(parseExecutionRequirements(tasksContent).map(item => [item.taskId, item.contract]));
+    const testContractPath = join(changeRoot, ".superspec", "artifacts", "test-contract.md");
+    const parsedTests = existsSync(testContractPath)
+        ? parseTestContractEntries(readFileSync(testContractPath, "utf8"))
+        : null;
+    const scenarios = parsedTests?.ok
+        ? new Map(parsedTests.entries.map(entry => [entry.test_id, entry.scenario]))
+        : new Map();
+    const lines = tasksContent.split("\n");
+    // Propose 展示的是当前计划，不是旧 Apply 轮的执行历史。重新打开同一 task 时，
+    // 当前 tasks.md 中的未勾选状态明确表示它已重新纳入本轮待实施范围。
+    const pendingTasks = tasks.filter(task => !task.done);
+    const completedCount = tasks.length - pendingTasks.length;
+    const items = pendingTasks.map((task, index) => {
+        const contract = contracts.get(task.taskId);
+        const explicitDelivery = taskSummaryField(lines, task, ["交付", "Delivery"]);
+        const explicitDependency = taskSummaryField(lines, task, ["依赖", "Dependencies", "Depends On"]);
+        const firstTest = contract?.tests[0];
+        const testScenario = firstTest ? scenarios.get(firstTest) : null;
+        const delivery = explicitDelivery ?? contract?.acceptance ?? taskTitle(tasksContent, task);
+        const dependency = explicitDependency ?? "无明确前置交付";
+        const acceptance = contract?.acceptance
+            ?? (testScenario ? `${firstTest}：${testScenario}` : "计划未单独声明验收");
+        return [
+            `${index + 1}. ${task.taskId} ${taskTitle(tasksContent, task)}`,
+            `   - 交付：${delivery}`,
+            `   - 依赖：${dependency}`,
+            `   - 验收：${acceptance}`,
+        ].join("\n");
+    });
+    const status = completedCount === 0
+        ? ""
+        : `已完成 ${completedCount} 项；${pendingTasks.length === 0 ? "当前没有待实施任务。" : `以下 ${pendingTasks.length} 项仍待实施或调整。`}\n\n`;
+    return `执行计划概览\n\n${status}${items.join("\n\n")}`;
+}
 function latestTransition(events, predicate) {
     return findLatestEvent(events, "transition_commit", event => predicate(event.payload));
 }
@@ -187,7 +252,11 @@ export function phaseConfirmationForBoundary(projectRoot, events, snapshot, boun
     const epochEventId = epoch?.event_id ?? `legacy-${spec.state}`;
     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);
+    const summary = boundary === "propose_to_apply"
+        ? proposeTaskDeliverySummary(openspecChangeRoot(projectRoot, snapshot.change_id))
+        : null;
+    const question = summary ? `${summary}\n\n${spec.question}` : spec.question;
+    const actions = buildActions(snapshot.change_id, boundary, scope, question, spec.actions, risk);
     return {
         boundary,
         epoch_event_id: epochEventId,
@@ -195,7 +264,7 @@ export function phaseConfirmationForBoundary(projectRoot, events, snapshot, boun
         scope,
         actions,
         ask: {
-            question: spec.question,
+            question,
             allowed_answers: actions.map(action => action.label),
             scope,
             actions,

package/dist/phase_plan.d.ts

@@ -1,4 +1,5 @@
 import type { ReviewGateRule } from "./review_job_gates.ts";
+import { exploreAnswerRegistrationPayload } from "./explore_round.ts";
 import type { AcceptedMaterialFollowupContinuation, AskUser, Event, ExecutionPolicy, Job, JobRole, PlanningValidationProfile, State } from "./types.ts";
 import type { Snapshot } from "./types.ts";
 import type { ReviewRisk } from "./review.ts";
@@ -87,6 +88,8 @@ export declare function executionPolicyForRisk(risk: ReviewRisk): ExecutionPolic
 export declare function executionPolicyForCurrentRound(events: Event[]): ExecutionPolicy;
 export declare function proposalDocsBaseline(changeRoot: string): Record<string, string>;
 export declare function discoveryDocsBaseline(changeRoot: string): Record<string, string>;
+/** 新 Explore 轮次冻结已有已确认事项，避免把历史答复当作本轮遗漏。 */
+export declare function exploreAnswerRegistrationPayloadForChange(changeRoot: string): ReturnType<typeof exploreAnswerRegistrationPayload>;
 export declare function latestAcceptedProposalBaseline(events: Event[]): Record<string, string> | null;
 export declare function latestReopenProposeBaseline(events: Event[]): Record<string, string> | null;
 export declare function latestReopenExploreBaseline(events: Event[]): Record<string, string> | null;