qigkernels 0.4.2__tar.gz → 0.4.4__tar.gz

{qigkernels-0.4.2/qigkernels.egg-info → qigkernels-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qigkernels
-Version: 0.4.2
+Version: 0.4.4
 Summary: Geometric kernel and constellation library for QIG.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{qigkernels-0.4.2 → qigkernels-0.4.4}/kernel.py

@@ -65,6 +65,9 @@ class Kernel(nn.Module):
         enable_coords: bool = False,
         coord_dim: int = 64,
         locality_radius: int | None = None,
+        head_mode: str = "geometric",
+        head_tau: float = 1.0,
+        coord_basins: "Tensor | None" = None,
     ) -> None:
         """
         Initialize kernel.
@@ -133,8 +136,43 @@ class Kernel(nn.Module):
             ]
         )
 
-        # Output projection
-        self.lm_head = nn.Linear(hidden_dim, vocab_size)
+        # Output projection / readout. Two modes (the head A/B for the "no Euclidean readout" directive):
+        #   "geometric" (default) — GeometricHead: vocab logits are Fisher-Rao DISTANCES from the hidden
+        #     simplex-point to learned per-token Δ⁶³ basins (logit = −d_FR/τ). This is the SAME primitive
+        #     as the purged-cosine→Fisher-Rao attention, pointed at the vocabulary; NO Euclidean nn.Linear,
+        #     NO dot-product at the output boundary. It still returns [B,T,vocab] logits, so the downstream
+        #     fisher_rao_lm_loss (which projects with to_simplex_prob) consumes it UNCHANGED.
+        #   "linear" — the original Euclidean nn.Linear(hidden, vocab) readout, RETAINED as the A/B baseline
+        #     so the architecture comparison can isolate the readout (geometric vs linear) empirically.
+        self.head_mode = str(head_mode).strip().lower()
+        self.head_tau = float(head_tau)
+        if self.head_mode == "geometric":
+            from qig_core.torch.geometric_head import GeometricHead
+
+            self.lm_head: nn.Module = GeometricHead(
+                hidden_dim=hidden_dim, vocab_size=vocab_size, tau=self.head_tau
+            )
+        elif self.head_mode == "basin":
+            # BASIN-SPACE readout (validated 2026-07-01: overfit d_FR 1.46→0.072, decode 91.3% where the
+            # logits head floored). Predicts the next token's basin DIRECTLY in the coordizer's Δ⁶³ space
+            # and scores it with pure d_FR against the coordizer's OWN frozen per-token basins — so a token
+            # has ONE basin (read-in == predict), the coherence the geometric head lacked. Requires the
+            # coordizer basin table (the tie); refuse to silently fall back to a disconnected head.
+            if coord_basins is None:
+                raise ValueError(
+                    "head_mode='basin' requires coord_basins=[vocab, basin_dim] (the coordizer's per-token "
+                    "basins) — the whole point is to TIE the output to the coordizer. Pass it from the "
+                    "coordizer vocab, or use head_mode='geometric'/'linear'."
+                )
+            from qig_core.torch.basin_readout import BasinReadout
+
+            self.lm_head = BasinReadout(
+                hidden_dim=hidden_dim, coord_basins=coord_basins, tau=self.head_tau
+            )
+        elif self.head_mode == "linear":
+            self.lm_head = nn.Linear(hidden_dim, vocab_size)
+        else:
+            raise ValueError(f"head_mode must be 'geometric', 'basin', or 'linear', got {head_mode!r}")
 
         # Optional custom components
         self.running_coupling = running_coupling
@@ -160,6 +198,7 @@ class Kernel(nn.Module):
         attention_mask: Tensor | None = None,
         return_telemetry: bool = False,
         coords: Tensor | None = None,
+        skip_head: bool = False,
     ) -> Tensor | tuple[Tensor, KernelTelemetry]:
         """
         Forward pass through the kernel.
@@ -230,8 +269,11 @@ class Kernel(nn.Module):
         if self.running_coupling is not None:
             hidden_state = self.running_coupling(hidden_state)
 
