@ccoalm/ccl-skills 0.13.0 → 0.15.0

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

@@ -0,0 +1,253 @@
+#!/usr/bin/env bash
+# Regression test for the bank runner's screening-vs-action resolution signal.
+#
+# A report taken below the action floor locates candidates; it does not license
+# a description edit. The runner says so on stdout and in the JSON report, and
+# this test pins BOTH sides of the number — the reference that states the rule
+# and the executable that enforces it — so they cannot drift apart the way the
+# description-length thresholds once did.
+#
+# Uses a fake `claude` earlier in PATH: never invokes a real CLI or account.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+EVAL_SCRIPT="$SCRIPT_DIR/eval-routing-bank.rb"
+DOC="$SCRIPT_DIR/../references/eval-routing.md"
+[ -f "$EVAL_SCRIPT" ] || { echo "FAIL: eval script not found: $EVAL_SCRIPT" >&2; exit 1; }
+[ -f "$DOC" ] || { echo "FAIL: reference not found: $DOC" >&2; exit 1; }
+
+fail() { echo "FAIL: $*" >&2; exit 1; }
+assert_contains() { case "$2" in *"$1"*) : ;; *) fail "expected output to contain: $1${3:+ ($3)}";; esac; }
+assert_absent() { case "$2" in *"$1"*) fail "expected output NOT to contain: $1${3:+ ($3)}";; *) : ;; esac; }
+
+TMP="$(mktemp -d "${TMPDIR:-/tmp}/eval-routing-bank-resolution.XXXXXX")"
+trap 'rm -rf "$TMP"' EXIT
+
+REPO="$TMP/repo"
+FAKE_BIN="$TMP/bin"
+mkdir -p "$REPO/skills/testing-strategy" "$REPO/skills/tighten-doc" "$REPO/eval" "$FAKE_BIN"
+
+git -C "$TMP" init -q repo
+git -C "$REPO" config user.email test@example.invalid
+git -C "$REPO" config user.name "Test User"
+
+cat > "$REPO/skills/testing-strategy/SKILL.md" <<'EOF'
+---
+description: Use when choosing test layers and regression evidence.
+---
+# Testing Strategy
+EOF
+
+# Keeps the outcome space larger than {expected, none} so the fixture is not
+# vacuous: a grader that always answered the only skill would pass trivially.
+cat > "$REPO/skills/tighten-doc/SKILL.md" <<'EOF'
+---
+description: Use when polishing document wording.
+---
+# Tighten Doc
+EOF
+
+# TWO cases, deliberately: with one case a per-case verdict and a report-wide
+# conjunction are indistinguishable, so every assertion below would also pass
+# against the defect they exist to catch. The degraded fixture fails only the
+# first utterance, which leaves one case short of the floor and one clear of it.
+cat > "$REPO/eval/routing-tasks.jsonl" <<'EOF'
+{"id":"resolution-fixture","utterance":"补一个回归测试","expected_skill":"testing-strategy","frozen_at_sha":""}
+{"id":"resolution-fixture-b","utterance":"帮我润色这段文档","expected_skill":"tighten-doc","frozen_at_sha":""}
+EOF
+
+git -C "$REPO" add -A
+git -C "$REPO" commit -qm "fixture"
+
+cat > "$FAKE_BIN/claude" <<'EOF'
+#!/usr/bin/env bash
+prompt="$(cat)"
+case "$prompt" in
+  *润色*) printf '{"selected_skill":"tighten-doc","clarify":false,"confidence":0.9,"rationale_short":"fixture"}\n' ;;
+  *)      printf '{"selected_skill":"testing-strategy","clarify":false,"confidence":0.9,"rationale_short":"fixture"}\n' ;;
+esac
+EOF
+chmod +x "$FAKE_BIN/claude"
+export PATH="$FAKE_BIN:$PATH"
+
+# --- (1) below the floor: banner printed, report says action_resolution false --
+out_lo="$(ruby "$EVAL_SCRIPT" "$REPO" --replicas 3 --json "$TMP/lo.json" 2>&1)" \
+  || fail "runner exited non-zero below the floor:\n$out_lo"
+assert_contains "screening_resolution_only" "$out_lo" "sub-floor run must announce screening resolution"
+assert_contains "replicas=3" "$out_lo" "banner must name the observed replica count"
+assert_contains "floor 10" "$out_lo" "banner must name the required floor"
+assert_contains "valid observations" "$out_lo" "banner must report the weakest task's valid-observation count, not the request alone"
+grep -q '"action_resolution": false' "$TMP/lo.json" \
+  || fail "sub-floor report must carry action_resolution:false — a consumer cannot read a printed banner"
+
+# --- (2) at the floor: no banner, report says action_resolution true -----------
+out_hi="$(ruby "$EVAL_SCRIPT" "$REPO" --replicas 10 --json "$TMP/hi.json" 2>&1)" \
+  || fail "runner exited non-zero at the floor:\n$out_hi"
+assert_absent "screening_resolution_only" "$out_hi" "a run at the floor must not be labelled screening-only"
+grep -q '"action_resolution": true' "$TMP/hi.json" \
+  || fail "at-floor report must carry action_resolution:true"
+
+# --- (2b) a nominal at-floor run with an invalid observation is NOT actionable -
+# The floor is on valid observations. A grader that fails one call leaves the
+# task below the floor while `--replicas` still reads 10, and a report that
+# trusted the request would license an edit its evidence cannot support.
+# The runner gives each unparsable verdict ONE retry, treating it as a sampling
+# accident, so a fixture that fails a single call is repaired and records no
+# error. The failure has to persist across the retry to leave the task short of
+# the floor -- which is exactly the real shape this guards: a grader that is
+# reliably unable to answer one utterance, not a stray quote.
+cat > "$FAKE_BIN/claude" <<'EOF'
+#!/usr/bin/env bash
+prompt="$(cat)"
+case "$prompt" in
+  *润色*) printf '{"selected_skill":"tighten-doc","clarify":false,"confidence":0.9,"rationale_short":"fixture"}\n'; exit 0 ;;
+esac
+echo x >> "$RESOLUTION_COUNT_FILE"
+n=$(wc -l < "$RESOLUTION_COUNT_FILE" | tr -d ' ')
+if [ "$n" = "3" ] || [ "$n" = "4" ]; then printf 'not json at all\n'; exit 0; fi
+printf '{"selected_skill":"testing-strategy","clarify":false,"confidence":0.9,"rationale_short":"fixture"}\n'
+EOF
+chmod +x "$FAKE_BIN/claude"
+: > "$TMP/count"
+out_deg="$(RESOLUTION_COUNT_FILE="$TMP/count" ruby "$EVAL_SCRIPT" "$REPO" --replicas 10 --json "$TMP/deg.json" 2>&1)" \
+  || fail "runner exited non-zero on the degraded run:\n$out_deg"
+assert_contains "screening_resolution_only" "$out_deg" "a nominal 10-replica run with an invalid observation must not be actionable"
+grep -q '"action_resolution": false' "$TMP/deg.json" \
+  || fail "a 10-replica run with only 9 valid observations must report action_resolution:false"
+grep -q '"min_valid_observations": 9' "$TMP/deg.json" \
+  || fail "the report must expose the weakest task's valid-observation count"
+
+# --- (2c) the verdict is per case, and says nothing about a case not measured --
+# A report-wide boolean alone is unsound in the licensing direction: a subset run
+# over one case would otherwise read as licence for an edit to a case the run
+# never graded. Each result carries its own actionable and valid_observations.
+grep -q '"actionable": true' "$TMP/hi.json" \
+  || fail "an at-floor case must carry its own actionable:true"
+grep -q '"valid_observations": 10' "$TMP/hi.json" \
+  || fail "each case must expose its own valid-observation count"
+grep -q '"action_resolution_scope"' "$TMP/hi.json" \
+  || fail "the report must say its top-level verdict covers only the cases it measured"
+grep -q '"actionable": false' "$TMP/deg.json" \
+  || fail "a case left short by an invalid observation must carry actionable:false"
+# The split is the point: the degraded case is short, the other one is not, and a
+# report-wide conjunction substituted for the per-case field would mark both false.
+python3 - "$TMP/deg.json" <<'PYEOF' || fail "the healthy case must stay actionable while the degraded one does not"
+import json,sys
+d=json.load(open(sys.argv[1]))
+by={r["id"]:r for r in d["results"]}
+ok = (by["resolution-fixture"]["actionable"] is False
+      and by["resolution-fixture-b"]["actionable"] is True
+      and by["resolution-fixture-b"]["valid_observations"] == 10
+      and d["action_resolution"] is False)
+sys.exit(0 if ok else 1)
+PYEOF
+
+# --- (2d) shapes where a result could carry no usable verdict at all ----------
+# The resolution loop reads every result's verdict list. Review could not check
+# from the bounded packet that a list is always present, so the shapes that would
+# expose an absent one are pinned here: a single-replica run, and a task whose
+# every replica fails. Neither may crash, and neither may report itself
+# actionable.
+: > "$TMP/count"
+out_one="$(RESOLUTION_COUNT_FILE="$TMP/count" ruby "$EVAL_SCRIPT" "$REPO" --replicas 1 --json "$TMP/one.json" 2>&1)" \
+  || fail "runner exited non-zero on a single-replica run:\n$out_one"
+grep -q '"action_resolution": false' "$TMP/one.json" \
+  || fail "a single-replica run is below the floor and must not be actionable"
+python3 - "$TMP/one.json" <<'PYEOF' || fail "every result of a single-replica run must carry its own verdict list and count"
+import json,sys
+d=json.load(open(sys.argv[1]))
+ok = bool(d["results"]) and all(
+    isinstance(r.get("verdicts"), list) and len(r["verdicts"]) == 1
+    and r["valid_observations"] <= 1 and r["actionable"] is False
+    for r in d["results"])
+sys.exit(0 if ok else 1)
+PYEOF
+
+cat > "$FAKE_BIN/claude" <<'EOF'
+#!/usr/bin/env bash
+cat >/dev/null
+printf 'never json\n'
+EOF
+chmod +x "$FAKE_BIN/claude"
+# Every task fails every replica: the runner reports the wholly-unmeasured run and
+# exits 3 by its documented contract, and the report must still be well formed.
+# `set -e` would kill the suite on the non-zero exit before it could be read, so
+# the status is captured in the same command that produces it.
+rc=0
+ruby "$EVAL_SCRIPT" "$REPO" --replicas 2 --json "$TMP/allfail.json" >/dev/null 2>&1 || rc=$?
+[ "$rc" = "3" ] || fail "a wholly failed run must exit 3 by the runner's contract, got $rc"
+python3 - "$TMP/allfail.json" <<'PYEOF' || fail "a wholly failed run must still report zero valid observations and no actionable case"
+import json,sys
+d=json.load(open(sys.argv[1]))
+ok = bool(d["results"]) and d["action_resolution"] is False and d["min_valid_observations"] == 0 \
+     and all(r["valid_observations"] == 0 and r["actionable"] is False and isinstance(r["verdicts"], list)
+             for r in d["results"])
+sys.exit(0 if ok else 1)
+PYEOF
+
+# --- (2e) a parseable answer naming no catalog skill is not an observation ------
+# Review could not see from the packet whether a well-formed JSON verdict whose
+# selected_skill is not in the catalog counts toward the floor. It must not: it
+# is absence of evidence, not evidence against the route, so it is an ERROR
+# verdict and the case it belongs to stays short of the floor.
+cat > "$FAKE_BIN/claude" <<'EOF'
+#!/usr/bin/env bash
+cat >/dev/null
+printf '{"selected_skill":"skill-that-does-not-exist","clarify":false,"confidence":0.9,"rationale_short":"fixture"}\n'
+EOF
+chmod +x "$FAKE_BIN/claude"
+rc=0
+ruby "$EVAL_SCRIPT" "$REPO" --replicas 10 --json "$TMP/badsel.json" >/dev/null 2>&1 || rc=$?
+python3 - "$TMP/badsel.json" <<'PYEOF' || fail "a parseable verdict naming a non-catalog skill must count as an error, not a usable observation"
+import json,sys
+d=json.load(open(sys.argv[1]))
+ok = d["action_resolution"] is False and d["min_valid_observations"] == 0 \
+     and all(r["valid_observations"] == 0 and r["actionable"] is False for r in d["results"]) \
+     and all(v["status"] == "ERROR" for r in d["results"] for v in r["verdicts"])
+sys.exit(0 if ok else 1)
+PYEOF
+
+# --- (2f) a skill the prompt never offered is not selectable ---------------------
+# A directory with a SKILL.md but no usable description is filtered out of the
+# prompt catalog. If the selectable-name list were built separately it could still
+# admit that name, and a verdict naming it would count. Both must come from one
+# filtered list, so selecting the unoffered skill is an ERROR like any other
+# non-catalog name.
+mkdir -p "$REPO/skills/ghost-skill"
+printf -- '---\ndescription: ""\n---\n# Ghost\n' > "$REPO/skills/ghost-skill/SKILL.md"
+git -C "$REPO" add -A && git -C "$REPO" commit -qm "ghost skill with empty description"
+cat > "$FAKE_BIN/claude" <<'EOF'
+#!/usr/bin/env bash
+cat >/dev/null
+printf '{"selected_skill":"ghost-skill","clarify":false,"confidence":0.9,"rationale_short":"fixture"}\n'
+EOF
+chmod +x "$FAKE_BIN/claude"
+rc=0
+ruby "$EVAL_SCRIPT" "$REPO" --replicas 10 --json "$TMP/ghost.json" >/dev/null 2>&1 || rc=$?
+python3 - "$TMP/ghost.json" <<'PYEOF' || fail "a verdict naming a skill the prompt never offered must be an error, not a usable observation"
+import json,sys
+d=json.load(open(sys.argv[1]))
+ok = d["action_resolution"] is False and all(v["status"]=="ERROR" for r in d["results"] for v in r["verdicts"])
+sys.exit(0 if ok else 1)
+PYEOF
+
+# --- (3) the two sides of the number must agree -------------------------------
+# The rule is only as good as the agreement between the reference that states it
+# and the executable that enforces it. Compare the numbers themselves rather
+# than pinning one literal in two places.
+exe_min="$(grep -oE 'ACTION_RESOLUTION_MIN_REPLICAS = [0-9]+' "$EVAL_SCRIPT" | grep -oE '[0-9]+$' | sort -u)"
+[ -n "$exe_min" ] || fail "could not read ACTION_RESOLUTION_MIN_REPLICAS from $EVAL_SCRIPT"
+[ "$(printf '%s\n' "$exe_min" | wc -l | tr -d ' ')" = "1" ] \
+  || fail "ACTION_RESOLUTION_MIN_REPLICAS is defined with more than one value: $exe_min"
+doc_min="$(grep -oE 'replicas < [0-9]+' "$DOC" | grep -oE '[0-9]+$' | sort -u)"
+[ -n "$doc_min" ] || fail "$DOC does not state the replicas floor as \`replicas < N\`"
+[ "$doc_min" = "$exe_min" ] \
+  || fail "doc states floor $doc_min but the runner enforces $exe_min — they must be one number"
+
+# The prose obligation (">=N valid observations before acting") must name the
+# same number too, so a reader following the sentence and a consumer reading the
+# report are held to one bar.
+grep -qF "≥${exe_min} 个有效观测" "$DOC" \
+  || fail "$DOC must state the per-case obligation with the same floor (≥${exe_min} 个有效观测)"
+
+echo "PASS: eval-routing-bank resolution signal (banner, report field, doc/executor agreement)"

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

