@ccoalm/ccl-skills 0.10.0 → 0.12.0

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

@@ -133,10 +133,30 @@ check_absent() { # <file> <token> <label> — file must exist AND token absent;
   fi
 }
 
+check_line_all() { # <file> <selector> <label> <req...> — EVERY <req> must sit on
+  # ONE line that matches <selector>. Filtering the matched lines through each req in
+  # turn is what binds them to the same line: asserting each req against the whole set
+  # of matched lines lets two reqs pass on two different lines, so a contract that says
+  # "both owners on that line" would be satisfied while no line carries both.
+  # -e is required: a selector starting with "-" is otherwise parsed as an option.
+  local file="$1" sel="$2" label="$3"; shift 3
+  local out req
+  out=$(grep -F -e "$sel" "$file" 2>/dev/null)
+  if [ -z "$out" ]; then
+    echo "FAIL: $label missing ($file :: no line matches '$sel')" >&2; fail=1; return
+  fi
+  for req in "$@"; do
+    out=$(printf '%s\n' "$out" | grep -F -e "$req")
+    if [ -z "$out" ]; then
+      echo "FAIL: $label missing ($file :: one line matching '$sel' must also contain '$req')" >&2; fail=1; return
+    fi
+  done
+}
+
 # Self-pin: an emptied or truncated suite must fail, not pass. Update EXPECTED
 # when adding/removing checks deliberately (same diff). Runs FIRST: a truncated
 # tail removes real checks and the count goes red.
-EXPECTED_CHECKS=21
+EXPECTED_CHECKS=24
 actual_checks=$(grep -cE '^check([_a-z]+)? ' "$0")
 if [ "$actual_checks" -ne "$EXPECTED_CHECKS" ]; then
   echo "FAIL: suite self-pin: expected $EXPECTED_CHECKS checks, found $actual_checks" >&2
@@ -176,6 +196,22 @@ check "$ROOT/skills/product-rd-workflow/SKILL.md" "must go to that language's de
 # no-owner fallback be deleted while the suite stays green, which is exactly the
 # routing hole (a CLI in a language with no dev owner) this rule closes.
 check "$ROOT/skills/product-rd-workflow/SKILL.md" "no such dev owner stays with \`terminal-cli-dev\` as the default CLI owner" "product-rd coordinator CLI carve-out (no-owner fallback branch, incl. destination)"
+# A routing-bank case cannot guard this: a multi-stage Node request selects
+# product-rd-workflow from its own wording and stays green even when the
+# coordinator omits the Node owner from its dispatch map. Pin the map itself —
+# both the stack enumeration and the CLI carve-out list — or the omission that
+# sent Node deliveries to a coordinator with no owner to dispatch to recurs
+# invisibly, with the no-owner fallback above silently reclaiming Node CLIs.
+check_line_all "$ROOT/skills/product-rd-workflow/SKILL.md" "- Development routing:" "product-rd Development-routing line carries the Node owner in BOTH the stack enumeration and the CLI carve-out" "\`nodejs-service-dev\` for Node.js services" "\`python-service-dev\`, \`nodejs-service-dev\`)"
+# Node has no *-architecture sibling by decision, so the technical-design gate
+# must name where its architecture decisions go; without this the gate lists
+# only the Go and Python architecture owners and Node design work has no owner.
+# Naming the vacuum is not naming a destination: both owners must sit on that
+# line, or the gate can declare Node has no architecture sibling and stop there.
+# The positive ownership clause is pinned too: keeping only the two owner tokens
+# while deleting "run this gate here" would leave the architecture decision ownerless,
+# since nodejs-service-dev is named there as the IMPLEMENTATION owner, not the gate.
+check_line_all "$ROOT/skills/product-rd-workflow/references/delivery-lifecycle.md" "For Node.js backend, worker, or CLI/tooling architecture" "product-rd design gate owns the Node architecture decision and names both downstream owners on that line" "run this gate here" "\`platform-*\` owners" "\`nodejs-service-dev\` for the Node-side implementation contract"
 # Both legs of the skip clause are pinned: an unanchored leg can be deleted while
 # the reciprocal trigger anchor above stays green, and the eval fixtures assert
 # terminal-cli-dev must NOT receive either request.
