@ccoalm/ccl-skills 0.17.0 → 0.18.0

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

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""Refuse a pull request that changes shared skill behavior with no recorded review.
+
+The extraction review lane owes one review and one challenge per non-wording
+change (references/dual-track-review-gate.md). The merge-side candidate binding
+that used to sit here was retired: it tied every pass to one tree hash, so every
+fix voided the passes and restarted the sequence. What it also did — refuse a
+landing with no review at all — is the half worth keeping, and it needs no hash.
+
+This gate asks one question: does a pull request that changes `skills/` or
+`hooks/` carry at least one conclusive review result added or modified under a
+specs/<round>/evidence/ directory?
+
+It deliberately does not require a challenge result. An earlier version did,
+with a waiver for wording-only changes; independent review broke that waiver in
+four successive forms (a global waiver, a second skill, a later edit to the same
+file, a rewritten frontmatter delimiter), because deciding "still wording-only"
+means re-parsing diffs this gate does not own. Same-class recurrence is the cue
+to delete the capability, so the challenge obligation stays in the review-lane
+rule and this gate only catches a round that recorded no external pass at all.
+
+A result is conclusive when it is a schema-3 controller envelope whose status is
+`passed` or `findings` and which names the client that ran it. It does not check
+which candidate a result reviewed, and it cannot tell a genuine result from a
+hand-written one: like the repository's other author-declared gates it catches a
+pass that was never recorded, not a forged one.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+SUBJECT_PREFIXES = ("skills/", "hooks/")
+CONCLUSIVE = ("passed", "findings")
+
+
+def changed_paths(root: Path, base: str) -> list[str]:
+    result = subprocess.run(
+        # No --diff-filter: every change class counts, including a type change
+        # (a regular file replaced by a symlink), which a filter list omits.
+        ["git", "-C", str(root), "diff", "--name-only", "--no-renames", base, "HEAD"],
+        capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(result.stderr.strip() or "git diff failed")
+    return [line for line in result.stdout.splitlines() if line]
+
+
+def is_evidence_json(path: str) -> bool:
+    parts = path.split("/")
+    return (
+        len(parts) >= 4
+        and parts[0] == "specs"
+        and "evidence" in parts[2:-1]
+        and parts[-1].endswith(".json")
+    )
+
+
+def load_result(root: Path, path: str) -> dict | None:
+    target = root / path
+    if not target.is_file():
+        return None
+    try:
+        value = json.loads(target.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+        return None
+    if not isinstance(value, dict) or value.get("schema_version") != 3:
+        return None
+    if value.get("mode") not in ("review", "challenge"):
+        return None
+    if value.get("status") not in CONCLUSIVE or not value.get("selected_client"):
+        return None
+    return value
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--repo-root", default=".")
+    parser.add_argument("--base", required=True)
+    args = parser.parse_args(argv)
+    root = Path(args.repo_root).resolve()
+
+    try:
+        paths = changed_paths(root, args.base)
+    except RuntimeError as exc:
+        print(f"review_evidence_unevaluated: {exc}")
+        return 2
+
+    subjects = [p for p in paths if p.startswith(SUBJECT_PREFIXES)]
+    if not subjects:
+        print("review_evidence_not_required: no change under skills/ or hooks/")
+        return 0
+
+    reviews: list[str] = []
+    challenges: list[str] = []
+    for path in paths:
+        if not is_evidence_json(path):
+            continue
+        result = load_result(root, path)
+        if result is None:
+            continue
+        (reviews if result["mode"] == "review" else challenges).append(path)
+
+    if not reviews:
+        print(
+            "review_evidence_missing: this pull request changes "
+            f"{len(subjects)} path(s) under skills/ or hooks/ but carries no conclusive "
+            "review result under specs/<round>/evidence/"
+        )
+        print("  fix: commit the controller result JSON of each owed pass "
+              "(references/dual-track-review-gate.md, Recording the passes)")
+        return 1
+    print(f"review_evidence_present_ok: {len(reviews)} review, {len(challenges)} challenge")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/dist/assets/marketplace/plugins/ccl-skills/skills/skill-extraction-workflow/scripts/contract-anchors.tsv

@@ -13,7 +13,6 @@ burn-rate-page-row-reference	skills/platform-observability/references/sli-slo-de
 coverage-tier-provenance	skills/testing-strategy/references/test-code-authoring-patterns.md	60% acceptable / 75% commendable / 90% exemplary 分档	071-chainC-r1f4: externally verified coverage tiers (specs/071 source-verification)
 pairwise-trigger-range	skills/test-artifact-management/references/classical-test-design-techniques.md	2-way 累计触发 53–97%	071-chainC-r1f4: NIST SP 800-142 empirical range, externally verified (specs/071 source-verification)
 bva-two-vs-three-value	skills/test-artifact-management/references/classical-test-design-techniques.md	2-value（边界 + 下一格）和 3-value（边界 + 两侧）	071-chainC-r1f4: ISTQB v4 BVA variant definitions, externally verified (specs/071 source-verification)
-merge-side-ledger-binding-failclosed	skills/skill-extraction-workflow/scripts/review_ledger_binding.py	return 0 if args.allow_unevaluated else 2	084-r4f1: the no-base fail-closed branch; flipping it to an unconditional 0 restores a gate that passes having checked nothing
 lane-budget-default-range	skills/code-review/references/timeout-auth-and-capabilities.md	defaults to 2400 seconds and accepts 5 to 3600	125-r1f1: the entrypoint now points here for the cumulative lane budget instead of restating it; dropping or drifting the default/range would silently strip the bound from both surfaces
 lane-budget-mode-minimums	skills/code-review/references/timeout-auth-and-capabilities.md	21 total seconds for review and 16	125-r1f1: the per-mode fail-closed minimums the entrypoint delegates here; without the pin the fail-closed limit can vanish with no suite failing
 lane-budget-reserved-seconds	skills/code-review/references/timeout-auth-and-capabilities.md	while reserving ten controller	125-r1f1: the reserved controller seconds in the per-invocation division the entrypoint delegates here

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

@@ -1,22 +1,51 @@
 #!/usr/bin/env bash
-# Extraction-owned autonomous review wrapper: one review plus one challenge.
+# Extraction-owned review wrapper: every call is one single-shot pass.
+#
+# A non-wording extraction owes one review and one challenge, plus a delta pass
+# per fixed P0/P1 (references/dual-track-review-gate.md). None of them is bound
+# to another pass or to one candidate hash, so this wrapper fixes the controller
+# options that make a pass single-shot and refuses the options that would open a
+# tracked review chain. The generic controller keeps its chain mode for other
+# callers; this lane does not use it.
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
 CONTROLLER="$SCRIPT_DIR/../../code-review/scripts/review_gate.sh"
 
+fail() {
+  echo "extraction_review_gate_error: $*" >&2
+  exit 2
+}
+
+mode=""
+expect_mode=0
 for arg in "$@"; do
+  if [[ "$expect_mode" == 1 ]]; then
+    mode="$arg"
+    expect_mode=0
+    continue
+  fi
   case "$arg" in
-    --challenge-b*)
-      echo "extraction_review_gate_error: challenge budget is fixed at 1" >&2
-      exit 2
-      ;;
+    --mode) expect_mode=1 ;;
+    --mode=*) mode="${arg#--mode=}" ;;
+    # Prefixes cover the controller's unambiguous abbreviations as well as the
+    # full spellings, so a shortened flag cannot reopen a chain.
+    --challenge-b*|--challenge-i*)
+      fail "the extraction lane fixes the challenge budget and index; do not pass $arg" ;;
+    --review-c*|--au*|--prio*|--pre*|--com*)
+      fail "the extraction lane is single-shot; review-chain option $arg is not accepted" ;;
   esac
 done
 
