docs(sp4): close all carve-outs — weight decay + L1 lambda fully signal-driven

Folds two new producer signals into SP4 scope, eliminating the earlier
"carved out" exception:

WEIGHT DECAY (per param-group, 7 new ISV slots):
  λ = |w·g| / max(||w||², ε)
Derived from equilibrium analysis of d/dt(||w||²) = 2(w·g) - 2λ||w||².
The equilibrium gradient-projection-onto-weight-direction divided by
weight norm. Same theoretical-derivation category as Adam β values.
EMA half-life α=0.005 (~140 steps). Bootstrap 1.0.

L1 LAMBDA (trunk only, 1 new ISV slot — NOVEL PEARL):
  λ = (mean(|g|) / mean(|w|)) × D
  where D = (log K - H_observed) / log K  is gradient-direction entropy deficit
  and H_observed = -Σ p[i]·log p[i],  p[i] = ||g[:,i]|| / Σ ||g[:,j]||

L1 regularization-strength derives from gradient-direction entropy
deficit across input features. When gradient is uniform across features
(D≈0): network hasn't differentiated, λ=0 (no pruning). When gradient
concentrates on few features (D≈1): network has identified what matters,
λ ramps up to prune the rest. Self-curriculum — L1 strength tracks the
emergence of feature differentiation.

This extends pearl_adaptive_moe_lambda (regularization strength = EMA-
tracked deficit of regularized quantity) to feature-redundancy domain.
Pearl-name candidate (post-validation): pearl_signal_driven_regularisation_strength.

Bootstrap λ=0 means cold-start = no L1 pruning; ramp-up only after
gradient differentiates. Worst-case behavior is "L1 disabled" — graceful.

Total ISV slot count: 28 → 36. Total producer kernels: 28 → 36.
Effort estimate: 3000-4000 → 3500-4500 LOC, 1-1.5 → 1.5-2 weeks.

