@chrono-meta/fh-gate 1.4.51 → 1.4.53

package/knowledge/shared/harness-core/self_evolution_routine.md

@@ -32,7 +32,7 @@ Three platform facts shape the design below:
     → post the digest as a COMMENT on the standing Issue "🛰️ Frontier Digest Log"
     → no repo commit, no PR   (cheap, ephemeral-safe)
 
-[Weekly Routine]  (schedule: weekly, model: OPUS — required, see §4 floor note)
+[Weekly Routine]  (schedule: weekly, model: opus preferred / sonnet first-class, see §4 floor note)
   ① read the last 7 days of comments on the "🛰️ Frontier Digest Log" issue
   ② persona-innovator Mode F — gap + external-frontier scan against current FH assets
   ③ pick AT MOST ONE concrete, scoped improvement candidate (or none — "no proposal this week" is valid)
@@ -79,17 +79,22 @@ bash templates/regression_guard.sh --pr "$(git branch --show-current)"   # Axis
 # Axis 4 edit-manifest RECORD → append today's predicted-impact line to tracks/_meta/edit_manifest.yaml
 ```
 
-**Floor note — why the weekly routine MUST be opus (load-bearing).** The pre-commit hook cross-checks
-the marker's `axis2-model` against `floor-status`: a `sonnet`/`haiku` model claiming `at-floor` or
-`above-floor` is **rejected**, and `below-floor` is rejected too **unless** a `below-floor-ack:` line
-quotes a live operator utterance. A routine runs with **no human online**, so there is no utterance to
-quote — meaning a Sonnet weekly run **cannot legally pass the gate and cannot commit**. That dead-end
-is itself a hazard: under "produce a draft PR" pressure a session may improvise an unsanctioned escape
-(fabricate an ack, mislabel the floor, `--no-verify`). **Pin the weekly routine to opus** so the
-honest marker is `floor-status: at-floor` and the gate passes unattended. (If opus is ever unavailable
-in routines, the sanctioned fallback is: do **not** commit — attach the proposed patch to a draft PR
-opened via the GitHub tools as a diff in the PR body / a patch file, bypassing the local hook, and
-label it `gate: deferred — opus re-run needed` for the operator. Never `--no-verify`.)
+**Floor note — dispatch-first, Sonnet first-class (re-semanticized 2026-07-10, Sonnet-Floor
+Doctrine).** The pre-commit hook cross-checks the marker's `axis2-model` against `floor-status`.
+The routine's honest, unattended paths in preference order:
+1. **Dispatch the Axis-2 audit** (cross-family sidecar or an opus sub-agent, consent permitting) —
+   marker is `floor-status: at-floor` with the dispatched engine recorded; strongest and preferred.
+2. **Opus inline** (when the routine session itself runs at opus) — `at-floor`, as before.
+3. **Sonnet inline** — first-class, no operator utterance needed: `floor-status: sonnet-floor` +
+   an `axis2-anchor:` line naming the mechanical evidence that grounds the judged verdict (a
+   regression test, scan output, probe count). The marker auto-enters the weekly re-validation
+   queue (`below_floor_scan.sh`, R-tier advisory). The old dead-end — "a Sonnet run cannot legally
+   commit, so it improvises an escape" — is gone *because* the sanctioned lane exists; the anchor
+   requirement is what keeps the lane from being a free pass.
+Sub-Sonnet tiers remain `below-floor` + operator ack (a routine with no human online genuinely
+cannot pass there — that residual is intended). If no anchor can be produced at Sonnet either, the
+fallback stays: do **not** commit — attach the patch to a draft PR opened via the GitHub tools,
+label it `gate: deferred — floor re-run needed`. Never `--no-verify`.
 
 **Marker carve-out (the one sanctioned `tracks/**` write).** The two gate files
 (`tracks/_meta/.axes_23_passed_*.marker` and `tracks/_meta/edit_manifest.yaml`) live under gitignored

package/knowledge/shared/harness-core/sonnet_floor_doctrine.md

@@ -0,0 +1,132 @@
+# Sonnet-Floor Doctrine — the harness's optimization target
+
+> **Canonical axiom node** (operator-declared 2026-07-10). Short by design: this file names the
+> invariant, its defect class, and the prescription ladder. The operating mechanics live in their
+> existing homes — floor resolution & dispatch: `multi_model_sidecar_strategy.md §Tier-floor`
+> (F1/F2, "Sonnet-main + Opus-dispatch"); escalation consent: `capability_escalation_consent.md`;
+> mechanical enforcement: `templates/.git-hooks/pre-commit` (Axis-2 floor fields) +
+> `scripts/below_floor_scan.sh`. Do not restate their details here; do not restate this axiom there.
+
+## The invariant
+
+**FH's base operation must run 100% at Sonnet-tier.** Every gate, onboarding path, diagnostic,
+close-chain step, and skill must fire and complete on Sonnet 5. A capability that is only
+discoverable, or only fires, on Opus/Fable-tier is a **harness defect** — the same severity class
+as a phantom reference. A harness exists to hold quality high *on weaker models*; if it needs the
+strongest model to work at all, it has failed as a harness.
+
+**Escalation is dispatch, never substrate.** Depth beyond Sonnet's ceiling is reached by
+*recommending* a dispatch — an Opus/Fable same-family sub-agent, or a cross-family sidecar
+(codex / agy) — consent-gated per `capability_escalation_consent.md`. The session substrate stays
+whatever the operator chose. A Sonnet-only environment is a **first-class mode**: run everything at
+Sonnet, extract the harness's maximum, and name residuals honestly (below-floor / sonnet-floor
+markers) — never silently drop a capability.
+
+## Why this is the optimization target (measured, not aspirational)
+
+- **H1 (2026-07-05)**: the anchor-emit harness reduced borderline verdict flips **more on weaker
+  models** — Flash −18.5pp vs Pro −11.1pp (within-model deltas, 3-measurement convergence). The
+  harness's value peaks exactly where the model is weakest; optimizing FH for the strong tier
+  optimizes it where it matters least.
+- **Every confirmed Sonnet-tier miss in FH history was closed by mechanization or salience
+  hardening, never by requiring a stronger model**: the task-first companion-load miss (2026-07-05
+  → SessionStart hook), the tone salience gap (2026-07-08 → recorded, prompt-layer), the
+  card-reconcile blind spot (2026-07-10 → mtime-independent STATUS map in the hook). The doctrine
+  is a name for what the fix pattern already was.
+- **The value does not vanish at the top tier — the harness complements the strongest model too**
+  (operator observation, 2026-07-10, same-day measured): a Sonnet blind probe caught a SIGPIPE
+  silent-death defect in a script the top-tier session had just written (5/5 repro), and the new
+  close-chain checker blocked that same top-tier session's card-last violation twice on its first
+  day. Structure-enforcing checks are tier-blind by construction — so the harness raises the floor
+  for weak models *and* guards the ceiling for strong ones. Weak-model benefit is the larger term
+  (H1), top-tier benefit is the existence proof that the harness is not scaffolding-only.
+
+## The defect class: tier-gated capability
+
+When auditing (harness-doctor, weekly audit, or a dedicated census), enumerate candidates with
+`bash scripts/tier_census_grep.sh <files>` (word-boundary patterns + N/A-sense hints — mechanized
+2026-07-10 after a probe's naive grep false-positived on "fron**tier**"), then classify every hit:
+
+| Class | Shape | Verdict |
+|---|---|---|
+| **Trust-floor** | a *judgment* (skip/run, compose/rank) is trusted only at opus+; below-floor = run the check anyway or ask | **Compatible** — Sonnet still runs everything; degrade direction is run-or-ask, never skip |
+| **Availability-gate** | a capability is *absent, blocked, or dead-ended* below a tier (hard `model:` pin, "cannot pass", opus-only judge path) | **Defect** — fix via the ladder below |
+| **Advisory** | recommends a tier, never blocks (Mode D Model Notice, depth-escalation notices) | Compatible — but the recommendation direction must be **dispatch-first** (keep Sonnet + dispatch the depth), with a session pin as the secondary option |
+
+## Prescription ladder (for a confirmed tier-gated capability)
+
+1. **Mechanize** — move the behavior to a hook / script / exit code. Tier-independent by
+   construction; the strongest fix. (SessionStart load, STATUS map, pre-commit gate.)
+2. **Salience-harden** — split, imperative pointers, turn-0 injection; then verify with a
+   **Sonnet blind sim** (the target-tier sim gate's default tier *is* Sonnet for this reason).
+3. **Reclassify as dispatch** — if the capability is irreducibly judgment-heavy (adversarial
+   depth, wide design synthesis), it becomes a *dispatch surface*: at Sonnet the harness surfaces
+   a one-line escalation recommendation (sidecar or floor-up, consent-gated) and proceeds at the
+   floor with a named residual. Silent absence is never an option.
+
+## Floor semantics under the doctrine
+
+- **Sonnet = the base floor.** Meeting it is `at-floor` for base operation. Judged-class verdicts
+  produced at Sonnet on depth-critical roles remain **provisional** (`sonnet-floor` marker,
+  auto-queued for the weekly audit's re-run-or-write-off pass) — first-class ≠ free of residuals.
+- **Sub-Sonnet (Haiku, local canaries)** stays `below-floor`: canary/producer roles only, explicit
+  ack required on gate surfaces. The doctrine raises no ceiling and lowers no guard rails there.
+- **Depth ladder on a depth turn at Sonnet** (cheapest rung first — effort is depth, model is
+  ceiling, `[[feedback_workflow_stage_effort_routing]]`): ① **raise reasoning effort on the same
+  substrate** (Sonnet medium → high — free, no consent needed, no boundary crossed) → ② dispatch
+  an audit/research sidecar (consent permitting — cross-family preferred for decorrelation) →
+  ③ proceed at Sonnet-high with mechanical anchors + named residual. A hard model requirement is
+  never a rung.
+
+## Autonomy at Sonnet — run-first, ask-last (full-potential clause, 2026-07-10)
+
+The intended FH surface — including its **full autonomous potential** (goal-quench max runs,
+harvest-loop full mode, overnight loops, cluster orchestration) — must be *executable* at
+Sonnet medium-high effort, not merely available-if-a-human-answers. Two rules make that safe:
+
+- **Trust-floor degrade order is RUN → ASK, never ask-first**: where a judgment is trusted at
+  opus+ ("skip/run", "compose/rank"), a Sonnet session's default is to **run the full check /
+  present the full result** — the conservative branch that needs no trust. Asking is reserved for
+  the case where no mechanical or anchored path exists at all (a pure-judged fork with no anchor).
+  A Sonnet loop that stalls on "ask" when running-the-check was available has mis-degraded.
+- **The defense is the gate layer, not the model tier**: FH's mechanical floors — pre-commit
+  4-axis, pre-push Destructive-Op, prepublish scan, consent protocol, HITL irreversibility floors —
+  are tier-independent hooks. They hold *regardless of who is driving*, which is precisely what
+  makes Sonnet full-autonomy safe: **autonomy removes the prompt, never the gate** (the same
+  clause the Autopilot's full-autonomy mode already carries). Irreversible-surface HITL floors are
+  surface-class rules and do not scale down with tier — a Sonnet loop gets the same hard walls,
+  not softer ones.
+
+## What survives model evolution — the durable-mechanization criterion (operator insight, 2026-07-10)
+
+Sidecar dispatch is the *cheap* way to chase LLM evolution (swap the engine, keep the harness), and
+internal mechanization could chase capability gaps forever — so which mechanization is worth
+building? Split by **what the mechanization compensates for**:
+
+| Class | Compensates for | Fate as models improve | Examples |
+|---|---|---|---|
+| **Capability-compensating** | the model being *weak* — reasoning depth, salience, attention discipline | **evaporates** — scaffolding to shed (`[[feedback_frontier_substrate_self_adaptation]]`); build only on measured misses, keep cheap to delete | salience splits · turn-0 imperatives · word-boundary grep discipline (partially — see note) |
+| **Structure-enforcing** | what a *perfect* model still cannot see or is still incentivized to fumble: information outside the context boundary (cross-machine state, version drift), ordering invariants across ephemeral contexts, ship-pressure optimism, irreversible surfaces | **permanent** — model evolution never fixes "the card lives on another machine" or "the runner controls what the hook sees" | STATUS map (machine boundary) · card-last check (ordering invariant) · substrate-jump detector (out-of-context drift) · fail-closed gates · consent floors |
+
+**The test question when proposing mechanization: "would an infinitely strong model still miss
+this?"** Yes → structure-enforcing, build it, it compounds. No → capability-compensating, prefer
+dispatch first, mechanize only on a measured miss, and tag it shed-eligible (the substrate loop's
+shed/advance pass is its consumer).
+
+*Note on determinism*: some capability-class tools survive anyway because they are **cheaper and
+deterministic** (a grep never has an attention lapse and costs nothing) — determinism is a second
+survival axis, orthogonal to capability. A deterministic check that replaces a per-session judged
+step keeps paying even when the model no longer needs the help.
+
+## Done When (for any change citing this doctrine)
+
+- No availability-gate remains in the touched surface *(check class: measured — tier-reference
+  census grep, classify per the table)*.
+- Salience-dependent changes pass a Sonnet blind sim *(measured — sim verdict recorded in the
+  Axes 2–3 marker)*.
+- Depth needs express as dispatch recommendations, not requirements *(judged, pair: adversarial
+  review asks "where does this silently require opus?")*.
+
+Cross-refs: `[[feedback_tier_invariant_over_treadmill]]` · `[[feedback_harness_aerodynamics_perceived_perf]]`
+· `[[feedback_fh_rides_on_cc_harness]]` · `[[feedback_h1_two_tier_closure]]` · `loop_engineering.md`
+(PROSE legs are where Sonnet-tier misses live — the two lenses share one spine).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrono-meta/fh-gate",
-  "version": "1.4.51",
+  "version": "1.4.53",
   "description": "FH runtime adapters — run FH governance, skills, and agents via Claude or Codex with machine-parseable gates.",
   "license": "MIT",
   "keywords": [
@@ -20,10 +20,11 @@
   "bin": {
     "fh-gate": "bin/fh-gate.js",
     "fh-run": "bin/fh-run.js",
-    "fh-goal": "bin/fh-goal.js"
+    "fh-goal": "bin/fh-goal.js",
+    "fh-codex-doctor": "bin/fh-codex-doctor.js"
   },
   "scripts": {
-    "prepare": "chmod +x bin/fh-gate.js bin/fh-run.js bin/fh-goal.js scripts/fh-gate.sh scripts/fh-run.sh scripts/fh-goal.sh",
+    "prepare": "chmod +x bin/fh-gate.js bin/fh-run.js bin/fh-goal.js bin/fh-codex-doctor.js scripts/fh-gate.sh scripts/fh-run.sh scripts/fh-goal.sh",
     "test": "bash scripts/selfcheck.sh",
     "prepublishOnly": "bash scripts/selfcheck.sh && bash scripts/public_surface_scan_files.sh",
     "release": "bash scripts/public_surface_scan_files.sh && npm publish"
@@ -45,10 +46,13 @@
   },
   "files": [
     "AGENTS.md",
+    ".claude-plugin/marketplace.json",
     "CATALOG.md",
     "CHEATSHEET.md",
     "CLAUDE.md",
+    ".claude/registry/agent_cards.json",
     "docs/CONTRIBUTING.md",
+    "bin/fh-codex-doctor.js",
     "bin/fh-gate.js",
     "bin/fh-run.js",
     "bin/fh-goal.js",
@@ -57,9 +61,13 @@
     "scripts/fh-gate.sh",
     "scripts/fh-run.sh",
     "scripts/fh-goal.sh",
+    "scripts/count_check.sh",
     "scripts/selfcheck.sh",
+    "templates/local_fh_context.md",
+    "plugins/fh-meta/.claude-plugin/plugin.json",
     "plugins/fh-meta/skills",
     "plugins/fh-meta/agents",
+    "plugins/fh-commons/.claude-plugin/plugin.json",
     "plugins/fh-commons/skills",
     "plugins/fh-commons/agents",
     "knowledge/shared/harness-core",

package/plugins/fh-commons/.claude-plugin/plugin.json

@@ -0,0 +1,23 @@
+{
+  "name": "fh-commons",
+  "version": "1.4.53",
+  "engines": {
+    "claudeCode": ">=1.0.0"
+  },
+  "description": "Cross-project utility skill bundle — 4 skills + 1 agent. Domain-agnostic and portable: convergence-loop, deliberation, mcp-circuit-breaker, token-budget-gate + quench-challenger agent.",
+  "author": {
+    "name": "chrono-meta",
+    "email": "chrono-meta@users.noreply.github.com"
+  },
+  "keywords": [
+    "commons",
+    "convergence-loop",
+    "gate-reinforcement",
+    "multi-round-validation",
+    "deliberation",
+    "multi-perspective-synthesis",
+    "forge-skill",
+    "domain-agnostic",
+    "cross-project"
+  ]
+}

package/plugins/fh-commons/skills/deliberation/SKILL.md

@@ -3,7 +3,7 @@ name: deliberation
 description: Multi-perspective synthesis structure — Innovator (propose) → Devil-Advocate (challenge) → Mediator (synthesize) 3-layer execution. Outputs conditional verdicts without binary win/loss. Activates on "deliberation", "battle this out", "weigh the pros and cons", "review from multiple angles", "which side is right?". Optional deep-insight persona jurors for domain-specific views. Designed for design decisions, skill proposals, and architectural choices.
 user-invocable: true
 allowed-tools: ["Read", "Bash", "Agent"]
-model: opus
+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
 origin: fh-meta
 ---
 

package/plugins/fh-meta/.claude-plugin/plugin.json

@@ -0,0 +1,36 @@
+{
+  "name": "fh-meta",
+  "version": "1.4.53",
+  "engines": {
+    "claudeCode": ">=1.0.0"
+  },
+  "description": "Hub meta-engineering toolkit — 33 skills + 7 agents. New in 1.4.48: phantom-quench + steel-quench gain external frontier anchors (arXiv:2607.02052 package-hallucination; arXiv:2607.02057 prompt-coverage-adequacy); README model-flat claim reframed from a per-release point-curve to structural invariants (operation flattens across tiers; depth tier-order fixed within a generation). New in 1.4.47: onboarding step ① surfaces the Mode D companion-store session-start load in the auto-read salience anchor (previously only in the local binding + rules, so a greeting could skip the load). New in 1.4.46: context-doctor gains a command-output axis — routes to a command-output proxy/hook (rtk) to trim verbose CLI stdout, complementing .claudeignore; risk-gated to token-scarce environments (lossy filtering, off gate-input paths). New in 1.4.41: context-doctor 2026 trigger vocab (context engineering/rot/collapse) + phantom-citation hardening; hub measurement-integrity-checklist (cross-model measurement pre-flight: display-name pin/reps≥3/discriminating probe). New in 1.4.40: install-wizard scaffolds the companion store as a queryable wiki (INDEX + session-start read + Raw/Wiki/Conversation ingest axis). New in 1.4.39: auto-decorrelation (cross-family verifier sidecar recruitment, calibration-gated) + video-ingest (capability-routed video ingestion). New in 1.4.37: corpus-grounding-expander + persona-roster-expander (field-harvested verbatim-relay capability skills). New in 1.3.0: public-surface-audit (git-tracked private-token leak scan), field-harvest Mode B session-end auto-trigger, 4-axis gate scope extension (docs/ + AGENTS.md). New in 1.2.0: pipeline-conductor (4-pipeline gated sweep), return-path-gate (chain closure audit), goal-quench (Stop hook + quality gate), steel-quench Wave 5 (multi-model sidecar challenger), 2-layer architecture docs, YAML validation script. Validated cross-CLI: Claude Code, Codex, Gemini.",
+  "author": {
+    "name": "chrono-meta",
+    "email": "chrono-meta@users.noreply.github.com"
+  },
+  "keywords": [
+    "hub-meta",
+    "fact-check",
+    "self-verification",
+    "bidirectional-validation",
+    "cross-ecosystem-synergy",
+    "plugin-recommender",
+    "pr-review",
+    "harness-engineering",
+    "ai-collaboration",
+    "token-efficiency",
+    "context-doctor",
+    "harness-doctor",
+    "install-doctor",
+    "install-conflict-detection",
+    "install-wizard",
+    "onboarding-automation",
+    "marketplace-gate",
+    "marketplace-readiness",
+    "meta-prompt-builder",
+    "prompt-delegation",
+    "circular-validation",
+    "2d-adversary"
+  ]
+}

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

@@ -3,7 +3,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"]
-model: opus
+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
 ---
 
 # agent-composer — Agent Composition Layer

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

@@ -3,7 +3,7 @@ name: apex-review
 description: Reviews a technical proposal from the perspective of organizational decision-makers (CTO, technical lead, QA lead, conference reviewers, etc.) and generates an HTML presentation deck. Outputs approval gate results per persona and connects to sim-conductor for improvement suggestions.
 user-invocable: true
 allowed-tools: ["Read", "Write", "Bash", "Agent"]
-model: opus
+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
 ---
 
 # apex-review — Decision-Maker Review Layer

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

@@ -3,7 +3,7 @@ name: auto-decorrelation
 description: Recruits cross-family verifier sidecars (codex, agy, local 4090 over Tailscale) for adversarial verification of load-bearing changes, maximizing model-family diversity against the orchestrator. Mechanically discovers the available sidecar panel, recruits at least one cross-family verifier when present, and degrades gracefully when none are. The governor (Claude) keeps the terminal verdict; sidecar findings must be source-grounded before acceptance. Opt-in via one-time consent, stored in the UAP; fires only on load-bearing changes. Triggered by "recruit a cross-family check", "decorrelate this verification", "use the idle sidecars to verify", "auto-decorrelation".
 user-invocable: true
 allowed-tools: ["Read", "Bash", "Grep", "Glob"]
-model: opus
+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
 ---
 
 # auto-decorrelation — Cross-Family Verifier Recruitment

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

@@ -94,7 +94,7 @@ When context is near the limit and you want to *preserve state* rather than rese
 
 | Current task | Recommended | Command |
 |---|---|---|
-| Complex design decisions · architecture review | Opus | `/model opus` |
+| Complex design decisions · architecture review | Opus — dispatch-first: package into an opus/sidecar agent dispatch (consent-gated); session pin secondary | dispatch · or `/model opus` |
 | Code writing · file editing · refactoring | Sonnet (default) | — |
 | Simple file lookup · short Q&A | Haiku | `/model haiku` |
 

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

@@ -3,7 +3,7 @@ name: harvest-loop
 description: A self-evolution pipeline that runs automatically after field sessions end. field-harvest (pattern extraction) → contention-layer (collision signals) → [Agent(subagent_type="challenger") + persona-innovator parallel] → synthesizer (challenger/innovator collision harvest) → Critic isolated Agent (SAGE automated critique) → harness-doctor (health check) → verify-bidirectional (consistency validation) → curator (skill lifecycle management) — 8 steps. Session learnings are automatically absorbed back into the FH ecosystem so the harness evolves on its own. In the main development environment, runs automatically at session end. For external FH users, proposes execution first. Triggered by "session harvest", "learning absorption", "fh evolution", or "harvest-loop". (The phrase "run the pipeline" is ceded to pipeline-conductor to avoid a trigger collision — for end-to-end verification sweeps use pipeline-conductor.)
 user-invocable: true
 allowed-tools: ["Read", "Write", "Bash", "Grep", "Glob", "Agent"]
-model: opus
+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
 ---
 
 # harvest-loop — Field Session → FH Self-Evolution Pipeline

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

@@ -3,7 +3,7 @@ name: install-wizard
 description: Run when setting up a new project for the first time or onboarding after installing FH (first setup, initial configuration, onboarding start, configure project, help me set up). Performs environment detection → gap diagnosis → item-by-item suggestions → user approval → execution → acceleration baseline setup in sequence. Use --dry-run to output diagnosis report only (bg dispatch compatible).
 user-invocable: true
 allowed-tools: ["Read", "Write", "Bash", "Glob", "Grep", "Edit"]
-model: opus
+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
 category: Composability Gate
 ---
 

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

@@ -3,7 +3,7 @@ name: meta-prompt-builder
 description: Generates structured prompts to send to each agent in an agent dispatch plan. Triggered by "write the instructions", "what do I say to the agent?", "write the prompt for me", "meta-prompt-builder". Bridges agent-composer (which agents) and prompt content (what to say). Uses Goal/Context/Constraints/Done When structure.
 user-invocable: true
 allowed-tools: ["Read", "Bash", "Glob", "Grep"]
-model: opus
+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
 ---
 
 # meta-prompt-builder — Prompt Delegation Skill

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

@@ -3,7 +3,7 @@ name: sim-conductor
 description: Autonomously runs external user reaction simulations, internal audits, ideation scans, artifact validation, and quality reviews. Profiles the target artifact first, then derives task-appropriate personas, dispatches them as parallel agents, classifies findings into M/S/R tiers, and completes the pipeline through to commit automatically.
 user-invocable: true
 allowed-tools: ["Read", "Write", "Bash", "Grep", "Glob", "Agent"]
-model: opus
+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
 ---
 
 # sim-conductor — Meta-Simulation Automation Orchestrator

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

@@ -13,7 +13,7 @@ description: >-
   "steel quench", "deep pre-completion inspection", "did it really pass?".
 user-invocable: true
 allowed-tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob", "WebSearch", "Agent"]
-model: opus
+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
 ---
 
 # steel-quench — All-Angle Verification Meta-Skill

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

@@ -10,7 +10,7 @@ complexity_routing:
   escalate_when:
     - full_revalidation
     - high_stakes
-    - fail_verdict   # AI recommendation was wrong → baseline overwrite is high-stakes, never stay at sonnet
+    - fail_verdict   # AI recommendation was wrong → baseline overwrite is high-stakes: at Sonnet, bind the overwrite to a mechanical anchor (diff review + source re-check) and RECOMMEND an opus/sidecar dispatch (consent-gated) — Sonnet+anchor is a legitimate path (sonnet_floor_doctrine.md), silent judged-only overwrite is not
 ---
 
 # verify-bidirectional — Bidirectional Self-Validation Automation

package/scripts/count_check.sh

@@ -0,0 +1,95 @@
+#!/usr/bin/env bash
+# count_check.sh — skill/agent count-consistency check (single source).
+# Class: mandatory-pass (harness_6axis_framework.md §Axis 5) — exit 1 on drift.
+#
+# Called by ALL THREE count-consistency boundaries so one logic runs everywhere:
+#   - scripts/selfcheck.sh            → publish-readiness (prepublishOnly + npm test)
+#   - templates/.git-hooks/pre-commit → local commit time, `--staged` (index mode)
+#   - .github/workflows/validate.yml  → PR/merge boundary (checked-out tree == committed)
+#
+# Origin (fh_signal_2026-06-21): the count check used to live ONLY at the publish boundary.
+# But the actor that breaks it — a commit/merge that adds/removes a skill dir — acts at
+# commit/merge time, so a skill-adding PR (#111) merged with stale counts and they sat
+# undetected on main until the next publish. This is the gate-locality gap (a gate must
+# live where the breaking action happens). One source, three boundaries, no reinvention.
+#
+# Modes:
+#   (default)  count the WORKING TREE — selfcheck (publish; tree == HEAD) and CI
+#              (a checked-out PR IS the committed state). cat/glob the on-disk files.
+#   --staged   count the INDEX (exactly what THIS commit will contain) — the pre-commit
+#              hook. Fixes steel-quench S1 (2026-06-21): a worktree-only count can
+#              FALSE-PASS a commit that stages a skill add but leaves the count-file
+#              updates unstaged — the gate would verify a different tree than it commits.
+set -u
+cd "$(dirname "${BASH_SOURCE[0]}")/.." || { echo "COUNT-CHECK: FAIL (cannot cd to repo root)"; exit 1; }
+
+MODE="worktree"
+[ "${1:-}" = "--staged" ] && MODE="staged"
+fail=0
+
+# Read a tracked file's content from the active tree (index in --staged, disk otherwise).
+read_tree() { # read_tree <path>
+  if [ "$MODE" = staged ]; then git show ":$1" 2>/dev/null; else cat "$1" 2>/dev/null; fi
+}
+# List a plugin's top-level SKILL.md paths in the active tree.
+list_skills() { # list_skills <plugin>
+  if [ "$MODE" = staged ]; then
+    git ls-files --cached -- "plugins/$1/skills" 2>/dev/null \
+      | grep -E "^plugins/$1/skills/[^/]+/SKILL\.md$"
+  else
+    local s
+    for s in plugins/"$1"/skills/*/SKILL.md; do [ -f "$s" ] && echo "$s"; done
+  fi
+}
+# Count a plugin's top-level agent .md files in the active tree.
+count_agents() { # count_agents <plugin>
+  if [ "$MODE" = staged ]; then
+    git ls-files --cached -- "plugins/$1/agents" 2>/dev/null \
+      | grep -cE "^plugins/$1/agents/[^/]+\.md$"
+  else
+    ls plugins/"$1"/agents/*.md 2>/dev/null | wc -l | tr -d ' '
+  fi
+}
+# Active skill = SKILL.md whose head (first 20 lines) carries no deprecation marker
+# (a whole-file grep false-positives on skills that merely mention the word).
+count_active() { # count_active <plugin>
+  local n=0 s
+  while IFS= read -r s; do
+    [ -z "$s" ] && continue
+    read_tree "$s" | head -20 | grep -qE 'deprecated: true|DEPRECATED' || n=$((n+1))
+  done < <(list_skills "$1")
+  echo "$n"
+}
+
+meta_sk=$(count_active fh-meta); meta_ag=$(count_agents fh-meta)
+com_sk=$(count_active fh-commons); com_ag=$(count_agents fh-commons)
+total_sk=$((meta_sk + com_sk)); total_ag=$((meta_ag + com_ag))
+
+# Impossible-zero guard (steel-quench A4 — fail CLOSED): fh-meta always has active skills.
+# A 0 means the tree/glob resolved to nothing (wrong cwd, empty index, sh-as-bash shim) —
+# a gate must never return "consistent" from an empty tree.
+if [ "$meta_sk" -eq 0 ]; then
+  echo "COUNT-CHECK: FAIL (0 active fh-meta skills — empty/wrong tree, mode=$MODE)"
+  exit 1
+fi
+
+count_check() { # count_check <label> <file> <expected-string>
+  if read_tree "$2" | grep -q "$3"; then
+    echo "PASS  count: $1"
+  else
+    echo "FAIL  count: $1 — expected \"$3\" in $2 (actual: fh-meta ${meta_sk}sk/${meta_ag}ag, fh-commons ${com_sk}sk/${com_ag}ag)"
+    fail=1
+  fi
+}
+count_check "fh-meta plugin.json"      plugins/fh-meta/.claude-plugin/plugin.json    "${meta_sk} skills + ${meta_ag} agents"
+count_check "fh-commons plugin.json"   plugins/fh-commons/.claude-plugin/plugin.json "${com_sk} skills"
+count_check "marketplace.json fh-meta" .claude-plugin/marketplace.json               "${meta_sk} skills + ${meta_ag} agents"
+count_check "README header"            README.md                                     "${total_sk} skills · ${total_ag} agents"
+count_check "local_fh_context fh-meta" templates/local_fh_context.md                 "(fh-meta, ${meta_sk})"
+
+if [ "$fail" -ne 0 ]; then
+  echo "COUNT-CHECK: FAIL"
+  exit 1
+fi
+echo "COUNT-CHECK: PASS (mode=$MODE)"
+exit 0

package/scripts/selfcheck.sh

@@ -25,6 +25,11 @@ for f in bin/*.js; do
   check "node --check $f" node --check "$f"
 done
 
+# Codex adapter drift: the thin Codex runtime must keep reading canonical FH
+# skill/agent surfaces without silently accepting Claude-native primitives as
+# Codex-native.
+check "fh-codex-doctor --strict" bash -c 'node bin/fh-codex-doctor.js --strict >/dev/null'
+
 # Bash surface: npm-shipped scripts + local bin wrappers + gate-chain infra
 for f in scripts/*.sh bin/fh-gate bin/fh-run bin/fh-goal \
          templates/regression_guard.sh templates/temper_check.sh templates/predelete_check.sh templates/.git-hooks/pre-commit; do
@@ -43,26 +48,28 @@ if ! bash scripts/count_check.sh; then
   fail=1
 fi
 
-# Referenced-path existence: backtick-quoted repo-relative file refs in the always-loaded
-# governance surface (CLAUDE.md + .claude/rules/*.md) must exist. Phantom-reference class
-# recurred N>=3 in the 2026-06-11 audit window (operations.md _scanner.sh, claude-chrono path,
-# stale templates ref) — instrument-not-habit. Globs/placeholders/{vars} are excluded by the
-# filter; tracks/ is machine-local and deliberately out of scope. Gitignored refs (e.g.
-# `.claude/settings.json` named in prose *about* gitignored files) are skipped — they exist
-# locally but not on a fresh clone, and "must exist" here means "must ship".
-while IFS= read -r p; do
-  if git check-ignore -q "$p" 2>/dev/null; then
-    echo "SKIP  ref-path (gitignored): $p"
-  elif [ -f "$p" ]; then
-    echo "PASS  ref-path: $p"
-  else
-    echo "FAIL  ref-path: $p — referenced in CLAUDE.md/.claude/rules but missing"
-    fail=1
-  fi
-done < <(grep -hoE '\`[^\` ]+\`' CLAUDE.md .claude/rules/*.md 2>/dev/null \
-  | sed 's/\`//g' \
-  | grep -E '^(knowledge|templates|scripts|docs|plugins|\.claude)/[^*{}<>$]+\.(md|sh|ya?ml|jsonc|json)$' \
-  | sort -u)
+# Referenced-path existence is a source-tree check. The npm package intentionally
+# ships a narrower runtime surface, so package-mode selfcheck skips this section.
+if [ -d ".claude/rules" ]; then
+  # Backtick-quoted repo-relative file refs in the always-loaded governance surface
+  # (CLAUDE.md + .claude/rules/*.md) must exist. Phantom-reference class recurred
+  # N>=3 in the 2026-06-11 audit window — instrument-not-habit.
+  while IFS= read -r p; do
+    if git check-ignore -q "$p" 2>/dev/null; then
+      echo "SKIP  ref-path (gitignored): $p"
+    elif [ -f "$p" ]; then
+      echo "PASS  ref-path: $p"
+    else
+      echo "FAIL  ref-path: $p — referenced in CLAUDE.md/.claude/rules but missing"
+      fail=1
+    fi
+  done < <(grep -hoE '\`[^\` ]+\`' CLAUDE.md .claude/rules/*.md 2>/dev/null \
+    | sed 's/\`//g' \
+    | grep -E '^(knowledge|templates|scripts|docs|plugins|\.claude)/[^*{}<>$]+\.(md|sh|ya?ml|jsonc|json)$' \
+    | sort -u)
+else
+  echo "SKIP  ref-path (package mode: .claude/rules absent)"
+fi
 
 if [ "$fail" -ne 0 ]; then
   echo "SELFCHECK: FAIL"