@chrono-meta/fh-gate 1.4.95 → 1.4.97

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

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

@@ -43,7 +43,7 @@ A designer's anxiety is most dangerous when vague. steel-quench breaks that anxi
 
 | Wave | Role | Termination |
 |---|---|---|
-| **Phase 0** (optional) | Counterexample calibration — extract patterns from external bad cases, merge into Wave 1 | No external case → skip |
+| **Phase 0** (optional) | Counterexample calibration — extract patterns from external bad cases, merge into Wave 1 (→ `SKILL_detail.md §Phase0`) | No external case → skip |
 | **Wave 1** | Challenger attack (quench-challenger) — surface critical flaws, no defense | — |
 | **Wave 2** | Defense — defend or state as residual risk | — |
 | **Wave 3+** | Convergence — repeat until a round is clean AND triggers no repair | Zero new S/A **and no repairs made in response, B included** (§Convergence Criteria) |
@@ -52,6 +52,8 @@ A designer's anxiety is most dangerous when vague. steel-quench breaks that anxi
 | **Wave 5** (optional) | Multi-Team Adversarial Panel — external CLIs or cross-session Claude | Wave 3+ criterion, cross-team |
 | **Wave-T** (after convergence) | Temper — measure complexity the quench *added*; flag over-hardening | τ-PASS or named τ-FAIL |
 
+> **Detail**: See `SKILL_detail.md §Phase0` — counterexample calibration full spec (pattern extraction from an external bad case, merge rules into Wave 1) — read when an external bad case is supplied.
+
 ---
 
 ## Step 0.3 — Artifact Vulnerability Profile

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

@@ -107,13 +107,22 @@ First identify the list of affected assets. Actual file modification is performe
 
 | Affected Asset | Update Location | Notes |
 |---|---|---|
-| memory `feedback_bidirectional_self_validation.md` | Add cumulative count + new round table | Self-perpetuation of this rule |
+| This SKILL.md §Validation Ledger | Add cumulative count + new round entry | Self-perpetuation of this rule. (Was `memory feedback_bidirectional_self_validation.md` — **absent, verified 2026-08-12**; the rule body is this file.) |
 | memory `project_*.md` (if affected) | Add relevant section | When naming, identity, or roadmap changes |
 | `tracks/_audit/*.md` (if affected) | Add pre-design section | When this validation affects persistent assets |
 | `CATALOG.md` | Add this session entry | For major decisions |
 | `reference_next_session_starter.md` §1 | Merge this conclusion | Material for next session entry |
 
-**Markdown editing discipline** (`feedback_markdown_edit_discipline`): Use Edit for existing `.md`. Write prohibited. If unavoidable, verify immediately with `git diff`.
+**Markdown editing discipline** — this skill's own rule, stated here rather than delegated:
+
+> Use `Edit` for any `.md` that already exists. `Write` on an existing file replaces it whole and
+> silently discards content this session never read — that is the failure mode the rule exists for,
+> not a style preference. If a full rewrite is genuinely unavoidable, `Read` the file first, then
+> verify immediately with `git diff` and report what changed.
+
+(Previously cited as `feedback_markdown_edit_discipline` — that memory key is **absent, verified
+2026-08-12**. The rule is live; only the pointer was dead, so it is written out here. A prohibition
+that rests on a file nobody can open is not enforceable.)
 
 ### Step 4.5. Change `diff` Review (User Gate Required)
 
@@ -144,7 +153,9 @@ Skip this step if no compatibility enhancement found (no token-filler).
 
 ### Step 6. Update Trigger Count + Skill Update Review
 
-Update trigger count in `memory feedback_bidirectional_self_validation.md`:
+Update the trigger count in the **§Validation Ledger** at the bottom of this file. (It formerly
+pointed at `memory feedback_bidirectional_self_validation.md`, **absent, verified 2026-08-12** —
+so the count had nowhere to land and this step could not actually be performed.)
 
 - 5+ accumulated = Skill promotion review (already fulfilled by creating this skill ✅)
 - 8+ accumulated = skill update review (rule refinement + round table compression + update this skill)
