Architecture Document 23: Anticipatory Transformer Architecture

P(token_t+1 | context_0:t) → argmax(probability distribution)

Commitment(trajectory_0:t) × Uncertainty(futures_t) → action_threshold
- High commitment + Low uncertainty = Generate immediately
- Low commitment + High uncertainty = Buffer and observe
- High commitment + High uncertainty = Surprising (adapt fast)

def compute_commitment_target(model, anchor, kernel, k_samples=5):
    """
    Self-supervised commitment signal via counterfactual stability.
    """
    # Sample k different admissible slices
    slices = [
        kernel.slice(anchor, policy=perturb_policy(base_policy, epsilon))
        for _ in range(k_samples)
    ]

    # Generate continuations for each
    continuations = [
        model.generate(slice, max_tokens=10)
        for slice in slices
    ]

    # Measure agreement (normalized edit distance)
    agreements = []
    for i in range(len(continuations)):
        for j in range(i+1, len(continuations)):
            agreements.append(
                1.0 - edit_distance(continuations[i], continuations[j]) / max_len
            )

    # High agreement = high commitment
    commitment = np.mean(agreements)
    return commitment

def commitment_via_robustness(model, context, k=5):
    """
    Commitment = robustness of next k tokens across temperatures.
    """
    temps = [0.5, 0.7, 1.0, 1.2, 1.5]
    samples = [
        model.generate(context, max_tokens=k, temperature=t)
        for t in temps
    ]

    # Low variance = high commitment
    variance = np.mean([
        edit_distance(samples[i], samples[j])
        for i in range(len(samples))
        for j in range(i+1, len(samples))
    ])

    commitment = 1.0 / (1.0 + variance)
    return commitment

# Commitment high when next structural token is unambiguous
commitment = P(next_token in {'{', '}', 'def', 'class', 'return'})

# Commitment high when sentence intention class is stable
commitment = max(P(intention_class | context))

┌─────────────────────────────────────────────────┐
│                Input Embedding                   │
└─────────────────┬───────────────────────────────┘
                  │
         ┌────────┴────────┐
         ▼                 ▼
┌─────────────────┐ ┌──────────────────┐
│  Fast Pathway   │ │   Slow Pathway   │
│                 │ │                  │
│ • Local attn    │ │ • Slice attn     │
│ • 8-12 layers   │ │ • 4-6 layers     │
│ • τ_fast = 4    │ │ • τ_slow = 64    │
│ • High freq     │ │ • Low freq       │
│ • Syntax/fluency│ │ • Semantics/plan │
└────────┬────────┘ └────────┬─────────┘
         │                   │
         └────────┬──────────┘
                  ▼
         ┌─────────────────┐
         │ Gating Network  │
         │ (Coordinator)   │
         └────────┬────────┘
                  ▼
         ┌─────────────────┐
         │ Output + Commit │
         │ + Uncertainty   │
         └─────────────────┘

L_total = L_recon + λ_smooth * L_smooth + λ_ortho * L_ortho + λ_info * L_info

L_recon = -log P(y | context)                    # Standard LM loss

# Temporal smoothness (within pathways)
L_smooth_fast = ||h^F_{t+1} - h^F_t||²
L_smooth_slow = ||h^S_{t+τ} - h^S_t||²           # Slower timescale
L_smooth = L_smooth_fast + L_smooth_slow

# Orthogonality penalty (force decorrelation, not just distance)
cov = (h^F - mean(h^F))^T @ (h^S - mean(h^S))
L_ortho = ||cov||²_F  # Frobenius norm of cross-covariance

# Information bottleneck on slow path (force low-freq compression)
# Slow path should only carry semantics, not high-freq details
L_info = -mutual_information(h^S, low_freq_target)

# Commitment coherence (penalize oscillation)
L_commit = ||commit_{t+1} - commit_t||²

# Uncertainty calibration
empirical_correct = (argmax(logits) == targets).float()
L_cal = ||1.0 - uncert - empirical_correct||²

