@chrono-meta/fh-gate 1.4.78 → 1.4.80

package/scripts/test_ollama_panel_lanes.sh

@@ -0,0 +1,120 @@
+#!/usr/bin/env bash
+# test_ollama_panel_lanes.sh — hermetic known pairs for the ollama panel leg of sidecar_calibrate.sh
+#
+# Hermetic by construction: every lane runs against a stub HTTP server on loopback. No network, no
+# spend, no dependence on a node being powered on — the same property the CLI lanes get from stub
+# binaries. A calibrator whose own tests need the thing it calibrates cannot fail honestly.
+#
+# WHAT MAKES THIS LEG DIFFERENT FROM codex/agy, AND WHY IT NEEDED ITS OWN LANES
+#   The CLI legs anchor PIN-OK on the model's SELF-REPORT. That anchor is invalid here and the
+#   measurement says so: asked which model it was, `gpt-oss:20b` answered "The underlying model is
+#   GPT-4 (likely)" (2026-07-31). Open-weight models do not reliably know their own name, so a
+#   self-report anchor would mark an EXACT pin as UNTRUSTED and drop it from the panel — an
+#   instrument that cannot separate known-positive from known-negative on its target. The anchor is
+#   therefore the SERVER's response envelope: a server-side fact, not a model's claim.
+#   Lane S2 is the reason that distinction has teeth — it is the agy failure in this protocol's
+#   spelling: the server quietly answers as a different model than the one pinned.
+
+set -u
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+CAL="$ROOT/scripts/sidecar_calibrate.sh"
+pass=0; fail=0
+PORT="${FH_LANE_PORT:-18011}"
+SRV_PID=""
+
+# `wait` after the kill, so bash reaps the child quietly instead of printing "Terminated: 15" into
+# the lane output — a harness that litters CI logs teaches people to stop reading them.
+stop_stub() {
+  [ -n "$SRV_PID" ] || return 0
+  kill "$SRV_PID" 2>/dev/null
+  wait "$SRV_PID" 2>/dev/null
+  SRV_PID=""
+}
+trap 'stop_stub' EXIT
+
+# The stub is written to a file so the heredoc cannot collide with the lane script's own quoting.
+STUB="$(mktemp -d)/stub.py"
+cat > "$STUB" <<'PY'
+import json, sys
+from http.server import BaseHTTPRequestHandler, HTTPServer
+PORT = int(sys.argv[1]); MODE = sys.argv[2]
+
+class H(BaseHTTPRequestHandler):
+    def log_message(self, *a): pass
+    def _send(self, obj, code=200):
+        b = json.dumps(obj).encode()
+        self.send_response(code); self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(b))); self.end_headers(); self.wfile.write(b)
+    def do_GET(self):
+        if self.path == "/api/version": self._send({"version": "stub"})
+        elif self.path == "/api/tags": self._send({"models": [{"name": "stub-model:1b"}]})
+        else: self._send({}, 404)
+    def do_POST(self):
+        n = int(self.headers.get("Content-Length", 0))
+        req = json.loads(self.rfile.read(n) or b"{}")
+        m = req.get("model", "")
+        if m.startswith("fh-calib-nonexistent"):
+            # BOGUS control. 'accept' mode is the dangerous server: it serves SOMETHING for a name
+            # that cannot exist, so the pin is never validated at all.
+            if MODE == "accept": self._send({"model": m, "response": "PASS"})
+            else: self._send({"error": f"model '{m}' not found"})
+            return
+        if MODE == "substitute":  # the agy failure, in this protocol
+            self._send({"model": "some-other-model:9b", "response": "PASS"}); return
+        if MODE == "starved":     # reasoning model spent the whole budget thinking
+            self._send({"model": m, "response": "", "thinking": "x" * 780}); return
+        if MODE == "prose":       # cannot carry a machine-read verdict
+            self._send({"model": m, "response": "Well, I would say this looks like a PASS overall."}); return
+        self._send({"model": m, "response": "PASS"})
+HTTPServer(("127.0.0.1", PORT), H).serve_forever()
+PY
+# shellcheck disable=SC2016
+start_stub() {
+  stop_stub
+  python3 "$STUB" "$PORT" "$1" >/dev/null 2>&1 &
+  SRV_PID=$!
+  for _ in $(seq 1 40); do
+    curl -sf --max-time 1 "http://127.0.0.1:$PORT/api/version" >/dev/null 2>&1 && return 0
+    sleep 0.25
+  done
+  return 1
+}
+
+# expect <label> <mode> <expect-in-panel: YES|NO> [needle]
+expect() {
+  local label="$1" mode="$2" want="$3" needle="${4:-}" out inpanel
+  start_stub "$mode" || { printf '  ❌ %-44s stub failed to start\n' "$label"; fail=$((fail+1)); return; }
+  out=$( FH_OLLAMA_HOST="http://127.0.0.1:$PORT" FH_OLLAMA_MODELS="stub-model:1b" \
+         bash "$CAL" --only ollama --quiet 2>&1 )
+  stop_stub
+  if printf '%s' "$out" | grep -q 'PANEL:.*ollama:stub-model:1b'; then inpanel=YES; else inpanel=NO; fi
+  if [ "$inpanel" = "$want" ] && { [ -z "$needle" ] || printf '%s' "$out" | grep -q "$needle"; }; then
+    printf '  ✅ %-44s in-panel=%s\n' "$label" "$inpanel"; pass=$((pass+1))
+  else
+    printf '  ❌ %-44s in-panel=%s (expected %s%s)\n' "$label" "$inpanel" "$want" "${needle:+, needle '$needle'}"
+    printf '     out: %s\n' "$(printf '%s' "$out" | head -4)"; fail=$((fail+1))
+  fi
+}
+
+echo "[ollama-panel] known pairs (hermetic stub server)"
+expect "S1 envelope matches pin, verdict parses" ok         YES "PIN-OK(envelope)"
+expect "S2 server substitutes a DIFFERENT model" substitute NO  "UNTRUSTED-PIN"
+expect "S3 empty answer (budget starvation)"     starved    NO  "larger FH_OLLAMA_NUM_PREDICT"
+expect "S4 prose answer cannot carry a verdict"  prose      NO  "VERDICT-UNPARSEABLE"
+expect "S5 server accepts a bogus model name"    accept     YES "accepts-bogus"
+
+# S6 — absence must be MEASURED, never assumed. No server at the host at all.
+out=$( FH_OLLAMA_HOST="http://127.0.0.1:$((PORT+7))" bash "$CAL" --only ollama --quiet 2>&1 )
+if printf '%s' "$out" | grep -q 'ABSENT — no server at the configured host'; then
+  printf '  ✅ %-44s reported ABSENT\n' "S6 no server at host"; pass=$((pass+1))
+else
+  printf '  ❌ %-44s (expected a measured ABSENT line)\n' "S6 no server at host"
+  printf '     out: %s\n' "$(printf '%s' "$out" | head -3)"; fail=$((fail+1))
+fi
+
+echo
+if [ "$fail" -eq 0 ]; then
+  echo "[ollama-panel] ✅ all $pass known pairs hold"; exit 0
+else
+  echo "[ollama-panel] ❌ $fail/$((pass+fail)) lanes failed"; exit 1
+fi