+case "$mode" in
+  review) fixed=(--challenge-budget 0) ;;
+  challenge) fixed=(--challenge-budget 1 --challenge-index 1) ;;
+  "") fail "pass --mode review or --mode challenge" ;;
+  *) fail "the extraction lane runs only --mode review or --mode challenge, not $mode" ;;
+esac
+
 if [[ ! -x "$CONTROLLER" ]]; then
-  echo "extraction_review_gate_error: code-review controller is unavailable" >&2
-  exit 2
+  fail "code-review controller is unavailable"
 fi
 
-exec bash "$CONTROLLER" --challenge-budget 1 "$@"
+exec bash "$CONTROLLER" "${fixed[@]}" "$@"

package/dist/assets/marketplace/plugins/ccl-skills/skills/skill-extraction-workflow/scripts/register-firing-path-resolution.rb

@@ -83,16 +83,31 @@ unless File.file?(register_path)
   exit 1
 end
 
-# Reviewed waivers cover one immutable historical row whose locator was retired
+# Reviewed waivers cover the immutable historical rows whose locator was retired
 # by an explicit superseding round. The digest table below binds each waiver to
-# that exact row; a new row cannot inherit it by reusing the locator.
+# those exact rows (one digest, or an array when several rows cited the retired
+# locator); a new row cannot inherit it by reusing the locator.
 EXEMPT = {
   "file:skills/product-ui-ux-design/references/external-ui-ux-quality-benchmarks.md#Disabled semantics are real, not painted" =>
     "065 replaced the combined platform walkthrough with an authority-classed claim ledger and executable delivery contract",
   "file:skills/product-ui-ux-design/references/external-ui-ux-quality-benchmarks.md#predictive-back geometry routes to" =>
     "065 moved platform mechanics to the canonical client-owner return while keeping platform guidance scoped",
   "file:skills/product-ui-ux-design/references/external-ui-ux-quality-benchmarks.md#Interaction-state matrix is complete" =>
-    "065 replaced walkthrough-level proof with criterion IDs, test-layer selection, runtime evidence, and a candidate-bound verdict"
+    "065 replaced walkthrough-level proof with criterion IDs, test-layer selection, runtime evidence, and a candidate-bound verdict",
+  "command:skills/skill-extraction-workflow/scripts/test_validate_extraction_review_state.sh" =>
+    "127 retired the closeout ledger and its validator; the extraction lane records single-shot passes instead",
+  "command:skills/skill-extraction-workflow/scripts/test_review_ledger_binding.sh" =>
+    "127 retired the merge-side candidate binding; the post-review delta and the human merge replace it",
+  "command:skills/skill-extraction-workflow/scripts/review_ledger_binding.py" =>
+    "127 retired the merge-side candidate binding; the post-review delta and the human merge replace it",
+  "file:skills/skill-extraction-workflow/references/dual-track-review-gate.md#Sum spent rounds across all chains before opening one more" =>
+    "127 replaced the round budget with one review, one challenge and bounded delta passes",
+  "file:skills/skill-extraction-workflow/references/dual-track-review-gate.md#accumulate every fix unapplied, run the challenge on the frozen" =>
+    "127 lets the challenge run after the review's fixes; nothing is bound to one candidate",
+  "file:skills/skill-extraction-workflow/references/extraction-quickstart.md#still owes the two-round chain before it can land" =>
+    "127 retired the merge-side binding that imposed the chain on wording-only changes",
+  "file:skills/skill-extraction-workflow/references/extraction-quickstart.md#must exclude every evidence JSON the round has already added" =>
+    "127 retired the merge-side binding whose evidence exclusion this rule mirrored"
 }.freeze
 
 # `\p{Word}` rather than `[a-z0-9]`: GitHub keeps non-ASCII characters in a slug,