λ_smooth = 0.01     # Smoothness regularization
λ_ortho = 0.1       # Orthogonality (decorrelation)
λ_info = 0.05       # Information bottleneck
λ_commit = 0.1      # Commitment smoothness
λ_cal = 0.2         # Uncertainty calibration

# Occasionally stop gradient from one path to prevent coupling
if step % stop_grad_freq == 0:
    h_fast = h_fast.detach()  # Slow can't pull fast

struct TrajectoryPosition {
    temporal: f64,      // Sequential position (like traditional PE)
    semantic: f64,      // Distance to current semantic anchor
    depth: f64,         // Nesting level (quotes, parentheticals, recursion)
    homogeneity: f64,   // Similarity to local context (regime stability)
    salience: f64,      // Dynamic importance (attention-weighted)
}

def trajectory_attention(Q, K, V, traj_coords, bias_net):
    """
    Trajectory-aware attention with ADDITIVE bias.
    Compatible with FlashAttention and numerically stable.
    """
    # Traditional dot-product attention
    scores = (Q @ K.T) / sqrt(d_k)  # [batch, n_heads, seq_len, seq_len]

    # Compute trajectory bias (learned per head)
    bias = compute_trajectory_bias(
        traj_coords,
        bias_net  # Learned bias function
    )  # [batch, n_heads, seq_len, seq_len]

    # ADD bias (not multiply)
    scores = scores + bias

    # Apply softmax
    weights = softmax(scores)
    return weights @ V

def compute_trajectory_bias(traj_coords, bias_net):
    """
    Compute additive bias from trajectory distance.
    Each attention head learns its own bias function.
    """
    # Compute pairwise ring distances
    ring_dist = pairwise_ring_distance(traj_coords)

    # Per-head learned bias (could be MLP or simple linear)
    # shape: [n_heads, 1] - per-head scale parameter
    bias = bias_net(ring_dist)  # Learned function of distance

    return bias

def pairwise_ring_distance(coords):
    """
    5D ring distance with learned dimension weights.
    Prevents any single dimension from dominating.
    """
    # Normalize each dimension independently
    temporal_norm = coords.temporal / temporal_scale
    semantic_norm = coords.semantic / semantic_scale  # From embeddings
    depth_norm = coords.depth / max_depth
    homogeneity_norm = coords.homogeneity  # Already [0,1]
    salience_norm = coords.salience  # Already [0,1]

    # Compute pairwise distances
    d_ring = sqrt(
        w_t * (temporal_norm[i] - temporal_norm[j])² +
        w_s * (semantic_norm[i] - semantic_norm[j])² +
        w_d * (depth_norm[i] - depth_norm[j])² +
        w_h * (homogeneity_norm[i] - homogeneity_norm[j])² +
        w_sal * (salience_norm[i] - salience_norm[j])²
    )

    # Weights w_* are LEARNED per attention head
    return d_ring

Semantic Regimes:
1. Exploration    - High uncertainty, many plausible futures
2. Consolidation  - Narrowing options, committing to direction
3. Synthesis      - Low uncertainty, executing committed plan
4. Transition     - Regime shift detected, recalibrating

class RegimeDetector(nn.Module):
    def __init__(self, d_model, n_regimes=4):
        self.regime_head = nn.Linear(d_model, n_regimes)

    def forward(self, h_fast, h_slow, commit, uncert):
        """
        Output differentiable regime distribution.
        """
        # Combine fast, slow, and commitment signals
        combined = torch.cat([
            h_fast,
            h_slow,
            commit.unsqueeze(-1),
            uncert.unsqueeze(-1)
        ], dim=-1)

        # Project to regime logits
        regime_logits = self.regime_head(combined)

        # Softmax to get regime probabilities (simplex)
        regime_probs = softmax(regime_logits)  # [batch, seq_len, 4]

        return regime_probs