package/scripts/test_package_coverage_lanes.sh

@@ -0,0 +1,250 @@
+#!/usr/bin/env bash
+# test_package_coverage_lanes.sh — regression anchor for scripts/package_coverage_check.sh.
+#
+# WHY THIS EXISTS (measured 2026-07-31):
+#   package_coverage_check.sh gated itself on `[ ! -d .git ]`. In a git WORKTREE `.git` is a FILE
+#   (a gitdir pointer), so every worktree fell into the "installed package" branch and the check
+#   printed `SKIP` and exited 0 without scanning anything. That is a FALSE CLEAN of the worst shape:
+#   a worktree is the standard way to approximate a fresh CI checkout, so the surface used to argue
+#   "CI would be green" was precisely the surface on which this check silently did not run.
+#   It was found by using the instrument, then asking whether the instrument had run at all —
+#   CLAUDE.md §Instrument-Calibration, applied to FH's own tooling.
+#
+#   Second reason: selfcheck.sh enforces "subject present but anchor missing => FAIL" for eight
+#   other scripts, and package_coverage_check.sh was the one subject exempted from its own rule.
+#   An unanchored checker is one revert away from being decoration.
+#
+# The lanes pin, in order: the source-checkout predicate across all four tree shapes (worktree /
+# ordinary checkout / package mode / no manifest), and a KNOWN PAIR — a tree that must FAIL and an
+# otherwise identical tree that must PASS. A predicate that cannot separate that pair is not
+# measuring coverage, it is emitting a verdict.
+#
+# Usage:  bash scripts/test_package_coverage_lanes.sh
+# Exit:   0 = no lane FAILED. 1 = a regression.
+#         NOT "all lanes passed": a lane whose precondition is absent (no git) is counted as
+#         UNCALIBRATED and printed in the summary, and exit stays 0. Stated precisely because the
+#         earlier wording promised more than the code delivers, and an exit contract that overstates
+#         is exactly the false-clean this suite exists to prevent (round-3 review, LOW).
+set -uo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+SUBJECT="$REPO_ROOT/scripts/package_coverage_check.sh"
+[ -f "$SUBJECT" ] || { echo "FAIL: $SUBJECT not found"; exit 1; }
+
+TMP="$(mktemp -d)"
+trap 'rm -rf "$TMP"' EXIT
+
+pass=0; fail=0; skipped=0
+ok()  { printf '  ✅ %s\n' "$1"; pass=$((pass+1)); }
+bad() { printf '  ❌ %s\n' "$1"; fail=$((fail+1)); }
+# A skip is COUNTED and reported. An uncounted skip is how "could not run" becomes indistinguishable
+# from "ran and passed" in the summary line — measured on this very suite in review round 2, where a
+# broken git produced "7 passed, 0 failed" and exit 0 while the real-worktree claim went untested.
+# Degrade direction per CLAUDE.md §Instrument-Calibration: label it UNCALIBRATED, never a bare pass.
+skip() { printf '  ⏭  UNCALIBRATED — %s\n' "$1"; skipped=$((skipped+1)); }
+
+# Build a hermetic fake source tree. `git_shape` is one of: file | dir | none.
+# `ship_the_doc` decides whether the referenced path is inside files[] (the known pair).
+make_tree() { # make_tree <dir> <git_shape> <cover_target:yes|no> [omit_manifest]
+  local d="$1" git_shape="$2" cover="$3" omit="${4:-}"
+  mkdir -p "$d/scripts" "$d/docs"
+  cp "$SUBJECT" "$d/scripts/package_coverage_check.sh"
+
+  # A shipped document that points at scripts/helper.sh, and that file really exists here.
+  # "exists here but absent from files[]" is exactly the defect class this check owns.
+  printf 'Run `scripts/helper.sh` before the gate.\n' > "$d/docs/guide.md"
+  printf '#!/usr/bin/env bash\necho helper\n' > "$d/scripts/helper.sh"
+
+  if [ "$cover" = "yes" ]; then
+    printf '{"files":["docs/guide.md","scripts/helper.sh"]}\n' > "$d/package.json"
+  else
+    printf '{"files":["docs/guide.md"]}\n' > "$d/package.json"
+  fi
+  [ -n "$omit" ] && rm -f "$d/package.json"
+
+  case "$git_shape" in
+    dir)  mkdir -p "$d/.git" ;;
+    file) printf 'gitdir: /somewhere/else/.git/worktrees/x\n' > "$d/.git" ;;
+    none) : ;;
+  esac
+}
+
+run_tree() { bash "$1/scripts/package_coverage_check.sh" 2>&1; }
+rc_tree()  { bash "$1/scripts/package_coverage_check.sh" >/dev/null 2>&1; echo $?; }
+
+# Assert a POSITIVE outcome, never merely the absence of the SKIP line. Cross-family review caught
+# the first draft here: it checked only that `SKIP  package-coverage` was missing, so a checker that
+# exited 1 on every worktree — the opposite defect, equally broken — would have passed the lane that
+# exists to prove the worktree path works. "Did not say the wrong thing" is not "did the right
+# thing"; a lane phrased as a negative can only ever fail one way.
+ran_clean() { # ran_clean <dir> -> 0 iff the check actually ran AND reported a clean scan
+  local d="$1" o rc
+  o=$(bash "$d/scripts/package_coverage_check.sh" 2>&1); rc=$?
+  [ "$rc" -eq 0 ] && printf '%s' "$o" | grep -q 'PASS  package-coverage' \
+    && ! printf '%s' "$o" | grep -q 'SKIP  package-coverage'
+}
+caught_defect() { # caught_defect <dir> -> 0 iff the check FOUND the planted omission
+  local d="$1" o rc
+  o=$(bash "$d/scripts/package_coverage_check.sh" 2>&1); rc=$?
+  [ "$rc" -eq 1 ] && printf '%s' "$o" | grep -q 'scripts/helper.sh'
+}
+# A CLEAN LANE ALONE PROVES NOTHING ABOUT THE WORKTREE PATH. Cross-family review round 2 demonstrated
+# this by EXECUTION: it replaced the subject with a mutant that printed `PASS  package-coverage`
+# whenever `.git` was a file, without scanning anything — and all eight lanes passed, suite exit 0.
+# The lanes proved "returned a PASS-shaped string", not "ran the coverage logic". The known-positive
+# fixtures existed but only under the `.git`-is-a-DIRECTORY shape, so nothing exercised detection in
+# the very shape the fix was about. Every worktree lane below is now a PAIR: the same tree must go
+# clean->PASS and planted-omission->FAIL. A bypassing mutant fails the second half by construction.
+wt_pair() { # wt_pair <label> <dir> <git_shape>
+  local label="$1" d="$2" shape="$3"
+  make_tree "$d" "$shape" yes
+  if ! ran_clean "$d"; then
+    bad "$label — clean leg: did not run to a PASS ($(run_tree "$d" | head -1))"; return
+  fi
+  make_tree "$d" "$shape" no        # identical tree, files[] no longer covers the referenced path
+  if ! caught_defect "$d"; then
+    bad "$label — DEFECT leg: planted omission not caught, so the clean PASS proved nothing"; return
+  fi
+  ok "$label"
+}
+
+# ── L1 · THE REGRESSION ANCHOR ───────────────────────────────────────────────────────
+wt_pair "L1 worktree (.git is a FILE): scans for real — clean PASSes, planted omission FAILs" \
+        "$TMP/l1" file
+
+# ── L1-b · a REAL git worktree, not a hand-written pointer ───────────────────────────
+# The synthetic fixture writes a gitdir pointer whose target does not exist, so it proves the
+# predicate accepts "a file named .git" — not that it accepts a genuine worktree. This lane builds
+# an actual repo and an actual `git worktree add`.
+# ISOLATION (review round 2, LOW): the git commands run with signing off, hooks disabled, and both
+# config files pointed at /dev/null, so a configured signing prompt or a global hook cannot hang the
+# suite or write outside $TMP. GIT_TERMINAL_PROMPT=0 turns any credential prompt into an error.
+# SKIP ACCOUNTING (review round 2, MED — confirmed by execution): the first draft printed a skip and
+# incremented nothing, so a machine with a broken git reported "7 passed, 0 failed" and exited 0 —
+# a lane that cannot run must not read as a lane that passed. Now: git ABSENT is a legitimate skip
+# but is counted and surfaced as UNCALIBRATED in the summary; git PRESENT but setup failing is a
+# FAILURE, because there the claim was testable and the test did not run.
+GIT_ISO=(-c commit.gpgsign=false -c core.hooksPath=/dev/null -c user.email=a@b -c user.name=t)
+# CONFIG isolation is not REPOSITORY-ROUTING isolation. Round-3 review reproduced this on Apple Git
+# 2.50.1: with GIT_DIR pointing at an unrelated repo, this suite reported "8 passed, 0 failed" while
+# that external repo's commit count went 0 -> 1. So the lane could pass by exercising — and WRITING
+# TO — a repository that is not its fixture. A test that mutates state outside its own $TMP is not
+# a test, and the green summary is the worst part: it reports calibration it did not perform.
+# Every routing variable is cleared, and the resolved git-dir is then ASSERTED to live under $TMP
+# rather than assumed — the unset list is a denylist and a denylist is never proof; the assertion is.
+# SECOND LEAK CHANNEL, same class, found by the reviewer running the attack rather than reading for
+# it: GIT_CONFIG_PARAMETERS injects config that GIT_CONFIG_GLOBAL/SYSTEM=/dev/null does NOT suppress.
+# Reproduced here: with `init.templateDir` pointed at a directory whose `refs` is a symlink to an
+# external dir, `git init` populated that external dir — and the suite still printed
+# "8 passed, 0 failed". The git-dir assertion cannot see this one, because the git-dir DOES resolve
+# inside $TMP; the escape is through the template, not the routing. So the assertion is necessary and
+# not sufficient, and the config-injection channels have to be closed by name.
+# `--template=` with an empty directory is the belt to that braces: even if a config channel is
+# missed, init has an explicit, empty template to copy from.
+unset GIT_DIR GIT_WORK_TREE GIT_INDEX_FILE GIT_COMMON_DIR GIT_OBJECT_DIRECTORY \
+      GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_NAMESPACE GIT_CEILING_DIRECTORIES \
+      GIT_CONFIG_PARAMETERS GIT_CONFIG_COUNT GIT_TEMPLATE_DIR
+export GIT_TERMINAL_PROMPT=0 GIT_CONFIG_GLOBAL=/dev/null GIT_CONFIG_SYSTEM=/dev/null
+if ! command -v git >/dev/null 2>&1; then
+  skip "L1-b real git worktree (git not installed — the on-disk layout under test cannot exist here)"
+else
+  mkdir -p "$TMP/realrepo"
+  # BOTH SIDES NORMALIZED. First version compared the raw `mktemp -d` path against
+  # `rev-parse --absolute-git-dir`, and on macOS that fails for a clean tree: mktemp hands back
+  # /var/folders/... while git resolves symlinks and returns /private/var/folders/... . The
+  # assertion then rejected its OWN correct fixture — a false positive on a safety check, which is
+  # the same defect class as a false negative and would have trained the next reader to delete it.
+  # `pwd -P` resolves the $TMP side; the other side is already physical because
+  # `rev-parse --absolute-git-dir` resolves symlinks itself. The raw "$TMP"/* branch is kept as a
+  # belt for platforms where it does not. (An earlier comment said "both sides normalized via
+  # pwd -P" — only one side uses it.)
+  _TMP_REAL="$(cd "$TMP" && pwd -P)"
+  # NAME THE ORDER HONESTLY: `git init` runs FIRST and this assertion runs immediately after, so it
+  # gates every subsequent write (commit, worktree add) — not the init itself. init is bounded
+  # separately by the unset list plus the explicit empty --template. An earlier comment claimed
+  # "before anything is written", which overstated it by one step.
+  _gitdir_ok() { # the fixture repo must resolve INSIDE $TMP before anything FURTHER is written
+    local r; r=$(git "${GIT_ISO[@]}" -C "$TMP/realrepo" rev-parse --absolute-git-dir 2>/dev/null) || return 1
+    case "$r" in
+      "$_TMP_REAL"/*|"$TMP"/*) return 0 ;;
+      *) echo "  ↳ git-dir resolved OUTSIDE the fixture: $r" >&2; return 1 ;;
+    esac
+  }
+  mkdir -p "$TMP/emptytpl"
+  if git "${GIT_ISO[@]}" -C "$TMP/realrepo" init -q --template="$TMP/emptytpl" . >/dev/null 2>&1 \
+     && _gitdir_ok \
+     && git "${GIT_ISO[@]}" -C "$TMP/realrepo" commit -q --allow-empty -m init >/dev/null 2>&1 \
+     && git "${GIT_ISO[@]}" -C "$TMP/realrepo" worktree add -q --detach "$TMP/realwt" >/dev/null 2>&1 \
+     && [ -f "$TMP/realwt/.git" ]; then
+    wt_pair "L1-b real \`git worktree add\` (.git is a genuine gitdir pointer): scans for real" \
+            "$TMP/realwt" none          # the REAL .git file is already in place; do not overwrite it
+  else
+    bad "L1-b git IS installed but the real-worktree fixture could not be built — the claim was testable and was not tested"
+  fi
+fi
+
+# ── L2 · ordinary checkout keeps working ─────────────────────────────────────────────
+wt_pair "L2 ordinary checkout (.git is a DIR): scans for real — both legs" "$TMP/l2" dir
+
+# ── L3 · package mode must STILL skip ────────────────────────────────────────────────
+# The widening from -d to -e must not cost the legitimate skip. An installed npm package has no
+# .git of either kind; making it fail there would fire on every consumer running `npm test`.
+make_tree "$TMP/l3" none yes
+out=$(run_tree "$TMP/l3"); rc=$(rc_tree "$TMP/l3")
+if printf '%s' "$out" | grep -q 'SKIP  package-coverage' && [ "$rc" -eq 0 ]; then
+  ok "L3 package mode (no .git): still skips, exit 0"
+else
+  bad "L3 package mode (no .git): expected SKIP+0, got rc=$rc / $(printf '%s' "$out" | head -1)"
+fi
+
+# ── L4 · a checkout with no manifest is UNMEASURED, not clean ────────────────────────
+# EXPECTATION CORRECTED by cross-family review, 2026-07-31. The first draft asserted SKIP+0 here
+# and would have ANCHORED a fail-open: inside a checkout, a missing package.json means the shipped
+# file list cannot be read, which is "cannot measure", not "nothing to measure". An anchor that
+# pins the wrong direction is worse than no anchor — it makes the hole look deliberate.
+make_tree "$TMP/l4" dir yes omit
+out=$(run_tree "$TMP/l4"); rc=$(rc_tree "$TMP/l4")
+if [ "$rc" -eq 1 ] && printf '%s' "$out" | grep -q 'UNMEASURED, not clean'; then
+  ok "L4 .git present but no package.json: FAILS as unmeasured, not a clean skip"
+else
+  bad "L4 no package.json: expected exit 1 (unmeasured), got rc=$rc / $(printf '%s' "$out" | head -1)"
+fi
+
+# ── L5/L6 · KNOWN PAIR ───────────────────────────────────────────────────────────────
+# Same tree twice; the ONLY difference is whether files[] covers the referenced path.
+# L5 known-POSITIVE: referenced, exists, not shipped -> must FAIL.
+make_tree "$TMP/l5" dir no
+out=$(run_tree "$TMP/l5"); rc=$(rc_tree "$TMP/l5")
+if [ "$rc" -eq 1 ] && printf '%s' "$out" | grep -q 'scripts/helper.sh'; then
+  ok "L5 known-positive (referenced ∧ exists ∧ ¬shipped): FAIL, names the path"
+else
+  bad "L5 known-positive: expected exit 1 naming scripts/helper.sh, got rc=$rc"
+fi
+
+# L6 known-NEGATIVE: identical, but the path is in files[] -> must PASS.
+make_tree "$TMP/l6" dir yes
+out=$(run_tree "$TMP/l6"); rc=$(rc_tree "$TMP/l6")
+if [ "$rc" -eq 0 ] && printf '%s' "$out" | grep -q 'PASS  package-coverage'; then
+  ok "L6 known-negative (same tree, path shipped): PASS"
+else
+  bad "L6 known-negative: expected exit 0 PASS, got rc=$rc"
+fi
+
+# ── L7 · the impossible-zero guard is not reachable by an empty files[] ──────────────
+# A manifest with no shipped docs must report the extractor as broken, not print a pass.
+mkdir -p "$TMP/l7/scripts"; cp "$SUBJECT" "$TMP/l7/scripts/"; mkdir -p "$TMP/l7/.git"
+printf '{"files":[]}\n' > "$TMP/l7/package.json"
+out=$(run_tree "$TMP/l7"); rc=$(rc_tree "$TMP/l7")
+if [ "$rc" -eq 1 ] && printf '%s' "$out" | grep -q 'the check broke, it did not pass'; then
+  ok "L7 zero shipped docs: reported as broken extractor, not as a pass"
+else
+  bad "L7 zero shipped docs: expected exit 1 'check broke', got rc=$rc"
+fi
+
+echo
+if [ "$skipped" -gt 0 ]; then
+  echo "package-coverage lanes: ${pass} passed, ${fail} failed, ${skipped} UNCALIBRATED (not verified here)"
+else
+  echo "package-coverage lanes: ${pass} passed, ${fail} failed"
+fi
+[ "$fail" -eq 0 ] || exit 1

package/scripts/test_pipe_verdict_guard_lanes.sh

@@ -0,0 +1,96 @@
+#!/usr/bin/env bash
+# test_pipe_verdict_guard_lanes.sh — known pairs for scripts/pipe_verdict_guard.sh
+#
+# WHY THIS FILE EXISTS, AND WHY IT IS WRITTEN BEFORE THE DETECTOR
+#   2026-07-30 harvest #1: across a 5-round challenger run, three rounds contained a fix that
+#   reverted an earlier fix — and the rounds that wrote the lane BEFORE touching the code had
+#   zero such regressions. Convergence came from the ORDER, not the patch. So: lanes first.
+#
+# WHAT IS BEING GUARDED
+#   Reading a verdict from `$?`/`${PIPESTATUS[…]}` after a pipeline, which yields the status of
+#   the LAST stage. When the last stage is a display filter (`tail`, `head`, `cat`), that status
+#   is the filter's — a FAILING gate reads as exit 0. Degrade direction: toward PASS.
+#
+#   R1 (deterministic, zero-FP): `${PIPESTATUS[...]}` under zsh. zsh spells it `$pipestatus[1]`
+#       and 1-indexes it; the bash array expands to the EMPTY STRING. Any verdict read from it is
+#       not merely wrong, it is absent. Measured 6× in this project's ad-hoc invocations.
+#   R2 (heuristic, narrowed): pipeline whose FINAL stage is a display filter, followed by a read
+#       of `$?`. Narrowed to display filters on purpose — see the FP lanes below.
+#
+# WHY A REPO-FILE LINTER IS THE WRONG SURFACE (measured 2026-07-31)
+#   The prescription on the session card was "add an S6 class to degrade_direction_scan.sh".
+#   Hand-verifying every `pipe + $?` hit in this repo's scripts returned 7 hits, 7 of them correct
+#   (the last stage WAS the command under test in all 7). True positives in shipped files: 0.
+#   All 6 measured recurrences were in interactively-composed commands, which no file scanner
+#   reads. Shipping S6 would have been a 0-true-positive probe — exactly the failure S5's own
+#   comment records ("100% FP trains dismissal of the one hit that will matter").
+
+set -u
+G="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/pipe_verdict_guard.sh"
+pass=0; fail=0
+
+# expect <label> <expected: HIT|CLEAN> <command-string>
+expect() {
+  local label="$1" want="$2" cmd="$3" out got
+  out=$(printf '%s' "$cmd" | bash "$G" --stdin-raw 2>&1)
+  if printf '%s' "$out" | grep -q 'PIPE-VERDICT'; then got=HIT; else got=CLEAN; fi
+  if [ "$got" = "$want" ]; then
+    printf '  ✅ %-52s %s (expected %s)\n' "$label" "$got" "$want"; pass=$((pass+1))
+  else
+    printf '  ❌ %-52s %s (expected %s)\n' "$label" "$got" "$want"; fail=$((fail+1))
+    printf '     cmd: %s\n     out: %s\n' "$cmd" "$out"
+  fi
+}
+
+echo "[pipe-verdict-guard] known pairs"
+echo "-- R1: PIPESTATUS under zsh (deterministic) --"
+# The exact shape emitted 6× in this project, including twice on 2026-07-31.
+expect "R1 the measured shape"            HIT   'bash x.sh | tail -5; echo "exit=${PIPESTATUS[0]}"'
+expect "R1 any index"                     HIT   'a | b; rc=${PIPESTATUS[1]}'
+expect "R1 inside a larger command"       HIT   'cd /r && npm t | tail; E=${PIPESTATUS[0]}; echo $E'
+# zsh's own spelling is correct here and must never be flagged.
+expect "R1 zsh spelling is CLEAN"         CLEAN 'a | b; rc=$pipestatus[1]'
+
+echo "-- R2: display-filter final stage, then \$? --"
+expect "R2 tail then \$?"                  HIT   'bash gate.sh | tail -20; echo "exit=$?"'
+expect "R2 head then \$?"                  HIT   'make test | head -40; rc=$?'
+expect "R2 cat then \$?"                   HIT   'run.sh | cat; if [ $? -ne 0 ]; then echo bad; fi'
+
+echo "-- R2 false-positive lanes: the 7 shapes this repo actually ships --"
+# Every one of these was hand-verified on 2026-07-31 as CORRECT: the final stage IS the command
+# whose status is wanted. A detector that flags these is noise, and noise trains dismissal.
+expect "FP grep -q is the test itself"    CLEAN 'echo "$pos" | grep -qE "$re"; rc=$?'
+expect "FP grep compiles the regex"       CLEAN "printf '' | grep -E \"\$re\" >/dev/null 2>&1; rc=\$?"
+# Path deliberately generic: naming a real unshipped script here would make this lane a shipped
+# doc pointing at a file the package omits (caught by selfcheck's package-coverage rule).
+expect "FP last stage is the script"      CLEAN "printf '%s' \"\$S\" | bash some-filter.sh - ; echo EXIT:\$?"
+expect "FP command substitution assign"   CLEAN 'out=$(printf x | ( cd "$r" && bash hook 2>&1 )); rc=$?'
+expect "FP no pipe at all"                CLEAN 'bash gate.sh; echo "exit=$?"'
+expect "FP || fallback, not a pipe"       CLEAN 'stat -c %Y f || stat -f %m f || echo 0'
+expect "FP pipefail set, explicit"        CLEAN 'set -o pipefail; bash gate.sh | tail -5; rc=$?'
+
+echo "-- adversarial (found by the Axis-2 pass on this guard, 2026-07-31) --"
+# A: grep is line-oriented, so `.*` never spanned a newline and every MULTI-LINE command missed.
+#    This mattered more than the single-line case: the invocations that actually recur in this
+#    project are multi-line. Caught by attacking the guard, not by the happy-path lanes.
+expect "A multi-line pipe then \$?"        HIT   'bash gate.sh | tail -20
+echo "exit=$?"'
+expect "A multi-line, three statements"   HIT   'cd /r
+make test | head -40
+rc=$?'
+expect "A multi-line stays CLEAN if legit" CLEAN 'cd /r
+echo x | grep -q y
+rc=$?'
+# B: zsh accepts `$PIPESTATUS[0]` without braces; the brace-anchored regex missed it.
+expect "B PIPESTATUS without braces"      HIT   'a | b; rc=$PIPESTATUS[0]'
+expect "B braced form still caught"       HIT   'a | b; rc=${PIPESTATUS[0]}'
+
+echo "-- opt-out --"
+expect "noqa suppresses"                  CLEAN 'bash g.sh | tail; rc=$?  # noqa: pipe-verdict'
+
+echo
+if [ "$fail" -eq 0 ]; then
+  echo "[pipe-verdict-guard] ✅ all $pass known pairs hold"; exit 0
+else
+  echo "[pipe-verdict-guard] ❌ $fail/$((pass+fail)) lanes failed"; exit 1
+fi

package/scripts/test_sidecar_wait_stdin.sh

@@ -143,7 +143,19 @@ if command -v script >/dev/null 2>&1; then
   # The inner shell writes its rc to a FILE. Parsing `script`'s own stdout fails: it emits ^D and
   # CRLF, and the first version of this lane read rc as empty and reported a defect that did not
   # exist — the target was fine, the instrument was not.
-  script -q /dev/null bash -c "SIDECAR_POLL=1 timeout 12 bash '$SW' '$TD/p9.out' 3 -- cat >'$TD/p9.txt' 2>&1; echo \$? > '$TD/p9rc'" >/dev/null 2>&1 < /dev/null
+  # `script(1)` HAS TWO INCOMPATIBLE CLIs and this lane only ever spoke one of them. BSD/macOS takes
+  # `script -q <file> <cmd> [args...]`; util-linux (every Linux runner) takes `script -q -c "<cmd>"
+  # <file>`. Given the BSD form, util-linux treats `bash` and `-c` as stray operands, never runs the
+  # inner command, and writes no rc file — so the lane read rc='<unread>' and reported a defect in
+  # sidecar_wait that did not exist. Measured on the first CI run, 2026-07-31; it had been invisible
+  # because this suite had only ever executed on macOS. Same shape as the Hangul-range collation bug
+  # found in the same run: a TOOL INTERFACE that differs by platform, silently.
+  _P9CMD="SIDECAR_POLL=1 timeout 12 bash '$SW' '$TD/p9.out' 3 -- cat >'$TD/p9.txt' 2>&1; echo \$? > '$TD/p9rc'"
+  if script --version 2>&1 | grep -qi util-linux; then
+    script -q -c "$_P9CMD" /dev/null >/dev/null 2>&1 < /dev/null
+  else
+    script -q /dev/null bash -c "$_P9CMD" >/dev/null 2>&1 < /dev/null
+  fi
   rc9=$(tr -dc '0-9' < "$TD/p9rc" 2>/dev/null)
   if [ -n "$rc9" ] && [ "$rc9" != "124" ] && grep -q 'SIDECAR_VERDICT=' "$TD/p9.txt" 2>/dev/null; then
     ok "P9 the tty path runs and emits a verdict (UNCALIBRATED — see note; does NOT bind the branch)"

package/templates/.git-hooks/pre-commit

@@ -362,6 +362,15 @@ if [ -n "$EXEC_STAGED" ] && [ -z "$DOC_STAGED" ]; then
   echo ""
 fi
 
+# ── Half-fix propagation (advisory — MARK, never block) ──────────────────────
+# The operator's spec for this debt is explicit: 표시(차단 아님 — 정당한 복제도 있다).
+# templates/ ships deliberate copies of scripts/, so blocking on duplication would block correct
+# work; and a gate that fires when the author did the right thing is a gate that gets disabled.
+# Failing to RUN is likewise never a finding: a missing/erroring scan is silent here, because this
+# surface is a commit (reversible) — the fail-closed direction belongs to publish and delete.
+HALFFIX="$REPO_ROOT/scripts/halffix_propagation_scan.sh"
+[ -f "$HALFFIX" ] && bash "$HALFFIX" 2>&1 || true
+
 # ── Axis 1 — Regression Guard (always required) ──────────────────────────────
 echo "[Axis 1] Regression Guard..."
 GUARD="$REPO_ROOT/templates/regression_guard.sh"
@@ -608,12 +617,71 @@ if [ ! -f "$MANIFEST" ]; then
   echo "  ❌ FAIL — tracks/_meta/edit_manifest.yaml not found"
   echo "  Run /edit-manifest RECORD or create the file manually."
   FAILED=1
-elif grep -q "date: $TODAY" "$MANIFEST" 2>/dev/null; then
-  echo "  ✅ PASS (entry for $TODAY found in edit_manifest.yaml)"
 else
-  echo "  ❌ FAIL — no entry dated $TODAY in edit_manifest.yaml"
-  echo "  Run /edit-manifest RECORD to log predicted impact for today's changes."
-  FAILED=1
+  # PRESENCE **AND** VALIDITY, decided by the canonical loader rather than by grep.
+  #
+  # This axis had been a pure substring grep, so it never asked whether the file it gates is the
+  # thing its name promises. It was not: 12 of 147 entries were invalid YAML for months, silently,
+  # because every consumer reads it line-wise (this hook, activity_log.sh awk, sync-to-be.sh cp).
+  #
+  # The FIRST fix for that was itself defective, and cross-family review measured all three holes —
+  # which is why the verdict now travels on the EXIT CODE and one Python pass owns every predicate:
+  #   - `$(python3 ...) || echo unchecked` SWALLOWED the exit code, so any interpreter failure, on a
+  #     manifest with a confirmed syntax error, degraded to PASS. A checker whose crash means "fine"
+  #     is not a checker.
+  #   - it discarded the parse RESULT, so a duplicate `date:` key (YAML is last-wins) could delete
+  #     today's entry while still reporting valid, and a list item drifted outside its parent list
+  #     still passed — the exact class the same commit had just repaired, left undetected.
+  #   - the grep was substring-based: a COMMENTED `# date: <today>` counted as an entry, while a
+  #     quoted `date: "<today>"` or extra spacing did not. Fail-open and over-block in one predicate.
+  # Free-form stdout is never the verdict channel either — a python3 shim printing one banner line
+  # would otherwise fail a healthy manifest.
+  MANIFEST_MSG=$(python3 - "$MANIFEST" "$TODAY" <<'PYEOF'
+import sys
+try:
+    import yaml
+except Exception:
+    sys.exit(3)                      # 3 = checker unavailable (env gap, not a defect in the change)
+try:
+    doc = yaml.safe_load(open(sys.argv[1]))
+except Exception as e:
+    mk = getattr(e, "problem_mark", None)
+    print("invalid YAML at line %s" % (mk.line + 1 if mk else "?")); sys.exit(1)
+if not isinstance(doc, list):
+    print("top level is %s, expected a list of entries" % type(doc).__name__); sys.exit(1)
+for i, entry in enumerate(doc):
+    if not isinstance(entry, dict):
+        print("entry #%d is a %s, not a mapping — a list item may have drifted outside its parent"
+              % (i, type(entry).__name__)); sys.exit(1)
+def norm(v):
+    return v.isoformat() if hasattr(v, "isoformat") else str(v).strip()
+if not any(norm(e.get("date")) == sys.argv[2] for e in doc):
+    sys.exit(2)                      # 2 = parses fine, but no entry for today
+sys.exit(0)
+PYEOF
+  )
+  MANIFEST_RC=$?
+  case "$MANIFEST_RC" in
+    0) echo "  ✅ PASS (entry for $TODAY present; manifest parses and its shape is intact)" ;;
+    3) # Degrade-to-advisory on purpose: a commit is a REVERSIBLE surface (CLAUDE.md
+       # §Irreversibility Surface-Class Degrade Invariant), and a missing PyYAML is an environment
+       # gap rather than a defect in the change being committed. Loud, never silent.
+       if grep -q "date: $TODAY" "$MANIFEST" 2>/dev/null; then
+         echo "  ✅ PASS (entry for $TODAY found by fallback grep; validity UNCHECKED — PyYAML unavailable)"
+       else
+         echo "  ❌ FAIL — no entry dated $TODAY in edit_manifest.yaml (fallback grep; PyYAML unavailable)"
+         echo "  Run /edit-manifest RECORD to log predicted impact for today's changes."
+         FAILED=1
+       fi ;;
+    2) echo "  ❌ FAIL — manifest is valid YAML but has no entry dated $TODAY"
+       echo "  Run /edit-manifest RECORD to log predicted impact for today's changes."
+       FAILED=1 ;;
+    *) echo "  ❌ FAIL — edit_manifest.yaml did not validate: ${MANIFEST_MSG:-checker exited $MANIFEST_RC}"
+       echo "  Usual causes: an unquoted value containing ': ' (quote it), or a list item indented"
+       echo "  outside its parent list. Check:"
+       echo "    python3 -c \"import yaml;yaml.safe_load(open('tracks/_meta/edit_manifest.yaml'))\""
+       FAILED=1 ;;
+  esac
 fi
 
 # Universal guards (defined above) — confidentiality/privacy boundary, every commit.