@peterxiaoyang/superspec 0.1.5 → 0.1.7

package/dist/src/apply_worker_chain_lifecycle.d.ts

@@ -0,0 +1,19 @@
+import type { JsonMap, Reason } from "./util.ts";
+export type ApplyWorkerChainLifecycleState = {
+    completionReasons: Reason[];
+    packetBlockers: Reason[];
+    activeBlockingReasons: Reason[];
+    activePresence: "none" | "single_open" | "blocked";
+    active: JsonMap | null;
+    openActiveChainIds: Set<string>;
+    validTerminalChainIds: Set<string>;
+    validClosedChainIds: Set<string>;
+    validClosedGreenEvidenceIds: Set<string>;
+    takeoverBaselines: {
+        fingerprint: unknown;
+        successorGreenRefs: string[];
+    }[];
+};
+export declare function serial_completion_green(ev: JsonMap): boolean;
+export declare function apply_worker_chain_lifecycle_state(repoRoot: string, changeRoot: string, evidences: JsonMap[], taskId: string): ApplyWorkerChainLifecycleState;
+export declare function apply_worker_chain_lifecycle_reasons(repoRoot: string, changeRoot: string, evidences: JsonMap[], taskId: string): Reason[];

package/dist/src/apply_worker_chain_lifecycle.js

