@ccoalm/ccl-skills 0.1.0

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

@@ -0,0 +1,414 @@
+#!/usr/bin/env bash
+# Production-wiring regression for the register firing-path gate.
+#
+# test_register_firing_path_resolution.sh exercises the Ruby gate DIRECTLY, so it
+# stays green even if the `ruby "$firing_path_gate" "$root"` line is deleted from
+# check-ccl-skills.sh — the gate would be unreachable in production while its
+# own suite reported success. That is the same unregistered-suite false green this
+# repository has hit before, one layer up: registered, passing, and enforcing
+# nothing. This test closes it by driving the checker ENTRYPOINT.
+#
+# ALIAS_AUDIT_CMD=true stands in for a passing private R0 audit so the assertion
+# isolates firing-path enforcement from the separate R0 interim path.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+CHECK_SCRIPT="$SCRIPT_DIR/check-ccl-skills.sh"
+[ -f "$CHECK_SCRIPT" ] || { echo "FAIL: checker not found: $CHECK_SCRIPT" >&2; exit 1; }
+ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd -P)"
+
+TMP="$(mktemp -d "${TMPDIR:-/tmp}/regfiringwire.XXXXXX")"
+trap 'rm -rf "$TMP"' EXIT
+
+passed=0
+fail() { echo "FAIL: $*" >&2; exit 1; }
+pass() { passed=$((passed + 1)); echo "PASS: $*"; }
+
+# Static/executed three-way pin: the tail guard's literal must equal the
+# script's own pass-call inventory, so a dropped or added case cannot leave the
+# 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" = "14" ] \
+  || fail "pass-call inventory drifted: counted $static_pass_calls, guard expects 14"
+pass "executed-count guard matches the script's own pass-call inventory"
+
+REPO="$TMP/repo"
+git clone -q "$ROOT" "$REPO"
+git -C "$REPO" config user.email test@example.invalid
+git -C "$REPO" config user.name "Test User"
+# Give the clone its own base branch and upstream, the same fixture shape the
+# sibling register tests use. The checker resolves its diff base from
+# `@{upstream}` and falls back to `origin/main`; a clone made while CI has the
+# project checked out at a DETACHED HEAD carries neither, so impact-chain fails
+# closed with `impact_chain_merge_base_missing: origin/main` and this test would
+# red for a reason unrelated to the wiring it asserts. Pinning
+# CCL_SKILL_BASE_REF=HEAD instead is NOT equivalent: it makes the
+# evidence-card detector's self-test take its no-base branch and fail
+# (`no-base clean changed-scope should be degraded`). A real branch with a real
+# upstream keeps every other gate on its normal path.
+git -C "$REPO" branch -f fixture-base HEAD
+git -C "$REPO" switch -q -C fixture-work fixture-base
+git -C "$REPO" branch --set-upstream-to=fixture-base fixture-work >/dev/null 2>&1
+REGISTER="$REPO/skills/skill-extraction-workflow/references/source-register.md"
+[ -f "$REGISTER" ] || fail "cloned register missing: $REGISTER"
+
+# The distributed register starts as a source-neutral template. Add one live,
+# repository-local locator to this clone so the wiring test can mutate a real
+# anchor without shipping task provenance in the published repository. The
+# anchor lives in a note file THIS FIXTURE writes and commits itself, so every
+# byte of the anchor vocabulary is suite-owned: the previous design pinned a
+# README heading literal (stale the moment the README evolved, undetected while
+# the heavy lane never ran), and the replacement runtime-derivation grew a
+# fence-parsing surface that produced same-class findings across two adversarial
+# rounds (fenced decoy, mixed-marker fence, close-suffix recognition) — parsing
+# an artifact the suite does not own was the defect class, so the capability is
+# deleted rather than hardened further.
+FIXTURE_NOTE_REL="skills/skill-extraction-workflow/references/wiring-fixture-note.md"
+FIXTURE_ANCHOR="Wiring fixture anchor heading for the resolution gate"
+printf '# %s\n\nSynthetic fixture note committed by the wiring suite; the heading above is the seeded firing-path anchor.\n' \
+  "$FIXTURE_ANCHOR" > "$REPO/$FIXTURE_NOTE_REL"
+printf '| wiring fixture | firing-path: file:%s#%s | `updated` | synthetic test |\n' \
+  "$FIXTURE_NOTE_REL" "$FIXTURE_ANCHOR" >> "$REGISTER"
+git -C "$REPO" add "$REGISTER" "$FIXTURE_NOTE_REL"
+git -C "$REPO" commit -qm "Add wiring fixture"
+git -C "$REPO" branch -f fixture-base HEAD
+
+run_check() {
+  set +e
+  out="$(env -u CCL_SKILL_BASE_REF ALIAS_AUDIT_CMD='true' bash "$CHECK_SCRIPT" "$REPO" 2>&1)"
+  rc=$?
+  set -e
+}
+
+# Always show the checker's own output when an assertion fails; without this a
+# CI red says only "got rc=1" and the actual cause has to be re-derived by hand.
+dump() { printf '%s\n' "--- checker output (rc=$rc) ---" "$out" | tail -25 >&2; }
+
+# ── Control: the pristine clone passes and the gate's token is emitted ───────
+run_check
+[ "$rc" = "0" ] || { dump; fail "pristine clone should pass the checker, got rc=$rc"; }
+case "$out" in
+  *register_firing_path_resolution_ok*) : ;;
+  *) dump; fail "checker did not emit the firing-path gate token — the gate is not wired in" ;;
+esac
+pass "checker entrypoint runs the firing-path gate on a clean tree"
+
+# ── RED: break a historical anchor; the CHECKER (not just the gate) must fail ─
+# Reproduces the observed shape: an anchored rule reworded after its row landed.
+anchor_line="$(grep -m1 -o 'firing-path: file:[^|;]*#[^|;]*' "$REGISTER")"
+[ -n "$anchor_line" ] || fail "no file: anchor found in the cloned register"
+target_rel="${anchor_line#firing-path: file:}"; target_rel="${target_rel%%#*}"
+anchor_text="${anchor_line#*#}"
+target="$REPO/$target_rel"
+[ -f "$target" ] || fail "anchor target missing in clone: $target"
+python3 - "$target" "$anchor_text" <<'PY'
+import sys
+p, anchor = sys.argv[1], sys.argv[2].strip()
+s = open(p, encoding="utf-8").read()
+assert anchor in s, "fixture precondition failed: anchor not present before mutation"
+# Rewrite the anchor's TAIL. Appending would leave the original anchor intact as
+# a substring, so the fixture would assert nothing while looking like a mutation.
+assert len(anchor) > 12, "anchor too short to mutate safely"
+mutated = anchor[:-8] + "ZZQXZZQX"
+s2 = s.replace(anchor, mutated, 1)
+assert anchor not in s2, "fixture failed to remove the anchor — mutation is a no-op"
+open(p, "w", encoding="utf-8").write(s2)
+PY
+run_check
+[ "$rc" != "0" ] || { dump; fail "checker must FAIL when a historical firing-path anchor no longer resolves"; }
+case "$out" in
+  *register_firing_path_unresolved*) : ;;
+  *) dump; fail "checker failed, but not via the firing-path gate (wrong-reason RED)" ;;
+esac
+pass "reworded historical anchor turns the CHECKER ENTRYPOINT red for the right reason"
+
+# ── RED: rc=0 without the gate's terminal token must NOT read as a pass ──────
+# A clean rc has to pair with a clean terminal line. A gate that dies quietly
+# after `set -e` is disarmed inside it, or whose token gets reworded, still
+# exits 0 — and a bare `ruby "$gate" "$root"` call site cannot tell that apart
+# from a real clean run, so the checker certifies a gate that never adjudicated
+# anything. The stub reproduces exactly that: exit 0, print nothing.
+#
+# The call site resolves the gate from the CHECKER's own directory, not from
+# $root, so stubbing the clone's copy would be a no-op — the fixture has to
+# drive a checker whose sibling scripts dir it owns.
+STUB_SCRIPTS="$TMP/stubscripts"
+cp -R "$SCRIPT_DIR" "$STUB_SCRIPTS"
+STUB_CHECK="$STUB_SCRIPTS/check-ccl-skills.sh"
+STUB_GATE="$STUB_SCRIPTS/register-firing-path-resolution.rb"
+[ -f "$STUB_GATE" ] || fail "stub scripts dir missing the firing-path gate: $STUB_GATE"
+printf '%s\n' '#!/usr/bin/env ruby' 'exit 0' > "$STUB_GATE"
+
+run_stub_check() {
+  set +e
+  out="$(env -u CCL_SKILL_BASE_REF ALIAS_AUDIT_CMD='true' bash "$STUB_CHECK" "$REPO" 2>&1)"
+  rc=$?
+  set -e
+}
+
+# The clone still carries the r1 anchor mutation from the RED above; restore it
+# so this assertion isolates the silent-rc-0 path from the unresolved-anchor one.
+git -C "$REPO" checkout -- . >/dev/null 2>&1 || fail "could not restore the clone before the stub case"
+run_stub_check
+[ "$rc" = "2" ] || { dump; fail "a gate exiting 0 with no terminal token must fail closed as rc=2, got rc=$rc"; }
+case "$out" in
+  *register_firing_path_terminal_missing*) : ;;
+  *) dump; fail "checker rejected the silent gate, but not via the terminal-token contract (wrong-reason RED)" ;;
+esac
+case "$out" in
+  *ccl_skill_check_clean_ok*) dump; fail "a silent gate must never yield a clean-landing token" ;;
+  *) : ;;
+esac
+pass "gate rc=0 without its terminal token fails closed instead of certifying a pass"
+
+# ── RED: a non-git root must not print a clean-landing token ─────────────────
+# Every gate above (impact-chain, firing-path resolution, register pending
+# status, diff --check) sits inside `if git rev-parse --is-inside-work-tree`.
+# On an exported copy / build artifact directory that branch is simply skipped,
+# and with nothing marking the skip the run still reaches the clean token — four
+# gates silently not run, reported as a clean landing. Skip must never read as
+# clean (same honesty shape as the size gate's `*_unevaluated` token).
+NONGIT="$TMP/nongit"
+mkdir -p "$NONGIT"
+git -C "$REPO" archive HEAD | tar -x -C "$NONGIT"
+[ -d "$NONGIT/skills" ] || fail "non-git fixture export produced no skills/ tree"
+[ ! -e "$NONGIT/.git" ] || fail "non-git fixture is still a git work tree"
+
+set +e
+out="$(env -u CCL_SKILL_BASE_REF ALIAS_AUDIT_CMD='true' bash "$CHECK_SCRIPT" "$NONGIT" 2>&1)"
+rc=$?
+set -e
+case "$out" in
+  *ccl_skill_check_clean_ok*) dump; fail "a non-git root skips the git-dependent gates — it must not report a clean landing" ;;
+  *) : ;;
+esac
+case "$out" in
+  *ccl_skill_check_interim_ok*) : ;;
+  *) dump; fail "a non-git root should downgrade to interim, saw neither clean nor interim token" ;;
+esac
+case "$out" in
+  *"not a git work tree"*) : ;;
+  *) dump; fail "the interim downgrade must name the skipped git-dependent gates" ;;
+esac
+pass "non-git root downgrades to interim instead of silently reporting clean"
+
+# ── RED: an export nested INSIDE another checkout is not a clean landing ─────
+# `--is-inside-work-tree` answers true for a directory that merely sits under
+# some other repository, so a bare inside-work-tree predicate lets the four
+# git-dependent gates adjudicate the ENCLOSING repository's state while reading
+# this directory's files — the wrong tree, reported clean. $root must be the
+# work tree's own top level.
+NESTED="$REPO/nested-export-fixture"
+mkdir -p "$NESTED"
+git -C "$REPO" archive HEAD | tar -x -C "$NESTED"
+[ -d "$NESTED/skills" ] || fail "nested fixture export produced no skills/ tree"
+[ "$(git -C "$NESTED" rev-parse --is-inside-work-tree 2>/dev/null)" = "true" ] \
+  || fail "nested fixture precondition failed: git does not consider it inside a work tree"
+[ "$(git -C "$NESTED" rev-parse --show-toplevel 2>/dev/null)" != "$NESTED" ] \
+  || fail "nested fixture precondition failed: it IS its own toplevel, so nothing is being tested"
+
+set +e
+out="$(env -u CCL_SKILL_BASE_REF ALIAS_AUDIT_CMD='true' bash "$CHECK_SCRIPT" "$NESTED" 2>&1)"
+rc=$?
+set -e
+case "$out" in
+  *ccl_skill_check_clean_ok*) dump; fail "an export nested inside another checkout must not report a clean landing" ;;
+  *) : ;;
+esac
+case "$out" in
+  *"not a git work tree root"*) : ;;
+  *) dump; fail "the nested-export downgrade must name the skipped git-dependent gates" ;;
+esac
+# "Downgraded" means it reached a SUCCESSFUL interim verdict. Asserting only the
+# absence of the clean token would also accept an unrelated hard failure.
+[ "$rc" = "0" ] || { dump; fail "the nested-export downgrade must still succeed, got rc=$rc"; }
+case "$out" in
+  *ccl_skill_check_interim_ok*) : ;;
+  *) dump; fail "the nested-export run must end on the interim token, not merely lack the clean one" ;;
+esac
+pass "export nested inside another checkout downgrades instead of adjudicating the enclosing repo"
+
+# ── RED: a TRUNCATED terminal line is a malfunction, not a pass ──────────────
+# The shape a gate crashing mid-print actually produces. An unanchored substring
+# check accepts it, which would defeat the terminal-token contract above.
+printf '%s\n' '#!/usr/bin/env ruby' \
+  'print "register_firing_path_resolution_ok (269 locators resolved"' \
+  'exit 0' > "$STUB_GATE"
+run_stub_check
+[ "$rc" = "2" ] || { dump; fail "a truncated terminal line must fail closed as rc=2, got rc=$rc"; }
+assert_out_has_terminal_missing() {
+  case "$out" in
+    *register_firing_path_terminal_missing*) : ;;
+    *) dump; fail "truncated terminal line rejected, but not via the terminal-token contract" ;;
+  esac
+}
+assert_out_has_terminal_missing
+pass "truncated gate terminal line fails closed instead of matching as a substring"
+
+# ── RED: bulk output BEFORE a valid token must NOT read as missing ──────────
+# The false-RED direction of the contract. Under `pipefail`, a `printf | grep -q`
+# form has the writer take SIGPIPE once grep short-circuits, so the pipeline
+# reports 141 and a gate that DID emit its token gets rejected as malfunctioning.
+# The bulk goes BEFORE the token because the terminal line must stay last — the
+# two properties are checked together on purpose, so neither can be satisfied by
+# weakening the other. 50k lines is 4,538,890 bytes (measured), well past the
+# 64 KiB pipe buffer where SIGPIPE starts.
+printf '%s\n' '#!/usr/bin/env ruby' \
+  '50_000.times { |i| puts "leading diagnostic line #{i} " + ("x" * 60) }' \
+  'puts "register_firing_path_resolution_ok (271 locators resolved)"' \
+  'exit 0' > "$STUB_GATE"
+run_stub_check
+case "$out" in
+  *register_firing_path_terminal_missing*) dump; fail "a complete terminal line preceded by bulk output must not be reported as missing (SIGPIPE false RED)" ;;
+  *) : ;;
+esac
+# Assert the SUCCESS, not merely the absence of rc=2: `!= 2` would also accept a
+# false red arriving as 1/126/127/141 — including the very SIGPIPE status this
+# case exists to rule out.
+[ "$rc" = "0" ] || { dump; fail "bulk output preceding a valid terminal line must still pass, got rc=$rc"; }
+case "$out" in
+  *ccl_skill_check_clean_ok*) : ;;
+  *) dump; fail "a valid terminal line plus bulk output must still reach the clean-landing token" ;;
+esac
+pass "valid terminal line survives bulk preceding output (no pipefail/SIGPIPE false RED)"
+
+# ── RED: a token that is NOT the last line must not certify a clean run ─────
+# The shape of a gate that reached its terminal line and then died on a later
+# path. An any-line match accepts it; the last-line contract does not.
+printf '%s\n' '#!/usr/bin/env ruby' \
+  'puts "register_firing_path_resolution_ok (271 locators resolved)"' \
+  'puts "post-terminal work continued and produced this"' \
+  'exit 0' > "$STUB_GATE"
+run_stub_check
+[ "$rc" = "2" ] || { dump; fail "a token followed by further stdout must fail closed as rc=2, got rc=$rc"; }
+case "$out" in
+  *register_firing_path_terminal_missing*) : ;;
+  *) dump; fail "non-terminal token rejected, but not via the terminal-token contract" ;;
+esac
+pass "a token that is not the last stdout line fails closed"
+
+# ── RED: an undiagnosed non-zero rc is infra failure, not a ledger violation ─
+# A Ruby syntax error, an uncaught exception, and a silent `exit 1` all arrive
+# as rc=1. Forwarding that as rc=1 tells CI "the ledger is wrong" when the truth
+# is "the gate did not run" — and leaves no diagnosable cause in the log.
+printf '%s\n' '#!/usr/bin/env ruby' 'exit 1' > "$STUB_GATE"
+run_stub_check
+[ "$rc" = "2" ] || { dump; fail "a silent rc=1 must be re-tiered to rc=2, got rc=$rc"; }
+case "$out" in
+  *register_firing_path_gate_failed*) : ;;
+  *) dump; fail "silent rc=1 rejected, but not via the gate-failure tier" ;;
+esac
+pass "undiagnosed non-zero rc is re-tiered as gate failure, not a ledger violation"
+
+# GREEN control: a DIAGNOSED rc=1 must still pass through as a rule failure, so
+# the re-tiering above cannot be satisfied by mapping every failure to rc=2.
+printf '%s\n' '#!/usr/bin/env ruby' \
+  'warn "register_firing_path_unresolved: a recorded firing path no longer resolves"' \
+  'warn "  fixture-source.md:1: anchor text absent from target: file:demo#anchor"' \
+  'exit 1' > "$STUB_GATE"
+run_stub_check
+[ "$rc" = "1" ] || { dump; fail "a diagnosed ledger violation must stay rc=1, got rc=$rc"; }
+pass "diagnosed rc=1 still surfaces as a ledger violation"
+
+# ── RED: failing to create the capture directory is infra, not a violation ──
+# The checker cannot run the gate at all if it has nowhere to capture output.
+# An unchecked `mktemp` would exit with whatever status it happened to have —
+# typically 1, indistinguishable from an adjudicated ledger violation — so CI
+# would read "the ledger is wrong" when the truth is "the checker could not
+# start". A PATH shim fails only THIS mktemp so the rest of the checker keeps
+# its normal path; setting TMPDIR to a bad directory would instead trip an
+# earlier, unrelated mktemp and test nothing about this call site.
+REAL_MKTEMP="$(command -v mktemp)"
+[ -n "$REAL_MKTEMP" ] || fail "mktemp not found; cannot build the shim"
+SHIM_DIR="$TMP/shimbin"
+mkdir -p "$SHIM_DIR"
+{
+  echo '#!/usr/bin/env bash'
+  echo 'case "$*" in *firingpath*) echo "mktemp: shimmed failure" >&2; exit 1;; esac'
+  echo "exec $REAL_MKTEMP \"\$@\""
+} > "$SHIM_DIR/mktemp"
+chmod +x "$SHIM_DIR/mktemp"
+# Confirm the shim actually discriminates before trusting a RED it produces.
+PATH="$SHIM_DIR:$PATH" mktemp -d "${TMPDIR:-/tmp}/firingpath.XXXXXX" >/dev/null 2>&1 \
+  && fail "shim precondition failed: the firingpath template should have failed"
+shim_passthrough="$(PATH="$SHIM_DIR:$PATH" mktemp -d "${TMPDIR:-/tmp}/shimprobe.XXXXXX")" \
+  || fail "shim precondition failed: unrelated templates must still succeed"
+rm -rf "$shim_passthrough"
+
+# Restore the real gate: this case is about the checker's own capture setup.
+cp "$SCRIPT_DIR/register-firing-path-resolution.rb" "$STUB_GATE"
+set +e
+out="$(env -u CCL_SKILL_BASE_REF ALIAS_AUDIT_CMD='true' PATH="$SHIM_DIR:$PATH" bash "$STUB_CHECK" "$REPO" 2>&1)"
+rc=$?
+set -e
+[ "$rc" = "2" ] || { dump; fail "a failed capture-directory creation must fail closed as rc=2, got rc=$rc"; }
+case "$out" in
+  *register_firing_path_gate_failed*) : ;;
+  *) dump; fail "capture-setup failure rejected, but not via the gate-failure tier" ;;
+esac
+pass "capture-directory creation failure is reported as infrastructure, not a ledger violation"
+
+# ── RED: the digest-table seam must never yield a clean landing ─────────────
+# The injected table exists so a fixture can describe its own synthetic ledger,
+# but an injected table can only ever be weaker than the built-in one for the
+# real ledger. If the seam were silent, an inherited test environment would
+# disable the digest and missing-row layers on a real run and still report a
+# clean landing — the exact false-green shape this whole change exists to close.
+git -C "$REPO" checkout -- . >/dev/null 2>&1 || fail "could not restore the clone before the seam case"
+SEAM_TABLE="$TMP/injected-exempt-digests.json"
+printf '{}\n' > "$SEAM_TABLE"
+set +e
+out="$(env -u CCL_SKILL_BASE_REF ALIAS_AUDIT_CMD='true' \
+  REGISTER_FIRING_PATH_EXEMPT_DIGESTS="$SEAM_TABLE" bash "$CHECK_SCRIPT" "$REPO" 2>&1)"
+rc=$?
+set -e
+[ "$rc" = "0" ] || { dump; fail "an injected digest table is a downgrade, not a failure, got rc=$rc"; }
+case "$out" in
+  *ccl_skill_check_clean_ok*) dump; fail "a run with an injected EXEMPT digest table must not report a clean landing" ;;
+  *) : ;;
+esac
+case "$out" in
+  *ccl_skill_check_interim_ok*) : ;;
+  *) dump; fail "the injected-table run must end on the interim token" ;;
+esac
+case "$out" in
+  *register_firing_path_exempt_digests_injected*) : ;;
+  *) dump; fail "the gate must announce that its waiver-row bindings were replaced" ;;
+esac
+pass "injected EXEMPT digest table downgrades to interim instead of silently bypassing"
+
+# ── RED: a failure while the cleanup trap is armed must keep its status ─────
+# The narrow window between arming the temp-dir cleanup trap and disarming it.
+# `rm -rf` succeeds inside the trap and overwrites the pending exit status, so a
+# trap that does not save and restore `$?` first converts this block's rc=2 for
+# an unreadable capture into rc=0 — a failure reported as success.
+CAT_SHIM_DIR="$TMP/catshim"
+mkdir -p "$CAT_SHIM_DIR"
+REAL_CAT="$(command -v cat)"
+[ -n "$REAL_CAT" ] || fail "cat not found; cannot build the shim"
+{
+  echo '#!/usr/bin/env bash'
+  echo 'case "$*" in *firingpath*/out|*firingpath*/err) echo "cat: shimmed failure" >&2; exit 1;; esac'
+  echo "exec $REAL_CAT \"\$@\""
+} > "$CAT_SHIM_DIR/cat"
+chmod +x "$CAT_SHIM_DIR/cat"
+PATH="$CAT_SHIM_DIR:$PATH" cat /dev/null >/dev/null 2>&1 \
+  || fail "shim precondition failed: unrelated cat invocations must still work"
+
+git -C "$REPO" checkout -- . >/dev/null 2>&1 || fail "could not restore the clone before the trap-status case"
+cp "$SCRIPT_DIR/register-firing-path-resolution.rb" "$STUB_GATE"
+set +e
+out="$(env -u CCL_SKILL_BASE_REF ALIAS_AUDIT_CMD='true' PATH="$CAT_SHIM_DIR:$PATH" \
+  bash "$STUB_CHECK" "$REPO" 2>&1)"
+rc=$?
+set -e
+[ "$rc" = "2" ] || { dump; fail "an unreadable capture must keep its rc=2 through the cleanup trap, got rc=$rc"; }
+case "$out" in
+  *register_firing_path_gate_failed*) : ;;
+  *) dump; fail "capture read failure rejected, but not via the gate-failure tier" ;;
+esac
+pass "a failure inside the cleanup-trap window keeps its exit status"
+
+[ "$passed" -eq 14 ] || fail "expected 14 assertions, saw $passed"
+echo "register_firing_path_wiring_tests_ok ($passed assertions)"

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

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+# Guard: every test_*.sh in the extraction scripts/ dir must be registered in
+# test_check_ccl_regressions.sh's fast_tests/heavy_tests arrays, or CI
+# silently skips it — the false-green class that let test_validate_skill_credential_cwd.sh
+# ship unrun. This test asserts zero unregistered on the real repo (so a future
+# unwired test turns CI red), and proves the detector actually flags an
+# unregistered fixture (non-vacuous).
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+RUNNER="$SCRIPT_DIR/test_check_ccl_regressions.sh"
+[ -f "$RUNNER" ] || { echo "FAIL: runner not found: $RUNNER" >&2; exit 1; }
+fail() { echo "FAIL: $*" >&2; exit 1; }
+
+# (1) Real repo: no sibling test_*.sh is left out of the aggregate arrays.
+out="$(bash "$RUNNER" --list-unregistered)"
+[ -z "$out" ] || fail "test_*.sh not registered in fast_tests/heavy_tests (CI would not run them):\n$out"
+
+# (2) Non-vacuous: an unregistered fixture IS reported and a registered name is NOT.
+TMP="$(mktemp -d "${TMPDIR:-/tmp}/regreg.XXXXXX")"
+trap 'rm -rf "$TMP"' EXIT
+: > "$TMP/test_zzz_unregistered.sh"
+: > "$TMP/test_generic_r0_leak_scan.sh"   # a name that IS in fast_tests
+fout="$(REGRESSION_SCRIPTS_DIR="$TMP" bash "$RUNNER" --list-unregistered)"
+case "$fout" in
+  *test_zzz_unregistered.sh*) : ;;
+  *) fail "detector did not flag an unregistered fixture\n$fout" ;;
+esac
+case "$fout" in
+  *test_generic_r0_leak_scan.sh*) fail "detector wrongly flagged a registered test\n$fout" ;;
+  *) : ;;
+esac
+
+echo "test_regression_runner_registration: ok"

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

