@chrono-meta/fh-gate 1.4.95 → 1.4.96

package/plugins/fh-meta/agents/persona-innovator.md

@@ -69,7 +69,13 @@ Additional checklist for the human operator:
 
 ### 1-a. Load naming history
 
-**Path A (hub environment with naming history)**: Read `MEMORY.md` (hub memory index), then load the naming-relevant files referenced there.
+**Path A (hub environment with naming history)**: read the naming history from `CATALOG.md` and
+`knowledge/shared/` (both repo-root, both present). *Corrected 2026-08-11: this said `MEMORY.md`,
+which does not exist at the repo root (`ls MEMORY.md` → No such file; control: `CATALOG.md` and
+`README.md` resolve). Path A therefore read nothing and rendered as "no naming gap found" — and
+Path B could not catch it, because its condition is "external environment" and this IS the hub.*
+**If neither source resolves, degrade to Path B and say so in Section 0 — a silent empty read is
+not a finding of zero.**
 
 **Path B (external environment)**: Skip memory read. Use only the naming pattern taxonomy below (§ Naming pattern taxonomy) and the current invocation context.
 
@@ -77,7 +83,9 @@ Additional checklist for the human operator:
 
 Scan current asset inventory using Grep/Glob:
 ```
-grep -r "candidate\|gap\|unnamed\|no name" <harness-root>/
+Grep tool: pattern `candidate|gap|unnamed|no name`, path `.` (repo root)
+    — stated as a Grep-tool call, not a shell line: this agent declares `tools: Read, Grep, Glob`
+      and has no Bash, so a shell command here is an instruction it cannot execute.
 ```
 
 Also look for:

package/plugins/fh-meta/skills/agent-composer/SKILL.md

@@ -2,7 +2,7 @@
 name: agent-composer
 description: Reads the current work context and plans the optimal agent dispatch. Clarifies direction with 1-2 questions when unclear; infers and proceeds immediately when execution path is unclear. Runs an automatic recording gate after each Wave completes. Triggered by "compose agents", "which agent should I use?", "run in parallel", or "agent-composer".
 user-invocable: true
-allowed-tools: ["Read", "Bash", "Glob", "Grep"]
+allowed-tools: ["Read", "Bash", "Glob", "Grep", "Agent", "Skill"]
 model-note: session-inherit — Sonnet base is first-class (sonnet_floor_doctrine.md); depth-critical judged steps route to dispatch (opus agent / cross-family sidecar, consent-gated), never a substrate requirement
 ---
 
@@ -150,7 +150,7 @@ This orchestrator does not read files or understand structure directly — **eve
 
 Default composition table by task type.
 
-> **Note**: This table lists known installed agents. Capability fit scoring in Step 0.2 overrides static mapping when `agent_cards.json` has more current data.
+> **Note**: This table lists known installed agents. Capability fit scoring in Step 0.2 overrides static mapping when `.claude/registry/agent_cards.json` (repo-relative — there is no bare `agent_cards.json` at the repo root) has more current data.
 
 > **Call method distinction**: `(S)` = Skill tool call / `(A)` = Background dispatch via Agent tool
 

package/plugins/fh-meta/skills/apex-review/SKILL.md

@@ -177,6 +177,11 @@ Incorporate sim-conductor results into the HTML deck and save the revised versio
 All steps 0–4 completed
 + Verdict (✅/⚠️/❌) output for all target decision-makers
 + Gate verdict (Passed / Conditionally passed / Rejected) stated
++ Deck artifact exists on disk: `apex_review_deck_YYYYMMDD.html` (Step 2) — confirm by printing its
+  path and byte size; this is the skill's only durable output, so "reviewed but no deck" is NOT done
++ If the gate verdict is `Conditionally passed`: the `/sim-conductor Area E` verdict has been
+  RECEIVED and folded in (the mandatory-next gate below). Without that verdict the run is not done,
+  regardless of the A/B/C/D selection
 + User next step selection (A/B/C/D) confirmed
 ```
 

package/plugins/fh-meta/skills/asset-placement-gate/SKILL.md

@@ -2,7 +2,7 @@
 name: asset-placement-gate
 description: Routes a proposed skill, plugin, or agent to its correct home — forge-harness (FH) meta-skill, project-local agent, or drop — by applying a 4-criteria meta-skill bar followed by a project-local value test.
 user-invocable: true
-allowed-tools: ["Read", "Grep", "Glob"]
+allowed-tools: ["Read", "Grep", "Glob", "Bash"]
 model: sonnet
 ---
 
@@ -73,19 +73,37 @@ Criterion ④ ("no overlap with existing FH skills") is otherwise an LLM **recal
 ground truth — a duplicate skill with a novel name passes because the judge has no enumerated list to
 check against (judge-robustness swarm, 2026-06-13). Ground it mechanically first:
 
+Run this in **Bash** from the FH repo root (the pipeline below is `grep | grep -v | grep -c`, which the
+Grep tool cannot express).
+
 ```bash