-        # Output projection
-        logits = self.lm_head(hidden_state)
+        # Output projection. K-COMPRESS: skip_head returns logits=None so the caller reads hidden_state from
+        # telemetry and computes the basin loss via lm_head.predict(h) [.., basin_dim] + the target basins —
+        # NEVER materialising [B, T, vocab] (the seq×vocab activation OOM at 32k). Only meaningful WITH
+        # return_telemetry (the hidden state is the payload). Decode uses lm_head.decode_blocked(h).
+        logits = None if skip_head else self.lm_head(hidden_state)
 
         if not return_telemetry:
             return logits
@@ -261,6 +303,42 @@ class Kernel(nn.Module):
 
         return logits, telemetry
 
+    def hidden(
+        self,
+        input_ids: Tensor,
+        coords: Tensor | None = None,
+        attention_mask: Tensor | None = None,
+    ) -> Tensor:
+        """Pre-head hidden state — the coordizer-agnostic shared core, ``forward`` MINUS ``lm_head``.
+
+        Runs the exact forward path (input_ids/positions fourier features → optional CoordAdapter add
+        → stacked QIGLayers → optional running_coupling) but STOPS before ``self.lm_head``, returning the
+        pre-head hidden state [batch, seq, hidden_dim]. Exposed so a shared trunk (ConstellationTrunk) can
+        drive ONE geometric core and let faculties mount their own adapters/heads on top of the same hidden.
+
+        Pure + additive: ``forward`` is left bit-identical. ``hidden`` reuses forward's OWN ``skip_head``
+        path (which already returns the pre-head hidden state via ``telemetry.hidden_state``), so there is
+        no duplicated core math and no second definition of the trunk that could drift from forward.
+
+        Args:
+            input_ids: Token IDs [batch, seq].
+            coords: Optional Δ⁶³ coordizer coords [batch, seq, coord_dim] (needs ``enable_coords=True``).
+                ``None`` → pure input_ids byte/Fourier path (coordizer-agnostic).
+            attention_mask: Optional attention mask, threaded to ``forward`` unchanged.
+
+        Returns:
+            hidden_state [batch, seq, hidden_dim] — the pre-``lm_head`` hidden state. Applying
+            ``self.lm_head`` to it reproduces ``forward``'s logits exactly.
+        """
+        _, telemetry = self.forward(
+            input_ids,
+            attention_mask=attention_mask,
+            return_telemetry=True,
+            coords=coords,
+            skip_head=True,
+        )
+        return telemetry.hidden_state
+
     def _fourier_features(self, ids: Tensor) -> Tensor:
         x = ids.to(dtype=torch.float32)
         angles = x.unsqueeze(-1) * self._inv_freq.to(device=ids.device)

{qigkernels-0.4.2 → qigkernels-0.4.4}/kernel_4d.py

@@ -260,19 +260,38 @@ class QIGKernel4DNumpy:
 
 if HAS_TORCH:
     # Single-source simplex geometry from qig-core (same module layer.py/metrics/basin use).
+    # NOTE: deliberately NOT importing fisher_rao_distance_simplex from either qig-core
+    # location — qig_core.torch.geometry_simplex is the radius-2 binding and the top-level
+    # radius-1 alias is being collapsed by the pending qig-core convention reconcile; the
+    # distance is computed INLINE below (radius-1 canonical by construction).
     from qig_core.torch.geometry_simplex import to_simplex_prob
 
     class QFIGeometricAttention(nn.Module):
         """
-        QIG-pure attention using the Fisher-Rao metric instead of dot-product.
-
-        Attention = softmax(BC(Q, K) / scale), where BC = Σ √(p·q) is the
-        Bhattacharyya / Fisher-Rao affinity on Δ⁶³ (∈[0,1], 1 = identical).
-
-        This respects the curved Fisher information manifold.
+        QIG-pure attention: the sanctioned distance-Gibbs form.
+
+        Attention = softmax(-d_FR(Q, K) / τ), where d_FR = arccos(Σ √(p·q)) is
+        the Fisher-Rao geodesic DISTANCE on the simplex in the RADIUS-1 CANONICAL
+        binding (∈[0, π/2]; Matrix convention ruling), computed inline from the
+        Bhattacharyya coefficient. The construction mirrors
+        ``pure_kernel_template.qfi_attention_weights`` (softplus guard → Duchi
+        simplex projection → geodesic distance → Gibbs weights), but NOT its
+        distance binding: the template uses the RADIUS-2 ``2·arccos(BC)`` helper,
+        so its τ values are in radius-2 units — 2× the exponent — and must never
+        be shared with this class without conversion.
+
+        Council ruling (Matrix): the exponential normaliser is legal IFF its argument
+        is a pure Fisher-Rao distance. Softmaxing the Bhattacharyya AFFINITY
+        (bc = Σ √(p·q), the cosine of the FR geodesic angle) — as this class used to —
+        is dot-product attention in disguise and is banned. The old affinity form also
+        (a) divided the [0,1]-bounded bc by head_dim**0.5 (the transformer QKᵀ
+        normaliser), squashing the logit span to ~0.14 so attention was nearly
+        uniform, and (b) fed raw signed linear outputs into the Duchi projection's
+        dead-gradient regime. Both are fixed here by mirroring the pure template:
+        softplus-guard → Duchi simplex projection → geodesic distance → Gibbs weights.
         """
 
