fix(detection): backport CTO-reviewed detector fixes into phase5 branch

1. ConfigDefDetector: move seenKeys to file scope to prevent duplicate
   config nodes when multiple classes in the same file reference the same
   @value or ConfigDef key.

2. ConfigDefDetector: add receiver discriminator to .define() call
   matching — only flags calls where the scope references "ConfigDef" or
   "CONFIG" to prevent false positives from unrelated .define() calls.

3. KafkaDetector: extend CLASS_RE to include enum|inline|value|protected
   Kotlin modifiers (enum class, inline class, value class, protected class).

4. TopicLinker: extend to handle PUBLISHES/LISTENS edge kinds and
   TOPIC/QUEUE/EVENT/MESSAGE_QUEUE node kinds for full messaging coverage.

5. TopicLinker: add determinism test covering multi-sender/multi-receiver
   SENDS_TO/RECEIVES_FROM scenarios.

These fixes were reviewed and approved in the detection-quality-fixes
branch (46fd2b0) but were absent from the phase5 branch.

Co-Authored-By: Paperclip <noreply@paperclip.ing>

Author: aksOps

src/main/java/io/github/randomcodespace/iq/analyzer/linker/TopicLinker.java

@@ -18,12 +18,13 @@
 import java.util.TreeSet;
 
 /**
- * Links messaging producers to consumers via shared topic/queue names.
+ * Links messaging producers to consumers via shared topic/queue/event names.
  * <p>
- * Scans for TOPIC/QUEUE nodes and matches PRODUCES/SENDS_TO edges with
- * CONSUMES/RECEIVES_FROM edges on the same topic label to create direct
- * producer-to-consumer CALLS edges. Supports Kafka, RabbitMQ, TIBCO EMS,
- * IBM MQ, Azure Service Bus, and other enterprise messaging patterns.
+ * Scans for TOPIC, QUEUE, EVENT, and MESSAGE_QUEUE nodes and matches producer
+ * edges (PRODUCES, SENDS_TO, PUBLISHES) with consumer edges (CONSUMES,
+ * RECEIVES_FROM, LISTENS) on the same label to create direct producer-to-consumer
+ * CALLS edges. Supports Kafka, RabbitMQ, TIBCO EMS, IBM MQ, Azure Service Bus,
+ * Spring application events, and other enterprise messaging patterns.
  */
 @Component
 public class TopicLinker implements Linker {
@@ -35,7 +36,8 @@ public LinkResult link(List<CodeNode> nodes, List<CodeEdge> edges) {
         // Collect topic/queue nodes by label
         Map<String, List<String>> topicIdsByLabel = new TreeMap<>();
         for (CodeNode node : nodes) {
-            if (node.getKind() == NodeKind.TOPIC || node.getKind() == NodeKind.QUEUE) {
+            if (node.getKind() == NodeKind.TOPIC || node.getKind() == NodeKind.QUEUE
+                    || node.getKind() == NodeKind.EVENT || node.getKind() == NodeKind.MESSAGE_QUEUE) {
                 topicIdsByLabel
                         .computeIfAbsent(node.getLabel(), k -> new ArrayList<>())
                         .add(node.getId());
@@ -52,8 +54,10 @@ public LinkResult link(List<CodeNode> nodes, List<CodeEdge> edges) {
         Map<String, List<String>> consumersByTopic = new TreeMap<>();
 
         for (CodeEdge edge : edges) {
-            boolean isProducer = edge.getKind() == EdgeKind.PRODUCES || edge.getKind() == EdgeKind.SENDS_TO;
-            boolean isConsumer = edge.getKind() == EdgeKind.CONSUMES || edge.getKind() == EdgeKind.RECEIVES_FROM;
+            boolean isProducer = edge.getKind() == EdgeKind.PRODUCES || edge.getKind() == EdgeKind.SENDS_TO
+                    || edge.getKind() == EdgeKind.PUBLISHES;
+            boolean isConsumer = edge.getKind() == EdgeKind.CONSUMES || edge.getKind() == EdgeKind.RECEIVES_FROM
+                    || edge.getKind() == EdgeKind.LISTENS;
             if (isProducer && edge.getTarget() != null) {
                 producersByTopic
                         .computeIfAbsent(edge.getTarget().getId(), k -> new ArrayList<>())

src/main/java/io/github/randomcodespace/iq/detector/java/ConfigDefDetector.java

@@ -80,16 +80,28 @@ public DetectorResult detect(DetectorContext ctx) {
     private DetectorResult detectWithAst(CompilationUnit cu, DetectorContext ctx) {
         List<CodeNode> nodes = new ArrayList<>();
         List<CodeEdge> edges = new ArrayList<>();
+        // File-scoped seenKeys prevents duplicate config nodes when multiple classes
+        // in the same file reference the same key (e.g., @Value("${server.port}")).
+        Set<String> seenKeys = new LinkedHashSet<>();
 
         cu.findAll(ClassOrInterfaceDeclaration.class).forEach(classDecl -> {
             String className = classDecl.getNameAsString();
             String classNodeId = ctx.filePath() + ":" + className;
-            Set<String> seenKeys = new LinkedHashSet<>();
 
             // 1. Kafka ConfigDef.define() calls
+            // Discriminator: receiver must mention "ConfigDef" or "CONFIG" to avoid matching
+            // unrelated .define() calls (per CLAUDE.md: framework detectors must have guards).
             classDecl.findAll(MethodCallExpr.class).forEach(call -> {
                 if (!"define".equals(call.getNameAsString())) return;
                 if (call.getArguments().isEmpty()) return;
+                // Receiver check: scope must reference a ConfigDef instance or chain
+                boolean receiverIsConfigDef = call.getScope()
+                        .map(scope -> {
+                            String s = scope.toString();
+                            return s.contains("ConfigDef") || s.toUpperCase().contains("CONFIG");
+                        })
+                        .orElse(false);
+                if (!receiverIsConfigDef) return;
                 var firstArg = call.getArguments().get(0);
                 if (!firstArg.isStringLiteralExpr()) return;
                 String configKey = firstArg.asStringLiteralExpr().getValue();

src/main/java/io/github/randomcodespace/iq/detector/java/KafkaDetector.java

@@ -30,7 +30,8 @@
 public class KafkaDetector extends AbstractRegexDetector {
 
     private static final Pattern CLASS_RE = Pattern.compile(
-            "(?:(?:public|internal|private|abstract|sealed|data|open)\\s+)*(?:class|object)\\s+(\\w+)");
+            "(?:(?:public|internal|private|protected|data|abstract|open|sealed|enum|inline|value)\\s+)*" +
+            "(?:class|object)\\s+(\\w+)");
     private static final Pattern KAFKA_LISTENER_RE = Pattern.compile(
             "@KafkaListener\\s*\\(\\s*(?:.*?topics?\\s*=\\s*)?[\\{\"]?\\s*\"([^\"]+)\"");
     private static final Pattern KAFKA_SEND_RE = Pattern.compile(

src/main/resources/static/assets/CodeGraphView-Bs3FzZUD.js

@@ -9,8 +9,8 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/assets/index-DNHxJZLD.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/vendor-react-74ka7VJT.js">
+    <script type="module" crossorigin src="/assets/index-C1nABH5f.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/vendor-react-DGy_UPuR.js">
     <link rel="stylesheet" crossorigin href="/assets/index-BOVJBvRE.css">
   </head>
   <body class="bg-surface-950 text-surface-100">

src/main/resources/static/assets/index-C1nABH5f.js

@@ -136,6 +136,130 @@ void linksMixedSendsToAndConsumes() {
         assertEquals(EdgeKind.CALLS, result.edges().getFirst().getKind());
     }
 
+    @Test
+    void linksPublisherToListenerViaEvent() {
+        var event = new CodeNode("event:UserCreated", NodeKind.EVENT, "UserCreated");
+        var publisher = new CodeNode("svc:UserService", NodeKind.CLASS, "UserService");
+        var listener = new CodeNode("svc:NotificationService", NodeKind.CLASS, "NotificationService");
+
+        var publishesEdge = new CodeEdge();
+        publishesEdge.setId("e1");
+        publishesEdge.setKind(EdgeKind.PUBLISHES);
+        publishesEdge.setSourceId("svc:UserService");
+        publishesEdge.setTarget(event);
+
+        var listensEdge = new CodeEdge();
+        listensEdge.setId("e2");
+        listensEdge.setKind(EdgeKind.LISTENS);
+        listensEdge.setSourceId("svc:NotificationService");
+        listensEdge.setTarget(event);
+
+        LinkResult result = linker.link(
+                List.of(event, publisher, listener),
+                List.of(publishesEdge, listensEdge)
+        );
+
+        assertEquals(1, result.edges().size());
+        CodeEdge callsEdge = result.edges().getFirst();
+        assertEquals(EdgeKind.CALLS, callsEdge.getKind());
+        assertEquals("svc:UserService", callsEdge.getSourceId());
+        assertEquals("svc:NotificationService", callsEdge.getTarget().getId());
+        assertEquals("UserCreated", callsEdge.getProperties().get("topic"));
+    }
+
+    @Test
+    void linksPublisherWithExistingConsumer() {
+        var event = new CodeNode("event:OrderPlaced", NodeKind.EVENT, "OrderPlaced");
+        var publisher = new CodeNode("svc:OrderService", NodeKind.CLASS, "OrderService");
+        var consumer = new CodeNode("svc:InventoryService", NodeKind.CLASS, "InventoryService");
+
+        var publishesEdge = new CodeEdge();
+        publishesEdge.setId("e1");
+        publishesEdge.setKind(EdgeKind.PUBLISHES);
+        publishesEdge.setSourceId("svc:OrderService");
+        publishesEdge.setTarget(event);
+
+        var consumesEdge = new CodeEdge();
+        consumesEdge.setId("e2");
+        consumesEdge.setKind(EdgeKind.CONSUMES);
+        consumesEdge.setSourceId("svc:InventoryService");
+        consumesEdge.setTarget(event);
+
+        LinkResult result = linker.link(
+                List.of(event, publisher, consumer),
+                List.of(publishesEdge, consumesEdge)
+        );
+
+        assertEquals(1, result.edges().size());
+        assertEquals(EdgeKind.CALLS, result.edges().getFirst().getKind());
+    }
+
+    @Test
+    void handlesMessageQueueNodes() {
+        var mq = new CodeNode("mq:ibm-orders", NodeKind.MESSAGE_QUEUE, "ibm-orders");
+        var producer = new CodeNode("svc:IBMProducer", NodeKind.CLASS, "IBMProducer");
+        var consumer = new CodeNode("svc:IBMConsumer", NodeKind.CLASS, "IBMConsumer");
+
+        var sendsEdge = new CodeEdge();
+        sendsEdge.setId("e1");
+        sendsEdge.setKind(EdgeKind.SENDS_TO);
+        sendsEdge.setSourceId("svc:IBMProducer");
+        sendsEdge.setTarget(mq);
+
+        var receivesEdge = new CodeEdge();
+        receivesEdge.setId("e2");
+        receivesEdge.setKind(EdgeKind.RECEIVES_FROM);
+        receivesEdge.setSourceId("svc:IBMConsumer");
+        receivesEdge.setTarget(mq);
+
+        LinkResult result = linker.link(
+                List.of(mq, producer, consumer),
+                List.of(sendsEdge, receivesEdge)
+        );
+
+        assertEquals(1, result.edges().size());
+        assertEquals(EdgeKind.CALLS, result.edges().getFirst().getKind());
+    }
+
+    @Test
+    void determinismTest() {
+        var topic = new CodeNode("topic:payments", NodeKind.TOPIC, "payments");
+        var event = new CodeNode("event:PaymentProcessed", NodeKind.EVENT, "PaymentProcessed");
+        var svcA = new CodeNode("svc:A", NodeKind.CLASS, "A");
+        var svcB = new CodeNode("svc:B", NodeKind.CLASS, "B");
+        var svcC = new CodeNode("svc:C", NodeKind.CLASS, "C");
+
+        List<CodeEdge> edges = new ArrayList<>();
+
+        var e1 = new CodeEdge();
+        e1.setId("e1"); e1.setKind(EdgeKind.PRODUCES); e1.setSourceId("svc:A"); e1.setTarget(topic);
+        edges.add(e1);
+
+        var e2 = new CodeEdge();
+        e2.setId("e2"); e2.setKind(EdgeKind.CONSUMES); e2.setSourceId("svc:B"); e2.setTarget(topic);
+        edges.add(e2);
+
+        var e3 = new CodeEdge();
+        e3.setId("e3"); e3.setKind(EdgeKind.PUBLISHES); e3.setSourceId("svc:A"); e3.setTarget(event);
+        edges.add(e3);
+
+        var e4 = new CodeEdge();
+        e4.setId("e4"); e4.setKind(EdgeKind.LISTENS); e4.setSourceId("svc:C"); e4.setTarget(event);
+        edges.add(e4);
+
+        List<CodeNode> nodes = List.of(topic, event, svcA, svcB, svcC);
+
+        LinkResult result1 = linker.link(nodes, edges);
+        LinkResult result2 = linker.link(nodes, edges);
+
+        assertEquals(result1.edges().size(), result2.edges().size());
+        for (int i = 0; i < result1.edges().size(); i++) {
+            assertEquals(result1.edges().get(i).getId(), result2.edges().get(i).getId());
+            assertEquals(result1.edges().get(i).getSourceId(), result2.edges().get(i).getSourceId());
+            assertEquals(result1.edges().get(i).getTarget().getId(), result2.edges().get(i).getTarget().getId());
+        }
+    }
+
     @Test
     void handlesQueueNodes() {
         var queue = new CodeNode("queue:tasks", NodeKind.QUEUE, "tasks");