@ccoalm/ccl-skills 0.16.0 → 0.18.0

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

@@ -1,15 +1,14 @@
 #!/usr/bin/env bash
-# Regression for the extraction-specific autonomous review budget wrapper.
+# Regression for the extraction review wrapper: every call is one single-shot
+# pass, and no caller option can reopen a tracked review chain.
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
 WRAPPER="$SCRIPT_DIR/extraction_review_gate.sh"
 REAL_CONTROLLER="$SCRIPT_DIR/../../code-review/scripts/review_gate.sh"
-REAL_VALIDATOR="$SCRIPT_DIR/validate_extraction_review_state.py"
 ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd -P)"
 [ -x "$WRAPPER" ] || { echo "FAIL: wrapper missing or not executable: $WRAPPER" >&2; exit 1; }
 [ -x "$REAL_CONTROLLER" ] || { echo "FAIL: real controller missing or not executable: $REAL_CONTROLLER" >&2; exit 1; }
-[ -f "$REAL_VALIDATOR" ] || { echo "FAIL: real validator missing: $REAL_VALIDATOR" >&2; exit 1; }
 
 TMP="$(mktemp -d "${TMPDIR:-/tmp}/extraction-review-gate.XXXXXX")"
 trap 'rm -rf "$TMP"' EXIT
@@ -17,326 +16,185 @@ trap 'rm -rf "$TMP"' EXIT
 fail() { echo "FAIL: $*" >&2; exit 1; }
 assert_rc() { [ "$1" = "$2" ] || fail "expected rc=$2 got rc=$1 ($3)"; }
 assert_contains() { case "$2" in *"$1"*) : ;; *) fail "expected '$1' ($3): $2";; esac; }
+assert_not_contains() { case "$2" in *"$1"*) fail "unexpected '$1' ($3): $2";; *) : ;; esac; }
 
+# A fake controller that records its argv, so the fixed options are observable.
 mkdir -p "$TMP/skills/skill-extraction-workflow/scripts" "$TMP/skills/code-review/scripts"
-cp "$WRAPPER" "$TMP/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh"
+FAKE_WRAPPER="$TMP/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh"
+cp "$WRAPPER" "$FAKE_WRAPPER"
 printf '%s\n' \
   '#!/usr/bin/env bash' \
   'printf '\''%s\0'\'' "$@" >"$CAPTURE_PATH"' \
   'exit "${FAKE_RC:-0}"' >"$TMP/skills/code-review/scripts/review_gate.sh"
-chmod +x "$TMP/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh" "$TMP/skills/code-review/scripts/review_gate.sh"
+chmod +x "$FAKE_WRAPPER" "$TMP/skills/code-review/scripts/review_gate.sh"
 