@@ -471,7 +486,45 @@ EXEMPT_ROW_DIGESTS = {
   "file:skills/product-ui-ux-design/references/external-ui-ux-quality-benchmarks.md#predictive-back geometry routes to" =>
     "6847e68f062c2fe65a32f34bc743a6162a4e245a3a5d858c020faa841868f929",
   "file:skills/product-ui-ux-design/references/external-ui-ux-quality-benchmarks.md#Interaction-state matrix is complete" =>
-    "9671789a4bac36787dc26965ca03c98c7ab1c10de3312c6792587cb34e7c548e"
+    "9671789a4bac36787dc26965ca03c98c7ab1c10de3312c6792587cb34e7c548e",
+  "command:skills/skill-extraction-workflow/scripts/test_validate_extraction_review_state.sh" => [
+    "da20ca2ada11f70a55bbfbffde84a80d0a8a8a46c9e4010a96a9614ca854fd34",
+    "b8eede70a62910f0a7f2d11cfd854537c3450889bc294cfc933b37f2a13c55b8",
+    "1c575fdad17f3fca00569832d487dcf0ac0f28fe5f8fb4bfa21e784d9111a243",
+    "b40a21a554cbc8bb3484c345160403a69f1cfb0b41702559fc2442572f52afce",
+    "0579ef1411fc866c0e612f9475634f073cfc0e0be429482ee9e8b4fd7abafe10"
+  ],
+  "command:skills/skill-extraction-workflow/scripts/test_review_ledger_binding.sh" => [
+    "0579ef1411fc866c0e612f9475634f073cfc0e0be429482ee9e8b4fd7abafe10",
+    "fdb08300002289dc5b3d0bcd279589ec8eca7dd5d3b14f0b7b079d34372b41f7",
+    "4a593029ba36b128519adeb8a3b9cbee32053caec7953c884ad587efaf88a3aa",
+    "f56d544525a45d0b26e8752eec4f2ff516239c3ca866df600506ea3ccb39f4b2",
+    "6f3b518a04ea8c20adc1ec3cf377a7eda2ef775903354cf54bed59268a8332b4",
+    "dfa47eac33add5ce0a7a73ce237b8bf4a1589bd325eb34b4531e25f9adbb574d",
+    "c6e6f74ca2407db2d98124e0517e6d70fae6f9df669f190bb7336ab76f13eb56",
+    "16f862e9df7fea0ea817e392e78e561690b0120f97125c2db5f7c7b987154385",
+    "c450336b8031f4ea9b3a614db3908b1f21c37559098b4e24672947172bb42de4",
+    "aaa569c4934575aae78c2a3901ef44696501ee56d0cb700bfa2559ac79677d6c",
+    "a9a2484c102a9392ffa00edc684b8feddea9ccc6a881d35433c72594e72959c5",
+    "f9cfc29b561d55da7838d371f1307bf015822bdea2961cfb6dd0b6da6232eede",
+    "1e769efadec0325d53de5d0c1023eea675499d9d67b086bcfc4c507ca0f25dac",
+    "749ef2d63c4dda83e3885b7c2dfaedc9f2970dc09ae310082ad5367bc322cebc",
+    "2402bf5b6b7a00aba5e6200c47277bdf6bb65e4d255f8126b8615eb9d1168545",
+    "7f68e4204587602d53d135152d9a0b4fa7e8da1cc0c43f02813debb8c3a99528",
+    "0d7e1a6de3ced156e54b9a50737835f49c424846e86adf28f1b19a1aa46f0f5a",
+    "2c894914dd47b1764c63bd525891246c8adcb14b0f00c446e84e28320451a213",
+    "0ab74921c2222979701499bc12d53c5a0942f51a7b1dd3a090ef58e83cea42f9"
+  ],
+  "command:skills/skill-extraction-workflow/scripts/review_ledger_binding.py" =>
+    "6216104a650a7c30f78d0163d0a7cde37c9d809eb5967f291a30ebd516b1e337",
+  "file:skills/skill-extraction-workflow/references/dual-track-review-gate.md#Sum spent rounds across all chains before opening one more" =>
+    "988cd8128ee6f93b4ea5a0cc8ada170401a1790831b2cd7b95a79642a76f1112",
+  "file:skills/skill-extraction-workflow/references/dual-track-review-gate.md#accumulate every fix unapplied, run the challenge on the frozen" =>
+    "d999fadd8e3778bfdb9d54d34d3cabf965547ed39448a6ffba5e8310ca151612",
+  "file:skills/skill-extraction-workflow/references/extraction-quickstart.md#still owes the two-round chain before it can land" =>
+    "bf1fa382021b079b200b6d8d367e407bd0adbbac1d862e22d78062d83906c05e",
+  "file:skills/skill-extraction-workflow/references/extraction-quickstart.md#must exclude every evidence JSON the round has already added" =>
+    "d762cbab094279d26461843dfe12c5dd28ae41a1e9a40b7ae9f7f806fee51c36"
 }.freeze
 # TRUST BOUNDARY. The count answers "one row"; it cannot answer "WHICH row", so
 # it is paired with the digest of the citing row in EXEMPT_ROW_DIGESTS above.
