algebra/rotor.py and persona/motor.py were calling normalize_to_versor()
which is the gate-only injection primitive. Both are construction-time
sites (building rotors and motors from raw arrays), so the correct call
is unitize_versor().
Also tightens TestINV02 to scan for normalize_to_versor violations only —
unitize_versor has its own legitimate call sites and is not under the
same single-site restriction. Adds a new TestINV02b that verifies
unitize_versor is NOT called inside propagation, generation, or vault
recall paths.
Fixes: INV-02 architectural invariant test failure.
Three surgical import changes. No behavior change. No new semantics.
Backend decides Rust vs pure-Python transparently.
- field/propagate.py: versor_apply <- algebra.backend
- vocab/manifold.py: cga_inner <- algebra.backend
- vault/store.py: recall loop replaced with vault_recall() from
algebra.backend; public result shape preserved ({versor, score,
metadata, index}). null_project stays on algebra.cga (not the
recall hot path). store() and reproject() unchanged.
Rust path for vault_recall uses Rayon parallel scan and releases
the GIL. Python fallback is sequential and behaviorally identical.
No batching introduced; that is Commit 3+.
- field/state.py: FieldState is now frozen+slotted; constructor copies and
enforces float32 shape (32,); advance() updated to pass raw arrays.
np.ndarray inside frozen dataclass is ref-frozen — copy() at construction
is the explicit contract boundary.
- generate/result.py: NEW — GenerationResult frozen dataclass carrying
tokens + final_state. Async variant yields tokens and exposes final_state
on completion.
- generate/stream.py: generate() now returns GenerationResult, not list[str].
vocab.edge_rotor() call replaced with:
A = vocab.get_versor_at(current.node)
B = vocab.get_versor_at(word_idx)
V = word_transition_rotor(A, B)
agenerate() updated to yield tokens and surface final_state.
- vocab/manifold.py: added get_versor_at(idx) and get_word_at(idx) indexed
accessors. VocabManifold stores points; algebra constructs operators.
normalize_to_versor() call-site in docstring clarified: callers must call
unitize_versor() (algebra construction primitive) before add(), not
normalize_to_versor() directly.
- algebra/versor.py: unitize_versor() added as the explicit construction-time
primitive. normalize_to_versor() kept but marked internal/gate-only.
Distinction encoded in docstrings and __all__.
- persona/motor.py + ingest/gate.py: SessionContext.respond() is not yet in
the repo as a separate file; gate.py docstring updated to reflect the
three-tier normalization doctrine:
unitize_versor() — algebra construction only
inject() — gate, once per raw input
normalization — forbidden in propagate/generate/vault recall
- docs/decisions/ADR-0008-allocation-physics.md
Formalizes salience, attention, inhibition, and coherence-budget
as the allocation physics of cognition. Replaces attention-as-weights
with attention-as-field-curvature over the versor manifold.
- docs/decisions/ADR-0009-compositional-physics.md
Defines temporal binding, digest cycles, reasoning trajectories,
and articulation planning as the compositional physics layer —
how CORE assembles pressure into structured thought and output.
- docs/decisions/ADR-0010-identity-physics.md
Establishes IdentityManifold, DriveGradientMap, ExertionMeter,
and CharacterProfile as structural identity primitives. Identity
is a field over the geometry, not a prompt veneer. Grounded in
John 1:1–2 and the Logos theology that anchors the architecture.
- docs/architecture/MIND-PHYSICS-BLUEPRINT.md
Integration blueprint showing how allocation → compositional →
identity physics layers compose into the full cognitive cycle.
- core/physics/ (11 Python interface stubs)
SalienceOperator, AttentionOperator, InhibitionOperator,
BindingFrame, DigestCycle, ReasoningTrajectory,
ArticulationPlanner, DriveGradientMap, ExertionMeter,
IdentityManifold, CharacterProfile — all typed, all frozen
where stateless, all carrying explicit field contracts.
Third Door: no off-the-shelf cognitive architecture borrowed.
All operators defined from the geometry up.
- Add algebra/rotor.py: word_transition_rotor() as a free operator function
- Update algebra/__init__.py: export word_transition_rotor
- Refactor vocab/manifold.py: remove edge_rotor(), add versor grade-norm
invariant check in add() to reject raw coordinate vectors at insertion time
VocabManifold now stores only algebraically valid Cl(4,1) versors and
exposes only relational lookup (CGA inner product). Rotor construction
is a contextual algebra-layer concern, not a vocabulary property.
