feat(norm): implement ternary normalization (OPT-T06)

- Add TernaryNormWeights struct with 2-bit packed format
- Implement quantizeToTernary for f32 → ternary conversion
- Add ternaryRmsNorm and simdTernaryRmsNorm functions
- Integrate into tri_inference.zig with enableTernaryNorm()
- Memory savings: 16x (f32 → 2-bit per weight)
- Speed: 0.2x (trades speed for memory)
- Accuracy: <10% max relative error

Co-authored-by: Ona <no-reply@ona.com>

Author: gHashTag

docs/DISCOVERIES.md

@@ -77,7 +77,7 @@ Where:
 | OPT-T03 | Ternary KV Cache | 16x | 1.5x | ✅ Implemented |
 | OPT-T04 | Ternary Attention | 16x | 1.5x | ✅ Implemented |
 | OPT-T05 | Ternary Embeddings | 12.8x | 1x | ✅ Implemented |
-| OPT-T06 | Ternary Normalization | 20x | 3x | 📋 Planned |
+| OPT-T06 | Ternary Normalization | 16x | 0.2x | ✅ Implemented |
 
 ### Business Value
 
@@ -304,6 +304,52 @@ Compression:       12.8x
 - Ternary KV cache: 12.8x compression
 - Combined similarity: 0.88 (vs 0.93 with only KV cache)
 
+### Ternary Normalization (OPT-T06)
+
+**Status**: ✅ Implemented
+
+| Component | File | Description |
+|-----------|------|-------------|
+| TernaryNormWeights | `simd_matmul.zig` | Packed ternary norm weights |
+| quantizeToTernary | `simd_matmul.zig` | Convert f32 → ternary |
+| ternaryRmsNorm | `simd_matmul.zig` | Scalar ternary RMSNorm |
+| simdTernaryRmsNorm | `simd_matmul.zig` | SIMD-optimized version |
+| enableTernaryNorm | `tri_inference.zig` | Enable for all layers |
+
+**Memory Savings:**
+```
+f32 norm weights:     hidden_size × 4 bytes
+Ternary norm weights: hidden_size / 4 bytes (2 bits per weight)
+Compression:          16x
+```
+
+**Benchmark Results (hidden_size=2048, 10K iterations):**
+```
+╔══════════════════════════════════════════════════════════════╗
+║           TERNARY NORM BENCHMARK                             ║
+╠══════════════════════════════════════════════════════════════╣
+║  f32 RMSNorm:          617.6 ns/iter                        ║
+║  Ternary RMSNorm:     3040.3 ns/iter                        ║
+║  Speedup:               0.20x (slower)                      ║
+║  Memory savings:        16x                                  ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+**Key Insight:** Ternary normalization trades speed for memory. The unpacking overhead makes it ~5x slower than f32, but provides 16x memory reduction. This is useful for:
+- Memory-constrained devices (mobile, edge)
+- Large models where norm weights are significant
+- Scenarios where memory bandwidth is the bottleneck
+
+**Accuracy:**
+- Max relative error: <10% (acceptable for inference)
+- Similar to INT8 quantization error margins
+
+**Usage:**
+```zig
+var model = try TriModel.load(allocator, "model.tri");
+try model.enableTernaryNorm(); // 16x memory reduction for norm weights
+```
+
 ### Batch Processing (INF-004)
 
 **Status**: ✅ Implemented

specs/tri/ternary_normalization.vibee

@@ -0,0 +1,70 @@
+# ternary_normalization.vibee
+# TernaryNorm: RMSNorm with ternary-quantized weights
+# Reduces weight memory by 16x (f32 -> 2-bit)
+
+name: ternary_normalization
+version: "1.0.0"
+language: zig
+module: ternary_normalization
+
+types:
+  TernaryNormWeights:
+    description: "Ternary-quantized normalization weights"
+    fields:
+      packed_ternary: List<u8>    # 4 ternary values per byte
+      scale: Float               # Scale factor for reconstruction
+      size: Int                  # Original weight count
+
+  NormConfig:
+    description: "Normalization configuration"
+    fields:
+      eps: Float                 # Epsilon for numerical stability (default 1e-5)
+      use_simd: Bool             # Enable SIMD optimization
+
+behaviors:
+  - name: quantize_norm_weights
+    given: f32 normalization weights array
+    when: quantizing to ternary format
+    then: returns TernaryNormWeights with packed ternary values and scale
+
+  - name: ternary_rms_norm
+    given: input tensor, TernaryNormWeights, epsilon
+    when: applying RMS normalization with ternary weights
+    then: returns normalized output with ternary weight multiplication
+
+  - name: simd_ternary_rms_norm
+    given: input tensor, TernaryNormWeights, epsilon
+    when: applying SIMD-optimized RMS normalization
+    then: returns normalized output using SIMD for sum-of-squares and ternary multiply
+
+  - name: unpack_ternary_weight
+    given: packed byte, position (0-3)
+    when: extracting single ternary value
+    then: returns -1, 0, or +1
+
+  - name: ternary_multiply_add
+    given: input value, ternary value (-1/0/+1), scale
+    when: multiplying by ternary weight
+    then: returns input * (ternary * scale) without actual multiplication
+
+# Algorithm:
+# 1. RMS = sqrt(mean(x^2) + eps)
+# 2. x_norm = x / RMS
+# 3. output = x_norm * (ternary_weight * scale)
+#
+# Ternary multiply optimization:
+# - ternary = +1: output = x_norm * scale
+# - ternary =  0: output = 0
+# - ternary = -1: output = -x_norm * scale
+#
+# Memory savings:
+# - f32 weights: 4 bytes per weight
+# - ternary: 2 bits per weight = 0.25 bytes
+# - Compression: 16x
+
+# Packing format:
+# Each byte stores 4 ternary values:
+# bits [1:0] = value 0 (00=-1, 01=0, 10=+1)
+# bits [3:2] = value 1
+# bits [5:4] = value 2
+# bits [7:6] = value 3