-# enumerate existing skill names + descriptions (grounds the judged comparison)
-grep -riE "name:|description:" plugins/fh-meta/skills/*/SKILL.md plugins/fh-commons/skills/*/SKILL.md
-# hard-collision check: WHOLE proposed name or a WHOLE trigger phrase reused verbatim.
+# LEG A — enumerate existing skill names + descriptions (grounds the judged comparison).
+# This leg is ALSO the liveness check for leg B: a dead scan and a genuine no-collision both
+# produce collision-count 0, so the enumerate count must be read FIRST.
+ROSTER="$(grep -riE 'name:|description:' plugins/fh-meta/skills/*/SKILL.md plugins/fh-commons/skills/*/SKILL.md)"
+ROSTER_N="$(printf '%s' "$ROSTER" | grep -c . )"
+echo "roster_entries=$ROSTER_N"
+if [ "$ROSTER_N" -eq 0 ]; then
+  echo "SCAN_DEAD — enumerate leg returned 0 rows (wrong cwd / missing plugins tree / glob did not match)."
+  echo "Criterion ④ = UNDETERMINED. Do NOT read this as 'no collision'. Fix the cwd and re-run."
+  # fail-closed: stop here, do not run leg B, do not pass ④
+fi
+# LEG B — hard-collision check (run ONLY when ROSTER_N > 0).
+# WHOLE proposed name or a WHOLE trigger phrase reused verbatim.
 # grep -wF (whole-word, fixed-string) on the full strings — NOT -E on tokens (a shared common
 # word like "review" is not a collision). Exclude the asset's own file (self-match = false hit).
-SELF="plugins/fh-meta/skills/<proposed name>/SKILL.md"
-grep -rwF -e "<proposed full name>" -e "<full trigger phrase 1>" -e "<full trigger phrase 2>" \
+SELF="plugins/fh-meta/skills/PROPOSED_NAME/SKILL.md"
+grep -rwF -e "PROPOSED_FULL_NAME" -e "FULL_TRIGGER_PHRASE_1" -e "FULL_TRIGGER_PHRASE_2" \
      plugins/*/skills/*/SKILL.md | grep -v "$SELF" | grep -c .
 ```
 
-Surface **collision count + nearest existing skill(s)**. Criterion ④ then passes only if **0 whole-name/
-whole-trigger collision AND the judged ≤90%-overlap check agrees**. A verbatim whole-name or
+(Replace the `PROPOSED_*` / `FULL_TRIGGER_*` tokens with the literal strings under evaluation.)
+
+Surface **roster_entries + collision count + nearest existing skill(s)** — the roster count is part of
+the report, not a private step: `collision=0` is only meaningful next to a non-zero `roster_entries`
+(not-found ≠ zero). Criterion ④ then passes only if **`roster_entries` > 0 AND 0 whole-name/
+whole-trigger collision AND the judged ≤90%-overlap check agrees**. `roster_entries = 0` is
+`SCAN_DEAD` → ④ **UNDETERMINED** (fail-closed), never a pass. A verbatim whole-name or
 whole-trigger reuse is a hard ④ fail regardless of the LLM judgment. **Honest scope**: the grep grounds
 *literal* name/trigger reuse only — a post-cutoff duplicate with a *paraphrased* trigger is invisible to
 both the judge (cutoff) and the grep (literal); that residual leans on the judged half **fed the
@@ -105,10 +123,22 @@ skipping. (Provenance: `tracks/_audit/session_2026_07_25_claude5-context-rules-s
 
 ## Done When
 
+Each condition declares its check class (mandatory-pass / measured / judged); every judged condition
+names its adversarial pairing — no judge-only path.
+
 ```
 All steps 0–3 completed
+  (mandatory-pass — each step's output block is present; a skipped step is a FAIL, not a default pass)
++ Step 0.5 scan is LIVE: roster_entries > 0
+  (measured: the reported roster_entries count. 0 = SCAN_DEAD → criterion ④ UNDETERMINED and this
+   skill is NOT done — a dead scan and a genuine no-collision both read 0 collisions, so the
+   liveness number is what separates them)
 + Step 3 routing result output (location: FH meta-skill / local agent / drop)
+  (judged — adversarial pairing: `fh-meta:challenger` re-argues the case for the destination that was
+   NOT chosen, citing the 4 criteria; a routing verdict that survives the opposite case passes, an
+   unopposed one does not)
 + Next action specified (write SKILL.md / create .claude/agents/ / none)
+  (mandatory-pass — a literal next-action string from that enum; blank or "TBD" does not satisfy it)
 ```
 
 ---