@@ -209,8 +220,8 @@ Speak up **before** entering implementation if any of these apply:
 
 - **This skill = validation and recording automation. Core decisions belong to the user** — this harness AI has no independent decision authority
 - **This harness AI self-catch cannot be applied alone** — follow `fact-checker` rule (narrow 1 / broad N+1)
-- **Simplification guard compliance** (`feedback_simplification_evidence`) — when creating/modifying this skill, only update SKILL.md. Do not create additional auxiliary files
-- **Markdown editing discipline obligation** (`feedback_markdown_edit_discipline`) — prefer Edit. Write prohibited
+- **Simplification guard compliance** — when creating or modifying this skill, update SKILL.md only. Do not spawn auxiliary files; a change that needs a new file needs a reason stated in the same edit. (Formerly cited `feedback_simplification_evidence` — **absent, verified 2026-08-12**)
+- **Markdown editing discipline obligation** — `Edit` on existing `.md`; `Write` only after reading the file, and verified with `git diff` (full statement in Step 4 above). (Formerly cited `feedback_markdown_edit_discipline` — **absent, verified 2026-08-12**)
 
 ## External User Environment Adaptation
 
@@ -220,7 +231,7 @@ This skill's core essence = "channel for updating baseline when user refinement
 
 | Origin Environment Dependency | External User Environment Fallback |
 |---|---|
-| `memory feedback_bidirectional_self_validation.md` (rule body) | User environment's own `memory/` or `notes/` bidirectional validation rule / if absent, follow this skill's own rule baseline |
+| Rule body — **this SKILL.md itself** (the origin environment's `memory feedback_bidirectional_self_validation.md` is **absent, verified 2026-08-12**; there is no origin-side file to fall back from) | User environment's own `memory/` or `notes/` bidirectional validation rule / if absent, this skill's own rule baseline — which is now the only baseline in either environment |
 | `memory feedback_*.md` grep scope (Step 2 priority 1) | User environment's own `learnings/` · `docs/` · `CLAUDE.md` grep (user's own baseline) |
 | `tracks/*/learnings/feedback_*.md` (Step 2 priority 2) | User environment's own learnings area (auto-detect naming variations) |
 | `knowledge/shared/harness-core/*.md` (Step 2 priority 4) | User environment's own `docs/` or `knowledge/` grep |
@@ -245,17 +256,64 @@ This skill's core essence = "channel for updating baseline when user refinement
 ## Done When
 
 ```
-Steps 1~6 all executed
-+ fact-checker self-catch mark output
-+ Step 4.5 diff gate user confirmation complete (y/N response received)
-+ Update trigger count updated
-+ External validation path: harvest-loop's Critic isolation pass (SAGE automated critique) can independently judge based on above criteria (skill_quality_rubric.md verifiable criteria)
+☐ Steps 1~6 all executed — a step that produced no artifact is
+  not executed                                                  (measured: 6 steps, 6 artifacts)
+☐ Step 1 baseline update applied BEFORE Step 2 grep runs — the
+  order is the point of the skill, not a formality              (mandatory-pass)
+☐ Step 2 consistency grep ran across all 4 priority scopes, and
+  each scope reports hits or an explicit "0 hits, scope exists"
+  — a scope that does not exist reports MISSING, never 0        (measured: 4 scopes reported)
+☐ fact-checker self-catch mark output                           (mandatory-pass)
+☐ Step 4.5 diff gate: user confirmation received (y/N) before
+  any file was modified; no answer == N                         (mandatory-pass, HITL)
+☐ §Validation Ledger has one new row and the Count line matches
+  the row total                                                 (measured: rows == Count)
+☐ Every memory/asset key cited in the round was confirmed to
+  RESOLVE before being used as grounds                          (mandatory-pass — an absent key
+                                                                 is cited as absent, never as
+                                                                 support)
+☐ The counter-argument was actually re-examined rather than
+  conceded to                                                   (judged — adversarial pairing:
+                                                                 `fact-checker` (narrow 1 /
+                                                                 broad N+1) re-runs the grep
+                                                                 independently; agreement with
+                                                                 the user is not evidence the
+                                                                 user was right)
+☐ External validation path available: harvest-loop's Critic
+  isolation pass can independently judge on the above criteria  (judged — adversarial pairing:
+                                                                 Critic runs isolated, not in
+                                                                 this session's context)
 ```
 
