@chrono-meta/fh-gate 1.4.95 → 1.4.96

package/plugins/fh-meta/skills/persona-roster-expander/SKILL.md

@@ -2,7 +2,7 @@
 name: persona-roster-expander
 description: Expands a named persona seed into a tiered, judgment-mapped cast — tiering each persona by a domain safety rule, mapping each to a decision-lens in the user's vocabulary, then proposing additional voices with sourced anchors.
 user-invocable: true
-allowed-tools: ["Read", "Grep", "WebSearch", "WebFetch"]
+allowed-tools: ["Read", "Grep", "WebSearch", "WebFetch", "Write", "Agent"]
 model: sonnet
 ---
 
@@ -15,7 +15,12 @@ caller-supplied safety rule so the expansion stays faithful to the domain's cons
 
 > Origin: harvested from the-bible (2026-06-20) — an operator persona seed (priest/nun/angel/devil/
 > God/Jesus/Holy-Spirit/apostles) tiered relay-vs-lens by a relay-safety rule and mapped to
-> engineering-judgment lenses, +4 sourced proposals. See
+> engineering-judgment lenses, +4 sourced proposals. **The grounds, inline, because the harvest
+> record does not ship**: an ungated persona cast drifts into inventing its own authority — a voice
+> given a lens will speak past what the domain lets it assert — so tiering by a *caller-supplied*
+> rule is what keeps the expansion faithful, and the lens mapping is what makes a named voice
+> usable as a decision instrument instead of flavor. 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
@@ -41,14 +46,17 @@ caller-supplied safety rule so the expansion stays faithful to the domain's cons
 4. **Propose 2–4 additions** filling lenses the seed doesn't cover (delegate net-new *name*
    generation to the `persona-innovator` agent — this skill's distinct value is the tiering +
    lens-mapping, not naming). For the strongest 2–3, find a real anchor (a sourced
-   example/reference), not a shallow stub.
-5. **Emit the tiered, lens-mapped cast** (named + proposed) as a structured artifact the system can
-   load (e.g. `personas.json`).
+   example/reference); **any remaining proposal ships with a literal `stub:` prefix** — unanchored
+   and unlabeled is not an allowed output (see Done When).
+5. **Emit the tiered, lens-mapped cast** (named + proposed) by **writing it to a structured file**
+   the system can load (e.g. `personas.json`), then confirm the written file parses. Leaving the
+   cast in the response text only does not complete this step.
 
 ## Done When
 - **Every persona has a tier + lens label + invoke-condition.** *Check class: mandatory-pass (binary — all three fields present per persona).*
-- **Each net-new proposal names a real anchor** (not a stub). *Check class: judged, pair: an anchor-existence check (the cited source/reference resolves).*
-- **The tiering respects the caller's safety rule** (no persona exceeds its tier's allowed emission). *Check class: judged, pair: an adversarial read — find a persona whose mapping lets it act beyond its tier.*
+- **Every proposal is either anchored or explicitly labeled a stub.** An anchored proposal names a source/reference that resolves; a proposal without one is emitted with a literal `stub:` prefix and is **not counted as a candidate**. *Check class: mandatory-pass (binary — each proposal carries either a resolving anchor or a `stub:` label; an unanchored, unlabeled proposal is FAIL). Anchor resolution is checked mechanically (fetch/look up the cited reference), not by judgment.* (This is the Done-When floor; Step 4's "strongest 2–3" is the effort target that sits above it — a 4th proposal may ship as `stub:` without violating either.)
+- **The cast is materialized as a loadable artifact** (e.g. `personas.json`) that a consumer can parse — the file exists on disk and a parse of it succeeds against the declared schema (per persona: tier / lens / invoke-condition; per proposal additionally `anchor` or `stub:`). *Check class: mandatory-pass (binary — file exists and parses; a cast that exists only in the response text is UNMET).*
+- **The tiering respects the caller's safety rule** (no persona exceeds its tier's allowed emission). *Check class: judged, pair: dispatch `fh-meta:challenger` at the tier-escalation angle — "find a persona whose lens mapping lets it emit beyond its tier". The pairing is a **different-agent** read; the author's own re-read does not satisfy it. If that agent is unreachable, record `pair: unavailable (<reason>)` — the condition stays UNMET and is **reported as a named residual**, never self-scored closed. It does **not** block delivery: a roster is a reversible artifact, so the degrade direction here is declare-and-ship, not fail-closed (that direction is reserved for irreversible surfaces — publish, delete, history-rewrite). Shipping with an UNMET pairing is honest; silently marking it met is the defect.*
 
 ## Guards
 - **Caller-supplied safety rule is mandatory** — the skill tiers by the domain's rule, it does not

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

@@ -2,7 +2,7 @@
 name: plugin-recommender
 description: Given a task description, searches internal and external open-source ecosystems (including Codex marketplace and Claude Code marketplace) to find and recommend suitable plugins with installation guidance. Recommendation is quality-validation based (marketplace-listed + performance-validated), not source-origin based. Activates on "recommend a plugin", "what tool should I use?", "is there a plugin for this?", "recommend a tool". Also checks for duplicate installations.
 user-invocable: true
-allowed-tools: ["Grep", "GoogleWebSearch", "Bash"]
+allowed-tools: ["Read", "Grep", "Bash", "WebSearch", "WebFetch"]
 model: sonnet
 ---
 