@@ -139,28 +139,52 @@ git -C "$REPO_ROOT" show "$BASELINE_GATE_COMMIT:$GATE_PATH" > "$BASELINE_GATE" 2
   exit 1
 }
 
-# EXPECTED DIVERGENCES. Four landings back-filled a ledger row by corrective
-# rewrite — the repair for a round that merged with this gate red — so the owner
-# change sits below their base and the row cites an owner the range does not
-# touch. The candidate refuses that shape by design and deliberately offers no
-# author-declared escape, so these four historical ranges diverge. The gate is
-# diff-scoped and never re-judges landed history, so nothing operational depends
-# on them; this differential is the only thing that replays them.
+# EXPECTED DIVERGENCES, two named classes, both "newly refused".
 #
-# Each exemption is constrained to ONE direction and ONE diagnostic. A blanket
-# "any mismatch at this SHA is fine" would also swallow the opposite direction —
-# a loosening — which is the failure this whole suite exists to catch. Entries are
-# named individually, never matched by pattern, and an entry that stops diverging
-# is reported as stale rather than tolerated.
-EXPECTED_DIVERGENCE_SHAS="f03b1140f 93d09c563 9f233728a 046612652"
-EXPECTED_DIVERGENCE_DIRECTION="newly refused"
-EXPECTED_DIVERGENCE_TOKEN="impact_chain_row_vouches_for_unchanged_owner"
-expected_divergence() { # <full sha> <direction> <candidate output>
-  local short="${1:0:9}" direction="$2" out="$3" known
-  [ "$direction" = "$EXPECTED_DIVERGENCE_DIRECTION" ] || return 1
-  case "$out" in *"$EXPECTED_DIVERGENCE_TOKEN"*) : ;; *) return 1 ;; esac
-  for known in $EXPECTED_DIVERGENCE_SHAS; do
-    [ "$known" = "$short" ] && return 0
+# `impact_chain_row_vouches_for_unchanged_owner` (four points): landings that
+# back-filled a ledger row by corrective rewrite — the repair for a round that
+# merged with this gate red — so the owner change sits below their base and the
+# row cites an owner the range does not touch. The candidate refuses that shape by
+# design and deliberately offers no author-declared escape.
+#
+# `impact_chain_gate_missing` (six points): merges from before CI judged the
+# branch head (register row on the checkout ref binding, 2026-08-25). The gate now
+# expands a merge git rebuilds from its parents into the branch's own rounds, so a
+# merge is judged exactly as its branch was; these six branches carry owner work
+# outside the round that declares it (a row appended before the work, or work
+# after the last append) and the baseline accepted them only through the
+# collapsed merged view, which no longer exists as a distinct verdict. Three of
+# the six are refused on their own branch head by the baseline gate too; the other
+# three are promotions or syncs whose second parent is the integration branch,
+# where the same shapes sit one merge deeper.
+#
+# The gate is diff-scoped and never re-judges landed history, so nothing
+# operational depends on these points; this differential is the only thing that
+# replays them. Each entry is constrained to ONE direction and ONE diagnostic. A
+# blanket "any mismatch at this SHA is fine" would also swallow the opposite
+# direction — a loosening — which is the failure this whole suite exists to
+# catch. Entries are named individually, never matched by pattern, and an entry
+# that stops diverging is reported as stale rather than tolerated.
+EXPECTED_DIVERGENCES="
+f03b1140f:refused:impact_chain_row_vouches_for_unchanged_owner
+93d09c563:refused:impact_chain_row_vouches_for_unchanged_owner
+9f233728a:refused:impact_chain_row_vouches_for_unchanged_owner
+046612652:refused:impact_chain_row_vouches_for_unchanged_owner
+b9de13869:refused:impact_chain_gate_missing
+8cea35e6d:refused:impact_chain_gate_missing
+95f06b2e6:refused:impact_chain_gate_missing
+c0561c74e:refused:impact_chain_gate_missing
+fad480296:refused:impact_chain_gate_missing
+90ec533e1:refused:impact_chain_gate_missing
+"
+expected_divergence() { # <full sha> <direction> <candidate output>; prints the matched token
+  local short="${1:0:9}" direction="$2" out="$3" entry sha dir token
+  case "$direction" in "newly refused") direction=refused ;; "newly accepted") direction=accepted ;; esac
+  for entry in $EXPECTED_DIVERGENCES; do
+    sha="${entry%%:*}"; token="${entry##*:}"; dir="${entry#*:}"; dir="${dir%%:*}"
+    [ "$sha" = "$short" ] || continue
+    [ "$dir" = "$direction" ] || return 1
+    case "$out" in *"$token"*) printf '%s' "$token"; return 0 ;; *) return 1 ;; esac
   done
   return 1
 }
