@chrono-meta/fh-gate 1.4.72 → 1.4.74

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

@@ -20,7 +20,7 @@ Diagnoses the main causes of session token waste and prescribes immediate remedi
 3. Not using `/clear` after direction changes → continuing work with accumulated noise
 4. Verbose CLI output → every `git`/`ls`/build/test call floods context with stdout (a *different* layer from 1–3 — see §Command-Output Reduction)
 
-**Two reduction axes — keep them distinct.** Causes 1–3 are the **context-footprint** axis (what gets read *into* context: files, history). Cause 4 is the **command-output** axis (tokens produced *by* the tools you run). `.claudeignore` cannot touch command output, and a command-output proxy cannot touch file reads — they are complementary, not substitutes.
+**Two reduction axes — keep them distinct.** Causes 1–3 are the **context-footprint** axis (what gets read *into* context: files, history). Cause 4 is the **command-output** axis (tokens produced *by* the tools you run). `.claudeignore` cannot touch command output, and a command-output proxy cannot touch file reads — they are complementary, not substitutes. (Step 3.5 below adds an optional **third**, orthogonal lever — provider-side cache billing — distinct from both.)
 
 **Standalone install** — this skill works normally with plugin install only, without cloning the full meta-harness.
 
@@ -111,6 +111,39 @@ When context is near the limit and you want to *preserve state* rather than rese
 
 > Models are tools for allocating the right expertise to complexity. Opus for simple tasks = wasted expertise; Haiku for design decisions = insufficient expertise. Switch models when task nature changes.
 
+### Step 3.5. Cache-Boundary Audit (prompt caching, optional third lever)
+
+Distinct from both axes above: Steps 1–3 reduce what occupies the context *window*; this
+reduces what the provider re-bills as **fresh input tokens** on each turn by preserving
+prompt-cache hits. **Optional** — run it when a metered/quota-limited backend makes cache
+cost the binding constraint (same gating logic as §Command-Output Reduction: diagnose and
+recommend, do not chase this when tokens are merely plentiful).
+
+**Audit checklist**:
+- Is the system prompt / CLAUDE.md content **stable byte-for-byte** across turns in a
+  session? Any turn-to-turn diff in the fixed prefix invalidates the cache for that prefix —
+  which is in tension with Step 5's CLAUDE.md-compression prescription: compress at session
+  boundaries (before a fresh cache is built), never mid-session (which would invalidate one
+  already warm).
+- Is session-specific / dynamic content (task state, recent results) placed at the
+  **end of the user message**, not interleaved into the system prompt or early context?
+
+**Reported, UNCALIBRATED by FH** (2026-07-27 frontier digest, issue #102): input:output token
+ratio **> 10:1** favors cache/context engineering over model-level optimization; **> 50:1**,
+prefix caching dominates; cache-boundary control reportedly raised hit rate ~7%→84% in one
+production case (arXiv:2603.09619 *Context Engineering: From Prompts to Corporate Multi-Agent
+Architecture* · appscale.blog).
+
+**What is and is not verified** — the two are separate checks and only one has been run:
+the cited paper's **existence** was confirmed 2026-07-28 (arxiv.org/abs/2603.09619 → HTTP 200,
+title matches; measured alongside a known-real control ID, so the check itself is calibrated).
+The **figures** above were not read out of the paper — they are still traced only to the digest
+comment. Treat the ratio thresholds as illustrative, not a calibrated gate, until the source
+text is read directly.
+
+> **Detail**: See `SKILL_detail.md §CacheBoundary` — full citation text and the 403 grounding
+> note — read before citing these figures elsewhere.
+
 ### Step 4. harvest-loop Integration (burst pattern recording)
 
 When burst pattern is detected and `tracks/_audit/` exists: locate the latest weekly_audit file and suggest adding the Token Efficiency Check items to it (bash + checklist block in §Step-Bash).
@@ -132,6 +165,8 @@ Run the audit bash (§Step-Bash) and apply thresholds:
 
 **Frequency**: When explicitly called with `/context-doctor` or auto-invoked at session start when MEMORY.md is detected at 180+ lines.
 
+**Cache-boundary note**: apply CLAUDE.md compression (above) at a session boundary, not mid-session — see Step 3.5's cache-invalidation tension if that step is also in scope.
+
 ## Context Hierarchy (L1/L2/L3)
 
 Information buried in the middle of a long context window suffers measurable accuracy loss — the "lost in the middle" effect, ~10–30% degradation for mid-context information (see `../../../../knowledge/shared/harness-core/harness_frontier_diagnosis_2026-06-02.md`). The remedy is two-fold: tier the context, and place the most important instructions at the **start and end**, never buried in the middle.