def regime_conditional_attention(Q, K, V, regime_probs):
    """
    Mix attention patterns based on regime probabilities.
    Each regime has its own attention bias.
    """
    # Precompute attention for each regime
    attn_exploration = attention(Q, K, V, bias=exploration_bias)
    attn_consolidation = attention(Q, K, V, bias=consolidation_bias)
    attn_synthesis = attention(Q, K, V, bias=synthesis_bias)
    attn_transition = attention(Q, K, V, bias=transition_bias)

    # Mix according to regime probabilities
    output = (
        regime_probs[:, :, 0].unsqueeze(-1) * attn_exploration +
        regime_probs[:, :, 1].unsqueeze(-1) * attn_consolidation +
        regime_probs[:, :, 2].unsqueeze(-1) * attn_synthesis +
        regime_probs[:, :, 3].unsqueeze(-1) * attn_transition
    )

    return output

# Regime-specific loss weighting
regime_weights = {
    'exploration': 0.3,      # Less important (often tangential)
    'consolidation': 0.6,    # Medium importance
    'synthesis': 1.0,        # Most important (insights)
    'transition': 0.5        # Medium (recalibration)
}

# Weight reconstruction loss by regime
regime_weight = torch.sum(
    regime_probs * torch.tensor([0.3, 0.6, 1.0, 0.5]),
    dim=-1
)
L_recon_weighted = regime_weight * L_recon

# For interpretability, can hard-argmax regime
regime_idx = torch.argmax(regime_probs, dim=-1)
regime_name = ['exploration', 'consolidation', 'synthesis', 'transition'][regime_idx]

def select_context(
    anchor_query: Embedding,
    kernel: GraphKernel,
    budget: int,  # Token budget
    policy: SlicePolicy
) -> AdmissibleSliceBundle:
    """
    Deterministic context selection via priority-queue expansion.
    Operates on SliceExport primitives from graph kernel.

    Same input → identical output across runs.
    """

    # Initialize priority queue
    pq = PriorityQueue()

    # Request initial slice from kernel (always includes most recent context)
    initial_slice = kernel.slice(
        anchor=get_most_recent_turn(),
        policy=policy,
        budget=budget // 2  # Reserve half budget for expansion
    )

    # Verify admissibility
    assert initial_slice.verify_admissibility(kernel.hmac_secret)

    pq.push(initial_slice, priority=float('inf'))

    total_tokens = initial_slice.num_tokens()
    selected_slices = [initial_slice]

    while not pq.empty() and total_tokens < budget:
        current_slice = pq.pop()

        # Request neighbor slices from kernel
        neighbors = kernel.get_neighbor_slices(
            current_slice,
            policy=policy
        )

        for neighbor in neighbors:
            # Verify each neighbor is kernel-issued
            if not neighbor.verify_admissibility(kernel.hmac_secret):
                continue  # Skip non-admissible slices

            if total_tokens + neighbor.num_tokens() > budget:
                break  # Hard budget constraint

            priority = compute_priority(neighbor, anchor_query, policy)
            pq.push(neighbor, priority)

            selected_slices.append(neighbor)
            total_tokens += neighbor.num_tokens()

    # Deterministic ordering (stable sort by timestamp)
    selected_slices.sort(key=lambda s: s.anchor_turn_id)

    return AdmissibleSliceBundle(
        slices=selected_slices,
        fingerprint=compute_bundle_hash(selected_slices),
        budget_used=total_tokens
    )

def compute_priority(
    slice: SliceExport,
    query: Embedding,
    policy: SlicePolicy
) -> float:
    """
    Compute priority for a kernel slice.
    Uses phase weights calibrated to information density.
    """
    # Extract dominant phase from slice turns
    phase_counts = Counter(turn.phase for turn in slice.turns)
    dominant_phase = phase_counts.most_common(1)[0][0]

    priority = (
        slice.salience *                              # Base salience
        PHASE_WEIGHTS[dominant_phase] *               # Information density
        exp(-policy.distance_decay *                  # Semantic distance
            semantic_distance(slice.embedding, query)) *
        recency_boost(slice.anchor_turn().timestamp)  # Recent = higher priority
    )

    return priority

