@ccoalm/ccl-skills 0.9.0 → 0.11.0

package/dist/assets/marketplace/plugins/ccl-skills/skills/code-review/SKILL.md

@@ -13,7 +13,7 @@ Choose the smallest useful mode:
 
 - **Review mode**: normal pre-merge or plan review. Find blocking or materially misleading issues.
 - **Challenge mode**: adversarial pass modeled after `codex challenge`. Try to break the diff or decision by finding production failure paths.
-- **Complete mode**: local exact-candidate deep-self-review checkpoint after a passed final external round. It invokes no reviewer and grants no human or merge authority.
+- **Complete mode**: local exact-candidate deep-self-review checkpoint after a passed final round. It invokes no reviewer and grants no human or merge authority.
 - **Consult mode**: ask Claude a bounded question when no diff or plan review is needed.
 
 Use challenge mode when the user asks for "challenge", "poke holes", "try to break it", "adversarial", or when the change touches money, permissions, privacy, compliance, tenant/user data, production rollout, high-impact AI, architecture, economics, or IA.
@@ -68,8 +68,9 @@ staged-contract and client-routing references below for details.
 
 Current contract: review/challenge may use a stamped
 `review_plan_source=derived-default`; `complete` requires a plan and output uses
-schema 3. Automation retains one chain: one review plus at most four challenges.
-Positive challenge capacity opens it at Agent index 1; budget zero is untracked.
+schema 3. Automation retains one chain (one review, at most four challenges) plus one
+succession.
+Positive challenge capacity opens it at index 1; budget zero is untracked.
 The sole release/high-risk budget-zero exception is a controller-proved
 `markdown-punctuation-only` review: it requires `wording_only_boundary`, permits
 no `complete`, and rejects an author assertion alone (recipe:

package/dist/assets/marketplace/plugins/ccl-skills/skills/code-review/references/staged-review-contract.md

@@ -289,6 +289,24 @@ refreshes, mode changes, and renamed invocations do not reset Agent authority.
 An initial `review` with positive challenge capacity must start this chain at
 index 1; an untracked initial review is single-round and therefore uses budget 0.
 
+**Chain succession.** A fix that edits a selected owner's package moves
+`selected_skills_sha256` and ends its chain by construction, so the post-fix
+candidate can never be challenged inside it. One succeeding chain may open at
+index 1 in `challenge` mode by supplying `--predecessor-chain-result-file` — the
+ended chain's terminal receipt — instead of an in-chain prior result. The
+controller accepts it only when that receipt is a tracked challenge at its own
+chain's terminal index, carries this chain's `review_scope_sha256` and matching
+stage/depth/risk-tags/budget, preserves the controller digest, owner-selection
+source, and selected owner names, and binds a candidate that DIFFERS from this
+packet: the owner-package digest is the one binding allowed to move, because its
+move is why the chain ended, and an unmoved candidate is a repeat round wearing a
+new chain id. Earlier challenge focuses carry forward, so a succession focus must
+differ from every focus the ended chain spent. The result records
+`predecessor_chain_id`, `predecessor_result_sha256`, and
+`predecessor_candidate_sha256`, and counts `material_candidate_change` as a
+satisfied self-review trigger. Succession carries history rather than resetting
+it: consumers still sum rounds across both chains.
+
 The chain binds task scope, candidate identity per round, result hashes, mode,
 status, challenge focus, controller, and selected owners. The opaque
 `review_scope_sha256` always hashes normalized intent, acceptance, stage/depth,
@@ -314,6 +332,11 @@ self-review plus explicit task reframing; it does not silently create a new
 Agent budget. An untracked challenge is one-off advisory evidence; it cannot
 enter a later Agent round or satisfy the local completion checkpoint.
 
+Two consequences follow from those stable bindings and must be planned for before round 1:
+
+- The selected-owner digest hashes each selected owner package's current working tree, and owners derive from the candidate's own paths — so a candidate edit inside any selected owner package invalidates every prior receipt and the next tracked round fails `review_chain_invalid`. For a self-hosted candidate (a skill-repo diff editing the package that owns it) that is nearly every applied fix — one confined to files outside every selected owner drifts only the candidate hash and may continue in-chain: "do not reset Agent authority" promises no continuation, and the in-chain tolerance for older candidate hashes is reachable only while the fix stays outside its selected owners.
+- A chain restarted after such a break re-enters the same cumulative Agent budget and must never be counted as fresh authority; the bounded restart recipe for the extraction lane (batched dispositions, cross-chain round accounting, full-context first packet, terminal disposition at the cap) is owned by the extraction workflow's dual-track gate reference.
+
 The controller is stateless and prevents accidental/cooperative resets only. A
 trusted host or platform must retain the ledger when hostile local callers are in
 scope; a repository-local counter cannot authenticate human authority.

package/dist/assets/marketplace/plugins/ccl-skills/skills/code-review/scripts/review_gate.py

@@ -429,6 +429,10 @@ CONTROLLER_OWNED_FIELDS = {
     "owner_selection_source",
     "owner_gaps",
     "observed_skill_usage",
+    "predecessor_candidate_sha256",
+    "predecessor_chain_id",
+    "predecessor_challenge_focuses",
+    "predecessor_result_sha256",
     "prior_challenge_focuses",
     "prior_review_result_sha256",
     "residual_risks",
@@ -1598,6 +1602,111 @@ def _stable_binding_matches(
     )
 
 
+def _validate_chain_succession(
+    path_value: str,
+    *,
+    review_chain_id: str,
+    challenge_budget: int,
+    review_scope_sha256: str,
+    stage: str,
+    review_depth: str,
+    risk_tags: list[str],
+    packet_hash: str,
+    review_controller_sha256: str,
+    owner_selection_source: str,
+    selected_skill_names: list[str],
+) -> dict[str, Any]:
+    """Validate the terminal receipt of the chain this one succeeds.
+
+    A fix that edits the reviewed owner package moves ``selected_skills_sha256``
+    and ends its chain by construction, so the post-fix candidate can never be
+    challenged inside that chain. Succession carries the ended chain forward:
+    every binding must still hold EXCEPT the owner-package digest whose move is
+    the reason the chain ended, and the candidate MUST have moved — a succession
+    whose candidate is unchanged is a repeat round wearing a new chain id.
+    """
+
+    def reject(reason: str) -> None:
+        raise GateError(f"chain succession {reason}", "review_chain_invalid")
+
+    prior, result_hash = _load_prior_review_result(path_value, 1)
+    if prior.get("predecessor_chain_id") is not None:
+        reject("predecessor is itself a succession round; succession does not compose")
+    prior_budget = prior.get("challenge_budget")
+    if (
+        prior.get("schema_version") != 3
+        or prior.get("mode") != "challenge"
+        or prior.get("status") not in ("passed", "findings")
+        or prior.get("review_chain_tracked") is not True
+        or not isinstance(prior_budget, int)
+        or isinstance(prior_budget, bool)
+        or prior_budget < 1
+    ):
+        reject("predecessor is not a tracked challenge receipt")
+    if (
+        prior.get("autonomous_review_index") != prior_budget + 1
+        or prior.get("challenge_index") != prior_budget
+        or prior.get("autonomous_reviews_remaining") != 0
+        or prior.get("autonomous_review_allowed") is not False
+    ):
+        # Terminality is the receipt's own arithmetic, not just its index: a
+        # forged receipt can carry a terminal index while every other field still
+        # says the chain has rounds left.
+        reject("predecessor is not its chain's terminal round")
+    predecessor_chain_id = prior.get("review_chain_id")
+    if not isinstance(predecessor_chain_id, str) or not predecessor_chain_id.strip():
+        reject("predecessor carries no chain id")
+    # A succession opens a second chain, so the chain it opens cannot be the chain
+    # it succeeds: reusing the id would let one chain keep succeeding itself, and
+    # every succession is a round the per-chain budget did not authorize. The
+    # closeout validator refuses this too, but only for a lane it reads whole --
+    # the controller mints one receipt at a time, and a caller that never closes a
+    # ledger never reaches that check. Refuse where the receipt is made.
+    if predecessor_chain_id == review_chain_id:
+        reject("may not succeed its own chain")
+    if _review_scope_digest(prior.get("review_scope")) != prior.get(
+        "review_scope_sha256"
+    ):
+        reject("predecessor carries a scope digest its own recorded scope does not produce")
+    if prior.get("review_scope_sha256") != review_scope_sha256:
+        reject("predecessor was reviewed under a different scope")
+    if (
+        prior.get("stage") != stage
+        or prior.get("review_depth") != review_depth
+        or prior.get("risk_tags") != risk_tags
+        or prior_budget != challenge_budget
+    ):
+        reject("predecessor carries the current scope digest with contradicting scope fields")
+    if (
+        prior.get("review_controller_sha256") != review_controller_sha256
+        or prior.get("owner_selection_source") != owner_selection_source
+        or prior.get("selected_skills") != selected_skill_names
+    ):
+        reject("predecessor does not preserve the controller and owner selection")
+    candidate_hash = prior.get("candidate_sha256")
+    if (
+        not isinstance(candidate_hash, str)
+        or len(candidate_hash) != 64
+        or prior.get("packet_sha256") != candidate_hash
+    ):
+        reject("predecessor does not bind one frozen candidate")
+    if candidate_hash == packet_hash:
+        reject("candidate has not moved, so this is a repeat round rather than a succession")
+    focuses: list[str] = []
+    for value in [
+        *(prior.get("prior_challenge_focuses") or []),
+        prior.get("challenge_focus"),
+    ]:
+        if isinstance(value, str) and value.strip():
+            focuses.append(value)
+    return {
+        "chain_id": predecessor_chain_id,
+        "result_sha256": result_hash,
+        "candidate_sha256": candidate_hash,
+        "focuses": focuses,
+    }
+
+
 def _wording_only_error(reason: str) -> None:
     raise GateError(reason, "wording_only_proof_invalid")
 
@@ -2540,6 +2649,7 @@ def freeze_review_profile(
             or args.review_chain_id
             or args.autonomous_review_index is not None
             or args.prior_review_result_file
+            or args.predecessor_chain_result_file
         ):
             raise GateError(
                 "complete mode accepts only a completion review result, candidate, and self-review plan",
@@ -2703,6 +2813,7 @@ def freeze_review_profile(
             or args.review_chain_id is not None
             or args.autonomous_review_index is not None
             or args.prior_review_result_file
+            or args.predecessor_chain_result_file
         ):
             _wording_only_error(
                 "--wording-only-proof-file is valid only for one untracked review with challenge budget 0"
@@ -2863,7 +2974,11 @@ def freeze_review_profile(
                 "review_chain_invalid",
             )
     else:
-        if args.autonomous_review_index is not None or args.prior_review_result_file:
+        if (
+            args.autonomous_review_index is not None
+            or args.prior_review_result_file
+            or args.predecessor_chain_result_file
+        ):
             raise GateError(
                 "Agent review-chain inputs require --review-chain-id",
                 "review_chain_invalid",
@@ -2934,13 +3049,54 @@ def freeze_review_profile(
     previous_challenge_focuses: list[str] = []
     prior_review_result_hashes: list[str] = []
     prior_review_candidate_hashes: list[str] = []
+    succession: dict[str, Any] | None = None
+    inherited_challenge_focuses: list[str] = []
     if review_chain_tracked:
+        if args.predecessor_chain_result_file:
+            if args.mode != "challenge":
+                raise GateError(
+                    "chain succession applies only to a challenge round",
+                    "review_chain_invalid",
+                )
+            if not challenge_focus:
+                raise GateError("challenge mode requires a non-empty --focus")
+            if challenge_budget == 0:
+                raise GateError("challenge mode requires a positive challenge budget")
+            if autonomous_review_index != 1 or args.challenge_index != 1:
+                raise GateError(
+                    "a succession chain opens at Agent round 1 with challenge index 1",
+                    "review_chain_invalid",
+                )
+            if args.prior_review_result_file:
+                raise GateError(
+                    "a succession chain opens with no in-chain prior review result",
+                    "review_chain_invalid",
+                )
+            succession = _validate_chain_succession(
+                args.predecessor_chain_result_file,
+                review_chain_id=review_chain_id,
+                challenge_budget=challenge_budget,
+                review_scope_sha256=review_scope_sha256,
+                stage=args.stage,
+                review_depth=review_depth,
+                risk_tags=risk_tags,
+                packet_hash=packet_hash,
+                review_controller_sha256=review_controller_sha256,
+                owner_selection_source=owner_selection_source,
+                selected_skill_names=[item["name"] for item in selected_skills],
+            )
+            # Inherited focuses get their own field. prior_challenge_focuses carries
+            # in-chain arithmetic that consumers derive from the round index, and a
+            # succession round would otherwise arrive at index 1 carrying focuses the
+            # index cannot explain -- which is exactly how the completion checkpoint
+            # rejected it.
+            inherited_challenge_focuses = list(succession["focuses"])
         if args.mode == "review" and autonomous_review_index != 1:
             raise GateError(
                 "tracked review mode is Agent round 1; later Agent rounds use challenge mode",
                 "review_chain_invalid",
             )
-        if args.mode == "challenge":
+        if args.mode == "challenge" and succession is None:
             if not challenge_focus:
                 raise GateError("challenge mode requires a non-empty --focus")
             if challenge_budget == 0:
@@ -2961,6 +3117,11 @@ def freeze_review_profile(
             args.prior_review_result_file, start=1
         ):
             prior, result_hash = _load_prior_review_result(path_value, expected_index)
+            if prior.get("predecessor_chain_id") is not None:
+                raise GateError(
+                    f"prior review result {expected_index} is a succession round, which is one-shot",
+                    "review_chain_invalid",
+                )
             expected_mode = "review" if expected_index == 1 else "challenge"
             focus = prior.get("challenge_focus")
             candidate_hash = prior.get("candidate_sha256")
@@ -3038,7 +3199,9 @@ def freeze_review_profile(
                 previous_challenge_focuses.append(focus)
             prior_review_result_hashes.append(result_hash)
             prior_review_candidate_hashes.append(candidate_hash)
-        if challenge_focus and challenge_focus in previous_challenge_focuses:
+        if challenge_focus and challenge_focus in (
+            previous_challenge_focuses + inherited_challenge_focuses
+        ):
             raise GateError(
                 "challenge focus must differ from earlier challenges",
                 "review_chain_invalid",
@@ -3062,7 +3225,7 @@ def freeze_review_profile(
     if (
         prior_review_candidate_hashes
         and prior_review_candidate_hashes[-1] != packet_hash
-    ):
+    ) or succession is not None:
         self_review_satisfied_triggers.append("material_candidate_change")
     if high_risk:
         self_review_satisfied_triggers.append("risk_or_scope_escalation")
@@ -3120,6 +3283,12 @@ def freeze_review_profile(
         "skill_delivery": "native-installed",
         "prior_challenge_focuses": previous_challenge_focuses,
         "prior_review_result_sha256": prior_review_result_hashes,
+        "predecessor_challenge_focuses": inherited_challenge_focuses,
+        "predecessor_chain_id": succession["chain_id"] if succession else None,
+        "predecessor_result_sha256": succession["result_sha256"] if succession else None,
+        "predecessor_candidate_sha256": (
+            succession["candidate_sha256"] if succession else None
+        ),
         "self_review_satisfied_triggers": self_review_satisfied_triggers,
         "required_concerns": [
             {"id": concern_id, "description": description}
@@ -3394,6 +3563,10 @@ def composite_base(
         "review_scope": _canonical_review_scope(profile),
         "review_scope_sha256": profile["review_scope_sha256"],
         "prior_review_result_sha256": profile["prior_review_result_sha256"],
+        "predecessor_challenge_focuses": profile["predecessor_challenge_focuses"],
+        "predecessor_chain_id": profile["predecessor_chain_id"],
+        "predecessor_result_sha256": profile["predecessor_result_sha256"],
+        "predecessor_candidate_sha256": profile["predecessor_candidate_sha256"],
         "challenge_rounds_remaining": challenge_rounds_remaining,
         "autonomous_review_budget": autonomous_review_budget,
         "autonomous_review_index": autonomous_review_index,
@@ -3691,6 +3864,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--review-chain-id")
     parser.add_argument("--autonomous-review-index", type=int)
     parser.add_argument("--prior-review-result-file", action="append", default=[])
+    parser.add_argument("--predecessor-chain-result-file", default=None)
     parser.add_argument("--completion-review-result-file")
     parser.add_argument("--allow-fallback-egress", action="store_true")
     parser.add_argument("--host-remediation-attempted", action="store_true")

package/dist/assets/marketplace/plugins/ccl-skills/skills/code-review/scripts/test_review_gate.sh

@@ -3199,6 +3199,133 @@ printf '%s\n' "$passed_round_one" >"$WORK/passed-round-one.json"
 check "a passed first tracked round still owes its challenge before completion" \
   '[ "$passed_round_one_rc" = 0 ] && json_fields "$passed_round_one" status=passed autonomous_review_index=1 autonomous_reviews_remaining=2 autonomous_review_allowed=true next_action=run_challenge completion_gated=true'
 
+# Chain succession. A fix that touches the owner package moves selected_skills_sha256
+# and ends the chain by design, so the post-fix candidate can never be challenged
+# inside it. Succession opens ONE new chain whose first Agent round is a challenge,
+# inheriting the ended chain's terminal receipt. The owner-binding move is the
+# expected difference; every other binding must still hold, and a succession whose
+# candidate did not actually move is a repeat round, not a succession.
+succession_saved_diff="$(cat "$WORK/diff.patch")"
+printf 'diff --git a/x b/x\n--- a/x\n+++ b/x\n@@ -1 +1 @@\n-pre\n+fix-pending\n' >"$WORK/diff.patch"
+reset_case findings unavailable unavailable
+succ_one="$(run_gate --challenge-budget 1 --review-chain-id succ-phase-one --autonomous-review-index 1)"; succ_one_rc=$?
+printf '%s\n' "$succ_one" >"$WORK/succ-round-one.json"
+reset_case findings unavailable unavailable
+succ_two="$(run_challenge_gate --focus phase-one-surface --review-chain-id succ-phase-one --autonomous-review-index 2 --prior-review-result-file "$WORK/succ-round-one.json")"; succ_two_rc=$?
+printf '%s\n' "$succ_two" >"$WORK/succ-round-two.json"
+check "the succession fixture builds a terminal budget-one phase-one chain" \
+  '[ "$succ_one_rc" = 0 ] && [ "$succ_two_rc" = 0 ] && json_fields "$succ_two" autonomous_review_index=2 autonomous_reviews_remaining=0'
+
+# The fix batch lands: the candidate moves and the owner package hash moves with it.
+printf 'diff --git a/x b/x\n--- a/x\n+++ b/x\n@@ -1 +1 @@\n-pre\n+fix-applied\n' >"$WORK/diff.patch"
+python3 - "$WORK/succ-round-two.json" \
+  "$WORK/succ-predecessor-owner-moved.json" \
+  "$WORK/succ-predecessor-forged-controller.json" \
+  "$WORK/succ-predecessor-foreign-scope.json" \
+  "$WORK/succ-predecessor-forged-terminal.json" <<'PY'
+import json
+from pathlib import Path
+import sys
+
+source = json.loads(Path(sys.argv[1]).read_text())
+# The owner package legitimately moved: the fix edited the reviewed skill itself.
+owner_moved = json.loads(json.dumps(source))
+owner_moved["selected_skills_sha256"] = "a" * 64
+Path(sys.argv[2]).write_text(json.dumps(owner_moved, separators=(",", ":")))
+# The controller itself must not move under a succession.
+forged = json.loads(json.dumps(source))
+forged["review_controller_sha256"] = "0" * 64
+Path(sys.argv[3]).write_text(json.dumps(forged, separators=(",", ":")))
+# A predecessor from a differently-scoped chain is not this candidate's history.
+foreign = json.loads(json.dumps(source))
+foreign["review_scope"] = dict(foreign["review_scope"], stage="explore")
+foreign["stage"] = "explore"
+Path(sys.argv[4]).write_text(json.dumps(foreign, separators=(",", ":")))
+# A terminal index with non-terminal arithmetic: the index alone cannot establish
+# that the succeeded chain actually ended.
+forged_terminal = json.loads(json.dumps(source))
+forged_terminal["challenge_index"] = 0
+forged_terminal["autonomous_reviews_remaining"] = 1
+forged_terminal["autonomous_review_allowed"] = True
+Path(sys.argv[5]).write_text(json.dumps(forged_terminal, separators=(",", ":")))
+PY
+
+reset_case passed unavailable unavailable
+succ_phase_two="$(run_challenge_gate --focus post-fix-batch --review-chain-id succ-phase-two --autonomous-review-index 1 --predecessor-chain-result-file "$WORK/succ-round-two.json")"; succ_phase_two_rc=$?
+check "a succession chain opens its first Agent round as a challenge on the moved candidate" \
+  '[ "$succ_phase_two_rc" = 0 ] && json_fields "$succ_phase_two" mode=challenge review_chain_tracked=true review_chain_id=succ-phase-two autonomous_review_index=1 predecessor_chain_id=succ-phase-one predecessor_result_sha256='"$(shasum -a 256 "$WORK/succ-round-two.json" | awk '{print $1}')"''
+
+reset_case passed unavailable unavailable
+out="$(run_challenge_gate --focus owner-moved --review-chain-id succ-owner-moved --autonomous-review-index 1 --predecessor-chain-result-file "$WORK/succ-predecessor-owner-moved.json")"; rc=$?
+check "a succession accepts the owner-package hash move that ended the prior chain" \
+  '[ "$rc" = 0 ] && json_fields "$out" mode=challenge predecessor_chain_id=succ-phase-one'
+
+reset_case passed unavailable unavailable
+out="$(run_challenge_gate --focus no-predecessor --review-chain-id succ-orphan --autonomous-review-index 1)"; rc=$?
+check "a tracked challenge cannot open a chain without a predecessor receipt" \
+  '[ "$rc" = 2 ] && [ ! -e "$WORK/state/client_sequence" ] && json_fields "$out" reason_code=review_chain_invalid && case "$out" in *"chain succession"*) false;; *) true;; esac'
+
+reset_case passed unavailable unavailable
+out="$(run_challenge_gate --focus review-predecessor --review-chain-id succ-review-predecessor --autonomous-review-index 1 --predecessor-chain-result-file "$WORK/succ-round-one.json")"; rc=$?
+check "a succession rejects a predecessor that is not a challenge receipt" \
+  '[ "$rc" = 2 ] && [ ! -e "$WORK/state/client_sequence" ] && json_fields "$out" reason_code=review_chain_invalid && case "$out" in *"chain succession predecessor is not a tracked challenge receipt"*) true;; *) false;; esac'
+
+# A mid-chain challenge is a live chain, not an ended one: succeeding it would
+# silently retire rounds the wrapper still owes. chain-round-two above is round 2
+# of a three-round budget, so it is a challenge that is NOT its chain's terminal.
+reset_case passed unavailable unavailable
+out="$(run_challenge_gate --challenge-budget 2 --focus non-terminal --review-chain-id succ-non-terminal --autonomous-review-index 1 --predecessor-chain-result-file "$WORK/chain-round-two.json")"; rc=$?
+check "a succession rejects a predecessor that is not its chain's terminal round" \
+  '[ "$rc" = 2 ] && [ ! -e "$WORK/state/client_sequence" ] && json_fields "$out" reason_code=review_chain_invalid && case "$out" in *"chain succession predecessor is not its chain"*) true;; *) false;; esac'
+
+reset_case passed unavailable unavailable
+printf '%s\n' "$(cat "$WORK/succ-round-two.json")" >/dev/null
+printf 'diff --git a/x b/x\n--- a/x\n+++ b/x\n@@ -1 +1 @@\n-pre\n+fix-pending\n' >"$WORK/diff.patch"
+out="$(run_challenge_gate --focus unmoved-candidate --review-chain-id succ-unmoved --autonomous-review-index 1 --predecessor-chain-result-file "$WORK/succ-round-two.json")"; rc=$?
+check "a succession whose candidate did not move is a repeat round, not a succession" \
+  '[ "$rc" = 2 ] && [ ! -e "$WORK/state/client_sequence" ] && json_fields "$out" reason_code=review_chain_invalid && case "$out" in *"chain succession candidate has not moved"*) true;; *) false;; esac'
+printf 'diff --git a/x b/x\n--- a/x\n+++ b/x\n@@ -1 +1 @@\n-pre\n+fix-applied\n' >"$WORK/diff.patch"
+
+# A succession opens a second chain, so the chain it opens cannot be the chain it
+# succeeds. The closeout validator already refuses this shape, but only for a lane
+# it reads whole: the controller mints receipts one at a time, and a caller that
+# never closes a ledger never reaches that check. Refusing at mint keeps the rule
+# where the receipt is made rather than where it is later audited.
+reset_case passed unavailable unavailable
+out="$(run_challenge_gate --focus self-succession --review-chain-id succ-phase-one --autonomous-review-index 1 --predecessor-chain-result-file "$WORK/succ-round-two.json")"; rc=$?
+check "a succession may not carry the chain id of the chain it succeeds" \
+  '[ "$rc" = 2 ] && [ ! -e "$WORK/state/client_sequence" ] && json_fields "$out" reason_code=review_chain_invalid && case "$out" in *"chain succession may not succeed its own chain"*) true;; *) false;; esac'
+
+for succession_case in forged-controller foreign-scope forged-terminal; do
+  reset_case passed unavailable unavailable
+  out="$(run_challenge_gate --focus "succ-${succession_case}" --review-chain-id "succ-${succession_case}" --autonomous-review-index 1 --predecessor-chain-result-file "$WORK/succ-predecessor-${succession_case}.json")"; rc=$?
+  check "a succession rejects a ${succession_case} predecessor" \
+    '[ "$rc" = 2 ] && [ ! -e "$WORK/state/client_sequence" ] && json_fields "$out" reason_code=review_chain_invalid && case "$out" in *"chain succession"*) true;; *) false;; esac'
+done
+# Succession is one-shot. If a succession receipt could be continued in-chain, or
+# could itself be the next succession's predecessor, the relaxation would daisy-chain
+# into unbounded autonomous rounds -- the exact bypass it must not become.
+printf '%s\n' "$succ_phase_two" >"$WORK/succ-phase-two.json"
+reset_case passed unavailable unavailable
+out="$(run_challenge_gate --focus chained-succession --review-chain-id succ-phase-three --autonomous-review-index 1 --predecessor-chain-result-file "$WORK/succ-phase-two.json")"; rc=$?
+check "a succession round cannot be the predecessor of another succession" \
+  '[ "$rc" = 2 ] && [ ! -e "$WORK/state/client_sequence" ] && json_fields "$out" reason_code=review_chain_invalid && case "$out" in *"succession does not compose"*) true;; *) false;; esac'
+
+reset_case passed unavailable unavailable
+out="$(run_challenge_gate --focus continued-succession --review-chain-id succ-phase-two --autonomous-review-index 2 --prior-review-result-file "$WORK/succ-phase-two.json")"; rc=$?
+check "a succession round cannot be continued in its own chain" \
+  '[ "$rc" = 2 ] && [ ! -e "$WORK/state/client_sequence" ] && json_fields "$out" reason_code=review_chain_invalid && case "$out" in *"succession round, which is one-shot"*) true;; *) false;; esac'
+
+# The completion checkpoint has to accept the succession round it will actually be
+# handed: a chain-index-1 challenge. Without this the ledger's terminal step is
+# unproven for exactly the chain shape the third round produces.
+reset_case passed unavailable unavailable
+out="$(run_completion_gate --challenge-budget 1 --completion-review-result-file "$WORK/succ-phase-two.json")"; rc=$?
+check "the completion checkpoint closes on a succession round" \
+  '[ "$rc" = 0 ] && json_fields "$out" mode=complete status=passed review_chain_tracked=true review_chain_id=succ-phase-two autonomous_review_index=1 autonomous_review_allowed=false completion_gated=false'
+
+printf '%s\n' "$succession_saved_diff" >"$WORK/diff.patch"
+
 python3 - "$WORK/passed-round-one.json" "$WORK/chain-round-two.json" \
   "$WORK/round-one-forged-final-shape.json" \
   "$WORK/round-two-forged-final-shape.json" <<'PY'

package/dist/assets/marketplace/plugins/ccl-skills/skills/defect-diagnosis/SKILL.md

@@ -45,7 +45,7 @@ Use this skill for the full defect discipline: diagnose the immediate failure, f
 
 3. Hypothesize.
    - Write concrete causes that can be proven or rejected.
-   - For each hypothesis, define the expected observation if it is true.
+   - For each hypothesis, define the expected observation if it is true **and the observation that would falsify it** — then go get the falsifying one first. A search hit, a log line, or a plausible implementation detail proves the text EXISTS, not that it RAN on the path that failed: run it on the failing path for an observation only THAT cause predicts — reachability rules out non-execution and nothing else, so watching the suspected code execute clears no cause — or build a paired control differing in exactly ONE variable (every precondition of the predicate under test enumerated, both arms equal on all the others). Until an operation that could have falsified the cause has been run and did not, it stays a `hypothesis` — it must not become the basis of a fix, and it must not enter a commit/MR body, a durable note, or a report as the cause. Withdrawing a landed wrong cause costs far more than testing it. The probe itself stays inside the same boundaries the extraction workflow's falsification rule names — existing sandbox and permission limits, non-destructive, synthetic targets, no production or live credentials, no permission-boundary bypass; where no safe probe exists the cause simply stays a `hypothesis` and must never be upgraded by running an unsafe one.
 
 4. Instrument.
    - Add targeted logs, assertions, traces, metrics, local probes, or debugger breakpoints.
@@ -137,6 +137,7 @@ The **widen + multi-layer (Swiss Cheese) lens fires on complexity above, not onl
 - Go backend implementation, testing, codegen, DB, Redis, MQ, or protobuf issue -> `go-microservice-dev` references.
 - Python backend, AI-service host, worker, SDK/package, or batch-job architecture issue -> `python-service-architecture`.
 - Python implementation, pytest, packaging, schema, ORM/migration, Redis, queue, async, or service-wiring issue -> `python-service-dev` references.
+- Node.js implementation, runtime/module/type path, package-manager or lockfile, async lifecycle, stream, worker, outbound-client, or `node:test`/runner issue -> `nodejs-service-dev` references. A Node.js architecture or service-boundary issue has no architecture sibling by decision and must not be filed under a sibling stack's architecture skill -> `product-rd-workflow`'s architecture gate plus the relevant `platform-*` owner.
 - LLM, inference, RAG, prompt, model-routing, streaming, fallback, evaluation, replay, shadow, token-cost, or agent-runtime/tool-call issue -> `llm-inference-integration`.
 - Mobile app issue involving Flutter, Android, iOS, navigation, state, platform bridge, device capability, build/release, crash, accessibility, or performance -> `app-cross-platform-dev`.
 - Mini-program issue involving WeChat/Alipay/Douyin/Baidu page routing, host-platform APIs, developer tools, review submission, release, real-device preview, or platform capability -> `miniapp-product-dev`.

package/dist/assets/marketplace/plugins/ccl-skills/skills/go-microservice-dev/SKILL.md

@@ -30,7 +30,7 @@ Use this for implementation of new backend products and services. It should adap
 - If an observed pattern only works for one product domain, discard it instead of turning it into a rule.
 - Resolve conflicts by choosing the safer generic default: explicit contracts over hidden conventions, DB constraints over cache-only correctness, typed config over ad hoc strings, idempotent consumers over retry-only consumers, focused unit tests over live-infra tests by default, and fail-closed for auth/permission/data-integrity paths.
 - Fuse patterns only when both are product-agnostic and reduce implementation ambiguity; otherwise keep the simpler rule.
-- When adding or revising durable Go implementation guidance, check whether the lesson is generic backend service practice that should also update `python-service-dev`, or belongs in a shared workflow skill instead. If the rule depends on Go tooling, protobuf/Kitex/Hertz, Go concurrency, or Go package layout, keep it here and do not force a Python mirror.
+- When adding or revising durable Go implementation guidance, check whether the lesson is generic backend service practice that should also update the sibling stack owners `python-service-dev` and `nodejs-service-dev`, or belongs in a shared workflow skill instead. Record each sibling as `update`, `unchanged`, or `route-to-shared` rather than leaving it unexamined. If the rule depends on Go tooling, protobuf/Kitex/Hertz, Go concurrency, or Go package layout, keep it here and do not force a Python or Node mirror.
 - Example: if an existing project uses inline Redis keys but another wraps keys in typed builders, implement typed builders and discard inline string formatting as a reusable pattern.
 
 ## Development Workflow

package/dist/assets/marketplace/plugins/ccl-skills/skills/llm-inference-integration/SKILL.md

@@ -12,6 +12,7 @@ Use this for product backend work that calls, hosts, evaluates, or operates LLM
 - Use this skill for LLM gateway/client design, model registry, prompt versioning, agent/tool orchestration, streaming APIs, fallback, token/cost accounting, evals, replay, shadow comparison, batch inference, and inference observability.
 - Use `go-microservice-architecture` or `go-microservice-dev` when the work is mainly a Go service with ordinary storage/RPC/MQ concerns and only minor LLM integration.
 - Use `python-service-architecture` or `python-service-dev` when the work is mainly a Python service, AI-service host, worker, SDK/package, or batch job with ordinary API/storage/Redis/queue/pytest/packaging concerns and only minor inference integration.
+- Use `nodejs-service-dev` on the same terms when that host is mainly a Node.js service, worker, or CLI/tooling with ordinary API/storage/queue/runner/packaging concerns and only minor inference integration; its architecture decisions must go to `product-rd-workflow`, never to a Node architecture sibling, which does not exist by decision.
 - Use `defect-diagnosis` first when a model output, flaky eval, timeout, regression, fallback failure, or prompt/version issue must be reproduced and root-caused.
 - Use `product-rd-workflow` first when the request spans product goal, PRD, architecture, implementation plan, release, and learning loop.
 - Use `product-rd-workflow` first for AI/algorithm product launch SOPs, business acceptance baselines, build-vs-buy ROI, new-vs-iteration launch gates, or multi-algorithm product quality gates. This skill owns inference implementation/evaluation mechanics after the product gate is defined.

package/dist/assets/marketplace/plugins/ccl-skills/skills/nodejs-service-dev/SKILL.md

@@ -12,6 +12,14 @@ description: Use when implementing, modifying, scaffolding, or testing Node.js b
 - `testing-strategy` chooses test layers, coverage policy, contract/E2E scope, and CI gates. This skill owns Node runner, mock, fixture, and command mechanics after that choice.
 - Standalone CLI/tooling stays here; language-stack CLI implementation must not be routed back to `terminal-cli-dev`, owner of the interface contract; logs/metrics/traces to `platform-observability`; cross-service timeout/retry/mTLS to `platform-service-connectivity`; rollout/rollback to `platform-release-engineering`.
 - Browser UI goes to `web-react-dev`; LLM/RAG/agent-runtime behavior to `llm-inference-integration`. Keep language-neutral rules in their existing owner.
+- Architecture, service-boundary, and data-ownership decisions have no Node architecture sibling skill by decision: they run through `product-rd-workflow`'s architecture gate plus the relevant `platform-*` owners, and this skill owns the Node-side implementation contract. Do not borrow the Go or Python architecture skill for a Node.js service.
+- The runtime contract here is Node.js. Bun and Deno share much of this service shape, but their runtime, package, permission, and built-in-API semantics differ and are not verified against this skill's sources: reuse the boundary and lifecycle rules, confirm every runtime-specific claim against that runtime's own documentation, and treat a deliberate migration as a `product-rd-workflow` decision rather than a drop-in swap.
+
+## Generalization Discipline
+
+- Implement the repository in front of you; do not lift product nouns, service names, package paths, or organization-specific habits from a prior codebase into a reusable rule.
+- When adding or revising durable Node.js guidance, place it deliberately. A rule that depends on Node runtime or toolchain mechanics — module resolution, TypeScript execution, event loop, streams, `worker_threads`, package-manager state — stays here. Generic backend service practice belongs in the shared workflow, testing, or architecture owner; a lesson that also holds for a sibling stack updates `go-microservice-dev` or `python-service-dev` in the same landing instead of living only here.
+- The duty runs inward too: a generic backend rule already landed in a sibling stack skill applies here unless Node runtime semantics make it wrong. Record the per-sibling decision — `update`, `unchanged`, or `route-to-shared` — rather than leaving the sibling unexamined.
 
 ## Workflow
 
@@ -34,8 +42,10 @@ State input, output, error, cancellation, timeout, idempotency, and ownership be
 - Propagate cancellation/deadlines to underlying work. A wrapper timeout that leaves work running is not cancellation.
 - Use streams with backpressure for large/unbounded data. Use a bounded `worker_threads` pool only for measured CPU-intensive JavaScript, not ordinary async I/O.
 - Preserve error causes and map once at the boundary. Do not swallow rejections or resume normal operation after an unknown fatal process error.
+- Carry request context (correlation, tenant, deadline) in `AsyncLocalStorage` established at the owning boundary, not through every signature or a process-wide mutable. Pick the no-context behavior by what the value authorizes: a diagnostic value may declare a default, but a security-bearing one must fail the operation closed.
+- Treat the outbound HTTP client as a bounded resource: its pool is unbounded by default, its timeouts are layered rather than an overall deadline, and an unconsumed response body holds its connection.
 
-Read [async-lifecycle-and-performance.md](references/async-lifecycle-and-performance.md) when touching concurrency, streams, CPU work, shutdown, or performance.
+Read [async-lifecycle-and-performance.md](references/async-lifecycle-and-performance.md) when touching concurrency, request context, outbound clients, streams, CPU work, shutdown, or performance.
 
 ### 3. Make lifecycle and exposure explicit
 

package/dist/assets/marketplace/plugins/ccl-skills/skills/nodejs-service-dev/references/async-lifecycle-and-performance.md

@@ -22,6 +22,13 @@ Node.js uses a small number of threads to serve many clients. A long callback re
 - Remove listeners and timers during cleanup. Use `unref()` only when it matches lifecycle ownership; it is not a substitute for cancelling work.
 - Retries must fit inside one overall deadline, use the connectivity owner's policy, and remain bounded. Never retry non-idempotent effects without an idempotency contract.
 
+## Request context propagation
+
+- Carry per-request context — correlation/trace ids, tenant, deadline, auth subject — in `AsyncLocalStorage` rather than threading it through every signature or parking it on a process-wide mutable. Prefer the built-in store over hand-rolled `async_hooks` context machinery: the custom form has to re-implement propagation across every async boundary and is where context silently vanishes.
+- Establish the store once at the owning boundary (request/job/consumer entry) and read it inward. Outside an established context the read returns `undefined` — or the instance's configured default value, where the deployed runtime supports declaring one, which is a version-gated option to verify rather than assume. Either way, code that must also run without a request (startup, a shutdown drain, a background loop) needs an explicit branch or fallback, never a bare dereference of an absent context. Choose which by what the value authorizes: a correlation id may safely default, but a tenant, subject, or permission scope must make the operation fail closed when the context is missing. Declaring a default for those turns an absent context into work silently executed under the wrong identity — the store is a propagation mechanism, never the authorization decision.
+- Propagation is not automatic across every boundary. The store stays coherent through asynchronous operations started inside the context, which is not the same as crossing an isolate or process edge: before relying on context inside a `worker_threads` worker or a child process, verify propagation there rather than assuming it, and pass the needed values explicitly across any edge you have not verified.
+- What goes in the store is an implementation mechanic; which fields must exist and propagate is owned by `platform-observability`. Do not invent a field set here.
+
 ## Bounded concurrency
 
 - Replace unbounded `Promise.all(items.map(...))` on variable-size input with a repository-standard limiter, queue, or batch window.
@@ -29,6 +36,15 @@ Node.js uses a small number of threads to serve many clients. A long callback re
 - Track in-flight ownership so shutdown can await or abort it. A detached promise must have an explicit supervisor and error sink.
 - Avoid per-request child processes or workers. If CPU offload is justified, measure task duration and transfer cost, then reuse a bounded pool.
 
+## Outbound HTTP clients
+
+- The process-wide dispatcher is a real contract, not a default to ignore. The built-in `fetch` routes through the globally configured dispatcher, so pooling, keep-alive, and timeout behavior for every outbound call are decided by that one object; set it deliberately at startup and treat replacing it as a service-wide change rather than a local one.
+- **The defaults are unbounded where it matters.** The per-origin pool defaults to unlimited connections, and the number of distinct origins is unbounded unless capped, so an outbound burst is bounded only by whatever bounds the calling code carries. This is the bounded-concurrency rule above applied at the socket layer: bound connections per origin, and bound origins too when destinations are influenced by input.
+- **Timeouts are layered, and none of them is an overall deadline.** Connect, response-headers, and response-body timeouts are separate settings; a request can stay within every one of them and still blow the caller's budget. The overall deadline comes from the caller's `AbortSignal` — per the cancellation rule above, a deadline not attached to the request is not a deadline.
+- **An unconsumed response body holds its connection.** Consume or explicitly cancel the body even when only the status or headers were wanted; leaving it unread stalls the request and leaks the pooled connection. A happy-path test that never reads a body cannot see this, so exercise the discard path directly.
+- Defaults and option names drift across runtime and client versions. Read the deployed version's own documentation and the repository's actual dispatcher wiring instead of assuming a number, and verify the pool/timeout settings a change depends on rather than restating them from memory.
+- Retry, backoff, circuit breaking, mTLS, and cross-service timeout *policy* stay with `platform-service-connectivity`. This section owns only the Node-side client shape that implements whatever policy that owner sets.
+
 ## Streams and backpressure
 
 - Prefer `node:stream/promises` `pipeline()` or an established equivalent so errors and teardown propagate across the chain.

package/dist/assets/marketplace/plugins/ccl-skills/skills/nodejs-service-dev/references/source-map.md

@@ -17,6 +17,7 @@ Inspected 2026-08-30. This file records provenance and extraction limits; it is
 | diagnostics | [Heap snapshots](https://nodejs.org/en/learn/diagnostics/memory/using-heap-snapshot), [flame graphs](https://nodejs.org/en/learn/diagnostics/flame-graphs) | performance claims need profiles/measurements; heap snapshots can stop the main thread and exhaust memory |
 | security | [Node.js security best practices](https://nodejs.org/en/learn/getting-started/security-best-practices) | bound input work, harden dependencies, and use runtime permissions only as defense in depth |
 | reproducible install / provenance | [npm ci](https://docs.npmjs.com/cli/v11/commands/npm-ci/), [npm provenance](https://docs.npmjs.com/generating-provenance-statements) | frozen lockfile install is the verification contract; provenance proves origin/build linkage, not code safety |
+| outbound HTTP clients | [undici getting started](https://github.com/nodejs/undici/blob/main/docs/docs/getting-started.md), [undici Agent API](https://github.com/nodejs/undici/blob/main/docs/docs/api/Agent.md), [undici README](https://github.com/nodejs/undici/blob/main/README.md) | the global dispatcher backs the built-in `fetch`; per-origin pools default to unlimited connections and origins are unbounded unless capped; connect/headers/body timeouts are layered and none is an overall deadline; an unconsumed response body stalls the request and holds its pooled connection |
 
 ## Independent industry controls