@chrono-meta/fh-gate 1.4.73 → 1.4.75

package/templates/goal-quench-hook-setup.md

@@ -0,0 +1,152 @@
+# goal-quench Stop Hook Setup
+
+Add the following to your project's `.claude/settings.json` to enable the goal-quench Stop hook:
+
+```json
+{
+  "hooks": {
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash -c 'f=\".claude/goal-quench.active\"; [ -f \"$f\" ] && echo \"\\n[goal-quench] /goal finished. Running quality verification...\" && cp \"$f\" \".claude/goal-quench.pending\" && rm -f \"$f\" || true'"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+Add to your project's `.gitignore`:
+
+```
+.claude/goal-quench.active
+.claude/goal-quench.pending
+```
+
+## How it works
+
+1. `/goal-quench` (Phase 1) writes `.claude/goal-quench.active` with scope + budget info
+2. User runs `/goal [condition]`
+3. When `/goal` finishes → Stop hook fires → detects `.active` → copies to `.pending` → removes `.active`
+4. Next Claude response: detects `.pending` → auto-runs `pipeline-conductor --quick` → cleans up
+
+## Merge with existing settings.json
+
+If you already have a `settings.json`, merge the `hooks.Stop` array:
+
+```json
+{
+  "permissions": { ... your existing permissions ... },
+  "hooks": {
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          { "type": "command", "command": "... your existing stop hook command if any ..." }
+        ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash -c 'f=\".claude/goal-quench.active\"; [ -f \"$f\" ] && echo \"\\n[goal-quench] /goal finished. Running quality verification...\" && cp \"$f\" \".claude/goal-quench.pending\" && rm -f \"$f\" || true'"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+## Manual Apply (forge-harness)
+
+A pre-merged `settings.json` for the forge-harness repo is available at:
+
+```
+templates/goal-quench-settings-merged.json
+```
+
+To apply it manually (one command, run from the forge-harness repo root):
+
+```bash
+cp templates/goal-quench-settings-merged.json .claude/settings.json
+```
+
+This file preserves all existing `permissions` and `enabledPlugins` from the current `.claude/settings.json` and adds the `hooks.Stop` section.
+
+Note: `.claude/settings.json` is gitignored (local-only file), so this copy must be done manually on each machine.
+
+## Verification Steps
+
+After applying the hook, verify the full pipeline with these steps:
+
+### Step 1 — Start a goal-quench session
+
+Run the goal-quench skill to write the `.active` file:
+
+```
+/goal-quench
+```
+
+This should create `.claude/goal-quench.active` with scope + budget metadata.
+
+Confirm:
+
+```bash
+ls -la .claude/goal-quench.active
+cat .claude/goal-quench.active
+```
+
+### Step 2 — Run a goal
+
+```
+/goal <your completion condition here>
+```
+
+Example: `/goal all acceptance tests pass`
+
+### Step 3 — Verify Stop hook fired
+
+When the `/goal` task finishes (Claude stops responding), check that:
+
+```bash
+# .active should be gone
+ls .claude/goal-quench.active 2>/dev/null && echo "ERROR: .active still exists" || echo "OK: .active removed"
+
+# .pending should exist
+ls .claude/goal-quench.pending && echo "OK: .pending created" || echo "ERROR: .pending missing"
+
+# .pending content
+cat .claude/goal-quench.pending
+```
+
+### Step 4 — Verify auto-trigger in next response
+
+Send any message to Claude in the same session. The next response should:
+1. Detect `.claude/goal-quench.pending`
+2. Auto-run `pipeline-conductor --quick` (or equivalent quality verification)
+3. Remove `.pending` after completion
+
+If the skill is not installed, Claude will report the pending file and ask how to proceed.
+
+### Step 5 — Cleanup check
+
+After the verification round completes:
+
+```bash
+ls .claude/goal-quench.* 2>/dev/null || echo "OK: all state files cleaned up"
+```
+
+## Troubleshooting
+
+| Symptom | Likely cause | Fix |
+|---|---|---|
+| `.active` not created after `/goal-quench` | Skill not writing the file | Check SKILL.md `goal-quench` for file write step |
+| `.active` still present after session stop | Hook not installed / not firing | Re-run `cp templates/goal-quench-settings-merged.json .claude/settings.json`, restart Claude Code |
+| `.pending` created but no auto-trigger | pipeline-conductor not installed | Install or implement the skill; Claude will report the pending state |
+| Hook fires on every stop (not just goal-quench) | Expected — `[ -f "$f" ]` guard prevents false triggers when `.active` absent |

package/templates/starter_profile.md

@@ -0,0 +1,83 @@
+# FH Starter Profile — Mode C (plugin only, no clone)
+
+> **The one opinionated front door.** FH has 33 skills and a full hub you can clone — but you
+> don't need any of that to get value today. This profile is the *single strong default*: one
+> install command, a curated first-five skills, and a zero-install governance gate. Pick up the
+> rest later if you want it.
+>
+> This is **Mode C** (see `knowledge/shared/rules/modes_and_value.md`): you install the plugin/skills only,
+> you do **not** clone the hub. That trade-off is spelled out under *What Mode C does not include*.
+
+---
+
+## 1. Install — one command
+
+**Prerequisite**: Claude Code CLI (`claude --version`).
+
+```bash
+claude plugin marketplace add https://github.com/chrono-meta/forge-harness.git
+claude plugin install -s user fh-meta@forge-harness
+```
+
+That's it — no clone, no shell hooks, no machine setup. Open Claude Code in *your own* project and
+the skills are available as slash commands.
+
+```bash
+cd ~/your-project && claude
+```
+
+## 2. Governance gate — zero install (no plugin needed either)
+
+The core FH value — **"pass → accelerate"**: code that clears the gate ships faster. You can run it
+on any file with nothing installed but `npx`:
+
+```bash
+npx --package @chrono-meta/fh-gate fh-gate                    # default: Claude backend
+FH_BACKEND=codex npx --package @chrono-meta/fh-gate fh-gate   # Codex backend
+# → FH_GATE_VERDICT: PASS | PENDING | BLOCKED | ESCALATE
+```
+
+This wraps any coding agent (Claude, Codex) as a post-generation governance gate. It is the single
+highest-leverage thing to try first if you only do one thing.
+
+## 3. The opinionated first five (start here, ignore the other 28)
+
+A new user dropped into 33 skills stalls. These five cover the common path; reach for the rest only
+when a real need shows up.
+
+| Skill | Run it when | One line |
+|---|---|---|
+| `/plugin-recommender` | "what tools should I even use?" | Discovery — classifies tools, checks token cost |
+| `/context-doctor` | session feels slow / token-heavy | Generates `.claudeignore`, flags large files, `/clear` timing |
+| `/harness-doctor` | "is my setup sane?" | L1–L4 structure diagnosis + prescription |
+| `/goal-quench` | before executing a risky/long task | Gated execution — the acceleration gate in skill form |
+| `/frontier-digest` | "what's new out there?" | External/frontier trend cross-reference |
+
+Natural language works too — you don't need to memorize slash commands. "manage my context",
+"recommend a plugin", "check my harness structure" route to the same skills.
+
+## 4. What Mode C does *not* include (honest boundary)
+
+Plugin-only install gives you **Layer 2 (the skills)**. It does **not** give you **Layer 1**, which
+only activates when you clone the hub (Mode A/B):
+
+- **No active onboarding cascade** — no greeting-triggered 5-skill auto-run. You invoke skills yourself.
+- **No acceleration baseline** — no zshrc notification hook, no sentinels, no weekly-audit schedule,
+  no 4-axis pre-commit gate. Those are hub-internal infra and are deliberately not shipped to Mode C.
+- **No automatic harness signals** — history accumulation happens on *your* project side; FH won't
+  prompt you. (FH absorbs Mode-C contributions through issue monitoring + PR cadence, not a daemon.)
+
+If you later want Layer 1, clone the hub and run `/install-wizard` — the full path. The README's
+"Get started in 2 minutes" covers it.
+
+## 5. Want to go further?
+
+- **Clone the hub** (Mode A/B) → persistent cross-project knowledge, `tracks/`, the compounding loop.
+- **Contribute back** → a Mode-C PR is exactly the external validation FH is looking for. Open an
+  issue or PR on `chrono-meta/forge-harness`.
+
+---
+
+*Design note: this profile follows the frictionless-distribution + opinionated-front-door pattern
+seen in field harnesses like [gstack](https://github.com/garrytan/gstack) — a single strong default
+as the public entry point, full meta-flexibility kept behind it.*

package/templates/temper_check.sh

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+# temper_check.sh — Wave-T (Temper) step T-1: complexity delta of a quench.
+# Measures how much complexity a steel-quench ADDED to a markdown asset
+# (pre-quench baseline → post-convergence). It is a MEASUREMENT, not a detector
+# (don't-overbuild guard: no judgment engine here — T-3 verdict is human/LLM).
+#
+# Usage:  temper_check.sh <repo> <file-rel-path> <pre-quench-ref> [<post-ref>]
+#   <post-ref> default = working tree.
+# See plugins/fh-meta/skills/steel-quench/SKILL.md §Wave-T.
+set -euo pipefail
+
+repo="${1:?repo path}"; file="${2:?file rel path}"; pre="${3:?pre-quench ref}"; post="${4:-}"
+
+metrics() {  # reads text on stdin → "lines sections steps tables fences crossrefs"
+  local t prose; t="$(cat)"
+  # sections/steps/tables count PROSE only — lines inside ``` fences are code
+  # (bash comments `# ...` would otherwise inflate Δsections; found run #4, install-wizard)
+  prose="$(printf '%s\n' "$t" | awk '/^[[:space:]]*```/{f=!f;next} !f')"
+  local lines sections steps tables fences crossrefs
+  lines=$(printf '%s\n' "$t" | wc -l | tr -d ' ')
+  sections=$(printf '%s\n' "$prose" | grep -cE '^#{1,6} ' || true)
+  steps=$(printf '%s\n' "$prose" | grep -cE '^[[:space:]]*([0-9]+\.|[-*] )' || true)
+  tables=$(printf '%s\n' "$prose" | grep -cE '^\|' || true)
+  fences=$(( $(printf '%s\n' "$t" | grep -c '```' || true) / 2 ))
+  crossrefs=$(printf '%s\n' "$t" | grep -oE '\]\(|\[\[' | wc -l | tr -d ' ')
+  echo "$lines $sections $steps $tables $fences $crossrefs"
+}
+
+pre_txt=$(git -C "$repo" show "$pre:$file")
+if [ -n "$post" ]; then post_txt=$(git -C "$repo" show "$post:$file"); else post_txt=$(cat "$repo/$file"); fi
+
+read -r l0 s0 p0 t0 f0 x0 <<<"$(printf '%s' "$pre_txt"  | metrics)"
+read -r l1 s1 p1 t1 f1 x1 <<<"$(printf '%s' "$post_txt" | metrics)"
+
+printf '\n=== Wave-T complexity delta — %s ===\n' "$file"
+printf 'baseline: %s   post: %s\n\n' "$pre" "${post:-<working>}"
+printf '%-12s %6s %6s %8s\n' metric pre post Δ
+for row in "lines $l0 $l1" "sections $s0 $s1" "steps $p0 $p1" "tables $t0 $t1" "fences $f0 $f1" "cross-refs $x0 $x1"; do
+  set -- $row; printf '%-12s %6s %6s %+8d\n' "$1" "$2" "$3" "$(( $3 - $2 ))"
+done
+
+dx=$(( x1 - x0 )); dp=$(( p1 - p0 ))
+printf '\n-- T-3 heuristic flags (review, not auto-reject) --\n'
+[ "$dx" -gt "$dp" ] && printf '  ⚠ Δcross-refs(%+d) > Δsteps(%+d): quench added wiring, not function?\n' "$dx" "$dp" || true
+[ "$(( s1 - s0 ))" -gt 0 ] && printf '  ⚠ %+d new section(s): confirm each fixes a flaw, not just defends a Wave finding\n' "$(( s1 - s0 ))" || true
+printf '\nNext: run harness-doctor on post asset for absolute tier (T-2), then record τ verdict (PASS / FAIL + named construct)\n'

package/plugins/fh-meta/skills/context-bridge-dispatch/SKILL.md

@@ -1,32 +0,0 @@
----
-name: context-bridge-dispatch
-description: >-
-  DEPRECATED — merged into agent-composer Step 3-a (2026-06-02).
-  Context Card injection (N≤2 standard / N≥3 Registry mode) + coordination-overhead budget + Focus Mode
-  are now part of agent-composer Step 3. Invoke /agent-composer for parallel dispatch.
-user-invocable: false
-allowed-tools: []
-model: sonnet
-deprecated: true
-deprecated_reason: absorbed into agent-composer Step 3-a
-deprecated_date: 2026-06-02
-successor: agent-composer
----
-
-# context-bridge-dispatch — DEPRECATED
-
-> **Merged into `agent-composer` Step 3-a (2026-06-02).**
-> Context Card injection, Registry mode, coordination-overhead budget, and Focus Mode are now part of agent-composer Step 3.
-> Use `/agent-composer` for all parallel dispatch with context injection.
-
-## Content preserved at
-
-`plugins/fh-meta/skills/agent-composer/SKILL.md §Step 3-a` — the live successor.
-
-> The original pre-merge content is preserved in git history (this stub's earlier revisions); the
-> shipped `SKILL_detail.md` archive was removed in the curator shrink (2026-06-16) as redundant with
-> git history. No live content lost — the functional content lives in agent-composer Step 3-a.
-
-## Done When
-
-Deprecated — no active execution path. Done When: skill is never directly invoked; all dispatch routes through `/agent-composer` Step 3-a (the successor). This entry satisfies the harness-doctor L2 M-tier requirement for missing Done When (CLAUDE.md §New Skill Creation Pre-Commit Gate).

package/plugins/fh-meta/skills/self-marketing-lint/SKILL.md

@@ -1,30 +0,0 @@
----
-name: self-marketing-lint
-description: >-
-  DEPRECATED — merged into harness-doctor --lint mode (2026-06-02).
-  Language pattern detection (self-marketing, cushion words, version labels) is now Step 3-L of harness-doctor.
-  Use /harness-doctor --lint instead.
-user-invocable: false
-allowed-tools: []
-model: sonnet
-deprecated: true
-deprecated_reason: absorbed into harness-doctor Step 3-L (--lint mode)
-deprecated_date: 2026-06-02
-successor: harness-doctor
----
-
-# self-marketing-lint — DEPRECATED
-
-This skill was absorbed into **harness-doctor** on 2026-06-02. Its self-marketing /
-cushion-word / version-brag detection patterns now live in **harness-doctor Step 3-L
-(`--lint` mode)**, which carries the canonical baseline.
-
-**Use instead:**
-
-```
-/harness-doctor --lint
-```
-
-Triggers that previously reached this skill (`check FH files`, `remove marketing
-language`, `description diet`) now route to harness-doctor Step 3-L. This stub remains
-only so old references resolve.