@@ -0,0 +1,205 @@
+#!/usr/bin/env bash
+# Structural contract test for the routing task bank (eval/routing-tasks.jsonl).
+#
+# SCOPE — read this before citing the lane as evidence. This test proves the
+# bank is well-formed and that every skill it names actually exists. It does
+# NOT route anything and therefore does NOT prove any fixture's expectation is
+# delivered: the behavioural grader (`eval-routing-bank.rb`) shells out to a
+# live `claude` CLI, so it is advisory Tier-2 and cannot be a deterministic CI
+# gate. A source-register row may cite THIS lane for "the fixture exists, is
+# well-formed, and its targets resolve" — never for "the fixture passes".
+#
+# What it catches (the gap it was written for): a fixture silently deleted,
+# an id collision, a typo'd or renamed target skill, a required provenance
+# field dropped, or a self-contradictory row. Before this lane existed, all of
+# those stayed green because the only registered routing lane checks literal
+# phrases in SKILL.md files and never opens the bank at all.
+set -u
+ROOT="${BANK_ROOT:-$(cd "$(dirname "$0")/../../.." && pwd)}"
+[ -n "${BANK_ROOT:-}" ] && echo "NOTICE: BANK_ROOT set — testing tree: $ROOT" >&2
+BANK="$ROOT/eval/routing-tasks.jsonl"
+
+if [ ! -f "$BANK" ]; then
+  echo "FAIL: task bank missing ($BANK)" >&2
+  exit 1
+fi
+
+python3 - "$ROOT" "$BANK" <<'PY'
+import json, os, sys
+
+root, bank = sys.argv[1], sys.argv[2]
+skills_dir = os.path.join(root, "skills")
+installed = {
+    name for name in os.listdir(skills_dir)
+    if os.path.isfile(os.path.join(skills_dir, name, "SKILL.md"))
+}
+
+# Universal fields, measured against the bank rather than assumed: all 113 rows
+# carry these five. `source` is present on only 37/113 and `added_by_change_sha`
+# on none, although docs/f4-skill-effectiveness-harness.md lists both as required
+# provenance — that doc-vs-bank drift is reported below, not failed, because
+# failing it would red-line ~76 pre-existing rows this change never touched.
+REQUIRED = ("id", "utterance", "expected_skill", "why_expected", "frozen_at_sha")
+fail = 0
+seen = {}
+rows = 0
+
+def bad(msg):
+    global fail
+    print(f"FAIL: {msg}", file=sys.stderr)
+    fail = 1
+
+with open(bank, encoding="utf-8") as fh:
+    for lineno, raw in enumerate(fh, 1):
+        raw = raw.strip()
+        if not raw:
+            continue
+        rows += 1
+        try:
+            row = json.loads(raw)
+        except json.JSONDecodeError as exc:
+            bad(f"line {lineno}: not valid JSON ({exc})")
+            continue
+
+        rid = row.get("id")
+        for field in REQUIRED:
+            if not row.get(field):
+                bad(f"line {lineno} ({rid}): missing/empty required field '{field}'")
+
+        if rid in seen:
+            bad(f"line {lineno}: duplicate id '{rid}' (first seen line {seen[rid]})")
+        elif rid:
+            seen[rid] = lineno
+
+        expected = row.get("expected_skill")
+        if expected and expected not in installed:
+            bad(f"line {lineno} ({rid}): expected_skill '{expected}' is not a skill in skills/")
+
+        must_not = row.get("must_not_route_to") or []
+        if not isinstance(must_not, list):
+            bad(f"line {lineno} ({rid}): must_not_route_to must be a list")
+            must_not = []
+        for target in must_not:
+            if target not in installed:
+                bad(f"line {lineno} ({rid}): must_not_route_to names '{target}', not a skill in skills/")
+            if target == expected:
+                bad(f"line {lineno} ({rid}): '{target}' is both expected_skill and must_not_route_to")
+
+# A truncated or emptied bank must fail rather than vacuously pass.
+MIN_ROWS = 100
+if rows < MIN_ROWS:
+    bad(f"bank has {rows} rows, expected at least {MIN_ROWS} (truncation guard)")
+
+# Row-count guards are too coarse to notice ONE deleted fixture (deleting one of
+# 113 still clears MIN_ROWS). Any fixture a source-register row cites as its
+# evidence is pinned by id here, so removing it turns this lane red instead of
+# silently invalidating the row that points at it. Add an id when a new register
+# row cites a new fixture, in the same diff.
+CITED_BY_REGISTER_ROWS = (
+    "miss-refactor-python-unqualified",
+    "miss-refactor-miniapp",
+    "route-python-cli-not-terminal",
+    "route-go-cli-not-terminal",
+    "route-cli-contract-design-not-stack",
+)
+for rid in CITED_BY_REGISTER_ROWS:
+    if rid not in seen:
+        bad(f"fixture '{rid}' is cited by a source-register row but is absent from the bank")
+
+# frozen_at_sha ancestry. docs/f4-skill-effectiveness-harness.md says the runner
+# validates this, but the runner needs a live model and no committed-time lane
+# checked it — so a fixture carrying a sha from an unrelated history (the "drift"
+# the field exists to catch) reached main unchallenged. Verified here instead.
+#
+# SEMANTICS, because two readers already read this field two different ways:
+# frozen_at_sha is an ANCESTRY/BATCH marker, not a claim that the expectation was
+# already deliverable at that commit. Fixtures that land together share the sha
+# of the branch point, so a fixture added ALONGSIDE the routing surface it
+# describes is correctly frozen at a commit where that surface does not yet
+# exist. Do not "fix" such a row by pointing it at a post-landing commit: branch
+# shas do not survive a squash merge, and a dangling sha reads as drift and
+# silently drops the fixture from regression judgement.
+import subprocess
+
+def git(*args):
+    return subprocess.run(("git", "-C", root) + args,
+                          capture_output=True, text=True)
+
+
+if git("rev-parse", "--git-dir").returncode != 0:
+    print("routing_bank_ancestry_info: not a git checkout — ancestry not verified")
+else:
+    # An unresolvable sha is tolerated ONLY where it is genuinely explainable:
+    # a shallow or partial clone that simply does not carry the object. In a
+    # COMPLETE checkout an unresolvable sha means the row points at a mistyped,
+    # dangling, or unrelated history — which is precisely the drift this check
+    # exists to catch, and the row would be silently dropped from regression
+    # judgement. Tolerating it unconditionally made the lane pass in exactly the
+    # case it was written for.
+    # Shallow detection: ONE signal, the `shallow` marker file. It is the ground
+    # truth `--is-shallow-repository` itself derives from, so pairing the two as
+    # "primary + fallback" is not redundancy — whichever is second is provably
+    # unreachable, and shipping an unreachable branch is how you get code that
+    # has never been observed to work. Verified both ways: deleting the marker
+    # makes the porcelain report false too.
+    #
+    # --git-COMMON-dir, not --git-dir: in a linked worktree --git-dir returns
+    # .git/worktrees/<name>, while `shallow` lives in the shared .git — probing
+    # the per-worktree dir silently finds nothing and reports every shallow
+    # worktree as a complete checkout.
+    common_dir = git("rev-parse", "--git-common-dir").stdout.strip()
+    shallow = False
+    if common_dir:
+        cd_abs = common_dir if os.path.isabs(common_dir) else os.path.join(root, common_dir)
+        shallow = os.path.isfile(os.path.join(cd_abs, "shallow"))
+    # Partial clone: git marks the PROMISOR REMOTE, whose name is not necessarily
+    # "origin" (`git clone -o upstream --filter=...`). Scan every remote, or a
+    # partial clone under any other remote name gets red-lined on every row.
+    # `extensions.partialClone` is the repository-level marker (it names the
+    # promisor remote) and survives a remote rename; the per-remote keys are the
+    # corroborating signal. Check both, under any remote name.
+    partial = bool(git("config", "--get", "extensions.partialClone").stdout.strip()) or \
+        bool(git("config", "--get-regexp",
+                 r"^remote\..*\.(promisor|partialclonefilter)$").stdout.strip())
+    # ONE decision point, deliberately hoisted out of the per-sha loop.
+    #
+    # This used to be consulted twice INSIDE the loop — once for an unresolvable
+    # object, once for a failed ancestry query — and both times I added a new
+    # failure mode while guarding only one of the two exits. A degraded clone
+    # cannot answer either question, so the honest structure is to decide once,
+    # up front, whether ancestry is answerable at all. Adding a third git query
+    # later cannot reintroduce the bug: there is no per-query tolerance to forget.
+    degraded = shallow or partial
+    if degraded:
+        kind = "shallow" if shallow else "partial"
+        print(f"routing_bank_ancestry_info: {kind} clone — ancestry NOT verified for any row "
+              f"(a complete checkout verifies every row and fails on drift)")
+    else:
+        for rid, sha in sorted({r.get("id"): r.get("frozen_at_sha") for r in
+                                [json.loads(l) for l in open(bank, encoding="utf-8") if l.strip()]}.items()):
+            if not sha:
+                continue  # empty/missing is already a required-field failure above
+            if sha == "root":
+                sha = git("rev-list", "--max-parents=0", "HEAD").stdout.splitlines()[0]
+            if git("cat-file", "-e", f"{sha}^{{commit}}").returncode != 0:
+                bad(f"({rid}): frozen_at_sha {sha[:12]} does not resolve to a commit in this "
+                    f"complete checkout (mistyped or from an unrelated history — the row would "
+                    f"be silently excluded from regression judgement)")
+                continue
+            if git("merge-base", "--is-ancestor", sha, "HEAD").returncode != 0:
+                bad(f"({rid}): frozen_at_sha {sha[:12]} is not an ancestor of HEAD (drift — the "
+                    f"row would be silently excluded from regression judgement)")
+        print(f"routing_bank_ancestry_ok: {rows} row(s) verified against HEAD")
+
+if fail:
+    sys.exit(1)
+
+# Informational: provenance coverage the harness doc asks for but the bank does
+# not yet carry. Reported so the drift stays visible without blocking.
+with open(bank, encoding="utf-8") as fh:
+    parsed = [json.loads(l) for l in fh if l.strip()]
+with_source = sum(1 for r in parsed if r.get("source"))
+print(f"routing_bank_provenance_info: source present on {with_source}/{rows} rows "
+      f"(docs/f4-skill-effectiveness-harness.md lists it as required; not enforced here)")
+print(f"routing_bank_integrity_ok rows={rows} (structure only — routing NOT evaluated)")
+PY