PHASE_WEIGHTS = {
    'synthesis': 1.0,      # Rare, breakthrough insights (0.1% of data, high signal)
    'planning': 0.9,       # Strategic thinking
    'consolidation': 0.6,  # Summarization
    'debugging': 0.5,      # Often repetitive
    'exploration': 0.3     # Often tangential
}

while not done:
    [sensitive field redacted]))
    output.append(token)

def anticipatory_decode(
    model,
    context,
    threshold_commit=0.8,
    max_buffer=5,        # NEW: Max buffer horizon
    max_wait_steps=3     # NEW: Max steps without committing
):
    """
    Commitment-gated generation with safety mechanisms.
    Prevents deadlock in high-uncertainty regimes.
    """
    committed_output = []   # Final, committed tokens
    draft_buffer = []       # Provisional tokens (may be revised)
    wait_steps = 0

    while not done:
        # Model outputs: logits, commitment, uncertainty
        logits, commit, uncert, regime_probs = model(context)

        # Multi-signal convergence check
        prob = max(softmax(logits))
        signals = {
            'probability': prob > threshold_commit,
            'commitment': commit > threshold_commit,
            'certainty': uncert < (1.0 - threshold_commit),
            'regime': regime_probs[2] > 0.5  # Synthesis regime
        }

        # Only commit if >= 3 signals agree
        if sum(signals.values()) >= 3:
            # High confidence - commit immediately
            [sensitive field redacted])
            committed_output.append(token)

            # Flush draft buffer
            if draft_buffer:
                committed_output.extend(draft_buffer)
                draft_buffer.clear()

            wait_steps = 0  # Reset wait counter

            if [sensitive field redacted]
                break

            context = append_and_trim(context, token)

        elif signals['commitment'] > 0.5:
            # Moderate confidence - buffer for revision
            [sensitive field redacted])
            draft_buffer.append(token)

            # SAFETY: Max buffer horizon
            if len(draft_buffer) >= max_buffer:
                # Commit buffer as "provisional"
                committed_output.extend(draft_buffer)
                draft_buffer.clear()
                wait_steps = 0

            context = append_and_trim(context, token)

        else:
            # Low confidence - wait/observe
            wait_steps += 1

            # SAFETY: Max wait steps (prevent infinite waiting)
            if wait_steps >= max_wait_steps:
                # Forced commit with warning flag
                [sensitive field redacted])
                committed_output.append(token)
                committed_output.append(PROVISIONAL_MARKER)
                wait_steps = 0
                context = append_and_trim(context, token)
            else:
                # Expand context (request more slices)
                context = expand_context(context, kernel, policy)

    return committed_output, draft_buffer

class GenerationOutput:
    committed: List[Token]      # Final, high-confidence tokens
    draft: List[Token]          # Provisional tokens (may change)
    commitment_scores: List[float]  # Per-token commitment

    def render_ui(self):
        """
        In a UI, show committed in black, draft in gray.
        User sees model thinking in real-time.
        """
        for token in self.committed:
            print(token, color='black', style='bold')
        for token in self.draft:
            print(token, color='gray', style='italic')

AnticipatorTransformer:
  ├─ Input Embedding Layer
  ├─ Trajectory Encoder (5D coordinates)
  ├─ Fast Pathway (8-12 layers, local token attention, τ=4)
  ├─ Slow Pathway (4-6 layers, slice cross-attention, τ=64)
  ├─ Gating Network (learns blending policy)
  ├─ Regime Detector (differentiable simplex over regimes)
  ├─ Output Heads:
  │   ├─ Token Logits (standard LM head)
  │   ├─ Commitment Score (scalar, 0-1, counterfactual stability)
  │   ├─ Uncertainty Estimate (scalar, 0-1, calibrated)
  │   └─ Regime Probabilities (simplex over 4 regimes)
  └─ Context Selector (kernel slice priority-queue)

