@chrono-meta/fh-gate 1.4.83 → 1.4.85

package/scripts/test_dispatch_log_lanes.sh

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+# test_dispatch_log_lanes.sh — known-pair anchor for session_close_check.sh ④-e (dispatch-log
+# reconciliation) and for the SubagentStop tally hook that feeds it.
+#
+# WHY (2026-08-02): CLAUDE.md makes an invocation-log entry mandatory immediately after any custom
+# sub-agent invocation — it feeds the 60/40 promotion gate and the UAP loop. Measured: one session
+# dispatched 20+ subagents and logged ZERO, in the same session that recovered that very log file
+# from a branch queued for deletion. An obligation that loses 20/20 is not under-emphasised, it is
+# unmechanized, so ④-e now reconciles a hook-written tally against the day's entries.
+#
+# The reconciliation itself then shipped a defect this suite exists to prevent from returning: the
+# log carries TWO date spellings — `- date: 2026-08-02` for hand-written entries and
+# `- date: '2026-08-02'` for anything appended through yaml.dump — and the first matcher saw only
+# one, counting half the entries as absent. A missing-records check that itself miscounts records is
+# the worst possible shape, so both spellings are lanes below.
+#
+# Exit 0 = the reconciliation discriminates · 1 = it would mis-report.
+
+set -uo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CHECK="$SCRIPT_DIR/session_close_check.sh"
+SETTINGS="$SCRIPT_DIR/../.claude/settings.json"
+FAILED=0; PASS=0
+chk() { if [ "$1" -eq 0 ]; then PASS=$((PASS+1)); echo "  ✅ $2"; else FAILED=1; echo "  ❌ $2"; fi; }
+
+[ -f "$CHECK" ] || { echo "FAIL  dispatch-log lanes: subject $CHECK missing"; exit 1; }
+
+# The matcher under test, lifted from the subject rather than re-spelled (a hand-copied predicate is
+# a divergent normalizer — which is exactly the bug being anchored). If it is gone, fail loudly.
+MATCHER=$(grep -oE "grep -cE \"\^- date: \*'\?\\\$TODAY'\?\"" "$CHECK" | head -1)
+if [ -z "$MATCHER" ]; then
+  echo "FAIL  the ④-e date matcher is no longer in session_close_check.sh in the expected form —"
+  echo "      this lane cannot verify what it claims to. Update the lane WITH the subject."
+  exit 1
+fi
+echo "── matcher located in the subject"
+
+T=$(mktemp -d); trap 'rm -rf "$T"' EXIT
+D=2026-08-02
+
+echo "── date-spelling lanes (the shipped miscount) ──"
+printf -- "- date: %s\n" "$D" > "$T/plain.yaml"
+printf -- "- date: '%s'\n" "$D" > "$T/quoted.yaml"
+printf -- "- date: %s\n- date: '%s'\n- date: 2020-01-01\n" "$D" "$D" > "$T/both.yaml"
+count() { grep -cE "^- date: *'?$D'?" "$1" 2>/dev/null | tr -d ' '; }
+[ "$(count "$T/plain.yaml")"  = 1 ] ; chk $? "unquoted date counted"
+[ "$(count "$T/quoted.yaml")" = 1 ] ; chk $? "yaml.dump-quoted date counted (the half the first matcher missed)"
+[ "$(count "$T/both.yaml")"   = 2 ] ; chk $? "mixed file counts both, and ignores another date"
+# known-POSITIVE for the bug itself: the reverted single-form matcher DOES undercount
+[ "$(grep -c "^- date: *$D" "$T/both.yaml")" = 1 ] ; chk $? "known-POSITIVE: the reverted matcher undercounts (1 of 2) — the defect is real"
+
+echo "── reconciliation verdict lanes ──"
+verdict() { # $1=dispatched $2=logged -> BLOCK | OK | NONE
+  if [ "$1" -gt 0 ] && [ "$2" -eq 0 ]; then echo BLOCK
+  elif [ "$1" -gt 0 ]; then echo OK
+  else echo NONE; fi
+}
+[ "$(verdict 20 0)" = BLOCK ] ; chk $? "dispatches with ZERO entries → BLOCK (this is the 2026-08-02 failure)"
+[ "$(verdict 20 4)" = OK ]    ; chk $? "consolidated logging (20 dispatches, 4 entries) → OK, not punished"
+[ "$(verdict 1 1)"  = OK ]    ; chk $? "1:1 logging → OK"
+[ "$(verdict 0 0)"  = NONE ]  ; chk $? "no dispatches → silent, not a failure"
+
+echo "── the tally hook that feeds it ──"
+if [ -f "$SETTINGS" ]; then
+  python3 - "$SETTINGS" <<'PY' >"$T/hookcmd" 2>/dev/null || true
+import json,sys
+d=json.load(open(sys.argv[1]))
+g=d.get("hooks",{}).get("SubagentStop",[])
+print(g[0]["hooks"][0]["command"] if g and g[0].get("hooks") else "")
+PY
+  cmd=$(cat "$T/hookcmd")
+  [ -n "$cmd" ] ; chk $? "SubagentStop hook is configured (an untallied dispatch is invisible to ④-e)"
+  if [ -n "$cmd" ]; then
+    case "$cmd" in *"exit 0"*) ok=0 ;; *) ok=1 ;; esac
+    [ "$ok" -eq 0 ] ; chk $? "hook ends in exit 0 — a non-zero hook exit discards its stdout SILENTLY"
+    # run it against a scratch HUB and confirm it appends today's date
+    CLAUDE_PROJECT_DIR="$T/hub" bash -c "$cmd" >/dev/null 2>&1
+    [ "$(grep -c "$(date +%Y-%m-%d)" "$T/hub/tracks/_meta/.subagent_dispatch_tally" 2>/dev/null || echo 0)" -ge 1 ]
+    chk $? "hook actually appends a dated line when run (not merely present)"
+  fi
+else
+  echo "  ⏭️  .claude/settings.json absent — hook lanes unchecked (not a pass)"
+fi
+
+echo "── absence-is-not-zero (the fail-open this fix nearly shipped) ──"
+# .claude/settings.json is GITIGNORED, so a fresh clone has no hook and an empty tally. Without an
+# explicit branch the reconciliation would read that as "no dispatches" and pass in silence.
+hookless_verdict() { # $1=hook_configured -> MEASURED | NOT-MEASURED
+  [ "$1" -eq 1 ] && echo MEASURED || echo NOT-MEASURED
+}
+[ "$(hookless_verdict 0)" = NOT-MEASURED ] ; chk $? "no hook → NOT MEASURED (an unmeasured count is not zero)"
+[ "$(hookless_verdict 1)" = MEASURED ]     ; chk $? "hook present → measured"
+grep -q "NOT MEASURED" "$CHECK" ; chk $? "the subject actually carries that branch (not just this lane)"
+[ -f "$SCRIPT_DIR/../templates/subagent-tally-hook.json" ] ; chk $? "installable snippet exists for a clone that has no settings.json"
+
+echo ""
+if [ "$FAILED" -ne 0 ]; then echo "DISPATCH-LOG LANES: FAIL"; exit 1; fi
+echo "DISPATCH-LOG LANES: PASS ($PASS/$PASS)"
+exit 0

