Always regenerate .inputs from a fresh signal registry

Previously cmd_inputs only deleted-and-rebuilt .inputs tensors when
their length disagreed with the gate's .weight. That caught the
bit-cascade migration but missed the more common case: .inputs has
the right length but its signal IDs reference a stale registry from
an earlier build (signal IDs are session-local; a different cmd_inputs
run produces different IDs for the same logical signal).

build_inputs now clears every single-gate .inputs up front and
regenerates from a fresh SignalRegistry. Packed multi-gate tensors
keep their .inputs untouched because they use a different convention.

build_all.py: after quantize.py --ternary, re-invoke `build.py inputs`
so that the new modular detector gates introduced by ternarization
get routing metadata. Without this, 2,879 modular.mod{N}.eq.k{k}.*
gates per variant had no .inputs at all.

Verified on neural_alu8: gates without .inputs went from 2,879 to 0.
The remaining mismatched-length .inputs (~3,400) are in seed-file
gate families (expr_paren.mul, multiplier8x8, div8bit, rol8bit,
sub16/32bit) where infer_inputs_for_gate's pattern matchers don't
yet cover the specific substructure layout. Those need per-family
matchers added in a subsequent pass.

build.py

@@ -2978,23 +2978,29 @@ def build_inputs(tensors: Dict[str, torch.Tensor]) -> tuple[Dict[str, torch.Tens
     reg = SignalRegistry()
     gates = get_all_gates(tensors)
     stats = {"added": 0, "skipped": 0, "empty": 0, "regenerated": 0}
-    for gate in sorted(gates):
+
+    # Signal IDs are assigned freshly every run from a new SignalRegistry, so
+    # any pre-existing .inputs tensors reference stale IDs from a prior build.
+    # Drop them up front (except on packed multi-gate tensors, which use a
+    # different convention) and regenerate everything below.
+    preexisting_count = 0
+    for gate in list(gates):
         inputs_key = f"{gate}.inputs"
         weight_key = f"{gate}.weight"
         if inputs_key in tensors:
-            # Detect stale .inputs (length doesn't match the gate's fan-in)
-            # for single-gate tensors and regenerate them. Packed multi-gate
-            # tensors have weight.dim() > 1 and use a different convention,
-            # so we leave their .inputs alone.
-            existing = tensors[inputs_key]
             weight = tensors.get(weight_key)
-            if (weight is not None and weight.dim() == 1
-                    and existing.numel() != weight.numel()):
-                del tensors[inputs_key]
-                stats["regenerated"] += 1
-            else:
-                stats["skipped"] += 1
+            if weight is not None and weight.dim() > 1:
+                # Packed multi-gate tensor; don't touch.
                 continue
+            del tensors[inputs_key]
+            preexisting_count += 1
+    stats["regenerated"] = preexisting_count
+
+    for gate in sorted(gates):
+        inputs_key = f"{gate}.inputs"
+        if inputs_key in tensors:
+            stats["skipped"] += 1
+            continue
         inputs = infer_inputs_for_gate(gate, reg, tensors)
         if inputs:
             tensors[inputs_key] = torch.tensor(inputs, dtype=torch.int64)

build_all.py

@@ -63,6 +63,16 @@ def build_variant(bits: int, profile: str) -> Path:
     return out
 
 
+def regenerate_inputs(path: Path) -> None:
+    """Re-run `build.py inputs` so the routing metadata reflects gates added
+    or replaced by post-build steps (notably quantize.py --ternary, which
+    rebuilds modular detectors with a new gate name structure)."""
+    cmd = [sys.executable, str(ROOT / "build.py"), "--apply", "--model", str(path), "inputs"]
+    rc, log = run(cmd, timeout=300)
+    if rc != 0:
+        raise RuntimeError(f"inputs regeneration failed for {path.name}:\n{log[-800:]}")
+
+
 def quantize_variant(path: Path) -> tuple[int, int]:
     """Run quantize.py on a built variant. Returns (bytes_before, bytes_after)."""
     rc, log = run([sys.executable, str(ROOT / "quantize.py"), str(path)], timeout=300)
@@ -151,6 +161,9 @@ def main() -> None:
                 pre_q_meta = measure_variant(path)
                 # Quantize in-place; weights are integer-valued so this is exact.
                 qb, qa = quantize_variant(path)
+                # Quantize replaces some gates (modular detectors); rebuild
+                # routing metadata so .inputs covers the new structure.
+                regenerate_inputs(path)
                 meta = measure_variant(path)
                 ev = eval_variant(path, device="cpu", timeout=900)
                 rows.append({