@@ -170,7 +194,7 @@ expected_divergence() { # <full sha> <direction> <candidate output>
 # them, so the exemptions are stale and the run would pass while silently failing
 # the staleness check it never reaches.
 if cmp -s "$BASELINE_GATE" "$CANDIDATE_GATE"; then
-  if [ -n "$(printf '%s' "$EXPECTED_DIVERGENCE_SHAS" | tr -d '[:space:]')" ]; then
+  if [ -n "$(printf '%s' "$EXPECTED_DIVERGENCES" | tr -d '[:space:]')" ]; then
     echo "FAIL: baseline and candidate are byte-identical, yet expected divergences are configured" >&2
     echo "      identical gates cannot diverge — the exemptions are stale and must be removed" >&2
     exit 1
@@ -261,8 +285,8 @@ for point in $INTEGRATION_POINTS; do
     direction="newly accepted"
   fi
   if [ -n "$direction" ]; then
-    if expected_divergence "$point" "$direction" "$candidate_out"; then
-      flag="  (expected divergence: corrective-rewrite back-fill, $direction)"
+    if matched_token="$(expected_divergence "$point" "$direction" "$candidate_out")"; then
+      flag="  (expected divergence: $matched_token, $direction)"
       expected_seen=$((expected_seen + 1))
     else
       flag="  <== VERDICT MISMATCH: $direction"
@@ -412,7 +436,7 @@ if [ "$total_failures" -gt 0 ]; then
 fi
 # An expected divergence that stops diverging means the exemption is stale and
 # should be removed, so it is reported rather than silently tolerated.
-expected_total="$(for e in $EXPECTED_DIVERGENCE_SHAS; do echo "$e"; done | wc -l | tr -d ' ')"
+expected_total="$(for e in $EXPECTED_DIVERGENCES; do echo "$e"; done | wc -l | tr -d ' ')"
 if [ "$expected_seen" != "$expected_total" ]; then
   echo "FAIL: $expected_seen of $expected_total expected divergences actually diverged" >&2
   echo "      an exemption that no longer fires is stale — remove it" >&2

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

@@ -0,0 +1,209 @@
+#!/usr/bin/env bash
+# Regression for reference-access-census.sh: synthetic transcripts only, no
+# host logs are read. Proves (1) per-file session counts and the touching
+# denominator, (2) the unevaluated sentinel when no transcript exists (never a
+# zero table), (3) the privacy contract — output carries no transcript text,
+# no absolute log path, no session id, (2b) input errors (an unreadable
+# transcript) withhold the table with exit 2 instead of printing zeros or the ok
+# token, (4) usage errors exit 2, and (5) the
+# ARG_MAX regression: a candidate set larger than one xargs batch still counts
+# (the first version silently reported 0 on a large window).
+set -euo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CENSUS="$HERE/reference-access-census.sh"
+TMP="$(mktemp -d)"; trap 'rm -rf "$TMP"' EXIT
+fail() { echo "FAIL: $*" >&2; exit 1; }
+
+# --- fixture repo: one skill package with an entrypoint and three references ---
+REPO="$TMP/repo"; mkdir -p "$REPO/skills/demo-skill/references"
+git -C "$TMP" init -q repo 2>/dev/null || git init -q "$REPO"
+printf '# demo\n' > "$REPO/skills/demo-skill/SKILL.md"
+for r in alpha beta gamma; do printf '# %s\n' "$r" > "$REPO/skills/demo-skill/references/$r.md"; done
+git -C "$REPO" add -A && git -C "$REPO" -c user.email=t@t -c user.name=t commit -qm fixture
+
+# --- fixture transcripts: two log roots, distinct mention shapes ---
+LOGS="$TMP/logs-claude"; mkdir -p "$LOGS/proj-a" "$TMP/logs-codex/2026/09"
+SECRET_PROMPT="user-private-prompt-text-7f3a"
+SESSION_ID="session-9c1e2d3b-secret"
+# session 1 (claude shape): reads alpha and beta via a Read tool call
+printf '{"type":"tool_use","name":"Read","input":{"file_path":"/abs/checkout/skills/demo-skill/references/alpha.md"},"prompt":"%s","session":"%s"}\n' "$SECRET_PROMPT" "$SESSION_ID" > "$LOGS/proj-a/one.jsonl"
+printf '{"type":"tool_use","name":"Read","input":{"file_path":"/abs/checkout/skills/demo-skill/references/beta.md"}}\n' >> "$LOGS/proj-a/one.jsonl"
+# session 2 (codex shape): shell command mentioning alpha twice (must count once)
+printf '{"cmd":"sed -n 1,40p skills/demo-skill/references/alpha.md && cat skills/demo-skill/references/alpha.md"}\n' > "$TMP/logs-codex/2026/09/rollout-two.jsonl"
+# session 3: touches the package (SKILL.md) but no reference
+printf '{"cmd":"cat skills/demo-skill/SKILL.md"}\n' > "$TMP/logs-codex/2026/09/rollout-three.jsonl"
+# session 4: unrelated transcript (must not count as touching)
+printf '{"cmd":"ls skills/other-skill/"}\n' > "$LOGS/proj-a/four.jsonl"
+
+# deterministic, differing mtimes so the last_touched column can be asserted exactly (newest wins)
+touch -t "$(date -v-3d +%Y%m%d%H%M 2>/dev/null || date -d '3 days ago' +%Y%m%d%H%M)" "$LOGS/proj-a/one.jsonl"
+touch -t "$(date -v-1d +%Y%m%d%H%M 2>/dev/null || date -d '1 day ago' +%Y%m%d%H%M)" "$TMP/logs-codex/2026/09/rollout-two.jsonl"
+NEWEST="$(date -v-1d +%Y-%m-%d 2>/dev/null || date -d '1 day ago' +%Y-%m-%d)"
+OLDER="$(date -v-3d +%Y-%m-%d 2>/dev/null || date -d '3 days ago' +%Y-%m-%d)"
+# a stale transcript (older than the window) that mentions tracked files must not move any count, share, or date
+printf '{"cmd":"cat skills/demo-skill/references/alpha.md skills/demo-skill/references/gamma.md"}\n' > "$LOGS/proj-a/stale.jsonl"
+touch -t "$(date -v-45d +%Y%m%d%H%M 2>/dev/null || date -d '45 days ago' +%Y%m%d%H%M)" "$LOGS/proj-a/stale.jsonl"
+run() { bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$LOGS,$TMP/logs-codex"; }
+out="$(run)" || fail "census exited non-zero on a valid fixture"
+
+# (1) counts and denominator
+printf '%s\n' "$out" | grep -qF 'transcripts=4 sessions_touching_package=3' || fail "denominator wrong:\n$out"
+printf '%s\n' "$out" | grep -qF "references/alpha.md | 2 | $NEWEST | 66%" || fail "alpha should count 2 sessions with the newest touching date $NEWEST:\n$out"
+printf '%s\n' "$out" | grep -qF "references/beta.md | 1 | $OLDER | 33%" || fail "beta should count 1 session dated $OLDER:\n$out"
+printf '%s\n' "$out" | grep -qE '^references/gamma\.md \| 0 \| - \| 0%' || fail "gamma should count 0 with no date:\n$out"
+printf '%s\n' "$out" | grep -qE '^SKILL\.md \| 1 \|' || fail "SKILL.md should count 1 session:\n$out"
+[ "$(printf '%s\n' "$out" | tail -1)" = "reference_access_census_ok" ] || fail "last token must be the ok marker"
+
+# (3) privacy contract
+printf '%s\n' "$out" | grep -qF "$SECRET_PROMPT" && fail "transcript text leaked into census output"
+printf '%s\n' "$out" | grep -qF "$SESSION_ID" && fail "session id leaked into census output"
+printf '%s\n' "$out" | grep -qF "$LOGS" && fail "absolute log path leaked into census output"
+printf '%s\n' "$out" | grep -qF "/abs/checkout" && fail "absolute checkout path leaked into census output"
+
+# (2) unevaluated sentinel: no transcripts at all
+EMPTY="$TMP/empty-logs"; mkdir -p "$EMPTY"
+eout="$(bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$EMPTY")" || fail "empty-log run must exit 0"
+[ "$(printf '%s\n' "$eout" | tail -1)" = "reference_access_census_unevaluated: no transcripts within 30d under 1 log root(s); counts withheld" ] || fail "missing unevaluated sentinel:\n$eout"
+printf '%s\n' "$eout" | grep -qE '\| 0 \|' && fail "an unevaluated run must not print a zero table"
+printf '%s\n' "$eout" | grep -qF "$EMPTY" && fail "unevaluated sentinel leaked the log root path"
+printf '%s\n' "$eout" | grep -qF "$TMP" && fail "unevaluated sentinel leaked an absolute path"
+
+# (2b) input errors withhold the table: an unreadable transcript is exit 2 + unevaluated, never zeros or ok
+UNREAD="$TMP/logs-unreadable"; mkdir -p "$UNREAD"
+printf '{"cmd":"cat skills/demo-skill/references/alpha.md"}\n' > "$UNREAD/readable.jsonl"
+printf '{"cmd":"cat skills/demo-skill/references/beta.md"}\n' > "$UNREAD/locked.jsonl"
+chmod 000 "$UNREAD/locked.jsonl"
+if [ -r "$UNREAD/locked.jsonl" ]; then
+  echo "note: chmod 000 is readable here (root); skipping the unreadable-input leg"
+else
+  uout="$(bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$UNREAD" 2>"$TMP/unread.stderr")" && fail "unreadable transcript must exit non-zero"
+  urc=$?
+  uout="$(bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$UNREAD" 2>/dev/null || true)"
+  bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$UNREAD" >/dev/null 2>&1 || [ $? -eq 2 ] || fail "unreadable transcript must exit 2"
+  printf '%s\n' "$uout" | grep -qE 'reference_access_census_unevaluated: [0-9]+ input error\(s\)' || fail "unreadable transcript must withhold counts as unevaluated:\n$uout"
+  printf '%s\n' "$uout" | grep -qF 'reference_access_census_ok' && fail "ok token printed after an input error"
+  printf '%s\n' "$uout" | grep -qE '\| [0-9]+ \|' && fail "a table was printed after an input error"
+  printf '%s\n' "$uout" | grep -qF "$UNREAD" && fail "input-error sentinel leaked the log path"
+fi
+chmod 644 "$UNREAD/locked.jsonl"
+
+# (4) usage errors exit 2
+if bash "$CENSUS" --repo-root "$REPO" --skill no-such-skill --logs "$LOGS" >/dev/null 2>&1; then fail "unknown skill must exit 2"; fi
+bash "$CENSUS" --repo-root "$REPO" --skill no-such-skill --logs "$LOGS" >/dev/null 2>&1 || [ $? -eq 2 ] || fail "unknown skill must exit 2 exactly"
+bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days abc --logs "$LOGS" >/dev/null 2>&1 || [ $? -eq 2 ] || fail "non-integer --days must exit 2"
+
+# (5) ARG_MAX regression: the candidate path list must exceed THIS host's exec limit
+# (getconf ARG_MAX) so that a `$(cat candidates)` expansion — the first version's shape,
+# which silently reported 0 on a real 60-day window — cannot fit in one exec. The fixture
+# size is derived from the limit, never a fixed byte figure; a host whose limit exceeds the
+# fixture bound runs only the counting leg and says so. Verified RED by applying that exact
+# mutation to a disposable copy of the script.
+DPAD=""; i=0; while [ $i -lt 150 ]; do DPAD="${DPAD}d"; i=$((i+1)); done
+BIG="$TMP/logs-big/$DPAD"; mkdir -p "$BIG"
+PAD=""; i=0; while [ $i -lt 40 ]; do PAD="${PAD}x"; i=$((i+1)); done
+arg_max="$(getconf ARG_MAX 2>/dev/null || echo 2097152)"
+per_path=$(( ${#BIG} + 60 ))
+need=$(( (arg_max + 262144) / per_path + 1 ))
+[ "$need" -lt 11000 ] && need=11000
+probe=1
+if [ "$need" -gt 60000 ]; then
+  echo "note: ARG_MAX=$arg_max would need $need fixture files; the E2BIG probe is skipped on this host and only the counting leg runs"
+  need=11000; probe=0
+fi
+( cd "$BIG" && i=1; while [ $i -le $need ]; do : > "s$i-$PAD.jsonl"; i=$((i+1)); done )
+find "$BIG" -type f -name '*.jsonl' > "$TMP/big-list"
+inv_bytes=$(wc -c < "$TMP/big-list" | tr -d ' ')
+if [ "$probe" -eq 1 ]; then
+  erc=0; bash -c 'grep -lF "skills/demo-skill/" $(cat "$1") >/dev/null 2>&1' _ "$TMP/big-list" 2>"$TMP/e2big.err" || erc=$?
+  [ "$erc" -eq 126 ] || grep -qi "argument list too long" "$TMP/e2big.err" || fail "ARG_MAX fixture ($inv_bytes bytes, ARG_MAX=$arg_max) does not exceed this host's exec limit (rc=$erc), so the leg cannot kill the single-exec mutation"
+fi
+for i in 7 5208 10999; do printf '{"cmd":"cat skills/demo-skill/references/gamma.md"}\n' > "$BIG/s$i-$PAD.jsonl"; done
+bout="$(bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$BIG")" || fail "big run exited non-zero"
+printf '%s\n' "$bout" | grep -qF "transcripts=$need sessions_touching_package=3" || fail "large candidate set miscounted (ARG_MAX regression):\n$bout"
+printf '%s\n' "$bout" | grep -qE '^references/gamma\.md \| 3 \|' || fail "gamma should count 3 across xargs batches:\n$bout"
+
+# (6) a flag without its value is a usage error (exit 2), not an unbound-variable abort
+bash "$CENSUS" --repo-root "$REPO" --skill >/dev/null 2>&1 || [ $? -eq 2 ] || fail "flag without value must exit 2"
+
+# (7) an unknown argument never echoes its value (an absolute path passed by mistake stays private)
+uerr="$(bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --logs "$LOGS" "/private/mistyped/path" 2>&1 >/dev/null || true)"
+bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --logs "$LOGS" "/private/mistyped/path" >/dev/null 2>&1 || [ $? -eq 2 ] || fail "unknown argument must exit 2"
+printf '%s\n' "$uerr" | grep -qF "/private/mistyped/path" && fail "unknown-argument error echoed the caller's value"
+printf '%s\n' "$uerr" | grep -qF "unknown argument" || fail "unknown-argument error must still say what went wrong"
+
+# (8) an explicitly supplied log root that does not exist is an input error — alone or mixed with a valid root
+for roots in "$TMP/no-such-root" "$TMP/no-such-root,$LOGS"; do
+  mout="$(bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$roots" 2>/dev/null || true)"
+  bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$roots" >/dev/null 2>&1 || [ $? -eq 2 ] || fail "missing explicit log root must exit 2 ($roots)"
+  printf '%s\n' "$mout" | grep -qF 'reference_access_census_unevaluated: 1 input error(s)' || fail "missing explicit log root must withhold counts:\n$mout"
+  printf '%s\n' "$mout" | grep -qF 'reference_access_census_ok' && fail "ok token printed with a missing explicit log root"
+  printf '%s\n' "$mout" | grep -qE '\| [0-9]+ \|' && fail "a table was printed with a missing explicit log root"
+  printf '%s\n' "$mout" | grep -qF "$TMP" && fail "missing-root sentinel leaked a path"
+done
+# a missing DEFAULT root stays normal: with no --logs and an empty HOME the result is the no-transcript sentinel, exit 0
+dout="$(HOME="$TMP/empty-home" bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30)" || fail "absent default roots must not be an input error"
+[ "$(printf '%s\n' "$dout" | tail -1)" = "reference_access_census_unevaluated: no transcripts within 30d under 2 log root(s); counts withheld" ] || fail "absent default roots must yield the no-transcript sentinel:\n$dout"
+
+# (10) overlapping log roots (a root and its own subtree, or a root listed twice) count each transcript once
+oout="$(bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$TMP/logs-codex,$TMP/logs-codex/2026,$TMP/logs-codex")" || fail "overlapping roots run exited non-zero"
+printf '%s\n' "$oout" | grep -qF 'transcripts=2 sessions_touching_package=2' || fail "overlapping roots must not double-count transcripts:\n$oout"
+printf '%s\n' "$oout" | grep -qE '^references/alpha\.md \| 1 \|' || fail "alpha must count once under overlapping roots:\n$oout"
+
+# (11) an invalid --skill value is never echoed back (a mistyped private identifier stays private)
+kerr="$(bash "$CENSUS" --repo-root "$REPO" --skill "acme-internal-secret-project" --logs "$LOGS" 2>&1 >/dev/null || true)"
+printf '%s\n' "$kerr" | grep -qF "acme-internal-secret-project" && fail "unknown --skill error echoed the caller's value"
+printf '%s\n' "$kerr" | grep -qF "usage_error" || fail "unknown --skill must still be reported as a usage error"
+
+# (12) a transcript whose name contains a newline is one candidate, not two broken ones
+NL="$TMP/logs-newline"; mkdir -p "$NL"; printf '{"cmd":"cat skills/demo-skill/references/beta.md"}\n' > "$NL/odd
+name.jsonl"
+nout="$(bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$NL")" || fail "newline-named transcript run exited non-zero"
+printf '%s\n' "$nout" | grep -qF 'transcripts=1 sessions_touching_package=1' || fail "newline in a transcript name must not split the candidate:\n$nout"
+
+# (13) HOME unset and no --logs: no default roots, the no-transcript sentinel, exit 0 (never an unbound-variable abort)
+hout="$(env -u HOME bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30)" || fail "unset HOME must not abort the census"
+[ "$(printf '%s\n' "$hout" | tail -1)" = "reference_access_census_unevaluated: no transcripts within 30d under 0 log root(s); counts withheld" ] || fail "unset HOME must yield the no-transcript sentinel:\n$hout"
+
+# (14) a transcript-read error forced by a command shim (root-independent twin of the chmod leg)
+GSHIM="$TMP/gshim"; mkdir -p "$GSHIM"
+printf '#!/usr/bin/env bash\necho "grep: transcript: Input/output error" >&2\nexit 2\n' > "$GSHIM/grep"; chmod +x "$GSHIM/grep"
+gout="$(PATH="$GSHIM:$PATH" bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$LOGS" 2>/dev/null || true)"
+PATH="$GSHIM:$PATH" bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$LOGS" >/dev/null 2>&1 || [ $? -eq 2 ] || fail "a grep read error must exit 2"
+printf '%s\n' "$gout" | grep -qF 'reference_access_census_unevaluated:' || fail "a grep read error must withhold counts:\n$gout"
+printf '%s\n' "$gout" | grep -qF 'reference_access_census_ok' && fail "ok token printed after a grep read error"
+
+# (15) a grep that fails silently (exit 2, no stderr) is still an input error: withhold, exit 2, no ok token
+QSHIM="$TMP/qshim"; mkdir -p "$QSHIM"
+printf '#!/usr/bin/env bash\nexit 2\n' > "$QSHIM/grep"; chmod +x "$QSHIM/grep"
+qout="$(PATH="$QSHIM:$PATH" bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$LOGS" 2>/dev/null || true)"
+PATH="$QSHIM:$PATH" bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$LOGS" >/dev/null 2>&1 || [ $? -eq 2 ] || fail "a silent grep failure must exit 2"
+printf '%s\n' "$qout" | grep -qF 'reference_access_census_unevaluated:' || fail "a silent grep failure must withhold counts:\n$qout"
+printf '%s\n' "$qout" | grep -qF 'reference_access_census_ok' && fail "ok token printed after a silent grep failure"
+
+# (16) an inherited errexit (caller exported SHELLOPTS=errexit) must not turn an all-no-match batch into an input error
+NM="$TMP/logs-nomatch"; mkdir -p "$NM"; printf '{"cmd":"ls skills/other-skill/"}\n' > "$NM/quiet.jsonl"
+mout2="$(env SHELLOPTS=errexit bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$NM")" || fail "inherited errexit must not abort a valid census"
+printf '%s\n' "$mout2" | grep -qF 'transcripts=1 sessions_touching_package=0' || fail "all-no-match batch under inherited errexit must be a valid zero census:\n$mout2"
+[ "$(printf '%s\n' "$mout2" | tail -1)" = "reference_access_census_ok" ] || fail "inherited errexit must not withhold a valid census"
+
+# (17) a find that fails silently (exit 2, no stderr) is an input error: withhold, exit 2, no ok token
+FSHIM="$TMP/fshim"; mkdir -p "$FSHIM"
+printf '#!/usr/bin/env bash\nexit 2\n' > "$FSHIM/find"; chmod +x "$FSHIM/find"
+fout="$(PATH="$FSHIM:$PATH" bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$LOGS" 2>/dev/null || true)"
+frc=0; PATH="$FSHIM:$PATH" bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$LOGS" >/dev/null 2>&1 || frc=$?
+[ "$frc" -eq 2 ] || fail "a silent find failure must exit 2 (got $frc)"
+printf '%s\n' "$fout" | grep -qE 'reference_access_census_unevaluated: [0-9]+ input error' || fail "a silent find failure must withhold counts as an input error, not the no-transcript sentinel:\n$fout"
+printf '%s\n' "$fout" | grep -qF 'reference_access_census_ok' && fail "ok token printed after a silent find failure"
+
+# (9) a failing stat (a transcript vanishing before the timestamp read) withholds the table with exit 2 —
+# deterministic via a PATH shim, independent of filesystem permissions or root
+SHIM="$TMP/shim"; mkdir -p "$SHIM"
+printf '#!/usr/bin/env bash\necho "stat: cannot stat: No such file or directory" >&2\nexit 1\n' > "$SHIM/stat"; chmod +x "$SHIM/stat"
+sout="$(PATH="$SHIM:$PATH" bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$LOGS,$TMP/logs-codex" 2>/dev/null || true)"
+PATH="$SHIM:$PATH" bash "$CENSUS" --repo-root "$REPO" --skill demo-skill --days 30 --logs "$LOGS,$TMP/logs-codex" >/dev/null 2>&1 || [ $? -eq 2 ] || fail "failing stat must exit 2, not the pipeline status"
+printf '%s\n' "$sout" | grep -qF 'reference_access_census_unevaluated:' || fail "failing stat must print the unevaluated sentinel:\n$sout"
+printf '%s\n' "$sout" | grep -qF 'reference_access_census_ok' && fail "ok token printed after a failing stat"
+printf '%s\n' "$sout" | grep -qE '\| [0-9]+ \|' && fail "a table was printed after a failing stat"
+
+echo "test_reference_access_census_ok"