class FastLayer(nn.Module):
    def __init__(self, d_model, n_heads, window_size=128):
        self.local_attn = LocalAttention(
            d_model, n_heads, window_size
        )
        self.ffn = FeedForward(d_model, expansion=4)
        self.norm1 = LayerNorm(d_model)
        self.norm2 = LayerNorm(d_model)

        # Per-head trajectory bias network
        self.traj_bias_net = nn.ModuleList([
            nn.Linear(5, 1)  # 5D trajectory → scalar bias per head
            for _ in range(n_heads)
        ])

    def forward(self, x, traj_coords):
        # Local trajectory-aware attention
        attn_out = self.local_attn(
            x, x, x,
            traj_coords=traj_coords,
            bias_net=self.traj_bias_net
        )
        x = self.norm1(x + attn_out)

        # Feed-forward
        ffn_out = self.ffn(x)
        x = self.norm2(x + ffn_out)

        return x

class SlowLayer(nn.Module):
    def __init__(self, d_model, n_heads, max_slices=32):
        # Cross-attention: attend to slice embeddings
        self.slice_cross_attn = CrossAttention(
            d_model, n_heads
        )

        # Materialization gate (expand slice → tokens only when needed)
        self.materialize_gate = nn.Linear(d_model, 1)

        self.ffn = FeedForward(d_model, expansion=4)
        self.norm1 = LayerNorm(d_model)
        self.norm2 = LayerNorm(d_model)
        self.max_slices = max_slices

    def forward(self, x_tokens, slice_embeddings):
        """
        x_tokens: [batch, seq_len, d_model] - token sequence
        slice_embeddings: [batch, num_slices, d_model] - compressed slices
        """
        # Cross-attention to slices (virtual context window)
        attn_out = self.slice_cross_attn(
            query=x_tokens,
            key=slice_embeddings,
            value=slice_embeddings
        )
        x = self.norm1(x_tokens + attn_out)

        # Feed-forward
        ffn_out = self.ffn(x)
        x = self.norm2(x + ffn_out)

        return x

class GatingNetwork(nn.Module):
    def __init__(self, d_model):
        self.project = nn.Linear(d_model * 2 + 2, d_model)
        self.gate = nn.Linear(d_model, 1)

    def forward(self, h_fast, h_slow, commit, uncert):
        # Concatenate fast, slow, and anticipation scalars
        combined = torch.cat([
            h_fast,
            h_slow,
            commit.unsqueeze(-1),
            uncert.unsqueeze(-1)
        ], dim=-1)

        # Learn gating weight
        α = torch.sigmoid(self.gate(self.project(combined)))

        # Blend outputs
        h = α * h_fast + (1 - α) * h_slow

        return h, α

def compute_loss(
    model_out,
    targets,
    h_fast,
    h_slow,
    commit,
    uncert,
    regime_probs
):
    # 1. Reconstruction loss (standard LM)
    L_recon = cross_entropy(model_out, targets)

    # 2. Temporal smoothness (within pathways)
    L_smooth_fast = mse(h_fast[1:], h_fast[:-1])
    L_smooth_slow = mse(h_slow[::stride], h_slow[:-stride])
    L_smooth = L_smooth_fast + L_smooth_slow

    # 3. Orthogonality penalty (force decorrelation)
    h_fast_centered = h_fast - h_fast.mean(dim=0)
    h_slow_centered = h_slow - h_slow.mean(dim=0)
    cov_matrix = h_fast_centered.T @ h_slow_centered
    L_ortho = torch.norm(cov_matrix, p='fro')  # Frobenius norm

    # 4. Commitment coherence (penalize oscillation)
    L_commit = mse(commit[1:], commit[:-1])

    # 5. Uncertainty calibration (match empirical correctness)
    empirical_correct = (argmax(model_out) == targets).float()
    L_calibration = mse(1.0 - uncert, empirical_correct)

    # 6. Regime-weighted reconstruction
    regime_weight = torch.sum(
        regime_probs * torch.tensor([0.3, 0.6, 1.0, 0.5]),
        dim=-1
    )
    L_recon_weighted = (regime_weight * L_recon).mean()

    # Weighted combination
    L_total = (
        L_recon_weighted +
        λ_smooth * L_smooth +
        λ_ortho * L_ortho +
        λ_commit * L_commit +
        λ_cal * L_calibration
    )

    return L_total