@@ -535,6 +588,11 @@ File.foreach(register_path).with_index(1) do |line, lineno|
         target = File.join(root, rel)
         if !syntactically_contained?(rel)
           unresolved << [lineno, locator, "path escapes the repository"]
+        elsif !File.file?(target) && anchor_waived
+          # A waived command locator names an executable a superseding round
+          # deliberately retired; its absence is the recorded retirement, and the
+          # digest check below still pins which historical rows may cite it.
+          next
         elsif !File.file?(target)
           unresolved << [lineno, locator, "executable not found"]
         elsif !resolves_inside?(root, rel)
@@ -701,20 +759,29 @@ end
 
 exempt_uses.each do |locator, linenos|
   rows = linenos.uniq.sort
-  if rows.length > EXEMPT_USE_ALLOWANCE
-    rows.drop(EXEMPT_USE_ALLOWANCE).each do |lineno|
+  # A waiver binds either one row (a digest string) or a fixed set of rows (an
+  # array of digests): a retired script or rule that several historical rows
+  # cited is still one retirement, and each of those rows is named by its digest.
+  expected = exempt_row_digests[locator]
+  expected_digests = expected.is_a?(Array) ? expected : [expected].compact
+  # How many rows a waiver covers is a property of the waiver, so it is read from
+  # the built-in table even when a test injects its own identity table.
+  builtin = EXEMPT_ROW_DIGESTS[locator]
+  builtin_rows = builtin.is_a?(Array) ? builtin.length : (builtin ? 1 : 0)
+  allowance = [expected_digests.length, builtin_rows, EXEMPT_USE_ALLOWANCE].max
+  if rows.length > allowance
+    rows.drop(allowance).each do |lineno|
       unresolved << [lineno, locator,
-                     "EXEMPT locator cited by #{rows.length} rows (allowance #{EXEMPT_USE_ALLOWANCE}); " \
-                     "a waiver covers the one unrepairable historical row at line #{rows.first}, " \
+                     "EXEMPT locator cited by #{rows.length} rows (allowance #{allowance}); " \
+                     "a waiver covers the recorded historical rows starting at line #{rows.first}, " \
                      "not a new row quoting the same retired locator"]
     end
     next
   end
