@peterxiaoyang/superspec 0.1.10 → 0.1.12

package/dist/src/apply_worker_chain_lifecycle.js

@@ -1,5 +1,6 @@
-import { isObject, reason, renderList, repr } from "./util.js";
-import { find_pass, live_pass } from "./evidence.js";
+import { NO_TDD_REASONS, isObject, reason, renderList, repr } from "./util.js";
+import { find_pass, live_pass, live_user_confirmations } from "./evidence.js";
+import { effective_superseded_ids } from "./openspec.js";
 import { apply_worker_implementation_fingerprint, apply_worker_executor_input_ref_digest, compute_apply_worker_freshness, fingerprint_matches, pinned_artifact_ref_reasons as shared_pinned_artifact_ref_reasons, pre_edit_evidence_ref_reasons, read_pinned_artifact_json, worker_input_ref_digest, worker_test_run_reasons, } from "./apply_worker_chain.js";
 function pinned_artifact_ref_matches(changeRoot, refItem, role, taskId, chainId, kind = "worker_report") {
     return shared_pinned_artifact_ref_reasons(changeRoot, refItem, `${role}_ref`, { kind, role, taskId, chainId }).length === 0;
@@ -25,6 +26,23 @@ function chain_green_ids(ev) {
         : String(ev.green_test_run_evidence_ref ?? "");
     return greenId ? [greenId] : [];
 }
+function chain_alternative_ids(ev) {
+    const refs = new Set();
+    if (Array.isArray(ev.alternative_verification_evidence_refs)) {
+        for (const item of ev.alternative_verification_evidence_refs) {
+            if (isObject(item) && typeof item.evidence_id === "string" && item.evidence_id)
+                refs.add(item.evidence_id);
+            else if (typeof item === "string" && item)
+                refs.add(item);
+        }
+    }
+    const single = ev.alternative_verification_evidence_ref;
+    if (isObject(single) && typeof single.evidence_id === "string" && single.evidence_id)
+        refs.add(single.evidence_id);
+    else if (typeof single === "string" && single)
+        refs.add(single);
+    return [...refs].sort();
+}
 function active_pre_edit_input_refs(evidences, active) {
     const preIds = Array.isArray(active.pre_edit_evidence_refs) ? active.pre_edit_evidence_refs.map(String) : [];
     return preIds.map((evidenceId) => {
@@ -34,13 +52,42 @@ function active_pre_edit_input_refs(evidences, active) {
             : { kind: "test_run", evidence_id: evidenceId };
     });
 }
+function active_chain_verifier_input_ref(active) {
+    const result = {
+        kind: "apply_worker_chain",
+        evidence_id: active.evidence_id,
+        task_id: active.task_id,
+        apply_worker_chain_id: active.apply_worker_chain_id,
+        pre_edit_proof_kind: active.pre_edit_proof_kind ?? "red_or_characterization",
+        pre_edit_evidence_refs: Array.isArray(active.pre_edit_evidence_refs) ? active.pre_edit_evidence_refs.map(String).filter(Boolean).sort() : [],
+    };
+    for (const field of ["apply_execution_surface", "tdd_required", "no_tdd_reason"]) {
+        if (active[field] !== undefined)
+            result[field] = active[field];
+    }
+    return result;
+}
+function active_no_tdd_declared_valid(active) {
+    const preIds = Array.isArray(active.pre_edit_evidence_refs) ? active.pre_edit_evidence_refs.map(String).filter(Boolean) : [];
+    return active.pre_edit_proof_kind === "no_tdd_declared"
+        && preIds.length === 0
+        && active.tdd_required === false
+        && (active.apply_execution_surface === "implementation" || active.apply_execution_surface === "runtime_config")
+        && NO_TDD_REASONS.has(String(active.no_tdd_reason ?? ""));
+}
+function alternative_evidence_input_ref(ev) {
+    return {
+        kind: ev.kind,
+        evidence_id: ev.evidence_id,
+        gate: ev.gate,
+        task_id: ev.task_id,
+    };
+}
 function closed_apply_worker_chain_valid(repoRoot, changeRoot, ev, evidences, taskId, chainId) {
     const active = live_pass(evidences, { gate: "task_complete", kind: "apply_worker_chain", task_id: taskId })
         .find((item) => item.chain_state === "active" && item.apply_worker_chain_id === chainId);
     if (!active)
         return false;
-    if (pre_edit_evidence_ref_reasons(evidences, active, taskId).length > 0)
-        return false;
     if (!pinned_artifact_ref_matches(changeRoot, ev.executor_report_ref, "executor", taskId, chainId))
         return false;
     if (!pinned_artifact_ref_matches(changeRoot, ev.task_code_review_report_ref, "code-reviewer", taskId, chainId))
@@ -59,6 +106,47 @@ function closed_apply_worker_chain_valid(repoRoot, changeRoot, ev, evidences, ta
     const verifierObserved = verifierReport?.observed_freshness_fingerprint ?? (isObject(ev.verifier_report_ref) ? ev.verifier_report_ref.observed_freshness_fingerprint : undefined);
     if (!fingerprint_matches(verifierObserved, ev.observed_freshness_fingerprint))
         return false;
+    const completionProofKind = String(ev.completion_proof_kind ?? "green_tests");
+    if (completionProofKind !== "green_tests" && completionProofKind !== "alternative_verification")
+        return false;
+    const preEditProofKind = String(active.pre_edit_proof_kind ?? "red_or_characterization");
+    if (completionProofKind === "green_tests" && preEditProofKind !== "red_or_characterization")
+        return false;
+    if (completionProofKind === "alternative_verification" && !active_no_tdd_declared_valid(active))
+        return false;
+    if (pre_edit_evidence_ref_reasons(changeRoot, evidences, active, taskId).length > 0)
+        return false;
+    if (completionProofKind === "alternative_verification") {
+        const alternativeIds = chain_alternative_ids(ev);
+        if (alternativeIds.length === 0)
+            return false;
+        const alternatives = alternativeIds.map((evidenceId) => live_pass(evidences, { gate: "task_complete", task_id: taskId })
+            .find((item) => (String(item.evidence_id ?? "") === evidenceId
+            && (item.kind === "alternative_verification" || item.kind === "manual_verification")))).filter((item) => isObject(item));
+        if (alternatives.length !== alternativeIds.length)
+            return false;
+        if (!report_input_refs_match(ev.verifier_report_ref, [
+            ev.executor_report_ref,
+            ev.task_code_review_report_ref,
+            ...alternatives.map(alternative_evidence_input_ref),
+            active_chain_verifier_input_ref(active),
+        ]))
+            return false;
+        const currentFreshness = compute_apply_worker_freshness(repoRoot, changeRoot, evidences, taskId, chainId, {
+            executor_report_ref: ev.executor_report_ref,
+            task_code_review_report_ref: ev.task_code_review_report_ref,
+            alternative_verification_evidence_refs: alternativeIds,
+            completion_proof_kind: "alternative_verification",
+            verifier_report_ref: ev.verifier_report_ref,
+        });
+        if (Array.isArray(currentFreshness.unexpected_guard_owned_dirty_paths) && currentFreshness.unexpected_guard_owned_dirty_paths.length > 0)
+            return false;
+        if (Array.isArray(currentFreshness.protected_dirty_paths) && currentFreshness.protected_dirty_paths.length > 0)
+            return false;
+        if (!fingerprint_matches(isObject(ev.task_code_review_report_ref) ? ev.task_code_review_report_ref.observed_implementation_fingerprint : undefined, currentFreshness.implementation_fingerprint))
+            return false;
+        return fingerprint_matches(currentFreshness, verifierObserved);
+    }
     const greenIds = chain_green_ids(ev);
     if (greenIds.length === 0)
         return false;
@@ -82,6 +170,7 @@ function closed_apply_worker_chain_valid(repoRoot, changeRoot, ev, evidences, ta
         task_code_review_report_ref: ev.task_code_review_report_ref,
         green_test_run_evidence_ref: greenIds[0],
         green_test_run_evidence_refs: greenIds,
+        completion_proof_kind: "green_tests",
         verifier_report_ref: ev.verifier_report_ref,
     });
     if (Array.isArray(currentFreshness.unexpected_guard_owned_dirty_paths) && currentFreshness.unexpected_guard_owned_dirty_paths.length > 0)
@@ -97,9 +186,37 @@ function closed_apply_worker_chain_valid(repoRoot, changeRoot, ev, evidences, ta
 function pinned_takeover_baseline_valid(changeRoot, refItem, taskId, chainId) {
     return shared_pinned_artifact_ref_reasons(changeRoot, refItem, "serial_takeover_baseline_ref", { kind: "status_report", role: "verifier", taskId, chainId }).length === 0;
 }
-function abandoned_apply_worker_chain_valid(repoRoot, changeRoot, ev, active, taskId, chainId) {
+function serial_takeover_baseline_ref_ids(ev) {
+    const refs = new Set();
+    if (isObject(ev.serial_takeover_baseline_ref)) {
+        for (const field of ["path", "ref_path", "evidence_id"]) {
+            const value = ev.serial_takeover_baseline_ref[field];
+            if (typeof value === "string" && value)
+                refs.add(value);
+        }
+    }
+    return [...refs].sort();
+}
+function serial_takeover_confirmation_valid(evidences, ev, active) {
+    const confirmationId = String(ev.takeover_confirmation_evidence_id ?? "");
+    const activeId = String(active.evidence_id ?? "");
+    const baselineIds = serial_takeover_baseline_ref_ids(ev);
+    if (!confirmationId || !activeId || baselineIds.length === 0)
+        return false;
+    const confirmation = live_user_confirmations(evidences, "serial_takeover")
+        .find((item) => String(item.evidence_id ?? "") === confirmationId);
+    if (!confirmation)
+        return false;
+    const confirmed = new Set(Array.isArray(confirmation.confirmed_refs) ? confirmation.confirmed_refs.map(String).filter(Boolean) : []);
+    return confirmed.has(activeId) && baselineIds.some((item) => confirmed.has(item));
+}
+function abandoned_apply_worker_chain_valid(repoRoot, changeRoot, ev, active, evidences, taskId, chainId) {
     if (!active)
         return false;
+    const hasRestored = "restored_implementation_fingerprint" in ev;
+    const hasSerialTakeover = "serial_takeover_baseline_ref" in ev;
+    if (hasRestored && hasSerialTakeover)
+        return false;
     if ("restored_implementation_fingerprint" in ev) {
         const activeScope = Array.isArray(active.declared_task_write_scope) ? active.declared_task_write_scope.map(String).filter(Boolean) : [];
         const current = apply_worker_implementation_fingerprint(repoRoot, changeRoot, [], { declaredTaskWriteScope: activeScope });
@@ -107,21 +224,16 @@ function abandoned_apply_worker_chain_valid(repoRoot, changeRoot, ev, active, ta
             && fingerprint_matches(current, active.source_implementation_fingerprint))
             return true;
     }
-    if ("serial_takeover_baseline_ref" in ev) {
+    if (hasSerialTakeover) {
         return pinned_takeover_baseline_valid(changeRoot, ev.serial_takeover_baseline_ref, taskId, chainId)
-            && Array.isArray(ev.successor_green_evidence_refs)
-            && ev.successor_green_evidence_refs.length > 0
-            && ev.successor_green_evidence_refs.every((item) => typeof item === "string" && item.length > 0);
+            && serial_takeover_confirmation_valid(evidences, ev, active);
     }
     return false;
 }
-export function serial_completion_green(ev) {
-    return (ev.runner_origin === undefined || ev.runner_origin === "main-thread")
-        && ev.apply_execution_chain !== "executor_worker"
-        && typeof ev.apply_worker_chain_id !== "string";
-}
 export function apply_worker_chain_lifecycle_state(repoRoot, changeRoot, evidences, taskId) {
     const chains = find_pass(evidences, { gate: "task_complete", kind: "apply_worker_chain", task_id: taskId });
+    const supersededIds = effective_superseded_ids(evidences);
+    const liveChainMarker = (ev) => !supersededIds.has(String(ev.evidence_id ?? ""));
     const activeByChain = new Map();
     const activeCounts = new Map();
     for (const ev of chains) {
@@ -147,9 +259,9 @@ export function apply_worker_chain_lifecycle_state(repoRoot, changeRoot, evidenc
         if (String(ev.chain_state ?? "") === "closed")
             valid = closed_apply_worker_chain_valid(repoRoot, changeRoot, ev, evidences, taskId, chainId);
         if (String(ev.chain_state ?? "") === "abandoned")
-            valid = abandoned_apply_worker_chain_valid(repoRoot, changeRoot, ev, activeByChain.get(chainId), taskId, chainId);
+            valid = abandoned_apply_worker_chain_valid(repoRoot, changeRoot, ev, activeByChain.get(chainId), evidences, taskId, chainId);
         terminalValidity.set(ev, valid);
-        return valid;
+        return valid && liveChainMarker(ev);
     })
         .map((ev) => String(ev.apply_worker_chain_id ?? ""))
         .filter(Boolean));
@@ -158,7 +270,7 @@ export function apply_worker_chain_lifecycle_state(repoRoot, changeRoot, evidenc
         .filter((ev) => {
         const chainId = String(ev.apply_worker_chain_id ?? "");
         const valid = String(ev.chain_state ?? "") === "closed" && (terminalValidity.get(ev) ?? closed_apply_worker_chain_valid(repoRoot, changeRoot, ev, evidences, taskId, chainId));
-        return chainId && valid;
+        return chainId && valid && liveChainMarker(ev);
     })
         .map((ev) => String(ev.apply_worker_chain_id ?? ""))
         .filter(Boolean));
@@ -166,10 +278,24 @@ export function apply_worker_chain_lifecycle_state(repoRoot, changeRoot, evidenc
         .filter((ev) => {
         const chainId = String(ev.apply_worker_chain_id ?? "");
         const valid = String(ev.chain_state ?? "") === "closed" && (terminalValidity.get(ev) ?? closed_apply_worker_chain_valid(repoRoot, changeRoot, ev, evidences, taskId, chainId));
-        return chainId && valid;
+        return chainId && valid && liveChainMarker(ev);
     })
         .flatMap(chain_green_ids));
-    const takeoverBaselines = [];
+    const validClosedAlternativeChainIds = new Set(chains
+        .filter((ev) => {
+        const chainId = String(ev.apply_worker_chain_id ?? "");
+        const valid = String(ev.chain_state ?? "") === "closed" && String(ev.completion_proof_kind ?? "green_tests") === "alternative_verification" && (terminalValidity.get(ev) ?? closed_apply_worker_chain_valid(repoRoot, changeRoot, ev, evidences, taskId, chainId));
+        return chainId && valid && liveChainMarker(ev);
+    })
+        .map((ev) => String(ev.apply_worker_chain_id ?? ""))
+        .filter(Boolean));
+    const validClosedAlternativeEvidenceIds = new Set(chains
+        .filter((ev) => {
+        const chainId = String(ev.apply_worker_chain_id ?? "");
+        const valid = String(ev.chain_state ?? "") === "closed" && String(ev.completion_proof_kind ?? "green_tests") === "alternative_verification" && (terminalValidity.get(ev) ?? closed_apply_worker_chain_valid(repoRoot, changeRoot, ev, evidences, taskId, chainId));
+        return chainId && valid && liveChainMarker(ev);
+    })
+        .flatMap(chain_alternative_ids));
     const completionReasons = [];
     const duplicateActives = [...activeCounts.entries()]
         .filter(([chainId]) => openActiveChainIds.has(chainId))
@@ -206,6 +332,7 @@ export function apply_worker_chain_lifecycle_state(repoRoot, changeRoot, evidenc
     if (duplicateTerminals.length > 0) {
         completionReasons.push(reason("apply_worker_chain_terminal_conflict", `task ${taskId} has duplicate apply worker chain terminal markers: ${renderList(duplicateTerminals)}`, duplicateTerminals));
     }
+    const takeoverbaselines = [];
     const invalidTerminals = chains
         .filter((ev) => String(ev.chain_state ?? "") === "closed" || String(ev.chain_state ?? "") === "abandoned")
         .filter((ev) => {
@@ -214,11 +341,11 @@ export function apply_worker_chain_lifecycle_state(repoRoot, changeRoot, evidenc
             return true;
         if (String(ev.chain_state ?? "") === "closed")
             return !(terminalValidity.get(ev) ?? closed_apply_worker_chain_valid(repoRoot, changeRoot, ev, evidences, taskId, chainId));
-        const valid = terminalValidity.get(ev) ?? abandoned_apply_worker_chain_valid(repoRoot, changeRoot, ev, activeByChain.get(chainId), taskId, chainId);
+        const valid = terminalValidity.get(ev) ?? abandoned_apply_worker_chain_valid(repoRoot, changeRoot, ev, activeByChain.get(chainId), evidences, taskId, chainId);
         if (valid && isObject(ev.serial_takeover_baseline_ref)) {
             const baseline = read_pinned_artifact_json(changeRoot, ev.serial_takeover_baseline_ref);
             if (baseline?.implementation_fingerprint !== undefined) {
-                takeoverBaselines.push({
+                takeoverbaselines.push({
                     fingerprint: baseline.implementation_fingerprint,
                     successorGreenRefs: Array.isArray(ev.successor_green_evidence_refs) ? ev.successor_green_evidence_refs.map(String).filter(Boolean) : [],
                 });
@@ -250,6 +377,8 @@ export function apply_worker_chain_lifecycle_state(repoRoot, changeRoot, evidenc
     if (duplicateTerminals.length > 0 || activeConflicts.length > 0) {
         validClosedChainIds.clear();
         validClosedGreenEvidenceIds.clear();
+        validClosedAlternativeChainIds.clear();
+        validClosedAlternativeEvidenceIds.clear();
     }
     const activeBlockingReasons = completionReasons.filter((item) => (item.code === "apply_worker_chain_active_conflict"
         || item.code === "apply_worker_chain_terminal_conflict"
@@ -270,7 +399,9 @@ export function apply_worker_chain_lifecycle_state(repoRoot, changeRoot, evidenc
         validTerminalChainIds: chainIdsWithTerminal,
         validClosedChainIds,
         validClosedGreenEvidenceIds,
-        takeoverBaselines,
+        validClosedAlternativeEvidenceIds,
+        validClosedAlternativeChainIds,
+        takeoverbaselines,
     };
 }
 export function apply_worker_chain_lifecycle_reasons(repoRoot, changeRoot, evidences, taskId) {

package/dist/src/cli_args.d.ts

@@ -21,6 +21,7 @@ export type ParsedArgs = {
     task_code_review_report_refs?: string[];
     apply_worker_chain_refs?: string[];
     green_test_run_evidence_refs?: string[];
+    alternative_verification_evidence_refs?: string[];
     red_test_run_evidence_refs?: string[];
     characterization_test_run_evidence_refs?: string[];
     create?: boolean;

package/dist/src/cli_args.js

@@ -48,6 +48,13 @@ function isPacketCommand(command) {
         || command === "apply-verify-packet"
         || command === "ledger-render";
 }
+function isHookEventCommand(command) {
+    return command === "hook-check-write"
+        || command === "hook-check-command"
+        || command === "hook-record-test"
+        || command === "hook-record-subagent-start"
+        || command === "hook-record-subagent-stop";
+}
 function requiredValueFlags(command) {
     const flags = ["--change"];
     if (command === "check-artifact")
@@ -67,11 +74,10 @@ function requiredValueFlags(command) {
     if (command === "apply-code-review-packet")
         flags.push("--task-id", "--executor-report-ref");
     if (command === "apply-verify-packet")
-        flags.push("--task-id", "--executor-report-ref", "--task-code-review-report-ref", "--green-test-run-evidence-ref");
+        flags.push("--task-id", "--executor-report-ref", "--task-code-review-report-ref");
     if (command === "ledger-render")
         flags.push("--gate");
-    if (command === "hook-check-write" || command === "hook-check-command" || command === "hook-record-test"
-        || command === "hook-record-subagent-start" || command === "hook-record-subagent-stop")
+    if (isHookEventCommand(command))
         flags.push("--event-ref");
     if (command === "hook-session-begin")
         flags.push("--workflow", "--entrypoint-token");
@@ -97,7 +103,7 @@ function optionalValueFlags(command) {
     if (command === "apply-executor-packet")
         return ["--apply-worker-chain-ref"];
     if (command === "apply-verify-packet")
-        return ["--red-test-run-evidence-ref", "--characterization-test-run-evidence-ref"];
+        return ["--green-test-run-evidence-ref", "--alternative-verification-evidence-ref", "--red-test-run-evidence-ref", "--characterization-test-run-evidence-ref"];
     if (command === "ledger-render")
         return ["--round"];
     if (command === "hook-session-end")
@@ -126,7 +132,7 @@ function requiresFormat(command) {
         || command === "apply-verify-packet";
 }
 function rootUsage() {
-    return `usage: superspec_guard [-h]\n                     {${COMMAND_LIST}}\n                     ...\n`;
+    return `usage: superspec [-h]\n                     {${COMMAND_LIST}}\n                     ...\n`;
 }
 function rootHelp() {
     const commandLines = COMMANDS.map((command) => {
@@ -144,7 +150,7 @@ function commandUsage(command) {
         ...requiredBooleanFlags(command),
         ...optionalBooleanFlags(command),
     ];
-    return `usage: superspec_guard ${command} ${usageFlags.join(" ")}\n`;
+    return `usage: superspec ${command} ${usageFlags.join(" ")}\n`;
 }
 function commandHelp(command) {
     const zh = command_zh(command);
@@ -179,7 +185,7 @@ function missingRequiredFlags(command, args) {
 }
 export function emitArgparsePreamble(argv) {
     if (argv.length === 0) {
-        process.stderr.write(`${rootUsage()}superspec_guard：错误：缺少必填参数：command\n`);
+        process.stderr.write(`${rootUsage()}superspec：错误：缺少必填参数：command\n`);
         return 2;
     }
     const command = argv[0];
@@ -188,7 +194,7 @@ export function emitArgparsePreamble(argv) {
         return 0;
     }
     if (!COMMANDS.includes(command)) {
-        process.stderr.write(`${rootUsage()}superspec_guard：错误：命令无效：'${command}'；可选值：${COMMAND_CHOICES}\n`);
+        process.stderr.write(`${rootUsage()}superspec：错误：命令无效：'${command}'；可选值：${COMMAND_CHOICES}\n`);
         return 2;
     }
     const args = argv.slice(1);
@@ -199,7 +205,11 @@ export function emitArgparsePreamble(argv) {
     if (!isPacketCommand(command)) {
         const missing = missingRequiredFlags(command, args);
         if (missing.length > 0) {
-            process.stderr.write(`${commandUsage(command)}superspec_guard ${command}：错误：缺少必填参数：${missing.join(", ")}\n`);
+            if (isHookEventCommand(command) && missing.length === 1 && missing[0] === "--event-ref") {
+                process.stderr.write(`${commandUsage(command)}superspec ${command}：错误：--event-ref must point to a readable hook event JSON file\n`);
+                return 2;
+            }
+            process.stderr.write(`${commandUsage(command)}superspec ${command}：错误：缺少必填参数：${missing.join(", ")}\n`);
             return 2;
         }
     }
@@ -357,6 +367,7 @@ export function parse_argv(argv) {
         const executorRefs = getValues("--executor-report-ref");
         const codeReviewRefs = getValues("--task-code-review-report-ref");
         const greenRefs = getValues("--green-test-run-evidence-ref");
+        const alternativeRefs = getValues("--alternative-verification-evidence-ref");
         const redRefs = getValues("--red-test-run-evidence-ref");
         const characterizationRefs = getValues("--characterization-test-run-evidence-ref");
         if (!taskId)
@@ -365,11 +376,18 @@ export function parse_argv(argv) {
             throw new GuardError("apply-verify-packet 缺少必填参数 --executor-report-ref");
         if (codeReviewRefs.length === 0)
             throw new GuardError("apply-verify-packet 缺少必填参数 --task-code-review-report-ref");
-        if (greenRefs.length === 0)
-            throw new GuardError("apply-verify-packet 缺少必填参数 --green-test-run-evidence-ref");
-        if (redRefs.length === 0 && characterizationRefs.length === 0) {
+        if (greenRefs.length === 0 && alternativeRefs.length === 0) {
+            throw new GuardError("apply-verify-packet requires --green-test-run-evidence-ref or --alternative-verification-evidence-ref");
+        }
+        if (greenRefs.length > 0 && alternativeRefs.length > 0) {
+            throw new GuardError("apply-verify-packet requires either GREEN refs or alternative verification refs, not both");
+        }
+        if (greenRefs.length > 0 && redRefs.length === 0 && characterizationRefs.length === 0) {
             throw new GuardError("apply-verify-packet requires --red-test-run-evidence-ref or --characterization-test-run-evidence-ref");
         }
+        if (alternativeRefs.length > 0 && (redRefs.length > 0 || characterizationRefs.length > 0)) {
+            throw new GuardError("apply-verify-packet alternative verification branch must not include RED or characterization refs");
+        }
         return {
             command,
             change,
@@ -377,6 +395,7 @@ export function parse_argv(argv) {
             executor_report_refs: executorRefs,
             task_code_review_report_refs: codeReviewRefs,
             green_test_run_evidence_refs: greenRefs,
+            alternative_verification_evidence_refs: alternativeRefs,
             red_test_run_evidence_refs: redRefs,
             characterization_test_run_evidence_refs: characterizationRefs,
             packet_format: parsePacketOutputFormat(selectedPacketFormat, { allowPrompt: true }),
@@ -394,11 +413,10 @@ export function parse_argv(argv) {
             throw new GuardError("--round 必须是大于等于 1 的整数");
         return { command, change, gate, round };
     }
-    if (command === "hook-check-write" || command === "hook-check-command" || command === "hook-record-test"
-        || command === "hook-record-subagent-start" || command === "hook-record-subagent-stop") {
+    if (isHookEventCommand(command)) {
         const eventRef = getValue("--event-ref");
         if (!eventRef)
-            throw new Error("缺少必填参数 --event-ref");
+            throw new GuardError("--event-ref must point to a readable hook event JSON file");
         return { command, change, format, event_ref: eventRef };
     }
     if (command === "hook-session-begin") {

package/dist/src/disclosure.js

@@ -10,7 +10,7 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join, relative } from "node:path";
 import { isObject, reason, renderList, repr, runtime, safe_within, toPosix, walkFiles } from "./util.js";
-import { normalize_gate } from "./openspec.js";
+import { effective_superseded_ids, normalize_gate } from "./openspec.js";
 // Explicit target map (design §7); later phases extend this table gate by gate.
 // Entries containing "*" are globs enumerated at check time; set equality (P1-6) means a spec
 // file added after the digest makes the digest stale even though every pinned blob still matches.
@@ -462,7 +462,7 @@ export function review_disclosure_reasons(gate, changeRoot, evidences) {
         return [reason("missing_review_digest", `${gate}: the disclosure loop is mandatory on this gate; need round-tagged role review evidence (review_round_id ${gate}-r1, findings[]) plus a main_review_digest`)];
     }
     const out = [];
-    const dead = new Set(valid.filter((ev) => ev.status === "superseded" && ev.supersedes).map((ev) => String(ev.supersedes)));
+    const dead = effective_superseded_ids(valid);
     const byId = new Map();
     for (const ev of valid) {
         if (typeof ev.evidence_id === "string" && ev.evidence_id)

package/dist/src/evidence.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join, relative } from "node:path";
-import { CLAIM_ADJUDICATION_DECISIONS, EVIDENCE_KINDS, EVIDENCE_STATUSES, FINAL_VERIFICATION_ROLES, HUMAN_CONFIRMATION_GATES, FINAL_TEST_REQUIRED_FIELDS, FINDING_ADJUDICATION_DECISIONS, FORBIDDEN_FIELDS, MAIN_ADJUDICATION_DECISIONS, MAIN_ADJUDICATION_REQUIRED_FIELDS, REQUEST_CHANGES_ROUTES, ROLE_EVIDENCE_FIELDS, REVIEW_GUIDANCE_ROLES, SELF_REVIEW_MARKERS, SOURCE_GUIDANCE_REQUIRED_FIELDS, TASK_REOPEN_INVALIDITY_CLASSES, TASK_REOPEN_REQUIRED_FIELDS, TASK_REOPEN_RESOLVED_REQUIRED_FIELDS, VERIFY_EVIDENCE_REQUIRED_FIELDS, fingerprint_obj, isObject, reason, renderList, repr, pinned_ref_key, runtime, safe_within, sha256_file, toPosix, walkFiles, } from "./util.js";
-import { normalize_gate } from "./openspec.js";
+import { CLAIM_ADJUDICATION_DECISIONS, EVIDENCE_KINDS, EVIDENCE_STATUSES, FINAL_VERIFICATION_ROLES, HUMAN_CONFIRMATION_GATES, FINAL_TEST_REQUIRED_FIELDS, FINDING_ADJUDICATION_DECISIONS, FORBIDDEN_FIELDS, MAIN_ADJUDICATION_DECISIONS, MAIN_ADJUDICATION_REQUIRED_FIELDS, NO_TDD_REASONS, REQUEST_CHANGES_ROUTES, ROLE_EVIDENCE_FIELDS, REVIEW_GUIDANCE_ROLES, SELF_REVIEW_MARKERS, SOURCE_GUIDANCE_REQUIRED_FIELDS, TASK_REOPEN_INVALIDITY_CLASSES, TASK_REOPEN_REQUIRED_FIELDS, TASK_REOPEN_RESOLVED_REQUIRED_FIELDS, VERIFY_EVIDENCE_REQUIRED_FIELDS, confirmation_text_has_pending_wording, fingerprint_obj, isObject, reason, renderList, repr, pinned_ref_key, runtime, safe_within, sha256_file, toPosix, UNCHECKED_CHECKBOX_RE, walkFiles, } from "./util.js";
+import { effective_superseded_ids, normalize_gate } from "./openspec.js";
 import { superspec_dir } from "./paths.js";
 import { findings_schema_reasons, review_digest_schema_reasons, standing_authorization_schema_reasons, user_decision_schema_reasons, } from "./disclosure.js";
 import { pinned_artifact_ref_reasons as shared_pinned_artifact_ref_reasons, worker_test_run_reasons, } from "./apply_worker_chain.js";
@@ -143,6 +143,24 @@ function string_list_field_reasons(ev, field, code, opts = {}) {
     }
     return [];
 }
+const APPLY_WORKER_CHAIN_SURFACES = new Set(["implementation", "runtime_config"]);
+function apply_worker_chain_ref_ids(ev, singleField, listField) {
+    const refs = new Set();
+    const single = ev[singleField];
+    if (isObject(single) && typeof single.evidence_id === "string" && single.evidence_id)
+        refs.add(single.evidence_id);
+    else if (typeof single === "string" && single)
+        refs.add(single);
+    if (Array.isArray(ev[listField])) {
+        for (const item of ev[listField]) {
+            if (isObject(item) && typeof item.evidence_id === "string" && item.evidence_id)
+                refs.add(item.evidence_id);
+            else if (typeof item === "string" && item)
+                refs.add(item);
+        }
+    }
+    return [...refs].sort();
+}
 function fingerprint_field_reasons(ev, field, code) {
     const raw = ev[field];
     if (typeof raw === "string") {
@@ -161,7 +179,37 @@ function pinned_artifact_ref_item_reasons(refItem, field, changeRoot, expected =
     });
 }
 export function role_target_ref_reasons(ev, targetRoot) {
-    return pinned_ref_reasons(ev, "target_refs", targetRoot, "stale_review");
+    const problems = [];
+    const raw = ev.target_refs;
+    if (!Array.isArray(raw)) {
+        problems.push(reason("target_ref_invalid", `${ev._path}: target_refs must be a list of {path, blob_sha}`));
+        return problems;
+    }
+    for (const refItem of raw) {
+        if (!isObject(refItem)) {
+            problems.push(reason("target_ref_invalid", `${ev._path}: target_refs item must be object`));
+            continue;
+        }
+        const rel = refItem.path;
+        const expected = refItem.blob_sha;
+        if (typeof rel !== "string" || !rel || typeof expected !== "string" || !expected) {
+            problems.push(reason("target_ref_invalid", `${ev._path}: target_refs requires path and blob_sha`));
+            continue;
+        }
+        const target = safe_within(targetRoot, rel);
+        if (target === null) {
+            problems.push(reason("evidence_unsafe_ref", `${ev._path}: target_refs escapes allowed root: ${rel}`));
+            continue;
+        }
+        if (!existsSync(target) || !statSync(target).isFile()) {
+            problems.push(reason("stale_review", `${ev._path}: target_refs is not readable: ${rel}`));
+            continue;
+        }
+        const actual = runtime.file_blob_sha(target);
+        if (actual !== expected)
+            problems.push(reason("stale_review", `${ev._path}: target_refs stale for ${rel}`));
+    }
+    return problems;
 }
 export function loaded_ref_reasons(ev, repoRoot) {
     return pinned_ref_reasons(ev, "loaded_refs", repoRoot, "stale_loaded_ref");
@@ -358,6 +406,16 @@ function human_confirmation_reasons(ev) {
         && (typeof ev.tasks_structure_hash !== "string" || !ev.tasks_structure_hash.trim())) {
         problems.push(reason("human_confirmation_invalid", `${ev._path}: ${gate} human_confirmation requires tasks_structure_hash pinning the approved tasks.md structure`));
     }
+    // B3: a pass confirmation must not carry unresolved signals. Strong signal: an unchecked checkbox
+    // "[ ]" pasted into confirmation_text (the agent copied an open question list into the confirmation).
+    // Weak signal: confirmation-pending wording shared with the explore gate (仍需确认 / 待确认 / ...),
+    // scoped to confirmation semantics so legitimate "细节仍需在 propose 细化" prose is not flagged.
+    // Real incident: secondment-hour-unit-support sealed status:"pass" while its confirmation_text said
+    // "还需要评估..." — the gate's presence-check then let propose through with 8 open questions.
+    const ctext = typeof ev.confirmation_text === "string" ? ev.confirmation_text : "";
+    if (UNCHECKED_CHECKBOX_RE.test(ctext) || confirmation_text_has_pending_wording(ctext)) {
+        problems.push(reason("human_confirmation_invalid", `${ev._path}: confirmation_text carries unresolved signals (unchecked checkbox or 「仍需确认/待确认」wording); do not record pass while open items remain`));
+    }
     return problems;
 }
 // FIX-10 (audit C-5/H-4): test_run evidence is archived per run, not as a bare self-report.
@@ -455,7 +513,28 @@ function apply_worker_chain_reasons(ev, changeRoot) {
         problems.push(...fingerprint_field_reasons(ev, "executor_packet_fingerprint", "apply_worker_chain_invalid"));
         problems.push(...fingerprint_field_reasons(ev, "source_implementation_fingerprint", "apply_worker_chain_invalid"));
         problems.push(...string_list_field_reasons(ev, "declared_task_write_scope", "apply_worker_chain_invalid"));
-        problems.push(...string_list_field_reasons(ev, "pre_edit_evidence_refs", "apply_worker_chain_invalid"));
+        const proofKind = String(ev.pre_edit_proof_kind ?? "red_or_characterization");
+        if (proofKind !== "red_or_characterization" && proofKind !== "no_tdd_declared") {
+            problems.push(reason("apply_worker_chain_invalid", `${ev._path}: active apply_worker_chain pre_edit_proof_kind must be red_or_characterization or no_tdd_declared`));
+        }
+        else if (proofKind === "no_tdd_declared") {
+            problems.push(...string_list_field_reasons(ev, "pre_edit_evidence_refs", "apply_worker_chain_invalid", { allowEmpty: true }));
+            if (Array.isArray(ev.pre_edit_evidence_refs) && ev.pre_edit_evidence_refs.length > 0) {
+                problems.push(reason("apply_worker_chain_invalid", `${ev._path}: no_tdd_declared active apply_worker_chain requires empty pre_edit_evidence_refs`));
+            }
+            if (ev.tdd_required !== false) {
+                problems.push(reason("apply_worker_chain_invalid", `${ev._path}: no_tdd_declared active apply_worker_chain requires tdd_required=false`));
+            }
+            if (!APPLY_WORKER_CHAIN_SURFACES.has(String(ev.apply_execution_surface ?? ""))) {
+                problems.push(reason("apply_worker_chain_invalid", `${ev._path}: no_tdd_declared active apply_worker_chain requires apply_execution_surface implementation or runtime_config`));
+            }
+            if (!NO_TDD_REASONS.has(String(ev.no_tdd_reason ?? ""))) {
+                problems.push(reason("apply_worker_chain_invalid", `${ev._path}: no_tdd_declared active apply_worker_chain requires valid no_tdd_reason`));
+            }
+        }
+        else {
+            problems.push(...string_list_field_reasons(ev, "pre_edit_evidence_refs", "apply_worker_chain_invalid"));
+        }
     }
     if (state === "closed") {
         const taskId = typeof ev.task_id === "string" ? ev.task_id : undefined;
@@ -468,8 +547,17 @@ function apply_worker_chain_reasons(ev, changeRoot) {
         problems.push(...refProblems);
         if (refProblems.length > 0)
             problems.push(reason("apply_worker_chain_invalid", `${ev._path}: closed apply_worker_chain report refs must be pinned same-chain worker reports`));
-        if (!isObject(ev.green_test_run_evidence_ref) && typeof ev.green_test_run_evidence_ref !== "string") {
-            problems.push(reason("apply_worker_chain_invalid", `${ev._path}: closed apply_worker_chain requires green_test_run_evidence_ref`));
+        const proofKind = String(ev.completion_proof_kind ?? "green_tests");
+        if (proofKind !== "green_tests" && proofKind !== "alternative_verification") {
+            problems.push(reason("apply_worker_chain_invalid", `${ev._path}: closed apply_worker_chain completion_proof_kind must be green_tests or alternative_verification`));
+        }
+        else if (proofKind === "green_tests") {
+            if (apply_worker_chain_ref_ids(ev, "green_test_run_evidence_ref", "green_test_run_evidence_refs").length === 0) {
+                problems.push(reason("apply_worker_chain_invalid", `${ev._path}: green_tests closed apply_worker_chain requires green_test_run_evidence_ref(s)`));
+            }
+        }
+        else if (apply_worker_chain_ref_ids(ev, "alternative_verification_evidence_ref", "alternative_verification_evidence_refs").length === 0) {
+            problems.push(reason("apply_worker_chain_invalid", `${ev._path}: alternative_verification closed apply_worker_chain requires alternative_verification_evidence_ref(s)`));
         }
         problems.push(...fingerprint_field_reasons(ev, "observed_freshness_fingerprint", "apply_worker_chain_invalid"));
     }
@@ -479,6 +567,9 @@ function apply_worker_chain_reasons(ev, changeRoot) {
         if ("restored_implementation_fingerprint" in ev) {
             problems.push(...fingerprint_field_reasons(ev, "restored_implementation_fingerprint", "apply_worker_chain_invalid"));
         }
+        if ("restored_implementation_fingerprint" in ev && "serial_takeover_baseline_ref" in ev) {
+            problems.push(reason("apply_worker_chain_invalid", `${ev._path}: abandoned apply_worker_chain restored_implementation_fingerprint and serial_takeover_baseline_ref are mutually exclusive`));
+        }
         if (!("restored_implementation_fingerprint" in ev) && !("serial_takeover_baseline_ref" in ev)) {
             problems.push(reason("apply_worker_chain_invalid", `${ev._path}: abandoned apply_worker_chain requires restored_implementation_fingerprint or serial_takeover_baseline_ref`));
         }
@@ -487,7 +578,12 @@ function apply_worker_chain_reasons(ev, changeRoot) {
             problems.push(...baselineProblems);
             if (baselineProblems.length > 0)
                 problems.push(reason("apply_worker_chain_invalid", `${ev._path}: abandoned apply_worker_chain serial_takeover_baseline_ref must be a pinned same-chain status_report`));
-            problems.push(...string_list_field_reasons(ev, "successor_green_evidence_refs", "apply_worker_chain_invalid"));
+            if (typeof ev.takeover_confirmation_evidence_id !== "string" || !ev.takeover_confirmation_evidence_id) {
+                problems.push(reason("apply_worker_chain_invalid", `${ev._path}: abandoned apply_worker_chain serial takeover requires takeover_confirmation_evidence_id`));
+            }
+            if ("successor_green_evidence_refs" in ev) {
+                problems.push(...string_list_field_reasons(ev, "successor_green_evidence_refs", "apply_worker_chain_invalid"));
+            }
         }
     }
     return problems;
@@ -915,7 +1011,7 @@ export function find_pass(evidences, filters = {}) {
     });
 }
 export function superseded_ids(evidences) {
-    return new Set(evidences.filter((ev) => ev.status === "superseded" && ev.supersedes).map((ev) => ev.supersedes));
+    return effective_superseded_ids(evidences);
 }
 // FIX-6 (audit C-2): supersede is a rollback mechanism, so it needs an authorization model.
 // A supersede evidence must point at an existing evidence_id, and a cross-gate supersede

package/dist/src/gates.d.ts

@@ -5,6 +5,7 @@ export declare function superspec_agent_reasons(repoRoot: string): Reason[];
 export declare function openspec_cli_capability_reasons(): Reason[];
 export declare function evidence_schema_guard(change: string, changeRoot: string, repoRoot: string, evidences: JsonMap[]): Reason[];
 export declare function check_init(change: string, status: JsonMap, repoRoot: string, changeRoot: string): Decision;
+export declare function discovery_open_question_count(discoveryPath: string): number;
 export declare function check_superspec_gate(change: string, status: JsonMap, changeRoot: string, evidences: JsonMap[], gateRaw: string): Decision;
 export declare function check_artifact(change: string, status: JsonMap, changeRoot: string, evidences: JsonMap[], artifact: string): Decision;
 export declare function check_task_reopen(change: string, status: JsonMap, changeRoot: string, evidences: JsonMap[], taskId: string): Decision;