@chrono-meta/fh-gate 1.4.95 → 1.4.97

package/plugins/fh-meta/skills/harness-doctor/SKILL_detail.md

@@ -157,7 +157,17 @@ done
 #### 5-2. CATALOG.md Open Item Count
 
 ```bash
-awk '/^### /{count++} count<=5{print}' CATALOG.md 2>/dev/null | grep -c "^- Open:" || echo "0"
+# An ABSENT CATALOG.md must not render as "0 open items" — that is the not-found-as-zero class this
+# whole file exists to close, and the old form produced it twice over: `2>/dev/null` swallowed awk's
+# error, and `grep -c … || echo "0"` printed a SECOND "0" on no-match (the counter already prints
+# its own "0" before exiting non-zero). `|| true` is the safe fallback — it prints nothing.
+if [ ! -f CATALOG.md ]; then
+  echo "5-2 UNMEASURED: CATALOG.md not found — absent is not 'no open items'"
+else
+  open_count=$(awk '/^### /{count++} count<=5{print}' CATALOG.md | grep -c "^- Open:" || true)
+  open_count=$(( ${open_count:-0} + 0 ))
+  echo "5-2 Open items (5 most recent sections): ${open_count}"
+fi
 ```
 
 > Do not use `grep -c "^- Open:" CATALOG.md` — returns hundreds as false positives counting entire history.