-  # The count says "one row"; the digest says WHICH row. Without it, deleting the
-  # historical row and writing a different claim that cites the same locator keeps
-  # the count at 1 and silently inherits the waiver.
-  expected = exempt_row_digests[locator]
-  unless expected
+  # The count says how many rows; the digests say WHICH rows. Without them,
+  # deleting a historical row and writing a different claim that cites the same
+  # locator keeps the count and silently inherits the waiver.
+  if expected_digests.empty?
     # A waiver with no recorded row identity keeps only the use-count layer,
     # which cannot tell a rewritten or repurposed row from the one that was
     # waived. On the BUILT-IN table that is a silent downgrade, so a new EXEMPT
@@ -729,13 +796,28 @@ exempt_uses.each do |locator, linenos|
     end
     next
   end
-  lineno = rows.first
-  actual = Digest::SHA256.hexdigest(register_lines[lineno - 1].to_s.rstrip)
-  next if actual == expected
-  unresolved << [lineno, locator,
-                 "EXEMPT citing row does not match the waived row (digest #{actual[0, 12]} != #{expected[0, 12]}); " \
-                 "a waiver covers one specific unrepairable historical row, so a rewritten or replaced row " \
-                 "does not inherit it — restore the row, or land a new waiver entry with its own digest and reason"]
+  remaining = expected_digests.tally
+  mismatched = 0
+  rows.each do |lineno|
+    actual = Digest::SHA256.hexdigest(register_lines[lineno - 1].to_s.rstrip)
+    if remaining[actual].to_i.positive?
+      remaining[actual] -= 1
+      next
+    end
+    mismatched += 1
+    unresolved << [lineno, locator,
+                   "EXEMPT citing row does not match the waived row (digest #{actual[0, 12]} not recorded); " \
+                   "a waiver covers specific unrepairable historical rows, so a rewritten or replaced row " \
+                   "does not inherit it — restore the row, or land a new waiver entry with its own digest and reason"]
+  end
+  # A rewritten row is already reported above; only rows that are gone entirely
+  # are left to name here.
+  missing = remaining.values.sum - mismatched
+  next unless missing.positive?
+  unresolved << [rows.first, locator,
+                 "EXEMPT entry has no citing row in the ledger for #{missing} of its #{expected_digests.length} " \
+                 "recorded rows; a waived historical row was deleted or its locator was edited — restore the row, " \
+                 "or retire its digest in the same change"]
 end
 
 # Both groups print before exiting. Bailing out on `malformed` alone would hide

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

@@ -736,7 +736,8 @@ DUAL_TRACK_REF="$REPO_ROOT/skills/skill-extraction-workflow/references/dual-trac
 LEDGER_REF="$REPO_ROOT/skills/skill-extraction-workflow/references/source-register.md"
 WALK_REF="$REPO_ROOT/skills/testing-strategy/references/run-killing-mutation-walk.md"
 DT_SELF_AUDIT_SECTION='### The self-adversary enumeration — method detail (relocated from `SKILL.md`)'