@@ -187,6 +223,10 @@ check_frontmatter_present "$ROOT/skills/terminal-cli-dev/SKILL.md" "Node.js CLI
 # implementation) — the gap two independent reviewer lanes hit.
 check_frontmatter_present "$ROOT/skills/terminal-cli-dev/SKILL.md" "command/subcommand/flag/help contract (owned here even when nothing is rendered)" "terminal-cli-dev owns the non-rendered CLI contract"
 check "$ROOT/skills/product-rd-workflow/SKILL.md" "command/subcommand/flag/help contract, which it owns even when nothing is rendered" "product-rd mirrors CLI-contract ownership"
+# testing-strategy must not re-claim language-stack CLI test IMPLEMENTATION: that
+# claim collided with the CLI carve-out every stack dev owner and the coordinator
+# carry, so the line is scoped to the interface contract it actually owns.
+check_line_all "$ROOT/skills/testing-strategy/SKILL.md" "- Use \`terminal-cli-dev\` for" "testing-strategy scopes terminal-cli-dev to the interface contract, not language-stack CLI implementation" "terminal interface contract"
 check_frontmatter_present "$ROOT/skills/platform-release-engineering/SKILL.md" "上线范围确认 / 合并 main / 打 tag" "rollout description prod-release skip"
 check "$ROOT/skills/app-cross-platform-dev/agents/openai.yaml" "React Native" "app-cross-platform-dev openai overlay RN parity"
 

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

@@ -145,6 +145,7 @@ def make_fixture(
     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 = 2 - index
+        remaining = 2 - chain_position
         if status == "findings":
-            state = "post_review_budget" if index == 2 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,
+            "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,
@@ -504,6 +520,97 @@ run("review-only", review_only["ledger"], 1, "ready requires at least one tracke
 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")

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

@@ -35,6 +35,12 @@ KNOWN_REVIEW_STATES = EXTERNAL_REVIEW_STATES | {"self_reviewed"}
 # 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",
@@ -304,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")
 
@@ -313,16 +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 wrapper can mint would
+        # 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.
-        if expected_index > WRAPPER_AUTONOMOUS_ROUNDS:
-            fail("controller chain exceeds the wrapper budget")
+        # 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}]"
         )
@@ -339,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"}:
@@ -349,15 +382,24 @@ 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:
@@ -368,7 +410,7 @@ def validate_controller_receipts(
             receipt.get("autonomous_review_budget")
         ) is not int:
             fail(f"controller receipt {expected_index} autonomous_review_budget must be {WRAPPER_AUTONOMOUS_ROUNDS}")
-        expected_remaining = WRAPPER_AUTONOMOUS_ROUNDS - expected_index
+        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:
@@ -376,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"
@@ -386,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
@@ -425,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 == WRAPPER_AUTONOMOUS_ROUNDS
+            if receipt["status"] == "findings" and chain_position == WRAPPER_AUTONOMOUS_ROUNDS
             else "findings_pending"
             if receipt["status"] == "findings"
             else "reviewed"
@@ -439,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(
@@ -485,18 +554,24 @@ def validate_completion_receipt(
         receipt.get("autonomous_review_budget")
     ) is not int:
         fail(f"completion receipt autonomous_review_budget must be {WRAPPER_AUTONOMOUS_ROUNDS}")
-    if receipt.get("autonomous_review_index") != len(receipts) or type(
+    # 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 = WRAPPER_AUTONOMOUS_ROUNDS - 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")
@@ -950,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) != WRAPPER_AUTONOMOUS_ROUNDS
-            or final.get("status") != "findings"
-            or final.get("review_state") != "post_review_budget"
-            or final.get("human_decision_required") is not True
-        ):
-            fail(f"continuation_authorization_required requires final-round (round {WRAPPER_AUTONOMOUS_ROUNDS}) 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.