@@ -59,7 +59,9 @@ Tier is **independent of platform origin** (Anthropic / OpenAI / community). A w
 
 2. **[Priority 1.5] Internal GHE Sister Assets (partially completed work — Tier 2)**: Check if user's task domain already exists in internal sister asset clusters. Prioritize direct use or adoption of sister assets if the user's task falls within these cluster domains.
 
-3. **[Priority 2.5] Project Reference/Contribution Path**:
+3. **[Priority 2] Organization's Internal GHE (Tier 1–4)**: Search internal GHE with keywords like `claude-plugin`, `gemini-plugin` + user keywords / API search. Replace with your organization's internal GHE orgs.
+
+4. **[Priority 2.5] Project Reference/Contribution Path**:
 
     For cases where referencing or contributing to the project itself is more appropriate than installing a plugin. Provide guidance when there's intent for medium-term contribution rather than immediate use.
 
@@ -71,9 +73,7 @@ Tier is **independent of platform origin** (Anthropic / OpenAI / community). A w
     - `plugin-recommender` [Priority 2.5]: When no immediately usable plugin is available → guide to project-level reference/contribution path (alternative to installing)
     - `cross-ecosystem-synergy-detection`: Discover hidden synergies among already-installed skills (post-install utilization optimization)
 
-    Activation condition: Automatically entered when Step 2 [Priority 1]~[Priority 2] search yields no suitable plugin.
-
-4. **[Priority 2] Organization's Internal GHE (Tier 1–4)**: Search internal GHE with keywords like `claude-plugin`, `gemini-plugin` + user keywords / API search. Replace with your organization's internal GHE orgs.
+    Activation condition: Automatically entered when Step 2 [Priority 1]~[Priority 2] search yields no suitable plugin. **This block therefore runs only after [Priority 2] has actually been executed** — the list above is in execution order (1 → 1.5 → 2 → 2.5 → 3), and the priority labels are names, not the run sequence.
 
 5. **[Priority 3] External Open-Source Ecosystem**: WebSearch / WebFetch — "best github actions for X", "claude plugin for Y", etc. Simplification guard: defer external install if internal assets suffice.
 