Acknowledged limitations updated: removed item #8 (carve-out) since
no carve-outs remain. Added items for L1 pearl novelty (untested) and
weight decay equilibrium-formula non-stationarity. Both have graceful
worst-case behavior and explicit validation criteria (#10 and #11) to
detect anomalies.

SP4 now closes 100% of the magnitude/regularization surface — no
hardcoded scalars remain in the entire chain. AdamW config fields for
weight_decay and l1_lambda removed from HyperParams to prevent
accidental hardcoding regression.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

docs/superpowers/specs/2026-04-30-sp4-signal-driven-magnitude-control-design.md

@@ -25,11 +25,14 @@ This revision (post-self-review) addresses 8 critical issues from the first draf
 - **Mech 10** — h_s2 activation clamp (`100 × H_S2_RMS_EMA.max(1.0)`)
 - **All `.max(1.0)` ε floors** (the SP1 pearl) — replaced by per-slot bootstrap values derived from theoretical-init statistics (Xavier max-element formula, etc.).
 
-**Carved out (will need separate specs):**
+**In scope (regularization knobs — added via novel pearls):**
 
-- **Weight decay (`AdamW wd × p`)** — controls L2-prior regularization strength. No clean producer signal: "ideal regularization" doesn't map to a single observable. Research-level open question. Out of SP4 scope.
-- **L1 lambda (`l1_lambda = 1e-3` in `dqn_adam_update_kernel`)** — controls feature-selection sparsity. Same problem. Out of SP4 scope.
-- **EMA rates (α values in producer kernels)** — kept as **statistical-design parameters** (each documented as observation time-window in steps), not signal-driven. Making α itself signal-driven creates a recursion (what controls α's update rate?); pragmatic resolution: α is a "time-window choice" analogous to choosing 1-second vs 1-hour averages, in the same theoretical-constant category as Adam β values.
+- **Weight decay (`AdamW wd × p`)** — derived from gradient-pressure-projection per param-group (see "Weight decay producer signal" below).
+- **L1 lambda (`l1_lambda` in `dqn_adam_update_kernel`)** — derived from gradient-direction entropy deficit per param-group (see "L1 lambda producer signal" below). This is a novel pearl extending `pearl_adaptive_moe_lambda.md` — same template (regularization strength = EMA-tracked deficit of what's being regularized against), applied to feature redundancy.
+
+**Kept as statistical-design parameters:**
+
+- **EMA rates (α values in producer kernels)** — each documented as observation time-window in steps, not signal-driven. Making α itself signal-driven creates a recursion (what controls α's update rate?); pragmatic resolution: α is a "time-window choice" analogous to choosing 1-second vs 1-hour averages, in the same theoretical-constant category as Adam β values.
 
 **Out of scope (categories D + E from the brainstorm):** mathematically derived theoretical constants (Adam β₁=0.9, β₂=0.999; Adam ε=1e-8 numerical denominator; Xavier init formula `√(2/K)`; attention 1/√d), and architectural shape constants (hidden_dim=256, num_atoms=51, num_quantiles=5, layer count, batch size).
 
@@ -133,7 +136,7 @@ This drops the `× 10` and `× 1e3` headroom patterns entirely. Both diagnostic
 
 ## Migration scope
 
-### ISV slot allocation (28 new slots)
+### ISV slot allocation (36 new slots)
 
 | Slot family | Count | Tracks | Consumed by |
 |---|---|---|---|
@@ -144,7 +147,9 @@ This drops the `× 10` and `× 1e3` headroom patterns entirely. Both diagnostic
 | `ADAM_V_BOUND[group]` | 7 (per param-group) | p99(\|adam_v\|) per group | slots 40-43 diagnostics |
 | `GRAD_CLIP_BOUND` | 1 | p99(grad_norm) | Mech 6 + adaptive_clip |
 | `H_S2_BOUND` | 1 | p99(\|h_s2\|) | Mech 10 clamp + slot 49 diagnostic |
-| **Total** | **28** | | |
+| `WD_RATE[group]` | 7 (per param-group) | EMA of \|w·g\|/\|\|w\|\|² per group | Adam kernel `weight_decay` arg |
+| `L1_LAMBDA[group]` | 1 (only trunk has L1) | (mean(\|g\|)/mean(\|w\|)) × entropy_deficit | Adam kernel `l1_lambda` arg |
+| **Total** | **36** | | |
 
 ### Param-group definitions (for the `[group]` slots)
 
@@ -207,11 +212,70 @@ Per `StateResetRegistry`: at fold boundary, all 28 ISV bound slots reset to thei
 
 Reset entries follow existing pattern in `state_reset_registry.rs` (one entry per slot with cold-start value and description).
 
+### Weight decay producer signal
+
+`AdamW` weight decay subtracts `λ × p` from each parameter per step. The "right" λ balances gradient pressure (which grows weights) against decay (which shrinks them). At equilibrium of `d/dt(||w||²) = 2(w·g) - 2λ||w||²`:
+
+```
+λ_equilibrium = (w · g) / ||w||²
+```
+
+This is the per-step **gradient projection onto weight direction divided by weight norm squared** — derived purely from observables. Sign-corrected variant: `λ = |w · g| / max(||w||², ε)` (always positive; ε from per-group bootstrap).
+
+Producer kernel `wd_rate_update[group]`:
+- Pass 1 (block-wide reduce): compute `w_dot_g = Σ_i w[i] × g[i]` over the param-group's slice
+- Pass 2 (block-wide reduce): compute `w_norm_sq = Σ_i w[i]²` over the slice
+- Final: `step_wd = |w_dot_g| / max(w_norm_sq, bootstrap²)` ; EMA into `ISV[WD_RATE[group]]`
+
+Adam kernels read `weight_decay = ISV[WD_RATE[group]]` from the launch site (no kernel-internal change beyond consuming the launch-site-supplied value, replacing the existing scalar field). Per-group → 7 producers, 7 ISV slots.
+
+EMA half-life: α=0.005 (~140 steps, matches weight evolution time-scale). Bootstrap: `1.0` (cold-start neutral; first-step EMA pulls toward observed signal).
+
+This is the same equilibrium-derivation principle the Adam paper uses for the β values — derived from a continuous-time stability analysis. Theoretically grounded, not tuned.
+
+### L1 lambda producer signal — gradient-direction entropy deficit pearl
+
+L1 regularization induces sparsity by pushing weights below `lr × λ` to exact zero. The principled question: when should pruning happen, and at what strength?
+
+**Insight:** L1 is regularizing against feature redundancy. The natural signal is **gradient-direction entropy deficit** across input features.
+
+For the trunk's first weight matrix `w[H, K]` (where K is input feature dim):
+- For each input feature `i`: `g_feat[i] = ||g_w[:, i]||₂` (L2 norm of gradient column — how much that feature's weights "want to change")
+- Normalized distribution: `p[i] = g_feat[i] / Σ_j g_feat[j]`
+- Shannon entropy: `H_observed = -Σ_i p[i] · log p[i]`
+- Maximum (uniform): `H_uniform = log(K)`
+- Deficit: `D = (H_uniform - H_observed) / H_uniform ∈ [0, 1]`
+
+D is a self-curriculum signal:
+- **D ≈ 0** (gradient uniform across features) → network hasn't differentiated → λ=0 (no pruning, let learning proceed)
+- **D ≈ 1** (gradient concentrated on few features) → network has identified what matters → λ grows to prune the rest
+
+Combined with a magnitude scale derived from observables:
+```
+λ[group] = (mean(|g|) / mean(|w|)) × D[group]
+```
+
+Producer kernel `l1_lambda_update[group]`:
+- Pass 1 (per-column reduce): `g_feat[i] = sqrt(Σ_h g_w[h,i]²)` for each i ∈ [0, K) — single block, K-thread tile
+- Pass 2 (block-wide reduce): `Σ g_feat[i]` for normalization, plus `mean(|g|)` and `mean(|w|)` over full slice
+- Pass 3 (single-thread): compute `H_observed`, `D`, `λ_step = (mean_g / mean_w) × D`
+- EMA into `ISV[L1_LAMBDA[group]]` (currently only trunk has L1 → 1 producer, 1 ISV slot)
+
+Adam kernel reads `l1_lambda = ISV[L1_LAMBDA[group]]` at the launch site, passes through to the existing L1 proximal step.
+
+EMA half-life: α=0.05 (~14 steps; L1 strength can react quickly to gradient-direction shifts since differentiation is the signal we're tracking).
+
+Bootstrap: `0.0` (cold-start no L1 — no pruning until network has differentiated). The fold-boundary reset to 0.0 means each new fold starts L1-free and the producer ramps up λ as gradient differentiates within the new fold's data regime. **This is exactly the right curriculum** — you don't want to prune during the first ~tens of steps when the network is learning the new fold's structure.
+
+**Pearl name (post-validation):** `pearl_signal_driven_regularisation_strength` — extends `pearl_adaptive_moe_lambda` to a class of regularization-strength controllers driven by entropy-deficit of the regularized quantity. Captured in memory once SP4 ships and validates.
+
 ## Producer architecture
 
 ### Per-signal kernels
 
-28 producer kernels, each mirroring the existing `h_s2_rms_ema_update` shape but with the histogram-p99 algorithm replacing the RMS computation:
+36 producer kernels (28 magnitude-bound + 7 weight-decay + 1 L1-lambda), each mirroring the existing `h_s2_rms_ema_update` shape. The 28 magnitude-bound producers use the histogram-p99 algorithm; the weight-decay and L1-lambda producers use their respective formulas above.
+
+Magnitude-bound producer signature:
 
 ```cuda
 extern "C" __global__ void <signal>_p99_update(
@@ -258,24 +322,25 @@ Per `feedback_no_partial_refactor`, the contract change is one atomic commit. Th
 
 ### Layer A — additive infrastructure (no behavior change)
 
-- Add 28 ISV slot indices to the bus (extend `ISV_TOTAL_DIM` if needed)
-- Implement 28 producer kernels (each with unit test)
-- Wire 28 launch sites in the appropriate locations (captured-graph for buffer-based bounds; cold-path in `training_loop.rs` for weight/Adam bounds)
-- Add 28 `StateResetRegistry` entries with bootstrap values (computed from K_in[group] × LR_init)
+- Add 36 ISV slot indices to the bus (extend `ISV_TOTAL_DIM` if needed)
+- Implement 36 producer kernels (28 magnitude-bound histogram-p99 + 7 weight-decay equilibrium + 1 L1-lambda entropy-deficit), each with unit test
+- Wire 36 launch sites in the appropriate locations (captured-graph for buffer-based bounds; cold-path in `training_loop.rs` for weight/Adam/regularization bounds)
+- Add 36 `StateResetRegistry` entries with bootstrap values (Xavier-derived for magnitude bounds; `1.0` for weight decay; `0.0` for L1 lambda)
 - Bootstrap initialization in `GpuDqnTrainer::new`
 
-After Layer A: all 28 ISV slots are populated correctly each step; nothing else changes; cargo check + unit tests + L40S smoke (regression check) pass.
+After Layer A: all 36 ISV slots are populated correctly each step; nothing else changes; cargo check + unit tests + L40S smoke (regression check) pass.
 
 ### Layer B — atomic consumer migration (the contract change)
 
 ALL consumer sites flip simultaneously in one commit. Files modified:
 
-- `cuda_pipeline/gpu_dqn_trainer.rs` — Mech 1 clamp call site reads `ISV[TARGET_Q_BOUND]`; Mech 6 reads `ISV[GRAD_CLIP_BOUND]`; Mech 10 clamp call site reads `ISV[H_S2_BOUND]`; Adam launch sites compute `weight_clamp_max_abs` from `ISV[WEIGHT_BOUND[group]]`
+- `cuda_pipeline/gpu_dqn_trainer.rs` — Mech 1 clamp call site reads `ISV[TARGET_Q_BOUND]`; Mech 6 reads `ISV[GRAD_CLIP_BOUND]`; Mech 10 clamp call site reads `ISV[H_S2_BOUND]`; Adam launch sites compute `weight_clamp_max_abs` from `ISV[WEIGHT_BOUND[group]]`, `weight_decay` from `ISV[WD_RATE[group]]`, and `l1_lambda` from `ISV[L1_LAMBDA[group]]` (trunk only).
 - `cuda_pipeline/atoms_update_kernel.cu` (and `iql_value_kernel.cu`, `experience_kernels.cu`) — Mech 2 clamps read `isv_signals[ATOM_POS_BOUND[branch]]`
-- `cuda_pipeline/dqn_utility_kernels.cu` — Mech 5 fused diagnostic kernel: per-slot threshold reads from corresponding `isv_signals[BOUND_X]` instead of computing `K × q_abs_ref_eff`
-- `cuda_pipeline/iqn_dual_head_kernel.cu`, `iql_value_kernel.cu`, `attention_backward_kernel.cu`, `curiosity_training_kernel.cu` — each Adam kernel's `weight_clamp_max_abs` arg reads from its group's bound
+- `cuda_pipeline/dqn_utility_kernels.cu` — Mech 5 fused diagnostic kernel: per-slot threshold reads from corresponding `isv_signals[BOUND_X]` instead of computing `K × q_abs_ref_eff`. Adam kernel's `weight_decay` and `l1_lambda` args become ISV-sourced (replacing existing scalar config fields).
+- `cuda_pipeline/iqn_dual_head_kernel.cu`, `iql_value_kernel.cu`, `attention_backward_kernel.cu`, `curiosity_training_kernel.cu` — each Adam kernel's `weight_clamp_max_abs` and `weight_decay` args read from their group's bounds (no L1 in these — only trunk has L1).
+- `crates/ml/src/trainers/dqn/hyperparams.rs` (or similar) — remove `weight_decay`, `l1_lambda` from `HyperParams` config struct since they're now signal-driven (not configurable). Replace with documentation pointing to ISV slots.
 
-Single coordinated commit. Hardcoded multipliers all removed. `feedback_no_partial_refactor` honored.
+Single coordinated commit. Hardcoded multipliers, weight decay, L1 lambda — ALL removed. `feedback_no_partial_refactor` honored. SP4 closes 100% of the magnitude/regularization surface.
 
 ### Layer C — validation + cleanup
 
@@ -292,11 +357,14 @@ Single coordinated commit. Hardcoded multipliers all removed. `feedback_no_parti
 2. **F1 Best Sharpe > 0** — fixes the original SP3 motivation; no h_s2-overflow cascade
 3. **F0 Best Sharpe ≥ 37.5** — *revised criterion* matches `smoke-test-76pnm`'s 1e30-effectively-unclamped control. The 45.47 v2 baseline may be unreachable due to launch-scheduling-shift (the diagnostic smoke already showed F0=37.53 with no value-clamping at all). 37.5 is the realistic upper bound for any Mech-10-class design.
 4. **F2 Best Sharpe ≥ 55** — F2 reached 80.55 with Mech 10 100×, and 56.70 with v2; ≥55 is the conservative floor
-5. **Producer unit tests all pass** with <5% histogram-quantization error
-6. **No new ISV slots beyond the 28 in this design**
+5. **Producer unit tests all pass** with <5% histogram-quantization error (magnitude bounds), <2% relative error vs. analytical formula (weight decay, L1 lambda)
+6. **No new ISV slots beyond the 36 in this design**
 7. **No new kernels beyond per-signal producers + standard Adam-kernel arg additions**
 8. **Each consumer site reads exactly one ISV slot** (no compound expressions like `K × isv[X]`)
 9. **Mech 5 diagnostic slots fire only on regime shifts** — sticky-flag pattern
+10. **L1 lambda starts at 0 and ramps up** — entropy-deficit pearl: log `ISV[L1_LAMBDA[trunk]]` per fold; expect 0 at fold-start, ramping up as gradient differentiates within ~hundreds of steps. If λ stays at 0 throughout a fold, gradient never differentiates → either D signal is degenerate or the network's gradients are uniformly distributed (separate investigation thread).
+11. **Weight decay tracks gradient pressure** — log `ISV[WD_RATE[group]]` per fold; expect non-zero, smooth, per-group-specific values. If WD_RATE is identically zero, gradient projection onto weights is zero (network not learning anything from those weights → separate concern).
+12. **No `weight_decay` or `l1_lambda` config fields remain in `HyperParams`** — the contract is fully ISV-driven; removing the config field prevents accidental hardcoding regression.
 
 ### Regression sentinels (logged, not pass/fail)
 
@@ -322,11 +390,13 @@ The following risks are documented, not resolved, within SP4. They are accepted
 
 7. **Histogram log-spacing parameters are numerical-precision choices.** 256 bins gives 0.4% quantile precision; the choice is derived from "1% quantile needs ≥100 bins". Same theoretical-constant category as floating-point precision. Not tuning.
 
-8. **Carved-out items (weight decay, L1 lambda) remain hardcoded after SP4.** They're principle violations, but their producer signal isn't designable in this pattern. Documented as known scope reduction; future spec may address.
+8. **L1 lambda pearl is novel.** The gradient-direction entropy-deficit signal extends `pearl_adaptive_moe_lambda` to a class of regularization-strength controllers — but it has not yet been validated in an ML pipeline. Risk: the curriculum (D ramps up as gradient differentiates) might not match the network's actual learning dynamics. Mitigation: validation criterion #10 explicitly checks that λ ramps from 0 to non-zero within each fold; if not, the signal is degenerate and we'd need a separate investigation thread. Bootstrap=0 means worst-case behavior is "no L1 regularization" (equivalent to L1-disabled), which is graceful — won't cause training instability, just won't induce sparsity.
+
+9. **Weight decay equilibrium formula is theoretically sound but untested at scale.** `λ = |w·g| / ||w||²` is derived from `d/dt(||w||²) = 0` equilibrium analysis. Real training is non-stationary — equilibrium may not hold. Mitigation: the EMA smooths step-to-step variation; bootstrap=1.0 provides a sane cold-start; validation criterion #11 logs WD_RATE values per fold so anomalies are visible.
 
 ## Estimated effort
 
-- **Layer A:** 28 producer kernels + 28 unit tests + ISV plumbing + reset entries + bootstraps + 28 launch sites ≈ 3000-4000 LOC, ~1-1.5 weeks of focused work
+- **Layer A:** 36 producer kernels + 36 unit tests + ISV plumbing + reset entries + bootstraps + 36 launch sites ≈ 3500-4500 LOC, ~1.5-2 weeks of focused work. The 8 added regularization producers (7 weight-decay + 1 L1-lambda) are slightly more complex per-kernel than the 28 magnitude-bound histogram producers (multi-pass reductions for entropy/projection vs single-pass histogram), but unit tests are easier (analytical ground truth instead of histogram-quantization tolerance).
 - **Layer B:** ~15 consumer sites × ~10 LOC change each ≈ 200 LOC, one focused day
 - **Layer C:** smoke + audit doc + memory entries ≈ 100 LOC + validation runs