@@ -165,12 +175,24 @@ awk '/^### /{count++} count<=5{print}' CATALOG.md 2>/dev/null | grep -c "^- Open
 #### 5-3. Field Project CLAUDE.md Existence
 
 ```bash
-grep -oE '`~/[^`]+`' .claude/memory/reference_field_projects.md 2>/dev/null \
-  | tr -d '`' | sed "s|~|$HOME|g" | while read p; do
-    [ -f "$p/CLAUDE.md" ] && echo "OK: $p" || echo "MISSING CLAUDE.md: $p"
-  done
+# The index file may not exist at all. `not found` != `0 problems` — an absent
+# index must print MISSING INDEX, never an empty (= "all OK") result.
+field_index=.claude/memory/reference_field_projects.md
+if [ ! -f "$field_index" ]; then
+  echo "MISSING INDEX: $field_index (5-3 UNMEASURED — not a pass)"
+else
+  grep -oE '`~/[^`]+`' "$field_index" \
+    | tr -d '`' | sed "s|~|$HOME|g" | while read p; do
+      [ -f "$p/CLAUDE.md" ] && echo "OK: $p" || echo "MISSING CLAUDE.md: $p"
+    done
+fi
 ```
 
+> Known-pair calibration for this block: a **known-positive** path that does exist
+> (`.claude/rules/fh_4axis_gate.md`) must print its `OK:`/`MISSING CLAUDE.md:` verdict, while an
+> absent index must print `MISSING INDEX`. Do not add `2>/dev/null` back — it was what turned a
+> non-existent directory into a silent zero-byte "everything is fine".
+
 ---
 
 ## §L5-Detail — Bash Scripts for L5-A, L5-B, L5-C
@@ -178,23 +200,33 @@ grep -oE '`~/[^`]+`' .claude/memory/reference_field_projects.md 2>/dev/null \
 ### L5-A Skill Activity (bash)
 
 ```bash
+# SHELL PORTABILITY (2026-08-12, measured): the earlier form used `for f in $recent_sessions`.
+# bash word-splits an unquoted parameter expansion on IFS; **zsh does not** (SH_WORD_SPLIT is off by
+# default, and zsh is the macOS login shell these fences get pasted into). Under zsh the loop ran
+# ONCE with the entire newline-joined list as a single filename, every grep missed, and this block
+# reported EVERY skill as INACTIVE_90D — the harness declaring its own skills dead. Note the
+# direction: not a permissive false clean, a false ALARM, which is why no lane caught it.
+# `printf | while IFS= read -r` is the portable iteration; it is also correct for names with spaces.
+# `grep -qi` (not `-li`) — `-l` printed each matching filename into the report as noise.
+# `count=$(... | grep -c x || true)`: `|| true` PRINTS NOTHING, so it cannot produce the "0\n0"
+# two-line disarm that `|| echo 0` produces (see the L5-C note below). Do not "simplify" it back.
 recent_sessions=$(find tracks/ -name "session_*.md" -mtime -30 2>/dev/null)
 if [ -z "$recent_sessions" ]; then
   echo "L5-A SKIP: no session records — re-diagnose after 30 days"
 else
-  installed_skills=$(ls plugins/fh-meta/skills/ 2>/dev/null)
-
-  for skill in $installed_skills; do
-    count=0
-    for f in $recent_sessions; do
-      grep -li "$skill\|/$skill" "$f" 2>/dev/null && ((count++)) || true
-    done
+  sessions_90d=$(find tracks/ -name "session_*.md" -mtime -90 2>/dev/null)
+
+  ls plugins/fh-meta/skills/ 2>/dev/null | while IFS= read -r skill; do
+    [ -n "$skill" ] || continue
+    count=$(printf '%s\n' "$recent_sessions" | while IFS= read -r f; do
+              [ -f "$f" ] && grep -qi "$skill" "$f" 2>/dev/null && printf 'x\n'
+            done | grep -c x || true)
+    count=$(( ${count:-0} + 0 ))
     if [ "$count" -eq 0 ]; then
-      sessions_90d=$(find tracks/ -name "session_*.md" -mtime -90 2>/dev/null)
-      count_90d=0
-      for f in $sessions_90d; do
-        grep -li "$skill\|/$skill" "$f" 2>/dev/null && ((count_90d++)) || true
-      done
+      count_90d=$(printf '%s\n' "$sessions_90d" | while IFS= read -r f; do
+                    [ -f "$f" ] && grep -qi "$skill" "$f" 2>/dev/null && printf 'x\n'
+                  done | grep -c x || true)
+      count_90d=$(( ${count_90d:-0} + 0 ))
       if [ "$count_90d" -eq 0 ]; then
         echo "INACTIVE_90D: $skill (no call record in 90 days)"
       else
@@ -216,7 +248,10 @@ recent_sessions=$(find tracks/ -name "session_*.md" -mtime -30 2>/dev/null)
 [ -z "$recent_sessions" ] && echo "L5-B SKIP: no session records" && exit 0
 
 # hub-persona-auditor misuse: code PR or internal refactoring context
-for f in $recent_sessions; do
+# `printf | while read`, not `for f in $recent_sessions` — zsh does not word-split a parameter
+# expansion, so the `for` form scanned one bogus blob filename and reported "no misuse" every time.
+printf '%s\n' "$recent_sessions" | while IFS= read -r f; do
+  [ -f "$f" ] || continue
   if grep -q "hub-persona-auditor" "$f" 2>/dev/null; then
     context=$(grep -n "hub-persona-auditor" "$f" | head -3)
     echo "$context" | while IFS=: read linenum rest; do
@@ -229,7 +264,8 @@ for f in $recent_sessions; do
 done
 
 # sim-conductor misuse: first run without onboarding context
-for f in $recent_sessions; do
+printf '%s\n' "$recent_sessions" | while IFS= read -r f; do
+  [ -f "$f" ] || continue
   if grep -q "sim-conductor" "$f" 2>/dev/null; then
     context=$(grep -n "sim-conductor" "$f" | head -3)
     echo "$context" | while IFS=: read linenum rest; do
@@ -242,8 +278,13 @@ for f in $recent_sessions; do
 done
 
 # harness-doctor self-loop misuse
-for f in $recent_sessions; do
-  count=$(grep -c "harness-doctor" "$f" 2>/dev/null || echo 0)
+printf '%s\n' "$recent_sessions" | while IFS= read -r f; do
+  [ -f "$f" ] || continue
+  # `grep -c` prints 0 AND exits 1 on no-match, so `|| echo 0` appends a SECOND line
+  # ("0\n0") and every later [ -eq/-gt ] test dies with "integer expression expected".
+  # `|| true` keeps the exit code from killing the assignment without corrupting the value.
+  count=$(grep -c "harness-doctor" "$f" || true)
+  count=$(( ${count:-0} + 0 ))
   if [ "$count" -gt 2 ]; then
     echo "L5-B MISUSE (suspected): harness-doctor @ $f — self-loop suspected (${count} mentions in same session)"
   fi
@@ -281,14 +322,21 @@ if [ "$skill_count" -gt 0 ]; then
 fi
 
 # E3: CATALOG.md Open item consumption rate
-current_open=$(awk '/^### /{count++} count<=5{print}' CATALOG.md 2>/dev/null | grep -c "^- Open:" || echo 0)
-past_open=$(git show "HEAD@{30 days ago}:CATALOG.md" 2>/dev/null \
-  | awk '/^### /{count++} count<=5{print}' | grep -c "^- Open:" || echo "N/A")
-if [ "$past_open" != "N/A" ]; then
+# NEVER use `grep -c ... || echo N/A` here: grep -c prints "0" and exits 1 on no-match, so the
+# fallback appends a second line ("0\nN/A"), the != "N/A" test passes, and $(( )) then dies with a
+# syntax error — the E3 line vanishes entirely (silent non-measurement, not a skip).
+# Separate the two questions: (a) is history reachable at all, (b) what is the count.
+current_open=$(awk '/^### /{count++} count<=5{print}' CATALOG.md 2>/dev/null | grep -c "^- Open:" || true)
+current_open=$(( ${current_open:-0} + 0 ))
+past_catalog=$(git show "HEAD@{30 days ago}:CATALOG.md" 2>/dev/null || true)
+if [ -z "$past_catalog" ]; then
+  echo "E3_SKIP: git history < 30 days or CATALOG.md absent then (UNMEASURED — not zero)"
+else
+  past_open=$(printf '%s\n' "$past_catalog" \
+    | awk '/^### /{count++} count<=5{print}' | grep -c "^- Open:" || true)
+  past_open=$(( ${past_open:-0} + 0 ))
   consumed=$((past_open - current_open))
   echo "E3: Open items consumed ${consumed} (30 days ago: ${past_open} → now: ${current_open})"
-else
-  echo "E3_SKIP: git history < 30 days"
 fi
 
 # E4: harvest signals
@@ -318,13 +366,28 @@ if [ ! -f "$manifest" ]; then
     && echo "E7_WARN: ${recent_asset_edits} asset edit(s) in 14d but no edit_manifest.yaml" \
     || echo "E7: no recent asset edits"
 else
-  manifest_recent=$(grep -c "$(date +%Y-%m)" "$manifest" 2>/dev/null || echo 0)
-  [ "$recent_asset_edits" -gt 0 ] && [ "$manifest_recent" -eq 0 ] \
-    && echo "E7_WARN: asset edits exist but no manifest entry this month" \
-    || echo "E7_OK: edit_manifest.yaml present with recent entries"
+  # `grep -c` on zero matches prints "0" and exits 1 → `|| echo 0` made this "0\n0", the
+  # -eq test then errored out (non-zero = false), and control fell through to the `||` branch:
+  # E7_OK. The evolution-loop blindness detector was structurally unable to raise its own alarm.
+  # `|| true` + arithmetic normalisation is what makes the WARN arm reachable.
+  manifest_recent=$(grep -c "$(date +%Y-%m)" "$manifest" || true)
+  manifest_recent=$(( ${manifest_recent:-0} + 0 ))
+  if [ "$recent_asset_edits" -gt 0 ] && [ "$manifest_recent" -eq 0 ]; then
+    echo "E7_WARN: ${recent_asset_edits} asset edit(s) in 14d but no manifest entry this month"
+  else
+    echo "E7_OK: edit_manifest.yaml present with ${manifest_recent} entr(ies) this month"
+  fi
 fi
 ```
 
+> **Known-pair calibration (mandatory before trusting E7).** Run both arms:
+> **negative arm** — point `manifest` at a file with no current-month entries while asset edits
+> exist → must print `E7_WARN`; **positive arm** — the real
+> `tracks/_meta/edit_manifest.yaml` → must print `E7_OK` with a non-zero entry count.
+> If the negative arm prints `E7_OK`, the detector is dead and its silence means nothing.
+> Note the `if/else` form: the old `[ ... ] && echo A || echo B` chain also falls to `B`
+> whenever the *first* test is false, which is a second route to the same false pass.
+
 ---
 
 ## §Step11 — PR Change Consistency Check Bash Scripts
@@ -332,13 +395,26 @@ fi
 ### 11-1. Detect Changed Files
 
 ```bash
+# Two defects lived here and both produced phantom downstream counts:
+#  (1) `return 0` is only valid inside a function/sourced script. Run as a plain block it
+#      printed "can only `return' from a function" to stderr and CARRIED ON into 11-2A/B/C.
+#  (2) `echo "" | wc -l` is 1, not 0 — so "no changes" was announced as "1 total".
+# `exit 0` actually stops the block, and `grep -c .` counts non-empty lines only.
 changed=$(git diff main..HEAD --name-only 2>/dev/null)
 [ -z "$changed" ] && changed=$(git diff --cached --name-only 2>/dev/null)
-[ -z "$changed" ] && echo "PR_CHECK: no changes detected vs main — skip" && return 0
-echo "=== Changed files ($(echo "$changed" | wc -l | tr -d ' ') total) ==="
+if [ -z "$changed" ]; then
+  echo "PR_CHECK: no changes detected vs main — skip (Step 11 UNMEASURED, run nothing below)"
+  exit 0
+fi
+changed_count=$(printf '%s\n' "$changed" | grep -c . || true)
+echo "=== Changed files ($(( ${changed_count:-0} + 0 )) total) ==="
 echo "$changed"
 ```
 
+> Steps 11-2A/B/C consume `$changed` and must not run when it is empty. If you inline this
+> into a larger function, swap `exit 0` for `return 0` — but never leave a bare `return` in a
+> block that is executed directly, which is what silently disarmed the guard.
+
 ### 11-2A. SKILL.md Changes → Count Drift + README + CATALOG
 
 ```bash

package/plugins/fh-meta/skills/harvest-loop/SKILL.md

@@ -123,7 +123,12 @@ Output final proposal list → Y: PR creation / N: persist to tracks/_meta/fh_si
 
 ### Step 3.75 — Critic (Isolated Agent)
 
-> Source: SAGE (arXiv 2603.15255). Isolation = Critic does not inherit synthesizer reasoning chain → resolves Cost of Consensus.
+> Isolation = the Critic does not inherit the synthesizer's reasoning chain. **This is an FH design
+> decision, not a borrowed one.** Its evidence is arXiv 2605.00914 (*The Cost of Consensus*): plurality
+> voting discards correct answers already present in the pool (oracle gap ≤32.3pp) and peer rationales
+> destabilize previously-correct reasoning (≤70.0%) — so the reviewer must not stand inside the
+> generator's chain. *Corrected 2026-08-11: this line previously cited SAGE (arXiv 2603.15255) as the
+> isolation source. SAGE's four agents **co-evolve from a shared backbone** — the opposite structure.*
 
 Critic evaluation: Done When logic validation · failure mode exploration (2+ edge cases) · claim vs. implementation alignment · scope appropriateness (Too Narrow / Too Broad).
 

package/plugins/fh-meta/skills/hub-cc-pr-reviewer/SKILL.md

@@ -73,18 +73,48 @@ Self-precision catch areas after first cc review (following previous PR self-cat
 - Check explicit statement that audience-specific guides are limited to original developer environment
 - Check explicit statement of organization-specific areas
 
-Self-catch areas 0 items = skip this entire catch matrix (no token-filling / following `feedback_simplification_evidence`).
+Self-catch areas 0 items = skip this entire catch matrix — do not pad with token-filling to make the section look populated.
 
 ### Step 4. Review Comment Attachment
 
-Attach the review comment (8-matrix results + self-catch + refinement suggestions + merge recommendation) via `gh pr comment`. Within this skill's execution authority (automatic).
+**Mandatory before any `gh pr comment`: run `/public-surface-audit` over the composed comment text.**
+A PR comment is a **paste on a public surface**, and the repo's mechanical privacy floor does not
+reach it — the pre-commit confidentiality guard scans *staged tracked content* and has **no view of
+PR-body text** (`.claude/rules/fh_4axis_gate.md §Reviewer-visible evidence` says so explicitly).
+This step's own inputs make that acute: Step 2 matrix #2 greps the operator's **local memory files**,
+so an unfiltered paste can carry absolute home paths and private memory prose onto a public PR.
+
+```
+verdict CLEAN                     → attach (automatic, within this skill's authority)
+verdict REVIEW / LEAK             → do NOT attach. Redact the flagged spans, re-scan, then attach
+verdict NOT_CONFIGURED, or the
+  skill is unavailable            → do NOT attach automatically. This is an irreversible surface
+                                    (a posted comment is public the instant it lands and may be
+                                    mirrored before deletion) → **fail-closed**: hand the composed
+                                    text to the operator, or take an explicit logged override
+```
+
+**Never paste raw Step 2 grep output.** Write a *sanitized capsule* — what was checked, what it
+returned, what was found — never the matched lines themselves. Same rule as the marker: the file is
+a local artifact, the capsule is what crosses the boundary.
+
+Then attach the review comment (8-matrix results + self-catch + refinement suggestions + merge
+recommendation) via `gh pr comment`.
 
 > **Detail**: See `SKILL_detail.md §Step 4 Comment Template` — `gh pr comment` heredoc template — read when attaching the comment.
 
 ### Step 5. Admin Override Merge Recommendation
 
 **User decision delegation** (this skill = review/recording automation / no merge authority):
-- Beta stage policy (`enforce_admins: false`) adherence → admin override possible
+- **Read the branch-protection state at run time — never from this line.** This repo moved to
+  `enforce_admins: true` + `required_approving_review_count: 0` on 2026-07-20, and an earlier version
+  of this bullet still claimed `false`: a gate skill was recommending an override on a **field that
+  had already flipped**. Protection is also two independent layers (legacy + rulesets, strictest
+  wins), so one object is never the effective answer — check both:
+  `gh api repos/{owner}/{repo}/branches/main/protection` **and**
+  `gh api repos/{owner}/{repo}/rules/branches/main`
+- Self-approve is impossible when this cc authored the PR → after a completed review, `--admin` is
+  the normal route, not a shortcut
 - Self-approve blocked (GHE policy) → admin override path adherence
 - When this cc authored the change, admin override path is mandatory
 - N+1th operation proof = baseline stabilization acceleration path
@@ -96,39 +126,118 @@ Attach the review comment (8-matrix results + self-catch + refinement suggestion
 | Stage | Approval |
 |---|---|
 | Step 1~3 check auto-activation | **Automatic** (editable afterward) |
-| Step 4 review comment attachment | **Automatic** (gh pr comment within this skill's execution authority) |
+| Step 4 review comment attachment | **Automatic only after `/public-surface-audit` on the comment text returns CLEAN.** REVIEW/LEAK → redact and re-scan; NOT_CONFIGURED or audit unavailable → **fail-closed**, hand to the operator (a posted comment is public on landing) |
 | Step 5 admin override merge execution | **User decision** (this skill = recommendation only / no merge authority) |
 
 ## Constraints
 
 - **This skill = review/recording automation / no merge authority** — user admin override or other reviewer merge decision
 - **No single-person decision application** — following `fact-checker` rule (narrow 1 / broad N+1 / this cc self-catch joins fact-checker count)
-- **Simplification guard consistency** (`feedback_simplification_evidence`) — when creating/modifying this skill, update SKILL.md only. No new auxiliary files
-- **Markdown editing discipline mandatory** (`feedback_markdown_edit_discipline`) — Edit first. No Write
-- **Frontmatter description plain text only baseline** (`feedback_skill_frontmatter_description_plain_text`) — avoid markdown bold
+- **Simplification guard consistency** — when creating/modifying this skill, update SKILL.md only. No new auxiliary files
+- **Markdown editing discipline mandatory** — Edit first. No Write
+- **Frontmatter description plain text only baseline** — avoid markdown bold
+
+> The three rules above were previously each attributed to a `memory feedback_*.md` file. Those files
+> do not exist (verified 2026-08-11 against the operator's memory root, with a known-positive control
+> in the same run). The **rules stand on their own**; only the pointers were dead, and citing a
+> non-resolving file as the authority is the phantom-reference class this skill is supposed to catch.
+> Do not re-attach a memory citation here unless `ls` resolves it **in the same run that cites it**.
 
 > **Detail**: See `SKILL_detail.md §Sister Asset Utilization Path`, `§External User Environment Adaptation Path`, `§Disable Path`, `§Persona Synergy Catch` — cross-ecosystem utilization, external-environment fallback, own-PRS disable resolution, and deep-insight simultaneous-activation handling — read when operating in an external user environment, resolving own-PRS conflict, or coordinating with deep-insight.
 
 ## Done When
 
+This is a **gate/routing skill** — its output is a merge verdict — so every judged condition below
+names its adversarial pairing. No judge-only path.
+
 ```
 All 5 Steps completed
-+ Baseline consistency check 8-matrix results output (✅/⚠️/❌ each item)
+  — mandatory-pass: each step produced its output or is marked N/A with a reason
+
++ Baseline consistency check 8-matrix results output (OK/WARN/BLOCK each item)
+  — measured: count items REPORTED vs items ACTUALLY CHECKED; the two must
+    match. Matrix #2 (memory baseline) reports SKIPPED when no memory file
+    resolves — it is never folded into the pass count (see §References)
+
++ Axis 1 run in --pr mode with a typed verdict read from
+  REGRESSION_GUARD_RESULT_FILE
+  — mandatory-pass: result is `pass` or `block`. `skip` and exit 3 are NOT
+    passes; they mean Axis 1 did not examine this PR and the recommendation
+    may not cite it as green
+
++ /public-surface-audit run over the composed comment text BEFORE any
+  gh pr comment
+  — mandatory-pass, fail-closed: CLEAN attaches; REVIEW/LEAK redact-and-rescan;
+    NOT_CONFIGURED or audit unavailable hands to the operator. A posted comment
+    is irreversible, so tooling-down is a block, never a free skip
+
 + Review comment attached via gh pr comment command
-+ Admin override merge recommendation output (merge execution is user's decision)
-+ External verification path: harvest-loop Step 3.75 Critic isolation Agent can independently judge based on above criteria (skill_quality_rubric.md verifiable criteria)
+  — mandatory-pass: the comment URL is returned by the command
+
++ Admin override merge recommendation output (merge execution is user's
+  decision)
+  — judged; adversarial pairing: the branch-protection state is re-read at run
+    time from BOTH layers (`.../branches/main/protection` and
+    `.../rules/branches/main`, strictest wins) in the same run that recommends.
+    A recommendation citing this file's prose instead of a live read is
+    unfounded — that exact defect already shipped once here, on a field that
+    had flipped
+
++ External verification path: an isolated Critic agent can reach the same
+  verdict from the artifacts alone
+  — judged; adversarial pairing: the reviewer-visible evidence must be
+    reproducible WITHOUT the author's local files. Any verdict resting on a
+    gitignored local artifact ships labelled LOCAL-ONLY ATTESTATION -
+    UNVERIFIED, which leaves the condition UNMET rather than met
+    (`.claude/rules/fh_4axis_gate.md` §Reviewer-visible evidence)
 ```
 
-**→ Mandatory when PR contains SKILL.md / rules / templates changes: `bash templates/regression_guard.sh`** — run Axis 1 (backward check) before merge recommendation is issued. If regression_guard exits with M-tier block, merge recommendation must change to ❌ regardless of other checks.
+**→ Mandatory when PR contains SKILL.md / rules / templates changes: run Axis 1 (backward check) in
+`--pr` mode, against the PR's head branch** — before the merge recommendation is issued. If
+regression_guard reports an M-tier block, the merge recommendation must change to ❌ regardless of
+other checks.
+
+```bash
+# Precondition: the PR head branch must exist locally. This skill reads the PR via `gh pr diff`
+# without checking anything out, so fetch the head ref first or --pr has nothing to resolve.
+PR_BRANCH="$(gh pr view "$PR" --json headRefName -q .headRefName)"
+git fetch origin "$PR_BRANCH":"refs/remotes/origin/$PR_BRANCH"   # skip if already present
+bash templates/regression_guard.sh --pr "origin/$PR_BRANCH"
+```
+
+⚠️ **Do not run it with no arguments.** Bare `bash templates/regression_guard.sh` diffs the **working
+tree**, and this skill's own workflow leaves the reviewer standing on a clean `main` — so the bare
+form returns `REGRESSION_GUARD_RESULT=skip` with `exit 0` **100% of the time**, and the mandatory
+Axis-1 gate never examines the PR at all. Measured 2026-08-11 on a clean checkout: bare form →
+`rc=0 / result=skip`; `--pr <branch>` on the same commit → `rc=0 / result=pass` having actually read
+the changed SKILL.md. Canonical form is `--pr {BRANCH}` (`.claude/rules/fh_4axis_gate.md`).
+
 **Read the verdict from the typed channel, not the exit code** — `exit 0` means pass **or** skip
 (not-checked). Run with `REGRESSION_GUARD_RESULT_FILE=/tmp/rg.$$` and read `result=` from that file:
-`skip` means Axis 1 **did not examine** this PR (no matching file) — record it as "Axis 1 N/A", never
-as a green check. A merge recommendation that cites an unexamined Axis 1 as PASS is the 2026-07-22
-fail-open class.
+`skip` means Axis 1 **did not examine** this PR (no matching file, or the wrong invocation form) —
+record it as "Axis 1 N/A", never as a green check. `exit 3` means the invocation itself failed
+(unresolvable branch) — also not a pass; fetch the ref and re-run. A merge recommendation that cites
+an unexamined Axis 1 as PASS is the 2026-07-22 fail-open class.
 
 ## References
 
-- Rule body: `memory feedback_command_tower_gate.md` (hub gate accumulated naming baseline) + `memory feedback_field_to_hub_sync_protocol.md` (Option C Hybrid sync policy)
-- Consistency rules: `feedback_simplification_evidence` · `feedback_markdown_edit_discipline` · `feedback_skill_frontmatter_description_plain_text` · `feedback_bidirectional_self_validation` · `feedback_reference_own_hub_assets_first`
+> ⚠️ **The memory filenames below were audited 2026-08-11 and **none of them exist** — 8/8 absent in
+> the operator's own memory root, i.e. they were never reachable, not merely absent externally. They
+> are kept, struck, as the record of a phantom-reference class: a gate skill citing rule bodies that
+> resolve nowhere, while matrix #2 silently "skips" and the run still reports an 8-matrix pass.
+> **Matrix #2 is therefore a 7-matrix in practice** — report it as `matrix 2: SKIPPED (no resolvable
+> memory baseline)` rather than folding it into the pass count (`not found ≠ 0`).
+> Re-populate this list only with paths verified by `ls` **in the same run that cites them**.
+>
+> **Arithmetic reconciled 2026-08-11**: the "8/8" above is now true of the list below — all 8 cited
+> filenames are struck (re-verified in one run: 8 cited / 8 absent, with a known-positive and a
+> known-negative control). Previously only 7 were struck while the 8th
+> (`feedback_autonomous_commit_proposal`) was still cited live, and three more were cited as live
+> authority up in §Constraints and §Step 3 — where an executor actually reads, since References is
+> not on the execution path. **Those live citations are removed; the rules they carried are stated
+> directly.** A struck entry in References is not a fix if the same name is still load-bearing above.
+
+- ~~Rule body: `memory feedback_command_tower_gate.md` + `memory feedback_field_to_hub_sync_protocol.md`~~ — **absent (verified 2026-08-11)**
+- ~~Consistency rules: `feedback_simplification_evidence` · `feedback_markdown_edit_discipline` · `feedback_skill_frontmatter_description_plain_text` · `feedback_bidirectional_self_validation` · `feedback_reference_own_hub_assets_first`~~ — **absent (verified 2026-08-11)**
 - Sister skills: `cross-ecosystem-synergy-detection` (sister asset cluster baseline) · `verify-bidirectional` (bidirectional self-validation automation / self-catch auxiliary axis) · `harvest-loop` (weekly audit automation / operation proof accumulation cross-link)
-- Autonomous commit proposal §2.19 baseline: `memory feedback_autonomous_commit_proposal.md` (① development source automation + PR proposal under human approval)
+- ~~Autonomous commit proposal §2.19 baseline: `memory feedback_autonomous_commit_proposal.md`~~ — **absent (verified 2026-08-11)**. The rule it stood for is live and lives in `CLAUDE.md §AI Contribution Model`: development-source automation is allowed, PR submission requires explicit human approval. Cite that, not this filename.

package/plugins/fh-meta/skills/install-doctor/SKILL.md

@@ -221,20 +221,38 @@ If existing retrospective/audit files exist → `harvest-loop` will create files
 # Check MCP server transport settings
 grep -r "\"transport\"" .mcp.json 2>/dev/null | grep -i "http\|sse"
 
-# List MCP servers using HTTP transport
-python3 -c "
-import json, sys
+# List MCP servers using HTTP transport.
+# `except: pass` made this exit 0 on ANY failure, so the `|| echo` fallback was dead code and a
+# corrupt .mcp.json rendered identically to "no risky servers" — a silent pass on a security check.
+# Four states, four distinct exits: absent(0) · unparseable(2) · risky(1) · all-stdio(0).
+python3 - <<'PY'
+import json, os, sys
+p = '.mcp.json'
+if not os.path.exists(p):
+    print('  MCP-CHECK: NOT-APPLICABLE — .mcp.json absent (no MCP servers configured)')
+    sys.exit(0)
 try:
-    d = json.load(open('.mcp.json'))
-    servers = d.get('mcpServers', {})
-    for name, cfg in servers.items():
-        t = cfg.get('transport', 'stdio')
-        if t != 'stdio':
-            print(f'  ⚠️  {name}: transport={t}')
-except: pass
-" 2>/dev/null || echo "  .mcp.json absent or unparseable"
+    d = json.load(open(p))
+except Exception as e:
+    print(f'  MCP-CHECK: UNPARSEABLE — {p}: {e}')
+    print('  Transport risk UNMEASURED — this is NOT a pass. Fix the file and re-run.')
+    sys.exit(2)
+servers = (d.get('mcpServers') or {})
+risky = [(n, (c or {}).get('transport', 'stdio')) for n, c in servers.items()
+         if (c or {}).get('transport', 'stdio') != 'stdio']
+if risky:
+    for n, t in risky:
+        print(f'  WARNING  {n}: transport={t} — verify localhost binding + auth')
+    sys.exit(1)
+print(f'  MCP-CHECK: PASS — {len(servers)} server(s), all stdio')
+PY
 ```
 
+> **Read the exit code, not just the text.** `2` (unparseable) is an *unmeasured* check and must be
+> reported 🟧 in Step 3, never folded into 🟩. Known-pair calibration for this block: a deliberately
+> truncated `.mcp.json` must yield `2`, and a config with one `transport: http` server must yield `1`.
+> If both print nothing, the check is dead.
+
 **Known MCP HTTP transport vulnerability patterns** (based on HTTP port exposure security principles): When MCP servers using HTTP/SSE transport expose ports without authentication, remote access risk within local networks may occur. stdio transport is not affected.
 
 | Transport | Risk |
@@ -283,11 +301,29 @@ If you installed only the plugin in a different project cwd:
 ## Done When
 
 ```
-All Steps 1~4 completed
-+ Step 3 diagnosis report output (🟥 immediate action / 🟧 check recommended / 🟩 no conflicts)
-+ "Plugin install is safe in current environment" confirmed when 0 conflicts
+Steps 0~4 completed                                              (mandatory-pass)
++ Step 0 node-floor results recorded per check, each as one of
+  PASS / FAIL / UNMEASURED — never blank                          (measured: 2 floors —
+                                                                   hook exec-bit, SessionStart
+                                                                   registration)
++ Step 2-6 MCP transport check exited 0/1/2 and the exit code is
+  carried into the Step 3 tier (2 = UNMEASURED → 🟧, never 🟩)     (mandatory-pass)
++ Step 3 diagnosis report emitted with a tier per area
+  (🟥 immediate action / 🟧 check recommended / 🟩 no conflicts)   (mandatory-pass)
++ Verdict is derived from the recorded per-area tiers: 🟩 only if
+  every area is 🟩 AND none is UNMEASURED                          (measured: count of
+                                                                   non-🟩 areas == 0)
 ```
 
+**Why `Steps 0~4`, not `1~4`**: Step 0 holds the only *mechanical floor* checks in this skill (hook
+exec-bit, SessionStart registration, Node floor). Leaving it outside the completion condition let a
+run report "done" having never touched the one part that is not judgement.
+
+**Why the verdict is counted, not stated**: the previous condition was `"Plugin install is safe in
+current environment" confirmed` — that measures whether a *sentence was printed*, which a run
+satisfies by printing it. An unmeasured area (e.g. an unparseable `.mcp.json`) must not be
+absorbed into 🟩; absence of a finding is not a finding of absence.
+
 ## Simplification Guard
 
 - 0 existing assets (new environment) → output "New environment. No conflicts." and exit immediately in Step 1

package/plugins/fh-meta/skills/install-wizard/SKILL.md

@@ -301,13 +301,32 @@ On Claude API / MCP failure → refer to [`references/fallback-guide.md`](../../
 ## Done When
 
 ```
-☐ Environment detection complete: shell, CC version, OS, project type identified
-☐ Gap diagnosis output: present vs missing items listed
-☐ User approval/decline recorded for each suggested item
-☐ All approved items installed with no failure state
-  (failed installs surfaced to user — not silently skipped)
-☐ Acceleration baseline confirmed: zshrc alias + sentinels active (or user declined)
-☐ Summary output: "N items installed, M items skipped — setup complete"
+☐ Environment detection complete: shell, CC version, OS, project type
+  identified — each field carries a value or the literal "unknown",
+  never blank                                                    (measured: 4 fields resolved)
+☐ Settings probe distinguished ABSENT / UNPARSEABLE / OK — an
+  unparseable config is never treated as absent                  (mandatory-pass)
+☐ Gap diagnosis output: present vs missing items listed          (measured: count of items
+                                                                  present + missing == items
+                                                                  scanned)
+☐ User approval/decline recorded for each suggested item —
+  a missing answer is a decline, never an assumed yes            (measured: recorded answers
+                                                                  == suggested items)
+☐ All approved items installed with no failure state; every
+  failure surfaced to the user, not silently skipped             (mandatory-pass)
+☐ Acceleration baseline: zshrc block either appended with
+  SUBSTITUTED values (no literal "{FH_DIR}" in the target file)
+  or explicitly declined and the decline recorded                (mandatory-pass)
+☐ Step 3-D dispatch consent recorded in the three-part form
+  (quoted words · dated lease · scope) or a recorded decline —
+  a two-part record is invalid and counts as absent              (mandatory-pass)
+☐ Summary output: "N items installed, M items skipped" where
+  N + M equals the number of items offered                       (measured: N + M == offered)
+☐ Nothing was overwritten that the user did not approve          (judged — adversarial pairing:
+                                                                  re-run the wizard on a
+                                                                  populated .claude/ and diff
+                                                                  the tree before/after; any
+                                                                  unapproved delta is a FAIL)
 ```
 
 `--dry-run` mode Done When: gap diagnosis report written, no installation executed.