steer-heal-love/spec.md

spec: steer_heal

Distil an activation steering vector into a LoRA, "heal" the incoherency the vector injects by regularising training toward the original model (KL or weight decay), then loop and watch the trait grow while coherence holds.

Hypothesis

Training a student on steered-teacher completions transmits the trait (this is established by the Subliminal Learning paper below). The new bet: a coherence regulariser anchored to the original model heals the incoherency the steering vector leaks into the completions, so we get the trait without the babble, and the loop compounds the trait while staying coherent.

Crux: KL-to-original penalises all drift, trait shift included. The bet is incoherency drift is large and erratic (low probability under the original model) while the trait shift is small and systematic, so the regulariser kills incoherency preferentially. Reverse KL is mode-seeking and should suppress exactly the low-base-probability tokens that read as incoherent, so I expect kl_rev to heal best. If the bet is wrong, we trade trait strength for coherence and get no net win over plain SFT at matched coherence.

Related work and tools (with links)

Building blocks, all yours unless noted:

• Paper we build on: Blank, Bhatia, Rajamanoharan, Conmy, Nanda, "Subliminal Learning Is Steering Vector Distillation", arXiv:2606.00995 — https://arxiv.org/abs/2606.00995 (HTML mirror: https://r.jina.ai/https://arxiv.org/html/2606.00995v1). Shows subliminal learning is mediated by a single steering vector: a trait system prompt is approximated by a steering vector, and a student trained on the steered teacher's outputs learns an aligned vector. They use one direction (neutral to trait), single completions, and do not measure or heal incoherency.
• steering-lite — https://github.com/wassname/steering-lite. Mean-diff steering vector extraction and hook-based application. v = Vector.train(model, tok, pos, neg, MeanDiffC(...)).calibrate(model, tok, target_kl=1.0); apply with with v(model, C=...): model.generate(...). Vector is L2-normalised per layer; application is h + coeff * v broadcast over positions (no norm-matching).
• isokl_steering_calibration — https://github.com/wassname/isokl_steering_calibration. iso-KL calibration: bisects the coefficient until p95 per-token KL(steered||base) hits a target (default 1 nat), giving a deterministic dose c_star. Then sweep alpha = c_star * [0.5, 1, 1.5, 2]. Pairs KL with an "alive" coherence check (force a JSON boolean prefill, require >=0.75 mass on true/false), which is the same idea as tinymfv p_ans_any. Reports a cumulative coherence budget of ~1.7 nats across iterated rounds, directly relevant to our loop.
• lora-lite — https://github.com/wassname/lora-lite. Hackable LoRA via forward hooks; base frozen, loss fully under our control (no built-in KL, we add it). Caveat: no merge/unmerge and one adapter per attach, so we do not "bake in" between rounds. Resolution: w2schar-mini's gated-history baking (below).
• w2schar-mini — https://github.com/wassname/w2schar-mini. Conditioned LoRA (scalar gate c) in an iterated distillation loop, the closest prior setup to ours. csm.ws.bake.baked composes N gated adapters into the weights (W += sum_i c_i*(alpha_i/r_i)*B_i A_i) and restores on exit; csm.ws.history.load_base_with_history gates history off at c=0 so the base stays pristine. Reuse ModulatedLoRA + baked for the accumulator and the C_0=C_N=0 KL anchor, and port csm/plot.py _build_scatter (plotly Care-vs-Authority scatter, one node per round, to_html) for our loop map. Not a dependency: it needs py3.13 and pins flash-attn, so we vendor it and copy the modules.

All four are cloned into docs/vendor (gitignored, just vendor to reclone); the lighter three are editable path deps.

• tinymfv — https://github.com/wassname/tinymfv. Eval on the moral-foundations auth vs care axis, plus coherence metrics p_ans_any (best), json_is_valid, ppx_json.
• Related, for positioning: Fierro and Roger, "Steering Language Models with Weight Arithmetic", arXiv:2511.05408 — https://arxiv.org/abs/2511.05408, code https://github.com/safety-research/weight-steering. Weight steering edits weights directly using the difference between two fine-tuned models. No coherence measurement, no KL, no iteration.