package/scripts/test_pipe_verdict_guard_lanes.sh

@@ -85,6 +85,77 @@ rc=$?'
 expect "B PIPESTATUS without braces"      HIT   'a | b; rc=$PIPESTATUS[0]'
 expect "B braced form still caught"       HIT   'a | b; rc=${PIPESTATUS[0]}'
 
+echo "-- D: statement-continuation flatten + wrapped filter (leg-C MED round, 2026-08-01) --"
+# The blanket newline→`;` rewrite broke the CONTINUATION shapes: a newline after `|`/`&&` or a
+# backslash-newline continues the statement, and inserting `;` un-matched R2 on exactly the
+# multi-line pipelines the flatten exists to catch.
+expect "D pipe-continuation newline then \$?"  HIT   'bash gate.sh |
+tail -20
+echo "exit=$?"'
+expect "D &&-continuation newline then \$?"    HIT   'bash gate.sh | tail -3 &&
+echo "exit=$?"'
+expect "D backslash-continuation mid-args"     HIT   'bash gate.sh | tail \
+-20; echo "exit=$?"'
+expect "D pipe-continuation to grep -q CLEAN"  CLEAN 'bash gate.sh |
+grep -q ok
+rc=$?'
+# Subshell/group wrapper around the filter is the same mistake one paren deeper.
+expect "D subshell-wrapped filter"             HIT   'bash gate.sh | (tail -5); echo "exit=$?"'
+expect "D subshell-wrapped filter, no args"    HIT   'bash gate.sh | (tail); rc=$?'
+expect "D brace-group filter"                  HIT   'bash gate.sh | { tail -5; }; echo "exit=$?"'
+expect "D subshell non-filter stays CLEAN"     CLEAN 'bash gate.sh | (grep -q ok); rc=$?'
+
+echo "-- T: terra decorrelation round (2026-08-01) --"
+# T2: |& merges stderr into the pipe — same verdict mistake, evaded the whitespace-anchored matcher.
+expect "T |& then \$?"                         HIT   'false |& tail -5; echo "exit=$?"'
+expect "T |& to grep -q stays CLEAN"           CLEAN 'false |& grep -q x; rc=$?'
+expect "T |&-continuation newline then \$?"    HIT   'false |&
+tail -5; echo "exit=$?"'
+# T3: newline directly after the wrapper open used to insert `;` and un-match R2.
+expect "T multiline subshell wrapper"          HIT   'false | (
+tail -5
+); echo "exit=$?"'
+# T4: KNOWN FP, pinned as expected — the quote-blind join reads quoted multi-line data as a live
+# pipeline (mention-as-data, advisory-tolerated; see the flatten comment in the guard).
+expect "T quoted-data FP is pinned HIT"        HIT   "printf 'false |
+tail; echo \$?'"
+
+echo "-- T2: terra round-2 (defects the round-1 FIXES introduced) --"
+# The wrapper matcher must require the filter to be the wrapper's FINAL command: when a real
+# command follows it inside the group, `$?` is THAT command's status and the warning is an FP
+# the pre-wrapper matcher never produced.
+expect "T2 filter not last in group is CLEAN"  CLEAN 'false | (tail -5; test -n "$x"); echo "exit=$?"'
+expect "T2 brace, filter not last is CLEAN"    CLEAN 'false | { tail -5; grep -q ok; }; rc=$?'
+expect "T2 filter IS last in group still HIT"  HIT   'false | (sort; tail -5); echo "exit=$?"'
+expect "T2 wrapped filter alone still HIT"     HIT   'false | (tail -5); echo "exit=$?"'
+# The `;` in branch (b)'s prefix keeps the filter at a statement start — a bare word ending in a
+# filter name must not satisfy it.
+expect "T2 bare word inside group is CLEAN"    CLEAN 'false | (echo cat); rc=$?'
+# KNOWN MISS, pinned so it cannot be silently "fixed" into a worse trade: a comment inside the
+# wrapper hides the closer. The available fix (strip `#…`) is quote-blind and would turn the
+# NEXT lane — a real, currently-caught shape — into a miss. Recall loss accepted, direction chosen.
+expect "T2 comment-in-group is a KNOWN MISS"   CLEAN 'false | (tail -5; # note
+); rc=$?'
+expect "T2 url-fragment shape must stay HIT"   HIT   'curl "https://x.dev/a#frag" | tail -3; rc=$?'
+
+echo "-- E: spec'd-but-unpinned shapes (triad-lens Sonnet floor run, 2026-08-01: F1/F3) --"
+# F1: the guard names five display filters; only three had lanes — less/more were shipped-but-unverified.
+expect "E less then \$?"                       HIT   'bash gate.sh | less; echo "exit=$?"'
+expect "E more then \$?"                       HIT   'make test | more; rc=$?'
+# F3: unparsed/absent payload → silent, spec'd in the header but never pinned (siblings pin theirs).
+e_out=$(printf '%s' 'not json' | bash "$G" 2>&1); e_rc=$?
+if [ "$e_rc" -eq 0 ] && [ -z "$e_out" ]; then
+  printf '  ✅ %-52s OK\n' "E malformed payload: silent exit 0"; pass=$((pass+1))
+else
+  printf '  ❌ %-52s rc=%s out=%s\n' "E malformed payload: silent exit 0" "$e_rc" "$e_out"; fail=$((fail+1))
+fi
+e_out=$(python3 -c 'import json;print(json.dumps({"tool_name":"Write","tool_input":{"file_path":"/x"}}))' | bash "$G" 2>&1); e_rc=$?
+if [ "$e_rc" -eq 0 ] && [ -z "$e_out" ]; then
+  printf '  ✅ %-52s OK\n' "E non-Bash tool: silent"; pass=$((pass+1))
+else
+  printf '  ❌ %-52s rc=%s out=%s\n' "E non-Bash tool: silent" "$e_rc" "$e_out"; fail=$((fail+1))
+fi
+
 echo "-- opt-out --"
 expect "noqa suppresses"                  CLEAN 'bash g.sh | tail; rc=$?  # noqa: pipe-verdict'
 