package/plugins/fh-meta/skills/auto-decorrelation/SKILL.md

@@ -103,11 +103,25 @@ probe localhost:11434 && echo "ollama-local(mac)"
 EP="$FH_SIDECAR_EXTRA"
 [ -z "$EP" ] && [ -f tracks/_meta/sidecar_endpoints.env ] && \
   EP="$(grep '^OLLAMA_EXTRA=' tracks/_meta/sidecar_endpoints.env | cut -d= -f2- | tr -d '"')"
-for e in $EP; do
-  case "$e" in *[!0-9a-zA-Z.:-]*|'') continue;; esac   # host:port form only — reject glob/junk (no word-split hole)
+# Split on NEWLINES via `while read`, never on an unquoted `for e in $EP`. Word-splitting an unquoted
+# variable is a BASH behavior; zsh does NOT word-split, so under zsh a space-separated multi-endpoint
+# list arrives as ONE string, hits the charclass below (space is not in it) and is dropped — silently
+# reporting "no extra sidecars", i.e. the single-family fail-open this skill exists to prevent.
+# Measured 2026-08-11: `EP="host1:11434 host2:11434"` → bash probes 2, zsh probes 0.
+# Accepts either separator: commas/spaces are normalized to newlines first.
+printf '%s\n' "$EP" | tr ' ,' '\n\n' | while IFS= read -r e; do
+  [ -z "$e" ] && continue
+  case "$e" in *[!0-9a-zA-Z.:-]*)
+    # NEVER a silent `continue` — a dropped endpoint must be visible, or an unprobed panel is
+    # indistinguishable from an unavailable one (DEGRADED_PANEL_UNUSED vs DEGRADED_SINGLE_FAMILY).
+    echo "sidecar-endpoint DROPPED (not host:port form): [$e]" >&2; continue;;
+  esac
   probe "$e" 10 && echo "ollama-extra($e)"             # -m10: a sleeping GPU box may wake slower than 6s
 done
 ```
+**Shell note**: this block is `sh`-portable and is written so bash and zsh behave identically. Any
+future edit that reintroduces `for e in $EP` re-opens the zsh drop above. A drop line on stderr is a
+**finding, not noise** — carry it into the Step 6 degrade verdict rather than discarding stderr.
 Endpoint resolution is a **mechanical env/file read** (not a prose instruction the runner must remember),
 so this discovery is tier-independent — no target-tier sim owed. The extra-endpoint binding lives only in
 the gitignored `tracks/_meta/sidecar_endpoints.env` (auto-synced to the companion store); the public skill

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

@@ -29,13 +29,37 @@ ls -d */ 2>/dev/null | head -20
 ### Step 2 — Large file detection + warning format
 
 ```bash
