# W-015 Investigation: session/context.py unitize root cause

## Question

What is the source of the versor-condition drift that `session/context.py:236`
corrects, and which of the three resolution paths applies?

## Evidence collected

Instrumented `_anchor_pull` to record `versor_condition(pulled_F)` immediately
before `unitize_versor(pulled_F)`. Ran `tests/test_session_coherence.py`,
`tests/test_achat.py`, `tests/test_chat_runtime.py`, and
`tests/test_warmed_session_lane.py` (4,138 samples total across 25 tests).

| Band | Count | % |
|---|---|---|
| < 1e-6 (invariant satisfied — unitize is near no-op) | 1,912 | 46% |
| [1e-6, 1e-3) (small drift) | 0 | 0% |
| [1e-3, 1) (large violation) | 2,201 | 53% |
| ≥ 1 (massive violation) | 25 | 1% |

**Distribution is strictly bimodal**: no samples fall in [1e-6, 1e-3). The
maximum observed pre-unitize versor_condition is **38.58**; median is **0.19**
across the dirty half.

The 1,912 "clean" samples correspond to calls where `_slerp_toward`'s near-
parallel fallback fires (`theta < 1e-6`), i.e., the field has not drifted from
the anchor — `result ≈ (1-α)·F + α·target ≈ F`, so vc is preserved. The 2,226
dirty samples are turns with non-negligible field-to-anchor angle.

## Upstream trace

Call chain leading to the unitize:

```
SessionContext.respond()                  session/context.py:321
  └→ generate(self.state, ...)            generate/stream.py (generate())
       └→ GenerationResult(
            final_state=_close_final_state(current)  stream.py:641
          )                               # unitizes F → vc < 1e-6
  └→ SessionContext.finalize_turn(result) session/context.py:337
       └→ _hemisphere_consistent_field(result.final_state)  context.py:272
            # negates F if wrong hemisphere — vc-preserving
       └→ _anchor_pull(oriented_state)    context.py:273
            └→ _slerp_toward(field_state.F,
                             self._anchor_field,
                             _ANCHOR_PULL_ALPHA)      context.py:235
                 # ← SOURCE OF VIOLATION
            └→ unitize_versor(pulled_F)               context.py:236
                 # ← THE SITE UNDER INVESTIGATION
```

`_close_final_state` (`generate/stream.py:132–140`) calls `unitize_versor` and
ensures `result.final_state.F` satisfies vc < 1e-6 on entry. The hemisphere
flip preserves vc. **The sole source of the violation is `_slerp_toward`.**

`_slerp_toward` (`session/context.py:38–64`) performs spherical linear
interpolation (slerp) on the 32-component multivector representation. Slerp
traces a geodesic on **S³¹** (the unit sphere in 32D), not on the **Spin
sub-manifold** embedded within Cl(4,1). For any non-negligible angle θ between
F and anchor, the slerp output is a point on S³¹ that is not a proper versor —
the versor condition `|v·rev(v) − 1|` can diverge far from zero. The strict
bimodal distribution (no samples in [1e-6, 1e-3)) confirms this: either θ ≈ 0
(clean) or the slerp leaves the versor manifold dramatically (dirty).

This pattern is explicitly noted at `generate/stream.py:218–219`:

> *"by construction (versor_condition stays < 1e-6), unlike a linear blend
> `weight·V + (1-weight)·identity` which violates closure."*

Stream.py avoids linear blending for exactly this reason. `_slerp_toward` is
the same category of error applied to an anchor-pull operation.

## Cross-check: field/operators.py:_unitize_f32

`field/operators.py:69` defines `_unitize_f32`, used by `GraphDiffusionOperator`
and `ConstraintCorrectionOperator` to close blend-then-unitize steps in the
field propagation pulse loop. This is an **independent concern**: it lives
inside operator-pipeline boundaries (L1 audit flagged it as pulse-only
normalization), whereas `session/context.py`'s site is at the session
finalization boundary. The two sites share the same class of error (blending on
the wrong manifold) but operate at different layers and have different fix paths.

## Verdict

**(c) Upstream construction violation.** The drift is not small and consistent
(ruling out (a)) and is not a near-no-op (ruling out (b)). The source is
`_slerp_toward` at `session/context.py:38–64`: it interpolates on S³¹ rather
than on the Spin group, producing off-manifold state with vc up to 38.58 for
non-negligible field-to-anchor angles.

## Recommended next action

Replace `_slerp_toward` with proper **rotor geodesic interpolation** via the
Lie group exponential map:

```
R_rel = R_anchor · reverse(R_current)
R_step = exp(α · log(R_rel))
result  = R_step · R_current
```

This stays on the versor manifold by construction (same principle as
`rotor_power` used at `generate/stream.py:220`), eliminating the need for
`unitize_versor` in `_anchor_pull`. The fix lives entirely in `session/context.py`
(replace `_slerp_toward` + remove the `unitize_versor` call). Sized as a small
focused PR; a test asserting `versor_condition(_anchor_pull(s).F) < 1e-6`
without the closing unitize would verify the fix without altering the invariant.
`algebra/versor.py` already exposes `versor_apply` and `reverse`; `rotor_power`
lives in `generate/stream.py` — the implementation is straightforward once the
operator algebra is right.