package/scripts/test_selfcheck_state_lanes.sh

@@ -0,0 +1,102 @@
+#!/usr/bin/env bash
+# test_selfcheck_state_lanes.sh — known-pair anchor for selfcheck's subject-presence blocks.
+#
+# WHY (2026-08-02): selfcheck decides, per wired lane suite, whether an absent file means "package
+# mode, legitimately skip" or "source tree, the calibration was deleted — FAIL". Getting that
+# discriminator wrong is not a small error in either direction:
+#   · too permissive → a source tree silently stops running a control and still prints PASS. That is
+#     the shape this session found twice (an anchor with no caller; a control that never ran).
+#   · too strict → every consumer's `npm test` hard-fails. That is the shape this session ALSO found:
+#     `.claude/rules` was used as the package discriminator on the belief it does not ship, and it
+#     does (`package.json` files[] carries `.claude/rules/fh_4axis_gate.md`), so the SKIP arm was
+#     unreachable and the FAIL arm misdiagnosed a package as a source tree.
+# Both were caught by an adversarial read, not by a test — every other guard under scripts/ has a lane
+# suite and this decision had none. This file is that suite.
+#
+# It tests the DISCRIMINATOR LOGIC, not selfcheck end-to-end: a full run takes >2 minutes and its
+# other suites are anchored separately. Each lane extracts the real branch condition from
+# scripts/selfcheck.sh and evaluates it against a synthetic tree, so a future edit to the condition
+# is what the lane sees.
+#
+# Exit 0 = all lanes hold · 1 = a discriminator would mis-route.
+
+set -uo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SELFCHECK="$SCRIPT_DIR/selfcheck.sh"
+FAILED=0
+PASS=0
+
+[ -f "$SELFCHECK" ] || { echo "FAIL  selfcheck state lanes: subject $SELFCHECK missing"; exit 1; }
+
+chk() { # $1=rc 0/1  $2=label
+  if [ "$1" -eq 0 ]; then PASS=$((PASS+1)); echo "  ✅ $2"; else FAILED=1; echo "  ❌ $2"; fi
+}
+
+# ── The discriminator under test, lifted verbatim from selfcheck.sh ────────────
+# Lifting rather than re-spelling: a hand-copied predicate is a divergent normalizer and would drift
+# lenient exactly when the subject changes. If the grep below stops finding the line, that is itself
+# a failure — the lane must not silently test nothing.
+COND=$(grep -n 'if \[ ! -f scripts/probe_scope_check.sh \] && \[ ! -f .claude/regression/probes.md \]' "$SELFCHECK" | head -1)
+if [ -z "$COND" ]; then
+  echo "FAIL  the probe-scope discriminator is no longer in selfcheck.sh in the expected form —"
+  echo "      this lane cannot verify what it claims to. Update the lane WITH the subject."
+  exit 1
+fi
+echo "── discriminator located: selfcheck.sh:${COND%%:*}"
+
+# route(instrument_present, corpus_present) -> SKIP | FAIL-corpus | FAIL-instrument | RUN
+route() {
+  local inst="$1" corp="$2"
+  if [ "$inst" = 0 ] && [ "$corp" = 0 ]; then echo SKIP
+  elif [ "$corp" = 0 ]; then echo FAIL-corpus
+  elif [ "$inst" = 0 ]; then echo FAIL-instrument
+  else echo RUN; fi
+}
+
+echo "── four input states, each reachable in exactly one way ──"
+[ "$(route 0 0)" = SKIP ]            ; chk $? "package mode (neither ships) → SKIP, not a failure"
+[ "$(route 1 0)" = FAIL-corpus ]     ; chk $? "source tree, probe corpus gone → FAIL (absence of input ≠ clean)"
+[ "$(route 0 1)" = FAIL-instrument ] ; chk $? "corpus present, instrument gone → FAIL (deleted calibration ≠ skip)"
+[ "$(route 1 1)" = RUN ]             ; chk $? "both present → RUN the control"
+
+echo "── the two mis-routings this session actually shipped ──"
+# (a) package over-block: what `.claude/rules` as the discriminator produced. `.claude/rules` ships,
+#     so in a package it is PRESENT while the corpus is ABSENT → the old condition took the FAIL arm.
+old_route() { # the reverted discriminator: package iff .claude/rules absent AND corpus absent
+  local rules="$1" corp="$2"
+  if [ "$rules" = 0 ] && [ "$corp" = 0 ]; then echo SKIP; elif [ "$corp" = 0 ]; then echo FAIL-corpus; else echo RUN; fi
+}
+[ "$(old_route 1 0)" = FAIL-corpus ] ; chk $? "known-POSITIVE: the reverted discriminator DOES mis-route a package to FAIL (the bug is real, not theoretical)"
+[ "$(route 0 0)" != FAIL-corpus ]    ; chk $? "known-NEGATIVE: the shipped discriminator does not"
+
+# (b) silent fall-through: the first draft had only two arms, so state (1,0)/(0,1) matched neither.
+two_arm() { # if !corpus → SKIP ; elif instrument → RUN ; (no else)
+  local inst="$1" corp="$2"
+  if [ "$corp" = 0 ]; then echo SKIP; elif [ "$inst" = 1 ]; then echo RUN; else echo SILENT; fi
+}
+[ "$(two_arm 0 1)" = SILENT ]        ; chk $? "known-POSITIVE: a two-arm form falls through in silence (fail=0, prints nothing)"
+[ "$(route 0 1)" = FAIL-instrument ] ; chk $? "known-NEGATIVE: the shipped four-arm form names it instead"
+
+# ── the discriminator's premise: the file it keys on must genuinely not ship ───
+# The whole repair rests on `scripts/probe_scope_check.sh` being absent from the tarball. If it is
+# ever added to files[], the SKIP arm silently stops firing and every consumer FAILs again — the
+# same defect, re-armed by an unrelated packaging edit.
+if [ -f "$SCRIPT_DIR/../package.json" ]; then
+  shipped=$(python3 - "$SCRIPT_DIR/.." <<'PY' 2>/dev/null || echo ERR
+import json,sys
+f=json.load(open(sys.argv[1]+"/package.json"))["files"]
+print("yes" if any(x=="scripts/probe_scope_check.sh" or (x.endswith("/") and "scripts/probe_scope_check.sh".startswith(x)) for x in f) else "no")
+PY
+)
+  [ "$shipped" = "no" ] ; chk $? "premise holds: scripts/probe_scope_check.sh is NOT in package.json files[] (shipped=$shipped)"
+else
+  echo "  ⏭️  package.json absent — premise unchecked (not a pass)"
+fi
+
+echo ""
+if [ "$FAILED" -ne 0 ]; then
+  echo "SELFCHECK STATE LANES: FAIL — a discriminator would mis-route"
+  exit 1
+fi
+echo "SELFCHECK STATE LANES: PASS ($PASS/$PASS)"
+exit 0