-# Detect files exceeding 500 lines (top 10)
-find . -name "*.py" -o -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.java" -o -name "*.kt" \
-  | grep -v node_modules | grep -v .git \
-  | xargs wc -l 2>/dev/null | sort -rn | head -11 | tail -10
+# Detect files exceeding 500 lines (top 10).
+#
+# Two mechanical guards, both measured 2026-08-11 on this repo:
+#  (a) 500-line THRESHOLD via awk. Without it, `head -11 | tail -10` emits 10 rows unconditionally —
+#      this repo's largest source file is 450 lines and ZERO files exceed 500, yet the old pipeline
+#      still returned 10 rows, which the warning block below then rendered as "Large file detected".
+#      Not-found must render as "none", never as a hit.
+#  (b) `while read` instead of `xargs wc -l`. xargs splits a long file list into batches and EACH
+#      batch emits its own `total` row; those rows then occupy slots in the reported top 10
+#      (measured: 6000 files -> 2 `total` rows, one of them inside the top 10). The loop also
+#      survives spaces in filenames, which the xargs form did not.
+FILES="$(find . -type f \( -name "*.py" -o -name "*.ts" -o -name "*.tsx" -o -name "*.js" \
+                        -o -name "*.java" -o -name "*.kt" \) \
+              -not -path "*/node_modules/*" -not -path "*/.git/*")"
+SCANNED="$(printf '%s' "$FILES" | grep -c . )"
+BIG="$(printf '%s\n' "$FILES" | while IFS= read -r f; do
+         [ -n "$f" ] || continue
+         printf '%s\t%s\n' "$(wc -l < "$f")" "$f"
+       done | awk -F'\t' '$1 > 500' | sort -rn | head -10)"
+
+if [ "$SCANNED" -eq 0 ]; then
+  echo "large-file scan: UNMEASURED — 0 source files matched (wrong cwd, or this project uses other extensions)"
+elif [ -z "$BIG" ]; then
+  echo "large-file scan: none — 0 of $SCANNED source files exceed 500 lines"
+else
+  printf '%s\n' "$BIG"
+fi
 ```
 
-When files exceeding 500 lines are found:
+Emit the warning below **only for rows the scan actually returned** (`BIG` non-empty). A `none` or
+`UNMEASURED` line is reported as-is and produces **no** warning — and `UNMEASURED` is not `none`:
 
 ```
 ⚠️  Large file detected: {filename} ({N} lines)
@@ -67,11 +91,22 @@ If found, suggest adding to the `## Check Items` or `## Token Efficiency` sectio
 # CLAUDE.md line count
 wc -l CLAUDE.md .claude/CLAUDE.md 2>/dev/null | sort -rn | head -3
 
-# MEMORY.md line count (200-line limit)
-wc -l memory/MEMORY.md 2>/dev/null
-
-# memory/*.md files exceeding 30K
-find memory -name "*.md" -size +30k 2>/dev/null | xargs wc -l | sort -rn | head -10
+# Session memory lives OUTSIDE the repo — under the Claude Code project dir, keyed by a slug of the
+# absolute cwd. There is NO `memory/` at the repo root: the old `wc -l memory/MEMORY.md 2>/dev/null`
+# and `find memory ... 2>/dev/null` both printed nothing on this repo, and that silence read as
+# "no bloat" (not-found rendered as zero). Derive the path; never hardcode a home path.
+MEMDIR="$HOME/.claude/projects/$(pwd | sed 's|/|-|g')/memory"
+if [ -d "$MEMDIR" ]; then
+  # MEMORY.md line count (200-line limit)
+  if [ -f "$MEMDIR/MEMORY.md" ]; then wc -l "$MEMDIR/MEMORY.md"
+  else echo "MEMORY.md: UNMEASURED — index absent under $MEMDIR"; fi
+  # topic files exceeding 30K (while-read: survives spaces, no xargs `total` rows)
+  find "$MEMDIR" -name "*.md" -size +30k | while IFS= read -r m; do
+    printf '%s\t%s\n' "$(wc -l < "$m")" "$m"
+  done | sort -rn | head -10
+else
+  echo "memory audit: UNMEASURED — no memory dir at $MEMDIR. This is NOT 'zero bloat'."
+fi
 
 # SKILL.md files > 300 lines with no SKILL_detail.md (salience-splitter candidates)
 find plugins -name "SKILL.md" 2>/dev/null | while read f; do

package/plugins/fh-meta/skills/corpus-grounding-expander/SKILL.md

@@ -14,8 +14,13 @@ that corpus from multiple public-domain versions so grounding is robust and non-
 verified in ANY version counts), without ever adding a generator.
 
 > Origin: harvested from the-bible (2026-06-20) — 6 public-domain Bible versions, 197k verses, as the
-> fail-closed grounding axiom. Generalizes to any verbatim-relay corpus (legal statute, RFC text,
-> standards). See `tracks/_contrib/field_harvest_2026-06-20_gate-locality-and-grounding-capabilities.md`.
+> fail-closed grounding axiom. **The grounds, inline, because the harvest record does not ship**: one
+> edition's wording makes a fail-closed check reject a faithful quote that followed a *different*
+> edition, so the union across versions is what stops fail-closed grounding from failing closed
+> *against the user* — and it keeps one translation's editorial choices from silently becoming the
+> axiom. Generalizes to any verbatim-relay corpus (legal statute, RFC text, standards).
+> Full harvest record — **hub-local, not distributed in the npm package**:
+> `tracks/_contrib/field_harvest_2026-06-20_gate-locality-and-grounding-capabilities.md`.
 
 ## Triggers
 - "get more sources" / "broaden the grounded corpus"
@@ -39,12 +44,16 @@ verified in ANY version counts), without ever adding a generator.
 4. **Wire grounding as a union** — the grounding check passes if the quote matches the canonical text
    at that key in ANY version. Never add a path that generates text — grounding is quote-only.
 5. **Relay-integrity check** — confirm the consumer (the gate) QUOTES the corpus and cannot emit
-   un-grounded text; run a fabrication probe (a known non-source quote must fail-closed).
+   un-grounded text; run a fabrication probe (a known non-source quote must fail-closed) and write
+   the probe's **actual output** into the index under `probe_status:`. Writing the probe *spec*
+   without running it is `probe_status: not_run`, not a pass.
 
 ## Done When
 - **Each added source carries a verifiable public-domain/license record** in the index. *Check class: mandatory-pass (binary — license field present and non-empty per version).*
-- **Every version is normalized to the same key schema** (cross-version keys align). *Check class: mandatory-pass (a shared sample key resolves in each version or is explicitly canon-scoped).*
-- **The index declares the quote-only union contract** (grounding matches verbatim text in ANY version; no generation path) and ships a fabrication-probe spec for the consumer to run. *Check class: mandatory-pass (binary — quote-only contract + probe-spec present in the index).*
+- **The index enumerates every version that was ATTEMPTED, each carrying a status** — `fetched` | `failed(<reason>)` | `skipped(<reason>)` | `unknown`. A version that was tried and dropped appears with its reason; **absence from the list is not a zero**, it is an unrecorded drop. *Check class: mandatory-pass (binary — the attempted-version list is present and every entry carries one of the four statuses).*
+- **Every version is normalized to the same key schema** (cross-version keys align). *Check class: mandatory-pass (a shared sample key resolves in each version). A key genuinely absent from a version is allowed ONLY when the index records it under `canon_scope:` — the reason plus the explicit list of affected keys and versions. An unrecorded exception is FAIL: "it's canon-scoped" asserted in prose and nowhere in the index does not satisfy this condition.*
+- **The index declares the quote-only union contract** (grounding matches verbatim text in ANY version; no generation path). *Check class: mandatory-pass (binary — quote-only contract present in the index).*
+- **The fabrication probe was RUN and its output shows fail-closed** — a known non-source quote was submitted to the consumer gate and refused, with the refusal output recorded in the index. *Check class: mandatory-pass (binary — `probe_status: executed` plus the attached refusal output). A probe **spec** with no run is `probe_status: not_run` and is a sub-condition, never this one.* **Degrade — labeled, never a silent pass**: no consumer gate exists yet → record `probe_status: no_consumer (<what is missing>)`; the corpus may still ship, but ships **labeled relay-unverified**, this condition stays UNMET, and nothing downstream may cite the corpus as relay-verified until a run is attached.
 
 ## Guards
 - **Grounding, never a generator** — the relay constraint is structural; this skill wires *grounding*.

package/plugins/fh-meta/skills/cross-ecosystem-synergy-detection/SKILL.md

@@ -21,7 +21,7 @@ Automatically discovers cross-invocable pairs in environments with multiple inst
 1. **Multi-ecosystem component environment specified**: "multiple plugins/cross-CLI installed", "synergy with other components", "cross-ecosystem", "run together"
 2. **New component added/removed**: "component install", "add/remove component"
 3. **Synergy check phrasing**: "are they working in isolation?", "can they be integrated?", "environment check", "combination effect"
-4. **Registry change detected** (optional): If a user-maintained `LOCAL_SKILL_REGISTRY.md` is present, Step 7 runs when a new project/skill is registered. The registry is not auto-created — absent file → Step 7 self-skips (see Step 7 guard).
+4. **Registry change detected** (optional): If a user-maintained `LOCAL_SKILL_REGISTRY.md` is present, Step 7 runs when a new project/skill is registered. The registry is not auto-created — absent file → Step 7 reports `[NOT-CONFIGURED]` and skips its body (see Step 7-1 outcome table).
 
 **Exception**: Single-component environments (1 or fewer installed → no meaningful activation)
 
@@ -40,15 +40,29 @@ Automatically discovers cross-invocable pairs in environments with multiple inst
 | "Wouldn't combining these plugins be more powerful?" | Explore component combination synergies |
 | "I feel like there's synergy here — find it" | Automatic cross-invocation pair discovery |
 
-## Processing Steps (6-step)
+## Processing Steps (7-step)
 
 ### Step 1. Installation Inventory Direct Inspection
 
 ```bash
 cat ~/.claude/plugins/installed_plugins.json
-# fields: name, version, installPath, gitCommitSha
 ```
 
+**Schema (measured 2026-08-11, `version: 2`)** — read this before writing any parser:
+
+```
+{"version": 2,
+ "plugins": {                       # DICT, not a list
+   "<plugin>@<marketplace>": [      # value is a LIST of entries
+     {"gitCommitSha": …, "installPath": …, "installedAt": …,
+      "lastUpdated": …, "scope": …, "version": …}
+   ]}}
+```
+
+The plugin **name is the dict key**, not an entry field — `entry.get('name')` is always `None`,
+and iterating `for pl in data['plugins']` yields **key strings**, not entry dicts.
+`gitCommitSha` is **optional** (measured: present on 5 of 11 installs) — see Step 5 drift.
+
 Additional checks:
 - `~/.claude/settings.json` `enabledPlugins` (actually active assets)
 - Check `installed_plugins.json` ↔ `enabledPlugins` consistency (catch drift)
@@ -56,15 +70,18 @@ Additional checks:
 ### Step 2. Asset Matrix Extraction per Component
 
 ```bash
-ls {installPath}/skills/   # SKILL.md units
-ls {installPath}/agents/   # *.md units
-ls {installPath}/commands/
-ls {installPath}/.mcp.json
-ls {installPath}/hooks/
+for T in skills agents commands .mcp.json hooks; do
+  if [ -e "$IP/$T" ]; then echo "PRESENT $T"; ls "$IP/$T"; else echo "ABSENT  $T"; fi
+done
 ```
 
 Extract each asset's frontmatter `description` + `allowed-tools` + `model`. Merge `plugin.json keywords`.
 
+**`ABSENT` is a state, not a zero.** Most plugins ship only a subset (measured on `fh-meta`:
+`skills`/`agents` present, `commands`/`.mcp.json`/`hooks` absent). Carry `ABSENT` through to
+the matrix — an absent asset class must not be counted as "0 assets found", which would read as
+an inspected-and-empty component.
+
 ### Step 3. Cross-Invocation Possible Pair Matrix Derivation
 
 Call mechanism compatibility:
@@ -88,15 +105,33 @@ Call mechanism compatibility:
 
 - **cwd fragmentation**: Component A and B operating in different cwds → work area separation
 - **Namespace conflict**: Same skill name exposed across multiple components simultaneously
-- **Drift**: Install path commit SHA ↔ original repo HEAD mismatch
+- **Drift**: Install path commit SHA ↔ original repo HEAD mismatch. **Three states, not two** —
+  `gitCommitSha` is absent on marketplace installs (measured: 6 of 11), and an absent SHA is
+  **`DRIFT-UNKNOWN` (cannot be checked)**, never "matches". Report `MATCH / DRIFTED /
+  DRIFT-UNKNOWN(n=…)` and **never fold `DRIFT-UNKNOWN` into the match count**
 - **Hook conflict**: Same event matcher across multiple components → inspect settings.json integration
 
 When risk found → user explicit decision gate (no automatic patching)
 
 ### Step 6. Result Persistence (Optional)
 
+**Canonical result file** (the "synergy reference file" referenced throughout this skill):
+
+```
+tracks/_meta/synergy_scan_{YYYY-MM-DD}.md      # local, gitignored by design
+```
+
+Verified 2026-08-11 against the two on-disk candidates:
+`tracks/_meta/synergy_scan_2026-07-31.md` **is** a synergy-pair ranking record and is the canon;
+`knowledge/shared/harness-core/fh_synergy_playbook.md` is **not** — it is a tracked, public
+integration playbook (FH × OpenCode / Hermes / OpenHuman workflows) with no pair registry.
+
+**Residency**: a scan output enumerates the operator's installed components and mapped field
+harnesses, which can carry company asset names. It belongs on a gitignored path only —
+never append discovered pairs to a tracked file such as the playbook.
+
 When persisting results:
-- Record discovered synergy pairs in result file
+- Record discovered synergy pairs in the canonical result file above
 - Confirm absence of equivalent external tools (environment comparison verification)
 
 ### Step 7. Proactive Discovery — Proactive Mode
@@ -107,30 +142,55 @@ When persisting results:
 
 #### 7-1. Dynamically Discover and Read Registry Path
 
+The registry is a **per-machine, gitignored** artifact (regenerated by the session scan). It therefore
+lives in the **working project**, not in the plugin cache — a plugin install path ships no `.claude/`
+directory at all, so searching only there yields a permanent false skip on every external install.
+
 ```bash
-# Auto-discover FH install path (avoid hardcoding)
+# Resolve FH install path (fallback root only). stderr is deliberately NOT discarded.
 FH_INSTALL=$(python3 -c "
 import json, pathlib
 p = pathlib.Path.home() / '.claude/plugins/installed_plugins.json'
 if p.exists():
     data = json.loads(p.read_text())
-    plugins = data if isinstance(data, list) else data.get('plugins', [])
-    for pl in plugins:
-        if 'forge-harness' in pl.get('name','') or 'fh' in pl.get('name','').lower():
-            print(pl.get('installPath',''))
+    raw = data.get('plugins', data) if isinstance(data, dict) else data
+    # version 2 = dict keyed by name; legacy = list of entries carrying 'name'
+    items = raw.items() if isinstance(raw, dict) else [(e.get('name',''), [e]) for e in raw]
+    for name, entries in items:
+        entry = entries[0] if isinstance(entries, list) else entries
+        if 'forge-harness' in name:
+            print(entry.get('installPath',''))
             break
-" 2>/dev/null)
+")
+py_rc=$?
 
-REGISTRY="${FH_INSTALL}/.claude/registry/LOCAL_SKILL_REGISTRY.md"
-if [ -f "$REGISTRY" ]; then
-  cat "$REGISTRY"
+if [ "$py_rc" -ne 0 ]; then
+  echo "[HARNESS_ERROR] installed_plugins.json read failed (python rc=$py_rc)."
+  echo "  Step 7 state = UNMEASURED. Do NOT report this as '[SKIP] no registry' — the inventory was never read."
 else
-  echo "[SKIP] LOCAL_SKILL_REGISTRY.md not found — skipping Step 7. Rerun with manual path if needed."
-  exit 0
+  REGISTRY=""
+  for CAND in "${CLAUDE_PROJECT_DIR:-$PWD}/.claude/registry/LOCAL_SKILL_REGISTRY.md" \
+              "${FH_INSTALL:+$FH_INSTALL/.claude/registry/LOCAL_SKILL_REGISTRY.md}"; do
+    if [ -n "$CAND" ] && [ -f "$CAND" ]; then REGISTRY="$CAND"; break; fi
+  done
+  if [ -n "$REGISTRY" ]; then
+    cat "$REGISTRY"
+  else
+    echo "[NOT-CONFIGURED] LOCAL_SKILL_REGISTRY.md absent (searched \$CLAUDE_PROJECT_DIR/.claude/registry/ then \$FH_INSTALL/.claude/registry/)."
+    echo "  Create: mkdir -p \"\${CLAUDE_PROJECT_DIR:-\$PWD}/.claude/registry\" and write LOCAL_SKILL_REGISTRY.md there (per-machine, gitignored by design)."
+  fi
 fi
 ```
 
-If file exists, extract `one-line description` + `example phrases` from newly registered projects/skills. If absent, skip Step 7 entirely.
+**Three outcomes, reported distinctly** (a missing measurement is not a zero):
+
+| Outcome | Meaning | Step 7 body |
+|---|---|---|
+| registry printed | configured and read | run 7-2 ~ 7-5 |
+| `[NOT-CONFIGURED]` | inventory read fine, no registry exists | skip 7-2 ~ 7-5, report this state + the creation hint |
+| `[HARNESS_ERROR]` | inventory could not be read | skip 7-2 ~ 7-5, report **UNMEASURED** — never as a skip or a clean result |
+
+If the registry was printed, extract `one-line description` + `example phrases` from newly registered projects/skills.
 
 #### 7-2. Load Existing Synergy Pair List
 
@@ -156,10 +216,10 @@ Compare domain of new skill/project against entire existing registry:
 |---|---|---|---|
 | 1 | `{new skill}` ↔ `{existing skill}` | ★★★ | {one-line description} |
 
-→ Add to synergy reference file? [Y / N]
+→ Add to the canonical result file (Step 6: `tracks/_meta/synergy_scan_{YYYY-MM-DD}.md`)? [Y / N]
 ```
 
-- **Y** → Automatically append to synergy reference file as new pair section
+- **Y** → Append to that file as a new pair section (gitignored path only — see Step 6 Residency)
 - **N** → Collect reason and discard or defer recording
 
 #### 7-5. Guards
@@ -182,12 +242,15 @@ External users automatically derive their own inventory via Step 1 `installed_pl
 
 ## Done When
 
-```
-All Steps 1~6 completed (Step 7 Proactive Mode only when registry change detected)
-+ Synergy ranking table (★~★★★) output
-+ User explicit decision gate completed if risk catch items exist
-+ User confirmed whether to persist results
-```
+| Condition | Check class |
+|---|---|
+| Steps 1~6 completed | **mandatory-pass** |
+| Synergy ranking table (★~★★★) output | **mandatory-pass** |
+| **Step 7 state reported as one of `run` / `not-configured` / `harness-error`** — never silently omitted, and `harness-error` never reported as a skip | **mandatory-pass** |
+| Step 5 drift reported as `MATCH / DRIFTED / DRIFT-UNKNOWN(n=…)`, with `DRIFT-UNKNOWN` excluded from the match count; Step 2 `ABSENT` asset classes carried through as `ABSENT`, not `0` | **measured** (counts come from the Step 1/2 output, not from recall) |
+| User explicit decision gate completed if risk catch items exist | **mandatory-pass** |
+| Synergy grades are defensible (★ assignment per the Step 4 table) | **judged** — adversarial pairing: `fh-meta:challenger` re-reads the pair list and attacks each ★★★ for "would these two actually chain, or do they merely sound adjacent?" |
+| User confirmed whether to persist results | **mandatory-pass** |
 
 ## Constraints
 

package/plugins/fh-meta/skills/deep-clarify/SKILL.md

@@ -83,13 +83,31 @@ Draft the spec first, then single confirmation: "Is this the right direction?"
 
 ## Step 3. Generate Spec Document
 
-Structure and save the results of the conversation.
+Structure and save the results of the conversation. **This step writes a file** — outputting the
+path is not saving it.
+
+1. Derive the slug: `slug = kebab-case(spec title) + "-" + YYYYMMDD`
+   (lowercase, non-alphanumerics → `-`, collapse repeats, strip leading/trailing `-`).
+   Example: "Rewrite the login flow" on 2026-08-11 → `rewrite-the-login-flow-20260811`.
+2. If `.claude/specs/{slug}.md` **already exists → ABORT** and report the existing path.
+   Never overwrite and never silently suffix — an existing spec is a prior decision to extend or
+   supersede, and that is the user's call.
+3. Create the directory, then write the file with the **Write** tool (not a shell redirect):
 
 ```bash
-# Save path
-.claude/specs/{task-slug}.md
+mkdir -p .claude/specs
 ```
 
+Then `Write` → `.claude/specs/{slug}.md` with the format below, and verify:
+
+```bash
+test -f .claude/specs/{slug}.md && echo "SPEC SAVED: .claude/specs/{slug}.md"
+```
+
+**Residency**: the spec records the user's goals, constraints, and "must not touch" list.
+`.claude/specs/` is gitignored in this repo; **in a company project, confirm the path is gitignored
+there too before writing** — if it is not, write to a gitignored location instead.
+
 ### Spec Document Format
 
 ```markdown
@@ -127,7 +145,7 @@ After generating the spec document, suggest the appropriate next path:
 | Situation | Connected skill |
 |---|---|
 | Agent orchestration needed for implementation | `agent-composer` — pass spec document path |
-| Plan / design review needed | `plan` agent — build plan based on spec |
+| Plan / design review needed | built-in `Plan` agent — build plan based on spec |
 | Single task is now clear | Start implementation directly |
 | Audit needed before external sharing | `hub-persona-auditor` |
 
@@ -135,10 +153,11 @@ After generating the spec document, suggest the appropriate next path:
 
 ## Done When
 
-| Condition | Completion verdict |
-|---|---|
-| Socratic dialogue complete + spec document saved | ✅ Clarification complete |
-| Spec path output: `.claude/specs/{slug}.md` | ✅ Save complete |
-| Follow-up skill connection suggestion output | ✅ Handoff complete |
+| Condition | Completion verdict | Check class |
+|---|---|---|
+| Socratic dialogue complete (≤3 rounds, ≤2 questions/round) | ✅ Clarification complete | **mandatory-pass** |
+| `test -f .claude/specs/{slug}.md` exits 0 — the file **exists on disk** | ✅ Save complete | **mandatory-pass** (a printed path is not a saved file) |
+| The spec's Completion Criteria are independently verifiable — someone other than the author could tell whether each is met | ✅ Spec actionable | **judged** — adversarial pairing: `fh-meta:beginner` cold-reads the spec and attempts to state, per criterion, how they would check it; a criterion they cannot operationalize fails |
+| Follow-up skill connection suggestion output | ✅ Handoff complete | **mandatory-pass** |
 
 **This skill's Done When = "actionable spec document saved".** Implementation itself is the domain of follow-up agents/skills.

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

@@ -2,6 +2,10 @@
 name: fh
 description: Renders the FH hub map on demand — the door menu, a starter set of skills, and the most-used trigger phrases — without requiring a greeting. State-aware; composes live candidates from the session card and tracks.
 user-invocable: true
+allowed-tools: ["Read", "Grep", "Glob"]
+# /fh is read-only by construction: it detects state and renders a map. It was the only one of
+# the 40 SKILL.md files with no allowed-tools declaration at all. Read/Grep/Glob is the full set
+# its body needs — no Bash, Write, Edit, or Agent appears anywhere in it.
 ---
 
 # /fh — hub map on demand