How we differ (note this where we cite each):

• vs weight steering: weight steering generates completions from a prompt prefix, not a steering vector, and takes its direction from two adapters (the difference is the vector). We take the direction from an activation steering vector, then heal with one adapter.
• vs Subliminal Learning: same steering-vector-distillation backbone, but we add a coherence regulariser (KL-to-original or WD) to heal incoherency, measure coherence explicitly (tinymfv), and iterate.

Steering vector extraction (paper's teacher vector)

Per Blank et al.: the teacher vector is the mean shift in the reference model's residual stream induced by a trait system prompt relative to a neutral system prompt, over training prompts D, read at the assistant tag.

v_\text{teacher} = \frac{1}{|D|}\sum_{x \in D}\big[\, h_\text{ref}(s_\text{trait} \oplus x) - h_\text{ref}(s_\text{neutral} \oplus x) \,\big]_{\text{@assistant tag}}

per layer. This is neutral-to-trait (base to pos), not chosen-vs-rejected completions. In steering-lite terms: pos = prompts with the trait system prompt, neg = same prompts with the neutral system prompt, mean-diff, normalised. One difference from steering-lite defaults: read the activation at the assistant tag, not the last non-pad token. Confirm steering-lite can target that position or extend it.

Eval-only (not used in training): the student vector

v_\text{student} = \frac{1}{|D|}\sum_{x \in D}\big[\, h_\text{student}(s_\text{neutral} \oplus x) - h_\text{ref}(s_\text{neutral} \oplus x) \,\big]_{\text{@assistant tag}}

measures how much the trait baked into the weights (it shows up under a neutral prompt now). cos(v_student, v_teacher) is a clean internalisation diagnostic to plot over rounds.

Adaptive steering (coherence dosing)

You asked whether we can steer adaptively to stay coherent, or just sweep C. iso-KL calibration is the adaptive answer and beats a blind sweep: calibrate c_star to a target p95 KL (1 nat), then generate at a few alpha = c_star * [0.5, 1, 1.5, 2]. KL is necessary but not sufficient for coherence (the calibration repo finds dead traces below budget from single-token spikes), so pair the dose with the alive check / p_ans_any and a repetition guard, and stop raising alpha when those degrade. C=0 is the neutral batch we need anyway (for the SFT control and for base-perplexity scoring). No per-token controller needed; the per-trajectory dose plus the gate is enough.

Loss

One objective, one constraint (per CLAUDE.md loss philosophy):

• Objective: SFT cross-entropy on the kept steered completions.
• Constraint: a divergence-to-original barrier, lambda * relu(D - tau), off while we are already within the coherence region so it does not fight the trait for free.

The barrier reference is barrier_ref (config). SETTLED 2026-06-04 (#97, was the original spec call, now reversed): default is prev = the previous round's student, NOT the round-0 original. Anchoring to base (barrier_ref="base") leashes the fresh adapter back toward the origin, and because the baked history already carries the accumulated trait, the relu barrier is permanently active and its gradient OPPOSES that trait, so it UNDOES the prior rounds (the external-review "history erasure" risk, confirmed: nll re-heal dAuth_prev=+1.157, kl_rev/base +0.855 = both erode). prev penalises only THIS round's new divergence (a trust region), so trait accumulates while each step stays coherent. At round 0 the two are identical (no history yet); they differ from round 1 on.

reg is the divergence in the LOSS barrier (the variable under test, U2):

• nll: no barrier, SFT only. The control.
• kl_fwd: KL(ref || theta), mass-covering, pulls theta to cover the reference everywhere, expected to dilute the trait.
• kl_rev: KL(theta || ref), mode-seeking, suppresses tokens improbable under the reference (the incoherent ones).
• spectral_norm: penalise σ_max(ΔW), the operator norm of the adapter update (power iteration, tau=0 = always-on). Weights-space, no reference forward pass. Caps how far the update stretches any single input direction (the largest singular value), where wd caps the whole Frobenius volume.

weight_decay is an INDEPENDENT AdamW knob (decoupled per-step shrink ~ lrwd on the adapter), NOT a reg choice, so it composes with any of the above. Early #98 finding: wd<=15 is byte-identical to the no-reg control (inert at this adapter scale, because Adam normalises the step to ~O(1) and the decay only competes once wd|param| ~ O(1), i.e. wd in the tens); the knee is ~30, where it both retains more trait and holds coherence.

All KLs are teacher-forced from per-position logits over the completion tokens, so no extra sampling. kl_fwd/kl_rev need the reference logits per step: bake the history (ref=prev) or not (ref=base), adapter off, no-grad forward. spectral_norm/nll need neither.

Three uncertainties, each a gate with a UAT

U1: can we filter the incoherent / trait-verbalising completions?

First uncertainty: a cheap scorer must separate keep from drop.

• Coherence: perplexity of the completion under the original model (incoherent = high), repetition (distinct-n, max n-gram repeat), tinymfv p_ans_any / json_is_valid.
• Enact-not-narrate: drop completions that verbalise the trait in the first person ("I always stick to principle") rather than enacting it. Cheap regex first pass, judge if needed.

Gate UAT: hand-label ~30-50 steered completions on two axes (coherent? enacts vs narrates?). Show the scorer's separation in a table at results/u1_filter_gate.md (threshold, precision/recall, a few example rows). Pass if a single threshold gives clean separation; if not, the whole approach stalls here, so this is gate one.

U2: can we heal, and which regulariser?

Second uncertainty: which regulariser trades coherence for trait most efficiently? The headline is the SLOPE, not a pass/fail:

\text{cohΔ/authΔ} = \frac{\Delta\text{coh}}{\Delta\text{auth}} \times 100 \quad\text{(centinats of coherence per nat of trait moved)}

DIRECTION matters, not magnitude: most-NEGATIVE is best (trait moved AND coherence ROSE = free lunch), then small-positive = cheap, large-positive = trait cost a lot of coherence. Guard the denominator: |dAuth| < 0.05 nats -> blank (a do-nothing config can't fake a good slope on a near-zero denominator).

The operative experiment is the regulariser ablation (scripts/diag_heal_sweep.py, run #98+): load the round-0 checkpoint as baked history, re-heal round-1's kept data on top, fix barrier_ref=prev, and sweep reg ∈ {nll, kl_rev, kl_fwd, spectral_norm} x strength plus weight_decay ∈ {30,60,120}, ranked by the cohΔ/authΔ slope. Prior, UPDATED by #82/#98 (was kl_rev > kl_fwd ~ wd > nll): the barrier THROTTLES trait and buys little coherence at this operating point (nll is already cheap, coh ~0.995-0.996), so the contest is whether any reg produces a NEGATIVE (free-lunch) slope that beats the nll/wd family rather than just trading trait away. wd is the surprise candidate (knee ~30, holds coherence while moving trait).

Gate UAT: the diag_heal_sweep table (headline-first, sorted best-slope-first) at the journal entry, winner = most-negative-or-smallest cohΔ/authΔ among rows whose dAuth_base is meaningfully negative (trait actually moved, not a blank do-nothing row, not a positive-dAuth undo), at coh >= prev. Read samples too: scores can move for the wrong reason (narration).

U3: iterative, coherent, same direction?

Third uncertainty: over rounds, does the auth axis increase monotonically (same direction) while coherence stays above a floor?

• Direction wander: cos(v_teacher^(r), v_teacher^(0)) per round; if it stays high the direction is stable.
• Internalisation: cos(v_student, v_teacher) per round.
• Budget: track cumulative KL vs the iso-KL ~1.7 nat prior.

Gate UAT: results/index.html, the ported w2schar Care-vs-Authority plotly map (one node per round, trajectory across the auth axis) plus a coherence and direction-cosine panel sharing the round axis, see /tufte-viz. Pass if auth increases monotonically and coherence stays above the floor for >=3 rounds.

Algorithm (pseudopy)

Uses steering-lite (vector + iso-KL), lora-lite (adapter + custom loss), tinymfv (eval).

Baking: run base, or scale the latest round

lora-lite has no merge, and we do not want to merge into W_b anyway: keeping W_b pristine is what lets us run the base model (KL reference, base eval) by gating the adapters to zero. So instead of merging, fold each finished round into a dense delta accumulator with its own gate, and keep the current round low-rank and trainable.

y = x\,\big(W_b + C_0\, W_\text{baked} + C_N\, A_N B_N\big) + b, \qquad W_\text{baked} = \sum_{i=0}^{N-1} A_i B_i

• C_0 = 0, C_N = 0 → base model (W_b only), this is the KL reference and base eval.
• C_0 = 1, C_N = 0 → student through round N-1.
• C_0 = 1, C_N = 1 → full current student.
• C_N free → dial the latest round's magnitude, like a steering coefficient.

Store the accumulator factored, not dense: stack the folded rounds' factors so the rank grows by r per round (N*r total, e.g. 4 rounds x r=8 = 32). With hidden d ~ 2560, factored does ~d/(2*N*r) ~ 40x fewer FLOPs and ~40x less memory than a dense d x d per layer, so it is both smaller and faster here. Dense only wins if N*r approaches d/2, which we never reach. Only A_N, B_N train each round.

This gated-history baking already exists in w2schar-mini (csm.ws.bake.baked, csm.ws.history.load_base_with_history): it composes N gated adapters and keeps the base pristine at gate 0, which is exactly our C_0=C_N=0 KL anchor. Prefer reusing it over writing a new lora-lite variant. Pseudocode for clarity:

# ── Factored baked-accumulator LoRA (one per linear layer) ──
# reuse csm.ws.bake / csm.ws.history rather than reimplementing.
class BakedLoRA:
    A_baked, B_baked = empty(0, d_in), empty(d_out, 0)   # stacked folded rounds, frozen
    A, B             = lora_init(r)                        # current round N, trainable

    def forward(self, x, y):               # y = x·W_bᵀ + b  (frozen base output)
        Δ_baked = C0 * ((x @ A_baked.T) @ B_baked.T)   # two skinny matmuls, rank N·r
        Δ_now   = Cn * ((x @ self.A.T)  @ self.B.T)    # current round
        return y + Δ_baked + Δ_now

    def fold(self):                        # stack current round into the frozen factors
        A_baked ← cat([A_baked, self.A.detach()], dim=0)   # [N·r, d_in]
        B_baked ← cat([B_baked, self.B.detach()], dim=1)   # [d_out, N·r]
        self.A, self.B ← lora_init(r)                      # fresh adapter for round N+1

# original logits = same module with both gates off (no second model copy)
def logπ0(model, x):
    with no_grad(), gates(model, C0=0, Cn=0):  return model(x)

Main loop

import steering_lite as sl;  from steering_lite import Vector, MeanDiffC
import lora_lite as ll
import tinymfv

# ── Teacher vector: trait sysprompt vs neutral sysprompt, @assistant tag ──
def teacher_vec(model, tok, D, ℓ, target_kl=1.0):
    pos = [s_trait   ⊕ x for x in D]
    neg = [s_neutral ⊕ x for x in D]
    v = Vector.train(model, tok, pos, neg, MeanDiffC(layers=ℓ))  # mean(h⁺)-mean(h⁻), L2-norm
    v.calibrate(model, tok, target_kl=target_kl)                 # iso-KL → c_star (p95 KL ≈ 1 nat)
    return v                                                     # v.cfg.coeff = c_star

# ── Generate steered completions, dose = α·c_star, gate for coherence ──
def gen_steered(model, tok, D, v, α, N):
    with v(model, C=α * v.cfg.coeff):           # h + C·v̂ on chosen layers
        comps = [model.generate(x) for x in sample(D, N)]
    return comps

def keep(c, orig, tok):                          # U1 filter gate
    coherent = ppl(c, orig) < τ_ppl and rep_ngram(c) < τ_rep and p_ans_any(c) > 0.75
    return coherent and not narrates_trait(c)    # enact, don't narrate

# ── Heal: SFT + barrier. reg ∈ {nll, kl_fwd, kl_rev, spectral_norm}; wd is an independent AdamW knob ──
# ref = prev student (history baked, this round's adapter off), NOT base -- see Loss section.
def train(model, comps, reg, λ, τ, wd, epochs=6):
    opt = AdamW(round_N_params(model), lr=α_lr, weight_decay=wd)   # wd composes with any reg
    for _ in range(epochs):
        for x in comps:                          # x = prompt + steered completion
            with gates(model, C0=1, Cn=1):  logπ = model(x)   # full student (grad on A_N,B_N)
            ℒ_sft = -mean(logπ[x.completion_tokens])
            if   reg=="kl_fwd":        div = KL(logπ_ref(model,x), logπ)[x.completion_tokens].mean()
            elif reg=="kl_rev":        div = KL(logπ, logπ_ref(model,x))[x.completion_tokens].mean()
            elif reg=="spectral_norm": div = σ_max(A_N B_N)     # operator norm, τ=0 -> always-on
            else:                      div = 0                  # nll
            ℒ = ℒ_sft + λ * relu(div - τ)        # barrier: off while div ≤ τ
            ℒ.backward();  opt.step();  opt.zero_grad()

# ── The loop: vector re-derived from current student, fold after each round ──
def steer_heal(model, tok, D_prompts, ℓ, N, λ, τ, D="kl_rev", rounds=4):
    ll.attach(model, BakedLoRA, ll.LoRAConfig(r=8, alpha=16))   # gates C0,Cn live
    v0 = None
    for r in range(rounds):
        with gates(model, C0=1, Cn=1):                          # extract on current student
            v = teacher_vec(model, tok, D_prompts, ℓ)
        v0 = v0 or v.unit()
        comps = [c for c in gen_steered(model, tok, D_prompts, v, α=1.0, N=N)
                   if keep(c, logπ0_model(model), tok)]         # filter vs original (gates off)
        train(model, comps, D, λ, τ)
        model.fold()                                            # bake round r → W_baked, fresh A,B
        log(tinymfv.eval(model))                                # auth/care + p_ans_any
        log(cos(v.unit(), v0))                                  # direction wander vs round 0
    return model

Compute and models

24 GB GPU. Real runs on a 4B model (Qwen3-4B): bf16 weights ~8 GB, LoRA optimiser state small, original-logits forward is the same model with the adapter toggled off (no second copy), short completion sequences. Comfortable in 24 GB.

Per setup-repo, the single functional test is just fast-dev-run: the real pipeline (vector, generate, filter, train, eval, loop) on the tiny random model wassname/qwen3-5lyr-tiny-random, beartype on, scale-only knobs, garbage numbers fine (the filter and tinymfv will score it as dead, we continue anyway to exercise the path). small-dev-run on Qwen3-0.6B for noisy-but-real numbers. No tests/ dir.

Open decisions (most resolved above)

1. Layer(s) ℓ for the teacher vector and steering. steering-lite default is all layers; the paper reads at the assistant tag at a chosen depth. Single mid-band or all? Need to pick.
2. Prompt set D: which distribution generates the completions and the vector? tinymfv-style prompts, or broader open-ended ones?
3. tau for the barrier and lambda scale; the iso-KL target_kl (1 nat default) for the dose.
4. N kept completions (~50?), epochs (2?), LoRA rank.
5. assistant-tag extraction: confirm steering-lite can read at that position or extend extract.py.

Plans / fallbacks if the trait won't distill (recorded 2026-06-04)

Context: on gemma-3-4b-it, one round of distill+heal UNDOES the steering rather than healing it (journal 2026-06-04 (a)): the adapter reverts to base, dropping Authority along with the incoherence, because the coherence filter removed the trait-laden completions before training. Ordered fallbacks:

• Plan A (current primary): make the steering in the TRAINING DATA strong enough to carry a large trait shift while the healed model still sits at coherence ~0.95 (not the 0.80 collapse of c=1, not the 0.99 no-op). Heal-vs-undo metric: retain = dAuth(heal)/dAuth(steer) and the ratio |dAuth|/|dCoh|; a real heal has large |dAuth| at small |dCoh|, an undo has both ~0. Run heal with the coherence FILTER OFF (ppl_tau large) so the kl_rev barrier, not the filter, removes incoherence during training.
• Plan B (better extraction method / target): TWO sub-options.
  • B1 (method): raw mean_diff is NOT the worst -- it is 4th/mid-pack in steering-lite (SI 32.8 vs directional_ablation 52.9, sspace 45.7, super_sspace 47.7). If the proper persona pair + diverse contexts is still broad, TODO try super_sspace or sspace (steering-lite variants/) -- more surgical, and super_sspace is 4x faster than per-Linear sspace. Check bake-ability (Plan D).
  • B2 (target): if Authority stays weak, target -Care or +Sanctity. Care has the widest steered range on 4b (base 0.274 -> steered 0.056) so better SNR. Pick whichever the model steers most cleanly.
  • Persona pair: use the PROVEN steering-lite pair (docs/personas/how_to_write_personas.md), NOT a made-up "trait vs helpful-assistant" pair. Direct opposites, no negation, conflict framing: pos="looks after others' wellbeing even when defying authority", neg="defers to authority even when others' wellbeing suffers for it". (fixed 2026-06-04)
• Plan C (eval reliability): the mean-mass forced-choice shift is noisy at max_think_tokens=64. Raise tinymfv to 128 or 256 think tokens for the headline evals (should not be necessary, but the 64-token profile is unreliable; document the cost). Also: foundation absolute values are NOT portable across n_vignettes (base Care is 0.92 at the first 24 vignettes but 0.27 at all 132) -- always compare base-vs-X paired at the SAME n, and prefer all 132.
• Plan D (better extraction): raw mean-diff may be too blunt. Consider steering-lite alternatives (cosine-gated steering, SVD/PiSSA-style directions) that give a cleaner trait axis. Constraint: the method must be BAKEABLE into static weights (the loop folds each round into baked()). A cosine GATE is input-dependent (its scale depends on the activation), so it cannot be folded into a fixed weight delta -- if we use gating for extraction we still need a bakeable distillate. Check which steering-lite methods are weight-foldable before adopting.

External review panel (2026-06-04)

Five non-Anthropic reviewers (deepseek-v4-pro, grok-4.3, gemini-3.5-flash, local qwen3.6:35b; mistral returned empty) over spec + src. Two CONFIRMED code bugs were fixed this round; the rest are design risks recorded here.

Fixed (code):

• Catastrophic-green cue (gemini, sharpest; echoed by deepseek/qwen). coh_cost = |dCoh|/|dAuth| is a pure ratio: a model that collapses to ~0 mass on Authority sends dAuth -> -inf so coh_cost -> 0, scoring a broken model green. Fix (run.py): check an ABSOLUTE coherence floor (coh < 0.85 -> red) and finiteness FIRST, require coh >= 0.95 for green, and broaden surgicality from |dAuth|>|dCare| to |dAuth| > max(|dCare|,|dFair|) (a shift dumping mass onto Fairness was passing the Care-only test).
• BPE-boundary assert escaped at the max_len/truncation boundary (grok, gemini, qwen, unanimous). Fix (heal.py): assert the surviving prefix overlap min(n_prompt, L) unconditionally; warn (not silently skip) when a kept completion truncates to zero target tokens.

Design risks (NOT fixed, inform the loop + Plan work):

• RESOLVED (#97, now barrier_ref=prev default): Loop barrier undoes its own history (gemini "history erasure", grok, deepseek). KL anchored to the round-0 original while history is baked into the student means by round>=1 the cumulative drift already exceeds tau, so the relu barrier is permanently active and its gradient pushes the fresh adapter to OPPOSE the trait the frozen history installed. Confirmed and FIXED: anchor the barrier to the PREVIOUS student (prev), penalising only this round's new divergence. See the Loss section for the settled call (supports task 17).
• Barrier mean-dilution (deepseek). div = mean over completion tokens of KL; a few catastrophically incoherent tokens are diluted by many in-distribution ones, so the mean stays < tau and kl_rev silently == nll. A max or high-quantile KL would penalise localised incoherence. METHOD change (alters the objective) -> deliberate decision, do not silently switch.
• ppl-under-base is a STYLE proxy, not coherence (deepseek, gemini, grok, qwen, independently re-deriving the known journal confound). Fluent-but-stylistically-novel on-trait completions score high ppl and get dropped -> survivorship toward base-like training data.
• Construct validity (gemini, qwen, deepseek). tinymfv is 3rd-person forced-choice classification; steering installs a 1st-person persona, so the link is an indirect propensity proxy. No neutral-instruction control rules out format/instruction-following artefacts.
• teacher_vec drift (gemini, deepseek): v re-extracted from the baked student can decay as the trait internalises (contrastive delta shrinks); cos_v0 already watches this.
• NARRATE regex brittle (deepseek): paraphrased verbalisation ("I never obey without question") evades it and leaks narration into training.

Verified FALSE positives (do not re-chase): qwen's "n_prompt = prompt_ids.shape[0] reads the batch dim" -- the line uses .input_ids[0], so prompt_ids is 1-D and shape[0] IS the seq len. grok/qwen's "profile['model'] may be model_T/top1" -- tinymfv eval.py:316 confirms it is the mean over vignettes of per-row p (the marginal). grok's "KL reference can't be the round-0 original" -- c=0.0 + no baked() is the pristine base by construction.

UAT summary (proof, not assertion)

• U1 filter gate: results/u1_filter_gate.md — labelled set, scorer separation. Link when done.
• U2 heal gate: the diag_heal_sweep.py regulariser-ablation table (headline cohΔ/authΔ×100, sorted best-slope-first), winner = most-negative slope among rows that actually move trait. Link the journal entry + pueue id.
• U3 loop gate: results/u3_loop.png — auth shift, coherence, direction cosines per round; monotone trait, coherence above floor. Link.
• Samples: first 3 train completions and first 3 eval generations printed in full (prompt + special tokens), confirming enact-not-narrate and correct formatting.

Log

gsd/lgtm: goals tracked in the task list with distinguishing checks (success looks different from silent failure) and a fresh-eyes subagent verify; one goal per Q.

• 2026-06-04 spec + scaffold done; vendored steering-lite, isokl, tinymfv, w2schar-mini.
• 2026-06-04 verified vendor APIs (file-anchored): steering-lite Vector.train does NOT apply the chat template, so we pre-template ending at the assistant tag (last-non-pad read lands there); v.calibrate(target_kl) sets cfg.coeff; tinymfv evaluate() returns mean_pmass_allowed (coherence canary) + per-foundation profile (auth/care). Prompt set resolved: reuse w2schar POOL (30 authority dilemmas), copied to prompts.py.
• 2026-06-04 decision: coherence = mean_pmass_allowed AND valid_json free-gen, self-relative to base c=0 (per w2schar CLAUDE.md); foundation shift (auth/care) is the trait signal, kept distinct from coherence.
• 2026-06-04 decision: KL reference anchored to round-0 original via the C_0=C_N=0 gate; bake via copied ws.bake.baked; no merge.
• 2026-06-04 implementing: copied ws/{adapter,bake}.py; wrote io.py, prompts.py, steering.py. Next: filter, heal, eval, plot, wire run.py, then fast-dev-run end to end.