-DT_AUTHORITY_SECTION='### Findings, autonomous budget, and human authority'
+DT_AUTHORITY_SECTION='### Findings and dispositions'
+DT_LANE_SECTION='### The extraction review lane: one review, one challenge'
 TS_CORE_RULES_SECTION='## Core Rules'
 WALK_PROBE_SECTION='## Encoded Probe For Destructive Artifacts'
 LEDGER_RULE_PARAGRAPH='Round-consolidation rule (append-once)'
@@ -749,8 +750,8 @@ assert_in_section "$DUAL_TRACK_REF" "$DT_SELF_AUDIT_SECTION" '**Re-owe after fix
   "process controls (re-owe rule anchored in the self-audit section)"
 assert_in_section "$DUAL_TRACK_REF" "$DT_AUTHORITY_SECTION" 'A convergence or closure declaration must be written falsifiably.' \
   "process controls (falsifiable closure declaration anchored in the authority section)"
-assert_in_section "$DUAL_TRACK_REF" "$DT_AUTHORITY_SECTION" '`continuation_authorization`' \
-  "process controls (continuation authorization anchored in the authority section)"
+assert_in_section "$DUAL_TRACK_REF" "$DT_LANE_SECTION" '**Task authority.**' \
+  "process controls (task authority anchored in the extraction review lane)"
 # Remediation re-owes the pre-cover axes; third same-class round escalates to one full-matrix self-enumeration.
 assert_same_line "$DUAL_TRACK_REF" 'remediation text written mid-round re-owes the draft-time axes BEFORE the candidate goes back to the reviewer' \
   '**Re-owe after fixes.**' \
@@ -768,7 +769,7 @@ assert_same_line "$DUAL_TRACK_REF" 'states × failure points × orderings × res
   '**Re-owe after fixes.**' \
   "process controls (full-matrix axes named)"
 # Convergence/closure declarations are falsifiable: named candidate/evidence/axes/open items, scoped adjectives.
-assert_same_line "$DUAL_TRACK_REF" 'Name the exact candidate identity it covers' \
+assert_same_line "$DUAL_TRACK_REF" 'Name the commit it covers' \
   'must be written falsifiably' \
   "process controls (declaration names the candidate identity)"
 assert_same_line "$DUAL_TRACK_REF" "each lane's terminal evidence, the axes/dimensions the closing self-audit actually crossed, and every standing open item by name" \
@@ -780,29 +781,17 @@ assert_same_line "$DUAL_TRACK_REF" 'cannot be checked false and is inconclusive'
 assert_same_line "$DUAL_TRACK_REF" 'any "full X" adjective is scoped to the named axes, never wider' \
   'must be written falsifiably' \
   "process controls (full-adjective scoped to named axes)"