@@ -187,8 +222,8 @@ The reductions above all act on the **context-footprint** axis (files, history r
 
 | Environment | Behavior |
 |---|---|
-| Meta-harness cloned (Mode A) | Perform full Steps 1–5 / integrate with harvest-loop files |
-| Plugin only (Mode C) | Perform Steps 1–3 / Step 4 output only (no file writes) |
+| Meta-harness cloned (Mode A) | Perform full Steps 1–5 (+ optional Step 3.5) / integrate with harvest-loop files |
+| Plugin only (Mode C) | Perform Steps 1–3 (+ optional Step 3.5, no file writes needed) / Step 4 output only (no file writes) |
 | External general environment | Focus on `.claudeignore` generation + large file guidance |
 
 ## Invocation Triggers
@@ -231,6 +266,7 @@ Explicit invocation (`/context-doctor`) always runs regardless of suppress state
 - "context diet", "memory audit", "CLAUDE.md is heavy", "MEMORY.md size"
 - "context engineering", "context rot", "context collapse"
 - "command output is huge", "verbose output", "rtk", "token killer", "trim command output"
+- "prompt caching", "cache hit rate", "cache boundary", "why are my API costs so high"
 
 ### Natural Language Triggers (activates without internal vocabulary)
 
@@ -247,6 +283,7 @@ Also activates when an external user expresses without token/context terminology
 | "Context is getting full", "context meter is high" | Approaching context limit | Step 3 — propose Wrap-then-Compact pattern |
 | "context engineering", "doing context engineering", "context rot setting in" | 2026 industry term for context discipline (Chroma 2025 / Anthropic) | Step 2 + Step 3 |
 | "every git command dumps a wall of text", "the build output eats my context" | Verbose command output flooding context | §Command-Output Reduction (route to proxy/hook) |
+| "our token bill is high but context looks fine", "cache keeps missing" | Suspected cache-boundary invalidation, not context bloat | Step 3.5 (optional) |
 
 ## Three-Doctor Loop Integration
 
@@ -277,9 +314,10 @@ context-doctor (token/context) · harness-doctor (structure) · sim-conductor (s
 
 | Condition | Completion verdict |
 |---|---|
-| Diagnosis results output to conversation (relevant stages among Steps 1~5) | ✅ Diagnosis complete |
+| Diagnosis results output to conversation (relevant stages among Steps 1~5, incl. optional 3.5) | ✅ Diagnosis complete |
 | `.claudeignore` created or modified + path output | ✅ Prescription complete |
 | Large file detected with split strategy guidance output | ✅ Step 2 complete |
+| Step 3.5 run: checklist findings output, thresholds labeled UNCALIBRATED per source above | ✅ Cache-boundary audit complete (only when Step 3.5 was triggered) |
 | "No context structure issues" judgment output | ✅ Health check complete |
 
 **This skill's Done When = "diagnosis report output complete"**. Actual resolution of prescription items is in the user's or follow-up work domain and is not included in this skill's completion criteria.

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

@@ -93,6 +93,44 @@ CC Context Audit Results
 
 ---
 
+## §CacheBoundary — prompt-caching evidence (Step 3.5, provisional)
+
+Full citation for the Step 3.5 evidence line, kept out of the always-read SKILL.md body
+per this file's own role (detail loads on-demand, SKILL.md stays lean).
+
+**Source**: forge-harness GitHub issue #102 ("Frontier Digest Log"), 2026-07-27 daily comment,
+itself citing:
+- arXiv:2603.09619 — reported input:output token-ratio thresholds (>10:1 favors context/cache
+  engineering over model-level optimization; >50:1, prefix caching dominates) and a
+  41–80% cost reduction / 13–31% TTFT improvement range attributed to prompt caching.
+- appscale.blog/en/blog/context-engineering-production-llm-agents-token-budget-compaction-2026
+  — the ~7%→84% cache-hit-rate figure from cache-boundary control (fixed system prompt,
+  dynamic content at the user-message end).
+
+**Grounding status — split verdict (2026-07-28 re-check).** Two separate questions; only one
+is closed. Do not collapse them:
+
+| Question | Verdict | Evidence |
+|---|---|---|
+| Does the cited paper exist? | ✅ **VERIFIED** | `arxiv.org/abs/2603.09619` → HTTP 200, title *"Context Engineering: From Prompts to Corporate Multi-Agent Architecture"*. Measured alongside a known-real control ID (1706.03762 → 200), so the instrument is calibrated for this check. |
+| Do the paper/blog actually state these figures? | ❌ **UNVERIFIED** | The source text was never read. The numbers are traced only to the digest comment. |
+
+⚠️ **Instrument note (kept because it nearly produced a wrong verdict).** The first re-check
+used the arXiv **API** (`export.arxiv.org/api/query`) and returned empty for the target — but
+also empty for the known-real control, i.e. the instrument was dead, not the paper missing.
+An absence measured without a live control is not evidence. Switching to the `abs` page gave a
+working control and flipped the existence verdict to VERIFIED. Original 403 note below for
+provenance.
+
+**Original (2026-07-27) note**: both URLs returned HTTP 403 when that session attempted
+to fetch and verify the claimed spans directly (`WebFetch`), matching the same sandbox
+network-policy limitation the daily frontier-digest routine logged on every run this week
+(WebSearch fallback, no direct API access). The figures above are therefore traced only to
+the digest comment's own text — a real, read GitHub source — and are **not** independently
+re-verified against the original paper/post. Per the Instrument-Calibration doctrine
+(`CLAUDE.md`), do not treat the 10:1 / 50:1 thresholds as a calibrated gate and do not cite
+the ~7%→84% figure elsewhere without re-fetching from an environment with access first.
+
 ## §Headroom — Tooling (external option)
 
 The compression pass in SKILL.md is tool-agnostic, but a concrete, reversible, local-first implementation exists: **Headroom** (`github.com/chopratejas/headroom`, open source, v0.22). It compresses tool outputs, logs, files, and RAG chunks before they reach the LLM — **vendor/coverage-reported** at 60–95% fewer tokens with the same answers ([The Register, 2026-05-31](https://www.theregister.com/ai-ml/2026/05/31/netflix-wiz-creates-app-to-slash-ai-bills-then-open-sources-it/5248702); figures unverified by FH). General token-efficiency basis: `../../../../knowledge/shared/harness-core/harness_frontier_diagnosis_2026-06-02.md`.

package/scripts/below_floor_scan.sh

@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+# below_floor_scan.sh — standing consumer for below-floor adversarial markers
+#
+# The pre-commit hook accepts a below-floor Axis-2 pass when an operator ack is
+# present, on the promise that "the weekly audit re-queues below-floor markers
+# for floor-tier re-run" (§Floor governance, multi_model_sidecar_strategy.md).
+# This script IS that consumer: it enumerates below-floor markers and reports
+# which ones still await floor-tier re-validation. Read-only, zero side effects.
+#
+# Resolution protocol (append to the marker after acting — machine-greppable):
+#   floor-rerun: <YYYY-MM-DD> <model> PASS|FAIL   ← Axis 2 re-run at >= floor
+#   floor-writeoff: <YYYY-MM-DD> <one-line reason> ← operator writes the ack off
+#
+# Usage: bash scripts/below_floor_scan.sh [repo_root]
+# Exit:  0 = no pending below-floor markers; 1 = pending re-runs found
+#        (manual weekly-audit step — Phase 1.5; exit 1 = raise the pending
+#        items as S-tier. No automated caller is wired yet.)
+
+set -uo pipefail
+
+REPO_ROOT="${1:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
+MARKER_DIR="$REPO_ROOT/tracks/_meta"
+PENDING=0
+TOTAL=0
+
+echo "── below-floor marker scan: $MARKER_DIR ──"
+
+if [ ! -d "$MARKER_DIR" ]; then
+  echo "   (no tracks/_meta directory — nothing to scan)"
+  exit 0
+fi
+
+SONNET_PENDING=0
+for m in "$MARKER_DIR"/.axes_23_passed_*.marker; do
+  [ -e "$m" ] || continue
+  # sonnet-floor lane (Sonnet-Floor Doctrine 2026-07-10): anchored Sonnet passes are
+  # first-class at commit time but provisional for judged depth — queued here as
+  # R-tier (advisory re-validation), distinct from below-floor's S-tier hard queue.
+  if grep -qE '^[[:space:]]*floor-status:[[:space:]]*sonnet-floor' "$m"; then
+    name=$(basename "$m")
+    rerun=$(grep -m1 -E '^[[:space:]]*floor-rerun:' "$m" \
+            | sed -E 's/^[[:space:]]*floor-rerun:[[:space:]]*//' || true)
+    writeoff=$(grep -m1 -E '^[[:space:]]*floor-writeoff:' "$m" \
+               | sed -E 's/^[[:space:]]*floor-writeoff:[[:space:]]*//' || true)
+    if [ -n "$rerun" ]; then
+      echo "✅ RESOLVED (re-run)   $name — floor-rerun: $rerun"
+    elif [ -n "$writeoff" ]; then
+      echo "✅ RESOLVED (writeoff) $name — floor-writeoff: $writeoff"
+    else
+      SONNET_PENDING=$((SONNET_PENDING + 1))
+      anchor=$(grep -m1 -E '^[[:space:]]*axis2-anchor:' "$m" \
+               | sed -E 's/^[[:space:]]*axis2-anchor:[[:space:]]*//' || true)
+      echo "🟨 R-tier re-validate  $name (sonnet-floor)"
+      echo "     axis2-anchor: ${anchor:-<missing>}"
+      echo "     action: re-run judged depth at >= opus or via sidecar dispatch when"
+      echo "             available, append 'floor-rerun: ...' — or 'floor-writeoff: ...'"
+    fi
+    continue
+  fi
+  grep -qE '^[[:space:]]*floor-status:[[:space:]]*below-floor' "$m" || continue
+  TOTAL=$((TOTAL + 1))
+  name=$(basename "$m")
+  model=$(grep -m1 -E '^[[:space:]]*axis2-model:' "$m" \
+          | sed -E 's/^[[:space:]]*axis2-model:[[:space:]]*//' || true)
+  ack=$(grep -m1 -E '^[[:space:]]*below-floor-ack:' "$m" \
+        | sed -E 's/^[[:space:]]*below-floor-ack:[[:space:]]*//' || true)
+  rerun=$(grep -m1 -E '^[[:space:]]*floor-rerun:' "$m" \
+          | sed -E 's/^[[:space:]]*floor-rerun:[[:space:]]*//' || true)
+  writeoff=$(grep -m1 -E '^[[:space:]]*floor-writeoff:' "$m" \
+             | sed -E 's/^[[:space:]]*floor-writeoff:[[:space:]]*//' || true)
+
+  if [ -n "$rerun" ]; then
+    echo "✅ RESOLVED (re-run)   $name — floor-rerun: $rerun"
+  elif [ -n "$writeoff" ]; then
+    echo "✅ RESOLVED (writeoff) $name — floor-writeoff: $writeoff"
+  else
+    PENDING=$((PENDING + 1))
+    echo "🟥 PENDING re-run      $name"
+    echo "     axis2-model: ${model:-<missing>} | ack: ${ack:-<missing>}"
+    echo "     action: re-run Axis 2 at >= floor (opus), append 'floor-rerun: ...'"
+    echo "             or operator writes off: append 'floor-writeoff: ...'"
+  fi
+done
+
+echo "── below-floor markers: $TOTAL total, $PENDING pending (S-tier) ──"
+echo "── sonnet-floor markers pending re-validation: $SONNET_PENDING (R-tier, advisory) ──"
+# Exit semantics unchanged: only below-floor (S-tier) hard-fails the scan.
+# sonnet-floor pendings are advisory — reported, never exit-blocking (doctrine:
+# Sonnet base is first-class; the queue exists so residuals terminate, not decorate).
+[ "$PENDING" -gt 0 ] && exit 1
+exit 0

package/scripts/chamber_candidate_collect.sh

@@ -0,0 +1,223 @@
+#!/usr/bin/env bash
+# chamber_candidate_collect.sh — chamber candidate discovery: 6-source converge → dedup → rank → screen.
+#
+# The second half of the discovery entrance (the first half = chamber_candidate_screen.sh, the reinvention
+# first-pass). Design home: tracks/_meta/fh_signal_2026-07-14_self-dev.md (design v2, 2-family verified).
+#
+# WHAT IT DOES: pulls candidate signals from the 6 sources, deduplicates the same gap arriving multiple
+# ways (2-family finding: harvest-loop/fh_signal/UAP observe the SAME session → triple-listing), ranks by
+# source-diversity + frequency, and runs each survivor through the reinvention screener. Output = a ranked
+# candidate queue for the operator's HITL "run the chamber?" decision (judged uncertainty/failure-cost
+# filters stay with the human — this tool does the mechanizable converge/dedup/rank/screen).
+#
+# CANDIDATE-EMISSION CONVENTION (why a convention, not source-specific parsing): the 2-family review
+# flagged per-source parsing as fragile/hand-wave. So a source declares a candidate with ONE robust line:
+#     CHAMBER-CANDIDATE: <one-line description of the capability/project to incubate>
+# Any of the 6 sources adds this line when it surfaces something chamber-worthy. Sources adopt it
+# incrementally — until they do, the queue is honestly SPARSE (the design's "6-source volume = n=0,
+# measured only after wiring"; this tool IS that wiring, and its first run measures the volume).
+#
+# NOT MECHANIZED HERE (stays judged/HITL, by design): uncertainty + failure-cost filters (operator judges
+# the ranked survivors); chamber injection (goal-quench budget gate + HITL). This tool ranks; it does not
+# admit. A high rank is a suggestion, never an auto-run.
+#
+# Usage:  bash scripts/chamber_candidate_collect.sh [--min-jaccard N]   (default 50)
+#   exit 0 = ran (ranked queue on stdout; empty queue is a valid honest result)
+#   exit 2 = harness error (FH root not found)
+
+set -uo pipefail
+
+FH="$(cd "$(dirname "$0")/.." && pwd)"
+if [ ! -d "$FH/tracks/_meta" ] || [ ! -d "$FH/plugins" ]; then
+  echo "❌ FH root not found at '$FH' — run from the FH repo." >&2
+  exit 2
+fi
+SCREEN="$FH/scripts/chamber_candidate_screen.sh"
+MINJ=50
+[ "${1:-}" = "--min-jaccard" ] && MINJ="${2:-50}"
+case "$MINJ" in ''|*[!0-9]*) echo "❌ --min-jaccard must be an integer 0-100 (got '$MINJ')" >&2; exit 2 ;; esac
+
+WORK="${TMPDIR:-/tmp}/cand_collect.$$"
+# fail-CLOSED on workdir failure (Axis-2 challenger MED): an unwritable TMPDIR must NOT masquerade as the
+# design's valid "honest-empty queue" — a genuine infra failure and "no markers surfaced" are otherwise
+# indistinguishable. Route infra failure to exit 2 (harness error), never to green-empty.
+mkdir -p "$WORK" 2>/dev/null || { echo "❌ cannot create workdir under '${TMPDIR:-/tmp}' — cannot collect (NOT an empty queue)" >&2; exit 2; }
+trap 'rm -rf "$WORK"' EXIT
+RAW="$WORK/raw"; : > "$RAW" 2>/dev/null || { echo "❌ cannot write workfile (NOT an empty queue)" >&2; exit 2; }
+
+# --- LAYER 1: 6-source converge. Each source = a label + a glob; grep the convention line. ---
+# (source label · file glob) — sources that don't exist yet simply contribute nothing (fail-visible below).
+_pull() { # $1=source-label  $2..=files
+  local label="$1"; shift
+  local f
+  for f in "$@"; do
+    [ -f "$f" ] || continue
+    # convention line: "CHAMBER-CANDIDATE: <desc>" (case-insensitive marker, desc after the colon)
+    grep -inE '^[[:space:]]*CHAMBER-CANDIDATE:' "$f" 2>/dev/null \
+      | sed -E 's/^[0-9]+:[[:space:]]*CHAMBER-CANDIDATE:[[:space:]]*//I' \
+      | while IFS= read -r desc; do
+          [ -n "$desc" ] && printf '%s\t%s\n' "$label" "$desc" >> "$RAW"
+        done
+  done
+}
+SRC_SEEN=0
+for spec in \
+  "harness-doctor:$FH/tracks/_meta/*harness_doctor*.md" \
+  "harvest-loop:$FH/tracks/_audit/*.md" \
+  "fh-signal:$FH/tracks/_meta/fh_signal_*.md" \
+  "field-harvest:$FH/tracks/_contrib/*.md" \
+  "frontier-digest:$FH/tracks/_meta/frontier_digest_*.md" \
+  "uap:$FH/tracks/_meta/user_adaptation_profile.md" ; do
+  label="${spec%%:*}"; glob="${spec#*:}"
+  # word-split the glob deliberately (globbing); nullglob-safe via the -f check in _pull
+  files=$(ls $glob 2>/dev/null || true)
+  [ -n "$files" ] && SRC_SEEN=$((SRC_SEEN+1))
+  # shellcheck disable=SC2086
+  _pull "$label" $files
+done
+
+NRAW=$(grep -c . "$RAW" 2>/dev/null); NRAW=${NRAW:-0}
+echo "── chamber candidate collect ──"
+echo "sources present: $SRC_SEEN/6 · raw candidate markers found: $NRAW"
+if [ "$NRAW" -eq 0 ]; then
+  echo "queue EMPTY — no 'CHAMBER-CANDIDATE:' markers in any source yet (convention not adopted / nothing surfaced)."
+  echo "  This is an honest result, not an error: the discovery volume is n=0 until sources emit the marker."
+  echo "  (Add 'CHAMBER-CANDIDATE: <desc>' to a harness-doctor / fh_signal / frontier-digest / harvest entry.)"
+  exit 0
+fi
+
+# --- keyword signature per candidate (for dedup) ---
+STOP='^(that|this|from|into|over|when|what|will|your|there|their|then|than|with|chamber|candidate|skill|agent|tool|does|done|after|before|which|about|through)$'
+_sig() { printf '%s' "$1" | tr '[:upper:]' '[:lower:]' | tr -c 'a-z0-9가-힣' ' ' | tr -s ' ' '\n' \
+         | awk 'length($0)>=4' | grep -vE "$STOP" | sort -u; }
+# kill-side signature for the seen-filter: keeps 2+ char tokens (a slug's meaningful short tokens like
+# "qa"/"ui" are dropped by _sig's ≥4 filter → an all-short slug yields an EMPTY sig → kkn=0 → the old
+# match never fired → a KILLed candidate re-entered the queue SILENTLY, Axis-2 MED-3b). Drops stopwords only.
+_ksig() { printf '%s' "$1" | tr '[:upper:]' '[:lower:]' | tr -c 'a-z0-9가-힣' ' ' | tr -s ' ' '\n' \
+          | awk 'length($0)>=2' | grep -vE "$STOP" | sort -u; }
+
+# --- LAYER 2: dedup by greedy jaccard clustering ---
+# cluster files: $WORK/cluster.N holds "source<TAB>desc" lines; $WORK/sig.N holds the union keyword sig.
+NC=0
+idx=0
+while IFS=$'\t' read -r label desc; do
+  idx=$((idx+1))
+  _sig "$desc" > "$WORK/candsig.$idx"
+  merged=0
+  c=1
+  while [ "$c" -le "$NC" ]; do
+    inter=$(comm -12 "$WORK/sig.$c" "$WORK/candsig.$idx" 2>/dev/null | grep -c . || true)
+    union=$(sort -u "$WORK/sig.$c" "$WORK/candsig.$idx" 2>/dev/null | grep -c . || true)
+    jac=0; [ "${union:-0}" -gt 0 ] && jac=$(( inter * 100 / union ))
+    if [ "$jac" -ge "$MINJ" ]; then
+      printf '%s\t%s\n' "$label" "$desc" >> "$WORK/cluster.$c"
+      sort -u "$WORK/sig.$c" "$WORK/candsig.$idx" > "$WORK/sig.$c.tmp" && mv "$WORK/sig.$c.tmp" "$WORK/sig.$c"
+      merged=1; break
+    fi
+    c=$((c+1))
+  done
+  if [ "$merged" -eq 0 ]; then
+    NC=$((NC+1))
+    printf '%s\t%s\n' "$label" "$desc" > "$WORK/cluster.$NC"
+    cp "$WORK/candsig.$idx" "$WORK/sig.$NC"
+  fi
+done < "$RAW"
+
+# --- seen-filter: pull already-KILLed candidates from the G4 run ledger so a re-listed marker for a
+# candidate the chamber already killed does NOT re-enter the main queue (the run-#3 real-use gap). It is
+# EXCLUDED from the ranked queue but SURFACED in a trailing section (re-emit trigger visibility — a KILL
+# is revisitable once its measured observation lands, so we don't silently erase it). Degrade: no ledger
+# → no seen-filter (fail-visible; equals the pre-seen behavior, safe). ---
+LEDGER="$FH/tracks/_chamber/INDEX.md"
+KILLED="$WORK/killed"; : > "$KILLED"
+if [ -f "$LEDGER" ]; then
+  # KILL rows: a run-log table data row (`| #N | date | candidate | VERDICT | ... |`) whose VERDICT
+  # field ($5) says KILL. Scope the KILL test to the verdict field — NOT a whole-line grep, which would
+  # match "kill" inside "skill" in any row's carry-text (Axis-2 HIGH-1: an EMIT row folding a sliver
+  # "into goal-quench skill" would be misread as KILL). Candidate = $4; strip backticks/asterisks/space.
+  awk -F'|' '$0 ~ /^\| *#/ && NF>=5 && toupper($5) ~ /KILL/ {print $4}' "$LEDGER" 2>/dev/null \
+    | sed 's/[`*]//g; s/^ *//; s/ *$//' | grep -v '^$' >> "$KILLED"
+fi
+NKILL=$(grep -c . "$KILLED" 2>/dev/null); NKILL=${NKILL:-0}
+SEENOUT="$WORK/seen_out"; : > "$SEENOUT"
+
+# --- LAYER 2: rank each cluster = source-diversity*2 + frequency; then screen for reinvention ---
+RANKED="$WORK/ranked"; : > "$RANKED"
+c=1
+while [ "$c" -le "$NC" ]; do
+  freq=$(grep -c . "$WORK/cluster.$c" 2>/dev/null); freq=${freq:-0}
+  ndiv=$(cut -f1 "$WORK/cluster.$c" | sort -u | grep -c . || true)
+  srcs=$(cut -f1 "$WORK/cluster.$c" | sort -u | paste -sd, -)
+  rep=$(head -1 "$WORK/cluster.$c" | cut -f2-)
+  score=$(( ndiv * 2 + freq ))
+  # seen-filter: does this candidate match an already-KILLed ledger entry? Two decorrelated tests, either
+  # sufficient: (1) kill-name keyword recall ≥60% (the common multi-token case); (2) normalized-substring
+  # fallback — the flattened slug (alnum-only, ≥5 chars) appearing in the flattened candidate — which
+  # closes the all-short-token silent-re-entry hole (MED-3b) that recall alone leaves open. Residual
+  # (documented, accepted): a paraphrased re-listing (router→routing) can still under-recall (MED-4), and
+  # a generic slug can over-exclude — but over-exclusion is VISIBLE in the SEEN-KILLED section (operator
+  # catches a wrong match), whereas silent re-entry was invisible. Visible-imprecise ≻ silent-miss.
+  if [ "$NKILL" -gt 0 ]; then
+    _ksig "$rep" > "$WORK/repsig"
+    repflat=$(printf '%s' "$rep" | tr '[:upper:]' '[:lower:]' | tr -cd 'a-z0-9')
+    seen_match=""
+    while IFS= read -r kname; do
+      [ -z "$kname" ] && continue
+      _ksig "$kname" > "$WORK/ksig"
+      kkn=$(grep -c . "$WORK/ksig" 2>/dev/null || true); kkn=${kkn:-0}
+      matched=0; [ "$kkn" -gt 0 ] && matched=$(comm -12 "$WORK/ksig" "$WORK/repsig" 2>/dev/null | grep -c . || true)
+      kpct=0; [ "$kkn" -gt 0 ] && kpct=$(( matched * 100 / kkn ))
+      kflat=$(printf '%s' "$kname" | tr '[:upper:]' '[:lower:]' | tr -cd 'a-z0-9')
+      if [ "$kkn" -gt 0 ] && [ "$kpct" -ge 60 ]; then seen_match="$kname"; break; fi
+      if [ "${#kflat}" -ge 5 ] && printf '%s' "$repflat" | grep -qF "$kflat"; then seen_match="$kname"; break; fi
+    done < "$KILLED"
+    if [ -n "$seen_match" ]; then
+      printf '%s\t%s\n' "$seen_match" "$rep" >> "$SEENOUT"
+      c=$((c+1)); continue
+    fi
+  fi
+  # reinvention first-pass on the representative description. Capture BOTH the verdict AND the matched
+  # anchor the screener already emits ("top asset overlap: X") so a DUPLICATE-CANDIDATE is ACTIONABLE
+  # ("DUP:skill:goal-quench") instead of a uniform non-discriminating flag (Axis-2 challenger Axis-5).
+  verdict="?"
+  if [ -x "$SCREEN" ] || [ -f "$SCREEN" ]; then
+    sout=$(bash "$SCREEN" "$rep" 2>/dev/null)
+    verdict=$(printf '%s\n' "$sout" | grep -oE 'VERDICT: [A-Z-]+' | head -1 | sed 's/VERDICT: //')
+    [ -z "$verdict" ] && verdict="?"
+    if [ "$verdict" = "DUPLICATE-CANDIDATE" ]; then
+      anchor=$(printf '%s\n' "$sout" | grep -oE 'top asset overlap: [^ ]+' | head -1 | sed 's/top asset overlap: //')
+      [ -n "$anchor" ] && verdict="DUP:$anchor"
+    fi
+  fi
+  printf '%03d\t%s\t%s\t%s\t%s\n' "$score" "$ndiv" "$srcs" "$verdict" "$rep" >> "$RANKED"
+  c=$((c+1))
+done
+
+echo "deduped candidates: $NC (from $NRAW raw markers)"
+echo ""
+printf '%-5s  %-6s  %-24s  %-18s  %s\n' "SCORE" "SRCS" "SOURCES" "REINVENTION" "CANDIDATE"
+printf '%-5s  %-6s  %-24s  %-18s  %s\n' "-----" "------" "------------------------" "------------------" "---------"
+sort -rn "$RANKED" | while IFS=$'\t' read -r score ndiv srcs verdict rep; do
+  # drop leading zeros for display
+  printf '%-5d  %-6d  %-24s  %-18s  %s\n' "$((10#$score))" "$ndiv" "$srcs" "$verdict" "$rep"
+done
+echo ""
+echo "NOTE: SCORE = source-diversity×2 + frequency. REINVENTION is a first-pass flag (DUPLICATE-CANDIDATE"
+echo "= HITL KILL review, not auto-drop). Uncertainty/failure-cost stay JUDGED — operator picks which"
+echo "survivors actually enter the chamber (goal-quench budget gate + HITL). This tool ranks; it never admits."
+
+# seen-filter trailing section: candidates the G4 ledger already KILLed are shown here (NOT in the ranked
+# queue) so a re-listed marker does not silently re-enter the chamber, yet the KILL stays visible (a KILL
+# is revisitable once its re-emit trigger lands — see the run's EMISSION_VERDICT for that condition).
+if [ -s "$SEENOUT" ]; then
+  echo ""
+  echo "SEEN-KILLED — excluded from the queue (G4 ledger $LEDGER already KILLed these):"
+  while IFS=$'\t' read -r kn rep; do
+    [ -z "$rep" ] && continue
+    echo "  · \"$rep\"  ↔ killed as \"$kn\"  (재등재 스킵; re-emit only when that run's trigger condition is met)"
+  done < "$SEENOUT"
+elif [ ! -f "$LEDGER" ]; then
+  echo ""
+  echo "SEEN-FILTER: skipped — no G4 ledger at $LEDGER (fail-visible; no seen-exclusion applied this run)."
+fi
+exit 0

package/scripts/chamber_run.sh

@@ -0,0 +1,184 @@
+#!/usr/bin/env bash
+# chamber_run.sh — chamber run orchestrator (the runner the skeleton's gaps G1-forcing/G2/G4/STATUS all
+# hung on). GLUE ONLY: it wires the pieces that already exist (workspace convention · budget gate notion ·
+# the isolated persona agents · the Emission Gate · the G4 ledger) into one intent-driven, resumable flow
+# so a chamber run can be *completed by intent* rather than hand-followed from the skeleton doc.
+#
+# What it MECHANIZES: workspace + INTENT/BUDGET templates · STATUS stamping (resumable — re-run to advance) ·
+# the budget-entry gate (G2: blocks step 4 until an ESTIMATE is recorded — no uncapped run) · the step-4
+# isolation gate (G1-forcing: blocks step 5 until SIM_NOTES has ≥3 blind persona sections) · the Emission
+# Gate verdict capture · actual-cost record · and the G4 ledger auto-append (idempotent).
+#
+# What it CANNOT mechanize (honest muscle boundary, documented in CHAMBER_RUN_SKELETON.md): bash cannot
+# spawn the isolated Agents itself. Step 4 PRINTS the exact dispatch and GATES on the ≥3 persona artifact —
+# the human/Claude does the actual `fh-meta:{beginner,challenger,main-player}` dispatch. Isolation stays a
+# salience+artifact gate, not a spawn. Budget/cost numbers calibrate only across real runs (muscle, not wiring).
+#
+# Usage:  bash scripts/chamber_run.sh <candidate-slug>          # create/advance the run (idempotent)
+#         bash scripts/chamber_run.sh <candidate-slug> status    # show where the run is
+#   exit 0 = advanced or already complete · exit 1 = blocked on a missing artifact (message says which)
+#   exit 2 = harness error (FH root / bad slug)
+
+set -uo pipefail
+
+FH="$(cd "$(dirname "$0")/.." && pwd)"
+if [ ! -d "$FH/tracks" ] || [ ! -d "$FH/plugins" ]; then
+  echo "❌ FH root not found at '$FH' — run from the FH repo." >&2; exit 2
+fi
+
+SLUG="${1:-}"
+[ -z "$SLUG" ] && { echo "usage: chamber_run.sh <candidate-slug> [status]" >&2; exit 2; }
+# slug charset: [A-Za-z0-9-] only, no leading dash. Rejecting regex metachars (`.` `+` `[` `*`) is
+# load-bearing — $SLUG is interpolated raw into an ERE idempotency grep below; `a.b` would let `.` match
+# any char (idempotency mismatch → duplicate ledger row), `a+b` would break the ERE (Axis-2 LOW-5).
+case "$SLUG" in -*) echo "❌ bad slug '$SLUG' (no leading dash)" >&2; exit 2 ;; esac
+case "$SLUG" in *[!A-Za-z0-9-]*) echo "❌ bad slug '$SLUG' (allowed: letters, digits, hyphen)" >&2; exit 2 ;; esac
+CMD="${2:-advance}"
+
+WS="$FH/tracks/_chamber/$SLUG"
+LEDGER="$FH/tracks/_chamber/INDEX.md"
+STATUS_F="$WS/STATUS"
+TODAY="$(date +%Y-%m-%d)"
+
+_status() { [ -f "$STATUS_F" ] && cat "$STATUS_F" || echo "step-0"; }
+_stamp()  { printf '%s\n' "$1" > "$STATUS_F"; }
+
+if [ "$CMD" = "status" ]; then
+  echo "chamber run '$SLUG' → STATUS: $(_status)"
+  [ -d "$WS" ] && ls -1 "$WS" 2>/dev/null | sed 's/^/    /'
+  exit 0
+fi
+
+echo "── chamber run: $SLUG (STATUS: $(_status)) ──"
+
+# STEP 1 — workspace
+if [ ! -d "$WS" ]; then
+  mkdir -p "$WS" 2>/dev/null || { echo "❌ cannot create workspace $WS" >&2; exit 2; }
+  echo "  ✓ step 1: workspace created ($WS)"
+fi
+_stamp "step-1-done"
+
+# STEP 2 — INTENT.md (template if absent; block until it has real content)
+if [ ! -f "$WS/INTENT.md" ]; then
+  cat > "$WS/INTENT.md" <<EOF
+# INTENT — $SLUG (chamber run)
+
+## Candidate intent
+<one line: the capability/project to incubate>
+
+## Success conditions (each with a check class: mandatory-pass / measured / judged)
+1.
+2.
+
+## Failure cost (blast radius AND reinvention risk)
+-
+
+## Chamber metadata
+- entry reason: <uncertain | exploratory | failure-expensive | high-reinvention-risk>
+- date: $TODAY
+EOF
+  echo "  ⛔ step 2 BLOCKED: fill in $WS/INTENT.md (template written), then re-run."; exit 1
+fi
+if grep -q '<one line: the capability' "$WS/INTENT.md"; then
+  echo "  ⛔ step 2 BLOCKED: $WS/INTENT.md still has the placeholder — fill it, then re-run."; exit 1
+fi
+# gate (a) is "artifact exists WITH real content", not just "placeholder removed" (Axis-2 LOW-6): require
+# at least one non-empty numbered success condition so a gutted INTENT.md doesn't pass.
+if ! awk '/^## Success conditions/{f=1;next} /^## /{f=0} f && /^[0-9]+\.[[:space:]]*[^[:space:]]/{print; exit}' "$WS/INTENT.md" | grep -q .; then
+  echo "  ⛔ step 2 BLOCKED: $WS/INTENT.md has no filled success condition (need a numbered line with content), re-run."; exit 1
+fi
+_stamp "step-2-done"; echo "  ✓ step 2: INTENT.md present"
+
+# STEP 3 — budget-entry gate (G2). Cannot invoke goal-quench from bash; MECHANICALLY require a recorded
+# estimate before any (expensive) simulation runs. No ESTIMATE = no run — that IS the entry cap.
+if [ ! -f "$WS/BUDGET.md" ]; then
+  cat > "$WS/BUDGET.md" <<EOF
+# BUDGET — $SLUG (chamber run)
+
+# Route through goal-quench's budget gate for an expensive run, then record here.
+# Demo-scale runs may self-cap — but an ESTIMATE line is mandatory (this is the entry cap).
+ESTIMATE: <e.g. ~3 persona dispatches, demo-scale, self-capped  |  or a token budget>
+ACTUAL:   <filled at step 6>
+EOF
+  echo "  ⛔ step 3 BLOCKED: record an ESTIMATE in $WS/BUDGET.md (budget-entry gate G2), then re-run."; exit 1
+fi
+if grep -qE '^ESTIMATE:[[:space:]]*<' "$WS/BUDGET.md" || ! grep -qE '^ESTIMATE:[[:space:]]*\S' "$WS/BUDGET.md"; then
+  echo "  ⛔ step 3 BLOCKED: $WS/BUDGET.md ESTIMATE is empty/placeholder (G2 entry cap), then re-run."; exit 1
+fi
+_stamp "step-3-done"; echo "  ✓ step 3: budget ESTIMATE recorded (entry cap satisfied)"
+
+# STEP 4 — persona simulation (G1-forcing gate). Dispatch is human/Claude-side (bash can't spawn Agents);
+# gate on the ≥3 blind persona artifact. Isolation is the mechanism — the runner enforces the artifact, not the spawn.
+if [ ! -f "$WS/SIM_NOTES.md" ]; then
+  echo "  ⛔ step 4 BLOCKED: dispatch 3 BLIND ISOLATED Agents and record each in $WS/SIM_NOTES.md:"
+  echo "        Agent fh-meta:beginner      → first-contact friction"
+  echo "        Agent fh-meta:main-player   → daily-use / target-user value"
+  echo "        Agent fh-meta:challenger    → skeptic: emit value? failure cost? what's invisible?"
+  echo "     Each as '## <persona> ...' section. (sim-conductor fills persona_container_schema's 6 slots.)"
+  exit 1
+fi
+# count DISTINCT personas (not raw lines — 3×"## beginner" must NOT satisfy the 3-blind-persona gate).
+NPERS=0
+for _p in beginner main-player challenger; do
+  grep -iqE "^##[[:space:]].*$_p" "$WS/SIM_NOTES.md" 2>/dev/null && NPERS=$((NPERS+1))
+done
+if [ "$NPERS" -lt 3 ]; then
+  echo "  ⛔ step 4 BLOCKED: SIM_NOTES.md has $NPERS/3 DISTINCT blind persona sections (need all of beginner + main-player + challenger)."; exit 1
+fi
+_stamp "step-4-done"; echo "  ✓ step 4: $NPERS blind persona sections present (isolation-gate satisfied)"
+
+# STEP 5 — Emission Gate. Require a VERDICT: EMIT | PARTIAL-EMIT | KILL.
+if [ ! -f "$WS/EMISSION_VERDICT.md" ]; then
+  cat > "$WS/EMISSION_VERDICT.md" <<EOF
+# Emission Gate Verdict — $SLUG (chamber run)
+
+VERDICT: <EMIT | PARTIAL-EMIT | KILL>
+
+## Judged: does the simulation hold?  (+ mechanical anchor: overlap grep / gate verdicts / reproduced flows)
+
+## Carry-forward (what compounds into the next run)
+-
+EOF
+  echo "  ⛔ step 5 BLOCKED: decide WITH the operator (HITL), record VERDICT in $WS/EMISSION_VERDICT.md, re-run."; exit 1
+fi
+# PARTIAL-EMIT listed FIRST in every alternation so it is never mis-extracted as its EMIT substring.
+VERDICT=$(grep -ioE '^VERDICT:[[:space:]]*(PARTIAL-EMIT|EMIT|KILL)' "$WS/EMISSION_VERDICT.md" 2>/dev/null | head -1 | grep -ioE 'PARTIAL-EMIT|EMIT|KILL' | head -1 | tr 'a-z' 'A-Z')
+# a bare "## Verdict:" prose line (run #3 style) also counts if it names KILL/EMIT
+[ -z "$VERDICT" ] && VERDICT=$(grep -ioE 'VERDICT[: *]+\**(PARTIAL-EMIT|EMIT|KILL)' "$WS/EMISSION_VERDICT.md" 2>/dev/null | grep -ioE 'PARTIAL-EMIT|EMIT|KILL' | head -1 | tr 'a-z' 'A-Z')
+if [ -z "$VERDICT" ]; then
+  echo "  ⛔ step 5 BLOCKED: no VERDICT (EMIT|PARTIAL-EMIT|KILL) found in $WS/EMISSION_VERDICT.md, re-run."; exit 1
+fi
+_stamp "step-5-done"; echo "  ✓ step 5: Emission Gate verdict = $VERDICT"
+
+# STEP 6 — actual cost / carry-forward record.
+if grep -qE '^ACTUAL:[[:space:]]*<' "$WS/BUDGET.md" || ! grep -qE '^ACTUAL:[[:space:]]*\S' "$WS/BUDGET.md"; then
+  echo "  ⛔ step 6 BLOCKED: record ACTUAL cost in $WS/BUDGET.md (actual-vs-estimate calibration), re-run."; exit 1
+fi
+_stamp "step-6-done"; echo "  ✓ step 6: actual cost recorded"
+
+# STEP 7 — terminus + G4 ledger auto-append (idempotent).
+if [ ! -f "$LEDGER" ]; then
+  echo "  ⚠ step 7: no ledger at $LEDGER — skipping auto-append (fail-visible)."
+elif grep -qE "^\|[^|]*\|[^|]*\|[^|]*\`$SLUG\`" "$LEDGER"; then
+  echo "  ✓ step 7: ledger already has a row for '$SLUG' (idempotent — no duplicate append)."
+else
+  NEXT=$(grep -oE '^\|[[:space:]]*#([0-9]+)' "$LEDGER" | grep -oE '[0-9]+' | sort -n | tail -1)
+  NEXT=$(( ${NEXT:-0} + 1 ))
+  CARRY=$(grep -A2 -iE '^##[[:space:]]*Carry-forward' "$WS/EMISSION_VERDICT.md" 2>/dev/null | grep -E '^-[[:space:]]*\S' | head -1 | sed 's/^-[[:space:]]*//; s/|/·/g')
+  [ -z "$CARRY" ] && CARRY="see $SLUG/EMISSION_VERDICT.md"
+  printf '| #%s | %s | `%s` | **%s** | %s | `%s/` |\n' "$NEXT" "$TODAY" "$SLUG" "$VERDICT" "$CARRY" "$SLUG" >> "$LEDGER"
+  echo "  ✓ step 7: appended run #$NEXT ($VERDICT) to the G4 ledger."
+fi
+_stamp "step-7-done"
+
+echo ""
+case "$VERDICT" in
+  EMIT) echo "TERMINUS (EMIT): route by class — field harness → Full-Harness Mode (auto_project_mapping.md §6);"
+        echo "                 FH-internal utility → New-Skill Pre-Commit gate + asset-placement-gate." ;;
+  PARTIAL-EMIT) echo "TERMINUS (PARTIAL-EMIT): the standing candidate is killed; fold the surviving sliver into an"
+                echo "                 existing asset / the skeleton (no new asset). Workspace stays as evidence." ;;
+  KILL) echo "TERMINUS (KILL): first-class success — a cheap run prevented a speculative/reinvention build."
+        echo "                 No emit. Workspace stays as the evidence record; seen-filter will skip re-listing it." ;;
+esac
+echo "chamber run '$SLUG' COMPLETE (STATUS: step-7-done, verdict $VERDICT)."
+exit 0