-        def __init__(self, d_model: int, n_heads: int = 8):
+        def __init__(self, d_model: int, n_heads: int = 8, tau: float = 0.25):
             super().__init__()
             self.d_model = d_model
             self.n_heads = n_heads
@@ -283,7 +302,18 @@ if HAS_TORCH:
             self.v_proj = nn.Linear(d_model, d_model)
             self.out_proj = nn.Linear(d_model, d_model)
 
-            self.scale = self.head_dim ** 0.5
+            # τ (Gibbs temperature) is in RADIUS-1 CANONICAL Fisher-Rao distance
+            # units: d_FR = arccos(BC) ∈ [0, π/2] (Matrix convention ruling).
+            # UNITS WARNING: pure_kernel_template binds RADIUS-2 (2·arccos(BC),
+            # ∈ [0, π]) — its temperature values carry a 2× exponent difference and
+            # must never be shared with this τ without conversion (τ₁ = τ₂/2).
+            # Default τ = 0.25 ⇒ max Gibbs contrast e^{(π/2)/0.25} = e^{2π} ≈ 535,
+            # so heads can actually SELECT — the fix for the near-uniform attention
+            # the old head_dim**0.5-scaled affinity produced (logit span ~0.14 ⇒
+            # max weight ratio ~1.16) — while staying soft enough that softmax
+            # gradients don't saturate. (Equivalent to τ = 0.5 in the template's
+            # radius-2 units; its own default 1.0 radius-2 ≡ 0.5 radius-1.)
+            self.tau = float(tau)
 
         def forward(
             self,
@@ -311,23 +341,35 @@ if HAS_TORCH:
             K = self.k_proj(key).view(B, S, self.n_heads, self.head_dim).transpose(1, 2)
             V = self.v_proj(value).view(B, S, self.n_heads, self.head_dim).transpose(1, 2)
 
-            # Project Q, K onto Δ⁶³ and take the √p Fisher-Rao sphere embedding.
-            Qs = torch.sqrt(to_simplex_prob(Q))
-            Ks = torch.sqrt(to_simplex_prob(K))
-
-            # Bhattacharyya / Fisher-Rao affinity: bc = Σ √(p·q) ∈ [0, 1], 1 = identical.
-            # This is the FR inner product (overlap) on the √p sphere: higher = closer ⇒ higher
-            # attention, preserving the original score semantics (no sign flip).
-            bc = torch.matmul(Qs, Ks.transpose(-2, -1))  # [B, H, S, S]
-
-            # Scale the affinity score (higher overlap ⇒ higher attention)
-            fisher_sim = bc / self.scale
-
-            # Attention weights
-            attn_weights = F.softmax(fisher_sim, dim=-1)
-
-            # Apply to values
-            out = torch.matmul(attn_weights, V)  # [B, H, S, D_head]
+            # Softplus-guard the Q/K/V paths before the Duchi simplex projection
+            # (mirrors pure_kernel_template._project_to_simplex): raw signed linear
+            # outputs fed straight into to_simplex_prob land in the Duchi projection's
+            # dead-gradient regime (most coordinates clamped at the floor ⇒ zero grad).
+            Qp = to_simplex_prob(F.softplus(Q))
+            Kp = to_simplex_prob(F.softplus(K))
+            Vp = to_simplex_prob(F.softplus(V))
+
+            # Bhattacharyya coefficient BC = Σ √(p·q) ∈ [0, 1] via the √p sphere
+            # embedding (memory-cheap matmul form of the pairwise overlap).
+            bc = torch.matmul(torch.sqrt(Qp), torch.sqrt(Kp).transpose(-2, -1))  # [B, H, S, S]
+
+            # radius-1 canonical d_FR computed inline; migrate to the single
+            # reconciled qig-core binding when the convention reconcile lands.
+            # d_FR = arccos(BC) ∈ [0, π/2]. Clamp strictly INSIDE (-1, 1): acos'(±1)
+            # is infinite, so a bare [-1, 1] clamp NaNs the backward pass at
+            # coincident points (the self-attention diagonal) — same guard rationale
+            # as qig-core's _acos_safe.
+            margin = 1e-6 if bc.dtype in (torch.float32, torch.float64) else 1e-3
+            d_fr = torch.arccos(torch.clamp(bc, -1.0 + margin, 1.0 - margin))
+
+            # Sanctioned distance-Gibbs form: softmax(-d_FR/τ). No head_dim**0.5
+            # scale — that was the transformer QKᵀ normaliser, wrong for a bounded
+            # geodesic distance (it made attention near-uniform).
+            attn_weights = F.softmax(-d_fr / self.tau, dim=-1)
+
+            # Apply to simplex-valued values: the output is a convex combination of
+            # Δ points (stays on the manifold); out_proj maps back to model space.
+            out = torch.matmul(attn_weights, Vp)  # [B, H, S, D_head]
 
             # Reshape and project
             out = out.transpose(1, 2).contiguous().view(B, S, self.d_model)

{qigkernels-0.4.2 → qigkernels-0.4.4}/layer.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 
 import torch
-from qig_core.geometry_simplex import to_simplex_prob
+from qig_core.torch.geometry_simplex import to_simplex_prob
 from torch import Tensor, nn
 from torch.nn import functional as F
 
@@ -205,14 +205,25 @@ class QIGLayer(nn.Module):
 
         b, t, _d = hidden_state.shape
         p = self._project_to_simplex(hidden_state)
+        r = self.locality_radius
+        # COMPUTE-SKIPPING windowed-local attention: when a locality radius is set AND the band is narrower
+        # than the sequence, attend only within ±r — O(t·r) memory/compute instead of the O(t²) all-pairs
+        # arccos tensor. This is what lifts the quadratic VRAM ceiling and makes context LINEAR/extensible
+        # (the radius is the finite-propagation budget). Numerically IDENTICAL to the full+mask path within
+        # the band (matched-cell equivalence-gated in tests) — it SKIPS the out-of-band compute, not masks it.
+        if r is not None and t > (2 * r + 1):
+            return self._banded_attention(hidden_state, p, r, attention_mask=attention_mask)
+
+        # Full O(t²) path — global attention, OR small-t where the band already spans every key (so the
+        # banded result is identical). Unchanged.
         p_i = p[:, :, None, :]
         p_j = p[:, None, :, :]
 
         dist = self._fisher_rao_distance_simplex(p_i, p_j)
         logits = -dist / max(float(self.temperature), 1e-6)
-        if self.locality_radius is not None:  # windowed-local: mask keys outside ±radius (pure mask)
+        if r is not None:  # windowed-local: mask keys outside ±radius (pure mask; small-t branch)
             idx = torch.arange(t, device=hidden_state.device)
-            band = (idx[:, None] - idx[None, :]).abs() <= self.locality_radius  # [t, t]; self always in window
+            band = (idx[:, None] - idx[None, :]).abs() <= r  # [t, t]; self always in window
             logits = logits.masked_fill(~band[None, :, :], float("-inf"))
         weights = torch.softmax(logits, dim=-1)
 
@@ -233,18 +244,73 @@ class QIGLayer(nn.Module):
             output = output + torch.randn_like(output) * float(self.decoherence_std)
         return output
 
+    def _banded_attention(
+        self, hidden_state: Tensor, p: Tensor, r: int, *, attention_mask: Tensor | None
+    ) -> Tensor:
+        """Windowed Fisher-Rao attention computed ONLY within ±r of each query (compute-skipping, O(t·r)).
+        Numerically equivalent to the full+mask path within the band; the equivalence is gated in tests."""
+        b, t, k = p.shape
+        w = 2 * r + 1
+        # per-query key windows via pad+unfold (zero-pad → out-of-range keys, masked below)
+        p_pad = F.pad(p, (0, 0, r, r))                       # [b, t+2r, k]
+        p_win = p_pad.unfold(1, w, 1)                        # [b, t, k, w]
+        p_q = p[:, :, :, None]                               # [b, t, k, 1]
+        # SAME formula as _fisher_rao_distance_simplex (RADIUS-2 d_FR = 2·acos(BC), BC = Σ√(p·q)), inlined
+        # for the [b,t,k,w] band layout (sum over dim=2). Like that method it operates on the already-Δ p
+        # WITHOUT re-projection, so the band result stays numerically equivalent to the full path within
+        # the window (matched-cell equivalence-gated in tests).
+        bc = torch.sqrt((p_q * p_win).clamp_min(1e-12)).sum(dim=2).clamp(0.0, 1.0 - 1e-6)  # [b, t, w]
+        logits = (-2.0 * torch.acos(bc)) / max(float(self.temperature), 1e-6)              # [b, t, w]
+        # valid window positions: wpos p ↦ key (i - r + p); valid iff 0 <= key < t
+        i_idx = torch.arange(t, device=p.device)[:, None]    # [t, 1]
+        wpos = torch.arange(w, device=p.device)[None, :]     # [1, w]
+        key_idx = i_idx - r + wpos                           # [t, w]
+        valid = (key_idx >= 0) & (key_idx < t)               # [t, w] — band validity (self always valid)
+        # softmax over the BAND only (self valid → no all-(-inf) row → no NaN); key-padding is applied AFTER
+        # the softmax and renormalised — EXACTLY as the full+mask path does (so the two stay equivalent).
+        logits = logits.masked_fill(~valid[None].expand(b, t, w), float("-inf"))
+        weights = torch.softmax(logits, dim=-1)              # [b, t, w]
+        if attention_mask is not None:
+            kpm = attention_mask if attention_mask.dtype == torch.bool else attention_mask == 0  # True=pad
+            if kpm.shape != (b, t):
+                raise ValueError("attention_mask expected shape (B, T)")
+            keep_win = F.pad((~kpm).to(p.dtype), (r, r)).unfold(1, w, 1)   # [b, t, w] 1=valid key
+            weights = weights * (keep_win > 0.5)
+            weights = weights / (weights.sum(dim=-1, keepdim=True) + 1e-8)
+        if self.sparsity_threshold > 0.0:
+            keep_s = weights > float(self.sparsity_threshold)
+            weights = weights * keep_s
+            weights = weights / (weights.sum(dim=-1, keepdim=True) + 1e-8)
+        h_pad = F.pad(hidden_state, (0, 0, r, r))            # [b, t+2r, d]
+        h_win = h_pad.unfold(1, w, 1)                        # [b, t, d, w]
+        output = (weights[:, :, None, :] * h_win).sum(dim=-1)  # [b, t, d]
+        if self.decoherence_std > 0.0:
+            output = output + torch.randn_like(output) * float(self.decoherence_std)
+        return output
+
     def _project_to_simplex(self, x: Tensor, eps: float = 1e-8) -> Tensor:
+        # NOT a reimplementation of the simplex projection: a nonlinearity GUARD (abs / softplus to
+        # lift raw signed activations off the Duchi dead-gradient regime) COMPOSED with qig-core's
+        # canonical to_simplex_prob (the single-source Δ projection). The guard is the local part;
+        # the projection is imported.
         x = x.abs() if self.simplex_mode == "abs" else F.softplus(x)
         return to_simplex_prob(x, eps=eps)
 
     def _fisher_rao_distance_simplex(
         self, p: Tensor, q: Tensor, eps: float = 1e-8
     ) -> Tensor:
-        # Gradient-stable Fisher-Rao on Δ: d_FR = 2·arccos(BC), BC = Σ√(p·q). Clamp BC away from 1
-        # BEFORE acos — acos'(1)=∞ ⇒ the backward pass NaNs when two distributions COINCIDE (collapse):
-        # the deep-kernel NaN root cause. Distances between DISTINCT points (BC<1) are unchanged.
-        # (Self-contained so it survives qig_core version drift; qig_core's shared primitive clamps BC
-        #  to 1.0 and has the SAME latent gradient bug — flagged for Devin to fix at the source.)
+        # DELIBERATE local primitive — NOT drift. Binding-identical to qig-core's
+        # qig_core.torch.geometry_simplex.fisher_rao_distance_simplex (RADIUS-2 d_FR = 2·arccos(BC),
+        # BC = Σ√(p·q), clamp BEFORE acos so acos'(1)=∞ can't NaN the backward at coincidence/collapse —
+        # the deep-kernel NaN fix), BUT it intentionally does NOT defensively re-project p,q via
+        # to_simplex_prob the way qig-core's public API does. Two reasons it must stay local:
+        #   1. Trusted input: callers pass points already on Δ (from _project_to_simplex), so a second
+        #      Duchi projection is wasted compute.
+        #   2. Banded equivalence: the O(t·r) compute-skip path (_banded_attention) operates on the SAME
+        #      un-re-projected p. qig-core's re-projection (Duchi identity + eps-floor + renormalise) shifts
+        #      each coord by ~n·eps, which breaks the matched-cell equivalence gate (measured ~1.8e-4 drift
+        #      vs the gate's 1e-5 tol). Keeping this no-re-project form keeps full≡banded.
+        # (fp32 clamp 1-1e-6 == qig-core's fp32 _acos_safe margin; this pair trains in fp32.)
         bc = torch.sqrt((p * q).clamp_min(1e-12)).sum(dim=-1).clamp(0.0, 1.0 - 1e-6)
         return 2.0 * torch.acos(bc)
 

{qigkernels-0.4.2 → qigkernels-0.4.4}/natural_gradient_optimizer.py

@@ -59,9 +59,17 @@ class NaturalGradientDescent(Optimizer):
             momentum=momentum,
         )
         super().__init__(params, defaults)