@@ -91,16 +91,18 @@ When queried for a specific capability (e.g., "adversarial reviewer for bash cod
 0. **Platform built-ins (Tier 0)** — does a built-in skill/command already cover the capability? Check the live session's available-skills list before any plugin search. A built-in that covers ~80% beats installing a plugin for the rest
 1. **Installed locally** — `.claude/agents/`, `plugins/` in current cwd
 2. **FH native skills** — always-loaded knowledge in `plugins/fh-meta/` and `plugins/fh-commons/`
-3. **Claude Code marketplace** — `claude mcp search [capability]` or known CC registry (see verified targets above)
-4. **Codex marketplace** — `npx @openai/codex list-agents [capability]` or known Codex registry
+3. **Claude Code marketplace** — `claude plugin list --available --json` (marketplace plugins; `--available` **requires** `--json`) + `claude plugin marketplace list` to see which marketplaces are even configured. There is **no** CLI keyword-search subcommand — filter the JSON yourself, and fall back to the known CC registry (see verified targets above) for anything not in a configured marketplace
+4. **Codex marketplace** — `npx --yes @openai/codex plugin list --available --json` (optionally `-m <marketplace>`) + `npx --yes @openai/codex plugin marketplace list`. Same limitation: no keyword search, filter the JSON
 5. **npm ecosystem** — `@chrono-meta/`, `@anthropic/`, and other known-quality scoped packages
 
+⚠️ **A failed or empty discovery lane is NOT "no candidates".** Both CLIs above list only *configured* marketplaces, and a non-zero exit / empty array means the lane did not answer — not that nothing exists. Report each lane's state explicitly (`EXECUTED` / `EMPTY` / `FAILED: <stderr>`) and never render a `FAILED` lane as a zero result; a lane that could not run must be re-run or replaced by the web-search fallback (Priority 3) before you tell the user nothing was found.
+
 **Discovery priority**: built-in (Tier 0) > installed > FH native > Tier 1 (any platform) > Tier 2 > Tier 3 > Tier 4
 **Tier 0 guard**: FH native wins over a built-in only when the FH skill adds governance the built-in lacks (e.g. `/goal` → `goal-quench` adds budget+quality gates; code diff review stays with built-in `/code-review`, FH-asset coherence with `hub-cc-pr-reviewer`)
 
 **When sim-conductor chains here for persona discovery**: apply the same platform-aware search scoped to persona/simulation/review capability tags. Return discovered agents with their Tier rating so sim-conductor can decide whether to install or use a built-in brief.
 
-For discovery bash commands (`claude mcp search`, `npx @openai/codex list-agents`, npm scoped search), see `SKILL_detail.md §Discovery-Bash`.
+For discovery bash commands (`claude plugin list --available --json`, `npx --yes @openai/codex plugin list --available --json`, npm scoped search), see `SKILL_detail.md §Discovery-Bash`.
 
 ### Step 2.6: Quality Validation Signals
 
@@ -149,7 +151,8 @@ When user selects desired plugin from recommendation list, help with installatio
 ## Constraints
 
 - **Recommendations, not guarantees**: Does not guarantee plugin performance, stability, or security.
-- **Inbound supply-chain risk (Tier 3/4)**: a Tier 3/4 candidate (§Tier Classification Table) has no marketplace vetting — public skill registries have shipped malicious skills at scale (pointers: [HN 47370624](https://news.ycombinator.com/item?id=47370624) — 824 malicious skills reported on ClawHub; [HN 48678603](https://news.ycombinator.com/item?id=48678603) — Snyk ToxicSkills study. Secondary sources — verify before quoting figures). Flag this explicitly to the user before recommending a Tier 3/4 candidate.
+- **Inbound supply-chain risk — EVERY tier, not just 3/4**: public skill registries have shipped malicious skills at scale (pointers: [HN 47370624](https://news.ycombinator.com/item?id=47370624) — 824 malicious skills reported on ClawHub; [HN 48678603](https://news.ycombinator.com/item?id=48678603) — Snyk ToxicSkills study. Secondary sources — verify before quoting figures). ⚠️ **The channel in both incidents was the marketplace listing itself — i.e. Tier 1/2.** An earlier version of this bullet scoped the warning to Tier 3/4, which inverted its own evidence: it warned loudest exactly where vetting exists and stayed silent where the cited attacks landed. Flag the risk before recommending **any** candidate; a high Tier means *listed and maintained*, never *audited for intent*.
+- **Install string must be resolved, not relayed**: the `<name>` in an install command frequently comes from a web-search result. Before surfacing it, confirm the name resolves to the intended repository (owner/repo matches the source you are citing) — a plausible near-name is the cheapest form of this attack, and installation is irreversible on the machine that runs it.
 - **User consent required**: Does not auto-install without explicit consent.
 - **Search scope limitations**: Only searches within configured search space.
 
@@ -213,9 +216,34 @@ sim-conductor needs persona X (no installed/built-in match)
 
 ```
 All Steps 0~5 completed
-+ Recommendation list table output (top 2~3 items, Tier + Platform + synergy grade included)
-+ Install completed after user selection (or install skipped / 5-B migration path guided)
+  — mandatory-pass: each step produced its stated output, or is
+    explicitly marked N/A with the reason
+
++ Recommendation list table output (top 2~3 items, Tier + Platform + synergy
+  grade included)
+  — mandatory-pass: the table exists with all three columns populated
+
++ Every discovery lane reported with an explicit state
+  (EXECUTED / EMPTY / FAILED: <stderr>)
+  — measured: count lanes attempted vs lanes reporting a state; the two
+    numbers must match. A FAILED lane rendered as "no candidates" is a FAIL
+    of this condition, not a pass — the CLI lanes have no keyword search and
+    see only configured marketplaces, so an empty result is routinely a
+    non-answer rather than an absence (`not found` != `0`)
+
++ Install completed after user selection (or install skipped / 5-B migration
+  path guided)
+  — mandatory-pass: explicit user consent recorded before any install ran
+
 + Duplicate detection results reported
+  — mandatory-pass: `claude plugin list` output consulted in this run
+
++ Every install string surfaced to the user resolves to the repository it is
+  cited from (§Constraints — resolved, not relayed)
+  — judged; adversarial pairing: in the same run, resolve one candidate name
+    you already know is correct AND check one near-name variant. If the
+    procedure cannot separate that pair, the resolution check is
+    UNCALIBRATED and no install string may be presented as verified
 ```
 
 ## Failure Response

package/plugins/fh-meta/skills/plugin-recommender/SKILL_detail.md

@@ -57,16 +57,24 @@ gh auth status  # default host (github.com) only
 # Unauthenticated → guide github.com PAT generation above
 ```
 
-**Claude Code marketplace search:**
+**Claude Code marketplace discovery** (there is **no** `search` subcommand — `claude mcp search` does not
+exist and exits 1 with `unknown command 'search'`; list, then filter yourself):
 ```bash
-claude mcp search [capability-keyword]
+claude plugin marketplace list --json      # which marketplaces are configured at all
+claude plugin list --available --json      # installed + available marketplace plugins (--available REQUIRES --json)
 ```
 
-**Codex marketplace search:**
+**Codex marketplace discovery** (`list-agents` does not exist either — the real noun is `plugin`):
 ```bash
-npx @openai/codex list-agents [capability-keyword]
+npx --yes @openai/codex plugin marketplace list
+npx --yes @openai/codex plugin list --available --json      # add -m <marketplace> to scope
 ```
 
+> **Lane-state reporting (mandatory).** Neither CLI supports a keyword query, and both see only
+> *configured* marketplaces. Record each lane as `EXECUTED` / `EMPTY` / `FAILED: <stderr>` and carry
+> that state into the recommendation. **A `FAILED` lane must never be rendered as "no candidates"** —
+> re-run it or fall back to Priority 3 web search before reporting an empty result.
+
 **npm ecosystem search (scoped packages):**
 ```bash
 npm search @chrono-meta [keyword]
@@ -113,11 +121,20 @@ If either duplicate condition met → skip install → report "Already active"
 #### 5-1 through 5-3. Install Steps
 
 1. Confirm intent: "Would you like to install the `[plugin-name]` plugin?"
-2. On agreement:
+2. On agreement — **the two commands take different arguments**: `marketplace add` takes a *source*
+   (`<owner/repo>`, a URL, or a local path), never a plugin name; only `install` takes the plugin name.
    ```bash
-   claude plugin marketplace add [plugin-name]
-   claude plugin install [plugin-name]
+   # Usage: claude plugin marketplace add [options] SOURCE
+   #   SOURCE = owner/repo, a URL, or a local path — NEVER a plugin name
+   SOURCE="owner/repo"
+   PLUGIN="plugin-name"        # optionally "plugin-name@marketplace" to disambiguate
+
+   claude plugin marketplace add "$SOURCE"
+   # Usage: claude plugin install|i [options] PLUGIN
+   claude plugin install "$PLUGIN"
    ```
+   Skip the `marketplace add` line when the plugin already resolves from a configured marketplace
+   (check `claude plugin marketplace list`).
 3. Post-install initial configuration guidance:
    - **API token input**: Guide token generation path for external service APIs (Jira/Confluence/Slack — specify each service's token page URL + env var or plugin config storage location)
    - **MCP connection**: If plugin uses MCP server, guide auto-update of `.mcp.json` or `claude mcp add` command

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

@@ -1,8 +1,8 @@
 ---
 name: prompt-regression
-description: Detects harness regressions by running standard prompt probes after rule/skill changes and comparing outputs against saved baselines. Triggers on "prompt regression", "did my changes break anything", "regression check", "test harness changes".
+description: Statically checks harness assets against a known-answer probe set after rule/skill changes — inspects the changed source for the trigger phrases, chain links and gate conditions each probe expects, and reports PASS/FAIL/SKIP per probe. Source inspection only; it does not run live sessions, so it catches assets that no longer SAY the right thing, not models that stop DOING it. Triggers on "prompt regression", "did my changes break anything", "regression check", "test harness changes".
 user-invocable: true
-allowed-tools: ["Read", "Bash", "Glob", "Grep"]
+allowed-tools: ["Read", "Write", "Bash", "Glob", "Grep"]
 model: sonnet
 complexity_routing:
   base: sonnet
@@ -58,8 +58,15 @@ ls .claude/regression/probes.md 2>/dev/null || echo "NO_CUSTOM_PROBES"
 ```
 
 **If custom probes exist**: load and use them. The hub repo ships its golden probe set
-(known-answer offline eval, 32 probes with check classes) at exactly this path — when
-present it is canonical and supersedes the default matrix below.
+(known-answer offline eval, **33 probes** with check classes — 27 mandatory-pass · 1 measured ·
+5 judged, of which 2 rows are inert deletion anchors, so live coverage is 31) at exactly this path
+— when present it is canonical and supersedes the default matrix below.
+
+> Count from the file, not from this line: `grep -cE '^\| *`[A-Z][A-Z0-9-]*-[0-9]+` *\|'
+> .claude/regression/probes.md`. Both this number and the tally inside `probes.md` read `32` until
+> 2026-08-12, when the actual count was 33 — a probe had been added to section A without touching
+> either summary. A count duplicated in two files rots independently; if the two disagree, the file
+> wins and both get corrected.
 
 **If no custom probes** (e.g. Mode C install without the hub repo): use the default
 probe matrix below.
@@ -93,7 +100,23 @@ If change scope is `CLAUDE.md` core (10+ lines changed): run **full suite** (all
 
 ---
 
-### Step 4. Run Affected Probes
+### Step 4. Evaluate Affected Probes (static source inspection)
+
+**What this step is, stated plainly.** Every check below reads the changed *source* and asks whether
+the text a probe expects is still there. No live session is started, no model is prompted, no output
+is compared against a recorded transcript. The description said "running standard prompt probes …
+comparing outputs against saved baselines", which reads as live execution; the honest label is a
+**known-answer static check**.
+
+**What it therefore cannot catch** — say this in the report, do not leave it implied:
+- a rule that is still present but has stopped *firing* (salience loss, ordering, competition
+  from another rule)
+- a trigger phrase present in the file but shadowed by a higher-priority route
+- any behavior change that leaves the source text identical
+
+Those need a dispatched blind sim at the target tier (`sim-conductor`, or the target-tier sim gate in
+`.claude/rules/fh_4axis_gate.md`). A green report here means *the assets still say the right thing*.
+Treating it as behavioral evidence is the misread this section exists to prevent.
 
 For each affected probe, evaluate:
 
@@ -150,24 +173,44 @@ If all probes pass:
 
 After a deliberate behavior change (not a regression — an intentional improvement), update the baseline:
 
+Prompt user first: *"Probe `G-GATE-03` now expects the new gate format. Update baseline? (y/n)"*
+Only update on explicit `y` — never auto-update.
+
+On `y`, actually perform the write. The previous version of this step was three lines of which two
+were comments — it created the directory and stopped, so "baseline updated" was reported by a step
+that had written nothing.
+
 ```bash
-# Baseline stored as markdown in .claude/regression/
 mkdir -p .claude/regression
-# Write updated probe expectations
 ```
 
-Prompt user: *"Probe P-CHAIN-01 now expects the new gate format. Update baseline? (y/n)"*
+Then **use the `Write` tool** on `.claude/regression/probes.md` (create it from the SKILL.md default
+matrix if absent) to apply the approved edit. Each approved change edits the probe's row in place —
+Expected Behavior, Scope, and Class — and:
 
-Only update on explicit `y` — never auto-update.
+- update the `**Count**:` tally line **in the same edit** if a row was added or removed, including
+  the per-section breakdown and the class counts (a stale tally is exactly how the `32`/`33`
+  mismatch was introduced)
+- append a one-line note under `**Baseline**:` recording the date and the reason for the change
+- never rewrite rows the user did not approve
+
+Confirm afterwards by re-reading the file and reporting the row's new content plus the recount —
+`grep -cE '^\| *`[A-Z][A-Z0-9-]*-[0-9]+` *\|' .claude/regression/probes.md`. Do not report a
+baseline update whose result you have not read back.
 
 ---
 
 ## Done When
 
-- All affected probes are evaluated (PASS / FAIL / SKIP) — class: mandatory-pass
+- All affected probes are evaluated (PASS / FAIL / SKIP) and the three counts sum to the number of
+  probes selected in Step 3 — class: measured (`PASS + FAIL + SKIP == selected`)
 - Regression report is output with clear PASS/FAIL verdict — class: mandatory-pass
+- The report states its own scope: **static source inspection, no live session run** — a green
+  verdict is never presented as behavioral evidence — class: mandatory-pass
 - If FAIL: specific file + line fix is recommended — class: judged, paired with verify-bidirectional (the fix recommendation is re-checked, not trusted as-is)
-- Baseline updated only on explicit user approval — class: mandatory-pass (HITL)
+- Baseline updated only on explicit user approval, and the written file is **read back** and its
+  probe count reported — class: mandatory-pass (HITL). Approval alone does not close this: a step
+  that prompts, gets `y`, and writes nothing satisfied the old wording.
 
 ---
 

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

@@ -2,7 +2,7 @@
 name: salience-splitter
 description: 'Splits an over-loaded always-loaded context asset — a SKILL.md, CLAUDE.md, or memory index — into a lean always-loaded layer + an on-demand layer, using a governance-semantic criterion (not length, but when the content is needed), connected by imperative pointers. Based on paper §9.5 Protocol-Priority Split pattern. Diagnoses, classifies, splits, and verifies in one pass. Renamed from skill-splitter (old name still routes here). Triggers: "SKILL.md too large", "split this skill", "skill is bloated", "skill file too long", "CLAUDE.md 너무 커".'
 user-invocable: true
-allowed-tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob"]
+allowed-tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob", "Agent"]
 model: sonnet
 ---
 
@@ -46,6 +46,43 @@ model: sonnet
 
 **One test**: *"If a consumer agent had only SKILL.md, could they recognize the trigger, understand the full step sequence, and make the key decisions?"* → Yes = correct split. No = something behavioral is missing from SKILL.md.
 
+### Two floors this skill must not cross (behavioral — resident on purpose)
+
+**① A cut is measured, never eyeballed** — and *which* measurement depends on what layer you are
+cutting from. Both branches forbid the same thing ("I read it and it looks redundant" is not a
+measurement); they differ in cost because the surfaces differ:
+
+| Cutting from | Measurement | Why this one |
+|---|---|---|
+| **Resident layer** — CLAUDE.md, a memory index (loaded every session, for every task) | **Ablation harness**: pre-registered question set · **isolated arm B** · `reps>=3` · runner precondition `bash scripts/ablation_calibrate.sh` exits 0 (canon = `scripts/probe_scope_check.sh` header) · verdict line → `.claude/regression/ablation_verdicts.md` | A wrong cut here degrades *every* session silently, and the cost is unattributable after the fact |
+| **SKILL.md → SKILL_detail.md** (loaded only when the skill is invoked) | **Cold-start sim**: `sim-conductor` Area D-skill on SKILL.md alone must reach grade F (see Done When) | The failure is scoped to one skill's invocation and the sim reproduces exactly that condition |
+
+**Arm B answering confidently wrong is a KEEP, not a pass** — fluency is not recall, and that is the
+whole reason the arm is isolated. The same reading applies to the sim: a consumer that improvises
+plausibly without the moved rule is grade P, not F.
+
+This skill is the one that executes resident removal, so the procedure is named *here* rather than
+assumed — an earlier version left the judgment "mentally", which is exactly the eyeball path both
+branches exist to replace. **Do not read the resident row onto the SKILL.md row**: requiring a full
+ablation for every ambiguous SKILL.md section would price routine splitting out of existence, which
+is how a floor turns into a bypass trainer (cross-family review 2026-08-11 flagged exactly that
+over-block in the first draft of this section).
+
+**② Every split must re-ask whether the destination is inside the gate.** Moving content to a new
+path can move it **out of the 4-axis gate's pathspec** — the gate-locality class has recurred four
+times, most sharply when `SKILL_detail.md` fell outside a literal `SKILL\.md` term and 27.7% of the
+skill-spec surface went ungated (it leaked twice for real). `.claude/rules/fh_4axis_gate.md` names
+*this skill* as the producer that **widens that hole every time the diet succeeds**. So coverage is
+re-verified mechanically at split time, not assumed:
+
+```bash
+bash scripts/gate_pathspec_check.sh    # exit 0 = known-pair coverage holds, 1 = a pair broke
+```
+
+A destination path the gate does not match is not a "later" item: **ship the pathspec update in the
+same commit as the split** — the split and its coverage are one change, and separating them is how
+the surface silently shrinks.
+
 ---
 
 ## Step Overview
@@ -64,13 +101,57 @@ Step 3 — Draft SKILL_detail.md
     One ## §SectionName header per pointer in SKILL.md
     Move removed content under its section
     Front-matter: name, description, load: on-demand
+    → Gate check (Floor ②): destination path inside the 4-axis pathspec?
+      bash scripts/gate_pathspec_check.sh — not-matched = update the pathspec in THIS commit
 
 Step 4 — Verify
     phantom-quench: every §pointer in SKILL.md resolves to ## §SectionName in SKILL_detail.md
     sim-conductor Area D-skill: consumer agent with SKILL.md only → must reach grade F
+      (grade scale — sim-conductor SKILL.md §Area-D: F = Functional/PASS · P = Partial · B = Broken)
     → Any pointer mismatch or grade P/B → fix before commit
 ```
 
+**Step 4 pointer↔header comparison — run it, don't eyeball it.** Both sides need normalizing or the
+check produces ~100% false positives: real headers are written `## §Name — description`, so a naive
+compare never matches. And extraction must be anchored to the **declared pointer form**
+(see "Imperative Pointer Format" below — a blockquote line whose bolded lead is followed by
+`See`), not to "a mention of the
+detail file": any prose that *discusses* a pointer, quoted or not, is otherwise collected as one.
+That is not hypothetical — a paragraph on this page names an example section, and a
+backtick-only filter counted it as a live pointer:
+
+```bash
+S="plugins/{plugin}/skills/{name}"   # the skill dir being split
+# pointer side: any bolded-lead "See" line (the marker word varies — **Detail**, **Template**, …),
+# and ALL §names on it (a documented variant puts two pointers on one line)
+diff <(grep -E '^> \*\*[A-Za-z]+\*\*: See ' "$S/SKILL.md" \
+         | grep -oE '§[A-Za-z0-9_-]+' | sed 's/^§//' | sort -u) \
+     <(grep '^## §' "$S/SKILL_detail.md" | sed 's/^## §//; s/ *—.*//' | sort -u)
+# rc=0 → every pointer resolves and every §header has a pointer. rc=1 → the diff names both directions
+#         ("<" = pointer with no section · ">" = section with no pointer, i.e. an orphan).
+```
+
+**Calibrate before trusting it** (this check was wrong twice while being written — each narrowing
+looked reasonable and produced false orphans): run it across sibling skills and confirm it
+*discriminates*. Measured 2026-08-11 over 6 FH skills: 5 exit 0, `steel-quench` exits 1 on a real
+orphan (`§Phase0` — no pointer anywhere in its SKILL.md), and this page's own prose example is not
+collected. A version of this check that flags everything, or nothing, is not measuring.
+
+**Orphan check covers `^## `, not `^## §` — and the two checks have different jobs.** The diff above
+compares §-prefixed headers against pointers; a header written *without* the `§` prefix is invisible
+to it. Measured across this repo's `SKILL_detail.md` files: **139 `## ` headers vs 97 `## §`**, so 42
+(30%) sit outside the comparison entirely and would pass forever. So run both, and read them as one
+rule:
+
+```
+diff (§ side)   → pointer↔header agreement, both directions
+grep '^## '     → coverage net: any header the diff could not see
+resolution      → give it the § prefix AND a pointer (then the diff covers it), or merge it away
+```
+
+A non-§ header listed by the grep and left alone is **not** a pass — it is the orphan the §-only
+scan used to hide.
+
 > **Detail**: See `SKILL_detail.md §Verification-Checklist` — pre-commit checklist table (8 checks) — read when running Step 4 verification.
 
 > **Detail**: See `SKILL_detail.md §Split-Execution` — step-by-step trimming procedure, SKILL_detail.md front-matter format, orphan-section check — read when executing Steps 2–3.
@@ -120,17 +201,49 @@ Run on a SKILL.md when **any one** of:
 
 ## Done When
 
+**Common to all three scopes** (§Scope declares SKILL.md · CLAUDE.md · memory index — the conditions
+below are the ones that hold whatever was split; scope-specific conditions follow):
+
 ```
 Step 1 classification table produced
+  (mandatory-pass — the table exists and every section carries a verdict)
++ Every AMBIGUOUS section carries the measurement its layer requires (Floor ①)
+  (measured — resident layer: ablation verdict line in .claude/regression/ablation_verdicts.md
+   (pre-registered set, isolated arm B, reps>=3) · SKILL.md layer: cold-start sim grade F.
+   Eyeball judgment = NOT met on either branch)
++ Gate coverage re-verified for every destination path introduced by the split
+  (mandatory-pass — `bash scripts/gate_pathspec_check.sh` exits 0, or the pathspec update
+   ships in the same commit)
++ No behavioral rule lives only in the on-demand layer
+  (judged — pair: an isolated consumer read that has ONLY the always-loaded layer and must reach
+   a decision the moved rule governs; author re-reading their own split does not satisfy this)
+```
+
+**Scope-specific — SKILL.md split:**
+```
 + SKILL.md trimmed: triggers · principles · step overview · decision tables · Done When retained
-+ SKILL.md has imperative pointer for every removed section (> **Detail**: See SKILL_detail.md §<X>)
-+ SKILL_detail.md created: ## §SectionName header for every pointer in SKILL.md
++ Imperative pointer for every removed section; SKILL_detail.md carries one ## §header per pointer
+  (mandatory-pass — Step 4 normalized diff exits 0, both directions)
 + phantom-quench: 0 phantoms (all §pointers resolve)
   → Fallback (skill unavailable): run §Verification-Checklist manually from SKILL_detail.md
 + sim-conductor Area D-skill: grade F (consumer completes core task from SKILL.md alone)
-  → Fallback (skill unavailable): manually confirm "trigger → step overview → key decision → Done When" all present in SKILL.md
+  (measured — grade scale, sim-conductor SKILL.md §Area-D: F = Functional/PASS · P = Partial · B = Broken)
+  → Fallback (skill unavailable): manually confirm "trigger → step overview → key decision → Done When" present
 ```
 
-**Not done**: SKILL_detail.md has a §section with no pointer from SKILL.md (orphan section).
-**Not done**: Consumer agent grade P/B after split — a behavioral rule was moved to SKILL_detail.md when it should have stayed.
-**Not done**: Any behavioral rule present only in SKILL_detail.md.
+**Scope-specific — CLAUDE.md split:** the resident file keeps the rule *and* an imperative
+`> **Detail**: See …` pointer; the detail destination is inside the gate pathspec (Floor ②); a cold
+top-level session can still act on the rule without opening the detail file
+(judged — pair: a blind sim at the tier the rule must survive on, **not** the author's re-read).
+⚠️ Resident-footprint claims are measured only by a **fresh top-level `/context`** — file char counts
+are not resident measurements, and an agent-view window cannot measure it at all.
+
+**Scope-specific — memory index split:** every demoted entry is reachable from the archive by the
+recall path the index declares (mandatory-pass — grep the archive for the demoted entry's own nouns
+and hit it); the hot index keeps one line per surviving entry.
+
+**Not done**: an on-demand section with no pointer from the always-loaded layer (orphan) — scan
+`^## `, not `^## §` (30% of real headers carry no §).
+**Not done**: consumer grade P (Partial) or B (Broken) after split — a behavioral rule was moved out
+when it should have stayed.
+**Not done**: a section CUT on "it looked redundant" with no ablation verdict line.

package/plugins/fh-meta/skills/salience-splitter/SKILL_detail.md

@@ -55,13 +55,28 @@ For each section in target SKILL.md:
 
 ### Ambiguous content test
 
-When unsure, apply the **D-skill cold-start test mentally**:
+The D-skill cold-start question frames the decision:
 
 > *"If a consumer agent had only SKILL.md and typed the trigger phrase, would they need this content in the first 2 steps?"*
 > - YES → Always-loaded
-> - NO → On-demand
+> - NO → **candidate** for on-demand — not yet a verdict
 
-Behavioral rules always pass this test (even if rarely triggered, the consumer needs to know the constraint exists).
+**Do not answer it in your head.** AMBIGUOUS is precisely the case where the eyeball answer is
+unreliable, so the verdict is measured, per SKILL.md §Floor ① and CLAUDE.md's ablation procedure:
+
+```bash
+bash scripts/ablation_calibrate.sh          # runner precondition — must exit 0 before any arm runs
+# then run the pre-registered arms per scripts/probe_scope_check.sh (header = canon:
+#   arms · isolation · reps>=3 · pre-registration · the two leak channels)
+# verdict line → .claude/regression/ablation_verdicts.md
+```
+
+Read the result correctly: a section is CUT only when the **isolated arm B answers the pre-registered
+questions correctly**. Arm B answering **confidently wrong is a KEEP** — fluency is not recall, and
+that is the failure the isolation exists to expose.
+
+Behavioral rules skip the probe and stay Always-loaded (even if rarely triggered, the consumer needs
+to know the constraint exists) — that is a KEEP by classification, not an unmeasured cut.
 
 ---
 
@@ -148,19 +163,35 @@ Opening line:
 
 For each pointer in SKILL.md: create matching `## §SectionName` header, paste removed content under it.
 
-Orphan check: every `## §SectionName` in SKILL_detail.md must have a corresponding pointer in SKILL.md. If not → either add pointer or merge with adjacent section.
+Orphan check: every section header in SKILL_detail.md must have a corresponding pointer in SKILL.md.
+Scan `^## ` — **not** `^## §`: measured across this repo, 139 `## ` headers vs 97 `## §`, so a §-only
+scan is structurally blind to 42 (30%) of real sections and passes them forever. If a header has no
+pointer → add the pointer or merge with an adjacent section.
 
 ### Step 4: Verification sequence
 
 ```bash
-# 1. Pointer extraction from SKILL.md
-grep -oE "SKILL_detail\.md §[A-Za-z0-9_-]+" plugins/{plugin}/skills/{name}/SKILL.md
-
-# 2. Section headers in SKILL_detail.md
-grep "^## §" plugins/{plugin}/skills/{name}/SKILL_detail.md
-
-# 3. Diff — every pointer must have a matching section
-# Any pointer with no matching section = Phantom → fix before commit
+S=plugins/{plugin}/skills/{name}
+
+# 1+2+3 in one comparison. Three normalizations, each one learned from a false positive:
+#   · headers are written "## §Name — description"      → strip the em-dash tail
+#   · the marker word varies (**Detail**, **Template**) → match any bolded lead + "See"
+#   · one line may carry TWO pointers (documented variant, §Pointers)
+#                                                       → collect ALL §names on the line
+#   Anchoring on the pointer LINE (not "any mention of the detail file") is what keeps prose that
+#   merely DISCUSSES a pointer out — measured: a backtick-only filter counted an explanatory
+#   example as a live pointer, and a **Detail**-only filter called two real pointers orphans.
+diff <(grep -E '^> \*\*[A-Za-z]+\*\*: See ' "$S/SKILL.md" \
+         | grep -oE '§[A-Za-z0-9_-]+' | sed 's/^§//' | sort -u) \
+     <(grep '^## §' "$S/SKILL_detail.md" | sed 's/^## §//; s/ *—.*//' | sort -u)
+# rc=0 → every pointer resolves AND every §header has a pointer (both directions in one run)
+# rc=1 → the diff output names which side is missing what. Fix before commit.
+
+# 4. Orphan scan over the WIDER header form (see above — §-only misses 30%)
+grep -n '^## ' "$S/SKILL_detail.md"
+
+# 5. Gate coverage for the destination path (SKILL.md §Floor ②)
+bash scripts/gate_pathspec_check.sh
 ```
 
 Then run:
@@ -180,6 +211,8 @@ Use before committing a completed split:
 | All §pointers resolve | phantom-quench: 0 phantoms |
 | Cold-start grade F | sim-conductor Area D-skill: consumer reaches core completion |
 | No behavioral rule in SKILL_detail only | Any rule governing "what counts as X" present in SKILL.md |
-| No orphan §sections | Every ## §SectionName in SKILL_detail.md has a pointer from SKILL.md |
+| No orphan sections | Every `## ` header in SKILL_detail.md has a pointer from SKILL.md (scan `^## `, not `^## §` — §-only is blind to 30% of real headers) |
+| Gate coverage holds | `bash scripts/gate_pathspec_check.sh` exits 0, or the pathspec update ships in the same commit |
+| Ablation verdict for every AMBIGUOUS cut | Verdict line in `.claude/regression/ablation_verdicts.md`; arm B correct = CUT, arm B confidently wrong = KEEP |
 | SKILL.md ≤ 50% of original | Line count check |
 | SKILL.md flows without gaps | Reading SKILL.md alone gives complete step sequence understanding |

package/plugins/fh-meta/skills/sim-conductor/SKILL_detail.md

@@ -335,14 +335,39 @@ cross_model_coverage: [external | cross-session | NONE]   # NONE on risk≥mediu
 ```bash
 cd "$HARNESS_ROOT"
 BRANCH="fix/sim-$(date +%Y%m%d)-m-tier"
-git checkout -b "$BRANCH"
-# [process M-tier items]
-git add -p
+git switch -c "$BRANCH"
+# [process M-tier items] — collect the files this run actually edited
+# Explicit list; never a glob, never -A, never `.`. Use an ARRAY, not a space-separated string:
+# `git add -- $FILES` relies on bash word-splitting an unquoted parameter expansion, and zsh does
+# NOT split one (SH_WORD_SPLIT off by default). Under zsh the whole string arrives as ONE pathspec,
+# git errors "did not match any files", and the commit that follows stages nothing — the explicit-
+# path discipline this line exists to enforce silently stops applying in the operator's own shell.
+FILES=(path/to/edited1.md path/to/edited2.md)
+git add -- "${FILES[@]}"
+git diff --cached --name-only    # confirm the staged set IS the intended set before committing
 git commit -m "fix(sim-conductor): resolve M-tier findings from simulation YYYY-MM-DD"
 git push -u origin "$BRANCH"
 # PR creation requires explicit user request per CLAUDE.md PR principle
 ```
 
+> **Never `git add -p` here — this skill runs to completion unattended.** `-p` is interactive: with
+> no TTY it either blocks forever, or (with stdin closed) exits **0 having staged nothing**. Measured
+> 2026-08-12 on the documented chain: `add -p` → rc 0, nothing staged → `git commit` → **rc 1**,
+> while `git switch -c` had **already created the branch** — so the run leaves a branch behind, the
+> fixes uncommitted, and a success-shaped exit on the staging step. A silent no-op in the middle of
+> an auto-commit chain is worse than a hang, because only the hang is visible.
+>
+> **Why an explicit list rather than `-A` or `.`**: `sim-conductor` frequently runs in a checkout
+> shared with other work. `git add -A` sweeps up whatever else is dirty — measured above: a
+> co-resident `b.txt` was left untouched by `git add -- a.txt` and would have been swallowed by
+> `-A`. Note the boundary: `git add -- <file>` stages **the whole file**, including lines this run
+> did not write, so if another session has appended to a file you also edited, commit that append
+> first rather than absorbing it.
+>
+> `git diff --cached --name-only` before the commit is the mechanical check that the staged set
+> equals the intended set. Do not skip it — it is what turns "I passed the right paths" from a
+> belief into an observation.
+
 ---
 
 ## §PathB-Detail — External Environment Fallback