-CAPTURE_PATH="$TMP/args" "$TMP/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh" \
-  --mode review --cwd /synthetic --base base --implementer-family openai
-python3 - "$TMP/args" <<'PY'
+captured() {
+  python3 - "$TMP/args" <<'PY'
 import sys
 from pathlib import Path
-
-args = [item.decode() for item in Path(sys.argv[1]).read_bytes().split(b"\0") if item]
-assert args[:2] == ["--challenge-budget", "1"], args
-assert args.count("--challenge-budget") == 1, args
-PY
-
-# A caller option with a missing operand must not consume the wrapper-owned
-# budget flag. The real controller will reject the missing operand, but only
-# after seeing the fixed extraction budget as its own option/value pair.
-CAPTURE_PATH="$TMP/args" "$TMP/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh" \
-  --mode review --cwd /synthetic --implementer-family openai --base
-python3 - "$TMP/args" <<'PY'
-import sys
-from pathlib import Path
-
-args = [item.decode() for item in Path(sys.argv[1]).read_bytes().split(b"\0") if item]
-assert args[:2] == ["--challenge-budget", "1"], args
-assert args[-1] == "--base", args
-assert args.count("--challenge-budget") == 1, args
+print(" ".join(i.decode() for i in Path(sys.argv[1]).read_bytes().split(b"\0") if i))
 PY
-
-# Exercise the installed wrapper/controller pair without invoking a model. The
-# same real controller defaults to budget 0 when called directly, while the
-# extraction wrapper must make the emitted receipt report budget 1.
-python3 - "$TMP/real-controller.diff" "$TMP/real-controller-plan.json" <<'PY'
-import json
-import sys
-from pathlib import Path
-
-diff_path, plan_path = map(Path, sys.argv[1:])
-diff_path.write_text(
-    "diff --git a/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh "
-    "b/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh\n"
-    "--- a/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh\n"
-    "+++ b/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh\n"
-    "@@ -1 +1 @@\n-old wrapper\n+new wrapper\n",
-    encoding="utf-8",
-)
-conclusions = {
-    "correctness": "The real controller receipt exposes the effective extraction budget.",
-    "safety": "The probe selects only the implementer family and invokes no external reviewer.",
-    "failure_paths": "The no-independent-reviewer boundary remains structured and fail closed.",
-    "tests_evidence": "Direct and wrapped calls provide a differential budget assertion.",
-    "compatibility": "The generic controller default remains zero while extraction fixes one.",
 }
-skills = {
-    "correctness": "skill-extraction-workflow",
-    "safety": "code-review",
-    "failure_paths": "python-service-dev",
-    "tests_evidence": "testing-strategy",
-    "compatibility": "terminal-cli-dev",
-}
-plan = {
-    "intent": "Prove the extraction wrapper and real review controller agree on budget one.",
-    "acceptance": ["The wrapped real-controller receipt reports challenge_budget one."],
-    "self_review": [
-        {
-            "concern": concern,
-            "skill": skills[concern],
-            "conclusion": conclusion,
-            "evidence_refs": ["real-controller-differential"],
-        }
-        for concern, conclusion in conclusions.items()
-    ],
-    "evidence": [
-        {
-            "id": "real-controller-differential",
-            "result": "The same real controller is invoked directly and through the extraction wrapper.",
-        }
-    ],
-}
-plan_path.write_text(json.dumps(plan, indent=2) + "\n", encoding="utf-8")
-PY
 
-real_args=(
-  --mode review --cwd "$ROOT" --diff-file "$TMP/real-controller.diff"
-  --implementer-family openai --review-plan-file "$TMP/real-controller-plan.json"
-  --stage build --review-harness --timeout 5 --total-timeout 5
-)
-# Make a Codex executable visibly available, independent of whichever CLI
-# version the host carries. Because the implementer is OpenAI-family, the real
-# controller must reject Codex as same-family before probing or invoking it.
-mkdir -p "$TMP/fake-bin"
-printf '%s\n' \
-  '#!/usr/bin/env bash' \
-  'printf invoked >"$CODEX_MARKER"' \
-  'exit 99' >"$TMP/fake-bin/codex"
-chmod +x "$TMP/fake-bin/codex"
-set +e
-direct_out="$(CODEX_MARKER="$TMP/codex-invoked" PATH="$TMP/fake-bin:$PATH" \
-  CODE_REVIEW_CLIENT_ORDER=codex bash "$REAL_CONTROLLER" "${real_args[@]}" 2>&1)"
-direct_rc=$?
-wrapped_out="$(CODEX_MARKER="$TMP/codex-invoked" PATH="$TMP/fake-bin:$PATH" \
-  CODE_REVIEW_CLIENT_ORDER=codex "$WRAPPER" "${real_args[@]}" \
-  --review-chain-id extraction-wrapper-real-controller \
-  --autonomous-review-index 1 2>&1)"
-wrapped_rc=$?
-set -e
-assert_rc "$direct_rc" 2 "direct real controller must stop before model inference"
-assert_rc "$wrapped_rc" 2 "wrapped real controller must stop before model inference"
-assert_contains '"reason_code":"no_independent_reviewer_available"' "$direct_out" "direct real-controller boundary"
-assert_contains '"reason_code":"no_independent_reviewer_available"' "$wrapped_out" "wrapped real-controller boundary"
-assert_contains '"challenge_budget":0' "$direct_out" "generic controller default budget"
-assert_contains '"challenge_budget":1' "$wrapped_out" "wrapper-enforced real-controller budget"
-[ ! -e "$TMP/codex-invoked" ] || fail "same-family Codex executable was invoked"
+CAPTURE_PATH="$TMP/args" "$FAKE_WRAPPER" --mode review --cwd /synthetic --implementer-family openai
+assert_contains "--challenge-budget 0 --mode review" "$(captured)" "review is single-shot with no challenge capacity"
 
-# Join the producer and consumer contracts. First feed the exact real receipt
-# to the validator and reach its semantic status boundary. Then normalize only
-# the terminal disposition fields so validation must walk the producer's real
-# chain/scope shape before stopping at the intentionally omitted base evidence.
-printf '%s\n' "$wrapped_out" >"$TMP/wrapped-real-controller.out"
-python3 - "$TMP/wrapped-real-controller.out" "$TMP" <<'PY'
-import copy
-import hashlib
-import json
-import sys
-from pathlib import Path
+CAPTURE_PATH="$TMP/args" "$FAKE_WRAPPER" --mode challenge --cwd /synthetic --implementer-family openai --focus f
+assert_contains "--challenge-budget 1 --challenge-index 1 --mode challenge" "$(captured)" "challenge is the single untracked challenge"
 
-output_path = Path(sys.argv[1])
-root = Path(sys.argv[2])
-receipt = None
-for line in reversed(output_path.read_text(encoding="utf-8").splitlines()):
-    try:
-        value = json.loads(line)
-    except json.JSONDecodeError:
-        continue
-    if isinstance(value, dict) and value.get("schema_version") == 3:
-        receipt = value
-        break
-assert receipt is not None
+CAPTURE_PATH="$TMP/args" "$FAKE_WRAPPER" --mode=challenge --cwd /synthetic --focus f
+assert_contains "--challenge-budget 1 --challenge-index 1 --mode=challenge" "$(captured)" "--mode=VALUE spelling"
 
-
-def write_receipt_and_ledger(stem, value, controller_state):
-    encoded = (json.dumps(value, ensure_ascii=False, indent=2) + "\n").encode()
-    receipt_name = f"{stem}-receipt.json"
-    (root / receipt_name).write_bytes(encoded)
-    digest = hashlib.sha256(encoded).hexdigest()
-    ledger = {
-        "schema_version": 3,
-        "candidate_sha256": value["candidate_sha256"],
-        "controller_receipts": [
-            {"sequence": 1, "file": receipt_name, "sha256": digest}
-        ],
-        "completion_receipt": None,
-        "base_attestations": [],
-        "autonomous_round": 1,
-        "controller_review_state": controller_state,
-        "finding_classes": [],
-        "unreviewed_delta": [],
-        "closeout_state": "ready_for_human_decision",
-    }
-    (root / f"{stem}-ledger.json").write_text(
-        json.dumps(ledger, ensure_ascii=False, indent=2) + "\n",
-        encoding="utf-8",
-    )
-
-
-write_receipt_and_ledger("real-emitted", receipt, receipt.get("review_state", "inconclusive"))
-normalized = copy.deepcopy(receipt)
-scope_before = json.dumps(normalized["review_scope"], sort_keys=True)
-normalized.update(
-    status="passed",
-    findings=[],
-    review_state="reviewed",
-    human_decision_required=False,
-)
-assert json.dumps(normalized["review_scope"], sort_keys=True) == scope_before
-write_receipt_and_ledger("real-scope", normalized, "reviewed")
-PY
-
-set +e
-emitted_state_out="$(python3 "$REAL_VALIDATOR" "$TMP/real-emitted-ledger.json" 2>&1)"
-emitted_state_rc=$?
-scope_state_out="$(python3 "$REAL_VALIDATOR" "$TMP/real-scope-ledger.json" 2>&1)"
-scope_state_rc=$?
-set -e
-assert_rc "$emitted_state_rc" 1 "exact real receipt reaches semantic status validation"
-assert_contains "must have status passed or findings" "$emitted_state_out" "exact real receipt semantic boundary"
-assert_rc "$scope_state_rc" 1 "producer-derived receipt reaches post-scope validation"
-assert_contains "base_attestations must be a non-empty array" "$scope_state_out" "real producer scope shape"
-
-# Shorter spellings that do not start with --challenge-b are ambiguous among
-# the controller's budget/index/classes options, so they fail closed instead of
-# becoming a hidden budget override.
-for abbreviated in --challeng --challenge=4; do
+# Missing or unsupported modes fail closed before the controller runs.
+for bad in "" "--mode complete" "--mode=complete" "--mo challenge"; do
+  : >"$TMP/args"
   set +e
-  out="$(CODE_REVIEW_CLIENT_ORDER=codex "$WRAPPER" "${real_args[@]}" "$abbreviated" 4 2>&1)"
+  # shellcheck disable=SC2086
+  out="$(CAPTURE_PATH="$TMP/args" "$FAKE_WRAPPER" $bad --cwd /synthetic 2>&1)"
   rc=$?
   set -e
-  assert_rc "$rc" 2 "ambiguous budget abbreviation must fail closed"
-  assert_contains "ambiguous option" "$out" "ambiguous abbreviation reason"
+  assert_rc "$rc" 2 "mode '$bad' must be refused"
+  assert_contains "extraction_review_gate_error" "$out" "mode '$bad' reason"
+  [ ! -s "$TMP/args" ] || fail "controller ran for mode '$bad'"
 done
 
-for spelling in --challenge-budget --challenge-budget=4 --challenge-b=4; do
+# Every chain option, full or abbreviated, with or without =VALUE, is refused.
+for spelling in \
+  --review-chain-id --review-chain-id=x --review-c \
+  --autonomous-review-index --autonomous-review-index=2 --au \
+  --prior-review-result-file --prior-review-result-file=/r.json --prio \
+  --predecessor-chain-result-file --pre \
+  --completion-review-result-file --com \
+  --challenge-budget --challenge-budget=4 --challenge-b=4 \
+  --challenge-index --challenge-index=2 --challenge-i; do
   : >"$TMP/args"
   set +e
-  out="$(CAPTURE_PATH="$TMP/args" "$TMP/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh" "$spelling" 4 2>&1)"
+  out="$(CAPTURE_PATH="$TMP/args" "$FAKE_WRAPPER" --mode challenge --focus f "$spelling" 1 2>&1)"
   rc=$?
   set -e
-  assert_rc "$rc" 2 "caller budget override must be rejected"
-  assert_contains "challenge budget is fixed at 1" "$out" "override reason"
-  [ ! -s "$TMP/args" ] || fail "controller ran after budget override"
+  assert_rc "$rc" 2 "chain option $spelling must be refused"
+  assert_contains "extraction_review_gate_error" "$out" "$spelling reason"
+  [ ! -s "$TMP/args" ] || fail "controller ran after $spelling"
 done
 
 set +e
-CAPTURE_PATH="$TMP/args" FAKE_RC=7 "$TMP/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh" \
-  --mode review --cwd /synthetic --base base --implementer-family openai >/dev/null 2>&1
+CAPTURE_PATH="$TMP/args" FAKE_RC=7 "$FAKE_WRAPPER" --mode review --cwd /synthetic >/dev/null 2>&1
 rc=$?
 set -e
 assert_rc "$rc" 7 "wrapper must preserve controller exit status"
 
 mv "$TMP/skills/code-review/scripts/review_gate.sh" "$TMP/controller-away"
 set +e
-out="$(CAPTURE_PATH="$TMP/args" "$TMP/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh" \
-  --mode review --cwd /synthetic --base base --implementer-family openai 2>&1)"
+out="$(CAPTURE_PATH="$TMP/args" "$FAKE_WRAPPER" --mode review --cwd /synthetic 2>&1)"
 rc=$?
 set -e
 assert_rc "$rc" 2 "missing controller must fail closed"
 assert_contains "controller is unavailable" "$out" "missing-controller reason"
 
-# The owner-facing start-here documents must route non-wording extraction work
-# through the fixed-budget wrapper and its terminal validator.  Strict
-# wording-only changes retain the documented single-review exception; they must
-# not be accidentally pulled into the multi-round ledger contract.
-python3 - "$ROOT" <<'PY'
-import re
+# The real controller must accept both single-shot shapes without a chain id.
+# The implementer is OpenAI-family and the only client offered is Codex, so the
+# controller must refuse it as same-family and stop before any model inference.
+python3 - "$TMP/real.diff" "$TMP/real-plan.json" "$ROOT" <<'PY'
+import json
+import subprocess
 import sys
 from pathlib import Path
 
-root = Path(sys.argv[1])
-skill = (root / "skills/skill-extraction-workflow/SKILL.md").read_text(encoding="utf-8")
-quickstart = (
-    root / "skills/skill-extraction-workflow/references/extraction-quickstart.md"
-).read_text(encoding="utf-8")
-dual = (
-    root / "skills/skill-extraction-workflow/references/dual-track-review-gate.md"
-).read_text(encoding="utf-8")
-landing = (
-    root / "skills/skill-extraction-workflow/references/validation-and-landing.md"
-).read_text(encoding="utf-8")
-staged = (
-    root / "skills/code-review/references/staged-review-contract.md"
-).read_text(encoding="utf-8")
-code_review = (root / "skills/code-review/SKILL.md").read_text(encoding="utf-8")
+diff_path, plan_path = map(Path, sys.argv[1:3])
+root = Path(sys.argv[3])
+diff_path.write_text(
+    "diff --git a/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh "
+    "b/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh\n"
+    "--- a/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh\n"
+    "+++ b/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh\n"
+    "@@ -1 +1 @@\n-old wrapper\n+new wrapper\n",
+    encoding="utf-8",
+)
+# The required concern set has one owner, the controller; derive it rather than
+# keeping a copy that drifts when the set changes.
+required = subprocess.run(
+    [sys.executable, str(root / "skills/code-review/scripts/review_gate.py"),
+     "--print-required-concerns", "--stage", "build"],
+    capture_output=True, text=True, check=True,
+).stdout.split()
+assert required, "the controller printed no required concerns"
+owners = ["skill-extraction-workflow", "code-review", "python-service-dev",
+          "testing-strategy", "terminal-cli-dev"]
+rows = [
+    {"concern": c, "skill": owners[i % len(owners)],
+     "conclusion": f"The single-shot wrapper probe covers {c} within its fixture.",
+     "evidence_refs": ["wrapper-probe"]}
+    for i, c in enumerate(required)
+]
+covered = {r["skill"] for r in rows}
+rows += [
+    {"concern": required[0], "skill": o,
+     "conclusion": f"{o} is covered for {required[0]} by the same probe.",
+     "evidence_refs": ["wrapper-probe"]}
+    for o in owners if o not in covered
+]
+plan_path.write_text(json.dumps({
+    "intent": "Prove the extraction wrapper drives the real controller single-shot.",
+    "acceptance": ["Both passes reach the reviewer-selection boundary untracked."],
+    "self_review": rows,
+    "evidence": [{"id": "wrapper-probe", "result": "The real controller is invoked through the wrapper."}],
+}, indent=2) + "\n", encoding="utf-8")
+PY
 
-for label, text in {
-    "SKILL": skill,
-    "quickstart": quickstart,
-    "dual-track": dual,
-    "validation-and-landing": landing,
-}.items():
-    assert "scripts/extraction_review_gate.sh" in text, (
-        f"{label} does not route the non-wording lane through the owner wrapper"
-    )
+mkdir -p "$TMP/fake-bin"
+printf '%s\n' '#!/usr/bin/env bash' 'printf invoked >"$CODEX_MARKER"' 'exit 99' >"$TMP/fake-bin/codex"
+chmod +x "$TMP/fake-bin/codex"
+real_args=(
+  --cwd "$ROOT" --diff-file "$TMP/real.diff" --implementer-family openai
+  --review-plan-file "$TMP/real-plan.json" --stage build --review-harness
+  --timeout 5 --total-timeout 5
+)
+for pass in review challenge; do
+  extra=()
+  [ "$pass" = challenge ] && extra=(--focus "single-shot probe")
+  set +e
+  out="$(CODEX_MARKER="$TMP/codex-invoked" PATH="$TMP/fake-bin:$PATH" CODE_REVIEW_CLIENT_ORDER=codex \
+    "$WRAPPER" --mode "$pass" "${real_args[@]}" "${extra[@]}" 2>&1)"
+  rc=$?
+  set -e
+  assert_rc "$rc" 2 "real $pass must stop before model inference"
+  assert_contains '"reason_code":"no_independent_reviewer_available"' "$out" "real $pass reaches reviewer selection"
+  assert_not_contains 'review_chain_required' "$out" "real $pass needs no chain"
+  assert_not_contains 'review_chain_invalid' "$out" "real $pass needs no chain"
+done
+[ ! -e "$TMP/codex-invoked" ] || fail "same-family Codex executable was invoked"
 
-for label, text in {"quickstart": quickstart, "dual-track": dual}.items():
-    assert "scripts/validate_extraction_review_state.py <closeout.json>" in text, (
-        f"{label} omits the terminal closeout validator"
-    )
+# The owner documents must route non-wording work through this wrapper and must
+# no longer send anyone to the retired chain ledger or merge-side binder.
+python3 - "$ROOT" <<'PY'
+import re
+import sys
+from pathlib import Path
 
-assert re.search(
-    r"[Nn]on-wording.{0,240}scripts/extraction_review_gate\.sh",
-    skill,
-    re.DOTALL,
-), "SKILL does not scope the fixed-budget wrapper to non-wording changes"
-assert re.search(
-    r"[Ww]ording-only.{0,500}(?:single|one)[- ](?:round|review)",
-    quickstart,
-    re.DOTALL,
-), "quickstart lost the strict wording-only single-review exception"
-for label, text in {
-    "quickstart": quickstart,
-    "dual-track": dual,
-    "validation-and-landing": landing,
-    "code-review": code_review,
-}.items():
-    assert "wording_only_boundary" in text, (
-        f"{label} does not require independent wording-only semantic confirmation"
-    )
-assert "--wording-only-proof-file" in staged
-assert "--challenge-budget 0" in staged
-assert "markdown-punctuation-only" in staged
-assert "markdown-token-replacement" in staged
-assert "opens no challenge chain or `complete` checkpoint" in dual
-assert "codex review --base" not in quickstart
-assert "codex exec adversarial" not in quickstart
-assert "--challenge-budget" not in quickstart, (
-    "quickstart must not let callers override the extraction review budget"
-)
-assert re.search(
-    r"[Rr]ound 2 challenge.{0,500}ready_for_human_decision",
-    quickstart,
-    re.DOTALL,
-), "quickstart does not validate an early-clean round-2 terminal checkpoint"
-assert re.search(
-    r"[Rr]ound 2 findings.{0,200}continuation_authorization_required",
-    quickstart,
-    re.DOTALL,
-), "quickstart does not validate the exhausted-budget terminal checkpoint"
-assert "baseline_race" in quickstart
-assert "at most two challenges" not in quickstart, (
-    "quickstart still advertises the retired two-challenge budget"
-)
-assert "At the third Agent-autonomous round" not in dual, (
-    "dual-track still gates the lane at the retired third round"
-)
+root = Path(sys.argv[1])
+ref = root / "skills/skill-extraction-workflow"
+docs = {
+    "SKILL": (ref / "SKILL.md").read_text(encoding="utf-8"),
+    "quickstart": (ref / "references/extraction-quickstart.md").read_text(encoding="utf-8"),
+    "dual-track": (ref / "references/dual-track-review-gate.md").read_text(encoding="utf-8"),
+    "validation-and-landing": (ref / "references/validation-and-landing.md").read_text(encoding="utf-8"),
+}
+for label, text in docs.items():
+    assert "scripts/extraction_review_gate.sh" in text, f"{label} does not route through the wrapper"
+    for retired in ("validate_extraction_review_state.py", "review_ledger_binding.py",
+                    "challenge_budget=1", "succession challenge"):
+        assert retired not in text, f"{label} still points at the retired {retired}"
+assert re.search(r"[Nn]on-wording.{0,240}scripts/extraction_review_gate\.sh",
+                 docs["SKILL"], re.DOTALL), "SKILL does not scope the wrapper to non-wording work"
+assert re.search(r"[Ww]ording-only.{0,500}(?:single|one)[- ](?:round|review|pass)",
+                 docs["quickstart"], re.DOTALL), "quickstart lost the wording-only single-review exception"
+assert "--challenge-budget" not in docs["quickstart"], "quickstart must not hand callers the budget flag"
+dual = docs["dual-track"]
+for pinned in ("post-review delta", "Every post-review delta gets a delta pass", "After five delta passes", "never left to a human reader"):
+    assert pinned in dual, f"dual-track lost '{pinned}'"
+wording_only = (root / "skills/code-review/references/wording-only-review.md").read_text(encoding="utf-8")
+assert "--wording-only-proof-file" in wording_only
+assert "--challenge-budget 0" in wording_only
 PY
 
 echo "test_extraction_review_gate: ok"

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

@@ -720,5 +720,45 @@ run_gate "$FIX"
 assert_rc "$rc" 0 "a fenced example row is an illustration, not a live declaration"
 pass "fenced declaration-looking example does not red a register with no live declarations"
 
-[ "$passed" -eq 57 ] || fail "expected 57 assertions, saw $passed (a case was skipped or misplaced)"
+# ── N. RED: the anchored list rule DELETED outright ──────────────────────────
+# A prose rule pinned for a documentation round is normally removed, not
+# reworded: the round that added this case pinned five rules whose only
+# mechanical protection is this gate, and its walk deleted each in turn.
+new_fixture deleted_rule "$LITERAL"
+# A mutation that does not apply proves nothing, so each edit below is checked
+# both before and after: the target must be present first, and the edit must
+# have changed the file. Without this a fixture drift turns these cases into
+# assertions about an unmutated fixture that still pass.
+grep -qF 'Never bypass the demo isolation boundary' "$FIX/skills/demo-skill/SKILL.md" \
+  || fail "fixture drift: the rule this case deletes is not in the fixture"
+grep -v 'Never bypass the demo isolation boundary' "$FIX/skills/demo-skill/SKILL.md" \
+  > "$FIX/skills/demo-skill/SKILL.md.tmp"
+mv "$FIX/skills/demo-skill/SKILL.md.tmp" "$FIX/skills/demo-skill/SKILL.md"
+grep -qF 'Never bypass the demo isolation boundary' "$FIX/skills/demo-skill/SKILL.md" \
+  && fail "mutation did not apply: the rule is still present"
+run_gate "$FIX"
+assert_rc "$rc" 1 "deleting the anchored rule outright must be caught"
+assert_contains "anchor text absent from target" "$out" "deleted anchored rule"
+assert_contains "Never bypass the demo isolation boundary" "$out" "names the dead locator"
+pass "deleting an anchored rule turns the gate RED"
+
+# ── N+1. GREEN by design: text OUTSIDE the anchor may be gutted ──────────────
+# The stated boundary, asserted rather than promised: a substring locator binds
+# the letters it names and nothing else. Here the anchored clause survives while
+# the rest of its line is replaced, and the gate is silent — which is why the
+# ledger rows that rely on it must not claim semantic protection.
+new_fixture unanchored_clause_gutted "$LITERAL"
+grep -qF ' when dispatching work.' "$FIX/skills/demo-skill/SKILL.md" \
+  || fail "fixture drift: the clause this case guts is not in the fixture"
+sed -i.bak 's/ when dispatching work\./ — every safeguard around it removed./' \
+  "$FIX/skills/demo-skill/SKILL.md"
+grep -qF ' — every safeguard around it removed.' "$FIX/skills/demo-skill/SKILL.md" \
+  || fail "mutation did not apply: the unanchored clause is unchanged"
+run_gate "$FIX"
+assert_rc "$rc" 0 "gutting text outside the anchor is invisible to this gate"
+assert_contains "register_firing_path_resolution_ok" "$out" "boundary control"
+assert_not_contains "anchor text absent" "$out" "no false RED on unanchored text"
+pass "text outside the anchor can be gutted while the gate stays green (declared boundary)"
+
+[ "$passed" -eq 59 ] || fail "expected 59 assertions, saw $passed (a case was skipped or misplaced)"
 echo "register_firing_path_resolution_tests_ok ($passed assertions)"

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

@@ -29,8 +29,8 @@ pass() { passed=$((passed + 1)); echo "PASS: $*"; }
 # guard silently stale again (the observed drift shape: a 16 guarding 13
 # executed cases, accumulated while this suite could not run).
 static_pass_calls="$(grep -c '^pass "' "$0")"
-[ "$static_pass_calls" = "18" ] \
-  || fail "pass-call inventory drifted: counted $static_pass_calls, guard expects 18"
+[ "$static_pass_calls" = "21" ] \
+  || fail "pass-call inventory drifted: counted $static_pass_calls, guard expects 21"
 pass "executed-count guard matches the script's own pass-call inventory"
 
 REPO="$TMP/repo"
@@ -478,6 +478,52 @@ case "$out" in
 esac
 pass "a second row cannot inherit a one-row historical locator waiver"
 
+# A retired locator that several historical rows cited is waived as ONE entry
+# binding every one of those rows by digest. Each row stays individually pinned:
+# removing one, rewriting one, or adding one more citation must each red.
+MULTI_LOCATOR="command:skills/skill-extraction-workflow/scripts/test_review_ledger_binding.sh"
+multi_row_case() {
+  multi_case="$1"
+  git -C "$REPO" checkout -- . >/dev/null 2>&1 \
+    || fail "could not restore the clone before the multi-row waiver $multi_case case"
+  python3 - "$REGISTER" "$MULTI_LOCATOR" "$multi_case" <<'PY'
+from pathlib import Path
+import sys
+
+path = Path(sys.argv[1])
+locator, case = sys.argv[2], sys.argv[3]
+lines = path.read_text(encoding="utf-8").splitlines(keepends=True)
+matches = [i for i, line in enumerate(lines) if line.startswith("|") and locator in line]
+assert len(matches) > 1, f"expected several real waived rows, found {len(matches)}"
+index = matches[len(matches) // 2]
+if case == "delete":
+    del lines[index]
+elif case == "rewrite":
+    lines[index] = lines[index].replace("| ", "| Fixture-rewritten claim: ", 1)
+else:
+    lines.insert(index + 1, lines[index])
+path.write_text("".join(lines), encoding="utf-8")
+PY
+  run_check
+  [ "$rc" = "1" ] || { dump; fail "multi-row waiver $multi_case must be rc=1, got rc=$rc"; }
+  case "$multi_case:$out" in
+    delete:*"EXEMPT entry has no citing row in the ledger for 1 of"*) : ;;
+    rewrite:*"EXEMPT citing row does not match the waived row"*) : ;;
+    duplicate:*"EXEMPT locator cited by"*"rows (allowance"*) : ;;
+    *) dump; fail "multi-row waiver $multi_case failed, but not via its exact diagnostic" ;;
+  esac
+  case "$out" in
+    *ccl_skill_check_clean_ok*) dump; fail "a multi-row waiver $multi_case must never yield a clean-landing token" ;;
+    *) : ;;
+  esac
+}
+multi_row_case delete
+pass "multi-row waiver: deleting one citing row fails closed"
+multi_row_case rewrite
+pass "multi-row waiver: rewriting one citing row fails closed"
+multi_row_case duplicate
+pass "multi-row waiver: a further citing row fails closed"
+
 # RED: adding an EXEMPT key without a row digest silently downgrades identity
 # binding unless the production gate rejects the incomplete waiver definition.
 # The checker resolves the gate beside itself, so mutate STUB_GATE — never the
@@ -547,5 +593,5 @@ case "$out" in
 esac
 pass "a failure inside the cleanup-trap window keeps its exit status"
 
-[ "$passed" -eq 18 ] || fail "expected 18 assertions, saw $passed"
+[ "$passed" -eq 21 ] || fail "expected 21 assertions, saw $passed"
 echo "register_firing_path_wiring_tests_ok ($passed assertions)"