@peterxiaoyang/superspec 0.1.47 → 0.1.48

package/dist/record.js

@@ -12,7 +12,8 @@ import { REVIEW_DOC_PATHS, REVIEW_REJECTION_OVERRIDE_SCOPE_PREFIX, REVIEW_REJECT
 import { EXPLORE_DISCOVERY_REVIEW_GATE, PROPOSE_FINAL_REVIEW_GATE } from "./review_job_gates.js";
 import { RecordInputDecodingError, readRecordInputFile } from "./record_input.js";
 import { currentExploreRoundId } from "./explore_round.js";
-import { discoveryOpenQuestionDisplayText, discoveryQuestionContextFingerprint, discoveryOpenQuestionScope, EXPLORE_OPEN_QUESTION_SCOPE_PREFIX, parseDiscoveryOpenQuestions, } from "./format.js";
+import { currentProposeOpenQuestion, currentProposeQuestionContent, currentProposeRoundId, } from "./propose_round.js";
+import { discoveryOpenQuestionDisplayText, discoveryQuestionContextFingerprint, discoveryQuestionDecisionBasisDigest, discoveryOpenQuestionScope, legacyDiscoveryOpenQuestionScope, EXPLORE_OPEN_QUESTION_SCOPE_PREFIX, parseDiscoveryOpenQuestions, proposeOpenQuestionDisplayText, proposeOpenQuestionScope, proposeQuestionContextFingerprint, proposeQuestionDecisionBasisDigest, legacyProposeOpenQuestionScope, PROPOSE_OPEN_QUESTION_SCOPE_PREFIX, } from "./format.js";
 const REVIEW_REPORT_REQUIRED_FIELDS = ["role", "verdict", "findings"];
 const REVIEW_REPORT_OPTIONAL_FIELDS = ["summary", "evidence_refs", "risks", "open_questions"];
 const REVIEWER_KINDS = new Set(["codex-subagent", "human", "external-agent"]);
@@ -73,7 +74,7 @@ function previousRejectionInstruction(job) {
     const identityRule = job.role === "code-reviewer"
         ? "同一问题仍存在时复用原 finding ID；legacy finding 没有 ID 时沿用原始语义并补一个稳定 ID；"
         : "已解决或已由等价证据闭环的问题不要重复报告，不得通过更换标题或措辞重复同一问题；";
-    return `${reason}本轮是修复复核：逐项判断本工作项附带的上一次同角色 finding 是否仍成立。Finding 中的 recommendation 只是非绑定建议，不是需求或验收标准；先独立核对 underlying problem、直接证据和本次验收，不得因原建议指定了某种架构就要求照做。${identityRule}默认只复核历史 finding；新 blocker 仅允许是本次修正直接引入的回归，并必须说明“修正动作 → 新问题”的因果链，不得展开无关的故障模型、消费者或架构议题。`;
+    return `${reason}本轮是修复复核：逐项判断本工作项附带的上一次同角色 finding 是否仍成立。Finding 中的 recommendation 只是非绑定建议，不是需求或验收标准；先独立核对 underlying problem、直接证据和本次验收，不得因原建议指定了某种架构就要求照做。修正不得通过缩小已确认范围、改写用户决定或删除验收来让 finding 字面消失；这类偏离属于本次修正直接引入的回归。${identityRule}默认只复核历史 finding；新 blocker 仅允许是本次修正直接引入的回归，并必须说明“修正动作 → 新问题”的因果链，不得展开无关的故障模型、消费者或架构议题。`;
 }
 function reviewScopeForJob(job) {
     if (job.review_targets !== undefined || job.read_only_refs !== undefined) {
@@ -132,12 +133,21 @@ function currentDiscoveryOpenQuestion(projectRoot, change) {
         return null;
     return parseDiscoveryOpenQuestions(readFileSync(discoveryPath, "utf8"))[0] ?? null;
 }
-function latestAcceptedExploreOpenQuestionDecision(events, scope) {
+function latestAcceptedExploreOpenQuestionDecision(events, scopes, identity) {
     return [...events].reverse().find(event => {
         if (event.event_type !== "user_decision_recorded")
             return false;
         const payload = event.payload;
-        return payload.accepted !== false && payload.scope === scope;
+        if (payload.accepted === false)
+            return false;
+        const recorded = payload.explore_open_question;
+        if (recorded && typeof recorded.decision_basis_digest === "string") {
+            return recorded.round_id === identity.roundId &&
+                recorded.question_id === identity.questionId &&
+                (!identity.questionId.startsWith("item-") || recorded.question_ordinal === identity.questionOrdinal) &&
+                recorded.decision_basis_digest === identity.decisionBasisDigest;
+        }
+        return typeof payload.scope === "string" && scopes.includes(payload.scope);
     }) ?? null;
 }
 function isExploreOpenQuestionScope(scope) {
@@ -172,6 +182,52 @@ function invalidExploreOpenQuestionResult(projectRoot, change, inputDigest, exis
                 : "需要确认的事项已变化或已完成，请重新执行 next 获取当前事项",
     };
 }
+function latestAcceptedProposeOpenQuestionDecision(events, scopes, identity) {
+    return [...events].reverse().find(event => {
+        if (event.event_type !== "user_decision_recorded")
+            return false;
+        const payload = event.payload;
+        if (payload.accepted === false)
+            return false;
+        const recorded = payload.propose_open_question;
+        if (recorded && typeof recorded.decision_basis_digest === "string") {
+            return recorded.round_id === identity.roundId &&
+                recorded.path === identity.path &&
+                recorded.question_id === identity.questionId &&
+                (!identity.questionId.startsWith("item-") || recorded.question_ordinal === identity.questionOrdinal) &&
+                recorded.decision_basis_digest === identity.decisionBasisDigest;
+        }
+        return typeof payload.scope === "string" && scopes.includes(payload.scope);
+    }) ?? null;
+}
+function isProposeOpenQuestionScope(scope) {
+    return scope.startsWith(PROPOSE_OPEN_QUESTION_SCOPE_PREFIX);
+}
+function isWellFormedProposeOpenQuestionScope(scope) {
+    return /^propose_open_question:sha256:[a-f0-9]{64}:(?:DEC-[A-Za-z0-9][A-Za-z0-9_-]*|item-[1-9]\d*)$/.test(scope);
+}
+function invalidProposeOpenQuestionResult(projectRoot, change, inputDigest, existing, decision, reason) {
+    const existingPayload = existing?.payload;
+    if (existingPayload?.accepted === false && existingPayload.reason === reason) {
+        return { event_type: "user_decision_recorded", accepted: false, message: "幂等返回：同一无效设计决定答复已登记" };
+    }
+    appendEvent(projectRoot, change, makeEvent(change, "user_decision_recorded", {
+        accepted: false,
+        scope: decision.scope,
+        answer: decision.answer,
+        reason,
+        input_digest: inputDigest,
+    }));
+    return {
+        event_type: "user_decision_recorded",
+        accepted: false,
+        message: reason === "invalid_propose_open_question_scope"
+            ? "设计决定的内部标识无效，请重新执行 next 获取当前事项"
+            : reason === "propose_open_question_already_recorded"
+                ? "这项设计决定已有答复，请先回写计划材料后重新执行 next"
+                : "需要确认的设计决定已变化或已完成，请重新执行 next 获取当前事项",
+    };
+}
 function invalidCodeReviewDecisionResult(projectRoot, change, inputDigest, existing, decision, reason, message) {
     const existingPayload = existing?.payload;
     if (existingPayload?.accepted === false && existingPayload.reason === reason) {
@@ -704,20 +760,31 @@ function recordUserDecisionLoaded(projectRoot, change, events, content, inputDig
     }
     // Explore 的用户答复只能绑定当前文档顺序中的第一项。这里不判断答案是否
     // “正确”，只机械校验当前项、Discovery 决策上下文和 Explore 轮次仍与 next
-    // 返回时一致，防止旧问题在材料改写或重新探索后被错误登记为新问题的决定。
+    // 返回时一致。决定身份绑定问题项中明确写出的 basis；其它文档内容不参与当前
+    // scope，避免无关材料编辑触发重复提问。
     let exploreOpenQuestion = null;
     let exploreOpenQuestionRoundId = null;
     let exploreOpenQuestionContextFingerprint = null;
+    let exploreOpenQuestionBasisDigest = null;
     if (isExploreOpenQuestionScope(decision.scope)) {
         if (!isWellFormedExploreOpenQuestionScope(decision.scope)) {
             return invalidExploreOpenQuestionResult(projectRoot, change, inputDigest, existing, { scope: decision.scope, answer: decision.answer }, "invalid_explore_open_question_scope");
         }
         const current = currentDiscoveryOpenQuestion(projectRoot, change);
-        const expectedScope = current ? discoveryOpenQuestionScope(current, currentExploreRoundId(events)) : null;
-        if (!expectedScope || decision.scope !== expectedScope) {
+        const exploreRoundId = currentExploreRoundId(events);
+        const expectedScopes = current
+            ? [discoveryOpenQuestionScope(current, exploreRoundId), legacyDiscoveryOpenQuestionScope(current, exploreRoundId)]
+            : [];
+        if (!expectedScopes.includes(decision.scope)) {
             return invalidExploreOpenQuestionResult(projectRoot, change, inputDigest, existing, { scope: decision.scope, answer: decision.answer }, "stale_explore_open_question_scope");
         }
-        const acceptedForCurrentScope = latestAcceptedExploreOpenQuestionDecision(events, decision.scope);
+        const currentBasisDigest = current ? discoveryQuestionDecisionBasisDigest(current) : "";
+        const acceptedForCurrentScope = latestAcceptedExploreOpenQuestionDecision(events, expectedScopes, {
+            roundId: exploreRoundId,
+            questionId: current.id,
+            questionOrdinal: current.ordinal,
+            decisionBasisDigest: currentBasisDigest,
+        });
         if (acceptedForCurrentScope) {
             const previousAnswer = acceptedForCurrentScope.payload.answer;
             if (previousAnswer === decision.answer) {
@@ -730,11 +797,52 @@ function recordUserDecisionLoaded(projectRoot, change, events, content, inputDig
             return invalidExploreOpenQuestionResult(projectRoot, change, inputDigest, existing, { scope: decision.scope, answer: decision.answer }, "explore_open_question_already_recorded");
         }
         exploreOpenQuestion = current;
-        exploreOpenQuestionRoundId = currentExploreRoundId(events);
+        exploreOpenQuestionRoundId = exploreRoundId;
         const discoveryPath = join(openspecChangeRoot(projectRoot, change), ".superspec", "artifacts", "discovery.md");
         exploreOpenQuestionContextFingerprint = current
             ? discoveryQuestionContextFingerprint(readFileSync(discoveryPath, "utf8"), current)
             : null;
+        exploreOpenQuestionBasisDigest = currentBasisDigest;
+    }
+    let proposeOpenQuestion = null;
+    let proposeOpenQuestionRoundId = null;
+    let proposeOpenQuestionContextFingerprint = null;
+    let proposeOpenQuestionBasisDigest = null;
+    if (isProposeOpenQuestionScope(decision.scope)) {
+        if (!isWellFormedProposeOpenQuestionScope(decision.scope)) {
+            return invalidProposeOpenQuestionResult(projectRoot, change, inputDigest, existing, { scope: decision.scope, answer: decision.answer }, "invalid_propose_open_question_scope");
+        }
+        const changeRoot = openspecChangeRoot(projectRoot, change);
+        const current = currentProposeOpenQuestion(changeRoot);
+        const proposeRoundId = currentProposeRoundId(events);
+        const expectedScopes = current
+            ? [proposeOpenQuestionScope(current, proposeRoundId), legacyProposeOpenQuestionScope(current, proposeRoundId)]
+            : [];
+        if (!expectedScopes.includes(decision.scope)) {
+            return invalidProposeOpenQuestionResult(projectRoot, change, inputDigest, existing, { scope: decision.scope, answer: decision.answer }, "stale_propose_open_question_scope");
+        }
+        const currentBasisDigest = current ? proposeQuestionDecisionBasisDigest(current) : "";
+        const acceptedForCurrentScope = latestAcceptedProposeOpenQuestionDecision(events, expectedScopes, {
+            roundId: proposeRoundId,
+            path: current.path,
+            questionId: current.id,
+            questionOrdinal: current.ordinal,
+            decisionBasisDigest: currentBasisDigest,
+        });
+        if (acceptedForCurrentScope) {
+            const previousAnswer = acceptedForCurrentScope.payload.answer;
+            if (previousAnswer === decision.answer) {
+                return { event_type: "user_decision_recorded", accepted: true, message: "幂等返回：同一用户决策已登记" };
+            }
+            return invalidProposeOpenQuestionResult(projectRoot, change, inputDigest, existing, { scope: decision.scope, answer: decision.answer }, "propose_open_question_already_recorded");
+        }
+        const content = current ? currentProposeQuestionContent(changeRoot, current) : null;
+        proposeOpenQuestion = current;
+        proposeOpenQuestionRoundId = proposeRoundId;
+        proposeOpenQuestionContextFingerprint = current && content
+            ? proposeQuestionContextFingerprint(content, current)
+            : null;
+        proposeOpenQuestionBasisDigest = currentBasisDigest;
     }
     let phaseConfirmation = null;
     let phaseAction = null;
@@ -915,7 +1023,9 @@ function recordUserDecisionLoaded(projectRoot, change, events, content, inputDig
             ? phaseConfirmation.ask.question
             : exploreOpenQuestion
                 ? discoveryOpenQuestionDisplayText(exploreOpenQuestion)
-                : typeof decision.question === "string" ? decision.question : "",
+                : proposeOpenQuestion
+                    ? proposeOpenQuestionDisplayText(proposeOpenQuestion)
+                    : typeof decision.question === "string" ? decision.question : "",
         answer: phaseAction
             ? phaseAction.label
             : normalizedAnswer ? codeReviewDecisionAnswerLabel(normalizedAnswer) : decision.answer,
@@ -923,13 +1033,25 @@ function recordUserDecisionLoaded(projectRoot, change, events, content, inputDig
         ...(reviewRejectionDecisionSource ? { decision_source: reviewRejectionDecisionSource } : {}),
         ...(reviewRejectionOverride ? { review_rejection_override: reviewRejectionOverride } : {}),
         ...(codeReviewDecisionReference ? { code_review_decision: codeReviewDecisionReference } : {}),
-        ...(exploreOpenQuestion && exploreOpenQuestionRoundId && exploreOpenQuestionContextFingerprint ? {
+        ...(exploreOpenQuestion && exploreOpenQuestionRoundId && exploreOpenQuestionContextFingerprint && exploreOpenQuestionBasisDigest ? {
             explore_open_question: {
                 round_id: exploreOpenQuestionRoundId,
                 question_id: exploreOpenQuestion.id,
                 question_ordinal: exploreOpenQuestion.ordinal,
                 document_fingerprint: exploreOpenQuestion.documentFingerprint,
                 context_fingerprint: exploreOpenQuestionContextFingerprint,
+                decision_basis_digest: exploreOpenQuestionBasisDigest,
+            },
+        } : {}),
+        ...(proposeOpenQuestion && proposeOpenQuestionRoundId && proposeOpenQuestionContextFingerprint && proposeOpenQuestionBasisDigest ? {
+            propose_open_question: {
+                round_id: proposeOpenQuestionRoundId,
+                path: proposeOpenQuestion.path,
+                question_id: proposeOpenQuestion.id,
+                question_ordinal: proposeOpenQuestion.ordinal,
+                document_fingerprint: proposeOpenQuestion.documentFingerprint,
+                context_fingerprint: proposeOpenQuestionContextFingerprint,
+                decision_basis_digest: proposeOpenQuestionBasisDigest,
             },
         } : {}),
         ...(phaseAction ? {

package/dist/review_job_gates.d.ts

@@ -15,7 +15,7 @@ export declare const EXPLORE_DISCOVERY_REVIEW_GATE_ID: "explore.discovery_review
 export declare const PROPOSE_FINAL_REVIEW_GATE_ID: "propose.final_review";
 export declare const REVIEW_CODE_REVIEW_GATE_ID: "review.code_review";
 export declare const REVIEW_FINAL_VERIFIER_GATE_ID: "review.final_verifier";
-export declare function reviewScopeForGateRole(gate: ReviewGateRule, role: JobRole): {
+export declare function reviewScopeForGateRole(gate: ReviewGateRule, role: JobRole, requiredRoles?: readonly JobRole[]): {
     reviewTargets: string[];
     readOnlyRefs: string[];
     boundPaths: string[];

package/dist/review_job_gates.js

@@ -26,14 +26,22 @@ function defaultReviewScope(gate) {
         boundPaths: [...new Set([...gate.reviewTargets, ...gate.readOnlyRefs])],
     };
 }
-export function reviewScopeForGateRole(gate, role) {
+export function reviewScopeForGateRole(gate, role, requiredRoles = gate.allowedRoles) {
     if (gate.gate_id !== PROPOSE_FINAL_REVIEW_GATE_ID)
         return defaultReviewScope(gate);
     if (role === "critic") {
-        const reviewTargets = ["proposal.md", "specs/", "tasks.md"];
+        const ownsDesign = !requiredRoles.includes("architect");
+        const ownsTestContract = !requiredRoles.includes("test-engineer");
+        const reviewTargets = [
+            "proposal.md",
+            "specs/",
+            ...(ownsDesign ? ["design.md"] : []),
+            "tasks.md",
+            ...(ownsTestContract ? [".superspec/artifacts/test-contract.md"] : []),
+        ];
         const readOnlyRefs = [
-            "design.md",
-            ".superspec/artifacts/test-contract.md",
+            ...(!ownsDesign ? ["design.md"] : []),
+            ...(!ownsTestContract ? [".superspec/artifacts/test-contract.md"] : []),
             ".superspec/artifacts/discovery.md",
         ];
         return {

package/dist/skill_loop.js

@@ -47,6 +47,26 @@ export function simulateLoop(nextFn, executeFn, maxSteps = 20) {
                     return { completed: false, steps, finalState: output.state, message: `工作项执行失败` };
                 }
                 break;
+            case "artifact_required":
+                step.action = "artifact";
+                step.detail = output.artifact.path;
+                steps.push(step);
+                return {
+                    completed: false,
+                    steps,
+                    finalState: output.state,
+                    message: `需要创建或更新工作流产物：${output.artifact.path}`,
+                };
+            case "material_update_required":
+                step.action = "material_update";
+                step.detail = output.errors.join("；");
+                steps.push(step);
+                return {
+                    completed: false,
+                    steps,
+                    finalState: output.state,
+                    message: `需要修正工作流材料：${output.errors.join("；")}`,
+                };
             case "ask_user":
                 step.action = "ask";
                 step.detail = output.ask_user.question;

package/dist/transition.js

@@ -9,7 +9,7 @@ import { REVIEW_CODE_REVIEW_GATE_ID, REVIEW_FINAL_VERIFIER_GATE, REVIEW_FINAL_VE
 import { codeReviewBoundFiles, codeReviewDecisionScope, codeReviewJobStaleReason, codeReviewPacketContext, codeReviewPacketDigest, collectCodeReviewGateFacts, computeCodeStateCheck, currentCodeReviewWorkingPaths, dismissedCodeReviewSummary, effectiveCoverageExemptionRefsFromEvents, latestCodeReviewGateEvidence, latestCodeReviewDecision, latestCodeReviewFailedStatus, missingCoverageExemptionTestIds, requiresFinalVerifierForCurrentReview, scanCodeChangesForReview, taskExecutionIndexForReview, } from "./code_review.js";
 import { taskEvidenceReadiness } from "./task_evidence.js";
 import { adoptedContractForTask, findTaskInLines, isFixTaskId, parseTasksMd, parseTestContractEntries, } from "./format.js";
-import { applyRequirementModeForCurrentRound, executionRequirementVersionForCurrentRound, blockingJobsForApplyDone, executionPolicyForCurrentRound, formatPendingTaskMessage, latestAcceptedProposalBaseline, pendingTaskStatusForApply, planningValidationProfileForNewRound, planTransition, discoveryDocsBaseline, exploreAnswerRegistrationPayloadForChange, proposalDocsBaseline, } from "./phase_plan.js";
+import { applyRequirementModeForCurrentRound, executionRequirementVersionForCurrentRound, blockingJobsForApplyDone, executionPolicyForCurrentRound, formatPendingTaskMessage, latestAcceptedProposalBaseline, pendingTaskStatusForApply, planningValidationProfileForNewRound, planTransition, discoveryDocsBaseline, exploreAnswerRegistrationPayloadForChange, proposeAnswerRegistrationPayloadForChange, proposalDocsBaseline, } from "./phase_plan.js";
 import { latestAcceptedPhaseDecision, phaseConfirmationCommitPayload, phaseConfirmationForBoundary, phaseConfirmationMissingMessage, } from "./phase_confirmation.js";
 import { currentGitHead, dirtyCodeFiles, stageProductionJavaFilesSince } from "./git_state.js";
 import { workflowRiskForProject } from "./workflow_config.js";
@@ -17,9 +17,9 @@ let transitionSeq = 0;
 function newTransitionId() { return `T-${Date.now()}-${++transitionSeq}`; }
 let jobSeq = 0;
 function newJobId(change, role) { return `JOB-${change.slice(0, 8)}-${role.slice(0, 4)}-${Date.now()}-${++jobSeq}`; }
-function createReviewJobsForGate(state, gate, roles, changeRoot, change, reason, events) {
+function createReviewJobsForGate(state, gate, roles, requiredRoles, changeRoot, change, reason, events) {
     const newJobs = roles.map(role => {
-        const scope = reviewScopeForGateRole(gate, role);
+        const scope = reviewScopeForGateRole(gate, role, requiredRoles);
         // 角色职责目标和显式 freshness 路径绑定时点指纹：单文件缺失使用 sha256:missing，目录缺失使用稳定空指纹。
         const boundPaths = [...new Set(scope.boundPaths)];
         const boundFiles = boundPaths
@@ -209,6 +209,28 @@ function compileRequiredEvidence(executionPolicy, testIds, requiresVerificationW
         accepted_green_statuses: ["expected_success"],
     };
 }
+function evidenceActionsForAttempt(change, attemptId, required) {
+    const testIds = required.test_ids.length > 0 ? required.test_ids : [undefined];
+    const statuses = [];
+    if (required.red_required)
+        statuses.push("expected_failure");
+    if (required.green_required)
+        statuses.push(required.accepted_green_statuses[0] ?? "expected_success");
+    return testIds.flatMap(testId => statuses.map(semanticStatus => ({
+        kind: "test_run",
+        ...(testId ? { test_id: testId } : {}),
+        record_argv: ["superspec", "record", "test-run", "--change", change, "--input", "-"],
+        record_input: {
+            ...(testId ? { test_id: testId } : {}),
+            attempt_id: attemptId,
+            command: null,
+            cwd: null,
+            exit_code: null,
+            semantic_status: semanticStatus,
+        },
+        required_fields: ["command", "cwd", "exit_code"],
+    })));
+}
 function hasRejectedReviewReadyVerifier(events) {
     const reviewReadyVerifierIds = new Set();
     for (const ev of events) {
@@ -627,7 +649,7 @@ function transitionPlanToDecision(snapshot, changeRoot, change, plan, events) {
         case "blocked":
             return { blocked: true, reason: plan.reason, jobs: plan.jobs, ...(plan.details ? { details: plan.details } : {}) };
         case "create_gate_jobs":
-            return createReviewJobsForGate(snapshot.state, plan.gate, plan.roles, changeRoot, change, plan.reason, events);
+            return createReviewJobsForGate(snapshot.state, plan.gate, plan.roles, plan.requiredRoles, changeRoot, change, plan.reason, events);
         case "advance":
             return {
                 fromState: plan.fromState,
@@ -867,6 +889,9 @@ export function taskStart(projectRoot, change, changeRoot, taskId) {
                 ...attempt,
                 ...boundarySnapshotPayload(projectRoot),
             };
+            const evidenceActions = requiredEvidence
+                ? evidenceActionsForAttempt(change, attempt.attempt_id, requiredEvidence)
+                : null;
             return {
                 fromState: "apply", toState: "apply", outcome: "advanced",
                 reason: `创建任务 ${taskId} 执行尝试`,
@@ -878,6 +903,7 @@ export function taskStart(projectRoot, change, changeRoot, taskId) {
                     contract: adopted.contract,
                     ...(fix ? { fix } : {}),
                     ...(requiredEvidence ? { required_evidence: requiredEvidence } : {}),
+                    ...(evidenceActions ? { evidence_actions: evidenceActions } : {}),
                     // legacy 轮统一标注历史模式（无论有无执行依据文本）；契约轮无块时标 false（如 Fix task）
                     ...(adopted.contract ? {} : { legacy_contract: !contractMode }),
                 },
@@ -969,6 +995,7 @@ export function reopen(projectRoot, change, changeRoot, to, reason, opts = {}) {
                         baseline_docs: proposalDocsBaseline(changeRoot),
                         planning_validation_version: 2,
                         planning_validation_profile: planningValidationProfileForNewRound(projectRoot),
+                        ...proposeAnswerRegistrationPayloadForChange(changeRoot),
                     },
                 };
             }

package/dist/types.d.ts

@@ -168,7 +168,7 @@ export interface RequiredJobAction {
     packet_command: string;
     packet_argv: string[];
 }
-export type EventType = "transition_prepare" | "transition_commit" | "job_requested" | "job_invalidated" | "reopen" | "abandon" | "task_started" | "task_completed" | "task_abandoned" | "job_accepted" | "job_rejected" | "user_decision_recorded" | "test_run_recorded" | "task_activation_recorded" | "artifact_recorded";
+export type EventType = "transition_prepare" | "transition_commit" | "job_requested" | "job_invalidated" | "reopen" | "abandon" | "task_started" | "task_completed" | "task_abandoned" | "job_accepted" | "job_rejected" | "user_question_presented" | "user_decision_recorded" | "test_run_recorded" | "task_activation_recorded" | "artifact_recorded";
 export interface Event {
     event_id: string;
     event_type: EventType;
@@ -192,6 +192,9 @@ export type OpenSpecValidationProfile = {
 export interface PlanningValidationProfile {
     version: 2;
     openspec: OpenSpecValidationProfile;
+    design?: {
+        schema_version: 1;
+    };
 }
 export interface TransitionCommitPayload {
     transition: string;
@@ -318,6 +321,14 @@ export interface AskUser {
     allowed_answers: string[];
     scope: string;
     actions?: AskUserAction[];
+    /** 自由文本问题的直接登记入口；固定选项继续使用 actions。 */
+    record_argv?: string[];
+    record_input?: {
+        scope: string;
+        question: string;
+        answer: null;
+    };
+    required_fields?: Array<"answer">;
 }
 export interface AcceptedMaterialFollowupContinuation {
     kind: "accepted_material_followup";
@@ -331,6 +342,33 @@ export interface AcceptedMaterialFollowupContinuation {
     };
     plan_docs_changed_since_accept: boolean | null;
 }
+export type WorkflowArtifactKind = "discovery" | "test_contract";
+export interface RequiredWorkflowArtifact {
+    kind: WorkflowArtifactKind;
+    /** Repository-relative canonical path owned by the workflow engine. */
+    path: string;
+    operation: "create_or_update";
+}
+export interface ArtifactRequiredResume {
+    argv: string[];
+}
+export interface MaterialUpdateRequiredResume {
+    argv: string[];
+}
+export interface TestEvidenceAction {
+    kind: "test_run";
+    test_id?: string;
+    record_argv: string[];
+    record_input: {
+        test_id?: string;
+        attempt_id: string;
+        command: null;
+        cwd: null;
+        exit_code: null;
+        semantic_status: "expected_failure" | "expected_success" | "characterization_pass";
+    };
+    required_fields: Array<"command" | "cwd" | "exit_code">;
+}
 export type NextOutput = {
     state: State;
 } & ({
@@ -342,6 +380,16 @@ export type NextOutput = {
     path: "required_job";
     required_jobs: RequiredJobAction[];
     reason: string;
+} | {
+    path: "artifact_required";
+    artifact: RequiredWorkflowArtifact;
+    resume: ArtifactRequiredResume;
+    reason: string;
+} | {
+    path: "material_update_required";
+    errors: string[];
+    resume: MaterialUpdateRequiredResume;
+    reason: string;
 } | {
     path: "ask_user";
     ask_user: AskUser;

package/dist/workflow_profile.js

@@ -6,7 +6,7 @@ const CURRENT_GATE_ROLES_BY_RISK = {
         "review.final_verifier": ["verifier"],
     },
     normal: {
-        "explore.discovery_review": [],
+        "explore.discovery_review": ["critic"],
         "propose.final_review": ["critic"],
         "review.code_review": ["code-reviewer"],
         "review.final_verifier": ["verifier"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peterxiaoyang/superspec",
-  "version": "0.1.47",
+  "version": "0.1.48",
   "description": "SuperSpec 流程引擎 — transition engine with lightweight fact-sync",
   "type": "module",
   "engines": {
@@ -24,6 +24,12 @@
     "build": "node build.js",
     "typecheck": "tsc --noEmit",
     "test": "node --test tests/*.ts",
+    "eval:probe": "node evals/probe.mjs",
+    "eval:dynamic": "node evals/probe.mjs --scenario evals/scenarios/probe-dynamic-accepted.json",
+    "eval:m2": "node evals/m2.mjs",
+    "eval:m2:validate": "node evals/m2.mjs --validate-faults",
+    "eval:arena": "node evals/arena.mjs",
+    "eval:delegation": "node evals/delegation-probe.mjs",
     "prepack": "npm run build",
     "prepublishOnly": "npm run build"
   },

package/templates/workflow/AGENTS.md

@@ -5,6 +5,8 @@
 
 每完成 `next` 返回的当前事项（材料更新、用户答复回写、实现、验证、审查或修复时），立即再次运行 `superspec transition next --change "<change>"` 并继续处理。完成单个事项不等于完成整个 change；只有工作流明确需要用户决定、当前独立工作项尚未返回结果、遇到真实阻塞或整个 change 已完成时才暂停。
 
+工作流要求用户决定时，只能登记当前对话中用户针对当前问题作出的明确答复。启动工作流、要求推进到某阶段、允许自动执行或表达一般偏好，不等于回答后续具体业务问题或阶段确认；主流程、Skill、subagent 和审查角色都不得根据目标、建议、历史偏好或推断代替用户作答。答复与当前问题不对应或仍有实质歧义时，保持待确认，不得登记为用户决定。
+
 当用户显式调用 `$superspec-explore`，或明确要求继续处于 Explore 的已有 change 时，视为已明确授权启动 `explore` subagent 做只读深扫；其他 `$superspec-*` 阶段仅在工作流引擎创建独立工作项时，视为授权启动对应 subagent。
 
 Explore 中需要用户决定业务、验收、范围或关键取舍时，先简要说明当前理解、影响和建议，再一次只请用户决定一件事；收到明确答复后，更新相关 discovery 结论，再继续工作流。其他阶段要求用户确认、选择处理方向或补齐材料时，按当前工作流返回的要求登记结论或更新相应材料；不得把这类答复默认写入 discovery。

package/templates/workflow/prompts/architect.md

@@ -22,6 +22,7 @@ argument-hint: "本次架构审查说明"
 - 方案必须说明在何处承担责任，以及本次数据、接口、状态或控制流如何改变；实现者不能据此落地时阻塞。
 - 需求、规格和 discovery 中影响实现的事实必须在设计中得到一致安排。共享数据、接口、状态或优先级规则不能在不同方案中得到冲突解释。
 - 复用既有机制时，核对接入点、本次差异和保持语义；只审查本次接入是否破坏现有契约，不要求重建或重新证明底层基础设施。
+- 参考实现证明的是可复用能力和候选机制，不自动决定本次的接口、资源、数据模型或模块形态。新增 Controller、API、实体、表、公共类型、独立模块或跨仓库改动时，检查其是否承担不可由现有边界表达的独立责任；不要规定数量，但应挑战无必要依据的平行结构和机械复制。
 - 只有本次确实改变的兼容、并发、恢复、数据语义或发布顺序才需要明确设计；未改变的既有风险和理论故障不是 blocker。
 - 设计取舍受用户决定和明确非目标约束。报告无法满足的结果或事实冲突，不把未经采纳的架构方案写成 required fix。
 
@@ -31,6 +32,7 @@ argument-hint: "本次架构审查说明"
 - 多个功能点共享字段组、接口语义、状态转换、优先级或一致性规则时，检查是否有一个一致的权威契约；局部方案互相矛盾时阻塞。
 - 改变既有规则变形、持久化语义、调用顺序或事务边界时，确认该变化已被声明为目标，并有与影响相称的保护边界；无理由地重复上游变形、双重兜底或扩大数据语义应报告。
 - 运行时输入或 producer-to-consumer 契约变化时，设计应分开说明输入如何完整到达 consumer、consumer 如何处理；不要用单一算法描述掩盖输入链路缺口。
+- 跨仓库、外部模块或不同运行时参与方案时，区分已经核实的契约、尚待核实的假设和必须先完成的外部前置变更。方案不能把当前证据范围外的实现当作确定事实，也不能让 Apply 隐含承担未登记的外部设计工作。
 - 任务应能从实现方案和边界约束自然推出。仅当多个独立行为、入口或系统边界确实不能共享一个验证边界时，才要求拆分；不要为了形式化而增加层级或任务。
 
 ### 停止边界

package/templates/workflow/prompts/critic.md

@@ -12,7 +12,7 @@ argument-hint: "本次反方审查说明"
 ## 工作边界
 
 - 先读任务说明和被引用材料；只审查本次 change 的既定范围。材料不足时报告证据缺口，不猜测或静默扩大范围。
-- 修复复核优先判断原问题是否仍成立；新 blocker 只能来自修复直接引入的回归，并说明因果链。
+- 修复复核优先判断原问题是否仍成立；不得通过缩小已确认范围、改写用户决定或删除验收来让 finding 字面消失。新 blocker 只能来自修复直接引入的回归，并说明因果链。
 - 不要因标题、字段、表格、编号、勾选或引用写法提出 finding；只判断材料表达的事实、范围和可执行性。
 
 ## 反方判断
@@ -21,7 +21,7 @@ argument-hint: "本次反方审查说明"
 
 Discovery 阶段，检查用户目标、当前差异和完成口径是否清楚；事实、推断和未知是否被诚实区分；影响范围、数据来源和下游影响是否由实际链路支撑。数据或跨边界输入发生变化时，确认调查能证明相关 producer-to-consumer 契约；局部行为且不改变数据传递时不要求虚构全链路。
 
-计划阶段，检查 proposal、specs、design、tasks 与测试契约是否围绕同一已确认目标：能力是否被可观察行为、可落地设计、独立验证边界和证据路径支撑；已确认决策与需求变化是否得到一致回写；是否把调查记录、实现日志、技术偏好或未证实消费者伪装成需求。技术路线优劣交给 Architect，测试证明力交给 Test Engineer。
+计划阶段，检查 proposal、specs、design、tasks 与测试契约是否围绕同一已确认目标：能力是否被可观察行为、可落地设计、独立验证边界和证据路径支撑；已确认决策与需求变化是否得到一致回写；是否把调查记录、实现日志、技术偏好或未证实消费者伪装成需求。Architect 和 Test Engineer 存在时分别承担技术路线与测试证明力的深入审查；Critic 仍需识别会让整个计划无法实施或无法证明的跨材料缺口。
 
 ### Discovery 反方口径
 
@@ -29,6 +29,11 @@ Discovery 阶段，检查用户目标、当前差异和完成口径是否清楚
 - 影响范围和风险应由当前调用、数据流、现有契约或用户可观察行为支撑。消费者类别只是搜索线索，不是无证据的覆盖配额。
 - 对共享数据、跨边界输入或下游可观察行为，检查是否追到足以判断影响的真实链路，以及是否说明已排除的相邻消费者。对局部改动，直接锚点和具体不适用理由可以构成闭环。
 - 已确认结论、未知和排除理由必须互相一致。会改变范围或验收的未知不能被伪装成非阻塞；可由继续调查解决的问题不应升级给用户。
+- 区分证据支持的事实、基于事实提出的建议和需要用户选择的产品决定。会实质收窄范围、定义兼容或接口语义、选择行为主体或改变验收结果的结论，没有明确需求源、系统不变量或用户针对该问题的答复时，不得视为已确认。
+
+Discovery 准备结束时，从本次变更及已有证据出发，反向检查是否仍有会影响范围、验收、兼容、数据语义或可落地性的未闭合分支。结合实际链路和边界自由判断，不套固定问题清单，也不为了形式完整而穷举可能性；正文已经暴露却没有得到明确处理的关键问题仍属于缺口。
+
+能够通过代码、依赖、配置、测试或需求源继续核实的事实，应要求补足调查；只有证据无法裁决且确实需要选择的事项才交给用户。没有直接证据或不影响本次结果的可能性不应扩展为审查义务。
 
 ### 计划反方口径
 
@@ -36,6 +41,10 @@ Discovery 阶段，检查用户目标、当前差异和完成口径是否清楚
 - `Impact` 应说明受影响原因和可观察影响，而不是文件清单；已证实会变化的影响没有登记且会使验收或实现判断失真时才阻塞。
 - design 应表达方案关系、责任边界和约束，而不是 discovery 调查过程、规格复述、测试步骤或实现日志。共享事实需要一个可定位的权威定义，避免多处含义漂移。
 - task 的来源、设计依据、验收和边界应能让执行者判断是否越界；这些材料与 task 实质无关、空泛或互相矛盾时才报告。不要检查字段、ID 或引用写法本身。
+- 参考实现只证明已有能力和候选机制，不自动证明其接口数量、资源拆分、数据模型或模块边界适合本次 change。新增公共表面或跨系统改动缺少独立责任与必要性依据，或者明显存在可复用、合并、缩减空间并影响实施边界时，应要求计划补足判断，而不是规定具体数量或替代方案。
+- 计划通过前，执行者应能在不重新决定产品语义或重做架构设计的前提下开始 Apply。会改变数据归属、调用路径、一致性或发布顺序的候选路线不得留给 Apply 临时选择。跨越可独立发布、失败或验证边界的 task，未经核实却被当成既定事实的外部依赖，以及无法证明已声明行为或设计直接风险的测试契约，都会削弱这一条件。
+- 检查计划自己声明的关键不变量是否在迁移、兼容、回退和失败路径下仍成立；新旧实现同时存在且可能承担同一写入责任时，计划应明确权威写入边界，避免实现阶段重新决定所有权。
+- 需求语义未闭合的问题属于 Explore；需求结果已经明确、但不同可行路线会改变迁移、兼容、数据归属、发布、成本或长期责任边界时，计划应让使用者明确选择。只有内部实现不同且不改变这些结果时，不得要求新增用户决定。
 
 建议只能说明需补足的事实、范围或闭环，不能把个人技术偏好、新基础设施或额外测试升级为强制要求。已声明行为及其直接边界有充分证据时停止。
 

package/templates/workflow/prompts/test-engineer.md

@@ -22,6 +22,7 @@ argument-hint: "本次测试审查说明"
 - 测试应证明用户或调用方可观察的结果；预期值应来自规格、示例或独立计算，而不是复刻被测实现。
 - 复用基础设施或既有测试时，只补本次接入的最小证明；不因理论上的长期风险重测未改变机制。
 - 数据传递、字段形态或 producer-to-consumer 契约变化时，测试或其他可信证据必须证明目标输入按新契约抵达 consumer；只证明 consumer 算法不足以证明链路。
+- 从已采纳方案实际引入的责任边界和失败方式推导测试义务。例如只有异步投影、一致性窗口、批量范围变更、租户路由、缓存陈旧或跨运行时版本差确实由本次方案产生并影响验收时，才要求相应证明；不要把这些例子当作所有 change 的固定矩阵。
 - 已采纳的方案和验收约束决定测试义务。技术偏好、未采纳架构、通用故障矩阵和审查建议不能自行升级为必须新增的测试。
 
 ### 证明力审查

package/templates/workflow/skills/superspec-apply/SKILL.md

@@ -16,10 +16,12 @@ metadata:
 
 每个 task 使用同一循环：
 
-1. 对照 task 的执行依据，确认要实现的行为、边界和相关测试仍与当前计划一致。
+1. 开始 task 前先检查当前工作区变化，并沿 task 引用链核对发生变化的需求源或计划材料；确认要实现的行为、边界和相关测试仍与当前计划一致。新变化使已批准行为、验收、边界或方案失效时，不按旧计划继续，停止实现并交回 Propose。
 2. 在授权范围内实现最小改动；不要提前修改计划材料或扩大范围。
 3. 完成当前 task 要求的验证，如实报告测试、环境或覆盖不足的结果。
-4. 完成后再继续工作流。
+4. 当前 task 完成后立即继续工作流并处理下一事项；不要总结交付或等待用户再次要求继续。
+
+验证和登记所需的执行顺序、固定语义与提交方式以工作流当前返回为准；执行者只补充真实命令、工作目录和退出结果。不要通过阅读 CLI 或引擎源码猜测证据格式。
 
 不要伪造完成结果、验证材料或审查结论。
 
@@ -30,7 +32,9 @@ metadata:
 - 优先沿用仓库已有的验证边界，证明用户或调用方可观察的结果。
 - 不为方便测试改变生产设计，也不把测试偏好升级为额外的开发步骤或测试义务。
 
-## 何时停止
+## 连续执行与停止
+
+完成单个 task、测试通过或文件修改完成都不是暂停条件。只有工作流明确需要用户决定、当前独立工作项仍在执行、遇到无法在当前范围内解决的真实阻塞，或整个 change 已完成时才暂停。
 
 当前 task 尚未完成时，自测发现仍属于该 task 已批准行为和边界的实现问题，直接修正并完成要求的验证；不要为同一实现缺陷新增 task 或回 propose。