@@ -0,0 +1,278 @@
+import { isObject, reason, renderList, repr } from "./util.js";
+import { find_pass, live_pass } from "./evidence.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;
+}
+function executor_worker_test_run_refs_valid(changeRoot, ev, taskId, chainId) {
+    return worker_test_run_reasons(changeRoot, ev, taskId, chainId).length === 0;
+}
+function report_origin_matches(refItem, expected) {
+    return isObject(refItem) && typeof expected === "string" && refItem.origin_packet_fingerprint === expected;
+}
+function report_input_refs_match(refItem, refs) {
+    return isObject(refItem) && refItem.input_ref_digest === worker_input_ref_digest(refs);
+}
+function report_input_digest_matches(refItem, expectedDigest) {
+    return isObject(refItem) && refItem.input_ref_digest === expectedDigest;
+}
+function chain_green_ids(ev) {
+    if (Array.isArray(ev.green_test_run_evidence_refs)) {
+        return ev.green_test_run_evidence_refs.map(String).filter(Boolean).sort();
+    }
+    const greenId = isObject(ev.green_test_run_evidence_ref)
+        ? String(ev.green_test_run_evidence_ref.evidence_id ?? "")
+        : String(ev.green_test_run_evidence_ref ?? "");
+    return greenId ? [greenId] : [];
+}
+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) => {
+        const ev = live_pass(evidences, { kind: "test_run" }).find((item) => String(item.evidence_id ?? "") === evidenceId);
+        return ev
+            ? { kind: "test_run", evidence_id: evidenceId, phase: ev.phase, semantic_status: ev.semantic_status }
+            : { kind: "test_run", evidence_id: evidenceId };
+    });
+}
+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))
+        return false;
+    if (!pinned_artifact_ref_matches(changeRoot, ev.verifier_report_ref, "verifier", taskId, chainId))
+        return false;
+    if (!report_origin_matches(ev.executor_report_ref, active.executor_packet_fingerprint))
+        return false;
+    if (!report_input_digest_matches(ev.executor_report_ref, apply_worker_executor_input_ref_digest(evidences, active)))
+        return false;
+    if (!report_input_refs_match(ev.task_code_review_report_ref, [ev.executor_report_ref]))
+        return false;
+    if (typeof ev.observed_freshness_fingerprint !== "string" && !(isObject(ev.observed_freshness_fingerprint) && typeof ev.observed_freshness_fingerprint.fingerprint_digest === "string"))
+        return false;
+    const verifierReport = read_pinned_artifact_json(changeRoot, ev.verifier_report_ref);
+    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 greenIds = chain_green_ids(ev);
+    if (greenIds.length === 0)
+        return false;
+    const greenRuns = greenIds.map((greenId) => live_pass(evidences, { gate: "task_complete", kind: "test_run", task_id: taskId }).find((item) => (String(item.evidence_id ?? "") === greenId
+        && item.semantic_status === "expected_success"
+        && (item.phase === undefined || item.phase === "green")
+        && item.apply_execution_chain === "executor_worker"
+        && item.apply_worker_chain_id === chainId
+        && executor_worker_test_run_refs_valid(changeRoot, item, taskId, chainId)))).filter((item) => isObject(item));
+    if (greenRuns.length !== greenIds.length)
+        return false;
+    if (!report_input_refs_match(ev.verifier_report_ref, [
+        ev.executor_report_ref,
+        ev.task_code_review_report_ref,
+        ...greenRuns.map((green) => ({ kind: "test_run", evidence_id: String(green.evidence_id ?? ""), phase: green.phase, semantic_status: green.semantic_status })),
+        ...active_pre_edit_input_refs(evidences, 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,
+        green_test_run_evidence_ref: greenIds[0],
+        green_test_run_evidence_refs: greenIds,
+        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 (!greenRuns.every((green) => fingerprint_matches(green.implementation_fingerprint, currentFreshness.implementation_fingerprint)))
+        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);
+}
+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) {
+    if (!active)
+        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 });
+        if (fingerprint_matches(ev.restored_implementation_fingerprint, active.source_implementation_fingerprint)
+            && fingerprint_matches(current, active.source_implementation_fingerprint))
+            return true;
+    }
+    if ("serial_takeover_baseline_ref" in ev) {
+        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);
+    }
+    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 activeByChain = new Map();
+    const activeCounts = new Map();
+    for (const ev of chains) {
+        if (String(ev.chain_state ?? "") !== "active")
+            continue;
+        const chainId = String(ev.apply_worker_chain_id ?? "");
+        if (!chainId)
+            continue;
+        const bucket = activeCounts.get(chainId) ?? [];
+        bucket.push(ev);
+        activeCounts.set(chainId, bucket);
+        if (!activeByChain.has(chainId))
+            activeByChain.set(chainId, ev);
+    }
+    const chainIdsWithActive = new Set([...activeByChain.keys()]);
+    const terminalValidity = new Map();
+    const chainIdsWithTerminal = new Set(chains
+        .filter((ev) => {
+        const chainId = String(ev.apply_worker_chain_id ?? "");
+        if (!chainId)
+            return false;
+        let valid = false;
+        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);
+        terminalValidity.set(ev, valid);
+        return valid;
+    })
+        .map((ev) => String(ev.apply_worker_chain_id ?? ""))
+        .filter(Boolean));
+    const openActiveChainIds = new Set([...activeByChain.keys()].filter((chainId) => !chainIdsWithTerminal.has(chainId)));
+    const validClosedChainIds = new Set(chains
+        .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;
+    })
+        .map((ev) => String(ev.apply_worker_chain_id ?? ""))
+        .filter(Boolean));
+    const validClosedGreenEvidenceIds = new Set(chains
+        .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;
+    })
+        .flatMap(chain_green_ids));
+    const takeoverBaselines = [];
+    const completionReasons = [];
+    const duplicateActives = [...activeCounts.entries()]
+        .filter(([chainId]) => openActiveChainIds.has(chainId))
+        .map(([, items]) => items)
+        .filter((items) => items.length > 1)
+        .flatMap((items) => items.map((ev) => String(ev.evidence_id ?? ev.apply_worker_chain_id ?? "")))
+        .filter(Boolean)
+        .sort();
+    const openActiveValues = [...openActiveChainIds].map((chainId) => activeByChain.get(chainId)).filter((ev) => isObject(ev));
+    const parallelActives = openActiveValues.length > 1
+        ? openActiveValues.map((ev) => String(ev.evidence_id ?? ev.apply_worker_chain_id ?? "")).filter(Boolean).sort()
+        : [];
+    const activeConflicts = [...new Set([...duplicateActives, ...parallelActives])].sort();
+    if (activeConflicts.length > 0) {
+        completionReasons.push(reason("apply_worker_chain_active_conflict", `task ${taskId} has conflicting active apply worker chain markers: ${renderList(activeConflicts)}`, activeConflicts));
+    }
+    const terminalsByChain = new Map();
+    for (const ev of chains) {
+        const state = String(ev.chain_state ?? "");
+        if (state !== "closed" && state !== "abandoned")
+            continue;
+        const chainId = String(ev.apply_worker_chain_id ?? "");
+        if (!chainId)
+            continue;
+        const bucket = terminalsByChain.get(chainId) ?? [];
+        bucket.push(ev);
+        terminalsByChain.set(chainId, bucket);
+    }
+    const duplicateTerminals = [...terminalsByChain.values()]
+        .filter((items) => items.length > 1)
+        .flatMap((items) => items.map((ev) => String(ev.evidence_id ?? ev.apply_worker_chain_id ?? "")))
+        .filter(Boolean)
+        .sort();
+    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 invalidTerminals = chains
+        .filter((ev) => String(ev.chain_state ?? "") === "closed" || String(ev.chain_state ?? "") === "abandoned")
+        .filter((ev) => {
+        const chainId = String(ev.apply_worker_chain_id ?? "");
+        if (!chainId)
+            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);
+        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({
+                    fingerprint: baseline.implementation_fingerprint,
+                    successorGreenRefs: Array.isArray(ev.successor_green_evidence_refs) ? ev.successor_green_evidence_refs.map(String).filter(Boolean) : [],
+                });
+            }
+        }
+        return !valid;
+    })
+        .map((ev) => String(ev.evidence_id ?? ev.apply_worker_chain_id ?? ""))
+        .filter(Boolean)
+        .sort();
+    if (invalidTerminals.length > 0) {
+        completionReasons.push(reason("apply_worker_chain_terminal_invalid", `task ${taskId} has invalid apply worker chain terminal markers: ${renderList(invalidTerminals)}`, invalidTerminals));
+    }
+    for (const chainId of [...openActiveChainIds].sort()) {
+        if (!chainIdsWithTerminal.has(chainId)) {
+            completionReasons.push(reason("apply_worker_chain_active", `task ${taskId} has active apply worker chain and cannot use non-chain task completion: ${chainId}`, [chainId]));
+        }
+    }
+    for (const ev of evidences) {
+        if (!isObject(ev) || ev._invalid || ev.status !== "pass" || ev.task_id !== taskId)
+            continue;
+        const chainId = typeof ev.apply_worker_chain_id === "string" ? ev.apply_worker_chain_id : "";
+        if (!chainId)
+            continue;
+        if (!chainIdsWithActive.has(chainId)) {
+            completionReasons.push(reason("apply_worker_chain_missing_active", `task ${taskId} references apply_worker_chain_id=${repr(chainId)} without a matching active marker`, [chainId]));
+        }
+    }
+    if (duplicateTerminals.length > 0 || activeConflicts.length > 0) {
+        validClosedChainIds.clear();
+        validClosedGreenEvidenceIds.clear();
+    }
+    const activeBlockingReasons = completionReasons.filter((item) => (item.code === "apply_worker_chain_active_conflict"
+        || item.code === "apply_worker_chain_terminal_conflict"
+        || item.code === "apply_worker_chain_terminal_invalid"
+        || item.code === "apply_worker_chain_missing_active"));
+    const activePresence = activeBlockingReasons.length > 0
+        ? "blocked"
+        : openActiveValues.length === 1
+            ? "single_open"
+            : "none";
+    return {
+        completionReasons,
+        packetBlockers: activeBlockingReasons,
+        activeBlockingReasons,
+        activePresence,
+        active: activePresence === "single_open" ? openActiveValues[0] : null,
+        openActiveChainIds,
+        validTerminalChainIds: chainIdsWithTerminal,
+        validClosedChainIds,
+        validClosedGreenEvidenceIds,
+        takeoverBaselines,
+    };
+}
+export function apply_worker_chain_lifecycle_reasons(repoRoot, changeRoot, evidences, taskId) {
+    return apply_worker_chain_lifecycle_state(repoRoot, changeRoot, evidences, taskId).completionReasons;
+}