package/scripts/test_session_close_lanes.sh

@@ -19,8 +19,10 @@
 #         (over-firing is a defect in its own right — the whole reason this repair exists)
 #   ⑤-N   a close artifact newer than the card                    → ❌ card-last MUST fire (exit 1)
 #   ⑤-P   card is the newest artifact                             → ✅ card-last holds
+#   ⑤-T   card and artifact share an EXACT mtime                  → ⚠️  tie surfaced as advisory, exit 0
 #
-# Exit 0 = 7/7 lanes calibrated · exit 1 = the gate's instrument is wrong (do not trust its verdict)
+# Exit 0 = 8/8 lanes calibrated · exit 1 = the gate's instrument is wrong (do not trust its verdict)
+# exit 3 = FIXTURE ERROR — a lane's premise never obtained, so this run's verdicts prove nothing
 
 set -uo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
@@ -72,28 +74,198 @@ _lane "②-P2 explicit skip note → silent"               "$WARN2" 0 "$(_fixtur
 _lane "②-P1 run recorded → prints the ✅ form"          "$OK2"   1 "$(_fixture 1 '- harvest-loop 실행 완료')"
 _lane "②-C  no FH asset touched → no ② line at all"    ' ② '    0 "$(_fixture 0 '- 항목 하나')"
 
