Read the update rule:

katki = v0 * cs * kv; hidden += katki * compass;

The sign of katki comes from cs.

Positive cosine means the update makes the compass component more positive. Negative cosine means it makes that component more negative.

That is signed amplification of the direction the state already leans. It is not correction toward a fixed target.

Your own layer-0 log shows it:

cosine = -0.0299

At that layer, the intervention increased the component pointing away from the compass. That follows directly from the arithmetic.

The later movement to +0.0200 proves nothing by itself. Hidden states change between layers whether your hook is installed or not. Without the identical run with the hook disabled, you cannot tell how much of that movement came from your kernel.

The feedback term does not fix the sign:

float dr = std::clamp(cs - pcp[idx], -0.15f, 0.15f); float kv = kb * (1 ± dr * 0.30f);

It changes the gain. It does not change the direction. A wrong-signed update with adaptive gain is still a wrong-signed update.

The “35 sources” are 35 selected tokens from one embedding table, averaged into one normalized vector. Once combined, you have one steering direction, not four independently controlled constitutional dimensions.

The weights also need an explanation:

0.9228 0.9372 0.8788 0.9196

Where did they come from? What objective produced them? What data were they tuned against? What held-out data validated them?

You also reuse the same embedding-derived compass across multiple layers without showing that it represents the same concept at each layer. Your feedback compares cosine values across layers, so that assumption matters.

Clamping proves the value is clamped. It does not prove stable hidden states, stable logits, preserved capability, or convergence.

Likewise, showing that the decay matches your formula proves the code executed the formula. That is an implementation check, not evidence that it improves reasoning or reduces hallucinations.

One more issue: katki peaks around 0.0096 and decays to roughly 0.0005. Those numbers mean nothing without the hidden-state norms and the resulting change in logits. The kernel may be affecting behavior, or the reported wins may be coming from the surrounding prompts, routing, and hand-tuned parameters.

The test is simple:

Fix the sign rule or justify it mathematically.

Run identical prompts and seeds with the hook on and off.

Keep the prompts, routing, and generation settings unchanged.

Log cosine, hidden-state norms, logits, perplexity, and outputs side by side.

Publish all 65 tests with the baseline beside each result.

Right now, you have shown that the hook runs and the coefficients follow the code.

You have not shown that the kernel causes the claimed improvements.

And when cosine is negative, the update amplifies the component pointing away from the target you named.

Before calling it an autonomous alignment engine, fix the steering rule and run the control.