macro-agent 0.0.10 → 0.0.12

package/src/router/__tests__/message-router.test.ts

@@ -452,6 +452,567 @@ describe("MessageRouter", () => {
       expect(parsed.status_type).toBe("failed");
       expect(parsed.details.error).toBe("Connection timeout");
     });
+
+    it("should route status to topic co-subscribers", () => {
+      // Two peer agents (no parent-child relationship) sharing a topic
+      createAgent("worker_a");
+      createAgent("worker_b");
+
+      router.subscribe("worker_a", { type: "topic", target: "work_coordination" });
+      router.subscribe("worker_b", { type: "topic", target: "work_coordination" });
+
+      // worker_a emits a status
+      router.emitStatus({
+        from: { agent_id: "worker_a" },
+        status_type: "completed",
+        summary: "Task A done",
+      });
+
+      // worker_b should receive the notification via topic routing
+      const messages = router.getMessages("worker_b");
+      const statusMsg = messages.find((m) =>
+        m.content.includes("status_notification")
+      );
+      expect(statusMsg).toBeDefined();
+
+      const parsed = JSON.parse(statusMsg!.content);
+      expect(parsed.status_type).toBe("completed");
+      expect(parsed.summary).toBe("Task A done");
+    });
+
+    it("should not send topic status to self", () => {
+      createAgent("worker_a");
+
+      router.subscribe("worker_a", { type: "topic", target: "work_coordination" });
+
+      router.emitStatus({
+        from: { agent_id: "worker_a" },
+        status_type: "checkpoint",
+        summary: "Progress",
+      });
+
+      // worker_a should NOT receive a notification about its own status
+      const messages = router.getMessages("worker_a");
+      const statusMsgs = messages.filter((m) =>
+        m.content.includes("status_notification")
+      );
+      expect(statusMsgs).toHaveLength(0);
+    });
+
+    it("should not duplicate delivery to agents already notified via subtree", () => {
+      // manager_1 is parent of worker_1, AND both share a topic
+      createAgent("manager_1");
+      createAgent("worker_1", "manager_1");
+
+      // Set up subtree subscription (parent subscribes to child)
+      router.setupDefaultSubscriptions({
+        agent_id: "worker_1",
+        parent_id: "manager_1",
+      });
+
+      // Also subscribe both to a shared topic
+      router.subscribe("manager_1", { type: "topic", target: "task_updates" });
+      router.subscribe("worker_1", { type: "topic", target: "task_updates" });
+
+      router.emitStatus({
+        from: { agent_id: "worker_1" },
+        status_type: "completed",
+        summary: "Done",
+      });
+
+      // manager_1 should receive exactly ONE notification (via subtree, not duplicated by topic)
+      const messages = router.getMessages("manager_1");
+      const statusMsgs = messages.filter((m) =>
+        m.content.includes("status_notification")
+      );
+      expect(statusMsgs).toHaveLength(1);
+    });
+
+    it("should route status to multiple topic co-subscribers", () => {
+      createAgent("worker_a");
+      createAgent("worker_b");
+      createAgent("monitor_1");
+
+      // All three share the health topic
+      router.subscribe("worker_a", { type: "topic", target: "health" });
+      router.subscribe("worker_b", { type: "topic", target: "health" });
+      router.subscribe("monitor_1", { type: "topic", target: "health" });
+
+      router.emitStatus({
+        from: { agent_id: "worker_a" },
+        status_type: "checkpoint",
+        summary: "Health OK",
+      });
+
+      // Both worker_b and monitor_1 should receive it
+      for (const recipientId of ["worker_b", "monitor_1"]) {
+        const messages = router.getMessages(recipientId);
+        const statusMsg = messages.find((m) =>
+          m.content.includes("status_notification")
+        );
+        expect(statusMsg).toBeDefined();
+        const parsed = JSON.parse(statusMsg!.content);
+        expect(parsed.summary).toBe("Health OK");
+      }
+
+      // worker_a should NOT receive it
+      const selfMessages = router.getMessages("worker_a");
+      expect(
+        selfMessages.filter((m) => m.content.includes("status_notification"))
+      ).toHaveLength(0);
+    });
+
+    it("should not route to topic subscribers when agent has no topic subscriptions", () => {
+      // worker_a has no topic subs, worker_b has a topic sub
+      createAgent("worker_a");
+      createAgent("worker_b");
+
+      router.subscribe("worker_b", { type: "topic", target: "work_coordination" });
+
+      router.emitStatus({
+        from: { agent_id: "worker_a" },
+        status_type: "completed",
+        summary: "Done",
+      });
+
+      // worker_b should NOT receive anything (worker_a isn't on the topic)
+      const messages = router.getMessages("worker_b");
+      expect(
+        messages.filter((m) => m.content.includes("status_notification"))
+      ).toHaveLength(0);
+    });
+
+    it("should deduplicate across multiple shared topics", () => {
+      // Two agents sharing two different topics
+      createAgent("worker_a");
+      createAgent("worker_b");
+
+      router.subscribe("worker_a", { type: "topic", target: "work_coordination" });
+      router.subscribe("worker_a", { type: "topic", target: "task_updates" });
+      router.subscribe("worker_b", { type: "topic", target: "work_coordination" });
+      router.subscribe("worker_b", { type: "topic", target: "task_updates" });
+
+      router.emitStatus({
+        from: { agent_id: "worker_a" },
+        status_type: "completed",
+        summary: "Done",
+      });
+
+      // worker_b should receive exactly ONE notification, not two
+      const messages = router.getMessages("worker_b");
+      const statusMsgs = messages.filter((m) =>
+        m.content.includes("status_notification")
+      );
+      expect(statusMsgs).toHaveLength(1);
+    });
+  });
+
+  describe("status wake logic", () => {
+    it("should wake sleeping agent on subtree status notification", async () => {
+      const wakeEvents: { agentId: string; eventId: string }[] = [];
+
+      const routerWithWake = createMessageRouter(eventStore, {
+        sessionChecker: {
+          hasActiveSession: () => false,
+          getSessionState: () => "idle",
+        },
+        wakeHandler: (agentId, _decision, eventId) => {
+          wakeEvents.push({ agentId, eventId });
+        },
+      });
+
+      createAgent("manager_1");
+      createAgent("worker_1", "manager_1");
+
+      routerWithWake.setupDefaultSubscriptions({
+        agent_id: "worker_1",
+        parent_id: "manager_1",
+      });
+
+      routerWithWake.emitStatus({
+        from: { agent_id: "worker_1" },
+        status_type: "completed",
+        summary: "Task done",
+      });
+
+      expect(wakeEvents).toHaveLength(1);
+      expect(wakeEvents[0].agentId).toBe("manager_1");
+      expect(wakeEvents[0].eventId).toBeDefined();
+    });
+
+    it("should wake sleeping agent on topic status notification", async () => {
+      const wakeEvents: { agentId: string; eventId: string }[] = [];
+
+      const routerWithWake = createMessageRouter(eventStore, {
+        sessionChecker: {
+          hasActiveSession: () => false,
+          getSessionState: () => "idle",
+        },
+        wakeHandler: (agentId, _decision, eventId) => {
+          wakeEvents.push({ agentId, eventId });
+        },
+      });
+
+      createAgent("worker_a");
+      createAgent("worker_b");
+
+      routerWithWake.subscribe("worker_a", { type: "topic", target: "work_coordination" });
+      routerWithWake.subscribe("worker_b", { type: "topic", target: "work_coordination" });
+
+      routerWithWake.emitStatus({
+        from: { agent_id: "worker_a" },
+        status_type: "completed",
+        summary: "Task A done",
+      });
+
+      expect(wakeEvents).toHaveLength(1);
+      expect(wakeEvents[0].agentId).toBe("worker_b");
+    });
+
+    it("should not wake busy (prompting) agent on status notification", async () => {
+      const wakeEvents: { agentId: string }[] = [];
+
+      const routerWithWake = createMessageRouter(eventStore, {
+        sessionChecker: {
+          hasActiveSession: () => true,
+          getSessionState: () => "active",
+          isPrompting: () => true,
+        },
+        wakeHandler: (agentId) => {
+          wakeEvents.push({ agentId });
+        },
+      });
+
+      createAgent("worker_a");
+      createAgent("worker_b");
+
+      routerWithWake.subscribe("worker_a", { type: "topic", target: "work_coordination" });
+      routerWithWake.subscribe("worker_b", { type: "topic", target: "work_coordination" });
+
+      routerWithWake.emitStatus({
+        from: { agent_id: "worker_a" },
+        status_type: "checkpoint",
+        summary: "Progress",
+      });
+
+      // Normal priority + busy (prompting) session = queue, no wake
+      expect(wakeEvents).toHaveLength(0);
+    });
+
+    it("should not fail status delivery if wake handler throws", async () => {
+      const routerWithWake = createMessageRouter(eventStore, {
+        sessionChecker: {
+          hasActiveSession: () => false,
+          getSessionState: () => "idle",
+        },
+        wakeHandler: () => {
+          throw new Error("Wake handler crashed");
+        },
+      });
+
+      createAgent("manager_1");
+      createAgent("worker_1", "manager_1");
+
+      routerWithWake.setupDefaultSubscriptions({
+        agent_id: "worker_1",
+        parent_id: "manager_1",
+      });
+
+      // Should not throw despite wake handler error
+      expect(() => {
+        routerWithWake.emitStatus({
+          from: { agent_id: "worker_1" },
+          status_type: "completed",
+          summary: "Task done",
+        });
+      }).not.toThrow();
+
+      // Message should still be delivered
+      const messages = routerWithWake.getMessages("manager_1");
+      const statusMsg = messages.find((m) =>
+        m.content.includes("status_notification")
+      );
+      expect(statusMsg).toBeDefined();
+    });
+  });
+
+  describe("signal filtering", () => {
+    it("should suppress delivery when signal filter rejects", () => {
+      createAgent("worker_a");
+      createAgent("worker_b");
+
+      router.subscribe("worker_a", { type: "topic", target: "work_coordination" });
+      router.subscribe("worker_b", { type: "topic", target: "work_coordination" });
+
+      // Install filter that blocks WORKER_DONE signal
+      router.setSignalFilter((_from, _to, signal) => {
+        return signal !== "WORKER_DONE";
+      });
+
+      router.emitStatus({
+        from: { agent_id: "worker_a" },
+        status_type: "completed",
+        summary: "Task done",
+        details: { signal: "WORKER_DONE" },
+      });
+
+      const messages = router.getMessages("worker_b");
+      expect(
+        messages.filter((m) => m.content.includes("status_notification"))
+      ).toHaveLength(0);
+    });
+
+    it("should allow delivery when signal filter accepts", () => {
+      createAgent("worker_a");
+      createAgent("worker_b");
+
+      router.subscribe("worker_a", { type: "topic", target: "work_coordination" });
+      router.subscribe("worker_b", { type: "topic", target: "work_coordination" });
+
+      // Install filter that allows CONVERGENCE_CHECK
+      router.setSignalFilter((_from, _to, signal) => {
+        return signal === "CONVERGENCE_CHECK";
+      });
+
+      router.emitStatus({
+        from: { agent_id: "worker_a" },
+        status_type: "checkpoint",
+        summary: "Check",
+        details: { signal: "CONVERGENCE_CHECK" },
+      });
+
+      const messages = router.getMessages("worker_b");
+      expect(
+        messages.filter((m) => m.content.includes("status_notification"))
+      ).toHaveLength(1);
+    });
+
+    it("should pass through untagged status events (no details.signal)", () => {
+      createAgent("worker_a");
+      createAgent("worker_b");
+
+      router.subscribe("worker_a", { type: "topic", target: "work_coordination" });
+      router.subscribe("worker_b", { type: "topic", target: "work_coordination" });
+
+      // Install strict filter that blocks everything
+      router.setSignalFilter((_from, _to, signal) => {
+        if (!signal) return true; // untagged passes through
+        return false;
+      });
+
+      // Emit without details.signal
+      router.emitStatus({
+        from: { agent_id: "worker_a" },
+        status_type: "completed",
+        summary: "Done",
+      });
+
+      const messages = router.getMessages("worker_b");
+      expect(
+        messages.filter((m) => m.content.includes("status_notification"))
+      ).toHaveLength(1);
+    });
+
+    it("should apply signal filter to subtree subscriptions", () => {
+      createAgent("manager_1");
+      createAgent("worker_1", "manager_1");
+
+      router.setupDefaultSubscriptions({
+        agent_id: "worker_1",
+        parent_id: "manager_1",
+      });
+
+      // Block FIXUP_CREATED for subtree subscribers
+      router.setSignalFilter((_from, _to, signal) => {
+        return signal !== "FIXUP_CREATED";
+      });
+
+      router.emitStatus({
+        from: { agent_id: "worker_1" },
+        status_type: "checkpoint",
+        summary: "Fixup created",
+        details: { signal: "FIXUP_CREATED" },
+      });
+
+      const messages = router.getMessages("manager_1");
+      expect(
+        messages.filter((m) => m.content.includes("status_notification"))
+      ).toHaveLength(0);
+    });
+
+    it("should use directional from/to in filter callback", () => {
+      const filterCalls: { from: string; to: string; signal: string | undefined }[] = [];
+
+      createAgent("worker_a");
+      createAgent("worker_b");
+
+      router.subscribe("worker_a", { type: "topic", target: "updates" });
+      router.subscribe("worker_b", { type: "topic", target: "updates" });
+
+      router.setSignalFilter((from, to, signal) => {
+        filterCalls.push({ from, to, signal });
+        return true;
+      });
+
+      router.emitStatus({
+        from: { agent_id: "worker_a" },
+        status_type: "completed",
+        summary: "Done",
+        details: { signal: "TEST_SIGNAL" },
+      });
+
+      expect(filterCalls).toHaveLength(1);
+      expect(filterCalls[0]).toEqual({
+        from: "worker_a",
+        to: "worker_b",
+        signal: "TEST_SIGNAL",
+      });
+    });
+  });
+
+  describe("emission validation", () => {
+    it("should block emission when validator returns reject", () => {
+      createAgent("worker_a");
+      createAgent("manager_1");
+
+      router.subscribe("manager_1", { type: "subtree", target: "worker_a" });
+
+      router.setEmissionValidator((_agentId, signal) => {
+        if (signal === "FORBIDDEN_SIGNAL") {
+          return { action: "reject", message: "Not allowed" };
+        }
+        return { action: "allow" };
+      });
+
+      router.emitStatus({
+        from: { agent_id: "worker_a" },
+        status_type: "checkpoint",
+        summary: "Forbidden",
+        details: { signal: "FORBIDDEN_SIGNAL" },
+      });
+
+      // No notification should be delivered
+      const messages = router.getMessages("manager_1");
+      expect(
+        messages.filter((m) => m.content.includes("status_notification"))
+      ).toHaveLength(0);
+    });
+
+    it("should allow emission when validator returns allow", () => {
+      createAgent("worker_a");
+      createAgent("manager_1");
+
+      router.subscribe("manager_1", { type: "subtree", target: "worker_a" });
+
+      router.setEmissionValidator(() => ({ action: "allow" }));
+
+      router.emitStatus({
+        from: { agent_id: "worker_a" },
+        status_type: "completed",
+        summary: "Done",
+        details: { signal: "WORKER_DONE" },
+      });
+
+      const messages = router.getMessages("manager_1");
+      expect(
+        messages.filter((m) => m.content.includes("status_notification"))
+      ).toHaveLength(1);
+    });
+
+    it("should allow emission and record audit event when validator returns audit", () => {
+      createAgent("worker_a");
+      createAgent("manager_1");
+
+      router.subscribe("manager_1", { type: "subtree", target: "worker_a" });
+
+      router.setEmissionValidator((_agentId, signal) => {
+        if (signal === "UNAUTHORIZED") {
+          return { action: "audit", message: "Audit: unauthorized emission" };
+        }
+        return { action: "allow" };
+      });
+
+      router.emitStatus({
+        from: { agent_id: "worker_a" },
+        status_type: "checkpoint",
+        summary: "Check",
+        details: { signal: "UNAUTHORIZED" },
+      });
+
+      // Status notification should still be delivered
+      const messages = router.getMessages("manager_1");
+      expect(
+        messages.filter((m) => m.content.includes("status_notification"))
+      ).toHaveLength(1);
+
+      // Audit event should be recorded in EventStore
+      const events = eventStore.query({ type: "status" });
+      const auditEvent = events.find(
+        (e) => (e.payload as Record<string, unknown>)?.audit != null
+      );
+      expect(auditEvent).toBeDefined();
+      const audit = (auditEvent!.payload as Record<string, unknown>).audit as Record<string, unknown>;
+      expect(audit.type).toBe("emission_violation");
+      expect(audit.agent_id).toBe("worker_a");
+      expect(audit.signal).toBe("UNAUTHORIZED");
+    });
+
+    it("should allow emission when validator returns warn", () => {
+      createAgent("worker_a");
+      createAgent("manager_1");
+
+      router.subscribe("manager_1", { type: "subtree", target: "worker_a" });
+
+      router.setEmissionValidator(() => ({
+        action: "warn",
+        message: "Warning: unusual emission",
+      }));
+
+      router.emitStatus({
+        from: { agent_id: "worker_a" },
+        status_type: "completed",
+        summary: "Done",
+        details: { signal: "ODD_SIGNAL" },
+      });
+
+      // Warn still allows delivery
+      const messages = router.getMessages("manager_1");
+      expect(
+        messages.filter((m) => m.content.includes("status_notification"))
+      ).toHaveLength(1);
+    });
+
+    it("should pass through untagged emissions without validation", () => {
+      const validatorCalls: { agentId: string; signal: string | undefined }[] = [];
+
+      createAgent("worker_a");
+      createAgent("manager_1");
+
+      router.subscribe("manager_1", { type: "subtree", target: "worker_a" });
+
+      router.setEmissionValidator((agentId, signal) => {
+        validatorCalls.push({ agentId, signal });
+        // Always reject tagged signals for this test
+        if (signal) return { action: "reject" };
+        return { action: "allow" };
+      });
+
+      // Emit without details.signal
+      router.emitStatus({
+        from: { agent_id: "worker_a" },
+        status_type: "completed",
+        summary: "Done",
+      });
+
+      // Validator is called with undefined signal and allows it
+      expect(validatorCalls).toHaveLength(1);
+      expect(validatorCalls[0].signal).toBeUndefined();
+
+      const messages = router.getMessages("manager_1");
+      expect(
+        messages.filter((m) => m.content.includes("status_notification"))
+      ).toHaveLength(1);
+    });
   });
 
   // Note: Lineage routing tests removed - feature only implemented in deprecated send()

package/src/router/channels.ts

@@ -107,10 +107,9 @@ export type Channel =
 // Message Priority
 // =============================================================================
 
-/**
- * Message priority levels
- */
-export type MessagePriority = "low" | "normal" | "high" | "urgent";
+// MessagePriority is imported from types.ts to avoid duplication
+import type { MessagePriority } from "./types.js";
+export type { MessagePriority } from "./types.js";
 
 /**
  * Priority level numeric values for ordering