fix(hslm): add JEPA constants + forwardHidden/backwardHidden + evolve Zig 0.15 compat

- constants.zig: 6 JEPA constants (EMA decay, mask ratio, ternary spans)
- model.zig: forwardHidden/backwardHidden for T-JEPA hidden state access
- tri_farm_evolve.zig: u01_lr→unit_lr naming, runMock stub, File.writer→bufPrint (Zig 0.15.2)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Antigravity Agent

src/hslm/constants.zig

@@ -130,6 +130,14 @@ test "config param count" {
     try std.testing.expect(count < 2_100_000);
 }
 
+// T-JEPA configuration
+pub const JEPA_EMA_DECAY_START: f32 = 0.996;
+pub const JEPA_EMA_DECAY_END: f32 = 1.0;
+pub const JEPA_MASK_RATIO: f32 = 0.6;
+pub const JEPA_MIN_SPAN: usize = 3; // = 3, ternary
+pub const JEPA_MAX_SPAN: usize = 9; // = 3², sacred
+pub const JEPA_NUM_SPANS: usize = 3; // = 3, trinity
+
 test "consciousness threshold is phi inverse" {
     try std.testing.expectApproxEqAbs(PHI_INV, CONSCIOUSNESS_THRESHOLD, 1e-10);
     try std.testing.expect(CONSCIOUSNESS_THRESHOLD > 0.6);

src/hslm/model.zig

@@ -316,6 +316,58 @@ pub const HSLM = struct {
         }
     }
 
+    /// Forward pass returning hidden states (before output projection) for all positions.
+    /// Used by T-JEPA to extract representations.
+    pub fn forwardHidden(self: *Self, tokens: []const u16, hidden_out: []f32) void {
+        const seq_len = @min(tokens.len, CONTEXT_LEN);
+
+        var float_seq: [CONTEXT_LEN * EMBED_DIM]f32 = undefined;
+        var trit_seq: [CONTEXT_LEN * VSA_DIM]i8 = undefined;
+        self.emb.embedSequence(tokens[0..seq_len], &float_seq, &trit_seq);
+
+        var cur_float: [CONTEXT_LEN * EMBED_DIM]f32 = float_seq;
+        var cur_trit: [CONTEXT_LEN * VSA_DIM]i8 = trit_seq;
+        var next_float: [CONTEXT_LEN * EMBED_DIM]f32 = undefined;
+        var next_trit: [CONTEXT_LEN * VSA_DIM]i8 = undefined;
+
+        for (&self.blocks) |*block| {
+            block.sacred_attn.resetCache();
+            for (0..seq_len) |pos| {
+                const f_off = pos * EMBED_DIM;
+                const t_off = pos * VSA_DIM;
+                block.forward(
+                    pos,
+                    cur_float[f_off .. f_off + EMBED_DIM],
+                    cur_trit[0 .. (pos + 1) * VSA_DIM],
+                    next_float[f_off .. f_off + EMBED_DIM],
+                    next_trit[t_off .. t_off + VSA_DIM],
+                );
+            }
+            cur_float = next_float;
+            cur_trit = next_trit;
+        }
+
+        // Copy hidden states (no output projection)
+        @memcpy(hidden_out[0 .. seq_len * EMBED_DIM], cur_float[0 .. seq_len * EMBED_DIM]);
+    }
+
+    /// Backward pass through blocks only (no output projection).
+    /// Used by T-JEPA where gradient comes from representation loss, not logits.
+    pub fn backwardHidden(self: *Self, grad_hidden: []const f32) void {
+        var grad_current: [EMBED_DIM]f32 = undefined;
+        @memcpy(&grad_current, grad_hidden[0..EMBED_DIM]);
+        var grad_next: [EMBED_DIM]f32 = undefined;
+
+        var block_idx: usize = NUM_BLOCKS;
+        while (block_idx > 0) {
+            block_idx -= 1;
+            self.blocks[block_idx].tnn.backward(&grad_current, &grad_next);
+            var grad_attn_input: [EMBED_DIM]f32 = undefined;
+            self.blocks[block_idx].sacred_attn.backward(&grad_next, &grad_attn_input);
+            grad_current = grad_attn_input;
+        }
+    }
+
     /// Generate next token (greedy)
     pub fn generate(self: *Self, tokens: []const u16) u16 {
         var logits: [VOCAB_SIZE]f32 = undefined;