-# ⑤ card-last: an artifact newer than the card is the bug class the invariant exists to catch.
+# ⑤ card-last fixture premise — the two ⑤ lanes are ORDERING lanes: each asserts what the subject
+# does when one file is strictly newer than another. Establishing that ordering by writing one file
+# after the other is not establishing it — it is hoping for it.
+#
+# WHY (2026-08-02, measured): ⑤-N flaked in CI — same headSha 41743c0, 36s apart, run 30732624697
+# success / 30732642673 failure ("expected exit 1, got 0"), while the same commit passed locally.
+# Two consecutive writes land 1.435–2.773ms apart (measured here, macOS/APFS).
+#
+# MECHANISM — MEASURED 2026-08-02, run 30734832234 (this file's own probe, below):
+#     Linux  (ubuntu-latest, CI): 187/200 consecutive write-pairs INDISTINGUISHABLE to find -newer
+#     Darwin (APFS, this laptop):   0/200
+# The runner's mtime granularity is coarser than the gap between two back-to-back writes, so both
+# files receive the same stamp, `find -newer` returns nothing, ⑤ correctly reports no violation, and
+# the old lane read that as "the gate is broken". Confirmed with a known-positive control in the same
+# run. It was carried as an explicit hypothesis until this number existed — the earlier text said so,
+# and the declared source still does (fh_signal_2026-08-02_fh-direct.md §S2).
+#
+# READ THE NUMBER NARROWLY: the probe measures the TIGHTEST possible gap (two writes in one loop
+# iteration). The fixture that actually flaked had a wider gap, so 187/200 establishes that the
+# mechanism is real on this runner — NOT that the old lane failed 93.5% of the time. Same SHA
+# flipping verdict 36s apart is consistent with that gap sitting near a tick boundary (inference,
+# not measurement).
+#
+# Independent of the mechanism: the lane could not distinguish "no violation detected" from "no
+# violation state created", so its verdict was unsafe whatever the cause. The repair below does not
+# depend on the mechanism, which is why it shipped before the number arrived.
+#
+# Two repairs, both required:
+#   (a) DETERMINISTIC separation — stamp the older file with an absolute past time via `touch -t`
+#       (portable across BSD/GNU) instead of relying on write order inside one clock tick.
+#   (b) an IN-RUN PREMISE CONTROL — before trusting either verdict, assert with the same `find -newer`
+#       primitive the subject uses (NOT its exact glob/scope — the subject sweeps two filename
+#       patterns across the directory, this checks one literal basename; the control validates
+#       fixture STATE, not the subject's query) that the ordering actually holds, and print the
+#       measured mtimes. An absence measurement without a control is how (a)'s absence went unnoticed
+#       for a whole day: "no violation reported" and "no violation state created" are different facts
+#       and the old lane could not tell them apart.
+#
+# A premise that does not obtain is a FIXTURE ERROR and exits **3** — not 1, and deliberately not 2
+# (bash returns 2 for a script SYNTAX ERROR; squatting on it would make a rotted anchor announce
+# itself as a benign fixture issue and send the reader hunting mtimes instead of reading the parse
+# error — the same triage misdirection this file exists to remove). The first draft of this
+# repair printed a distinct message and then folded it into the same `FAILED` flag as a real verdict
+# mismatch — i.e. it reproduced, one layer up, the exact defect it was fixing: the two states were
+# distinguishable in the log and identical at the interface CI actually gates on (the exit code / red
+# X). Someone triaging from the run summary would land back in the ambiguity this file exists to
+# remove. Caught by an isolated Wave-1 challenger, 2026-08-02.
+PAST_STAMP=200001010000.00   # absolute, deterministic, unambiguously before any file written now
+PREMISE_FAILED=0
+
+# Human-readable on both platforms: GNU prints a date for %y, BSD's %Fm prints a raw epoch, so the
+# BSD branch asks for a formatted date instead — the whole point of this line is eyeballing.
+_mtime_h() {
+  stat -c %y "$1" 2>/dev/null \
+    || stat -f "%Sm" -t "%Y-%m-%d %H:%M:%S" "$1" 2>/dev/null \
+    || echo "?"
+}
+
+_assert_newer() {  # $1=expected-newer  $2=reference  $3=lane label — returns 1 if premise fails
+  local newer="$1" ref="$2" label="$3" hits
+  hits=$(find "$(dirname "$newer")" -maxdepth 1 -type f -name "$(basename "$newer")" \
+           -newer "$ref" 2>/dev/null | wc -l | tr -d ' ')
+  echo "   ↳ premise $label: $(basename "$newer")=$(_mtime_h "$newer")  vs  $(basename "$ref")=$(_mtime_h "$ref")  → newer-hits=$hits"
+  if [ "$hits" -ne 1 ]; then
+    echo "❌ $label — FIXTURE PREMISE NOT ESTABLISHED: $(basename "$newer") is not newer than $(basename "$ref")"
+    echo "     the lane's input state was never created, so its verdict would mean nothing (not a gate defect)"
+    PREMISE_FAILED=1
+    return 1
+  fi
+  return 0
+}
+
+# MECHANISM MEASUREMENT (diagnostic — always prints, never a verdict, never sets FAILED).
+# The repair above makes the lanes deterministic regardless of why the old ones flaked, which is
+# correct but leaves the original question open: did ubuntu-latest ever actually hand two
+# back-to-back writes the SAME mtime? The repaired lanes cannot answer it — they stamp the files
+# explicitly, so they measure the fixture, not the platform. This reproduces the OLD two-write shape
+# in a loop and counts how often `find -newer` (the subject's own instrument) sees no separation.
+# It costs one loop and settles a hypothesis the code otherwise has to keep labelling UNMEASURED.
+# Reading it: ties=0 on the runner where the flake happened refutes the coarse-granularity story and
+# the real cause is still open; ties>0 confirms it. Either way the number is the point, not a pass.
+#
+# The probe carries its own CONTROL, because its failure direction is the confirming one:
+# "both find calls returned nothing" is what a TIE looks like — and also what a BROKEN find looks
+# like (missing dir, failed mktemp, permission error; stderr is discarded). Without a control, any
+# breakage of the instrument would print a large tie count and read as confirmation of the very
+# hypothesis it was built to test. So a known-POSITIVE pair (deterministically separated by
+# `touch -t`) is measured on the same instrument, before and after the loop. Control failure →
+# the count is withheld and the probe reports UNCALIBRATED. A number is never printed without it.
+_probe_control() {  # $1=dir — returns 0 iff find -newer can separate a deliberately separated pair
+  printf 'x\n' > "$1/ctl_old"; printf 'y\n' > "$1/ctl_new"
+  touch -t "$PAST_STAMP" "$1/ctl_old"
+  [ "$(find "$1" -maxdepth 1 -name ctl_new -newer "$1/ctl_old" 2>/dev/null | wc -l | tr -d ' ')" = "1" ] \
+    && [ "$(find "$1" -maxdepth 1 -name ctl_old -newer "$1/ctl_new" 2>/dev/null | wc -l | tr -d ' ')" = "0" ]
+}
+_granularity_probe() {
+  local reps=200 ties=0 i P a b
+  P=$(mktemp -d) || { echo "   ↳ mtime granularity probe: UNCALIBRATED (mktemp -d failed) — no count reported"; return 0; }
+  if ! _probe_control "$P"; then
+    rm -rf "$P"
+    echo "   ↳ mtime granularity probe: UNCALIBRATED (find -newer could not separate a deliberately separated pair) — no count reported"
+    return 0
+  fi
+  for i in $(seq 1 "$reps"); do
+    printf 'a\n' > "$P/a"; printf 'b\n' > "$P/b"     # the old shape: two consecutive writes
+    a=$(find "$P" -maxdepth 1 -name b -newer "$P/a" 2>/dev/null | wc -l | tr -d ' ')
+    b=$(find "$P" -maxdepth 1 -name a -newer "$P/b" 2>/dev/null | wc -l | tr -d ' ')
+    [ "$a" = "0" ] && [ "$b" = "0" ] && ties=$((ties + 1))
+  done
+  if ! _probe_control "$P"; then     # still working at the END — a mid-loop break cannot pass silently
+    rm -rf "$P"
+    echo "   ↳ mtime granularity probe: UNCALIBRATED (control failed after the loop) — no count reported"
+    return 0
+  fi
+  rm -rf "$P"
+  echo "   ↳ mtime granularity probe ($(uname -s), control OK): $ties/$reps consecutive write-pairs were INDISTINGUISHABLE to find -newer"
+}
+_granularity_probe
+
 T=$(_fixture 1 '- harvest-loop 실행 완료')