-        
+
         self.compute_fisher = compute_fisher
-        
+        if compute_fisher is None:
+            import warnings
+            warnings.warn(
+                "NaturalGradientDescent(compute_fisher=None) degrades to SGD+momentum — the step is the "
+                "RAW gradient, NOT preconditioned by the Fisher information. For the tractable diagonal "
+                "empirical-Fisher natural gradient (the P1 geometric optimizer), use DiagonalNaturalGradient.",
+                stacklevel=2,
+            )
+
     def step(self, closure=None):
         """
         Perform single optimization step.

{qigkernels-0.4.2 → qigkernels-0.4.4}/pure_kernel_template.py

@@ -6,7 +6,7 @@ from typing import Any
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-from qig_core.geometry_simplex import fisher_rao_distance_simplex, to_simplex_prob
+from qig_core.torch.geometry_simplex import fisher_rao_distance_simplex, to_simplex_prob
 
 
 @dataclass(frozen=True)
@@ -39,6 +39,8 @@ KernelTelemetry = PureKernelTelemetry
 
 
 def _project_to_simplex(x: torch.Tensor, eps: float = 1e-8) -> torch.Tensor:
+    # softplus GUARD (lifts raw signed activations off the Duchi dead-gradient regime) COMPOSED with
+    # qig-core's canonical to_simplex_prob — a wrapper, not a reimplementation of the Δ projection.
     x = F.softplus(x)
     return to_simplex_prob(x, eps=eps)
 

{qigkernels-0.4.2 → qigkernels-0.4.4}/pyproject.toml

@@ -25,6 +25,17 @@ dev = [
 ]
 # Note: markdownlint-cli2 is a Node.js package, install via npm/yarn if needed
 
+# QIG self-wiring (Phase 2): which capability-contract slots this package fills.
+# Group = qig.capabilities; name = contract slot_id; value = module:attr probe.
+# qig-stack's qig-doctor enumerates these (metadata-only) to verify the crystal
+# assembled correctly before any compute spend.
+# NOTE: PROPOSED slot pending qig-stack contract ratification — not yet in
+# qig_stack/contract.json, so qig-doctor classifies it as DRIFT (WARN, non-fatal)
+# until the contract adds the matching slot. Additive; genuine canonical primitive
+# (Kernel: the geometric QIG kernel — stacked QIGLayers with Fisher-Rao telemetry).
+[project.entry-points."qig.capabilities"]
+"SLOT-KERNEL" = "qigkernels.kernel:Kernel"
+
 [tool.setuptools]
 packages = ["qigkernels", "qigkernels.reasoning"]
 package-dir = {"qigkernels" = ".", "qigkernels.reasoning" = "reasoning"}
@@ -81,3 +92,6 @@ forbidden-words = [
   "token-level cross entropy",
   "just fine-tune a transformer",
 ]
+
+[tool.uv.sources]
+qig-core = { path = "../qig-core", editable = true }

{qigkernels-0.4.2 → qigkernels-0.4.4/qigkernels.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qigkernels
-Version: 0.4.2
+Version: 0.4.4
 Summary: Geometric kernel and constellation library for QIG.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{qigkernels-0.4.2 → qigkernels-0.4.4}/qigkernels.egg-info/SOURCES.txt

@@ -37,7 +37,6 @@ safety.py
 sleep_packet.py
 specializations.py
 storage.py
-tokenizer_integration.py
 training_service.py
 uv.lock
 ./__init__.py
@@ -64,7 +63,6 @@ uv.lock
 ./sleep_packet.py
 ./specializations.py
 ./storage.py
-./tokenizer_integration.py
 ./training_service.py
 .github/workflows/release.yml
 docs/20251205-client-wiring-example-canonical-0.01F.md
@@ -80,6 +78,7 @@ docs/20251222-kernel-experiments-results-0.01F.md
 qigkernels.egg-info/PKG-INFO
 qigkernels.egg-info/SOURCES.txt
 qigkernels.egg-info/dependency_links.txt
+qigkernels.egg-info/entry_points.txt
 qigkernels.egg-info/requires.txt
 qigkernels.egg-info/scm_file_list.json
 qigkernels.egg-info/scm_version.json
@@ -105,7 +104,9 @@ scripts/20251222-kernel-training-exp-0.01W.py
 scripts/publish_pypi.sh
 scripts/train_constellation.py
 tests/__init__.py
+tests/test_banded_attention.py
 tests/test_coords_path.py
+tests/test_kernel4d_attention.py
 tests/test_locality.py
 tests/test_phi_collapse.py
 tests/test_reasoning.py

qigkernels-0.4.4/qigkernels.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[qig.capabilities]
+SLOT-KERNEL = qigkernels.kernel:Kernel

{qigkernels-0.4.2 → qigkernels-0.4.4}/qigkernels.egg-info/scm_file_list.json

@@ -1,84 +1,85 @@
 {
   "files": [
-    "CLAUDE.md",
-    "kernel.py",
-    ".gitignore",
+    "20251205-decisions-canonical-0.01F.md",
+    "sleep_packet.py",
     "crystallization.py",
-    "coordizer.py",
-    "pyproject.toml",
-    "__init__.py",
-    "constants.py",
-    ".editorconfig",
-    "20251205-readme-canonical-0.01F.md",
-    "storage.py",
     "markdownlint.json",
-    "constellation.py",
-    "safety.py",
-    "router.py",
-    "training_service.py",
-    "sleep_packet.py",
-    "20251205-decisions-canonical-0.01F.md",
-    "coord_adapter.py",
-    "20251205-type-symbol-manifest-canonical-0.01F.md",
-    "rel_coupling.py",
-    "20251205-roadmap-canonical-0.01F.md",
-    "natural_gradient_optimizer.py",
+    "README.md",
+    "py.typed",
+    "__init__.py",
+    "kernel.py",
     "pre-commit-config.yaml",
-    "20251205-naming-convention-canonical-0.01F.md",
-    "tokenizer_integration.py",
+    "coord_adapter.py",
+    "uv.lock",
+    "safety.py",
+    "layer.py",
+    "pyproject.toml",
     "basin_sync.py",
+    "20251220-gfp-spec-1.00W.md",
+    "20251205-naming-convention-canonical-0.01F.md",
+    "pure_kernel_template.py",
     "20251205-architecture-canonical-0.01F.md",
     "heart.py",
-    "kernel_100m.py",
-    "pure_kernel_template.py",
+    "coordizer.py",
+    "20251205-changelog-canonical-0.01F.md",
+    "memory_classes.py",
+    "20251205-type-symbol-manifest-canonical-0.01F.md",
+    "constants.py",
     "basin.py",
-    "uv.lock",
+    "kernel_100m.py",
+    "natural_gradient_optimizer.py",
+    "CLAUDE.md",
+    "router.py",
+    ".editorconfig",
     "kernel_4d.py",
-    "README.md",
-    "memory_classes.py",
-    "metrics.py",
+    "storage.py",
+    "training_service.py",
+    "constellation.py",
+    ".gitignore",
+    "20251205-roadmap-canonical-0.01F.md",
+    "20251205-readme-canonical-0.01F.md",
     "specializations.py",
-    "layer.py",
-    "py.typed",
-    "20251220-gfp-spec-1.00W.md",
-    "20251205-changelog-canonical-0.01F.md",
-    "reasoning/temporal.py",
+    "rel_coupling.py",
+    "metrics.py",
+    "scripts/20251222-kernel-training-exp-0.01W.py",
+    "scripts/train_constellation.py",
+    "scripts/publish_pypi.sh",
     "reasoning/__init__.py",
-    "reasoning/primitives.py",
-    "reasoning/constants.py",
-    "reasoning/qig_chain.py",
     "reasoning/temporal_attention.py",
     "reasoning/modes.py",
+    "reasoning/qig_chain.py",
+    "reasoning/primitives.py",
+    "reasoning/temporal.py",
+    "reasoning/constants.py",
     "reasoning/qig_chain_4d.py",
     "docs/20251222-federated-constellation-architecture-0.01W.md",
-    "docs/20251206-e8-consciousness-stack-diagram.md",
     "docs/20251222-kernel-constellation-research-0.01W.md",
-    "docs/20251205-client-wiring-example-canonical-0.01F.md",
-    "docs/20251220-index-1.00W.md",
-    "docs/20251206-integration-plan-ultra-mode-0.01H.md",
     "docs/20251222-kernel-experiments-results-0.01F.md",
-    "docs/20251206-rel-weighted-basin-sync-spec.md",
+    "docs/20251206-e8-consciousness-stack-diagram.md",
+    "docs/20251206-integration-plan-ultra-mode-0.01H.md",
+    "docs/20251205-client-wiring-example-canonical-0.01F.md",
     "docs/20251205-index-canonical-0.01F.md",
     "docs/20251220-qig-core-integration-table-1.00W.md",
-    ".github/workflows/release.yml",
+    "docs/20251220-index-1.00W.md",
+    "docs/20251206-rel-weighted-basin-sync-spec.md",
+    "tests/__init__.py",
+    "tests/test_reasoning.py",
+    "tests/test_banded_attention.py",
+    "tests/test_phi_collapse.py",
+    "tests/test_smoke.py",
+    "tests/test_coords_path.py",
+    "tests/test_kernel4d_attention.py",
+    "tests/test_locality.py",
     "research/track_c/run_kill_test.py",
+    "research/track_c/README.md",
     "research/track_c/readout_layer.py",
-    "research/track_c/20260223-track-c-expressibility-kill-test-1.00F.md",
     "research/track_c/dynamical_field.py",
-    "research/track_c/README.md",
-    "research/track_c/core_assets/ocean_neurochemistry.py",
+    "research/track_c/20260223-track-c-expressibility-kill-test-1.00F.md",
     "research/track_c/core_assets/__init__.py",
-    "research/track_c/core_assets/neural_oscillators.py",
     "research/track_c/core_assets/neurotransmitter_fields.py",
+    "research/track_c/core_assets/neural_oscillators.py",
+    "research/track_c/core_assets/ocean_neurochemistry.py",
     "tools/qig_purity_check.py",
-    "tests/test_reasoning.py",
-    "tests/test_coords_path.py",
-    "tests/__init__.py",
-    "tests/test_smoke.py",
-    "tests/test_phi_collapse.py",
-    "tests/test_locality.py",
-    "scripts/20251222-kernel-training-exp-0.01W.py",
-    "scripts/publish_pypi.sh",
-    "scripts/train_constellation.py"
+    ".github/workflows/release.yml"
   ]
 }

qigkernels-0.4.4/qigkernels.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.4.4",
+  "distance": 0,
+  "node": "gdb65a3cb1cb125e9c44640f0789a1402043152c5",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-04"
+}