@ccoalm/ccl-skills 0.10.0 → 0.12.0

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

@@ -194,6 +194,86 @@ run_gate
 assert_not_contains "impact_chain_firing_path_missing" "$out" "a changed shebang owner executable should satisfy the firing-path gate"
 assert_rc "$rc" 0 "a complete RED row with a changed owner executable must pass"
 
+# Non-ASCII anchors must be accepted, and the proof must be DIFFERENTIAL rather
+# than one literal passing: a special-cased implementation, or one that handles
+# Han but not a combining mark, would satisfy a single-literal leg. Each row below
+# pairs a non-ASCII anchor with an ASCII anchor matched on everything the gate
+# actually predicates on - uniqueness, the 16-character bar, list-line shape, a
+# whitelisted normative verb - so the two verdicts must agree. This exists because
+# a round concluded from reading the wrong lambda (`raw_blob_at` forces binary;
+# `locator_valid` resolves through `blob_at`, which does not) that a non-ASCII
+# anchor could never validate, and recorded a defect that was not there.
+#
+# Representations covered: Han; a precomposed Latin letter (NFC, two bytes); the
+# same letter decomposed into base + combining mark (NFD, so the anchor carries a
+# codepoint that is not a character on its own).
+anchor_pair_case() {
+  # $1 = case label, $2 = non-ASCII anchor, $3 = ASCII anchor of the same shape
+  local label="$1" nonascii="$2" ascii="$3" verdict_nonascii verdict_ascii
+  new_case "case-ref-anchor-pair-$label-nonascii"
+  printf '\n- %s\n' "$nonascii" >> "$REPO/$UPSTREAM_REF"
+  printf '| Fixture anchor pair %s non-ASCII | `downstream-executor` | behavioral-evidence: RED-baseline; observed-failure: yes; result-class: failure; bank-evidence: downscoped:REFSCRIPTS-FIXTURE-NO-BANK; firing-path: file:skills/product-rd-workflow/references/adr-convention.md#%s | `updated` | `product-rd-workflow/SKILL.md` reference edit |\n' "$label" "$nonascii" >> "$REGISTER"
+  routing_surface_downscope
+  commit_case "anchor pair $label non-ASCII"
+  run_gate
+  verdict_nonascii="$rc"
+
+  new_case "case-ref-anchor-pair-$label-ascii"
+  printf '\n- %s\n' "$ascii" >> "$REPO/$UPSTREAM_REF"
+  printf '| Fixture anchor pair %s ASCII | `downstream-executor` | behavioral-evidence: RED-baseline; observed-failure: yes; result-class: failure; bank-evidence: downscoped:REFSCRIPTS-FIXTURE-NO-BANK; firing-path: file:skills/product-rd-workflow/references/adr-convention.md#%s | `updated` | `product-rd-workflow/SKILL.md` reference edit |\n' "$label" "$ascii" >> "$REGISTER"
+  routing_surface_downscope
+  commit_case "anchor pair $label ASCII"
+  run_gate
+  verdict_ascii="$rc"
+
+  assert_rc "$verdict_ascii" 0 "the ASCII control of pair $label must be accepted"
+  assert_rc "$verdict_nonascii" "$verdict_ascii" "pair $label: the non-ASCII anchor must get the same verdict as its ASCII control"
+}
+
+anchor_pair_case han \
+  '下游执行者必须在收到该契约变更时同步更新其验证面。' \
+  'The downstream executor must refresh its verification surface on this change.'
+# Same sentence and the same whitelisted verb in both arms; only the accented
+# codepoint differs, so a verdict difference can only come from byte composition.
+anchor_pair_case nfc \
+  'The owner must refresh its vérification surface on this change.' \
+  'The owner must refresh its verification surface on this change.'
+anchor_pair_case nfd \
+  'The owner must refresh its vérification surface on that change.' \
+  'The owner must refresh its verification surface on that change.'
+
+# When one owner carries several RED rows, the owner-level check reddens the whole
+# package for a single bad row — so the diagnostic must name WHICH row failed.
+# Without it the author inspects the row they just wrote (usually the correct one)
+# while an unrelated row is the offender; that cost one round three iterations.
+new_case case-ref-firing-path-names-offending-row
+printf '\n- 下游执行者必须在收到该契约变更时同步更新其验证面。\n' >> "$REPO/$UPSTREAM_REF"
+printf '| Fixture good row beside a bad one | `downstream-executor` | behavioral-evidence: RED-baseline; observed-failure: yes; result-class: failure; bank-evidence: downscoped:REFSCRIPTS-FIXTURE-NO-BANK; firing-path: file:skills/product-rd-workflow/references/adr-convention.md#下游执行者必须在收到该契约变更时同步更新其验证面 | `updated` | `product-rd-workflow/SKILL.md` reference edit |\n' >> "$REGISTER"
+printf '| Fixture offending row with an unresolvable anchor | `downstream-executor` | behavioral-evidence: RED-baseline; observed-failure: yes; result-class: failure; bank-evidence: downscoped:REFSCRIPTS-FIXTURE-NO-BANK; firing-path: file:skills/product-rd-workflow/references/adr-convention.md#this anchor text was never added by this round | `updated` | `product-rd-workflow/SKILL.md` reference edit |\n' >> "$REGISTER"
+routing_surface_downscope
+commit_case "one good row beside one unresolvable row"
+run_gate
+assert_rc "$rc" 1 "an unresolvable anchor on any bound RED row must fail the owner"
+assert_contains "impact_chain_firing_path_missing" "$out" "checker should report the firing-path verdict"
+assert_contains "Fixture offending row with an unresolvable anchor" "$out" "the diagnostic must name the offending row"
+assert_not_contains "offending row: Fixture good row beside a bad one" "$out" "the diagnostic must not name a row whose anchor resolves"
+
+# The offending-row line renders repository text a contributor controls onto a
+# terminal/CI channel. Control and invisible characters must be escaped, not merely
+# truncated: raw ANSI or carriage-return bytes can erase or restyle surrounding
+# output, and bidi overrides can reorder it, so a reader sees a diagnostic that does
+# not match what the gate decided. Both reviewer lanes raised this independently.
+new_case case-ref-offending-row-escapes-control-bytes
+printf '\n- 下游执行者必须在收到该契约变更时同步更新其验证面。\n' >> "$REPO/$UPSTREAM_REF"
+printf '| Fixture control-byte row \033[31m\rSPOOFED\u202E | `downstream-executor` | behavioral-evidence: RED-baseline; observed-failure: yes; result-class: failure; bank-evidence: downscoped:REFSCRIPTS-FIXTURE-NO-BANK; firing-path: file:skills/product-rd-workflow/references/adr-convention.md#this anchor text was never added by this round | `updated` | `product-rd-workflow/SKILL.md` reference edit |\n' >> "$REGISTER"
+routing_surface_downscope
+commit_case "offending row carrying control bytes"
+run_gate
+assert_rc "$rc" 1 "an unresolvable anchor must still fail with a control-byte row"
+assert_contains "\\u001B" "$out" "the diagnostic must escape an ANSI introducer rather than emit it"
+assert_contains "\\u000D" "$out" "the diagnostic must escape a carriage return rather than emit it"
+assert_contains "\\u202E" "$out" "the diagnostic must escape a bidi override rather than emit it"
+
 # A malformed impact-chain-looking row (wrong cell count) is warned but stays
 # advisory: hard-blocking would false-positive on the register's many other
 # legitimate table shapes, and deliberate mangling is outside the trust model