λ_smooth = 0.01     # Smoothness regularization
λ_ortho = 0.1       # Orthogonality (decorrelation)
λ_commit = 0.1      # Commitment smoothness
λ_cal = 0.2         # Uncertainty calibration

def generate(
    model,
    prompt,
    kernel,
    policy,
    max_tokens=512,
    commit_threshold=0.8,
    uncert_threshold=0.3
):
    # Select initial context slices from kernel
    slice_bundle = select_context(
        anchor_query=encode(prompt),
        kernel=kernel,
        budget=model.slice_budget,
        policy=policy
    )

    # Verify all slices are kernel-issued
    for slice in slice_bundle.slices:
        assert slice.verify_admissibility(kernel.hmac_secret)

    # Compress slices to embeddings for slow pathway
    slice_embeddings = [
        compress_slice(slice) for slice in slice_bundle.slices
    ]

    committed_output = []
    draft_buffer = []
    wait_steps = 0

    for step in range(max_tokens):
        # Forward pass
        logits, h_fast, h_slow, commit, uncert, regime_probs = model(
            tokens=committed_output + draft_buffer,
            slice_embeddings=slice_embeddings
        )

        # Multi-signal convergence check
        prob = max(softmax(logits[-1]))
        signals = {
            'probability': prob > commit_threshold,
            'commitment': commit > commit_threshold,
            'certainty': uncert < uncert_threshold,
            'regime': regime_probs[-1, 2] > 0.5  # Synthesis
        }

        # Commitment-gated generation (with safety)
        if sum(signals.values()) >= 3:
            [sensitive field redacted])
            committed_output.append(token)

            if draft_buffer:
                committed_output.extend(draft_buffer)
                draft_buffer.clear()

            wait_steps = 0

            if [sensitive field redacted]
                break

        elif signals['commitment'] > 0.5:
            [sensitive field redacted])
            draft_buffer.append(token)

            # Safety: max buffer
            if len(draft_buffer) >= 5:
                committed_output.extend(draft_buffer)
                draft_buffer.clear()

        else:
            wait_steps += 1

            # Safety: max wait steps
            if wait_steps >= 3:
                [sensitive field redacted])
                committed_output.append(token)
                wait_steps = 0

    return committed_output, draft_buffer

def measure_latency_gain(model, baseline, dataset, Q_target):
    """
    Hold quality constant, measure input context length required.
    """
    results = []

    for sample in dataset:
        # Baseline: Binary search for minimum context achieving Q_target
        baseline_ctx_len = binary_search_min_context(
            model=baseline,
            sample=sample,
            quality_fn=compute_quality,
            target=Q_target
        )

        # Anticipatory: Same procedure
        anticipatory_ctx_len = binary_search_min_context(
            model=model,
            sample=sample,
            quality_fn=compute_quality,
            target=Q_target
        )

        gain = (baseline_ctx_len - anticipatory_ctx_len) / baseline_ctx_len
        results.append(gain)

    return np.mean(results), np.std(results)

def compute_contributing_tokens(model, context, output):
    """
    Ablate each context slice and measure loss delta.
    Contribution = measurable degradation when removed.
    """
    baseline_loss = model.loss(context, output)

    contributions = []
    for i, slice in enumerate(context.slices):
        # Remove slice i
        ablated_context = context.without_slice(i)
        ablated_loss = model.loss(ablated_context, output)

        # Contribution = loss increase when removed
        contribution = ablated_loss - baseline_loss
        contributions.append(contribution)

    # "Contributing" = top-k by contribution score
    contributing_slices = sorted(
        enumerate(contributions),
        key=lambda x: x[1],
        reverse=True
    )[:k]

    return contributing_slices

Relevance Score = sum(contribution_i for i in selected_slices) / total_tokens

Compare:
- Fixed window (last N tokens)
- Recency-only (last N turns, no priority)
- Priority-queue kernel slices (proposed)

