@ccoalm/ccl-skills 0.9.0 → 0.11.0

package/dist/assets/marketplace/plugins/ccl-skills/skills/skill-extraction-workflow/scripts/test_validate_extraction_review_state.sh

@@ -140,11 +140,12 @@ def make_fixture(
     receipt_mutators=None,
     completion=True,
     completion_mutator=None,
-    budget=2,
+    budget=1,
     base_shas=None,
     closeout=None,
     unmatched=0,
     open_last=False,
+    succession=False,
 ):
     if receipt_findings is None:
         receipt_findings = [[finding(1)], []]
@@ -166,11 +167,15 @@ def make_fixture(
     receipt_hashes = []
     receipt_refs = []
     for index, findings in enumerate(receipt_findings, start=1):
-        mode = "review" if index == 1 else "challenge"
+        # With a succession the LAST round opens a second chain: its own chain
+        # arithmetic restarts at one while its lane position keeps counting.
+        is_succession = succession and index == rounds
+        chain_position = 1 if is_succession else index
+        mode = "challenge" if is_succession else "review" if index == 1 else "challenge"
         status = "findings" if findings else "passed"
-        remaining = 3 - index
+        remaining = 2 - chain_position
         if status == "findings":
-            state = "post_review_budget" if index == 3 else "findings_pending"
+            state = "post_review_budget" if chain_position == 2 else "findings_pending"
         else:
             state = "reviewed"
         receipt = {
@@ -179,16 +184,27 @@ def make_fixture(
             "status": status,
             "findings": copy.deepcopy(findings),
             "review_chain_tracked": True,
-            "review_chain_id": "extraction-chain",
-            "autonomous_review_index": index,
-            "autonomous_review_budget": 3,
+            "review_chain_id": (
+                "extraction-succession" if is_succession else "extraction-chain"
+            ),
+            "autonomous_review_index": chain_position,
+            "autonomous_review_budget": 2,
             "autonomous_reviews_remaining": remaining,
             "autonomous_review_allowed": remaining > 0,
-            "challenge_index": 0 if index == 1 else index - 1,
+            "challenge_index": 1 if is_succession else 0 if index == 1 else index - 1,
             "challenge_budget": budget,
-            "prior_review_result_sha256": list(receipt_hashes),
-            "candidate_sha256": CANDIDATE,
-            "packet_sha256": CANDIDATE,
+            "prior_review_result_sha256": [] if is_succession else list(receipt_hashes),
+            "predecessor_chain_id": "extraction-chain" if is_succession else None,
+            "predecessor_result_sha256": (
+                receipt_hashes[-1] if is_succession and receipt_hashes else None
+            ),
+            "predecessor_candidate_sha256": OTHER_CANDIDATE if is_succession else None,
+            "candidate_sha256": (
+                OTHER_CANDIDATE if succession and not is_succession else CANDIDATE
+            ),
+            "packet_sha256": (
+                OTHER_CANDIDATE if succession and not is_succession else CANDIDATE
+            ),
             "review_scope": copy.deepcopy(scope),
             "review_scope_sha256": scope_sha,
             "wording_only_proof_sha256": None,
@@ -221,7 +237,7 @@ def make_fixture(
             "review_chain_tracked": True,
             "review_chain_id": final["review_chain_id"],
             "autonomous_review_index": final["autonomous_review_index"],
-            "autonomous_review_budget": 3,
+            "autonomous_review_budget": 2,
             "autonomous_reviews_remaining": final["autonomous_reviews_remaining"],
             "autonomous_review_allowed": False,
             "challenge_budget": budget,
@@ -411,9 +427,9 @@ run("float-schema", float_schema["ledger"], 1, "schema_version must be 3")
 
 float_budget = make_fixture(
     "float-budget",
-    receipt_mutators={2: lambda row: row.update(challenge_budget=2.0)},
+    receipt_mutators={2: lambda row: row.update(challenge_budget=1.0)},
 )
-run("float-budget", float_budget["ledger"], 1, "challenge_budget must be 2")
+run("float-budget", float_budget["ledger"], 1, "challenge_budget must be 1")
 
 nan_schema = make_fixture("nan-schema")
 nan_schema["ledger"]["schema_version"] = float("nan")
@@ -493,11 +509,108 @@ scope_mismatch = make_fixture("scope-mismatch", receipt_mutators={2: drift_scope
 run("scope-mismatch", scope_mismatch["ledger"], 1, "review scope changed")
 
 budget_four = make_fixture("budget-four", budget=4)
-run("budget-four", budget_four["ledger"], 1, "challenge_budget must be 2")
+run("budget-four", budget_four["ledger"], 1, "challenge_budget must be 1")
 
 review_only = make_fixture("review-only", receipt_findings=[[]])
 run("review-only", review_only["ledger"], 1, "ready requires at least one tracked challenge")
 
+# A caller must not out-run the wrapper budget by supplying extra receipts: a
+# third receipt under budget 1 claims a negative remaining count and would
+# otherwise reach completion validation as a ready-state budget bypass.
+over_budget = make_fixture("over-budget", receipt_findings=[[], [], []])
+run("over-budget", over_budget["ledger"], 1, "exceeds the wrapper budget")
+
+# Chain succession. A fix that edits the reviewed owner package ends its chain, so
+# the landing candidate can only be challenged in a succeeding chain. The lane then
+# spans two chains and three rounds, and the succession round is the only one that
+# binds what actually lands.
+succession_ready = make_fixture(
+    "succession-ready", receipt_findings=[[finding(1)], [], []], succession=True
+)
+run("succession-ready", succession_ready["ledger"], 0, "closeout_state=ready_for_human_decision")
+
+# The failure this whole mechanism exists to make visible: the fix batch moved the
+# candidate and no round ever inspected what lands.
+succession_absent = make_fixture(
+    "succession-absent",
+    receipt_findings=[[finding(1)], []],
+    receipt_mutators={
+        1: lambda row: row.update(
+            candidate_sha256=OTHER_CANDIDATE, packet_sha256=OTHER_CANDIDATE
+        ),
+        2: lambda row: row.update(
+            candidate_sha256=OTHER_CANDIDATE, packet_sha256=OTHER_CANDIDATE
+        ),
+    },
+)
+run("succession-absent", succession_absent["ledger"], 1, "does not bind the ledger candidate")
+
+# A succession whose predecessor saw the same candidate reviewed nothing new.
+succession_unmoved = make_fixture(
+    "succession-unmoved",
+    receipt_findings=[[finding(1)], [], []],
+    succession=True,
+    receipt_mutators={
+        1: lambda row: row.update(candidate_sha256=CANDIDATE, packet_sha256=CANDIDATE),
+        2: lambda row: row.update(candidate_sha256=CANDIDATE, packet_sha256=CANDIDATE),
+        3: lambda row: row.update(predecessor_candidate_sha256=CANDIDATE),
+    },
+)
+run(
+    "succession-unmoved",
+    succession_unmoved["ledger"],
+    1,
+    "must bind a candidate the wrapper chain never saw",
+)
+
+succession_foreign_terminal = make_fixture(
+    "succession-foreign-terminal",
+    receipt_findings=[[finding(1)], [], []],
+    succession=True,
+    receipt_mutators={3: lambda row: row.update(predecessor_result_sha256="f" * 64)},
+)
+run(
+    "succession-foreign-terminal",
+    succession_foreign_terminal["ledger"],
+    1,
+    "does not bind the succeeded chain's terminal receipt",
+)
+
+succession_self = make_fixture(
+    "succession-self",
+    receipt_findings=[[finding(1)], [], []],
+    succession=True,
+    receipt_mutators={3: lambda row: row.update(review_chain_id="extraction-chain")},
+)
+run("succession-self", succession_self["ledger"], 1, "succeeds its own chain")
+
+succession_misplaced = make_fixture(
+    "succession-misplaced",
+    receipt_findings=[[finding(1)], [], []],
+    succession=True,
+    receipt_mutators={
+        2: lambda row: row.update(predecessor_chain_id="extraction-chain"),
+    },
+)
+run(
+    "succession-misplaced",
+    succession_misplaced["ledger"],
+    1,
+    "must be the lane's final round",
+)
+
+succession_over_lane = make_fixture(
+    "succession-over-lane",
+    receipt_findings=[[finding(1)], [], [], []],
+    succession=True,
+)
+run(
+    "succession-over-lane",
+    succession_over_lane["ledger"],
+    1,
+    "controller_receipts must contain one to 3 ordered Agent rounds",
+)
+
 missing_complete = make_fixture("missing-complete")
 missing_complete["ledger"]["completion_receipt"] = None
 run("missing-complete", missing_complete["ledger"], 1, "requires a completion receipt")
@@ -537,7 +650,7 @@ run(
 
 continuation = make_fixture(
     "continuation",
-    receipt_findings=[[finding(1)], [], [finding(2)]],
+    receipt_findings=[[finding(1)], [finding(2)]],
     completion=False,
     open_last=True,
 )
@@ -550,10 +663,10 @@ run(
 
 continuation_unconsumed_first_drift = make_fixture(
     "continuation-unconsumed-first-drift",
-    receipt_findings=[[finding(1)], [], [finding(2)]],
+    receipt_findings=[[finding(1)], [finding(2)]],
     completion=False,
     open_last=True,
-    base_shas=[A, A, A, B],
+    base_shas=[A, A, B],
 )
 run(
     "continuation-unconsumed-first-drift",
@@ -564,7 +677,7 @@ run(
 
 continuation_candidate = make_fixture(
     "continuation-candidate",
-    receipt_findings=[[finding(1)], [], [finding(2)]],
+    receipt_findings=[[finding(1)], [finding(2)]],
     completion=False,
     open_last=True,
 )
@@ -595,8 +708,8 @@ run(
 
 unknown_state = make_fixture(
     "unknown-state",
-    receipt_findings=[[finding(1)], [], [finding(2)]],
-    receipt_mutators={3: lambda row: row.update(review_state="potato")},
+    receipt_findings=[[finding(1)], [finding(2)]],
+    receipt_mutators={2: lambda row: row.update(review_state="potato")},
     completion=False,
     open_last=True,
 )
@@ -605,10 +718,10 @@ run("unknown-state", unknown_state["ledger"], 1, "unknown controller review_stat
 
 passed_continuation = make_fixture(
     "passed-continuation",
-    receipt_findings=[[finding(1)], [], []],
+    receipt_findings=[[finding(1)], []],
     completion=False,
 )
-run("passed-continuation", passed_continuation["ledger"], 1, "round 3 findings in post_review_budget")
+run("passed-continuation", passed_continuation["ledger"], 1, "findings in post_review_budget")
 
 bad_finding_hash = make_fixture("bad-finding-hash")
 bad_finding_hash["ledger"]["finding_classes"][0]["occurrences"][0][
@@ -744,7 +857,7 @@ run(
 
 historical_open = make_fixture(
     "historical-open",
-    receipt_findings=[[finding(1)], [finding(2)], []],
+    receipt_findings=[[finding(1), finding(2)], []],
 )
 historical_open["ledger"]["finding_classes"][0]["occurrences"][0][
     "disposition"
@@ -756,7 +869,7 @@ run("historical-open", historical_open["ledger"], 1, "unresolved finding occurre
 
 historical_open_linked = make_fixture(
     "historical-open-linked",
-    receipt_findings=[[finding(1)], [finding(2)], []],
+    receipt_findings=[[finding(1), finding(2)], []],
 )
 historical_open_linked_occurrences = historical_open_linked["ledger"][
     "finding_classes"
@@ -825,7 +938,7 @@ run("needs-human", needs_human["ledger"], 1, "unresolved finding occurrence")
 
 third_occurrence = make_fixture(
     "third-occurrence",
-    receipt_findings=[[finding(1)], [finding(2)], [finding(3)]],
+    receipt_findings=[[finding(1), finding(2)], [finding(3)]],
     completion=False,
     unmatched=1,
     open_last=True,
@@ -1045,7 +1158,7 @@ for closing_disposition in sorted(CLOSED_DISPOSITIONS):
     case_name = f"historical-needs-human-{closing_disposition.replace('_', '-')}"
     historical_needs_human_linked = make_fixture(
         case_name,
-        receipt_findings=[[finding(1)], [finding(2)], []],
+        receipt_findings=[[finding(1), finding(2)], []],
     )
     historical_needs_human_occurrences = historical_needs_human_linked["ledger"][
         "finding_classes"
@@ -1128,7 +1241,7 @@ duplicate_completion_result = invoke(
 
 duplicate_sweep = make_fixture(
     "duplicate-sweep",
-    receipt_findings=[[finding(1)], [finding(2)], [finding(3)]],
+    receipt_findings=[[finding(1), finding(2)], [finding(3)]],
     completion=False,
     open_last=True,
 )

package/dist/assets/marketplace/plugins/ccl-skills/skills/skill-extraction-workflow/scripts/validate_extraction_review_state.py

@@ -30,6 +30,17 @@ TERMINAL_STATES = {
 }
 EXTERNAL_REVIEW_STATES = {"reviewed", "findings_pending", "post_review_budget"}
 KNOWN_REVIEW_STATES = EXTERNAL_REVIEW_STATES | {"self_reviewed"}
+# The extraction wrapper fixes the autonomous lane at one review plus one
+# challenge; every numeric bound below derives from these two constants so a
+# future budget change lands in exactly one place.
+WRAPPER_CHALLENGE_BUDGET = 1
+WRAPPER_AUTONOMOUS_ROUNDS = WRAPPER_CHALLENGE_BUDGET + 1
+# A fix that edits the reviewed owner package ends its chain by construction, so
+# the post-fix candidate is challenged in ONE succeeding chain rather than inside
+# the ended one. The lane therefore spans at most two chains: the wrapper-budget
+# chain plus a single succession challenge bound to the landing candidate.
+LANE_MAX_CHAINS = 2
+LANE_MAX_ROUNDS = WRAPPER_AUTONOMOUS_ROUNDS + 1
 DISPOSITIONS = {
     "fixed",
     "source_refuted",
@@ -272,8 +283,8 @@ def validate_scope(receipt: dict[str, Any], label: str) -> str:
     ]
     if len(normalized_risks) != len(set(normalized_risks)):
         fail(f"{label}.review_scope.risk_tags contains duplicates")
-    if scope["challenge_budget"] != 2 or type(scope["challenge_budget"]) is not int:
-        fail(f"{label}.review_scope.challenge_budget must be 2")
+    if scope["challenge_budget"] != WRAPPER_CHALLENGE_BUDGET or type(scope["challenge_budget"]) is not int:
+        fail(f"{label}.review_scope.challenge_budget must be {WRAPPER_CHALLENGE_BUDGET}")
     if (
         scope["wording_only_proof_sha256"] is not None
         or scope["wording_only_scope_sha256"] is not None
@@ -299,8 +310,10 @@ def validate_controller_receipts(
     payload: dict[str, Any], ledger_dir: Path
 ) -> tuple[list[dict[str, Any]], list[str], dict[str, list[str]], str, str]:
     refs = payload["controller_receipts"]
-    if not isinstance(refs, list) or not 1 <= len(refs) <= 3:
-        fail("controller_receipts must contain one to three ordered Agent rounds")
+    if not isinstance(refs, list) or not 1 <= len(refs) <= LANE_MAX_ROUNDS:
+        fail(
+            f"controller_receipts must contain one to {LANE_MAX_ROUNDS} ordered Agent rounds"
+        )
     if payload["autonomous_round"] != len(refs) or type(payload["autonomous_round"]) is not int:
         fail("autonomous_round must equal the ordered controller receipt count")
 
@@ -308,11 +321,20 @@ def validate_controller_receipts(
     receipt_hashes: list[str] = []
     finding_hashes: dict[str, list[str]] = {}
     chain_id: str | None = None
+    final_chain_id: str | None = None
     scope_hash: str | None = None
+    candidates: list[str] = []
+    succession_index: int | None = None
     ledger_candidate = sha256(
         payload["candidate_sha256"], "ledger.candidate_sha256"
     )
     for expected_index, value in enumerate(refs, start=1):
+        # A caller supplying more receipts than the lane can mint would
+        # otherwise claim a negative remaining count and reach completion
+        # validation as a ready-state budget bypass. The wrapper bound still
+        # governs each chain; the lane bound governs their sum.
+        if expected_index > LANE_MAX_ROUNDS:
+            fail("controller chain exceeds the lane budget")
         ref = exact_object(
             value, {"sequence", "file", "sha256"}, f"controller_receipts[{expected_index - 1}]"
         )
@@ -329,7 +351,28 @@ def validate_controller_receipts(
         receipt = decode_json(raw, label=f"controller receipt {expected_index}")
         if receipt.get("schema_version") != 3 or type(receipt.get("schema_version")) is not int:
             fail(f"controller receipt {expected_index} schema_version must be 3")
-        expected_mode = "review" if expected_index == 1 else "challenge"
+        # A succession round opens a second chain, so its own chain arithmetic
+        # restarts at one while its lane position keeps counting. Classify first;
+        # every expectation below reads the chain position, not the lane index.
+        predecessor_chain = receipt.get("predecessor_chain_id")
+        is_succession = predecessor_chain is not None
+        if is_succession:
+            if expected_index != len(refs):
+                fail("a succession round must be the lane's final round")
+            if expected_index != WRAPPER_AUTONOMOUS_ROUNDS + 1:
+                fail("a succession round may only follow a spent wrapper chain")
+            succession_index = expected_index
+            chain_position = 1
+        else:
+            # Only a succession round may sit past the wrapper chain. Without this
+            # the caller claims a negative remaining count and reaches completion
+            # validation as a ready-state budget bypass.
+            if expected_index > WRAPPER_AUTONOMOUS_ROUNDS:
+                fail("controller chain exceeds the wrapper budget")
+            chain_position = expected_index
+        expected_mode = (
+            "challenge" if is_succession else "review" if expected_index == 1 else "challenge"
+        )
         if receipt.get("mode") != expected_mode:
             fail(f"controller receipt {expected_index} must have mode {expected_mode}")
         if receipt.get("status") not in {"passed", "findings"}:
@@ -339,26 +382,35 @@ def validate_controller_receipts(
         current_chain = bounded_text(
             receipt.get("review_chain_id"), f"controller receipt {expected_index}.review_chain_id", 120
         )
-        if chain_id is None:
+        if is_succession:
+            if current_chain == chain_id:
+                fail(
+                    f"controller receipt {expected_index} succeeds its own chain"
+                )
+            final_chain_id = current_chain
+        elif chain_id is None:
             chain_id = current_chain
+            final_chain_id = current_chain
         elif current_chain != chain_id:
             fail(f"controller receipt {expected_index} review_chain_id changed")
-        if receipt.get("autonomous_review_index") != expected_index or type(
+        if receipt.get("autonomous_review_index") != chain_position or type(
             receipt.get("autonomous_review_index")
         ) is not int:
             fail(f"controller receipt {expected_index} autonomous_review_index is not contiguous")
-        expected_challenge_index = 0 if expected_index == 1 else expected_index - 1
+        expected_challenge_index = (
+            1 if is_succession else 0 if expected_index == 1 else expected_index - 1
+        )
         if receipt.get("challenge_index") != expected_challenge_index or type(
             receipt.get("challenge_index")
         ) is not int:
             fail(f"controller receipt {expected_index} challenge_index is invalid")
-        if receipt.get("challenge_budget") != 2 or type(receipt.get("challenge_budget")) is not int:
-            fail(f"controller receipt {expected_index} challenge_budget must be 2")
-        if receipt.get("autonomous_review_budget") != 3 or type(
+        if receipt.get("challenge_budget") != WRAPPER_CHALLENGE_BUDGET or type(receipt.get("challenge_budget")) is not int:
+            fail(f"controller receipt {expected_index} challenge_budget must be {WRAPPER_CHALLENGE_BUDGET}")
+        if receipt.get("autonomous_review_budget") != WRAPPER_AUTONOMOUS_ROUNDS or type(
             receipt.get("autonomous_review_budget")
         ) is not int:
-            fail(f"controller receipt {expected_index} autonomous_review_budget must be 3")
-        expected_remaining = 3 - expected_index
+            fail(f"controller receipt {expected_index} autonomous_review_budget must be {WRAPPER_AUTONOMOUS_ROUNDS}")
+        expected_remaining = WRAPPER_AUTONOMOUS_ROUNDS - chain_position
         if receipt.get("autonomous_reviews_remaining") != expected_remaining or type(
             receipt.get("autonomous_reviews_remaining")
         ) is not int:
@@ -366,7 +418,8 @@ def validate_controller_receipts(
         if receipt.get("autonomous_review_allowed") is not (expected_remaining > 0):
             fail(f"controller receipt {expected_index} autonomous_review_allowed is invalid")
         prior = receipt.get("prior_review_result_sha256")
-        if prior != receipt_hashes:
+        expected_prior = [] if is_succession else receipt_hashes
+        if prior != expected_prior:
             fail(f"controller receipt {expected_index} prior_review_result_sha256 is not the complete ordered prefix")
         candidate = sha256(
             receipt.get("candidate_sha256"), f"controller receipt {expected_index}.candidate_sha256"
@@ -376,13 +429,10 @@ def validate_controller_receipts(
         )
         if packet != candidate:
             fail(f"controller receipt {expected_index} packet_sha256 must equal candidate_sha256")
-        # Every counted round must have inspected the exact final candidate;
-        # a chain whose review round saw an earlier candidate is not a review
-        # of the candidate this ledger closes out.
-        if candidate != ledger_candidate:
-            fail(
-                f"controller receipt {expected_index} does not bind the ledger candidate"
-            )
+        # Which candidate a round must bind depends on its phase, and the phase
+        # split is only known once every round is loaded, so this is settled
+        # after the loop rather than here.
+        candidates.append(candidate)
         current_scope_hash = validate_scope(receipt, f"controller receipt {expected_index}")
         if scope_hash is None:
             scope_hash = current_scope_hash
@@ -415,7 +465,7 @@ def validate_controller_receipts(
             fail(f"controller receipt {expected_index} has unknown controller review_state {state}")
         expected_state = (
             "post_review_budget"
-            if receipt["status"] == "findings" and expected_index == 3
+            if receipt["status"] == "findings" and chain_position == WRAPPER_AUTONOMOUS_ROUNDS
             else "findings_pending"
             if receipt["status"] == "findings"
             else "reviewed"
@@ -429,9 +479,38 @@ def validate_controller_receipts(
         receipt_hashes.append(receipt_hash)
         finding_hashes[receipt_hash] = current_findings
 
-    if chain_id is None or scope_hash is None:
+    if chain_id is None or scope_hash is None or final_chain_id is None:
         fail("controller receipt chain is empty")
-    return receipts, receipt_hashes, finding_hashes, chain_id, scope_hash
+
+    # Phase binding. Without a succession every counted round must have inspected
+    # the exact final candidate. With one, the wrapper chain reviewed the candidate
+    # the fix batch then moved, and the succession round is the only round that can
+    # bind what actually lands — which is the whole point of running it.
+    if succession_index is None:
+        for position, value in enumerate(candidates, start=1):
+            if value != ledger_candidate:
+                fail(f"controller receipt {position} does not bind the ledger candidate")
+    else:
+        succession = receipts[-1]
+        succeeded_candidate = sha256(
+            succession.get("predecessor_candidate_sha256"),
+            "succession receipt.predecessor_candidate_sha256",
+        )
+        if candidates[-1] != ledger_candidate:
+            fail("the succession round does not bind the ledger candidate")
+        if succeeded_candidate == ledger_candidate:
+            fail("a succession round must bind a candidate the wrapper chain never saw")
+        for position, value in enumerate(candidates[:-1], start=1):
+            if value != succeeded_candidate:
+                fail(f"controller receipt {position} does not bind the succeeded candidate")
+        if succession.get("predecessor_chain_id") != chain_id:
+            fail("the succession round does not name the chain it succeeds")
+        if sha256(
+            succession.get("predecessor_result_sha256"),
+            "succession receipt.predecessor_result_sha256",
+        ) != receipt_hashes[-2]:
+            fail("the succession round does not bind the succeeded chain's terminal receipt")
+    return receipts, receipt_hashes, finding_hashes, final_chain_id, scope_hash
 
 
 def validate_completion_receipt(
@@ -469,24 +548,30 @@ def validate_completion_receipt(
         fail("completion receipt cannot close a final external receipt with findings")
     if receipt.get("review_chain_tracked") is not True or receipt.get("review_chain_id") != chain_id:
         fail("completion receipt review_chain_id does not match the controller chain")
-    if receipt.get("challenge_budget") != 2 or type(receipt.get("challenge_budget")) is not int:
-        fail("completion receipt challenge_budget must be 2")
-    if receipt.get("autonomous_review_budget") != 3 or type(
+    if receipt.get("challenge_budget") != WRAPPER_CHALLENGE_BUDGET or type(receipt.get("challenge_budget")) is not int:
+        fail(f"completion receipt challenge_budget must be {WRAPPER_CHALLENGE_BUDGET}")
+    if receipt.get("autonomous_review_budget") != WRAPPER_AUTONOMOUS_ROUNDS or type(
         receipt.get("autonomous_review_budget")
     ) is not int:
-        fail("completion receipt autonomous_review_budget must be 3")
-    if receipt.get("autonomous_review_index") != len(receipts) or type(
+        fail(f"completion receipt autonomous_review_budget must be {WRAPPER_AUTONOMOUS_ROUNDS}")
+    # The completion checkpoint binds the final external round, so its chain
+    # arithmetic is that round's — which is the succeeding chain's when a fix
+    # batch ended the wrapper chain, not the lane's round count.
+    final_index = final.get("autonomous_review_index")
+    if receipt.get("autonomous_review_index") != final_index or type(
         receipt.get("autonomous_review_index")
     ) is not int:
         fail("completion receipt autonomous_review_index does not match the final round")
-    expected_remaining = 3 - len(receipts)
+    expected_remaining = WRAPPER_AUTONOMOUS_ROUNDS - final_index
     if receipt.get("autonomous_reviews_remaining") != expected_remaining or type(
         receipt.get("autonomous_reviews_remaining")
     ) is not int:
         fail("completion receipt autonomous_reviews_remaining does not match the final round")
     if receipt.get("autonomous_review_allowed") is not False:
         fail("completion receipt must disable further autonomous review")
-    if receipt.get("prior_review_result_sha256") != receipt_hashes[:-1]:
+    if receipt.get("prior_review_result_sha256") != final.get(
+        "prior_review_result_sha256"
+    ):
         fail("completion receipt prior_review_result_sha256 does not match the final external receipt")
     if receipt.get("completion_review_result_sha256") != receipt_hashes[-1]:
         fail("completion receipt completion_review_result_sha256 does not identify the final external receipt")
@@ -940,13 +1025,29 @@ def validate(payload: dict[str, Any], ledger_dir: Path) -> tuple[str, int, int]:
             fail("ready_for_human_decision requires no unresolved finding occurrence and no unreviewed delta")
     elif closeout == "continuation_authorization_required":
         final = receipts[-1]
-        if (
-            len(receipts) != 3
-            or final.get("status") != "findings"
-            or final.get("review_state") != "post_review_budget"
-            or final.get("human_decision_required") is not True
-        ):
-            fail("continuation_authorization_required requires round 3 findings in post_review_budget")
+        # The lane is spent either at the wrapper chain's last round, or — when a
+        # fix batch moved the candidate — at the succession round that reviewed it.
+        # Only the closeout knows the lane is spent: the controller sizes
+        # human_decision_required from its own chain, where the succession round
+        # is round one of two.
+        succeeded = final.get("predecessor_chain_id") is not None
+        if succeeded:
+            spent = (
+                len(receipts) == LANE_MAX_ROUNDS and final.get("status") == "findings"
+            )
+        else:
+            spent = (
+                len(receipts) == WRAPPER_AUTONOMOUS_ROUNDS
+                and final.get("status") == "findings"
+                and final.get("review_state") == "post_review_budget"
+                and final.get("human_decision_required") is True
+            )
+        if not spent:
+            fail(
+                "continuation_authorization_required requires final-round "
+                f"(round {WRAPPER_AUTONOMOUS_ROUNDS}) findings in post_review_budget, "
+                f"or a succession round (round {LANE_MAX_ROUNDS}) carrying findings"
+            )
     elif closeout == "baseline_race" and not delta:
         fail("baseline_race requires a non-empty unreviewed_delta")
 

package/dist/assets/marketplace/plugins/ccl-skills/skills/test-artifact-management/SKILL.md

@@ -15,7 +15,7 @@ Bitable ownership:
 
 - Ambiguous "写测试用例" / "write test cases" requests mean `testing-strategy` first when the user wants test code, E2E/browser/device tests, CI coverage, mocks, or verification evidence. Use this skill only when the deliverable is a structured TC artifact, Feishu/Bitable sync, or source-to-TC generation workflow.
 - Use `testing-strategy` to decide which test layers (unit / integration / E2E / scenario) are needed *after* the use cases are written.
-- Use `go-microservice-dev` / `python-service-dev` / `web-react-dev` / `miniapp-product-dev` / `app-cross-platform-dev` for implementing the test code once test cases are approved.
+- Test-code implementation, once test cases are approved, must go to the owning stack skill: `go-microservice-dev` / `python-service-dev` / `nodejs-service-dev` / `web-react-dev` / `miniapp-product-dev` / `app-cross-platform-dev`.
 - Use `product-rd-workflow` when the test case work is part of a broader feature delivery plan.
 - Use `llm-inference-integration` when test cases cover LLM / agent / RAG / inference behavior.
 - Use `skill-extraction-workflow` to feed lessons from test case generation or Feishu Bitable setup back into this skill after each delivery cycle.

package/dist/assets/marketplace/plugins/ccl-skills/skills/testing-strategy/SKILL.md

@@ -9,14 +9,15 @@ Use this skill when the task is about test scope, test design, verification evid
 
 ## Skill Routing
 
-- Use this skill for test strategy, test pyramid decisions, unit/integration/e2e/scenario boundaries, fixtures, mocks/fakes, regression coverage, and verification evidence.
-- Use `go-microservice-dev` for Go-specific implementation details after the test layer is chosen.
-- Use `python-service-dev` for Python-specific pytest, async test, fixture, fake client, ruff, mypy/pyright, packaging, or migration-test implementation details after the test layer is chosen.
-- Use `app-cross-platform-dev` for Flutter unit/widget/integration tests, Android unit/Compose/instrumented tests, iOS unit/UI tests, mobile device smoke, and app release verification after the test layer is chosen.
-- Use `miniapp-product-dev` for WeChat/Alipay/Douyin/Baidu mini-program build, developer-tool preview, real-device smoke, host capability verification, review submission, and release checks after the test layer is chosen.
-- Use `web-react-dev` for React unit/component/API-client/browser/E2E implementation, browser automation, accessibility checks, and build/deploy smoke after the test layer is chosen.
-- Use `terminal-cli-dev` for command-line, terminal, PTY-backed, ANSI-rendered, keyboard-driven, and full-screen text UI implementation after the test layer is chosen.
-- Use `llm-inference-integration` for LLM/agent/RAG evals, replay sets, prompt/model regression checks, shadow runs, and inference-specific observability after the test layer is chosen.
+- Use this skill for test strategy, test pyramid decisions, unit/integration/e2e/scenario boundaries, fixtures, mocks/fakes, regression coverage, and verification evidence. Stack pointers below apply after that choice.
+- Use `go-microservice-dev` for Go-specific implementation details.
+- Use `python-service-dev` for Python-specific pytest, async test, fixture, fake client, ruff, mypy/pyright, packaging, or migration-test implementation details.
+- Node runner, mock/fixture, fake timers, stream and cancellation assertions, child-process lifecycle, and packaged-artifact verification must use `nodejs-service-dev`.
+- Use `app-cross-platform-dev` for Flutter unit/widget/integration tests, Android unit/Compose/instrumented tests, iOS unit/UI tests, mobile device smoke, and app release verification.
+- Use `miniapp-product-dev` for WeChat/Alipay/Douyin/Baidu mini-program build, developer-tool preview, real-device smoke, host capability verification, review submission, and release checks.
+- Use `web-react-dev` for React unit/component/API-client/browser/E2E implementation, browser automation, accessibility checks, and build/deploy smoke.
+- Use `terminal-cli-dev` for the terminal interface contract, PTY/ANSI/keyboard rendering, and full-screen text UI testing.
+- Use `llm-inference-integration` for LLM/agent/RAG evals, replay sets, prompt/model regression checks, shadow runs, and inference-specific observability.
 - Use `defect-diagnosis` first when a test is failing, flaky, or used to reproduce a bug.
 - Use `product-rd-workflow` first when testing is part of an end-to-end product delivery plan.
 - Use `product-ui-ux-design` for visual hierarchy, interaction, state, accessibility, and design acceptance criteria; use this skill for automated proof and test coverage.