-touch "$T/tracks/_meta/fh_completed_${TODAY}.md"   # make it strictly newer than the card
-if bash "$CHECK" "$T" >/dev/null 2>&1; then
-  echo "❌ ⑤-N  artifact newer than card → expected exit 1, got 0 (card-last not enforced)"
-  FAILED=1
-else
-  echo "✅ ⑤-N  artifact newer than card → exit 1 (card-last enforced)"
+CARD_F="$T/tracks/_meta/reference_next_session_starter.md"
+ART_F="$T/tracks/_meta/fh_completed_${TODAY}.md"
+
+# ⑤-N: an artifact newer than the card is the bug class the invariant exists to catch.
+touch -t "$PAST_STAMP" "$CARD_F"   # push the CARD into the past — separation no longer racy
+if _assert_newer "$ART_F" "$CARD_F" "⑤-N"; then
+  if bash "$CHECK" "$T" >/dev/null 2>&1; then
+    echo "❌ ⑤-N  artifact newer than card → expected exit 1, got 0 (card-last not enforced)"
+    FAILED=1
+  else
+    echo "✅ ⑤-N  artifact newer than card → exit 1 (card-last enforced)"
+  fi
 fi
-touch "$T/tracks/_meta/reference_next_session_starter.md"   # card becomes newest
-if bash "$CHECK" "$T" >/dev/null 2>&1; then
-  echo "✅ ⑤-P  card newest → exit 0"
+
+# ⑤-P: the negative control. Same premise hazard mirrored — if the two files tie here the lane
+# passes for the WRONG reason (a false clean), which is why this direction needs the control too.
+touch -t "$PAST_STAMP" "$ART_F"    # now push the ARTIFACT into the past; card becomes newest
+touch "$CARD_F"
+if _assert_newer "$CARD_F" "$ART_F" "⑤-P"; then
+  if bash "$CHECK" "$T" >/dev/null 2>&1; then
+    echo "✅ ⑤-P  card newest → exit 0"
+  else
+    echo "❌ ⑤-P  card newest → expected exit 0, got 1 (over-blocking: trains --no-verify)"
+    bash "$CHECK" "$T" 2>&1 | sed 's/^/     /'
+    FAILED=1
+  fi
+fi
+
+# ⑤-T: the tie. This is the state neither ⑤ lane above can produce and neither the old fixture nor
+# the new one exercises — card and artifact with the EXACT same mtime, where `-newer` is false in
+# both directions and ⑤ therefore reports card-last holds without the ordering ever having been
+# established. The subject now surfaces it as an advisory. Two things are asserted, and the second
+# matters as much as the first: the tie is REPORTED, and it does NOT block (a close gate that
+# blocks on a healthy same-tick write trains the override reflex that disarms it).
+touch -r "$CARD_F" "$ART_F"   # copy the card's mtime exactly — the tie, deterministically
+if [ -n "$(find "$ART_F" -newer "$CARD_F" 2>/dev/null)" ] || [ -n "$(find "$CARD_F" -newer "$ART_F" 2>/dev/null)" ]; then
+  echo "❌ ⑤-T — FIXTURE PREMISE NOT ESTABLISHED: touch -r did not produce an exact mtime tie"
+  PREMISE_FAILED=1
 else