-# Default continuation retains original authority and accumulated evidence.
-assert_same_line "$DUAL_TRACK_REF" 'necessary in-scope fixes, tests and review are already authorized by default' \
-  '`continuation_authorization`' "process controls (necessary review inherits task authority)"
-assert_same_line "$DUAL_TRACK_REF" 'continuation_basis=existing-task-scope' \
-  '`continuation_authorization`' "process controls (inherited continuation has an explicit basis)"
-assert_same_line "$DUAL_TRACK_REF" 'the original authorization reference and scope' \
-  '`continuation_authorization`' "process controls (original authority remains traceable)"
-assert_same_line "$DUAL_TRACK_REF" 'changed method or added evidence, cumulative rounds' \
-  '`continuation_authorization`' "process controls (checkpoint requires method and spending evidence)"
-assert_same_line "$DUAL_TRACK_REF" "links between the old sequence's terminal evidence and the new sequence" \
-  '`continuation_authorization`' "process controls (successive sequences retain their links)"
-assert_same_line "$DUAL_TRACK_REF" 'fresh current-candidate bindings and preserves every prior receipt, focus, finding and disposition' \
-  '`continuation_authorization`' "process controls (fresh binding does not discard history)"
-assert_same_line "$DUAL_TRACK_REF" 'The existing per-sequence format, timeout and validation bounds remain unchanged' \
-  '`continuation_authorization`' "process controls (bounded invocation format remains enforced)"
-assert_same_line "$DUAL_TRACK_REF" 'never relabel these calls as newly human-requested or erase earlier spending' \
-  '`continuation_authorization`' "process controls (no fabricated human request or count reset)"
-assert_same_line "$DUAL_TRACK_REF" 'Ask only for scope or authority the original task lacks, an explicit user limit' \
-  '`continuation_authorization`' "process controls (real missing authority and user limits remain blocking)"
-assert_same_line "$DUAL_TRACK_REF" 'Continuation waives no review, test or evidence obligation and grants no merge, publication or risk-acceptance authority' \
-  '`continuation_authorization`' "process controls (continuation is not a waiver or landing authority)"
-assert_same_line "$DUAL_TRACK_REF" 'Never infer a lane waiver from silence or from authorization to continue' \
-  '`continuation_authorization`' "process controls (no inferred lane waiver)"
+# Task authority: necessary passes are inherited, never relabelled, never a waiver or merge grant.
+assert_same_line "$DUAL_TRACK_REF" 'necessary in-scope fixes, tests and review passes by default' \
+  '**Task authority.**' "process controls (necessary review inherits task authority)"
+assert_same_line "$DUAL_TRACK_REF" 'never relabels an Agent-run pass as newly human-requested' \
+  '**Task authority.**' "process controls (no fabricated human request)"
+assert_same_line "$DUAL_TRACK_REF" 'never infers a lane waiver from silence or from authorization to continue' \
+  '**Task authority.**' "process controls (no inferred lane waiver)"
+assert_same_line "$DUAL_TRACK_REF" 'Ask only for scope or authority the original task lacks, or when an explicit user limit' \
+  '**Task authority.**' "process controls (real missing authority and user limits remain blocking)"
+assert_same_line "$DUAL_TRACK_REF" 'waives no review, test or evidence obligation and grants no merge, publication or risk-acceptance authority' \
+  '**Task authority.**' "process controls (passes are not a waiver or landing authority)"
 assert_contains "$PRODUCT_SKILL" 'Necessary fixes, tests and review inherit task authorization' \
   "process controls (implementation entry reaches inherited authority)"
 assert_contains "$PRE_FINAL_REF" 'continuation_basis=existing-task-scope' \

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

@@ -18,7 +18,7 @@
 #   - test_generic_r0_leak_scan.sh
 #   - test_shared_git_surface_gate.sh
 #   - test_extraction_review_gate.sh
-#   - test_validate_extraction_review_state.sh
+#   - test_check_review_evidence_present.sh
 #   - test_check_ccl_route_drift.sh
 #   - test_check_sync_pointers.sh
 #   - test_check_ccl_register_pending_exclusion.sh
