xonecas.io
60255
Zn

Zoea-Nova / commit f7797cc

fix: allow broadcasts to idle myses

- Updated Broadcast and BroadcastFrom to use validateCanAcceptMessage
- Now includes idle myses in broadcast recipients
- Improved error messages to mention stopped/errored states
- Added test TestCommanderBroadcastToIdleMyses
- Fixed TestNudgeRoleIsUser to work with idle state acceptance

xonecas2026-02-07 f7797ccd871e7db28c5b550b1ce1a5c169176263 parent 71e119d

3 files changed

internal/core/commander.go+7−5
@@ -283,15 +283,16 @@ func (c *Commander) Broadcast(content string) error {
283283 c.mu.RLock()
284284 myses := make([]*Mysis, 0)
285285 for _, m := range c.myses {
286- if m.State() == MysisStateRunning {
286+ // Include myses in idle or running state (can accept messages)
287+ if validateCanAcceptMessage(m.State()) == nil {
287288 myses = append(myses, m)
288289 }
289290 }
290291 c.mu.RUnlock()
291292
292- // Check if any myses are running
293+ // Check if any myses can receive broadcast
293294 if len(myses) == 0 {
294- return fmt.Errorf("no running myses to receive broadcast")
295+ return fmt.Errorf("no myses available to receive broadcast (all stopped or errored)")
295296 }
296297
297298 // Emit broadcast event
@@ -320,14 +321,15 @@ func (c *Commander) BroadcastFrom(senderID, content string) error {
320321 c.mu.RLock()
321322 myses := make([]*Mysis, 0)
322323 for _, m := range c.myses {
323- if m.State() == MysisStateRunning && m.ID() != senderID {
324+ // Include myses in idle or running state (can accept messages), excluding sender
325+ if validateCanAcceptMessage(m.State()) == nil && m.ID() != senderID {
324326 myses = append(myses, m)
325327 }
326328 }
327329 c.mu.RUnlock()
328330
329331 if len(myses) == 0 {
330- return fmt.Errorf("no recipients for broadcast (sender excluded)")
332+ return fmt.Errorf("no recipients for broadcast (sender excluded or all stopped/errored)")
331333 }
332334
333335 // Emit broadcast event
internal/core/commander_test.go+64−0
@@ -410,6 +410,70 @@ func TestCommanderBroadcast(t *testing.T) {
410410 }
411411 }
412412
413+func TestCommanderBroadcastToIdleMyses(t *testing.T) {
414+ cmd, bus, cleanup := setupCommanderTest(t)
415+ defer cleanup()
416+
417+ // Subscribe first
418+ events := bus.Subscribe()
419+
420+ // Create myses but don't start them (they'll be in idle state)
421+ mysis1, _ := cmd.CreateMysis("idle-1", "mock")
422+ mysis2, _ := cmd.CreateMysis("idle-2", "mock")
423+
424+ // Verify they're idle
425+ if mysis1.State() != MysisStateIdle {
426+ t.Fatalf("mysis1 should be idle, got %s", mysis1.State())
427+ }
428+ if mysis2.State() != MysisStateIdle {
429+ t.Fatalf("mysis2 should be idle, got %s", mysis2.State())
430+ }
431+
432+ // Drain created events with timeout
433+ for i := 0; i < 2; i++ {
434+ select {
435+ case <-events:
436+ case <-time.After(100 * time.Millisecond):
437+ }
438+ }
439+
440+ // Should be able to broadcast to idle myses
441+ if err := cmd.Broadcast("Wake up!"); err != nil {
442+ t.Fatalf("Broadcast() should accept idle myses, got error: %v", err)
443+ }
444+
445+ // Should receive broadcast event
446+ found := false
447+ timeout := time.After(2 * time.Second)
448+ for !found {
449+ select {
450+ case e := <-events:
451+ if e.Type == EventBroadcast {
452+ found = true
453+ }
454+ case <-timeout:
455+ t.Fatal("timeout waiting for broadcast event")
456+ }
457+ }
458+
459+ // Verify messages were stored (even though myses are idle)
460+ memories1, err := cmd.Store().GetMemories(mysis1.ID())
461+ if err != nil {
462+ t.Fatalf("GetMemories() error: %v", err)
463+ }
464+ if len(memories1) == 0 {
465+ t.Error("broadcast should be stored for idle mysis1")
466+ }
467+
468+ memories2, err := cmd.Store().GetMemories(mysis2.ID())
469+ if err != nil {
470+ t.Fatalf("GetMemories() error: %v", err)
471+ }
472+ if len(memories2) == 0 {
473+ t.Error("broadcast should be stored for idle mysis2")
474+ }
475+}
476+
413477 func TestCommanderBroadcastSource(t *testing.T) {
414478 cmd, _, cleanup := setupCommanderTest(t)
415479 defer cleanup()
internal/core/nudge_escalation_test.go+31−16
@@ -163,28 +163,43 @@ func TestNudgeRoleIsUser(t *testing.T) {
163163 // Simulate what happens in run() when a nudge is received
164164 // The code calls: a.SendMessage(a.buildContinuePrompt(attemptCount), store.MemorySourceDirect)
165165 prompt := mysis.buildContinuePrompt(0)
166- err := mysis.SendMessage(prompt, store.MemorySourceDirect)
167166
168- // SendMessage will fail because mysis is not running, but we can test the role logic directly
169- if err == nil || !strings.Contains(err.Error(), "not running") {
170- t.Fatalf("Expected 'not running' error, got: %v", err)
167+ // Idle myses now accept messages, so this should succeed
168+ err := mysis.SendMessage(prompt, store.MemorySourceDirect)
169+ if err != nil {
170+ t.Fatalf("SendMessage should succeed for idle mysis, got: %v", err)
171171 }
172172
173173 // The important part: verify that MemorySourceDirect maps to user role
174- // This is tested by checking the SendMessageFrom logic
175- // role := store.MemoryRoleUser (default)
176- // if source == store.MemorySourceSystem { role = store.MemoryRoleSystem }
177- // Since we're using MemorySourceDirect, role should be user
174+ // Check the stored memory to verify role
175+ memories, err := s.GetMemories(mysis.ID())
176+ if err != nil {
177+ t.Fatalf("GetMemories() error: %v", err)
178+ }
179+
180+ // Should have stored the nudge message (and possibly LLM response)
181+ if len(memories) == 0 {
182+ t.Fatal("Expected stored memory for nudge message")
183+ }
184+
185+ // Find the user message (the nudge we sent)
186+ var userMemory *store.Memory
187+ for i := range memories {
188+ if memories[i].Role == store.MemoryRoleUser {
189+ userMemory = memories[i]
190+ break
191+ }
192+ }
178193
179- // We can verify this by checking what would be stored
180- // Let's test the role mapping directly
181- testRole := store.MemoryRoleUser
182- testSource := store.MemorySourceDirect
183- if testSource == store.MemorySourceSystem {
184- testRole = store.MemoryRoleSystem
194+ if userMemory == nil {
195+ t.Fatal("Expected to find user role memory (the nudge)")
185196 }
186197
187- if testRole != store.MemoryRoleUser {
188- t.Errorf("Expected nudge to use user role, got: %s", testRole)
198+ // Verify the role is user (not system) and source is direct
199+ if userMemory.Role != store.MemoryRoleUser {
200+ t.Errorf("Expected nudge to use user role, got: %s", userMemory.Role)
201+ }
202+ if userMemory.Source != store.MemorySourceDirect {
203+ t.Errorf("Expected source to be direct, got: %s", userMemory.Source)
189204 }
190205 }