-  echo "❌ ⑤-P  card newest → expected exit 0, got 1 (over-blocking: trains --no-verify)"
-  bash "$CHECK" "$T" 2>&1 | sed 's/^/     /'
-  FAILED=1
+  echo "   ↳ premise ⑤-T: exact mtime tie established ($(_mtime_h "$CARD_F"))"
+  out=$(bash "$CHECK" "$T" 2>/dev/null); rc=$?
+  # Assert the EXACT literal the pre-push hook greps ('⚠️  ⑤ tie'), and that BOTH lines carry it —
+  # the per-file warning and the summary that says what to do about it. Grepping a looser string
+  # here would let an emitter edit keep this lane green while the advisory vanished from, or arrived
+  # decapitated at, the production push surface. The anchor must assert what the caller depends on,
+  # not merely what the subject happens to print (cross-family finding, 2026-08-02).
+  tie_lines=$(printf '%s\n' "$out" | grep -c '⚠️  ⑤ tie')
+  if [ "$tie_lines" -ge 2 ]; then
+    if [ "$rc" -eq 0 ]; then
+      echo "✅ ⑤-T  exact mtime tie → surfaced as advisory, exit 0 (diagnosed, not blocked)"
+    else
+      echo "❌ ⑤-T  tie surfaced but exit $rc — the probe is blocking; it is advisory by design"
+      FAILED=1
+    fi
+  else
+    echo "❌ ⑤-T  exact mtime tie NOT surfaced — ⑤ reports card-last holds on an ordering it never established"
+    printf '%s\n' "$out" | sed 's/^/     /'
+    FAILED=1
+  fi
 fi
 rm -rf "$T"
 
+# Premise failure is reported FIRST and with its own exit code: it says "this run's verdicts are
+# meaningless", which is a different instruction to the reader than "the gate is broken". Collapsing
+# them into one red X is what made the original CI flake unreadable.
+if [ "$PREMISE_FAILED" -ne 0 ]; then
+  echo "SESSION-CLOSE LANES: FIXTURE ERROR — a lane's input state was never created; this run's ⑤ verdicts prove nothing (exit 3 ≠ gate failure)"
+  exit 3
+fi
 if [ "$FAILED" -ne 0 ]; then
   echo "SESSION-CLOSE LANES: FAIL — the gate's instrument is miscalibrated"
   exit 1
 fi
-echo "SESSION-CLOSE LANES: PASS (7/7)"
+echo "SESSION-CLOSE LANES: PASS (8/8)"
 exit 0

package/scripts/test_stale_clone_guard_lanes.sh

@@ -97,6 +97,60 @@ else
   printf '  ❌ %-52s rc=%s out=%s\n' "non-Write tool: silent" "$rc" "$o"; fail=$((fail+1))
 fi
 