@@ -122,10 +122,8 @@ fast_tests=(
   test_generic_r0_leak_scan.sh
   test_shared_git_surface_gate.sh
   test_extraction_review_gate.sh
-  test_validate_extraction_review_state.sh
-  # Merge-side binding between the landing candidate and the review evidence that
-  # inspected it: own throwaway git repo, no clone, seconds.
-  test_review_ledger_binding.sh
+  # Review-evidence presence gate: own throwaway git repo, seconds.
+  test_check_review_evidence_present.sh
   # Candidate-SHA-bound gate receipts (mint/verify): own throwaway git repo,
   # no clone, seconds — belongs in the lane every run exercises.
   test_gate_receipt.sh

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

@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+# Regression for check_review_evidence_present.py: a pull request that changes
+# skills/ or hooks/ must carry at least one conclusive review result; everything
+# else passes untouched. Own throwaway git repo.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+GATE="$SCRIPT_DIR/check_review_evidence_present.py"
+TMP="$(mktemp -d "${TMPDIR:-/tmp}/review-evidence.XXXXXX")"
+trap 'rm -rf "$TMP"' EXIT
+
+pass=0
+fail() { echo "FAIL: $*" >&2; exit 1; }
+ok() { pass=$((pass + 1)); echo "ok   - $1"; }
+
+REPO="$TMP/repo"
+git init -q "$REPO"
+git -C "$REPO" config user.email test@example.invalid
+git -C "$REPO" config user.name "Test User"
+mkdir -p "$REPO/skills/demo" "$REPO/docs"
+printf -- '---\nname: demo\ndescription: demo skill\n---\n\n# demo\n\nKeep the rule, always.\n' > "$REPO/skills/demo/SKILL.md"
+echo "# doc" > "$REPO/docs/a.md"
+git -C "$REPO" add -A && git -C "$REPO" commit -qm base
+BASE="$(git -C "$REPO" rev-parse HEAD)"
+
+result() { # result <path> <mode> <status>
+  mkdir -p "$(dirname "$REPO/$1")"
+  printf '{"schema_version":3,"mode":"%s","status":"%s","selected_client":"codex"}\n' \
+    "$2" "$3" > "$REPO/$1"
+}
+
+# case <label> <expected rc> <expected token> <setup...>: reset to base, apply setup, commit, run.
+run_case() {
+  local label="$1" want_rc="$2" want="$3"; shift 3
+  git -C "$REPO" checkout -q --detach "$BASE"
+  git -C "$REPO" clean -qfdx
+  "$@"
+  git -C "$REPO" add -A
+  git -C "$REPO" commit -qm case --allow-empty
+  set +e
+  out="$(python3 "$GATE" --repo-root "$REPO" --base "$BASE" 2>&1)"
+  rc=$?
+  set -e
+  [ "$rc" = "$want_rc" ] || fail "$label: expected rc=$want_rc got rc=$rc: $out"
+  case "$out" in *"$want"*) : ;; *) fail "$label: expected '$want': $out" ;; esac
+  ok "$label"
+}
+
+docs_only() { echo "more" >> "$REPO/docs/a.md"; }
+skill_change() { echo "rule" >> "$REPO/skills/demo/SKILL.md"; }
+hook_change() { mkdir -p "$REPO/hooks"; echo "#!/bin/sh" > "$REPO/hooks/h.sh"; }
+both_passes() { result specs/r1/evidence/round1-review.json review findings; result specs/r1/evidence/round2-challenge.json challenge passed; }
+
+run_case "no skills or hooks change needs nothing" 0 review_evidence_not_required docs_only
+run_case "skill change with no evidence is refused" 1 "no conclusive review result" skill_change
+run_case "hook change with no evidence is refused" 1 review_evidence_missing hook_change
+run_case "review plus challenge passes" 0 "review_evidence_present_ok: 1 review, 1 challenge" \
+  bash -c "$(declare -f result skill_change both_passes); REPO='$REPO'; skill_change; both_passes"
+run_case "a file replaced by a symlink still needs evidence" 1 review_evidence_missing \
+  bash -c "rm '$REPO/skills/demo/SKILL.md'; ln -s ../../docs/a.md '$REPO/skills/demo/SKILL.md'"
+run_case "a review alone is enough for the gate" 0 "review_evidence_present_ok: 1 review, 0 challenge" \
+  bash -c "$(declare -f result skill_change); REPO='$REPO'; skill_change; result specs/r1/evidence/round1-review.json review passed"
+run_case "a challenge alone does not satisfy the gate" 1 review_evidence_missing \
+  bash -c "$(declare -f result skill_change); REPO='$REPO'; skill_change; result specs/r1/evidence/round2-challenge.json challenge passed"
+run_case "an inconclusive result does not count" 1 review_evidence_missing \
+  bash -c "$(declare -f result skill_change); REPO='$REPO'; skill_change; result specs/r1/evidence/round1-review.json review inconclusive"
+run_case "a result outside an evidence directory does not count" 1 review_evidence_missing \
+  bash -c "$(declare -f result skill_change); REPO='$REPO'; skill_change; result specs/r1/round1-review.json review passed; result specs/r1/round2-challenge.json challenge passed"
+run_case "malformed JSON does not count" 1 review_evidence_missing \
+  bash -c "mkdir -p '$REPO/specs/r1/evidence'; echo 'not json' > '$REPO/specs/r1/evidence/round1-review.json'; echo rule >> '$REPO/skills/demo/SKILL.md'"
+
+set +e
+out="$(python3 "$GATE" --repo-root "$REPO" --base does-not-exist 2>&1)"
+rc=$?
+set -e
+[ "$rc" = 2 ] || fail "an unresolvable base must be unevaluated (rc=2), got rc=$rc"
+case "$out" in *review_evidence_unevaluated*) : ;; *) fail "unresolvable base reason: $out" ;; esac
+ok "an unresolvable base is unevaluated, never a pass"
+
+[ "$pass" = 11 ] || fail "expected 11 assertions, saw $pass"
+echo "test_check_review_evidence_present_ok ($pass assertions)"