feat(03-01): extend TrafficClass to 14 classes with hash-bucketed unknowns

- Replace ClassUnknown with ClassUnknown1-4 (unknown-1 through unknown-4)
- AllClasses() now returns 14 elements
- Add hashBucket() function routing unrecognized traffic deterministically
- Update synth/config.go: NumLayers=14, 4 dissonant unknown tone configs at 862-1047 Hz
- Add TestAllClassesCount and TestHashBucketDistribution tests
- Add TestClassFreqConfigsComplete and TestNumLayersMatchesAllClasses to config_test.go
- Update TestNewBankHas14Layers, TestMixerNoClip for 14 classes
- All classify and synth tests pass

classify/classifier.go

@@ -17,10 +17,9 @@ func NewClassifier(rules []Rule) *Classifier {
 
 // Classify inspects a gopacket.Packet and returns a ClassifiedPacket.
 // It checks ICMP first, then extracts TCP/UDP port info and matches against rules.
-// Per D-03: returns ClassUnknown if no rule matches.
+// Per D-03: returns ClassUnknown1-4 via hash-bucketing if no rule matches.
 func (c *Classifier) Classify(pkt gopacket.Packet) ClassifiedPacket {
 	result := ClassifiedPacket{
-		Class:  ClassUnknown,
 		Length: len(pkt.Data()),
 	}
 
@@ -34,6 +33,7 @@ func (c *Classifier) Classify(pkt gopacket.Packet) ClassifiedPacket {
 				return result
 			}
 		}
+		result.Class = hashBucket(result.DstPort, result.Protocol)
 		return result
 	}
 
@@ -49,6 +49,7 @@ func (c *Classifier) Classify(pkt gopacket.Packet) ClassifiedPacket {
 				return result
 			}
 		}
+		result.Class = hashBucket(result.DstPort, result.Protocol)
 		return result
 	}
 
@@ -64,9 +65,37 @@ func (c *Classifier) Classify(pkt gopacket.Packet) ClassifiedPacket {
 				return result
 			}
 		}
+		result.Class = hashBucket(result.DstPort, result.Protocol)
 		return result
 	}
 
-	// No recognized transport layer -> ClassUnknown per D-03
+	// No recognized transport layer -> hash-bucket per D-03
+	result.Class = hashBucket(result.DstPort, result.Protocol)
 	return result
 }
+
+// hashBucket maps an unrecognized packet to one of 4 unknown traffic classes.
+// Deterministic: same (dstPort, protocol) always maps to the same bucket.
+// ARP and other non-transport packets have dstPort=0, protocol="" -> bucket 0 (ClassUnknown1).
+func hashBucket(dstPort uint16, protocol string) TrafficClass {
+	var protoNum uint16
+	switch protocol {
+	case "tcp":
+		protoNum = 6
+	case "udp":
+		protoNum = 17
+	case "icmp":
+		protoNum = 1
+	}
+	h := uint32(dstPort)*31 + uint32(protoNum)*7
+	switch h % 4 {
+	case 0:
+		return ClassUnknown1
+	case 1:
+		return ClassUnknown2
+	case 2:
+		return ClassUnknown3
+	default:
+		return ClassUnknown4
+	}
+}

classify/classifier_test.go

@@ -1,6 +1,7 @@
 package classify_test
 
 import (
+	"strings"
 	"testing"
 
 	"github.com/gopacket/gopacket"
@@ -220,8 +221,8 @@ func TestClassify(t *testing.T) {
 	t.Run("TestClassifyUnknown", func(t *testing.T) {
 		pkt := buildUnknownPacket(t)
 		got := c.Classify(pkt)
-		if got.Class != classify.ClassUnknown {
-			t.Errorf("Unknown packet: got class %q, want %q", got.Class, classify.ClassUnknown)
+		if !strings.HasPrefix(string(got.Class), "unknown-") {
+			t.Errorf("Unknown packet: got class %q, want unknown-N bucket", got.Class)
 		}
 	})
 
@@ -241,3 +242,58 @@ func TestClassify(t *testing.T) {
 		}
 	})
 }
+
+func TestAllClassesCount(t *testing.T) {
+	classes := classify.AllClasses()
+	if len(classes) != 14 {
+		t.Errorf("AllClasses() returned %d classes, want 14", len(classes))
+	}
+	// No plain "unknown" should exist
+	for _, c := range classes {
+		if c == "unknown" {
+			t.Error("AllClasses() still contains plain \"unknown\" — should be removed per D-04")
+		}
+	}
+	// All 4 buckets must be present
+	buckets := map[classify.TrafficClass]bool{
+		classify.ClassUnknown1: false, classify.ClassUnknown2: false,
+		classify.ClassUnknown3: false, classify.ClassUnknown4: false,
+	}
+	for _, c := range classes {
+		if _, ok := buckets[c]; ok {
+			buckets[c] = true
+		}
+	}
+	for bucket, found := range buckets {
+		if !found {
+			t.Errorf("AllClasses() missing bucket %q", bucket)
+		}
+	}
+}
+
+func TestHashBucketDistribution(t *testing.T) {
+	// hashBucket is unexported, test through Classify with a minimal rule set
+	// that has no catch-all TCP/UDP rules, so unmatched ports reach hashBucket.
+	minimalRules := []classify.Rule{
+		{Protocol: "icmp", DstPort: 0, Class: classify.ClassICMP},
+		{Protocol: "tcp", DstPort: 443, Class: classify.ClassHTTPS},
+	}
+	c := classify.NewClassifier(minimalRules)
+	seen := make(map[classify.TrafficClass]bool)
+	// Try a range of unmatched TCP ports to hit all 4 buckets
+	for port := uint16(10000); port < 11000; port++ {
+		pkt := buildTCPPacket(t, port)
+		got := c.Classify(pkt)
+		if strings.HasPrefix(string(got.Class), "unknown-") {
+			seen[got.Class] = true
+		}
+	}
+	for _, bucket := range []classify.TrafficClass{
+		classify.ClassUnknown1, classify.ClassUnknown2,
+		classify.ClassUnknown3, classify.ClassUnknown4,
+	} {
+		if !seen[bucket] {
+			t.Errorf("hashBucket never produced %q across ports 10000-10999", bucket)
+		}
+	}
+}

classify/types.go

@@ -14,14 +14,19 @@ const (
 	ClassDHCP     TrafficClass = "DHCP"
 	ClassOtherTCP TrafficClass = "other-TCP"
 	ClassOtherUDP TrafficClass = "other-UDP"
-	ClassUnknown  TrafficClass = "unknown"
+	// D-04: ClassUnknown replaced by 4 hash-bucketed classes for distinct tones
+	ClassUnknown1 TrafficClass = "unknown-1"
+	ClassUnknown2 TrafficClass = "unknown-2"
+	ClassUnknown3 TrafficClass = "unknown-3"
+	ClassUnknown4 TrafficClass = "unknown-4"
 )
 
 // AllClasses returns all known traffic classes in display order.
 func AllClasses() []TrafficClass {
 	return []TrafficClass{
 		ClassICMP, ClassDNS, ClassHTTPS, ClassHTTP, ClassSSH,
-		ClassSMTP, ClassNTP, ClassDHCP, ClassOtherTCP, ClassOtherUDP, ClassUnknown,
+		ClassSMTP, ClassNTP, ClassDHCP, ClassOtherTCP, ClassOtherUDP,
+		ClassUnknown1, ClassUnknown2, ClassUnknown3, ClassUnknown4,
 	}
 }