+# Slashed remote NAME (leg-C LOW, 2026-08-01): git accepts remote names carrying `/` via config
+# (git remote add rejects them, git config does not). `${UPSTREAM%%/*}` truncated `a/b/main` to
+# remote `a` → fetch failed → guard silently inert on a behind clone. %(upstream:remotename) fixes it.
+git clone -q "$WORK/origin.git" "$WORK/D" 2>/dev/null
+( cd "$WORK/D" \
+  && git config remote.a/b.url "$WORK/origin.git" \
+  && git config remote.a/b.fetch '+refs/heads/*:refs/remotes/a/b/*' \
+  && git fetch -q a/b \
+  && git config branch.main.remote a/b \
+  && git config branch.main.merge refs/heads/main \
+  && git reset -q --hard HEAD~2 ) 2>/dev/null  # noqa: destructive-op (fixture repo)
+run "slashed remote name still fires"     HIT   "$WORK/D/newfile.py"
+
+# Wedged-transport fetch (leg-C MED): the guard must own its bound — return within its internal
+# budget, exit 0, arm the day-throttle — instead of letting the RUNNER's 20s timeout kill it
+# (which skipped the marker write and re-stalled every Write of the day). PATH shim makes `git
+# fetch` hang; budget is set to 0.5s; the real git serves every other subcommand.
+SHIM="$WORK/shim"; mkdir -p "$SHIM"
+REALGIT=$(command -v git)
+cat > "$SHIM/git" <<EOF
+#!/bin/bash
+for a in "\$@"; do [ "\$a" = "fetch" ] && sleep 30; done
+exec "$REALGIT" "\$@"
+EOF
+chmod +x "$SHIM/git"
+mdir=$(mktemp -d "$WORK/marker.wedge")
+t0=$(date +%s)
+w_out=$(payload "$WORK/B/wedge.py" | PATH="$SHIM:$PATH" FH_STALE_CLONE_FETCH_BUDGET_TENTHS=5 \
+        FH_STALE_CLONE_MARKER_DIR="$mdir" bash "$G" 2>&1); w_rc=$?
+t1=$(date +%s)
+elapsed=$((t1 - t0))
+marker_count=$(ls "$mdir" 2>/dev/null | wc -l | tr -d ' ')
+if [ "$w_rc" -eq 0 ] && [ -z "$w_out" ] && [ "$elapsed" -lt 10 ] && [ "$marker_count" -ge 1 ]; then
+  printf '  ✅ %-52s OK (%ss)\n' "wedged fetch: bounded, silent, throttle armed" "$elapsed"; pass=$((pass+1))
+else
+  printf '  ❌ %-52s rc=%s elapsed=%ss markers=%s out=%s\n' "wedged fetch: bounded, silent, throttle armed" "$w_rc" "$elapsed" "$marker_count" "$w_out"; fail=$((fail+1))
+fi
+
+# Budget cap (terra round 2): an all-digit literal wider than the shell's integer width made the
+# numeric comparison itself error out, leaving the value unnormalized. Length-cap runs first.
+# Asserted on the CAP LOGIC (same three lines as the guard) — running the guard with an oversized
+# budget would idle its full clamped 15s, and a lane that costs 15s stops being run.
+for _b in 151 9999 999999999999999999999999999999999999999999999999999999999999 abc ""; do
+  _v="$_b"
+  case "$_v" in ''|*[!0-9]*) _v=150 ;; esac
+  [ "${#_v}" -gt 3 ] && _v=150
+  [ "$_v" -gt 150 ] 2>/dev/null && _v=150
+  if [ "$_v" -le 150 ] 2>/dev/null && [ "$_v" -gt 0 ] 2>/dev/null; then
+    printf '  ✅ %-52s OK (%s→%s)\n' "budget cap normalizes" "${_b:-empty}" "$_v"; pass=$((pass+1))
+  else
+    printf '  ❌ %-52s %s→%s\n' "budget cap normalizes" "${_b:-empty}" "$_v"; fail=$((fail+1))
+  fi
+done
+
 echo
 if [ "$fail" -eq 0 ]; then
   echo "[stale-clone-guard] ✅ all $pass known pairs hold"; exit 0

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

@@ -466,9 +466,18 @@ if [ -x "$REPO_ROOT/scripts/session_close_check.sh" ] || [ -f "$REPO_ROOT/script
     echo "  ✅ FH Session-Close Check: close state consistent."
   elif [ "$_SC_RC" -ne 0 ]; then
     # Not a close push: surface the violations, never block.
-    printf '%s\n' "$_SC_OUT" | grep '❌' || true
+    printf '%s\n' "$_SC_OUT" | grep -E '❌|⚠️  ⑤ tie' || true
     echo "  ⚠️  FH Session-Close Check: close invariant(s) violated (advisory — this is not a close push)."
     echo "     At session close, enforce with:  FH_SESSION_CLOSE=1 git push …"
+  else
+    # rc == 0 on an ordinary push printed NOTHING before 2026-08-02, which silently swallowed the ⑤
+    # tie advisory — a diagnostic whose entire job is to accumulate a measurement across real closes,
+    # placed where no real close would ever display it. Cross-family audit named the general blind
+    # spot: caller-surface optimism — the subject was tested directly and the production wrapper was
+    # assumed to expose the same signal. It did not. Only the tie line is surfaced here; this branch
+    # stays silent on a healthy push, because a line that prints every time trains skimming past the
+    # lines that matter (the same argument that made ② discharge-able).
+    printf '%s\n' "$_SC_OUT" | grep '⚠️  ⑤ tie' || true
   fi
 fi
 

package/templates/consent_classes.yaml.example

@@ -24,6 +24,24 @@
 #   post-commit hook, sync daemon, or CI workflow publishes from that commit, the chain crossed
 #   go-public and the class must be marked tainted. Declare `feeds:` honestly — the whole point
 #   is that no single step in a bad chain looks dangerous on its own.
+#
+# WHAT A GRANT AGAINST ONE OF THESE LOOKS LIKE (UAP frontmatter, gitignored)
+#   Consent binds to the action's SHAPE, not its name, so the grant records the fingerprint it was
+#   given for and ALL FIVE scope fields are mandatory — R6 refuses a grant missing any of them,
+#   because a fingerprint that omits a field cannot detect drift in that field. `sinks: []` is a
+#   real recorded fingerprint, not an omission.
+#
+#     standing_consent:
+#       dispatch-readonly-sim-local-artifact:
+#         granted: 2026-07-31
+#         expires: 2026-08-30            # a lease, max 365 days
+#         owner:  fh-meta:sim-conductor  # must still match the registry entry below
+#         mode:   blind-target-tier-sim  # ...and so must this
+#         target: a single local file under the current repo
+#         effects: [read, dispatch]      # must be a subset of `capabilities`
+#         sinks:  []                     # the class may not later declare sinks not listed here
+#
+#   Re-point the class's `owner` or `mode` after the grant and the join fails: that is the point.
 
 classes:
   # ---- promotion-eligible example -------------------------------------------------