@@ -1329,6 +1409,6 @@ assert_rc "$rc" 1 "a directory masquerading as SKILL.md must not read as a prese
 assert_contains "platform-observability/SKILL.md" "$out" "the masqueraded owner must be named"
 
 assert_rc "$full_check_runs" 1 "fixture suite must retain exactly one full checker wiring case"
-assert_rc "$gate_runs" 80 "all remaining impact-chain fixtures must run the standalone gate"
+assert_rc "$gate_runs" 88 "all remaining impact-chain fixtures must run the standalone gate"
 
 echo "test_check_ccl_impact_chain_refscripts: ok"

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

@@ -114,6 +114,9 @@ fast_tests=(
   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
   # 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_review_ledger_binding.sh

@@ -0,0 +1,521 @@
+#!/usr/bin/env bash
+# Regression for the merge-side binding between the landing candidate and the
+# review evidence that inspected it.
+set -uo pipefail
+
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
+GATE="$DIR/review_ledger_binding.py"
+CONTROLLER="$DIR/../../code-review/scripts/review_gate.py"
+WORK="$(mktemp -d "${TMPDIR:-/tmp}/review-ledger-binding.XXXXXX")"
+trap 'rm -rf "$WORK"' EXIT
+
+fails=0
+check() { if eval "$2"; then echo "ok   - $1"; else echo "FAIL - $1"; fails=$((fails+1)); fi; }
+
+[ -f "$GATE" ] || { echo "FAIL: gate missing: $GATE" >&2; exit 1; }
+[ -f "$CONTROLLER" ] || { echo "FAIL: controller missing: $CONTROLLER" >&2; exit 1; }
+
+REPO="$WORK/repo"
+mkdir -p "$REPO/skills/code-review/scripts" "$REPO/skills/skill-extraction-workflow/scripts" "$REPO/specs/round/evidence"
+cp "$CONTROLLER" "$REPO/skills/code-review/scripts/review_gate.py"
+# The gate delegates ledger acceptance to the validator; these stubs isolate the
+# gate's own contract (recompute the packet, bind it, delegate) from the
+# validator's fixture surface, which its own suite already covers.
+cat >"$REPO/skills/skill-extraction-workflow/scripts/validate_extraction_review_state.py" <<'PY'
+import sys
+print("extraction_review_state_ok: stub accepted")
+sys.exit(0)
+PY
+cat >"$WORK/reject-validator.py" <<'PY'
+import sys
+print("extraction_review_state_invalid: stub rejected")
+sys.exit(1)
+PY
+
+git -C "$REPO" init -q .
+git -C "$REPO" config user.email t@example.invalid
+git -C "$REPO" config user.name tester
+printf 'baseline\n' >"$REPO/skills/skill-extraction-workflow/SKILL.md"
+git -C "$REPO" add -A
+git -C "$REPO" commit -qm baseline
+BASE="$(git -C "$REPO" rev-parse HEAD)"
+
+run_gate() { python3 "$GATE" --repo-root "$REPO" "$@" 2>&1; }
+
+out="$(run_gate --base "$BASE")"; rc=$?
+check "an unchanged reviewed path needs no review evidence" \
+  '[ "$rc" = 0 ] && case "$out" in *"no reviewed-path change"*) true;; *) false;; esac'
+
+out="$(CCL_SKILL_BASE_REF= run_gate)"; rc=$?
+check "a missing base ref fails closed instead of recording a passing check" \
+  '[ "$rc" = 2 ] && case "$out" in *"nothing was checked"*) true;; *) false;; esac'
+
+out="$(CCL_SKILL_BASE_REF= run_gate --allow-unevaluated)"; rc=$?
+check "an event with genuinely no base must say so out loud to exit clean" \
+  '[ "$rc" = 0 ] && case "$out" in *"nothing was checked"*) true;; *) false;; esac'
+
+out="$(CCL_SKILL_BASE_REF="$BASE" run_gate)"; rc=$?
+check "the gate reads the base from the environment variable its diagnostic names" \
+  '[ "$rc" = 0 ] && case "$out" in *"no reviewed-path change"*) true;; *) false;; esac'
+
+# The fix batch lands under the reviewed paths.
+printf 'baseline\nlanded change\n' >"$REPO/skills/skill-extraction-workflow/SKILL.md"
+git -C "$REPO" add -A
+git -C "$REPO" commit -qm "landing change"
+
+out="$(run_gate --base "$BASE")"; rc=$?
+check "a reviewed-path change with no evidence fails closed" \
+  '[ "$rc" = 1 ] && case "$out" in *"no accepted review evidence binds the landing candidate"*) true;; *) false;; esac'
+EXPECTED="$(run_gate --base "$BASE" --print-candidate)"
+check "the gate can name the candidate hash the evidence must carry" \
+  '[ -n "$EXPECTED" ] && case "$out" in *"$EXPECTED"*) true;; *) false;; esac'
+
+# Evidence for a different candidate must not satisfy the gate: this is the exact
+# shape the gate exists to catch -- a chain that closed out on the pre-fix tree.
+python3 - "$REPO/specs/round/evidence/stale-closeout.json"  <<'JSONGEN'
+import json, sys
+from pathlib import Path
+Path(sys.argv[1]).write_text(json.dumps({"schema_version": 3, "closeout_state": "ready_for_human_decision", "controller_receipts": [], "candidate_sha256": "0" * 64}))
+JSONGEN
+git -C "$REPO" add -A && git -C "$REPO" commit -qm "stale evidence"
+out="$(run_gate --base "$BASE")"; rc=$?
+check "a ledger bound to another candidate does not satisfy the gate" \
+  '[ "$rc" = 1 ] && case "$out" in *"no accepted review evidence"*) true;; *) false;; esac'
+
+# Committing evidence must not move the candidate: evidence lives outside the
+# reviewed paths, which is what lets a ledger record the tree that carries it.
+EXPECTED_AFTER="$(run_gate --base "$BASE" --print-candidate)"
+check "committing evidence outside the reviewed paths leaves the candidate unmoved" \
+  '[ "$EXPECTED_AFTER" = "$EXPECTED" ]'
+
+# A ledger that binds the landing candidate but fails validation is reported as a
+# rejected ledger, never silently ignored. Swapping the validator edits a reviewed
+# path, so the candidate moves and the ledger is written against the moved hash.
+cp "$WORK/reject-validator.py" "$REPO/skills/skill-extraction-workflow/scripts/validate_extraction_review_state.py"
+git -C "$REPO" add -A && git -C "$REPO" commit -qm "rejecting validator"
+REJECT_CANDIDATE="$(run_gate --base "$BASE" --print-candidate)"
+check "editing a reviewed path moves the candidate the evidence must bind" \
+  '[ -n "$REJECT_CANDIDATE" ] && [ "$REJECT_CANDIDATE" != "$EXPECTED" ]'
+python3 - "$REPO/specs/round/evidence/closeout.json" "$REJECT_CANDIDATE" <<'JSONGEN'
+import json, sys
+from pathlib import Path
+Path(sys.argv[1]).write_text(json.dumps({"schema_version": 3, "closeout_state": "ready_for_human_decision", "controller_receipts": [], "candidate_sha256": sys.argv[2]}))
+JSONGEN
+git -C "$REPO" add -A && git -C "$REPO" commit -qm "rejected ledger"
+out="$(run_gate --base "$BASE")"; rc=$?
+check "a bound but invalid ledger is reported as rejected, not ignored" \
+  '[ "$rc" = 1 ] && case "$out" in *"rejected ledger"*"stub rejected"*) true;; *) false;; esac'
+
+cat >"$REPO/skills/skill-extraction-workflow/scripts/validate_extraction_review_state.py" <<'ACCEPTSTUB'
+import sys
+print("extraction_review_state_ok: stub accepted")
+sys.exit(0)
+ACCEPTSTUB
+git -C "$REPO" add -A && git -C "$REPO" commit -qm "accepting validator"
+ACCEPT_CANDIDATE="$(run_gate --base "$BASE" --print-candidate)"
+python3 - "$REPO/specs/round/evidence/closeout.json" "$ACCEPT_CANDIDATE" <<'JSONGEN'
+import json, sys
+from pathlib import Path
+Path(sys.argv[1]).write_text(json.dumps({"schema_version": 3, "closeout_state": "ready_for_human_decision", "controller_receipts": [], "candidate_sha256": sys.argv[2]}))
+JSONGEN
+git -C "$REPO" add -A && git -C "$REPO" commit -qm "accepted ledger"
+out="$(run_gate --base "$BASE")"; rc=$?
+check "a validated ledger bound to the landing candidate passes the gate" \
+  '[ "$rc" = 0 ] && case "$out" in *"binds the landing candidate"*) true;; *) false;; esac'
+
+# The wording-only lane records a single review receipt rather than a ledger.
+rm "$REPO/specs/round/evidence/closeout.json"
+python3 - "$REPO/specs/round/evidence/wording-review.json" "$ACCEPT_CANDIDATE" <<'JSONGEN'
+import json, sys
+from pathlib import Path
+Path(sys.argv[1]).write_text(json.dumps({"schema_version": 3, "mode": "review", "candidate_sha256": sys.argv[2], "wording_only_proof_sha256": "b" * 64}))
+JSONGEN
+git -C "$REPO" add -A && git -C "$REPO" commit -qm "wording-only proof"
+out="$(run_gate --base "$BASE")"; rc=$?
+check "a hand-writable receipt-shaped file never satisfies the gate" \
+  '[ "$rc" = 1 ] && case "$out" in *"no accepted review evidence"*) true;; *) false;; esac'
+
+# Precision: a wording-only receipt for a different candidate must not pass.
+python3 - "$REPO/specs/round/evidence/wording-review.json" <<'PY'
+import json, sys
+from pathlib import Path
+Path(sys.argv[1]).write_text(json.dumps({
+    "schema_version": 3,
+    "mode": "review",
+    "candidate_sha256": "1" * 64,
+    "wording_only_proof_sha256": "b" * 64,
+}))
+PY
+git -C "$REPO" add -A && git -C "$REPO" commit -qm "stale wording-only proof"
+out="$(run_gate --base "$BASE")"; rc=$?
+check "a receipt-shaped file for another candidate does not satisfy the gate" \
+  '[ "$rc" = 1 ] && case "$out" in *"no accepted review evidence"*) true;; *) false;; esac'
+
+# An option-shaped base must not reach git as an option: git diff with no revision
+# compares the index to the working tree, which in a clean checkout reports no
+# paths and would let the gate pass having compared nothing.
+# The environment path is the one that reaches git without an argument parser in
+# front of it, which is exactly how such a base arrives in CI.
+for bad_base in --quiet --name-only refs/heads/does-not-exist; do
+  out="$(CCL_SKILL_BASE_REF="$bad_base" run_gate)"; rc=$?
+  check "an unresolvable base ($bad_base) is refused, not silently treated as no change" \
+    '[ "$rc" = 1 ] && case "$out" in *"does not resolve to a commit"*) true;; *) false;; esac'
+done
+
+out="$(run_gate --base "$BASE^{commit}")"; rc=$?
+check "a revision expression that does resolve is still accepted" \
+  '[ "$rc" = 1 ] && case "$out" in *"no accepted review evidence"*) true;; *) false;; esac'
+
+# The gate must not perturb the tree it hashes; asserting only that a hash comes
+# back would stay green if bytecode writes or packet cleanup regressed.
+before_state="$(git -C "$REPO" status --porcelain --ignored)"
+run_gate --base "$BASE" --print-candidate >/dev/null 2>&1
+after_state="$(git -C "$REPO" status --porcelain --ignored)"
+check "running the gate leaves the hashed tree byte-identical" \
+  '[ "$before_state" = "$after_state" ]'
+
+# What merges is the committed tree, so uncommitted evidence is not evidence about
+# the landing candidate: reading it would accept a ledger nobody can find later.
+printf '{"unfinished": true}\n' >"$REPO/specs/round/evidence/uncommitted.json"
+out="$(run_gate --base "$BASE")"; rc=$?
+check "an uncommitted evidence tree is refused rather than read from disk" \
+  '[ "$rc" = 1 ] && case "$out" in *"uncommitted changes"*) true;; *) false;; esac'
+rm "$REPO/specs/round/evidence/uncommitted.json"
+
+# An unrelated advance on the base branch must not restate what this branch is:
+# measured against the tip it would, and evidence that is still correct would go
+# stale every time somebody else merged.
+BEFORE_ADVANCE="$(run_gate --base "$BASE" --print-candidate)"
+git -C "$REPO" checkout -q -b other-work "$BASE"
+printf 'unrelated\n' >"$REPO/skills/code-review/UNRELATED.md"
+git -C "$REPO" add -A && git -C "$REPO" commit -qm "unrelated work on the base branch"
+ADVANCED="$(git -C "$REPO" rev-parse HEAD)"
+git -C "$REPO" checkout -q -
+AFTER_ADVANCE="$(run_gate --base "$ADVANCED" --print-candidate)"
+check "an unrelated advance on the base branch leaves the candidate unchanged" \
+  '[ -n "$BEFORE_ADVANCE" ] && [ "$AFTER_ADVANCE" = "$BEFORE_ADVANCE" ]'
+
+# Scope: which paths the candidate is computed over. A whitelist of the paths the
+# round happened to review leaves every other tracked path unbound, so a pull
+# request can carry a ledger valid for its skill changes while also landing a root
+# build script nobody reviewed -- the extra content does not move the candidate, so
+# the existing ledger still passes. The bound set is therefore every tracked path
+# except the evidence tree, which must stay outside it: evidence that moved the
+# candidate it records could never be committed.
+SCOPE="$WORK/scope-repo"
+mkdir -p "$SCOPE/skills/code-review/scripts" "$SCOPE/skills/skill-extraction-workflow/scripts" "$SCOPE/specs/round/evidence" "$SCOPE/scripts"
+cp "$CONTROLLER" "$SCOPE/skills/code-review/scripts/review_gate.py"
+cat >"$SCOPE/skills/skill-extraction-workflow/scripts/validate_extraction_review_state.py" <<'PY'
+import sys
+print("extraction_review_state_ok: stub accepted")
+sys.exit(0)
+PY
+git -C "$SCOPE" init -q .
+git -C "$SCOPE" config user.email t@example.invalid
+git -C "$SCOPE" config user.name tester
+printf 'baseline\n' >"$SCOPE/skills/skill-extraction-workflow/SKILL.md"
+printf 'test:\n\t@echo baseline\n' >"$SCOPE/Makefile"
+printf 'baseline\n' >"$SCOPE/README.md"
+printf 'baseline\n' >"$SCOPE/scripts/release.sh"
+# Committed review history for the earlier round: a plan and a receipt that already
+# exist at the base. These are what a later pull request must not be able to rewrite
+# unnoticed.
+printf 'earlier round plan\n' >"$SCOPE/specs/round/plan.md"
+printf '{"schema_version": 3, "closeout_state": "ready_for_human_decision"}\n' \
+  >"$SCOPE/specs/round/evidence/history.json"
+git -C "$SCOPE" add -A
+git -C "$SCOPE" commit -qm baseline
+SCOPE_BASE="$(git -C "$SCOPE" rev-parse HEAD)"
+
+run_scope() { python3 "$GATE" --repo-root "$SCOPE" "$@" 2>&1; }
+
+# Each of these is an executable or consumer-facing tracked path outside the
+# reviewed-skill tree. Landing one with no evidence is the failure the whitelist
+# admitted: before the bound set was inverted every one of them reported
+# "no reviewed-path change" and merged unreviewed.
+for unbound in Makefile README.md scripts/release.sh; do
+  git -C "$SCOPE" checkout -q -B "probe" "$SCOPE_BASE"
+  printf 'landed unreviewed\n' >>"$SCOPE/$unbound"
+  git -C "$SCOPE" add -A && git -C "$SCOPE" commit -qm "land $unbound with no evidence"
+  out="$(run_scope --base "$SCOPE_BASE")"; rc=$?
+  check "a change to $unbound alone needs review evidence like any other tracked path" \
+    '[ "$rc" = 1 ] && case "$out" in *"no accepted review evidence binds the landing candidate"*) true;; *) false;; esac'
+done
+
+# The other half of the same decision: a committed receipt stays excluded. If it did
+# not, committing a ledger would move the candidate that ledger records and no
+# ledger could ever bind its own landing candidate.
+git -C "$SCOPE" checkout -q -B "evidence-only" "$SCOPE_BASE"
+printf '{"schema_version": 3, "candidate_sha256": "%s"}\n' \
+  "0000000000000000000000000000000000000000000000000000000000000000" \
+  >"$SCOPE/specs/round/evidence/note.json"
+git -C "$SCOPE" add -A && git -C "$SCOPE" commit -qm "land a receipt only"
+out="$(run_scope --base "$SCOPE_BASE")"; rc=$?
+check "a change confined to added receipts still reports no reviewed-path change" \
+  '[ "$rc" = 0 ] && case "$out" in *"no reviewed-path change"*) true;; *) false;; esac'
+
+# The exclusion covers what this round ADDS, not the whole tree. Committed review
+# history is the record the gate exists to protect, so rewriting or deleting an
+# earlier round's plan or receipt has to reach the candidate like any other change.
+for corruption in rewrite-plan rewrite-receipt delete-receipt; do
+  git -C "$SCOPE" checkout -q -B "corrupt" "$SCOPE_BASE"
+  case "$corruption" in
+    rewrite-plan)    printf 'rewritten by a later round\n' >"$SCOPE/specs/round/plan.md";;
+    rewrite-receipt) printf '{"schema_version": 3, "closeout_state": "forged"}\n' \
+                       >"$SCOPE/specs/round/evidence/history.json";;
+    delete-receipt)  rm "$SCOPE/specs/round/evidence/history.json";;
+  esac
+  git -C "$SCOPE" add -A && git -C "$SCOPE" commit -qm "$corruption"
+  out="$(run_scope --base "$SCOPE_BASE")"; rc=$?
+  check "a later round cannot $corruption of committed review history without evidence" \
+    '[ "$rc" = 1 ] && case "$out" in *"no accepted review evidence binds the landing candidate"*) true;; *) false;; esac'
+done
+
+# The exclusion is about what a file IS, not where it sits. An evidence directory is
+# where receipts belong, but the directory alone must not buy exclusion: otherwise a
+# script, a fixture, or any other artifact committed there lands unreviewed while an
+# unchanged ledger still passes.
+for smuggled in payload.py fixture.bin notes.json; do
+  git -C "$SCOPE" checkout -q -B "smuggle" "$SCOPE_BASE"
+  mkdir -p "$SCOPE/specs/new-round/evidence"
+  case "$smuggled" in
+    payload.py)  printf 'import os\nos.system("echo landed")\n' >"$SCOPE/specs/new-round/evidence/$smuggled";;
+    fixture.bin) printf 'not text at all\n' >"$SCOPE/specs/new-round/evidence/$smuggled";;
+    notes.json)  printf '{"note": "json, but binds no candidate"}\n' >"$SCOPE/specs/new-round/evidence/$smuggled";;
+  esac
+  git -C "$SCOPE" add -A && git -C "$SCOPE" commit -qm "smuggle $smuggled"
+  out="$(run_scope --base "$SCOPE_BASE")"; rc=$?
+  check "an added $smuggled under an evidence directory is bound, not excluded" \
+    '[ "$rc" = 1 ] && case "$out" in *"no accepted review evidence binds the landing candidate"*) true;; *) false;; esac'
+done
+
+# The candidate has to be the tree a clean checkout recomputes. An uncommitted edit
+# or a scratch file inside the bound paths would otherwise produce a hash only this
+# working copy can reproduce, which the author then records in the ledger.
+git -C "$SCOPE" checkout -q -B "dirty-probe" "$SCOPE_BASE"
+printf 'scratch\n' >"$SCOPE/scratch-note.txt"
+out="$(run_scope --base "$SCOPE_BASE" --print-candidate)"; rc=$?
+check "an untracked file inside the bound paths refuses instead of printing an unreproducible hash" \
+  '[ "$rc" != 0 ] && case "$out" in *"uncommitted changes"*) true;; *) false;; esac'
+rm "$SCOPE/scratch-note.txt"
+printf 'unstaged edit\n' >>"$SCOPE/Makefile"
+out="$(run_scope --base "$SCOPE_BASE" --print-candidate)"; rc=$?
+check "an unstaged edit inside the bound paths refuses instead of printing an unreproducible hash" \
+  '[ "$rc" != 0 ] && case "$out" in *"uncommitted changes"*) true;; *) false;; esac'
+git -C "$SCOPE" checkout -q -- Makefile
+out="$(run_scope --base "$SCOPE_BASE" --print-candidate)"; rc=$?
+check "the same clean checkout still reaches its normal verdict" \
+  '[ "$rc" = 0 ] && case "$out" in *"no reviewed-path change"*) true;; *) false;; esac'
+
+# Partition: the candidate's Git identity is base..HEAD, but the packet a reviewer
+# can read is capped at the controller's byte ceiling. A landing candidate larger
+# than one packet used to be unlandable as one pull request -- the whole-candidate
+# freeze failed and no ledger could ever bind it -- so authors split the pull
+# request instead of the review. A committed landing partition manifest names
+# path partitions that together cover every changed file exactly once, each bound
+# by its own validated ledger; the gate recomputes every partition and refuses any
+# manifest whose parts do not add up to the whole.
+PART="$WORK/partition-repo"
+mkdir -p "$PART/skills/code-review/scripts" "$PART/skills/skill-extraction-workflow/scripts" "$PART/specs/round/evidence" "$PART/lane-a" "$PART/lane-b"
+cp "$CONTROLLER" "$PART/skills/code-review/scripts/review_gate.py"
+cat >"$PART/skills/skill-extraction-workflow/scripts/validate_extraction_review_state.py" <<'PY'
+import sys
+print("extraction_review_state_ok: stub accepted")
+sys.exit(0)
+PY
+git -C "$PART" init -q .
+git -C "$PART" config user.email t@example.invalid
+git -C "$PART" config user.name tester
+printf 'baseline\n' >"$PART/skills/skill-extraction-workflow/SKILL.md"
+printf 'baseline\n' >"$PART/lane-a/big.txt"
+printf 'baseline\n' >"$PART/lane-b/big.txt"
+git -C "$PART" add -A && git -C "$PART" commit -qm baseline
+PART_BASE="$(git -C "$PART" rev-parse HEAD)"
+
+run_part() { python3 "$GATE" --repo-root "$PART" "$@" 2>&1; }
+
+# The manifest oracle mirrors the documented canonical form (sorted keys, compact
+# separators, UTF-8) independently of the gate, so a drift in either side reds.
+cat >"$WORK/write-manifest.py" <<'PY'
+import hashlib, json, sys
+out, base, aggregate = sys.argv[1], sys.argv[2], sys.argv[3]
+partitions = []
+for spec in sys.argv[4:]:
+    paths, digest = spec.rsplit("=", 1)
+    partitions.append({"paths": paths.split(), "candidate_sha256": digest})
+body = {"schema_version": 1, "kind": "landing_partition_manifest", "base": base, "partitions": partitions}
+if aggregate == "AUTO":
+    canonical = json.dumps(body, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+    aggregate = hashlib.sha256(canonical).hexdigest()
+body["candidate_sha256"] = aggregate
+with open(out, "w", encoding="utf-8") as handle:
+    json.dump(body, handle, indent=2)
+    handle.write("\n")
+PY
+write_closeout() { python3 - "$1" "$2" <<'PY'
+import json, sys
+from pathlib import Path
+Path(sys.argv[1]).write_text(json.dumps({"schema_version": 3, "closeout_state": "ready_for_human_decision", "controller_receipts": [], "candidate_sha256": sys.argv[2]}))
+PY
+}
+
+# Two lanes each change ~130 KB: either fits one packet, the pair does not.
+python3 - "$PART" <<'PY'
+import sys
+from pathlib import Path
+root = Path(sys.argv[1])
+for lane in ("lane-a", "lane-b"):
+    lines = [f"{lane} line {index:06d} " + "x" * 40 for index in range(2200)]
+    (root / lane / "big.txt").write_text("\n".join(lines) + "\n")
+PY
+git -C "$PART" add -A && git -C "$PART" commit -qm "oversized landing"
+
+out="$(run_part --base "$PART_BASE")"; rc=$?
+check "a candidate too large for one packet is refused with the partition recipe, not a bare freeze error" \
+  '[ "$rc" = 1 ] && case "$out" in *"exceeds 200000 bytes"*"landing partition manifest"*) true;; *) false;; esac'
+
+MANIFEST_JSON="$(run_part --base "$PART_BASE" --print-manifest --partition lane-a --partition lane-b)"; rc=$?
+check "the gate renders a manifest for a partition that covers the whole candidate" \
+  '[ "$rc" = 0 ] && python3 -c "import json,sys; m=json.loads(sys.argv[1]); assert m[\"kind\"]==\"landing_partition_manifest\" and len(m[\"partitions\"])==2 and m[\"base\"]==sys.argv[2]" "$MANIFEST_JSON" "$PART_BASE"'
+
+out="$(run_part --base "$PART_BASE" --print-manifest --partition lane-a)"; rc=$?
+check "rendering refuses a partition that leaves a changed path uncovered" \
+  '[ "$rc" != 0 ] && case "$out" in *"uncovered"*"lane-b/big.txt"*) true;; *) false;; esac'
+
+out="$(run_part --base "$PART_BASE" --print-manifest --partition lane-a --partition lane-a/big.txt lane-b)"; rc=$?
+check "rendering refuses partitions that overlap on a changed path" \
+  '[ "$rc" != 0 ] && case "$out" in *"overlap"*"lane-a/big.txt"*) true;; *) false;; esac'
+
+out="$(run_part --base "$PART_BASE" --print-manifest --partition lane-a --partition lane-a lane-b)"; rc=$?
+check "rendering refuses the same path listed in two partitions before touching git" \
+  '[ "$rc" != 0 ] && case "$out" in *"listed twice"*"lane-a"*) true;; *) false;; esac'
+
+HASH_A="$(run_part --base "$PART_BASE" --print-candidate --paths lane-a)"
+HASH_B="$(run_part --base "$PART_BASE" --print-candidate --paths lane-b)"
+check "a partition's hash is exactly what --print-candidate --paths already answers" \
+  '[ ${#HASH_A} = 64 ] && python3 -c "import json,sys; m=json.loads(sys.argv[1]); assert [p[\"candidate_sha256\"] for p in m[\"partitions\"]]==[sys.argv[2], sys.argv[3]]" "$MANIFEST_JSON" "$HASH_A" "$HASH_B"'
+
+printf '%s\n' "$MANIFEST_JSON" >"$PART/specs/round/evidence/landing-partitions.json"
+git -C "$PART" add -A && git -C "$PART" commit -qm "partition manifest"
+out="$(run_part --base "$PART_BASE")"; rc=$?
+check "a manifest whose partitions carry no validated ledger is refused, naming the partition" \
+  '[ "$rc" = 1 ] && case "$out" in *"no accepted ledger"*"lane-a"*) true;; *) false;; esac'
+HASH_A_AFTER="$(run_part --base "$PART_BASE" --print-candidate --paths lane-a)"
+check "committing the manifest does not move the partition it describes" \
+  '[ "$HASH_A_AFTER" = "$HASH_A" ]'
+
+write_closeout "$PART/specs/round/evidence/closeout-a.json" "$HASH_A"
+write_closeout "$PART/specs/round/evidence/closeout-b.json" "$HASH_B"
+git -C "$PART" add -A && git -C "$PART" commit -qm "partition ledgers"
+out="$(run_part --base "$PART_BASE")"; rc=$?
+check "a complete manifest with a validated ledger per partition binds a candidate no single packet could" \
+  '[ "$rc" = 0 ] && case "$out" in *"binds the landing candidate"*"2 partitions"*) true;; *) false;; esac'
+PART_GOOD="$(git -C "$PART" rev-parse HEAD)"
+
+# Every way the parts can fail to add up to the whole is refused for its own
+# reason. Each probe branches from the passing state so the cases stay independent.
+MANIFEST="$PART/specs/round/evidence/landing-partitions.json"
+probe_part() {
+  git -C "$PART" checkout -q -B "probe" "$PART_GOOD"
+}
+
+probe_part
+python3 "$WORK/write-manifest.py" "$MANIFEST" "$PART_BASE" AUTO "lane-a=$HASH_A"
+git -C "$PART" add -A && git -C "$PART" commit -qm "manifest drops a lane"
+out="$(run_part --base "$PART_BASE")"; rc=$?
+check "a manifest that leaves a changed path in no partition is refused" \
+  '[ "$rc" = 1 ] && case "$out" in *"uncovered"*"lane-b/big.txt"*) true;; *) false;; esac'
+
+probe_part
+python3 "$WORK/write-manifest.py" "$MANIFEST" "$PART_BASE" AUTO "lane-a=$HASH_A" "lane-a/big.txt lane-b=$HASH_B"
+git -C "$PART" add -A && git -C "$PART" commit -qm "manifest overlaps"
+out="$(run_part --base "$PART_BASE")"; rc=$?
+check "a manifest whose partitions overlap is refused before any packet is frozen" \
+  '[ "$rc" = 1 ] && case "$out" in *"overlap"*"lane-a/big.txt"*) true;; *) false;; esac'
+
+probe_part
+printf 'moved after the manifest was written\n' >>"$PART/lane-a/big.txt"
+git -C "$PART" add -A && git -C "$PART" commit -qm "candidate moves after manifest"
+out="$(run_part --base "$PART_BASE")"; rc=$?
+check "a partition whose recorded hash no longer reproduces is refused" \
+  '[ "$rc" = 1 ] && case "$out" in *"lane-a"*"does not reproduce"*) true;; *) false;; esac'
+
+probe_part
+python3 "$WORK/write-manifest.py" "$MANIFEST" "0000000000000000000000000000000000000000" AUTO "lane-a=$HASH_A" "lane-b=$HASH_B"
+git -C "$PART" add -A && git -C "$PART" commit -qm "manifest names another base"
+out="$(run_part --base "$PART_BASE")"; rc=$?
+check "a manifest written against another base is refused" \
+  '[ "$rc" = 1 ] && case "$out" in *"base"*"fork point"*) true;; *) false;; esac'
+
+probe_part
+python3 "$WORK/write-manifest.py" "$MANIFEST" "$PART_BASE" "$(printf 'f%.0s' $(seq 64))" "lane-a=$HASH_A" "lane-b=$HASH_B"
+git -C "$PART" add -A && git -C "$PART" commit -qm "manifest aggregate forged"
+out="$(run_part --base "$PART_BASE")"; rc=$?
+check "a manifest whose aggregate hash does not reproduce its partitions is refused" \
+  '[ "$rc" = 1 ] && case "$out" in *"aggregate"*) true;; *) false;; esac'
+
+for bad_path in ":(exclude)lane-b" "-lane-b" "../lane-b" "/lane-b" "lane-*" "lane-?" "lane-[ab]" "lane-\\b"; do
+  probe_part
+  python3 "$WORK/write-manifest.py" "$MANIFEST" "$PART_BASE" AUTO "lane-a=$HASH_A" "$bad_path=$HASH_B"
+  git -C "$PART" add -A && git -C "$PART" commit -qm "manifest smuggles a pathspec"
+  out="$(run_part --base "$PART_BASE")"; rc=$?
+  check "a manifest partition path shaped like $bad_path is refused as a path, not handed to git" \
+    '[ "$rc" = 1 ] && case "$out" in *"partition path"*) true;; *) false;; esac'
+done
+
+out="$(run_part --base "$PART_BASE" --print-manifest --partition 'lane-*')"; rc=$?
+check "rendering refuses a wildcard partition instead of letting git expand it" \
+  '[ "$rc" != 0 ] && case "$out" in *"partition path"*"wildcard"*) true;; *) false;; esac'
+
+# Under a narrowed --paths scope the partition union must equal the reviewed
+# changed set, not merely contain it: a partition naming `.` reaches lane-b even
+# though only lane-a is under review, and that surplus is refused before any
+# packet is frozen. The ledgers are removed so the single-ledger path cannot
+# satisfy the narrowed scope first.
+probe_part
+git -C "$PART" rm -q "$PART/specs/round/evidence/closeout-a.json" "$PART/specs/round/evidence/closeout-b.json"
+python3 "$WORK/write-manifest.py" "$MANIFEST" "$PART_BASE" AUTO ".=$(printf '0%.0s' $(seq 64))"
+git -C "$PART" add -A && git -C "$PART" commit -qm "manifest reaches outside the reviewed scope"
+out="$(run_part --base "$PART_BASE" --paths lane-a)"; rc=$?
+check "a partition reaching changed paths outside a narrowed --paths scope is refused, not accepted as covering" \
+  '[ "$rc" = 1 ] && case "$out" in *"outside the reviewed scope"*"lane-b/big.txt"*) true;; *) false;; esac'
+
+probe_part
+git -C "$PART" rm -q "$PART/specs/round/evidence/closeout-b.json"
+git -C "$PART" commit -qm "one ledger missing"
+out="$(run_part --base "$PART_BASE")"; rc=$?
+check "a manifest with one partition unbound is refused, naming that partition" \
+  '[ "$rc" = 1 ] && case "$out" in *"no accepted ledger"*"lane-b"*) true;; *) false;; esac'
+
+git -C "$PART" checkout -q -B "landing" "$PART_GOOD"
+out="$(run_part --base "$PART_BASE")"; rc=$?
+check "the passing partition state still passes after the probes" \
+  '[ "$rc" = 0 ]'
+
+# The suite above exercises a synthetic repository. The gate must also run against
+# the real checkout it ships in, or a break in that path passes every test here.
+REAL_ROOT="$(cd "$DIR/../../.." && pwd -P)"
+real_out="$(env -u CCL_SKILL_BASE_REF python3 "$GATE" --repo-root "$REAL_ROOT" --base HEAD~1 --print-candidate 2>&1)"; real_rc=$?
+# Both outputs are legitimate and which one appears depends on what the parent
+# commit happened to touch: a candidate hash when a reviewed path moved, the
+# no-change signal when it did not. Accepting only the first makes this assertion
+# a function of repository state rather than of the gate.
+# Which answer is legitimate depends on the checkout, so decide that FIRST and then
+# assert the one matching branch. Accepting every output would make this assertion a
+# function of repository state; branching on the state keeps it an assertion about
+# the gate. A dirty checkout is a legitimate state for a developer to run in, and
+# the gate must refuse there rather than print a hash nobody else can recompute.
+real_dirty="$(git -C "$REAL_ROOT" status --porcelain)"
+if [ -n "$real_dirty" ]; then
+  check "the gate refuses to answer for a real checkout that is not committed" \
+    '[ "$real_rc" != 0 ] && case "$real_out" in *"uncommitted changes"*) true;; *) false;; esac'
+else
+  check "the gate answers for the clean real checkout it ships in, whichever legitimate answer applies" \
+    '[ "$real_rc" = 0 ] && { case "$real_out" in [0-9a-f]*) [ ${#real_out} = 64 ];; *) false;; esac || case "$real_out" in *review_ledger_binding_no_change*) true;; *) false;; esac; }'
+fi
+
+if [ "$fails" -gt 0 ]; then
+  echo "test_review_ledger_binding: $fails failing case(s)" >&2
+  exit 1
+fi
+echo "test_review_ledger_binding: ok"