@chrono-meta/fh-gate 1.4.73 → 1.4.75

package/scripts/memory_nearcheck.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""nearcheck.py — read-only near-duplicate probe over a markdown memory store.
+
+Design absorbed from obsidian-mind's `memory-similarity.ts` (MIT, breferrari) — the PROPOSITIONS,
+not the code:
+  * lexical, not semantic. An embedding call on the write hot path costs latency and money, and
+    the failure being prevented is the LITERAL re-record (a session restating a lesson in nearly
+    the same words), not two genuinely different phrasings. Semantics is what RECALL is for.
+  * facet-gated: two notes are only comparable when their declared reach overlaps.
+  * pure: no IO in the scoring core, so it can be calibrated on fixtures.
+
+DEVIATION, and why: obsidian-mind tokenizes on word boundaries. This corpus is majority KOREAN,
+where whitespace tokens are morphologically inflected and word-level overlap under-reports badly —
+the same failure class this repo already measured (an ASCII-token scanner over a Korean corpus
+produced ~96% false positives). So the shingles here are CHARACTER 3-grams over NFC-normalized,
+markup-stripped text, which is script-agnostic.
+
+READ-ONLY. Writes nothing. Exit 0 always — this is a measurement, not a gate.
+"""
+from __future__ import annotations
+import re, sys, unicodedata
+from pathlib import Path
+from itertools import combinations
+
+N = 3          # character shingle size
+TOP = 40       # how many pairs to print
+
+def strip_markup(t: str) -> str:
+    t = re.sub(r"```.*?```", " ", t, flags=re.S)      # fenced code
+    t = re.sub(r"`[^`]*`", " ", t)                    # inline code
+    t = re.sub(r"\[\[([^\]]*)\]\]", r"\1", t)         # wikilinks -> text
+    t = re.sub(r"\[([^\]]*)\]\([^)]*\)", r"\1", t)    # md links -> text
+    t = re.sub(r"https?://\S+", " ", t)
+    t = re.sub(r"[#*_>|\-–—·:;,.!?()\[\]{}\"'`~^=+/\\]", " ", t)
+    return re.sub(r"\s+", " ", t).strip()
+
+def parse(p: Path) -> dict:
+    raw = p.read_text(encoding="utf-8", errors="ignore")
+    fm, body = {}, raw
+    if raw.startswith("---"):
+        end = raw.find("\n---", 3)
+        if end > 0:
+            for line in raw[3:end].splitlines():
+                if ":" in line and not line.startswith(" "):
+                    k, v = line.split(":", 1)
+                    fm[k.strip()] = v.strip().strip('"')
+            body = raw[end + 4 :]
+    return {
+        "path": p,
+        "name": fm.get("name", p.stem),
+        "desc": fm.get("description", ""),
+        "type": fm.get("type", ""),
+        "body": unicodedata.normalize("NFC", strip_markup(body)),
+    }
+
+def shingles(t: str) -> set[str]:
+    t = t.replace(" ", "")
+    return {t[i : i + N] for i in range(max(0, len(t) - N + 1))}
+
+def jaccard(a: set, b: set) -> float:
+    if not a or not b:
+        return 0.0
+    inter = len(a & b)
+    return inter / (len(a) + len(b) - inter)
+
+def containment(a: set, b: set) -> float:
+    """Asymmetric: how much of the SMALLER note is inside the larger.
+
+    Jaccard alone under-reports the case that matters most here — a short lesson later restated
+    inside a longer note.
+
+    SIZE-GATED (repaired 2026-07-28 after the probe's first run): without the gate this metric
+    SATURATES on size-asymmetric pairs. Korean character 3-grams have a very high base rate
+    (inflectional endings and particles recur everywhere), so a 22 KB note "contains" almost every
+    short note's shingles and the top of the ranking became one large file paired with everything.
+    Hand-check that killed it: user_role.md (658 B, "user is a QA engineer") scored 0.80 against a
+    22 KB provenance note. Not a near-duplicate by any reading — an instrument artifact.
+    A restatement worth flagging is of COMPARABLE size; a short note swallowed by a long one is
+    the containment metric measuring the alphabet, not the content.
+    """
+    if not a or not b:
+        return 0.0
+    small, large = (a, b) if len(a) <= len(b) else (b, a)
+    if len(small) < 0.34 * len(large):
+        return 0.0
+    return len(small & large) / len(small)
+
+def main(argv):
+    root = Path(argv[1])
+    docs = [parse(p) for p in sorted(root.glob("*.md"))
+            if p.name not in {"MEMORY.md", "MEMORY_archive.md"}]
+    if not docs:
+        print("EXTRACTOR_BROKE: 0 documents parsed — the probe did not run", file=sys.stderr)
+        return 2
+    # Corpus-frequency filter — the second half of the same repair. A shingle present in most
+    # notes carries no evidence of duplication; it is this corpus's alphabet. Dropping the common
+    # band is the lexical equivalent of a stopword list, derived rather than hand-listed so it
+    # transfers to a corpus in any script.
+    from collections import Counter
+    df = Counter()
+    for d in docs:
+        d["sh_raw"] = shingles(d["body"])
+        df.update(d["sh_raw"])
+    cutoff = max(2, int(0.15 * len(docs)))
+    common = {g for g, n in df.items() if n > cutoff}
+    for d in docs:
+        d["sh"] = d["sh_raw"] - common
+        d["shd"] = shingles(d["desc"]) - common
+
+    empty = [d["path"].name for d in docs if len(d["sh"]) < 20]
+    pairs = []
+    for a, b in combinations(docs, 2):
+        j = jaccard(a["sh"], b["sh"])
+        c = containment(a["sh"], b["sh"])
+        jd = jaccard(a["shd"], b["shd"])
+        if j >= 0.25 or c >= 0.55 or jd >= 0.45:
+            pairs.append((max(j, c), j, c, jd, a, b))
+    pairs.sort(key=lambda t: -t[0])
+
+    print(f"scanned: {len(docs)} notes  (skipped index files)")
+    print(f"corpus-common shingles dropped: {len(common)} (present in >{cutoff} notes)")
+    print(f"too-short-to-score (<20 shingles): {len(empty)}" + (f" → {empty}" if empty else ""))
+    print(f"candidate pairs above threshold: {len(pairs)}\n")
+    for score, j, c, jd, a, b in pairs[:TOP]:
+        print(f"[{score:.2f}] jac={j:.2f} cont={c:.2f} desc={jd:.2f}")
+        print(f"    A {a['path'].name}")
+        print(f"    B {b['path'].name}")
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

package/scripts/package_coverage_check.sh

@@ -0,0 +1,140 @@
+#!/usr/bin/env bash
+# package_coverage_check.sh — a shipped document must not point at a file the package omits.
+#
+# WHY (measured 2026-07-28): the npm tarball shipped CLAUDE.md, README, CATALOG and the knowledge/
+# base while omitting much of what they instruct the reader to open — 35 distinct paths existed in
+# the repo, were named by a shipped document, and were absent from the tarball. `CLAUDE.md` told
+# consumers to run `templates/predelete_check.sh` before a destructive op; that file did not ship.
+# A gate you are told to run and cannot run is worse than one you were never told about.
+#
+# This is the ANTI-REGROWTH instrument for that class. Closing the 35 once is worth little: the set
+# regrows every time a doc gains a reference or files[] gains an entry. So the check is mechanical
+# and the exceptions are ENUMERATED, never implicit.
+#
+# SOURCE-TREE ONLY. Inside an installed package the un-shipped files are legitimately absent and
+# package.json's files[] may not even be present in a comparable form, so the check self-skips.
+#
+# Usage:  bash scripts/package_coverage_check.sh
+# Exit:   0 = every referenced path is either shipped or explicitly accepted; 1 = a new phantom.
+set -uo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$REPO_ROOT" || exit 1
+
+if [ ! -d .git ] || [ ! -f package.json ]; then
+  echo "SKIP  package-coverage (not a source checkout)"
+  exit 0
+fi
+
+# ── Accepted-absent, with the reason each one is NOT a defect ────────────────────────────────
+# Adding a line here is a decision, not a silencer: each entry states why shipping it would be
+# wrong. If you cannot write that sentence, the file probably belongs in files[].
+#
+#   .claude/registry/LOCAL_SKILL_REGISTRY.md — per-environment, generated by the registry scan.
+#       Its consumers probe it with `ls … 2>/dev/null` and handle absence; shipping one machine's
+#       registry would hand every consumer a false map of skills they do not have.
+#   .claude/regression/probes.md            — per-environment prompt-regression baselines. The
+#       skill explicitly prints NO_CUSTOM_PROBES when absent. Shipping FH's baselines would make
+#       a consumer's regression run compare against someone else's harness.
+#   scripts/sync-to-be.sh                   — operator-private companion-store sync. Never ships.
+#       (The reference that flags it is a TEST FIXTURE in prepush_guard_check.sh which *creates*
+#        a file of that name to exercise the LOW allowlist — not a pointer to this file at all.)
+#   scripts/sync_guard_check.sh             — anchor for that same operator-private mirror sync;
+#       no shipped hook invokes it.
+ACCEPTED_ABSENT=(
+  ".claude/registry/LOCAL_SKILL_REGISTRY.md"
+  ".claude/regression/probes.md"
+  "scripts/sync-to-be.sh"
+  "scripts/sync_guard_check.sh"
+)
+
+out=$(python3 - "${ACCEPTED_ABSENT[@]}" <<'PY'
+import re, os, json, sys
+accepted = set(sys.argv[1:])
+files = json.load(open('package.json'))['files']
+
+def covered(p):
+    return any(p == f or p.startswith(f.rstrip('/') + '/') for f in files)
+
+shipped = []
+for f in files:
+    if os.path.isfile(f):
+        shipped.append(f)
+    elif os.path.isdir(f):
+        for root, _, names in os.walk(f):
+            shipped.extend(os.path.join(root, n) for n in names)
+
+# Only text surfaces can carry a reference a human or agent would follow.
+shipped = [s for s in shipped if s.endswith(('.md', '.sh', '.js', '.json', '.yaml', '.yml'))]
+
+pat = re.compile(
+    r'(?<![\w/.-])((?:scripts|templates|bin|docs|knowledge|plugins|\.claude)'
+    r'/[A-Za-z0-9_./-]+\.(?:sh|py|js|md|yaml|yml|json|defaults))'
+)
+
+phantom = {}
+exercised = set()   # accepted entries a shipped doc ACTUALLY still points at
+for s in shipped:
+    try:
+        text = open(s, encoding='utf-8', errors='ignore').read()
+    except OSError:
+        continue
+    for m in set(pat.findall(text)):
+        # Only a path that REALLY EXISTS here but is left out of the tarball is this defect.
+        # A path that exists nowhere is the ordinary phantom-reference class the ref-path
+        # check above already owns; a path outside files[] that is also absent is nothing.
+        if os.path.exists(m) and not covered(m):
+            if m in accepted:
+                exercised.add(m)
+            else:
+                phantom.setdefault(m, set()).add(s)
+
+# Impossible-zero guard: this repo always has shipped docs. Zero scanned means the extractor
+# broke — report that as a failure rather than letting a dead check print a pass
+# (same rule as count_check.sh and the ref-path extractor).
+if not shipped:
+    print("EXTRACTOR_BROKE")
+    raise SystemExit(2)
+
+for p, srcs in sorted(phantom.items(), key=lambda kv: (-len(kv[1]), kv[0])):
+    print(f"{p}\t{len(srcs)}\t{sorted(srcs)[0]}")
+
+# An exception nobody exercises is a SILENCER waiting for a future real case to land on it.
+# Report the unexercised ones so the list stays a set of decisions, not accumulated residue.
+for a in sorted(accepted - exercised):
+    print(f"STALE\t{a}")
+raise SystemExit(1 if phantom else 0)
+PY
+)
+rc=$?
+
+if [ "$rc" -eq 2 ] || [ "$out" = "EXTRACTOR_BROKE" ]; then
+  echo "FAIL  package-coverage: extractor scanned 0 shipped docs — the check broke, it did not pass"
+  exit 1
+fi
+
+STALE_LIST=$(printf '%s\n' "$out" | grep '^STALE	' | cut -f2- || true)
+STALE_N=$(printf '%s' "$STALE_LIST" | grep -c . || true)
+EXERCISED_N=$(( ${#ACCEPTED_ABSENT[@]} - ${STALE_N:-0} ))
+
+if [ "$rc" -ne 0 ]; then
+  echo "FAIL  package-coverage: shipped document(s) point at file(s) the package omits:"
+  printf '%s\n' "$out" | grep -v '^STALE	' | while IFS=$'\t' read -r path n src; do
+    [ -z "$path" ] && continue
+    printf '        %s  (named by %s shipped doc(s), e.g. %s)\n' "$path" "$n" "$src"
+  done
+  echo "      Fix: add the path to package.json files[], OR list it in ACCEPTED_ABSENT here"
+  echo "      with a one-sentence reason why shipping it would be wrong."
+  exit 1
+fi
+
+# Advisory only — a stale exception is hygiene, not a shipped-doc defect, so it must not
+# convert a clean package into a red gate (that trains the runner to ignore the check).
+if [ "${STALE_N:-0}" -gt 0 ]; then
+  echo "⚠️  package-coverage: ${STALE_N} ACCEPTED_ABSENT entry(ies) no longer exercised — remove, or a"
+  echo "    future real omission can land on the stale exception and be silenced:"
+  printf '%s\n' "$STALE_LIST" | sed 's/^/        /'
+fi
+
+echo "PASS  package-coverage: every referenced path is shipped or explicitly accepted (${#ACCEPTED_ABSENT[@]} accepted, ${EXERCISED_N} exercised)"
+exit 0

package/scripts/selfcheck.sh

@@ -99,6 +99,53 @@ else
   fail=1
 fi
 
+# package-coverage — a shipped doc must not point at a file the tarball omits. Distinct from the
+# ref-path check below: that one asks "does this path exist at all", this one asks "does the
+# CONSUMER get it". Measured 2026-07-28: 35 paths existed, were named by a shipped doc, and were
+# absent from the tarball — including templates/predelete_check.sh, which CLAUDE.md instructs you
+# to run before a destructive op. Wired here in the same commit that created it, because the two
+# previous anchors this session shipped with zero callers.
+if [ -f scripts/package_coverage_check.sh ]; then
+  if ! bash scripts/package_coverage_check.sh; then
+    fail=1
+  fi
+fi
+
+# memory-link-check — the memory store is a GRAPH (memory_intent_recall.md: nodes=files,
+# edges=[[links]], recall walks one hop). Measured 2026-07-28: 50 of 872 edges pointed at a note
+# that existed under a different separator and 22 at nothing — a dead edge returns nothing and is
+# indistinguishable from "nothing is related", so the doctrine degraded silently. The checker's
+# --fix-separators path WRITES, so its anchor runs here rather than being invoked by hand.
+# Package/other-machine mode: the checker self-SKIPs when no memory dir exists.
+if [ -f scripts/test_memory_link_check.sh ] && [ -f scripts/memory_link_check.py ]; then
+  if ! bash scripts/test_memory_link_check.sh; then
+    fail=1
+  fi
+elif [ -f scripts/memory_link_check.py ]; then
+  echo "FAIL  memory-link-check: checker present but scripts/test_memory_link_check.sh missing"
+  fail=1
+fi
+
+# session-close gate lanes (② harvest-loop discharge + ⑤ card-last) and the ⑤-b card-drift probe.
+# Both anchors calibrate scripts/session_close_check.sh, which the pre-push hook runs on every push
+# — an uncalibrated instrument there produces exactly the false verdicts the close chain exists to
+# prevent. test_card_drift_probe.sh had shipped with ZERO callers since it was written; wiring it
+# here closes that, and the anchors are added to files[] in the same change so package mode runs
+# them too rather than reporting a deleted anchor.
+for _anchor in scripts/test_session_close_lanes.sh scripts/test_card_drift_probe.sh; do
+  if [ ! -f scripts/session_close_check.sh ]; then
+    echo "SKIP  ${_anchor##*/} (subject scripts/session_close_check.sh absent)"
+  elif [ -f "$_anchor" ]; then
+    if ! bash "$_anchor"; then
+      fail=1
+    fi
+  else
+    # subject present, anchor gone => the calibration was deleted. Real failure, not a skip.
+    echo "FAIL  ${_anchor##*/}: session_close_check.sh present but its anchor is missing"
+    fail=1
+  fi
+done
+
 # Referenced-path existence is a source-tree check. The npm package intentionally
 # ships a narrower runtime surface, so package-mode selfcheck skips this section.
 if [ -d ".claude/rules" ]; then

package/scripts/session_close_check.sh

@@ -42,10 +42,28 @@ fi
 # masking a real match as pipeline failure so the warning NEVER fired on true positives
 # (caught by a Sonnet blind probe 2026-07-10, 5/5 deterministic repro). `grep -c` reads the
 # whole stream; `|| true` guards its exit-1-on-zero.
+#
+# SATISFIABLE (2026-07-28): this warning used to fire on EVERY close that touched an FH asset, with
+# no way for the session to discharge it — the script had no means of observing whether harvest-loop
+# ran. A permanently-firing line is noise, and noise trains the runner to skim past the ❌ lines that
+# do matter (the same objection raised against pre-push:484 on 2026-07-28 — one standard, both places).
+# So the obligation now has a mechanical discharge: a `harvest-loop` mention in TODAY's fh_completed
+# file. HONEST SCOPE: this tests ACKNOWLEDGMENT, not execution — the script cannot see a skill run.
+# Recording "harvest-loop: skipped, <reason>" discharges it exactly as recording a run does, which is
+# correct: CLAUDE.md ② accepts "harvest-loop (or an explicit skip note)". What it now catches is the
+# real miss class — closing with FH assets changed and *no decision recorded either way*.
 FH_CHANGED=$(git -C "$FH" log --since="today 00:00" --name-only --pretty=format: 2>/dev/null \
      | grep -cE '^(plugins/.*SKILL\.md|\.claude/rules/|templates/|CLAUDE\.md|knowledge/)' || true)
 if [ "${FH_CHANGED:-0}" -gt 0 ]; then
-  echo "⚠️  ② FH assets changed today ($FH_CHANGED path-touch(es)) — harvest-loop (or an explicit skip note) is owed"
+  HL_NOTED=0
+  [ -f "$FH/tracks/_meta/fh_completed_${TODAY}.md" ] \
+    && HL_NOTED=$(grep -ciE 'harvest[-_]loop' "$FH/tracks/_meta/fh_completed_${TODAY}.md" || true)
+  if [ "${HL_NOTED:-0}" -gt 0 ]; then
+    echo "✅ ② FH assets changed today ($FH_CHANGED path-touch(es)) — harvest-loop decision recorded in fh_completed_${TODAY}.md"
+  else
+    echo "⚠️  ② FH assets changed today ($FH_CHANGED path-touch(es)) and fh_completed_${TODAY}.md records no"
+    echo "     harvest-loop decision — run it, or write one line stating the skip and why (either discharges this)"
+  fi
 fi
 
 # ④ real-time completion log — required whenever any commit landed today
@@ -100,6 +118,18 @@ if [ -f "$CARD" ]; then
   NEWER=$(find "$FH/tracks/_meta" -maxdepth 1 -type f \( -name "fh_completed_*.md" -o -name "fh_signal_*.md" \) -newer "$CARD" 2>/dev/null | wc -l | tr -d ' ')
   if [ "$NEWER" -gt 0 ]; then
     echo "❌ ⑤ card-last violated — $NEWER close artifact(s) newer than the session card; re-run ⑤ (delta update)"
+    # NAME the offenders. Recurrence N=3 (2026-07-28, three closes in one day): every repair so far
+    # was a prose vow ("next time I'll write the finding into the card first") and every one failed,
+    # because the reflex fires mid-close. What is mechanizable is not the reflex but the COST of the
+    # miss — a bare count makes ⑤ a re-read of the whole session, while naming the files and showing
+    # what landed after the card makes the delta update a minute's work, which is what actually gets
+    # done rather than deferred. Diagnosis, not prevention: this line does not claim to stop the miss.
+    find "$FH/tracks/_meta" -maxdepth 1 -type f \( -name "fh_completed_*.md" -o -name "fh_signal_*.md" \) -newer "$CARD" 2>/dev/null \
+      | while IFS= read -r f; do
+          echo "     ↳ ${f#"$FH"/}"
+          tail -n 3 "$f" 2>/dev/null | sed 's/^/         │ /'
+        done
+    echo "     → fold the above into the card, save the card LAST, then re-push."
     FAIL=1
   else
     echo "✅ ⑤ card is the newest close artifact (card-last holds)"

package/scripts/sidecar_wait.sh

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+# sidecar_wait.sh — run a sidecar to COMPLETION and report a typed verdict about it.
+#
+# WHY THIS EXISTS (measured twice, 2026-07-28 and 2026-07-29)
+#
+#   A session dispatched `codex exec` and `agy -p` into the background and read their output files
+#   one second and thirty seconds later. Both were empty at that moment, so the session recorded
+#   "both sidecars returned 0-output", wrote that into a gate marker, a PR body, a session card and
+#   a memory file, and did the adversarial work itself instead.
+#
+#   Both sidecars had in fact answered. codex produced 48 KB containing three findings — one HIGH
+#   (a normalization collision that silently reroutes a link and then looks clean forever) and one
+#   MED that showed the change was OVER-APPLIED. agy produced a HIGH of its own (anchor-form links
+#   were counted as fixable but never rewritten, so the fixer broke idempotence and over-reported
+#   its own writes). Every one was real; all were confirmed by execution and fixed.
+#
+#   So the failure was never the sidecars. It was reading a still-running process and calling the
+#   silence a result. That mis-reading then propagated as a claim about ANOTHER system — the worst
+#   shape a measurement error can take, because it retires a working mechanism.
+#
+#   The reflex fires mid-work and prose does not stop it (three consecutive card-last violations the
+#   day before are the same lesson). So the wait becomes mechanical: this script will not emit a
+#   verdict while the process is alive, and "no output" is only sayable after the process exits.
+#
+# VERDICTS (typed — grep these, never the prose)
+#   SIDECAR_VERDICT=COMPLETE exit=<n> bytes=<n>   process exited on its own
+#   SIDECAR_VERDICT=TIMEOUT  waited=<n>s bytes=<n> still alive when the budget ran out; NOT a result
+#   SIDECAR_VERDICT=EMPTY    exit=<n>             exited cleanly having written nothing — the only
+#                                                 state in which "the sidecar said nothing" is true
+#
+# Usage:
+#   bash scripts/sidecar_wait.sh <outfile> <timeout_seconds> -- <command> [args...]
+#   printf '%s' "$prompt" | bash scripts/sidecar_wait.sh out.txt 600 -- codex exec -m gpt-5.5 -
+#
+# Exit: 0 = COMPLETE (with or without output) · 1 = TIMEOUT (verdict withheld, not a failure claim)
+set -uo pipefail
+
+OUT="${1:?usage: sidecar_wait.sh <outfile> <timeout_s> -- <cmd...>}"
+BUDGET="${2:?missing timeout seconds}"
+shift 2
+[ "${1:-}" = "--" ] && shift
+[ $# -gt 0 ] || { echo "sidecar_wait: no command given" >&2; exit 2; }
+
+: > "$OUT"
+"$@" > "$OUT" 2>&1 &
+PID=$!
+
+waited=0
+last_size=0
+# Poll rather than `wait`, so a live-but-quiet process is distinguishable from a dead one and the
+# caller can SEE progress. A silent minute on a reasoning model is normal; the earlier misreading
+# happened precisely because silence was treated as termination.
+while kill -0 "$PID" 2>/dev/null; do
+  if [ "$waited" -ge "$BUDGET" ]; then
+    size=$(wc -c < "$OUT" 2>/dev/null | tr -d ' ')
+    echo "SIDECAR_VERDICT=TIMEOUT waited=${BUDGET}s bytes=${size:-0} pid=$PID"
+    echo "  the process is STILL RUNNING — this is not 'no output'. Raise the budget, or kill $PID" >&2
+    exit 1
+  fi
+  sleep 5
+  waited=$((waited + 5))
+  size=$(wc -c < "$OUT" 2>/dev/null | tr -d ' ')
+  if [ "${size:-0}" -ne "$last_size" ]; then
+    echo "  … ${waited}s elapsed, ${size} bytes so far (alive)" >&2
+    last_size=${size:-0}
+  fi
+done
+
+wait "$PID"; rc=$?
+size=$(wc -c < "$OUT" 2>/dev/null | tr -d ' ')
+if [ "${size:-0}" -eq 0 ]; then
+  echo "SIDECAR_VERDICT=EMPTY exit=$rc"
+else
+  echo "SIDECAR_VERDICT=COMPLETE exit=$rc bytes=$size"
+fi
+exit 0

package/scripts/substrate_jump_detector.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+# substrate_jump_detector.sh — detect substrate-version jumps (the trigger that was a phantom).
+#
+# WHY: the substrate self-adaptation loop's initiate leg cited a "substrate-version jump trigger"
+# that had NO detector (codex census 2026-07-10 refuted the self-assessment — the trigger existed
+# only as inventory text). This is STRUCTURE-ENFORCING mechanization per the durable-mechanization
+# criterion (sonnet_floor_doctrine.md): version drift lives OUTSIDE the session's context boundary —
+# an infinitely strong model still cannot know what changed on the machine between sessions.
+#
+# WHAT: snapshots substrate versions to a gitignored state file; on the next run, diffs and emits
+# a jump notice naming the doctrine's shed/advance pass. Silent when nothing changed.
+# Wire: one line in the SessionStart hook (fh_session_load.sh) or run standalone.
+#
+# Exit: always 0 (detector, not gate). State: tracks/_meta/.substrate_versions (gitignored).
+
+set -uo pipefail
+
+FH="${1:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
+STATE="$FH/tracks/_meta/.substrate_versions"
+
+snapshot() {
+  # one line per component: name=version (unavailable components recorded as absent — an
+  # appearing/disappearing component is itself a jump)
+  echo "claude=$(claude --version 2>/dev/null | head -1 || echo absent)"
+  echo "codex=$(codex --version 2>/dev/null | head -1 || echo absent)"
+  echo "agy=$(agy --version 2>/dev/null | head -1 || echo absent)"
+  echo "node=$(node --version 2>/dev/null || echo absent)"
+  echo "git=$(git --version 2>/dev/null || echo absent)"
+  echo "os=$(uname -sr 2>/dev/null || echo absent)"
+}
+
+CURRENT="$(snapshot)"
+
+if [ ! -f "$STATE" ]; then
+  printf '%s\n' "$CURRENT" > "$STATE"
+  echo "🧭 [substrate] baseline snapshot recorded ($(echo "$CURRENT" | wc -l | tr -d ' ') components)"
+  exit 0
+fi
+
+PREV="$(cat "$STATE")"
+if [ "$CURRENT" = "$PREV" ]; then
+  # silent no-op — a detector that talks every session trains the reader to skip it
+  exit 0
+fi
+
+echo "🧭 [substrate] VERSION JUMP detected — substrate loop initiate leg fires:"
+# show only changed lines (name-keyed diff, bash-3.2 safe)
+while IFS= read -r cur; do
+  name="${cur%%=*}"
+  old=$(printf '%s\n' "$PREV" | grep -m1 "^$name=" || echo "$name=<new>")
+  [ "$cur" != "$old" ] && echo "   $old  →  $cur"
+done <<EOF
+$CURRENT
+EOF
+echo "   → run the shed/advance pass: re-check capability-compensating scaffolding against the new"
+echo "     substrate (sonnet_floor_doctrine.md §durable-mechanization — shed what the model no longer"
+echo "     needs, advance what the new substrate enables). Removals go through the 4-axis gate."
+
+printf '%s\n' "$CURRENT" > "$STATE"
+exit 0

package/scripts/test_card_drift_probe.sh

@@ -0,0 +1,77 @@
+#!/usr/bin/env bash
+# test_card_drift_probe.sh — session_close_check.sh ⑤-b 카드-드리프트 프로브의 known-pair 픽스처.
+#
+# WHY: 프로브 자체가 계기다 — CLAUDE.md §Instrument Calibration 이 요구하는 known-pair
+# (양성 1 + 음성 1)를 통과하지 못하는 프로브는 배선하면 안 된다(다음 오판정의 원천이 된다).
+# 이 파일이 그 캘리브레이션의 회귀 앵커: 프로브 정규식/토큰추출을 고칠 때마다 재실행.
+#
+# 픽스처 3종:
+#   P  (known-positive): 카드가 🔴 "foo-digest 미가동 — 산출물 0" 주장 + 실물
+#                        tracks/_meta/foo_digest_2026_07_22.md 존재 → ⑤-b 경고가 떠야 한다
+#   N1 (known-negative): 카드가 부재 주장하는 bar-report 는 진짜 없음 → 경고 0
+#   N2 (과발화 가드):    같은 실물이 있어도 부재-주장이 아닌 🟢 줄 → 경고 0
+#                        (건강한 날 뜨는 경고는 무시를 학습시킨다 — 과발화도 결함)
+#
+# Exit 0 = 3/3 캘리브레이션 통과 · exit 1 = 프로브 계기 불량 (배선 금지)
+
+set -uo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CHECK="$SCRIPT_DIR/session_close_check.sh"
+FAILED=0
+
+run_fixture() {  # $1=name  $2=card-content  $3=make-artifact(0/1)  $4=expect-warn(0/1)
+  local name="$1" card="$2" mkart="$3" expect="$4"
+  local T; T=$(mktemp -d)
+  mkdir -p "$T/tracks/_meta/logs"
+  printf '%s\n' "$card" > "$T/tracks/_meta/reference_next_session_starter.md"
+  [ "$mkart" = 1 ] && touch "$T/tracks/_meta/foo_digest_2026_07_22.md"
+  # git 없는 디렉토리라도 다른 스텝은 조용히 지나간다(모두 2>/dev/null 가드)
+  local out; out=$(bash "$CHECK" "$T" 2>/dev/null)
+  local warned=0
+  printf '%s\n' "$out" | grep -q "⑤-b card-drift" && warned=1
+  rm -rf "$T"
+  if [ "$warned" = "$expect" ]; then
+    echo "✅ $name (warn=$warned, expected=$expect)"
+  else
+    echo "❌ $name — warn=$warned, expected=$expect"
+    FAILED=1
+  fi
+}
+
+run_fixture "P  known-positive: 부재주장+실물존재 → 경고" \
+  "- 🔴 **foo-digest 잡 미가동(07-22)** — 로그도 산출물도 0(launchd 확인 필요)." 1 1
+
+run_fixture "N1 known-negative: 부재주장+진짜부재 → 무경고" \
+  "- 🔴 **bar-report 잡 미가동** — 산출물 0, 미착수." 0 0
+
+run_fixture "N2 과발화가드: 실물존재+부재주장아님 → 무경고" \
+  "- 🟢 **foo-digest 가동 중** — 오늘자 산출 확인." 1 0
+
+run_fixture "N3 정정문맥가드: 부재주장 인용+오판정 명시 → 무경고" \
+  "- 🔴 **foo-digest 산출 누락 수리 미완**. 기존 카드의 \"미가동\"은 오판정이었음." 1 0
+
+run_fixture "N4 날짜토큰가드: 부재주장이나 토큰이 날짜뿐 → 무경고" \
+  "- 🔴 잡 미가동 2026-07-22 산출물 0" 1 0
+
+# challenger A-1 반례 (2026-07-23): 살아있는 주장 + 무관한 debunk 어휘 = 경고가 떠야 한다.
+# debunk-단독 가드는 이 두 줄을 무음 삼켰다(FN) — 인용부 조건이 판별자.
+run_fixture "P2 살아있는 주장+무관한 '정정 필요' → 경고 (A-1 FN 앵커)" \
+  "- 🔴 **foo-digest 미가동 지속** — 산출물 0. 지난 카드의 실행횟수 수치는 정정 필요." 1 1
+
+run_fixture "P3 살아있는 주장+무관한 '거짓' → 경고 (A-1 FN 앵커)" \
+  "- 🔴 **foo-digest 미가동** — 산출물 0, 로그는 거짓 성공만 찍힘" 1 1
+
+run_fixture "N5 위치-언급 디렉토리 → 무경고 (A-2 FP 앵커)" \
+  "- 🟡 bar-report 미생성 — tracks/_meta/ 산출물 0" 0 0
+
+run_fixture "N6 카드 자신 매치 제외 (A-3 FP 앵커)" \
+  "- 🔴 next_session_starter 갱신 부재 — 0건" 0 0
+
+run_fixture "P4 영어 부재주장 (A-4 앵커)" \
+  "- 🔴 **foo-digest job not running** — zero outputs" 1 1
+
+run_fixture "N7 인용된 부재키워드+정정 → 무경고 (실카드 07-22 클래스)" \
+  "- 🔴 foo-digest 산출 누락. 기존 카드의 \"미가동\" 주장은 오판정이었음" 1 0
+
+echo "── card-drift probe calibration: $([ "$FAILED" -eq 0 ] && echo "PASS (전 픽스처) — 배선 가능" || echo "FAIL — 계기 불량, 배선 금지") ──"
+exit "$FAILED"

package/scripts/test_degrade_scan_shell_probes.sh

@@ -155,6 +155,32 @@ n=$(s_hits "$TMP/dependency_guards.sh")
 [ "$n" -eq 2 ] && ok "dependency guards (\`[ -f lib ] || exit 0\`) still detected — scope exclusion did not swallow them" \
                 || bad "dependency guards: expected 2 S-hits, got $n — 'guard library missing → allow' is hidden again"
 
+# S5 known pair — added 2026-07-28 when the probe shipped with NO fixture of its own and every one
+# of the 9 hits it produced in this repo turned out to be a false positive. Both directions are
+# pinned because narrowing an all-FP probe is one edit away from a blind one.
+cat > "$TMP/s5_positive.sh" <<'EOF'
+#!/usr/bin/env bash
+set -uo pipefail
+N=$(find /nope . -maxdepth 1 2>/dev/null | grep -c . || echo 0)
+M=$(git log --oneline 2>/dev/null | wc -l || echo 0)
+EOF
+cat > "$TMP/s5_negative.sh" <<'EOF'
+#!/usr/bin/env bash
+set -uo pipefail
+# `a || b || echo 0` is NOT a pipeline — no stage can emit a second line.
+_mtime() { stat -c %Y "$1" 2>/dev/null || stat -f %m "$1" 2>/dev/null || echo 0; }
+# A pipeline whose failing stage emits nothing: the fallback supplies the only line, as intended.
+J=$(printf '%s' "$x" | jq -r '.a // 0' 2>/dev/null || echo 0)
+# A comment describing the defect must not be scored as the defect: cmd | grep -c . || echo 0
+EOF
+n=$(s_hits "$TMP/s5_positive.sh")
+[ "$n" -eq 2 ] && ok "S5 known-positive: counter-stage fallbacks (grep -c, wc) detected 2/2" \
+                || bad "S5 known-positive: expected 2 S-hits, got $n — the pipefail disarm is invisible"
+
+n=$(s_hits "$TMP/s5_negative.sh")
+[ "$n" -eq 0 ] && ok "S5 known-negative: \`||\` chains, empty-on-failure pipelines and comments stay silent" \
+                || bad "S5 known-negative: $n hit(s) — S5 is noise again (9/9 FP was its measured state)"
+
 n=$(p_hits "$TMP/kp.py")
 [ "$n" -ge 1 ] && ok "python known-positive: pre-existing probes still fire" \
                 || bad "python known-positive: no hits — the Python probes regressed"