feat(pins): Trinity Pins DSL - Single Source of Truth (#492)

- Lexer with proper token types (keywords, identifiers, strings, punctuation)
- Recursive descent parser for board, fabric, and design files
- XDC emitter that generates Vivado-compatible constraint files
- CLI commands: tri fpga pins {to-xdc|validate|ir|doctor}

Files:
- src/tri/pins_parser.zig - Full DSL implementation (~1400 LOC)
- src/tri/tri_fpga.zig - CLI routing for fpga pins commands
- fpga/boards/qmtech_xc7a100t.board.tri - Board definition with connectors
- fpga/designs/uart_bridge_fixed.design.tri - Test design binding

Generated XDC: uart_bridge_fixed.design.xdc
✓ uart_rx → FPGA L20 (FT232RL RXD)
✓ uart_tx → FPGA K20 (FT232RL TXD)
✓ led → FPGA T23 (Status LED)
✓ clk → FPGA M22 (50MHz oscillator)

Билд зелёный!

Author: Antigravity Agent

.trinity/dev_agents.json

@@ -1 +1 @@
-1775077532 score=100 laws=5/5 dirty=0 healed=18
+1775088476 score=100 laws=5/5 dirty=0 healed=18

.trinity/dev_loop_state.json

@@ -1 +1 @@
-{"agent":"mu","wake":324,"timestamp":1775079011,"errors_scanned":0,"fixes_applied":0,"build_ok":true,"test_ok":true}
+{"agent":"mu","wake":384,"timestamp":1775099069,"errors_scanned":0,"fixes_applied":0,"build_ok":true,"test_ok":true}

.trinity/dev_session.json

@@ -22,8 +22,10 @@ board qmtech_xc7a100t {
   }
 
   uart ft232rl {
-    txd fpga.K20   # FPGA uart_tx → FT232RL RXD (green, J2 pin 6)
-    rxd fpga.L20   # FT232RL TXD → FPGA uart_rx (white, J2 pin 5)
+    # FT232RL TXD (белый, J2.5) → FPGA uart_rx (L20)
+    # FT232RL RXD (зелёный, J2.6) → FPGA uart_tx (K20)
+    txd fpga.L20
+    rxd fpga.K20
     baud 115200
   }
 

.trinity/doctor_prev.dat

@@ -9,11 +9,11 @@ set_property LOC M22 [get_ports clk]
 set_property IOSTANDARD LVCMOS33 [get_ports clk]
 
 # board.uart.ft232rl.txd
-set_property LOC K20 [get_ports uart_rx]
+set_property LOC L20 [get_ports uart_rx]
 set_property IOSTANDARD LVCMOS33 [get_ports uart_rx]
 
 # board.uart.ft232rl.rxd
-set_property LOC L20 [get_ports uart_tx]
+set_property LOC K20 [get_ports uart_tx]
 set_property IOSTANDARD LVCMOS33 [get_ports uart_tx]
 
 # board.led.status

.trinity/mu/heartbeat.json

@@ -109,6 +109,60 @@ functions:
       grad_input[i] = sum_j(weights[i][j] * grad_output[j])
 
 behaviors:
+  - name: forward_dense
+    description: "Dense layer forward pass implementation"
+    implementation: |
+      pub fn forward(input: []const f32, weights: []const f32, bias: []const f32, output: []f32, config: DenseConfig) void {
+          const input_size = config.input_size;
+          const output_size = config.output_size;
+
+          for (0..output_size) |output_j| {
+              var sum: f32 = if (config.has_bias) bias[output_j] else 0;
+
+              for (0..input_size) |input_i| {
+                  const weight_idx = input_i * output_size + output_j;
+                  sum += input[input_i] * weights[weight_idx];
+              }
+
+              output[output_j] = sum; // Activation applied externally
+          }
+      }
+
+  - name: backward_dense
+    description: "Dense layer backward pass implementation"
+    implementation: |
+      pub fn backward(grad_output: []const f32, input: []const f32, weights: []const f32,
+      grad_input: []f32, grad_weights: []f32, grad_bias: []f32,
+      config: DenseConfig) void {
+          const input_size = config.input_size;
+          const output_size = config.output_size;
+
+          // Clear gradients
+          @memset(grad_weights, 0);
+
+          // Compute grad_weights and grad_bias
+          for (0..output_size) |output_j| {
+              if (config.has_bias) {
+                  grad_bias[output_j] = grad_output[output_j];
+              }
+
+              for (0..input_size) |input_i| {
+                  const weight_idx = input_i * output_size + output_j;
+                  grad_weights[weight_idx] += input[input_i] * grad_output[output_j];
+              }
+          }
+
+          // Compute grad_input
+          for (0..input_size) |input_i| {
+              var sum: f32 = 0;
+              for (0..output_size) |output_j| {
+                  const weight_idx = input_i * output_size + output_j;
+                  sum += weights[weight_idx] * grad_output[output_j];
+              }
+              grad_input[input_i] = sum;
+          }
+      }
+
   - name: matrix_multiply
     description: "Core operation is matrix-vector multiplication"
     implementation: |

codegen_impl

@@ -11,7 +11,7 @@ types:
   MSELossConfig:
     fields:
       - name: reduction
-        type: string
+        type: []const u8
         description: "mean, sum, or none"
 
 functions:
@@ -27,5 +27,37 @@ functions:
       # sum over all elements, divide by count
 
 behaviors:
+  - name: forward_mse_loss
+    description: "MSE loss forward implementation"
+    implementation: |
+      pub fn forward(predictions: []const f32, targets: []const f32) f32 {
+          const n = predictions.len;
+          if (n == 0) return 0;
+
+          var sum_loss: f32 = 0;
+          for (predictions, 0..) |pred, i| {
+              const diff = pred - targets[i];
+              sum_loss += diff * diff;
+          }
+
+          return sum_loss / @as(f32, @floatFromInt(n));
+      }
+
+  - name: backward_mse_loss
+    description: "MSE loss backward implementation"
+    implementation: |
+      pub fn backward(predictions: []const f32, targets: []const f32, grad_input: []f32) void {
+          const n = predictions.len;
+          if (n == 0) return;
+
+          const scale = 2.0 / @as(f32, @floatFromInt(n));
+          for (predictions, 0..) |pred, i| {
+              grad_input[i] = scale * (pred - targets[i]);
+          }
+      }
+
   - name: squared_error
     description: "Penalizes large errors more heavily"
+    implementation: |
+      Loss = mean((predictions - targets)^2)
+      Gradient = 2 * (predictions - targets) / n