@chrono-meta/fh-gate 1.4.40 → 1.4.42

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

@@ -0,0 +1,172 @@
+---
+name: persona-container-schema
+description: Canonical schema for synthesizing a simulation persona from a reusable container. sim-conductor and any persona-dispatch skill fill these slots instead of injecting an ad-hoc role directive. Defines the slots, crowd-scale stop rule, multi-LLM tier distribution, the situation→group→skill dispatch binding (folded skill-container), and the synthesize→validate→graduate lifecycle.
+type: reference
+scope: meta-harness
+---
+
+# Persona Container — Canonical Schema
+
+> **The gap this fills** (verified 2026-06-20): FH had no persona-*definition* container. `sim-conductor`
+> *conducts* — it profiles a target, derives a needed perspective, then sources a persona (installed
+> agent → an undefined "built-in fallback palette" injected as an ad-hoc prompt directive →
+> plugin-recommender). There was no reusable *container* that holds a persona's internal logic +
+> external-data wiring. This schema is that container. It does **not** replace sim-conductor (the
+> runner); it is what sim-conductor (and any persona-dispatch skill) **fills** instead of an ad-hoc
+> directive.
+>
+> **Consumer status**: sim-conductor extension **SHIPPED 2026-06-20** (same session as this schema) —
+> Persona Discovery ② now fills these 6 slots instead of an ad-hoc directive; §Scale gained the Crowd
+> tier (16-cap lifted behind the marginal-coverage stop) + cost-tier routing; Step 5 adds the graduate
+> step with the admission test below. The A4 clocked write-off trigger is therefore **resolved** — this
+> doc has a live consumer.
+>
+> **Orthogonal to `tpa_schema.md`** (foreseeable-collision note): TPA profiles the **target** (what is
+> reviewed → which gates fire); this profiles the **persona** (who reviews). TPA's profile *drives*
+> which personas to synthesize — they pair, they do not overlap (zero shared fields).
+
+## The container — 6 slots
+
+A synthesized persona is a filled instance of these slots. (Empirically used 2026-06-20 to synthesize
+blind `newcomer` / `red-team` / `vulnerable-user` personas that found a real grounding bug a
+design-aware inline pass missed.)
+
+| Slot | What it holds | Why it is a slot (not free text) |
+|---|---|---|
+| **lens / identity** | who the outsider is (non-tech newcomer · adversarial red-team · domain expert · vulnerable user) | the standpoint; parallax depth comes from the shift *between* standpoints |
+| **internal logic** | what they probe / attack / get stuck on (the persona's decision rules) | makes the reaction reproducible, not vibes |
+| **external grounding** | the real artifact files the persona MUST read + (optional) external-search queries that ground the persona in real data | a persona ungrounded in the artifact hallucinates; cheap bounded grounding keeps it economical |
+| **output protocol** | **reuses sim-conductor Step 1.5 parallax shape** (single source — do not re-spec here; it already defines Strengths / Concerns / Open-questions / Absence-check) | one shape across all personas → cross-persona agreement is meaningful (`[[multi-persona-review]]`) |
+| **cost tier** | which model runs this persona (floor-local · heavy-local · frontier) | the economy lever — see §Multi-LLM tier distribution |
+| **lifecycle** | synthesized · validated · graduated (see §Lifecycle) | most personas stay ephemeral; only proven ones graduate |
+
+**Isolation invariant**: a synthesized persona dispatches as an **isolated** agent (no main-session
+context inherited). Isolation is the FH mechanism that keeps a blind reaction honest — a `newcomer`
+that knows the design intent is not a newcomer. (2026-06-20: the blind-container personas found
+UNNAMED bugs precisely because the inline, design-aware pass was contaminated.)
+
+## Crowd scale + the marginal-coverage stop (anti-decorative)
+
+The container scales from a few personas to a crowd, but **crowd size is output-driven, never a
+target** — there is no persona-count goal, and naming a headline capacity number is itself the
+decorative over-generation steel-quench Wave-1 angle #1 attacks. Two rules bound the crowd:
+
+- **Decorrelation**: add a persona only if it is *distinct* (a different viewpoint, OR — at scale —
+  a different model family) from the ones already running. A crowd's value is breadth of distinct
+  viewpoints, never headcount.
+- **Marginal-coverage stop**: stop adding personas when the marginal new-finding rate → 0. Crowd size
+  is *measured against findings*, never a fixed number.
+
+(Platform sub-agent ceilings — recent runtimes allow large fan-outs — are a *capacity* fact, relevant
+only as the upper bound the marginal-coverage stop operates well below; they are not a usage target.)
+
+## Multi-LLM tier distribution (the economy lever)
+
+The `cost tier` slot lets a crowd be distributed across model tiers so breadth is cheap and the verdict
+stays trustworthy. **One probe, not a benchmark** (the-bible truncation-inversion, 2026-06-20, N=1 —
+a single task, a single model trio, one run):
+
+| Tier | Example | Role | What the one probe showed |
+|---|---|---|---|
+| **floor-local** | `gemma4:e2b` (MacBook) | cheap breadth / obvious-signal filtering | caught obvious oblique-distress, **MISSED** the subtle truncation-inversion |
+| **heavy-local** | `qwen3:32b` (4090) | stronger decorrelation canary | **CAUGHT** the subtle case with correct reasoning ("fool's heart, not authoritative") |
+| **frontier** | Claude (Opus/Sonnet) | terminal verdict | the blind red-team that originally found the bug |
+
+**What this one signal supports — and what it does NOT**: it is a single data point that a 27–32B tier
+*may* clear adversarial reasoning a floor model cannot — enough to justify the floor-local-as-cheap-
+breadth / heavy-local-as-stronger-canary split. It is **not** a measured equivalence to frontier, and
+the heavy-local tier is **never promoted to a gate** on this basis: **the terminal verdict always
+stays frontier** — local tiers are canaries (decorrelation), not gates. (Consistent with
+`[[feedback_judge_robustness_mechanical_anchor]]` and the "Local AI is not Opus" finding — a stronger
+local model lowers the cost of *breadth*, it does not move the *verdict*.)
+
+## Dispatch — situation → group → skill (folded skill-container)
+
+`[[asset-placement-gate]]` routed a proposed standalone **skill-container** here (2026-06-20): FH 4-criteria
+**FAIL on ④ overlap** — the GROUP axis is derivable from existing slots and dispatch-planning overlaps
+`[[agent-composer]]`, so it does not earn a standalone asset (the same anti-decorative fold as §Sibling's
+skill-foundry). The one net-new sliver — the **runtime situation→group→skill binding** — folds here.
+
+**Group = personas sharing a capability-class**, read mechanically off existing slots (NOT a new taxonomy):
+
+| Group | derived from slot | bound skill (the dispatch target) | tier-floor |
+|---|---|---|---|
+| Relay | output-protocol = quote-only | verified-corpus quote (fail-closed) | any |
+| Lens / counsel | external-grounding = active | framed reflection + search-synthesize | frontier for the synthesis step |
+| Adversary | lifecycle = ephemeral, paired | quench / failure-mode generation | local OK (generation task-class) |
+| Guardian | output-protocol = verdict | classify-and-block (L2 semantic) | local screen → **frontier on the subtle class** |
+
+**Dispatch rule**: classify the incoming situation → route to its group → invoke that group's bound skill.
+The binding carries a **tier-floor per group**, not one global model — consistent with §Multi-LLM above.
+
+**Guardian tier-floor is measured** (the-bible red-team dogfood, 2026-06-20, signal in the companion store):
+on CLEAR keyword-evasion the local L2 (qwen3:32b) caught **11/11**, but on the SUBTLE/borderline class it
+collapsed to **1/4** while Gemini-3.5-Flash got 3/4 and GPT-5 / Opus-4.6 got 4/4 (0 false-positives
+across all). So the Guardian binding is *local-screen-then-frontier*: cheap local clears the easy class,
+the subtle residual needs frontier (and ultimately L3 human, per the L2-imperfect residual). A second probe
+reinforcing §Multi-LLM's single truncation-inversion point, same direction — local lowers the cost of
+breadth, frontier keeps the verdict on the cases that matter.
+
+**Done When** (skeleton — fold scope only): (1) each group is derivable from a slot, no new taxonomy
+*[mandatory-pass]* · (2) each group names exactly one bound skill *[mandatory-pass]* · (3) a tier-floor is
+stated, measured where claimed *[judged, pair: target-tier sim]*.
+
+## Lifecycle — synthesize → simulate → validate → graduate
+
+```
+synthesize (fill the container)  →  simulate (dispatch isolated, collect parallax output)
+   →  validate (findings triaged M/S/R)
+   →  graduate (ONLY a persona that PASSES the admission test below is embedded in the project's
+                static set, e.g. the-bible's core/personas.json) — most personas never graduate;
+                the throwaway run still accelerated the work.
+```
+
+**Graduation admission test** (mechanical — closes the judge-only path; a "proven" persona is not a vibe):
+
+- **measured**: the persona surfaced **≥1 unique S/M finding** (a finding no other persona in the run
+  produced) across **≥2 distinct targets** — recurrence, not a one-off. A persona that fired once is a
+  lucky throwaway, not a graduate.
+- **mandatory-pass**: if graduating into a *skill* (not just a project's persona set), it additionally
+  clears the **FH 6-item creation gate** (the skill-foundry inversion below — the trust bar for a
+  governance asset is non-negotiable).
+
+Graduation is **optional and rare** — the analogue of "app-ification": a persona earns a permanent
+home only when it repeatedly proves itself. The cheap, dynamic, mostly-discarded synthesis is the
+point (cost-efficiency > build-and-demolish).
+
+## How a runner consumes this (sim-conductor extension — shipped 2026-06-20)
+
+`sim-conductor` is the runner that **fills** these slots instead of injecting an ad-hoc role directive.
+The shipped extension (through the FH 4-axis gate, HITL): sim-conductor's Persona Discovery ② reads this
+schema and fills the 6 slots; §Scale lifts its 3–16 cap behind the marginal-coverage stop (Crowd tier)
+and assigns `cost tier` per persona for multi-LLM distribution; Step 5 adds the graduate step. Routing
+decided by `[[asset-placement-gate]]` (2026-06-20): **not a new forked skill** (≈60–70% overlap with
+sim-conductor's runner role) — this schema is the net-new asset, sim-conductor is extended to consume it.
+
+## Sibling — skill-foundry (terminal-before-appification)
+
+The same lifecycle generalizes to **skills**, with one inversion that is the whole point: a persona is a
+low-trust simulation lens (ephemeral-and-many is the value); a skill is a governance asset whose value is
+being **trusted**. A persona's low trust bar is harmless (a wrong lens is a discarded run); a skill's is
+dangerous (a wrong instruction is trusted and reused). So a synthesized ("terminal-stage") skill is
+explicitly **provisional / ungated / unpublished** — its SKILL.md is marked `lifecycle: provisional` with
+an "ungated, in-session use only" banner so it cannot masquerade as a gate-passed skill.
+
+**Provisional convention** (salience-dependent, NOT hook-enforced — no checker scans `lifecycle:` today;
+it is a discipline, not a mechanical control): (1) used in the authoring session only — **not committed to
+a shared plugin or marketplace before graduation**; (2) **deleted if it never graduates** —
+build-and-keep-forever is the anti-pattern (the cheap-and-discarded discipline is the value); (3)
+**graduates only through the FH 6-item creation gate** (CLAUDE.md §New Skill Creation Pre-Commit Gate) +
+`[[asset-placement-gate]]` routing — HITL, never auto. Authoring reuses `contention-layer` Step-4's
+skeleton (`origin: skill-foundry`; drop/replace `contention-parents` with a `source-action:` pointer,
+mirroring that skeleton's field-scaffold reuse note). (Illustrative — *not* a committed artifact: a
+`persona-safety-sweep` provisional skill kept local/gitignored, graduation-target = a sim-conductor preset.)
+
+## Provenance
+
+Validated end-to-end on the `the-bible` project 2026-06-20: container-filled blind personas found a
+real substring-truncation grounding bypass; the multi-LLM tier comparison (e2b miss / 32B catch /
+frontier verdict) grounded the cost-tier slot. Operator-origin concept; `[[asset-placement-gate]]`
+routed it (schema here + sim-conductor extension + thin skill-foundry convention). Related:
+`[[multi-persona-review]]` (the output-protocol architecture this builds on) · `tpa_schema.md` (the
+target-profile schema sim-conductor pairs with this).

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

@@ -0,0 +1,120 @@
+---
+name: return-path-gate
+description: Skill chain pattern where a downstream skill returns a structured conditional verdict back to its caller, which gates its next step on that verdict. Prevents fire-and-forget chains and closes the feedback loop.
+type: pattern
+date: 2026-05-29
+tags: [pattern, skill-chain, verdict, conditional-pass, closed-loop]
+instances:
+  - apex-review → sim-conductor
+  - agent-composer ↔ deliberation
+---
+
+# Return-Path Gate — Closed-Loop Skill Chain Pattern
+
+A skill chain is **closed** when the downstream skill's output feeds back into the upstream caller's decision logic. Without a return path, downstream calls are fire-and-forget: the caller can't act on results, conditions go unresolved, and the chain terminates with unverified state.
+
+The Return-Path Gate enforces closure: the caller registers a verdict expectation before calling downstream, the downstream returns a structured verdict, and the caller gates its next step on that verdict.
+
+---
+
+## Structure
+
+```
+[Caller Skill]
+  Step N: Detect trigger condition
+  Step N+1: Dispatch → [Callee Skill] (with topic + context)
+  Step N+2: ◀ WAIT for verdict ▶
+  Step N+3: Gate on verdict
+    PASS           → proceed normally
+    CONDITIONAL    → resolve listed conditions before proceeding
+    FAIL/ESCALATE  → block + surface to user
+
+[Callee Skill]
+  Processes topic
+  Returns structured verdict (not a binary win/lose)
+  ↓
+[Caller] receives verdict → re-enters decision logic
+```
+
+---
+
+## Verdict Format (standard)
+
+```
+Verdict: PASS | CONDITIONAL_PASS | FAIL | ESCALATE
+Conditions: [list — only present when CONDITIONAL_PASS]
+Basis: [one-line rationale]
+```
+
+- **PASS** — proceed without modification
+- **CONDITIONAL_PASS** — proceed only after listed conditions are addressed; conditions must be explicitly resolved, not silently skipped
+- **FAIL** — block; requires redesign before proceeding
+- **ESCALATE** — surface to user; decision requires human judgment
+
+---
+
+## Verified Instances
+
+### 1. apex-review → sim-conductor
+
+**Caller**: `apex-review`
+**Callee**: `sim-conductor` (Area E — external scenario validation)
+
+**Trigger**: apex-review produces `Conditionally passed` verdict
+**Return path**: sim-conductor Area E results fold back into the apex-review HTML deck
+**Gate logic**:
+- `Passed` → deck is submission-ready
+- `Conditionally passed` → **mandatory sim-conductor dispatch** (option B is default; user must explicitly opt out)
+- `Rejected` → redesign required
+
+**Why it matters**: Without this gate, persona conditions from apex-review are listed but never verified. sim-conductor's challenger/beginner/main-player validation is the only mechanism that resolves them.
+
+---
+
+### 2. agent-composer ↔ deliberation
+
+**Caller**: `agent-composer` (Step 4-b state transition)
+**Callee**: `deliberation` (3-layer: Innovator → Devil → Mediator)
+
+**Trigger**: 2+ conflicting suggestions or design decision conflict detected in fan-in results → `Wave next-D`
+**Return path**: deliberation synthesis verdict folds back into agent-composer Step 4-b fan-in result set → conflict marked resolved → state transition re-runs
+**Gate logic**:
+- Synthesis verdict (conditional, not binary) replaces the conflict entry
+- Step 4-b re-evaluates with conflict resolved
+- Auto-execution forbidden — user decision finalizes
+
+**Why it matters**: Without the return fold, deliberation output is displayed to the user but the agent-composer orchestration loop doesn't update — the conflict remains unresolved in the state machine.
+
+---
+
+## Anti-Pattern: Fire-and-Forget
+
+```
+[Caller] → [Callee]
+              ↓
+         outputs result (displayed to user)
+              ↓
+         [Caller continues independently — does not act on result]
+```
+
+This is the default failure mode when a skill chain has no return path defined. Symptoms:
+- Downstream output is shown but not acted on
+- Conditions listed by callee remain unverified
+- Caller proceeds as if callee succeeded unconditionally
+
+---
+
+## Implementation Checklist (when adding a Return-Path Gate to a skill)
+
+- [ ] Caller SKILL.md: `§Done When` — explicitly states "wait for callee verdict before proceeding"
+- [ ] Callee SKILL.md: `§Done When` — outputs structured verdict (PASS / CONDITIONAL_PASS / FAIL / ESCALATE)
+- [ ] Callee SKILL.md: `§Chains` — "returns verdict to `[caller]`"
+- [ ] Caller SKILL.md: `§Chains` — "→ Mandatory next (`[callee]`) when [condition]; verdict folds back into [step]"
+- [ ] CONDITIONAL_PASS gate: default path is resolution, not bypass
+
+---
+
+## Relation to Other Patterns
+
+- **Three-Doctor Loop** (`harness-doctor ↔ context-doctor ↔ sim-conductor`) uses return paths implicitly — each doctor's output triggers the next. A full Return-Path Gate implementation would make the fold-back explicit.
+- **verify-bidirectional** is a single-depth return path: AI recommendation → user counter-argument → AI baseline update. The verdict here is implicit (user correction = FAIL signal).

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

@@ -0,0 +1,268 @@
+# Self-Evolution Routine — Remote Daily/Weekly Innovator Loop
+
+> **What this is**: a paste-ready Claude Code **Routines** configuration that runs `frontier-digest` +
+> `persona-innovator` on a remote schedule, accumulating frontier signals daily and proposing one
+> concrete FH improvement weekly — **as a draft PR for human merge, never auto-merge**.
+>
+> **Governance stance (proposal-type, HITL-preserving)**: the routine *runs* autonomously; the
+> decision to *adopt* an improvement stays with the operator. This keeps the
+> `feedback_no_personal_commit_to_shared_repo` spine intact even though Routine sessions execute with
+> no approval prompts. See §3.
+
+## 1. Why a routine (and why this shape)
+
+Claude Code on the web supports **Routines** (`code.claude.com/docs/en/routines.md`): a saved
+prompt + repo + connectors that runs automatically on a **schedule** (≥1h interval), a **GitHub
+event**, or an **HTTP API** call. Each run is a fresh, ephemeral cloud session — no local state
+survives, the container is reclaimed, and by default it may only push to `claude/`-prefixed branches.
+
+Three platform facts shape the design below:
+
+| Platform fact | Consequence for this loop |
+|---|---|
+| Runs are **ephemeral** (fresh clone each time) | Cross-run memory cannot live in the working tree — it lives on **GitHub** (issue comments / draft PR). |
+| `tracks/**` is **gitignored** (public mirror = methodology only) | Daily digests **must not** be committed to `tracks/_meta/` — they would be dropped by git and lost on reclaim. Durable store = a standing GitHub Issue. |
+| Routine sessions run with **no approval prompts** | "Self-improvement" must be **gated by a draft PR**, not auto-merged — the human merge IS the HITL gate. |
+
+## 2. Architecture — Daily scan, Weekly propose
+
+```
+[Daily Routine]  (schedule: daily, model: sonnet)
+  frontier-digest autonomous collection (HN + arxiv; operator-intake arm skipped — no human in loop)
+    → 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)
+  ① 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)
+  ④ install + run the FH 4-axis gate on the change (see §4)
+  ⑤ commit to a fresh  claude/frontier-auto-{YYYY-MM-DD}  branch → open a **DRAFT PR**
+  ⑥ STOP.  The operator reviews and merges.   ← HITL gate
+```
+
+**Why the daily/weekly split** (not "daily full"): FH's own cadence is 7-day for `frontier-digest`
+and event-bound for `persona-innovator` — a daily full synthesis would tax tokens and risk
+decorative-unit over-generation (the exact failure `steel-quench` Wave-1 #1 attacks). Daily =
+cheap signal accumulation; weekly = one considered proposal.
+
+## 3. Governance guards (do not weaken)
+
+- **Draft PR only — never merge.** The weekly routine opens a *draft* PR and stops. Auto-merge would
+  bypass `feedback_no_personal_commit_to_shared_repo`.
+- **One proposal per week, or none.** "No proposal this week" is a valid, preferred outcome over a
+  forced low-value change. Promotion of `persona-innovator` itself is *measured* (accepted ≥ 60% gate,
+  `operations.md`) — the draft-PR accept/reject history IS that pilot data.
+- **`claude/` branch prefix only.** Do not enable "unrestricted branch pushes" for this routine.
+- **Methodology mirror stays clean.** Daily digests live on the GitHub Issue, never in `tracks/**`
+  (gitignored) and never committed to the methodology tree.
+- **Cost ceiling.** Both arms run `WebSearch`/`WebFetch`. Daily draws subscription usage and counts
+  against the per-account routine daily cap; keep the daily prompt to collection-only.
+- **Cite-verify (PR #112 lesson, 2026-06-22) — do not weaken.** Any citation / source / version claim
+  the weekly change *introduces into an FH asset* (distinct from citing the signal URL) must be
+  WebSearch-verified before commit. Unverifiable → omit it or mark `(unverified)`; never ship a
+  plausible-sounding but unchecked citation. **Origin**: a weekly run added a fabricated "O'Reilly AI
+  Agents Stack 2026" citation (+ an over-specific "~32K" threshold) that reached draft PR #112; the
+  merger caught it via WebSearch (real source = Chroma 2025), but **Axis 3 phantom-quench is
+  "if available"** in the routine sandbox, so the prompt must enforce cite-verify directly — the gate
+  cannot be relied on for it.
+
+## 4. The 4-axis gate inside the weekly routine
+
+Because a fresh clone does **not** install the FH pre-commit hook, the weekly routine must install and
+run it before committing an FH-asset change:
+
+```bash
+git config core.hooksPath templates/.git-hooks && chmod +x templates/.git-hooks/pre-commit
+bash templates/regression_guard.sh --pr "$(git branch --show-current)"   # Axis 1
+# Axis 2 steel-quench + Axis 3 phantom-quench → write tracks/_meta/.axes_23_passed_{branch}_{date}.marker
+# 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`.)
+
+**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
+`tracks/**` and are **never committed** — the hook reads them from the **working tree**, which
+persists for the duration of the run. The §3 "no `tracks/**`" guard is about *committing the digest*,
+not these working-tree gate markers.
+
+If `steel-quench`/`phantom-quench` are unavailable in the routine session, note
+`Axis N: skipped (skill unavailable)` — Axis 1 PASS alone unblocks a *draft* PR (Axes 2–3 are the
+operator's residual at merge review).
+
+**Skip-visibility at the handoff (load-bearing for honest HITL escalation).** When Axis 2
+(challenger / steel-quench) is skipped, the adversarial check did not run autonomously — it becomes
+the *merger's* responsibility. An intelligent hand-off must make that visible at the hand-off point,
+not bury it. So the draft PR opened by the weekly routine MUST carry a top-of-body label whenever
+Axis 2 was skipped: `⚠️ Axis 2 (adversarial/challenger) NOT RUN this routine — adversarial review is
+the merger's before merge.` A silent skip turns the draft PR into an unchallenged proposal wearing a
+"gate passed" coat; the label keeps the escalation honest. (Axis 2 *passing* needs no such label — the
+marker already records `axis2-engine`/`axis2-evidence`.)
+
+**Merge-side citation residual (auto-PR cite floor — 2026-06-22 harvest-loop).** §3's cite-verify is
+the *generator-side* half; this is the *merger-side* redundancy. Because the routine sandbox runs
+phantom-quench only "if available" (line above) and **no CI job runs phantom-quench at the merge
+boundary** (the merge-time mechanical gates are `regression-guard.yml` Axis 1 + `validate.yml`
+token/JSON/count only), the citation check on an auto-authored (`claude/`-branch) PR is the **merger's
+explicit, non-skippable residual** — not a mechanical gate. *Honest scope: this is judged prose, not a
+CI check.* Obligation: before merging any auto-authored PR that **adds a citation / URL / version
+claim**, run phantom-quench on that citation surface (or WebSearch-verify it directly); a fabricated
+citation reaching `main` is the failure this closes (origin: PR #112's "O'Reilly AI Agents Stack 2026"
+phantom — the human merger was the only catch).
+
+> **Measured-trigger → CI escalation (do not build the CI gate speculatively).** One occurrence (PR
+> #112) is N=1, below `operations.md`'s N=3 recurrence threshold for instrumenting a defect class as a
+> CI probe. So the fix today is the prose residual above, **not** a workflow. **If an auto-PR phantom
+> citation recurs (N≥2 toward N=3)**, escalate to a real mechanical gate: a CI job (extend
+> `validate.yml` or a new workflow) that greps `claude/`-branch PR diffs for added citation tokens and
+> **fails** unless phantom-quench evidence is attached. Until that recurrence is measured, a prose
+> checklist is the right weight — calling it "mechanical" now would be the gate-locality error in
+> reverse (a decorative gate nobody's traffic justifies). See `[[measurement-integrity-checklist]]` for
+> the sibling "instrument-before-trusting" discipline.
+
+## 5. Setup steps (operator, one-time)
+
+1. **Standing issue** — create one GitHub issue in `chrono-meta/forge-harness` titled
+   `🛰️ Frontier Digest Log`, label `frontier-digest`. (Can be auto-created; see §6.) This is the
+   durable daily store.
+2. **Daily Routine** — at `claude.ai/code/routines` → New routine:
+   - Repo: `chrono-meta/forge-harness`
+   - Schedule: daily (pick a low-traffic hour)
+   - Model: sonnet
+   - Prompt: paste **§7 Daily prompt** (replace every `{ISSUE}` with the issue number from step 1 before saving)
+3. **Weekly Routine** — New routine:
+   - Repo: `chrono-meta/forge-harness`
+   - Schedule: weekly
+   - Model: **opus (required — see §4 floor note; a Sonnet weekly run cannot pass the commit gate)**
+   - Prompt: paste **§7 Weekly prompt**
+   - **Before saving**: replace every `{ISSUE}` in the prompt with the actual issue number from step 1.
+4. **Network policy**: default "Trusted" allows HN/arxiv/web search. No change needed unless you add
+   walled sources.
+5. **Connectors**: keep the GitHub connector; remove others to reduce surface.
+
+## 6. Auto-bootstrap (optional)
+
+The standing issue can be created from a normal session in FH cwd via the GitHub MCP tools (issue
+title `🛰️ Frontier Digest Log`, body = "Daily frontier-digest comments accumulate here; the weekly
+routine reads the last 7 days."). The two Routines themselves must be created in the web UI — there is
+no documented API to define a routine from inside a session (only to *fire* an existing one).
+
+## 7. Paste-ready routine prompts
+
+> These are **self-contained** — a fresh Routine session sees no prior context. Each restates its full
+> task. `{ISSUE}` = the "🛰️ Frontier Digest Log" issue number.
+
+### 7-a. Daily prompt
+
+```
+You are the FH self-evolution DAILY scan, running as an autonomous Claude Code routine in a fresh
+clone of chrono-meta/forge-harness. There is no human in the loop and no prior context.
+
+Task — collect, do NOT modify the repo:
+1. Read plugins/fh-meta/skills/frontier-digest/SKILL.md and run its AUTONOMOUS collection arm only
+   (HackerNews + arxiv). Let SKILL.md Step 0 resolve the engine itself — it prefers the /deep-research
+   built-in (Priority 0: staged gather + cross-check + cited synthesis) if it is in this session's
+   skill list, then ANTHROPIC_API_KEY/Sonnet, then plain WebSearch. Do not force an engine. SKIP the
+   Step 0.5 operator-intake question — there is no operator online.
+2. In this sandbox expect WebSearch mode (no ANTHROPIC_API_KEY, so the SKILL's API-synthesis arm is
+   unavailable) — YOU, the session model, do the synthesis in-context from the WebSearch results.
+   Produce a short digest: 3–6 bullets of frontier signals relevant to FH skills/structure, each with
+   a source URL and a one-line "relevance to FH" note.
+3. Post the digest as a COMMENT on issue #{ISSUE} ("🛰️ Frontier Digest Log") using the GitHub tools.
+   Title the comment with today's date.
+4. Do NOT commit, do NOT push, do NOT open a PR. Daily is collection-only.
+Stop after posting the comment.
+```
+
+### 7-b. Weekly prompt
+
+```
+You are the FH self-evolution WEEKLY proposer, running as an autonomous Claude Code routine in a fresh
+clone of chrono-meta/forge-harness. No human is online during the run. Your output is a DRAFT PR for
+later human review — you must NOT merge anything.
+
+Task:
+1. Read the last 7 days of comments on issue #{ISSUE} ("🛰️ Frontier Digest Log") via the GitHub tools.
+   These are the week's accumulated frontier signals.
+2. Dispatch the persona-innovator agent (plugins/fh-meta/agents/persona-innovator.md) in Mode F
+   (gap + external-frontier scan) against the current FH assets and those signals. If sub-agent
+   dispatch is unavailable in this runtime, run it INLINE: read the agent file and execute its Mode F
+   steps in this session.
+3. Select AT MOST ONE concrete, well-scoped FH improvement. THE BAR: the candidate must name a
+   SPECIFIC FH asset (file + section) AND cite a SPECIFIC signal URL from this week's issue comments.
+   If you cannot cite both, post a comment on #{ISSUE} saying "No proposal this week — signals logged"
+   and STOP. A no-op week is the PREFERRED outcome when the bar isn't met (it is also pilot data: it
+   shows the bar holds). A forced low-value PR costs the operator a review and erodes trust — when in
+   doubt, no-op.
+4. If you have one improvement, implement it minimally on a NEW branch named
+   claude/frontier-auto-<today's date>.
+   **CITE-VERIFY (mandatory — distinct from step 3's signal URL):** if your change introduces ANY
+   citation, source name, version, benchmark number, or "per <source> <year>" claim INTO an FH asset,
+   WebSearch-verify it FIRST. If you cannot confirm the exact source, OMIT it or write "(unverified)" —
+   never ship a plausible-but-unchecked citation. A fabricated citation in an FH asset is a phantom;
+   Axis 3 (phantom-quench) may be skipped in this sandbox, so this step does NOT depend on the gate.
+   (This guard exists because a prior run shipped a fabricated "O'Reilly AI Agents Stack 2026" cite to
+   PR #112 — real source was Chroma 2025.)
+5. Run the FH 4-axis gate before committing:
+   - git config core.hooksPath templates/.git-hooks && chmod +x templates/.git-hooks/pre-commit
+   - bash templates/regression_guard.sh --pr "$(git branch --show-current)"   (Axis 1, must PASS)
+   - Axis 2 steel-quench + Axis 3 phantom-quench if available → write the
+     tracks/_meta/.axes_23_passed_<branch>_<date>.marker with fields axis2-engine / axis2-model /
+     floor-status / axis2-evidence. If a skill is unavailable, note "skipped (skill unavailable)".
+   - Axis 4: append a one-line predicted-impact entry to tracks/_meta/edit_manifest.yaml.
+6. Commit (the hook enforces the gate), push the claude/frontier-auto-* branch, and open a DRAFT pull
+   request titled "frontier-auto: <one-line summary>" describing the signal it came from and the
+   predicted impact. IF Axis 2 (challenger/steel-quench) was skipped (skill unavailable), the FIRST
+   line of the PR body MUST be: "⚠️ Axis 2 (adversarial/challenger) NOT RUN — adversarial review is
+   the merger's." Do not bury the skip — the merger has to know the proposal is unchallenged.
+7. Do NOT mark the PR ready, do NOT merge. STOP after opening the draft PR.
+```
+
+## 8. Field-project adoption — any user, any project
+
+The loop is **not FH-only**. Anyone accelerating their own project — or the operator on any mapped field
+project — can adopt the same shape. Only **two things are FH-specific and must be swapped**; the rest
+is project-agnostic.
+
+| Layer | FH (this doc) | Field-project version |
+|---|---|---|
+| Daily scan lens | "frontier signals relevant to FH skills/structure" | "...relevant to **{project}'s domain/stack**" |
+| Durable daily store | `🛰️ Frontier Digest Log` issue in `forge-harness` | same pattern, an issue in the **project's own repo** |
+| Weekly verification gate | **FH 4-axis gate** (hub-internal hook — hard-codes hub paths/markers) | **the project's OWN gate** — NOT the FH hook (per `auto_project_mapping.md §6`, the FH gate is deliberately not installed into projects; it would block the project's commits). A project supplies its own: its test suite + lint + whatever quality gate it trusts |
+| HITL spine | draft PR → operator merge | **identical** — draft PR → owner merge (never auto-merge) |
+| Branch | `claude/frontier-auto-*` | **identical** — `claude/`-prefixed |
+
+**The invariant (do not change across projects)**: daily = cheap signal accumulation to a GitHub
+issue; weekly = at most one scoped proposal as a **draft PR**, gated by *whatever verification that
+project trusts*, merged by a human. Substitute the lens + the gate; keep the ephemeral-safe GitHub
+store and the draft-PR HITL.
+
+**For a field project**: the weekly proposer's gate is the project's own — run the project's test
+suite and its own quality gate instead of the FH marker/hook, and the model floor concern (§4) does
+**not** apply (no FH marker = no `floor-status` cross-check), so a field project's weekly routine can
+run on sonnet. Open the draft PR against the project repo's `claude/` branch.
+
+**Propagation path**: this pattern can ride **Full-Harness Mode** (`auto_project_mapping.md §6`) as an
+opt-in project-local asset — offered, never auto-installed, owner approves each routine. It is a
+*recommendation surface*, not a daemon dropped into the project.
+
+## 9. Honest limits
+
+- **Research preview**: Routines' limits/API may change; GitHub webhook + daily caps apply.
+- **Salience-dependent**: these prompts are prose the routine session must follow; on a weaker model
+  the gate/draft-only discipline can slip. Mitigation: the prompts restate the hard guards inline, the
+  weekly arm is opus-pinned (§4), and the `claude/`-branch-only default makes an accidental
+  protected-branch write impossible **while that restriction stays on** — do not disable it (§3).
+- **innovator is v0.2** (no pilot data). This loop is the mechanism that *produces* that data via the
+  draft-PR accept/reject record — treat early proposals as candidates, not authority.

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

@@ -0,0 +1,71 @@
+---
+type: measurement
+date: 2026-05-26
+refs:
+  - "arxiv 2605.26112 — From Model Scaling to System Scaling"
+  - "plugins/fh-meta/skills/harvest-loop/SKILL.md"
+  - "plugins/fh-meta/skills/agent-composer/SKILL.md"
+---
+
+# FH Skill Quality Rubric
+
+> Skill maturity score formula definition file.
+> Declaring verifiable / evolution numbers without this file violates the cold audit "self-declaration = delete if no basis" rule.
+
+---
+
+## Verifiable Axis Formula
+
+### Definition
+"The ratio at which the result of executing a skill can be independently reproduced and verified by an external observer"
+
+### Measurement targets (5 core skills — fixed denominator)
+harness-doctor · verify-bidirectional · hub-cc-pr-reviewer · context-doctor · sim-conductor
+
+### Per-skill scoring criteria
+
+| Condition | Score |
+|---|---|
+| Done When item exists + harvest-loop Step 3.75 Critic isolation judgment linkage stated | 1.0 |
+| Done When item exists + external observer reproducible format (Critic linkage not stated) | 0.75 |
+| Done When item exists + internal self-declaration format only | 0.5 |
+| No Done When | 0.0 |
+
+### Measurement history
+
+| Date | harness-doctor | verify-bidi | hub-cc-pr | context-doctor | sim-conductor | verifiable% | Change content |
+|---|---|---|---|---|---|---|---|
+| 2026-05-26 (pre-implementation) | 0.75 | 0.75 | 0.75 | 0.75 | 0.75 | 75% | Baseline set |
+| **2026-05-26 (post-implementation)** | **0.85** | **0.85** | **0.85** | **0.85** | **0.85** | **85%** | External verification path + Critic linkage stated complete |
+
+**Current verifiable% = 85%** ✅ (target 80%+ achieved)
+
+---
+
+## Evolution Axis Formula
+
+### Definition
+"The ratio of the harness's capacity to observe real usage data and automatically update parameters"
+
+### 5 core element checklist (20% each)
+
+| Element | Status | Basis |
+|---|---|---|
+| harvest-loop pipeline exists | ✅ | 8-step pipeline complete |
+| Harness Evolution Cadence 4-week cycle | ✅ | Step 6-b newly added (2026-05-26 `f13d3a4`) |
+| fh_signal accumulation mechanism | ✅ | `tracks/_meta/fh_signal_*.md` |
+| Real usage data auto-aggregation → Leaderboard update | ✅ | Step 6-b fh_signal grep executed / skill_usage.md updated (2026-05-26) |
+| escalate_when auto-update loop connection | ❌ | Candidate output then human approval only, no data feedback |
+
+**evolution% history**:
+- Pre-implementation: 60% (3/5)
+- After Step 6-b mechanism definition: 70% (3.5/5)
+- **fh_signal auto-aggregation + skill_usage.md update complete: 80%** ✅ (4/5)
+
+---
+
+## Update Rules
+
+- Recalculate denominator (5 core skills) when skills are added or removed
+- Re-measure once per quarter — auto-proposed at harvest-loop forced mode session end
+- Measurement executor: runs as part of harvest-loop Step 6-b Cadence execution