def measure_specialization(h_fast, h_slow):
    """
    Specialization Index = cross-covariance Frobenius norm.
    Low = specialized, High = mode collapse.
    """
    h_fast_centered = h_fast - h_fast.mean(dim=0)
    h_slow_centered = h_slow - h_slow.mean(dim=0)

    cov_matrix = h_fast_centered.T @ h_slow_centered
    specialization_index = torch.norm(cov_matrix, p='fro')

    return specialization_index.item()

def measure_frequency_separation(h_fast, h_slow):
    """
    Fast should have high-frequency content, slow should have low-frequency.
    Measure via FFT power spectrum.
    """
    fft_fast = torch.fft.fft(h_fast, dim=0)
    fft_slow = torch.fft.fft(h_slow, dim=0)

    # Measure power in high-frequency bands
    high_freq_power_fast = torch.sum(torch.abs(fft_fast[cutoff:]))
    high_freq_power_slow = torch.sum(torch.abs(fft_slow[cutoff:]))

    # Fast should have MORE high-freq power than slow
    freq_separation = high_freq_power_fast / high_freq_power_slow

    return freq_separation.item()

/// Exported slice from Graph Kernel with full provenance.
pub struct SliceExport {
    /// Anchor turn this slice was built around
    pub anchor_turn_id: TurnId,

    /// Turns in the slice, sorted by TurnId
    pub turns: Vec<TurnSnapshot>,

    /// Edges between turns in the slice
    pub edges: Vec<Edge>,

    /// Policy identifier (e.g., "slice_policy_v1")
    pub policy_id: String,

    /// Hash of policy parameters (deterministic)
    pub policy_params_hash: String,

    /// Schema version
    pub schema_version: String,

    /// Unique fingerprint of this slice (selection identity)
    pub slice_id: SliceFingerprint,

    /// Graph state at slicing time (content immutability proof)
    pub graph_snapshot_hash: GraphSnapshotHash,

    /// Unforgeable admissibility claim from Graph Kernel (HMAC-SHA256)
    pub admissibility_token: AdmissibilityToken,
}

impl SliceExport {
    /// Verify this slice was issued by the kernel.
    pub fn verify_admissibility(&self, hmac_secret: &[u8]) -> bool {
        self.admissibility_token.verify_hmac(
            hmac_secret,
            &self.slice_id,
            &self.anchor_turn_id,
            &self.policy_id,
            &self.policy_params_hash,
            &self.graph_snapshot_hash,
            &self.schema_version,
        )
    }

    /// Check if a turn is admissible in this slice.
    pub fn is_turn_admissible(&self, turn_id: &TurnId) -> bool {
        self.turns.binary_search_by_key(turn_id, |t| t.id).is_ok()
    }
}

class SliceBundle:
    """
    Bundle of admissible slices for transformer consumption.
    """
    def __init__(self, slices: List[SliceExport], kernel_secret: bytes):
        self.slices = slices
        self.kernel_secret = kernel_secret

        # Verify all slices are kernel-issued
        for slice in slices:
            assert slice.verify_admissibility(kernel_secret), \
                f"Slice {slice.slice_id} failed admissibility check"

        # Compute bundle fingerprint (for audit trail)
        self.bundle_fingerprint = self._compute_fingerprint()

    def _compute_fingerprint(self) -> str:
        """
        Content-derived hash of entire bundle.
        Enables deterministic replay of context selection.
        """
        slice_ids = sorted([s.slice_id for s in self.slices])
        return canonical_hash(slice_ids)

    def compress_to_embeddings(self, encoder: SliceEncoder) -> torch.Tensor:
        """
        Compress slices to fixed-size embeddings for slow pathway.

        Each slice → single embedding vector.
        Slow pathway attends to these compressed representations.
        """
        embeddings = []
        for slice in self.slices:
            # Encode slice content
            slice_embedding = encoder.encode(
                turns=slice.turns,
                edges=slice.edges,
                metadata={
                    'phase': slice.dominant_phase(),
                    'salience': slice.average_salience(),
                    'timestamp': slice.anchor_turn().timestamp
                }
            )
            embeddings.append(slice_embedding)

        return torch.stack(embeddings)  # [num_slices, d_model]

    def materialize_slice(self, slice_idx: int, tokenizer) -> List[Token]:
        """
        Materialize a slice to full token sequence (optional, expensive).
        Only called when materialization gate activates.
        """
        slice = self.slices[slice_idx]

        # Concatenate turn contents
        full_text = "\n".join([turn.content for turn in slice.turns])
        tokens = tokenizer.encode(full_text)

        return tokens

    def get_provenance_trail(self) -> Dict:
        """
        Export full provenance for auditing.
        Enables tracing model decisions back to kernel slices.
        """
        return {
            'bundle_fingerprint': self.bundle_fingerprint,
            'slices': [
                {
                    'slice_id': s.slice_id,
                    'anchor_turn': s.anchor_turn_id,
                    'policy_id': s.policy_id,
                    'graph_snapshot': s.graph_snapshot_hash,
                    'admissibility_token': s.admissibility_token,
                    'num_turns': len(s.turns),
                    'num_tokens': s.num_tokens()
                }
                for s in self.slices
            ]
        }