package/dist/src/cli_args.d.ts

@@ -7,9 +7,17 @@ export type ParsedArgs = {
     artifact?: string;
     gate?: string;
     task_id?: string;
+    test_id?: string;
+    phase?: "red" | "characterization" | "green";
     role?: string;
     evidence_kind?: string;
     round?: number;
+    executor_report_refs?: string[];
+    task_code_review_report_refs?: string[];
+    apply_worker_chain_refs?: string[];
+    green_test_run_evidence_refs?: string[];
+    red_test_run_evidence_refs?: string[];
+    characterization_test_run_evidence_refs?: string[];
     create?: boolean;
     force_unlock?: boolean;
     rebuild_corrupt?: boolean;

package/dist/src/cli_args.js

@@ -22,12 +22,22 @@ const COMMANDS = [
     "check-task-complete",
     "workflow-packet",
     "review-packet",
+    "apply-test-packet",
+    "apply-executor-packet",
+    "apply-code-review-packet",
+    "apply-verify-packet",
     "ledger-render",
 ];
 const COMMAND_LIST = COMMANDS.join(",");
 const COMMAND_CHOICES = COMMANDS.map((item) => `'${item}'`).join(", ");
 function isPacketCommand(command) {
-    return command === "workflow-packet" || command === "review-packet" || command === "ledger-render";
+    return command === "workflow-packet"
+        || command === "review-packet"
+        || command === "apply-test-packet"
+        || command === "apply-executor-packet"
+        || command === "apply-code-review-packet"
+        || command === "apply-verify-packet"
+        || command === "ledger-render";
 }
 function requiredValueFlags(command) {
     const flags = ["--change"];
@@ -41,6 +51,14 @@ function requiredValueFlags(command) {
         flags.push("--gate");
     if (command === "review-packet")
         flags.push("--gate", "--role", "--round");
+    if (command === "apply-test-packet")
+        flags.push("--task-id", "--test-id", "--phase");
+    if (command === "apply-executor-packet")
+        flags.push("--task-id");
+    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");
     if (command === "ledger-render")
         flags.push("--gate");
     return flags;
@@ -58,6 +76,12 @@ function optionalValueFlags(command) {
         return ["--task-id"];
     if (command === "review-packet")
         return ["--kind"];
+    if (command === "apply-test-packet")
+        return ["--task-code-review-report-ref"];
+    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"];
     if (command === "ledger-render")
         return ["--round"];
     return [];
@@ -65,14 +89,23 @@ function optionalValueFlags(command) {
 function formatUsage(command) {
     if (command === "workflow-packet")
         return "--format {agent}";
-    if (command === "review-packet")
+    if (command === "review-packet"
+        || command === "apply-test-packet"
+        || command === "apply-executor-packet"
+        || command === "apply-code-review-packet"
+        || command === "apply-verify-packet")
         return "--format {agent,prompt}";
     if (command === "ledger-render")
         return null;
     return "[--format {json,agent,user}]";
 }
 function requiresFormat(command) {
-    return command === "workflow-packet" || command === "review-packet";
+    return command === "workflow-packet"
+        || command === "review-packet"
+        || command === "apply-test-packet"
+        || command === "apply-executor-packet"
+        || command === "apply-code-review-packet"
+        || command === "apply-verify-packet";
 }
 function rootUsage() {
     return `usage: superspec_guard [-h]\n                     {${COMMAND_LIST}}\n                     ...\n`;
@@ -173,14 +206,19 @@ export function parse_argv(argv) {
     };
     const getValue = (flag) => getValues(flag)[0];
     const formatValues = getValues("--format");
-    const isPacketOutputCommand = command === "workflow-packet" || command === "review-packet";
+    const isPacketOutputCommand = command === "workflow-packet"
+        || command === "review-packet"
+        || command === "apply-test-packet"
+        || command === "apply-executor-packet"
+        || command === "apply-code-review-packet"
+        || command === "apply-verify-packet";
     const isPacketCommand = isPacketOutputCommand || command === "ledger-render";
     const selectedPacketFormat = formatValues.length > 0 ? formatValues[formatValues.length - 1] : undefined;
     if (isPacketOutputCommand) {
         if (!selectedPacketFormat)
             throw new GuardError("缺少必填参数 --format");
         for (const value of formatValues)
-            parsePacketOutputFormat(value, { allowPrompt: command === "review-packet" });
+            parsePacketOutputFormat(value, { allowPrompt: command !== "workflow-packet" });
     }
     else {
         for (const value of formatValues)
@@ -248,6 +286,84 @@ export function parse_argv(argv) {
             packet_format: parsePacketOutputFormat(selectedPacketFormat, { allowPrompt: true }),
         };
     }
+    if (command === "apply-test-packet") {
+        const taskId = getValue("--task-id");
+        const testId = getValue("--test-id");
+        const phase = getValue("--phase");
+        if (!taskId)
+            throw new GuardError("apply-test-packet 缺少必填参数 --task-id");
+        if (!testId)
+            throw new GuardError("apply-test-packet 缺少必填参数 --test-id");
+        if (phase !== "red" && phase !== "characterization" && phase !== "green") {
+            throw new GuardError("--phase 只允许 red、characterization 或 green");
+        }
+        return {
+            command,
+            change,
+            task_id: taskId,
+            test_id: testId,
+            phase,
+            task_code_review_report_refs: getValues("--task-code-review-report-ref"),
+            packet_format: parsePacketOutputFormat(selectedPacketFormat, { allowPrompt: true }),
+        };
+    }
+    if (command === "apply-executor-packet") {
+        const taskId = getValue("--task-id");
+        if (!taskId)
+            throw new GuardError("apply-executor-packet 缺少必填参数 --task-id");
+        return {
+            command,
+            change,
+            task_id: taskId,
+            apply_worker_chain_refs: getValues("--apply-worker-chain-ref"),
+            packet_format: parsePacketOutputFormat(selectedPacketFormat, { allowPrompt: true }),
+        };
+    }
+    if (command === "apply-code-review-packet") {
+        const taskId = getValue("--task-id");
+        const executorRefs = getValues("--executor-report-ref");
+        if (!taskId)
+            throw new GuardError("apply-code-review-packet 缺少必填参数 --task-id");
+        if (executorRefs.length === 0)
+            throw new GuardError("apply-code-review-packet 缺少必填参数 --executor-report-ref");
+        return {
+            command,
+            change,
+            task_id: taskId,
+            executor_report_refs: executorRefs,
+            packet_format: parsePacketOutputFormat(selectedPacketFormat, { allowPrompt: true }),
+        };
+    }
+    if (command === "apply-verify-packet") {
+        const taskId = getValue("--task-id");
+        const executorRefs = getValues("--executor-report-ref");
+        const codeReviewRefs = getValues("--task-code-review-report-ref");
+        const greenRefs = getValues("--green-test-run-evidence-ref");
+        const redRefs = getValues("--red-test-run-evidence-ref");
+        const characterizationRefs = getValues("--characterization-test-run-evidence-ref");
+        if (!taskId)
+            throw new GuardError("apply-verify-packet 缺少必填参数 --task-id");
+        if (executorRefs.length === 0)
+            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) {
+            throw new GuardError("apply-verify-packet requires --red-test-run-evidence-ref or --characterization-test-run-evidence-ref");
+        }
+        return {
+            command,
+            change,
+            task_id: taskId,
+            executor_report_refs: executorRefs,
+            task_code_review_report_refs: codeReviewRefs,
+            green_test_run_evidence_refs: greenRefs,
+            red_test_run_evidence_refs: redRefs,
+            characterization_test_run_evidence_refs: characterizationRefs,
+            packet_format: parsePacketOutputFormat(selectedPacketFormat, { allowPrompt: true }),
+        };
+    }
     if (command === "ledger-render") {
         const gate = getValue("--gate");
         const roundValue = getValue("--round");

package/dist/src/core.d.ts

@@ -9,6 +9,7 @@ export * from "./invariants.ts";
 export * from "./git.ts";
 export * from "./state.ts";
 export * from "./archive.ts";
+export * from "./apply_worker_chain.ts";
 export * from "./gates.ts";
 export * from "./install_engine.ts";
 import type { ParsedArgs } from "./cli_args.ts";

package/dist/src/core.js

@@ -9,6 +9,7 @@ export * from "./invariants.js";
 export * from "./git.js";
 export * from "./state.js";
 export * from "./archive.js";
+export * from "./apply_worker_chain.js";
 export * from "./gates.js";
 export * from "./install_engine.js";
 import { existsSync, readFileSync, statSync } from "node:fs";