+> **Why the last two are judged, and paired.** This skill fires when the user pushes back, which is
+> precisely the moment agreement is cheapest. A Done When that only counts steps is satisfied by a
+> run that folded immediately. The pairing is the whole check: an isolated re-grep, and an isolated
+> critic — neither of which has seen this session's reasoning.
+
 Verdict: PASS (Step 4.5 diff gate confirmed, baseline updated) | CONDITIONAL_PASS (update applied, external validation still pending) | FAIL (counter-argument confirmed — AI recommendation was wrong, baseline requires redesign) | ESCALATE (counter-argument ambiguous, human judgment required)
 
 ## References
 
-- Rule body: `memory feedback_bidirectional_self_validation.md`
-- Operating model text: `memory feedback_hub_cc_operating_model.md §2.5·§2.6` — Insight 5 meta dimension + refinement challenge 4 patterns
-- Consistency rules: `feedback_external_ai_github_recommendation_verification` · `feedback_reference_own_hub_assets_first` · `feedback_simplification_evidence` · `feedback_markdown_edit_discipline` · `feedback_impact_first_then_tune`
+> **All memory keys below were checked on 2026-08-12 and every one is absent** (same-run
+> known-positive control: `feedback_verify_before_downgrade.md` and `memory_intent_recall.md`
+> both resolve, so the check is not misreporting). A struck entry here is not a fix if the same
+> name is still load-bearing above — the rules those keys carried have been written into the body
+> of this skill (Step 4 markdown discipline, §Constraints, §Validation Ledger), which is why the
+> strikethroughs below are safe to leave as history.
+
+- ~~Rule body: `memory feedback_bidirectional_self_validation.md`~~ — **absent (verified 2026-08-12)**. The rule body is **this file**; the cumulative count lives in §Validation Ledger.
+- ~~Operating model text: `memory feedback_hub_cc_operating_model.md §2.5·§2.6`~~ — **absent (verified 2026-08-12)**. The live equivalent is `CLAUDE.md §Identity — 3-Layer Mission + Core Axis`; cite that, not this filename.
+- ~~Consistency rules: `feedback_external_ai_github_recommendation_verification` · `feedback_reference_own_hub_assets_first` · `feedback_simplification_evidence` · `feedback_markdown_edit_discipline` · `feedback_impact_first_then_tune`~~ — **absent (verified 2026-08-12)**. The two that this skill actually depends on are restated in §Constraints above.
+- Live, verified references (these resolve): `tracks/_meta/reference_next_session_starter.md` (session card, Step 4) · `CATALOG.md` · the `fact-checker` agent (Step 3).
+
+## Validation Ledger
+
+Cumulative trigger count for Step 6. Append one row per completed round; the count is the number of
+rows. This section is the landing site that the absent memory key used to be.
+
+| # | Date | Trigger (user's counter-argument, one line) | Verdict | Baseline change |
+|---|---|---|---|---|
+| — | — | (no rounds recorded in-file yet — prior rounds lived in the now-absent memory key and are not recoverable) | — | — |
+
+**Count**: 0 recorded rounds. Do not restate a remembered historical total here; an unrecoverable
+count is `unknown`, not a number carried over from a file nobody can open.