@chrono-meta/fh-gate 1.4.74 → 1.4.76

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

@@ -73,6 +73,7 @@ pat = re.compile(
 )
 
 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()
@@ -82,8 +83,11 @@ for s in shipped:
         # 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) and m not in accepted:
-            phantom.setdefault(m, set()).add(s)
+        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
@@ -94,6 +98,11 @@ if not shipped:
 
 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
 )
@@ -104,9 +113,13 @@ if [ "$rc" -eq 2 ] || [ "$out" = "EXTRACTOR_BROKE" ]; then
   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" | while IFS=$'\t' read -r path n src; do
+  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
@@ -115,5 +128,13 @@ if [ "$rc" -ne 0 ]; then
   exit 1
 fi
 
-echo "PASS  package-coverage: every referenced path is shipped or explicitly accepted (${#ACCEPTED_ABSENT[@]} accepted)"
+# 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

@@ -111,6 +111,41 @@ if [ -f scripts/package_coverage_check.sh ]; then
   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/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"

package/scripts/test_memory_link_check.sh

@@ -0,0 +1,134 @@
+#!/usr/bin/env bash
+# test_memory_link_check.sh — known-pair anchor for scripts/memory_link_check.py.
+#
+# WHY: the checker's --fix-separators path WRITES to personal knowledge files. Everything it gets
+# wrong, it gets wrong silently and in bulk. Two of its rules were found only by attacking it:
+#   * a first draft rewrote links inside FENCED blocks — i.e. it "corrected" the examples that
+#     document the convention, which is the probe-damages-the-remedy class;
+#   * a first measurement counted cross-store links as broken, overstating the defect by 44%.
+# Both are pinned below, alongside the classes.
+#
+# Lanes
+#   C1  the five classes separate on a fixture (ok / separator / cross-store-absent / placeholder / dangling)
+#   F1  a link inside a fenced block is COUNTED but never REWRITTEN
+#   F2  a link inside inline backticks IS rewritten (this corpus styles real links that way —
+#       measured 2026-07-28: 25 such links repaired, 0 fenced changes in the same run)
+#   F3  aliased links [[target|alias]] keep their alias
+#   F4  re-running the fixer changes nothing (idempotent)
+#   G1  an empty store reports an extractor failure, never a clean graph
+#
+# Exit 0 = 6/6.
+set -uo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+CHK="$ROOT/scripts/memory_link_check.py"
+[ -f "$CHK" ] || { echo "FAIL: $CHK missing"; exit 1; }
+
+pass=0; fail=0
+ok()  { printf '  ✅ %s\n' "$1"; pass=$((pass+1)); }
+bad() { printf '  ❌ %s\n' "$1"; fail=$((fail+1)); }
+
+TD="$(mktemp -d)"; trap 'rm -rf "$TD"' EXIT
+mkdir -p "$TD/store"
+printf -- '---\nname: real_target\n---\nbody\n' > "$TD/store/real_target.md"
+cat > "$TD/store/src.md" <<'EOF'
+---
+name: src
+---
+plain ok: [[real_target]]
+plain separator: [[real-target]]
+alias: [[real-target|shown as this]]
+inline: `[[real-target]]`
+dangling: [[nothing_here]]
+placeholder: [[link]]
+
+```
+fenced example — must NOT be rewritten: [[real-target]]
+```
+EOF
+
+_run() { python3 "$CHK" --memory "$TD/store" "$@" 2>/dev/null; }
+
+out=$(_run)
+# FIRST match only. `dangling` appears twice in the report — once as a count row and once as a
+# section header ("dangling (nothing on disk...)") — so an unbounded match returned two lines and
+# the numeric comparison silently failed against a correct tool. Instrument fault, fixed here.
+_n() { printf '%s\n' "$out" | awk -v k="$1" '$1==k && $2 ~ /^[0-9]+$/ {print $2; exit}'; }
+if [ "$(_n ok)" = "1" ] && [ "$(_n placeholder)" = "1" ] && [ "$(_n dangling)" = "1" ] && [ "$(_n separator)" -ge 4 ]; then
+  ok "C1 classes separate (ok=$(_n ok) separator=$(_n separator) placeholder=$(_n placeholder) dangling=$(_n dangling))"
+else
+  bad "C1 class counts wrong"; printf '%s\n' "$out" | sed 's/^/     /'
+fi
+
+_run --fix-separators --quiet >/dev/null
+body=$(cat "$TD/store/src.md")
+
+if printf '%s' "$body" | sed -n '/```/,/```/p' | grep -q '\[\[real-target\]\]'; then
+  ok "F1 fenced example left untouched (the documentation of the rule survives the fixer)"
+else
+  bad "F1 the fixer rewrote a link inside a fenced block — it corrected its own example"
+fi
+
+if printf '%s' "$body" | grep -q 'inline: `\[\[real_target\]\]`'; then
+  ok "F2 inline-backticked link repaired (this store's citation style is a real link)"
+else
+  bad "F2 inline-backticked link was not repaired"
+fi
+
+if printf '%s' "$body" | grep -q '\[\[real_target|shown as this\]\]'; then
+  ok "F3 alias preserved through the rewrite"
+else
+  bad "F3 alias lost or target not rewritten"
+fi
+
+before=$(cat "$TD/store/src.md")
+_run --fix-separators --quiet >/dev/null
+if [ "$before" = "$(cat "$TD/store/src.md")" ]; then
+  ok "F4 idempotent on re-run"
+else
+  bad "F4 a second run changed the file again"
+fi
+
+mkdir -p "$TD/empty"
+if python3 "$CHK" --memory "$TD/empty" >/dev/null 2>&1; then
+  bad "G1 an empty store exited 0 — a scan that cannot see its subject reported a clean graph"
+else
+  ok "G1 empty store fails as an extractor error, not a pass"
+fi
+
+
+# H1/A1 — cross-family findings, both confirmed by execution before acceptance.
+#   H1 (agy): an anchor-form link `[[target#section]]` was COUNTED as repairable but the rewrite
+#             enumerated closing forms by hand and never matched it — so it was flagged on every
+#             run (idempotence broken) and the summary reported more fixes than it made.
+#   A1 (gpt-5.5): two notes sharing a normalized name let the fixer reroute an edge to whichever
+#             sorted first, and the wrong link then resolves exactly, so no later run flags it.
+printf -- '---\nname: my_topic\n---\nbody\n' > "$TD/store/my_topic.md"
+printf -- '---\nname: anchored\n---\nanchor: [[my-topic#section-1]]\nplain: [[my-topic]]\n' > "$TD/store/anchored.md"
+_run --fix-separators --quiet >/dev/null
+if grep -q '\[\[my_topic#section-1\]\]' "$TD/store/anchored.md"; then
+  ok "H1 anchor-form link rewritten (target only, #section preserved)"
+else
+  bad "H1 [[target#anchor]] left unrewritten — flagged forever, and the fix count over-reports"
+fi
+# Idempotence here is a STABLE count, not zero: the fenced example is counted every run and
+# deliberately never rewritten, so zero is unreachable by design. Asserting zero was an instrument
+# error in this anchor's first draft — it scored a correct tool as failing.
+before_n=$(out=$(_run); printf '%s\n' "$out" | awk '$1=="separator" && $2 ~ /^[0-9]+$/ {print $2; exit}')
+_run --fix-separators --quiet >/dev/null
+after_n=$(out=$(_run); printf '%s\n' "$out" | awk '$1=="separator" && $2 ~ /^[0-9]+$/ {print $2; exit}')
+if [ "$before_n" = "$after_n" ]; then
+  ok "H1b idempotent with anchor forms present (count stable at $after_n — the fenced example)"
+else
+  bad "H1b count moved $before_n → $after_n across a second fix pass"
+fi
+printf -- 'A\n' > "$TD/store/collide-x.md"; printf -- 'B\n' > "$TD/store/collide_x.md"
+out=$(_run)
+if printf '%s\n' "$out" | grep -q 'ambiguous'; then
+  ok "A1 colliding normalized names surface as a reported class"
+else
+  bad "A1 no ambiguous class — a colliding pair can still be auto-rerouted"
+fi
+
+echo "----"
+echo "memory-link-check anchor: $pass passed, $fail failed"
+[ "$fail" -eq 0 ] || exit 1