Token Sequence (small window)  ─┐
                                 ├─→ Token Self-Attention (Fast)
                                 │
Kernel Slices (compressed)  ────┼─→ Slice Cross-Attention (Slow)
                                 │
                                 └─→ Gating Network → Output

class SliceAwareTransformer(nn.Module):
    def __init__(self, d_model, n_heads, n_fast_layers, n_slow_layers):
        # Fast pathway: token self-attention
        self.fast_layers = nn.ModuleList([
            FastLayer(d_model, n_heads, window_size=128)
            for _ in range(n_fast_layers)
        ])

        # Slow pathway: slice cross-attention
        self.slow_layers = nn.ModuleList([
            SlowLayer(d_model, n_heads, max_slices=32)
            for _ in range(n_slow_layers)
        ])

        # Slice encoder (compresses SliceExport → embedding)
        self.slice_encoder = SliceEncoder(d_model)

        # Coordinator
        self.gating = GatingNetwork(d_model)

    def forward(self, token_ids, slice_bundle: SliceBundle):
        # Encode tokens
        x_tokens = self.embed_tokens(token_ids)

        # Compress slices to embeddings
        slice_embeddings = slice_bundle.compress_to_embeddings(
            self.slice_encoder
        )

        # Fast pathway: process tokens
        h_fast = x_tokens
        for layer in self.fast_layers:
            h_fast = layer(h_fast, traj_coords=None)

        # Slow pathway: attend to slices
        h_slow = x_tokens  # Same initial state
        for layer in self.slow_layers:
            h_slow = layer(h_slow, slice_embeddings)

        # Coordinate outputs
        h_combined, alpha = self.gating(h_fast, h_slow, commit, uncert)

        return h_combined

class ModelOutput:
    """
    Model output with full provenance trail.
    """
    tokens: List[Token]
    commitment_scores: List[float]
    uncertainty_scores: List[float]
    regime_probs: torch.Tensor

    # Provenance fields
    slice_bundle_fingerprint: str
    slice_ids: List[str]
    slice_admissibility_tokens: List[str]

    def export_audit_log(self) -> Dict:
        """
        Export audit log for debugging/analysis.
        Enables tracing each token back to source slices.
        """
        return {
            'output_tokens': self.tokens,
            'commitment_per_token': self.commitment_scores,
            'uncertainty_per_token': self.uncertainty_scores,
            'regimes_per_token': self.regime_probs.tolist(),
            'provenance': {
                'bundle_fingerprint': self.slice_bundle_fingerprint,
                'source_slices': [
                    {
                        'slice_id': sid,
                        'admissibility_token': token,
                        'verified': True  # All tokens verified at input
                    }
                    for sid, token in zip(
                        self.slice_ids,
                        self.slice_admissibility_tokens
                    )
                ]
            }
        }