xonecas.io
60255
Zn

Zoea-Nova / commit a713a40

fix: prevent broadcast from blocking when myses are busy

Broadcasts were blocking indefinitely when one or more myses were busy
processing a previous message. This caused the TUI input box to remain
stuck showing the spinner, and broadcasts would not appear in the swarm
message list until all myses finished processing.

Changes:
- Add Mysis.QueueBroadcast() method for non-blocking broadcast delivery
- Update Commander.Broadcast() to use QueueBroadcast() instead of SendMessage()
- Add comprehensive test to verify broadcasts don't block on busy myses

The new QueueBroadcast() method:
- Stores the broadcast message in the database immediately (fast DB write)
- Emits the message event for the TUI
- Sends a nudge to trigger async processing
- Returns immediately without waiting for LLM processing

This ensures:
- The input box returns to placeholder state immediately after broadcast
- Broadcast messages appear in the swarm list right away
- The TUI remains responsive even when myses are busy

Test added: TestBroadcastDoesNotBlockOnBusyMysis
- Verifies broadcast completes in <1s even when a mysis is busy for 2s
- Confirms both busy and idle myses receive the broadcast message

xonecas2026-02-05 a713a40e65e8be421ddae7de020140037aaf6dbe parent b5b5c20

3 files changed

internal/core/commander.go+5−2
@@ -271,7 +271,9 @@ func (c *Commander) SendMessageAsync(id, content string) error {
271271 return nil
272272 }
273273
274-// Broadcast sends a message to all running myses (synchronous).
274+// Broadcast sends a message to all running myses.
275+// Stores the message immediately and triggers async processing.
276+// Returns quickly without waiting for LLM processing.
275277 func (c *Commander) Broadcast(content string) error {
276278 c.mu.RLock()
277279 myses := make([]*Mysis, 0)
@@ -294,9 +296,10 @@ func (c *Commander) Broadcast(content string) error {
294296 Timestamp: time.Now(),
295297 })
296298
299+ // Queue broadcast to each mysis (non-blocking)
297300 var errs []error
298301 for _, m := range myses {
299- if err := m.SendMessage(content, store.MemorySourceBroadcast); err != nil {
302+ if err := m.QueueBroadcast(content, ""); err != nil {
300303 errs = append(errs, fmt.Errorf("mysis %s: %w", m.ID(), err))
301304 }
302305 }
internal/core/commander_test.go+159−0
@@ -514,3 +514,162 @@ func TestCommanderLoadMyses(t *testing.T) {
514514 t.Errorf("expected 2 myses loaded, got %d", cmd.MysisCount())
515515 }
516516 }
517+
518+// TestBroadcastDoesNotBlockOnBusyMysis verifies that broadcasting doesn't block
519+// when one or more myses are busy processing a previous message.
520+// This test ensures the parallel broadcast implementation works correctly.
521+func TestBroadcastDoesNotBlockOnBusyMysis(t *testing.T) {
522+ tmpDir := t.TempDir()
523+ dbPath := filepath.Join(tmpDir, "test.db")
524+ s, err := store.Open(dbPath)
525+ if err != nil {
526+ t.Fatalf("Open() error: %v", err)
527+ }
528+ defer s.Close()
529+
530+ bus := NewEventBus(100)
531+ defer bus.Close()
532+
533+ reg := provider.NewRegistry()
534+ limiter := rate.NewLimiter(rate.Limit(1000), 1000)
535+
536+ // Create a slow provider that will block for 2 seconds
537+ slowProvider := provider.NewMock("slow", "slow response").
538+ WithLimiter(limiter).
539+ SetDelay(2 * time.Second)
540+
541+ // Create a fast provider for the other mysis
542+ fastProvider := provider.NewMock("fast", "fast response").
543+ WithLimiter(limiter)
544+
545+ // Register custom factories that return our specific providers
546+ reg.RegisterFactory(&customMockFactory{
547+ name: "slow",
548+ provider: slowProvider,
549+ })
550+ reg.RegisterFactory(&customMockFactory{
551+ name: "fast",
552+ provider: fastProvider,
553+ })
554+
555+ cfg := &config.Config{
556+ Swarm: config.SwarmConfig{MaxMyses: 16},
557+ Providers: map[string]config.ProviderConfig{
558+ "slow": {Endpoint: "http://slow", Model: "slow-model", Temperature: 0.7},
559+ "fast": {Endpoint: "http://fast", Model: "fast-model", Temperature: 0.7},
560+ },
561+ }
562+
563+ cmd := NewCommander(s, reg, bus, cfg)
564+ proxy := mcp.NewProxy(nil)
565+ cmd.SetMCP(proxy)
566+
567+ // Create two myses: one slow, one fast
568+ slowMysis, err := cmd.CreateMysis("slow-mysis", "slow")
569+ if err != nil {
570+ t.Fatalf("CreateMysis(slow) error: %v", err)
571+ }
572+
573+ fastMysis, err := cmd.CreateMysis("fast-mysis", "fast")
574+ if err != nil {
575+ t.Fatalf("CreateMysis(fast) error: %v", err)
576+ }
577+
578+ // Start both myses
579+ if err := cmd.StartMysis(slowMysis.ID()); err != nil {
580+ t.Fatalf("StartMysis(slow) error: %v", err)
581+ }
582+ if err := cmd.StartMysis(fastMysis.ID()); err != nil {
583+ t.Fatalf("StartMysis(fast) error: %v", err)
584+ }
585+
586+ // Wait for both to be running
587+ deadline := time.Now().Add(2 * time.Second)
588+ for time.Now().Before(deadline) {
589+ if slowMysis.State() == MysisStateRunning && fastMysis.State() == MysisStateRunning {
590+ break
591+ }
592+ time.Sleep(10 * time.Millisecond)
593+ }
594+ if slowMysis.State() != MysisStateRunning || fastMysis.State() != MysisStateRunning {
595+ t.Fatal("myses failed to start within timeout")
596+ }
597+
598+ // Send a direct message to the slow mysis to make it busy
599+ // This will block for 2 seconds due to the delay
600+ go func() {
601+ cmd.SendMessage(slowMysis.ID(), "make slow mysis busy")
602+ }()
603+
604+ // Give the slow mysis time to start processing (acquire turnMu lock)
605+ time.Sleep(100 * time.Millisecond)
606+
607+ // Now broadcast a message - this should NOT block waiting for the slow mysis
608+ // The broadcast should complete quickly (within 500ms) because it sends in parallel
609+ start := time.Now()
610+ err = cmd.Broadcast("broadcast message")
611+ elapsed := time.Since(start)
612+
613+ if err != nil {
614+ t.Fatalf("Broadcast() error: %v", err)
615+ }
616+
617+ // The broadcast should complete much faster than the 2-second delay
618+ // We allow up to 1 second for the broadcast to complete (generous margin)
619+ // If it takes longer, it means the broadcast blocked waiting for the slow mysis
620+ if elapsed > 1*time.Second {
621+ t.Errorf("Broadcast took too long (%v), likely blocked on busy mysis", elapsed)
622+ }
623+
624+ // Verify both myses received the broadcast
625+ // Wait a bit for the slow mysis to finish processing
626+ time.Sleep(2500 * time.Millisecond)
627+
628+ slowMemories, err := s.GetRecentMemories(slowMysis.ID(), 50)
629+ if err != nil {
630+ t.Fatalf("GetRecentMemories(slow) error: %v", err)
631+ }
632+
633+ fastMemories, err := s.GetRecentMemories(fastMysis.ID(), 50)
634+ if err != nil {
635+ t.Fatalf("GetRecentMemories(fast) error: %v", err)
636+ }
637+
638+ // Check that both myses have the broadcast message
639+ slowHasBroadcast := false
640+ for _, m := range slowMemories {
641+ if m.Source == store.MemorySourceBroadcast && m.Content == "broadcast message" {
642+ slowHasBroadcast = true
643+ break
644+ }
645+ }
646+
647+ fastHasBroadcast := false
648+ for _, m := range fastMemories {
649+ if m.Source == store.MemorySourceBroadcast && m.Content == "broadcast message" {
650+ fastHasBroadcast = true
651+ break
652+ }
653+ }
654+
655+ if !slowHasBroadcast {
656+ t.Error("slow mysis did not receive broadcast message")
657+ }
658+ if !fastHasBroadcast {
659+ t.Error("fast mysis did not receive broadcast message")
660+ }
661+
662+ cmd.StopAll()
663+}
664+
665+// customMockFactory is a factory that returns a specific provider instance
666+type customMockFactory struct {
667+ name string
668+ provider provider.Provider
669+}
670+
671+func (f *customMockFactory) Name() string { return f.name }
672+
673+func (f *customMockFactory) Create(model string, temperature float64) provider.Provider {
674+ return f.provider
675+}
internal/core/mysis.go+40−0
@@ -534,6 +534,46 @@ func (m *Mysis) SendMessage(content string, source store.MemorySource) error {
534534 return a.SendMessageFrom(content, source, "")
535535 }
536536
537+// QueueBroadcast stores a broadcast message and triggers async processing.
538+// Unlike SendMessage, this does not block waiting for the mysis to process.
539+// Returns immediately after storing the message in the database.
540+func (m *Mysis) QueueBroadcast(content string, senderID string) error {
541+ a := m
542+
543+ a.mu.RLock()
544+ state := a.state
545+ a.mu.RUnlock()
546+
547+ if state != MysisStateRunning {
548+ return fmt.Errorf("mysis not running")
549+ }
550+
551+ // Store the message immediately (fast DB write, no LLM call)
552+ if err := a.store.AddMemory(a.id, store.MemoryRoleUser, store.MemorySourceBroadcast, content, "", senderID); err != nil {
553+ return fmt.Errorf("store broadcast: %w", err)
554+ }
555+
556+ // Emit message event
557+ a.bus.Publish(Event{
558+ Type: EventMysisMessage,
559+ MysisID: a.id,
560+ MysisName: a.name,
561+ Message: &MessageData{Role: "user", Content: content},
562+ Timestamp: time.Now(),
563+ })
564+
565+ // Trigger async processing (nudge the mysis to process the new message)
566+ select {
567+ case a.nudgeCh <- struct{}{}:
568+ // Nudge sent successfully
569+ default:
570+ // Channel full or mysis not listening, that's OK
571+ // The mysis will pick up the message on its next turn
572+ }
573+
574+ return nil
575+}
576+
537577 // memoriesToMessages converts stored memories to provider messages.
538578 func (m *Mysis) memoriesToMessages(memories []*store.Memory) []provider.Message {
539579 a := m