60255
Zn
Zoea-Nova / files
Zoea-Nova / internal / core / mysis_test.go
88.3 KB
1package core 2 3import ( 4 "context" 5 "encoding/json" 6 "errors" 7 "fmt" 8 "path/filepath" 9 "strings" 10 "testing" 11 "time" 12 13 "github.com/xonecas/zoea-nova/internal/constants" 14 "github.com/xonecas/zoea-nova/internal/mcp" 15 "github.com/xonecas/zoea-nova/internal/provider" 16 "github.com/xonecas/zoea-nova/internal/store" 17) 18 19func setupMysisTest(t *testing.T) (*store.Store, *EventBus, func()) { 20 t.Helper() 21 22 tmpDir := t.TempDir() 23 dbPath := filepath.Join(tmpDir, "test.db") 24 s, err := store.Open(dbPath) 25 if err != nil { 26 t.Fatalf("Open() error: %v", err) 27 } 28 29 bus := NewEventBus(100) 30 31 cleanup := func() { 32 bus.Close() 33 s.Close() 34 } 35 36 return s, bus, cleanup 37} 38 39func TestMysisLifecycle(t *testing.T) { 40 s, bus, cleanup := setupMysisTest(t) 41 defer cleanup() 42 43 // Create stored mysis 44 stored, err := s.CreateMysis("test-mysis", "mock", "test-model", 0.7) 45 if err != nil { 46 t.Fatalf("CreateMysis() error: %v", err) 47 } 48 49 mock := provider.NewMock("mock", "Hello from mysis!") 50 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 51 52 // Initial state 53 if mysis.State() != MysisStateIdle { 54 t.Errorf("expected initial state=idle, got %s", mysis.State()) 55 } 56 if mysis.ID() != stored.ID { 57 t.Errorf("expected ID=%s, got %s", stored.ID, mysis.ID()) 58 } 59 if mysis.Name() != "test-mysis" { 60 t.Errorf("expected name=test-mysis, got %s", mysis.Name()) 61 } 62 63 // Start 64 if err := mysis.Start(); err != nil { 65 t.Fatalf("Start() error: %v", err) 66 } 67 if mysis.State() != MysisStateRunning { 68 t.Errorf("expected state=running, got %s", mysis.State()) 69 } 70 71 // Start again should error 72 if err := mysis.Start(); err == nil { 73 t.Error("expected error starting already running mysis") 74 } 75 76 // Stop 77 if err := mysis.Stop(); err != nil { 78 t.Fatalf("Stop() error: %v", err) 79 } 80 if mysis.State() != MysisStateStopped { 81 t.Errorf("expected state=stopped, got %s", mysis.State()) 82 } 83 84 // Stop again should be idempotent 85 if err := mysis.Stop(); err != nil { 86 t.Errorf("expected no error stopping already stopped mysis, got %v", err) 87 } 88} 89 90func TestMysisConcurrentStopDuringTurn(t *testing.T) { 91 s, bus, cleanup := setupMysisTest(t) 92 defer cleanup() 93 94 stored, err := s.CreateMysis("concurrent", "mock", "test-model", 0.7) 95 if err != nil { 96 t.Fatalf("CreateMysis() error: %v", err) 97 } 98 99 mock := provider.NewMock("mock", "ok").SetDelay(50 * time.Millisecond) 100 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 101 102 if err := mysis.Start(); err != nil { 103 t.Fatalf("Start() error: %v", err) 104 } 105 106 go func() { 107 _ = mysis.SendMessage("ping", store.MemorySourceDirect) 108 }() 109 110 time.Sleep(10 * time.Millisecond) 111 112 done := make(chan error, 1) 113 go func() { 114 done <- mysis.Stop() 115 }() 116 117 select { 118 case err := <-done: 119 if err != nil { 120 t.Fatalf("Stop() error: %v", err) 121 } 122 case <-time.After(500 * time.Millisecond): 123 t.Fatal("timeout waiting for Stop") 124 } 125} 126 127func TestMysisSendMessage(t *testing.T) { 128 s, bus, cleanup := setupMysisTest(t) 129 defer cleanup() 130 131 stored, _ := s.CreateMysis("msg-mysis", "mock", "test-model", 0.7) 132 mock := provider.NewMock("mock", "I received your message!") 133 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 134 135 // Can send to idle mysis (will be stored and processed when started) 136 if err := mysis.SendMessage("Hello", store.MemorySourceDirect); err != nil { 137 t.Errorf("should accept message in idle state, got error: %v", err) 138 } 139 140 // Start mysis 141 mysis.Start() 142 143 // Subscribe to events 144 events := bus.Subscribe() 145 146 // Wait for the initial turn to finish (triggered by synthetic encouragement message) 147 // It should emit a response event after processing the encouragement 148 timeout := time.After(2 * time.Second) 149initialTurnLoop: 150 for { 151 select { 152 case e := <-events: 153 if e.Type == EventMysisResponse { 154 break initialTurnLoop 155 } 156 case <-timeout: 157 t.Fatal("timeout waiting for initial turn") 158 } 159 } 160 161 // Send message 162 if err := mysis.SendMessage("Hello, mysis!", store.MemorySourceDirect); err != nil { 163 t.Fatalf("SendMessage() error: %v", err) 164 } 165 166 // Should receive message and response events for our message 167 var messageEvent, responseEvent bool 168 timeout = time.After(2 * time.Second) 169 170eventLoop: 171 for { 172 select { 173 case e := <-events: 174 if e.Type == EventMysisMessage { 175 if e.Message != nil && e.Message.Content == "Hello, mysis!" { 176 messageEvent = true 177 } 178 } 179 if e.Type == EventMysisResponse { 180 if e.Message != nil && e.Message.Content == "I received your message!" { 181 responseEvent = true 182 } 183 } 184 // Break early if we have both events 185 if messageEvent && responseEvent { 186 break eventLoop 187 } 188 case <-timeout: 189 break eventLoop 190 } 191 } 192 193 if !messageEvent { 194 t.Error("expected message event for 'Hello, mysis!'") 195 } 196 if !responseEvent { 197 t.Error("expected response event for 'I received your message!'") 198 } 199 200 // Check memories were stored 201 // Expected: user message (sent while idle), system prompt, assistant response (from ephemeral encouragement), 202 // user message (Hello, mysis!), assistant response 203 // NOTE: The encouragement message (initial trigger) is ephemeral and NOT stored in DB 204 memories, err := s.GetMemories(stored.ID) 205 if err != nil { 206 t.Fatalf("GetMemories() error: %v", err) 207 } 208 if len(memories) != 5 { 209 t.Errorf("expected 5 memories, got %d", len(memories)) 210 } 211 212 mysis.Stop() 213} 214 215func TestMysisReceivesBroadcastWithSender(t *testing.T) { 216 s, bus, cleanup := setupMysisTest(t) 217 defer cleanup() 218 219 receiverStored, _ := s.CreateMysis("receiver", "mock", "test-model", 0.7) 220 mock := provider.NewMock("mock", "response") 221 receiver := NewMysis(receiverStored.ID, receiverStored.Name, receiverStored.CreatedAt, mock, s, bus, "") 222 223 if err := receiver.Start(); err != nil { 224 t.Fatalf("Start() error: %v", err) 225 } 226 defer receiver.Stop() 227 228 senderID := "sender-mysis" 229 230 if err := receiver.SendMessageFrom("test broadcast", store.MemorySourceBroadcast, senderID); err != nil { 231 t.Fatalf("SendMessageFrom() error: %v", err) 232 } 233 234 memories, err := s.GetRecentMemories(receiverStored.ID, 10) 235 if err != nil { 236 t.Fatalf("GetRecentMemories() error: %v", err) 237 } 238 239 if len(memories) == 0 { 240 t.Fatal("expected at least 1 memory") 241 } 242 243 found := false 244 for _, m := range memories { 245 if m.Source == store.MemorySourceBroadcast && m.SenderID == senderID { 246 found = true 247 break 248 } 249 } 250 251 if !found { 252 t.Error("broadcast memory with correct sender_id not found") 253 } 254} 255 256func TestMysisSetErrorState(t *testing.T) { 257 s, bus, cleanup := setupMysisTest(t) 258 defer cleanup() 259 260 stored, _ := s.CreateMysis("error-state-test", "mock", "test-model", 0.7) 261 mock := provider.NewMock("mock", "response") 262 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 263 264 events := bus.Subscribe() 265 266 testErr := errors.New("test error") 267 mysis.setErrorState(testErr) 268 269 if mysis.State() != MysisStateErrored { 270 t.Errorf("expected state=errored, got %s", mysis.State()) 271 } 272 if mysis.LastError() != testErr { 273 t.Errorf("expected last error %v, got %v", testErr, mysis.LastError()) 274 } 275 276 // Should receive state change event first 277 select { 278 case e := <-events: 279 if e.Type != EventMysisStateChanged { 280 t.Errorf("expected EventMysisStateChanged, got %s", e.Type) 281 } 282 case <-time.After(100 * time.Millisecond): 283 t.Fatal("timeout waiting for state change event") 284 } 285 286 // Should receive error event 287 select { 288 case e := <-events: 289 if e.Type != EventMysisError { 290 t.Errorf("expected EventMysisError, got %s", e.Type) 291 } 292 case <-time.After(100 * time.Millisecond): 293 t.Fatal("timeout waiting for error event") 294 } 295} 296 297func TestMysisProviderName(t *testing.T) { 298 s, bus, cleanup := setupMysisTest(t) 299 defer cleanup() 300 301 stored, _ := s.CreateMysis("provider-test", "mock", "test-model", 0.7) 302 mock := provider.NewMock("test-provider", "response") 303 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 304 305 if mysis.ProviderName() != "test-provider" { 306 t.Errorf("expected provider name=test-provider, got %s", mysis.ProviderName()) 307 } 308 309 // Test with nil provider 310 mysis.SetProvider(nil) 311 if mysis.ProviderName() != "" { 312 t.Errorf("expected empty provider name for nil provider, got %s", mysis.ProviderName()) 313 } 314} 315 316func TestMysisStateEvents(t *testing.T) { 317 s, bus, cleanup := setupMysisTest(t) 318 defer cleanup() 319 320 stored, _ := s.CreateMysis("event-test", "mock", "test-model", 0.7) 321 mock := provider.NewMock("mock", "response") 322 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 323 324 events := bus.Subscribe() 325 326 mysis.Start() 327 328 // Should get state change event 329 select { 330 case e := <-events: 331 if e.Type != EventMysisStateChanged { 332 t.Errorf("expected state change event, got %s", e.Type) 333 } 334 if e.State == nil { 335 t.Fatal("expected state change data") 336 } 337 if e.State.OldState != MysisStateIdle { 338 t.Errorf("expected old state=idle, got %s", e.State.OldState) 339 } 340 if e.State.NewState != MysisStateRunning { 341 t.Errorf("expected new state=running, got %s", e.State.NewState) 342 } 343 case <-time.After(100 * time.Millisecond): 344 t.Fatal("timeout waiting for state change event") 345 } 346 347 mysis.Stop() 348} 349 350func TestSystemPromptContainsCaptainsLogExamples(t *testing.T) { 351 // SystemPrompt should contain core game guidance 352 if !strings.Contains(constants.SystemPrompt, "get_notifications") { 353 t.Fatal("SystemPrompt missing get_notifications reminder") 354 } 355 if !strings.Contains(constants.SystemPrompt, "{{LATEST_BROADCAST}}") { 356 t.Fatal("SystemPrompt missing broadcast placeholder") 357 } 358 if !strings.Contains(constants.SystemPrompt, "swarm") { 359 t.Fatal("SystemPrompt missing swarm reference") 360 } 361} 362 363func TestContinuePromptContainsCriticalReminders(t *testing.T) { 364 // ContinuePrompt should encourage autonomy 365 if !strings.Contains(constants.ContinuePrompt, "What's your next move?") { 366 t.Fatal("ContinuePrompt missing autonomy prompt") 367 } 368} 369 370func TestFormatToolResult_EmptyEntryError(t *testing.T) { 371 m := &Mysis{} 372 result := &mcp.ToolResult{ 373 Content: []mcp.ContentBlock{{Type: "text", Text: "empty_entry"}}, 374 IsError: true, 375 } 376 got := m.formatToolResult("call_1", "captains_log_add", result, nil) 377 if !strings.Contains(got, "entry field must contain non-empty text") { 378 t.Fatal("expected actionable guidance for empty_entry") 379 } 380 if !strings.Contains(got, "Error calling captains_log_add:") { 381 t.Fatal("expected tool name in error message") 382 } 383} 384 385func TestFormatToolResult_GenericError(t *testing.T) { 386 m := &Mysis{} 387 result := &mcp.ToolResult{ 388 Content: []mcp.ContentBlock{{Type: "text", Text: "some_other_error"}}, 389 IsError: true, 390 } 391 got := m.formatToolResult("call_1", "some_tool", result, nil) 392 if !strings.Contains(got, "Error calling some_tool:") { 393 t.Fatal("expected tool name in generic error format") 394 } 395 if strings.Contains(got, "entry field") { 396 t.Fatal("should not contain empty_entry guidance for generic errors") 397 } 398} 399 400func TestFormatToolResult_Success(t *testing.T) { 401 m := &Mysis{} 402 result := &mcp.ToolResult{ 403 Content: []mcp.ContentBlock{{Type: "text", Text: "success result"}}, 404 IsError: false, 405 } 406 got := m.formatToolResult("call_1", "test_tool", result, nil) 407 if !strings.Contains(got, "call_1:success result") { 408 t.Fatalf("expected success format, got: %s", got) 409 } 410 if strings.Contains(got, "Error") { 411 t.Fatal("should not contain Error prefix for successful results") 412 } 413} 414 415func TestSystemPromptContainsSearchGuidance(t *testing.T) { 416 // SystemPrompt was simplified - check for core game guidance 417 if !strings.Contains(constants.SystemPrompt, "game") { 418 t.Fatal("SystemPrompt missing game reference") 419 } 420 if !strings.Contains(constants.SystemPrompt, "EVERY TURN") { 421 t.Fatal("SystemPrompt missing turn reminder") 422 } 423} 424 425func TestContinuePromptContainsSearchReminder(t *testing.T) { 426 // ContinuePrompt is intentionally minimal - just encourages action 427 // All guidance is in SystemPrompt 428 if constants.ContinuePrompt == "" { 429 t.Fatal("ContinuePrompt is empty") 430 } 431} 432 433// TestContinuePromptAddsDriftReminder removed - buildContinuePrompt() method removed. 434// Drift reminders are now part of the system prompt, not dynamically generated. 435 436func TestSnapshotCompaction(t *testing.T) { 437 s, bus, cleanup := setupMysisTest(t) 438 defer cleanup() 439 440 stored, _ := s.CreateMysis("compaction-test", "mock", "test-model", 0.7) 441 mock := provider.NewMock("mock", "response") 442 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 443 444 // Add system prompt 445 s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "", "") 446 447 // Add multiple get_status tool results (should be compacted to keep only the latest) 448 for i := 0; i < 5; i++ { 449 s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "check status", "", "") 450 s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, constants.ToolCallStoragePrefix+"call_1:get_status:{}", "", "") 451 s.AddMemory(stored.ID, store.MemoryRoleTool, store.MemorySourceTool, 452 fmt.Sprintf(`call_1:{"status":"active","iteration":%d}`, i), "", "") 453 } 454 455 // Get context memories 456 memories, _, err := mysis.getContextMemories() 457 if err != nil { 458 t.Fatalf("getContextMemories() error: %v", err) 459 } 460 461 // With turn-aware composition + snapshot compression: 462 // - Historical context: latest tool loop from turns 0-3 (iteration 3) 463 // - Current turn: all of turn 4 (user + assistant + tool for iteration 4) 464 // - Compression: get_status is a snapshot tool, so only the LATEST is kept (iteration 4) 465 // So we expect 1 tool result: iteration 4 (most recent) 466 statusResults := 0 467 hasIteration4 := false 468 for _, m := range memories { 469 if m.Role == store.MemoryRoleTool && strings.Contains(m.Content, `"iteration":`) { 470 statusResults++ 471 if strings.Contains(m.Content, `"iteration":4`) { 472 hasIteration4 = true 473 } 474 } 475 } 476 if statusResults != 1 { 477 t.Errorf("expected 1 get_status result after compression, got %d", statusResults) 478 } 479 if !hasIteration4 { 480 t.Error("expected iteration 4 result (latest snapshot after compression)") 481 } 482} 483 484func TestGetContextMemories_CurrentTurnBoundary(t *testing.T) { 485 s, bus, cleanup := setupMysisTest(t) 486 defer cleanup() 487 488 // Create a mysis for testing 489 stored, err := s.CreateMysis("priority-test", "mock", "test-model", 0.7) 490 if err != nil { 491 t.Fatalf("CreateMysis() error: %v", err) 492 } 493 494 mock := provider.NewMock("mock", "response") 495 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 496 497 // Commander ID for testing 498 commanderID := "commander-mysis-id" 499 swarmMysisID := "swarm-mysis-id" 500 501 tests := []struct { 502 name string 503 setupMemories func() 504 expectedSource store.MemorySource 505 expectedSender string 506 }{ 507 { 508 name: "current_turn_start", 509 setupMemories: func() { 510 // Add system prompt 511 s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "", "") 512 // Add commander direct message (older) 513 s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "Commander direct message", "", commanderID) 514 // Add commander broadcast (middle) 515 s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceBroadcast, "Commander broadcast", "", commanderID) 516 // Add swarm broadcast (most recent - this starts the current turn) 517 s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceBroadcast, "Swarm broadcast", "", swarmMysisID) 518 }, 519 expectedSource: store.MemorySourceBroadcast, 520 expectedSender: swarmMysisID, 521 }, 522 { 523 name: "commander_broadcast_when_no_direct", 524 setupMemories: func() { 525 // Add system prompt 526 s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "", "") 527 // Add commander broadcast (most recent) 528 s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceBroadcast, "Commander broadcast 1", "", commanderID) 529 // Add swarm broadcast (should be ignored when commander broadcast exists) 530 s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceBroadcast, "Swarm broadcast", "", swarmMysisID) 531 // Add older commander broadcast 532 s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceBroadcast, "Commander broadcast 2", "", commanderID) 533 }, 534 expectedSource: store.MemorySourceBroadcast, 535 expectedSender: commanderID, 536 }, 537 { 538 name: "swarm_broadcast_when_no_commander_messages", 539 setupMemories: func() { 540 // Add system prompt 541 s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "", "") 542 // Add older swarm broadcast 543 s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceBroadcast, "Swarm broadcast 1", "", swarmMysisID) 544 // Add most recent swarm broadcast 545 s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceBroadcast, "Swarm broadcast 2", "", swarmMysisID) 546 }, 547 expectedSource: store.MemorySourceBroadcast, 548 expectedSender: swarmMysisID, 549 }, 550 { 551 name: "synthetic_nudge_when_no_broadcasts", 552 setupMemories: func() { 553 // Add system prompt only 554 s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "", "") 555 // Add some assistant responses (no user messages) 556 s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "Previous response", "", "") 557 }, 558 expectedSource: store.MemorySourceSystem, // Nudge should be synthesized (not in DB) 559 expectedSender: "", 560 }, 561 } 562 563 for _, tt := range tests { 564 t.Run(tt.name, func(t *testing.T) { 565 // Clear memories for clean test 566 s.DB().Exec("DELETE FROM memories WHERE mysis_id = ?", stored.ID) 567 568 // Setup memories for this test case 569 tt.setupMemories() 570 571 // Get context memories 572 memories, _, err := mysis.getContextMemories() 573 if err != nil { 574 t.Fatalf("getContextMemories() error: %v", err) 575 } 576 577 // Find the current turn boundary in the returned memories 578 // With turn-aware composition, the current turn starts at the most recent user prompt. 579 // The first user message in the result marks the turn boundary. 580 var foundPromptSource *store.Memory 581 for _, m := range memories { 582 if m.Role == store.MemoryRoleUser { 583 foundPromptSource = m 584 break // Take the first user message as the turn boundary 585 } 586 } 587 588 if tt.expectedSource == store.MemorySourceSystem { 589 // Synthetic encouragement case - should have a user message with source=system 590 if foundPromptSource == nil { 591 t.Fatal("expected synthetic encouragement user message, but got none") 592 } 593 if foundPromptSource.Role != store.MemoryRoleUser { 594 t.Errorf("expected role=user for encouragement, got %s", foundPromptSource.Role) 595 } 596 if foundPromptSource.Source != store.MemorySourceSystem { 597 t.Errorf("expected source=system for encouragement, got %s", foundPromptSource.Source) 598 } 599 // Encouragement should contain helpful content 600 if len(foundPromptSource.Content) == 0 { 601 t.Error("expected encouragement content to be non-empty") 602 } 603 } else { 604 // Should find the correct turn boundary 605 if foundPromptSource == nil { 606 t.Fatal("expected to find a turn boundary, but got none") 607 } 608 609 if foundPromptSource.Source != tt.expectedSource { 610 t.Errorf("expected source=%s, got %s", tt.expectedSource, foundPromptSource.Source) 611 } 612 613 if foundPromptSource.SenderID != tt.expectedSender { 614 t.Errorf("expected sender_id=%s, got %s", tt.expectedSender, foundPromptSource.SenderID) 615 } 616 } 617 }) 618 } 619} 620 621func TestExtractLatestToolLoopHelper(t *testing.T) { 622 s, bus, cleanup := setupMysisTest(t) 623 defer cleanup() 624 625 stored, err := s.CreateMysis("helper-test", "mock", "test-model", 0.7) 626 if err != nil { 627 t.Fatalf("CreateMysis() error: %v", err) 628 } 629 630 mock := provider.NewMock("mock", "response") 631 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 632 633 tests := []struct { 634 name string 635 memories []*store.Memory 636 expectedCount int 637 expectNil bool 638 }{ 639 { 640 name: "nil_memories", 641 memories: nil, 642 expectNil: true, 643 }, 644 { 645 name: "empty_memories", 646 memories: []*store.Memory{}, 647 expectNil: true, 648 }, 649 { 650 name: "no_tool_calls", 651 memories: []*store.Memory{ 652 {Role: store.MemoryRoleSystem, Content: "System"}, 653 {Role: store.MemoryRoleUser, Content: "User message"}, 654 {Role: store.MemoryRoleAssistant, Content: "Text response"}, 655 }, 656 expectNil: true, 657 }, 658 { 659 name: "single_tool_call_with_results", 660 memories: []*store.Memory{ 661 {Role: store.MemoryRoleSystem, Content: "System"}, 662 {Role: store.MemoryRoleUser, Content: "User"}, 663 {Role: store.MemoryRoleAssistant, Content: "[TOOL_CALLS]call_1:get_status:{}"}, 664 {Role: store.MemoryRoleTool, Content: "call_1:status result"}, 665 }, 666 expectedCount: 2, // 1 tool call + 1 result 667 }, 668 { 669 name: "tool_call_with_no_results_yet", 670 memories: []*store.Memory{ 671 {Role: store.MemoryRoleSystem, Content: "System"}, 672 {Role: store.MemoryRoleUser, Content: "User"}, 673 {Role: store.MemoryRoleAssistant, Content: "[TOOL_CALLS]call_1:get_status:{}"}, 674 }, 675 expectedCount: 1, // Just the tool call 676 }, 677 { 678 name: "multiple_loops_returns_most_recent", 679 memories: []*store.Memory{ 680 {Role: store.MemoryRoleSystem, Content: "System"}, 681 {Role: store.MemoryRoleAssistant, Content: "[TOOL_CALLS]call_old:get_status:{}"}, 682 {Role: store.MemoryRoleTool, Content: "call_old:old result"}, 683 {Role: store.MemoryRoleAssistant, Content: "[TOOL_CALLS]call_new:get_poi:{}"}, 684 {Role: store.MemoryRoleTool, Content: "call_new:new result"}, 685 }, 686 expectedCount: 2, // Most recent loop only 687 }, 688 { 689 name: "tool_call_with_multiple_results", 690 memories: []*store.Memory{ 691 {Role: store.MemoryRoleAssistant, Content: "[TOOL_CALLS]call_1:get_status:{}|call_2:get_system:{}"}, 692 {Role: store.MemoryRoleTool, Content: "call_1:result 1"}, 693 {Role: store.MemoryRoleTool, Content: "call_2:result 2"}, 694 }, 695 expectedCount: 3, // 1 tool call message + 2 results 696 }, 697 } 698 699 for _, tt := range tests { 700 t.Run(tt.name, func(t *testing.T) { 701 result := mysis.extractLatestToolLoop(tt.memories) 702 703 if tt.expectNil { 704 if result != nil { 705 t.Errorf("expected nil, got %d memories", len(result)) 706 } 707 return 708 } 709 710 if len(result) != tt.expectedCount { 711 t.Errorf("expected %d memories, got %d", tt.expectedCount, len(result)) 712 for i, m := range result { 713 t.Logf(" result[%d]: role=%s content=%.50s", i, m.Role, m.Content) 714 } 715 } 716 717 // Verify first is tool call 718 if len(result) > 0 { 719 if result[0].Role != store.MemoryRoleAssistant { 720 t.Errorf("first memory should be assistant, got %s", result[0].Role) 721 } 722 if !strings.HasPrefix(result[0].Content, "[TOOL_CALLS]") { 723 t.Errorf("first memory should have tool calls prefix") 724 } 725 } 726 727 // Verify rest are tool results 728 for i := 1; i < len(result); i++ { 729 if result[i].Role != store.MemoryRoleTool { 730 t.Errorf("memory[%d] should be tool result, got %s", i, result[i].Role) 731 } 732 } 733 }) 734 } 735} 736 737func TestComputeMemoryStats(t *testing.T) { 738 m := &Mysis{} 739 740 t.Run("empty", func(t *testing.T) { 741 stats := m.computeMemoryStats(nil) 742 if stats.MemoryCount != 0 { 743 t.Fatalf("expected memory count 0, got %d", stats.MemoryCount) 744 } 745 if stats.ContentBytes != 0 { 746 t.Fatalf("expected content bytes 0, got %d", stats.ContentBytes) 747 } 748 if stats.ReasoningBytes != 0 { 749 t.Fatalf("expected reasoning bytes 0, got %d", stats.ReasoningBytes) 750 } 751 if len(stats.RoleCounts) != 0 { 752 t.Fatalf("expected empty role counts, got %v", stats.RoleCounts) 753 } 754 if len(stats.SourceCounts) != 0 { 755 t.Fatalf("expected empty source counts, got %v", stats.SourceCounts) 756 } 757 }) 758 759 t.Run("mixed", func(t *testing.T) { 760 memories := []*store.Memory{ 761 {Role: store.MemoryRoleSystem, Source: store.MemorySourceSystem, Content: "abc", Reasoning: "r"}, 762 {Role: store.MemoryRoleUser, Source: store.MemorySourceDirect, Content: "", Reasoning: ""}, 763 {Role: store.MemoryRoleAssistant, Source: store.MemorySourceLLM, Content: "done", Reasoning: "why"}, 764 {Role: store.MemoryRoleTool, Source: store.MemorySourceTool, Content: "tool", Reasoning: ""}, 765 } 766 stats := m.computeMemoryStats(memories) 767 if stats.MemoryCount != 4 { 768 t.Fatalf("expected memory count 4, got %d", stats.MemoryCount) 769 } 770 if stats.ContentBytes != 11 { 771 t.Fatalf("expected content bytes 11, got %d", stats.ContentBytes) 772 } 773 if stats.ReasoningBytes != 4 { 774 t.Fatalf("expected reasoning bytes 4, got %d", stats.ReasoningBytes) 775 } 776 if stats.RoleCounts[string(store.MemoryRoleSystem)] != 1 || 777 stats.RoleCounts[string(store.MemoryRoleUser)] != 1 || 778 stats.RoleCounts[string(store.MemoryRoleAssistant)] != 1 || 779 stats.RoleCounts[string(store.MemoryRoleTool)] != 1 { 780 t.Fatalf("unexpected role counts: %v", stats.RoleCounts) 781 } 782 if stats.SourceCounts[string(store.MemorySourceSystem)] != 1 || 783 stats.SourceCounts[string(store.MemorySourceDirect)] != 1 || 784 stats.SourceCounts[string(store.MemorySourceLLM)] != 1 || 785 stats.SourceCounts[string(store.MemorySourceTool)] != 1 { 786 t.Fatalf("unexpected source counts: %v", stats.SourceCounts) 787 } 788 }) 789 790 t.Run("unicode", func(t *testing.T) { 791 memories := []*store.Memory{ 792 {Role: store.MemoryRoleUser, Source: store.MemorySourceDirect, Content: "◈", Reasoning: "ä"}, 793 } 794 stats := m.computeMemoryStats(memories) 795 if stats.ContentBytes != 3 { 796 t.Fatalf("expected content bytes 3, got %d", stats.ContentBytes) 797 } 798 if stats.ReasoningBytes != 2 { 799 t.Fatalf("expected reasoning bytes 2, got %d", stats.ReasoningBytes) 800 } 801 }) 802} 803 804func TestComputeMessageStats(t *testing.T) { 805 m := &Mysis{} 806 807 t.Run("empty", func(t *testing.T) { 808 stats := m.computeMessageStats(nil) 809 if stats.MessageCount != 0 { 810 t.Fatalf("expected message count 0, got %d", stats.MessageCount) 811 } 812 if stats.ContentBytes != 0 { 813 t.Fatalf("expected content bytes 0, got %d", stats.ContentBytes) 814 } 815 if stats.ToolCallCount != 0 { 816 t.Fatalf("expected tool call count 0, got %d", stats.ToolCallCount) 817 } 818 }) 819 820 t.Run("mixed", func(t *testing.T) { 821 messages := []provider.Message{ 822 {Role: "user", Content: "abc"}, 823 {Role: "assistant", Content: "◈", ToolCalls: []provider.ToolCall{{Name: "a"}, {Name: "b"}}}, 824 {Role: "tool", Content: "ok"}, 825 } 826 stats := m.computeMessageStats(messages) 827 if stats.MessageCount != 3 { 828 t.Fatalf("expected message count 3, got %d", stats.MessageCount) 829 } 830 if stats.ContentBytes != 8 { 831 t.Fatalf("expected content bytes 8, got %d", stats.ContentBytes) 832 } 833 if stats.ToolCallCount != 2 { 834 t.Fatalf("expected tool call count 2, got %d", stats.ToolCallCount) 835 } 836 }) 837} 838 839func TestMysisActivityTravelUntilFromTicks(t *testing.T) { 840 m := &Mysis{} 841 842 now := time.Now() 843 m.lastServerTick = 100 844 m.lastServerTickAt = now.Add(-20 * time.Second) 845 846 result := &mcp.ToolResult{ 847 Content: []mcp.ContentBlock{{Type: "text", Text: `{"current_tick":110,"arrival_tick":120}`}}, 848 } 849 850 m.updateActivityFromToolResult(result, nil) 851 852 if m.activityState != ActivityStateTraveling { 853 t.Fatalf("expected activity state traveling, got %s", m.activityState) 854 } 855 856 remaining := time.Until(m.activityUntil) 857 if remaining < 18*time.Second || remaining > 25*time.Second { 858 t.Fatalf("expected travel wait around 20s, got %s", remaining) 859 } 860} 861 862func TestMysisActivityTravelFallbackWait(t *testing.T) { 863 m := &Mysis{} 864 865 result := &mcp.ToolResult{ 866 Content: []mcp.ContentBlock{{Type: "text", Text: `{"arrival_tick":5000}`}}, 867 } 868 869 m.updateActivityFromToolResult(result, nil) 870 871 if m.activityState != ActivityStateTraveling { 872 t.Fatalf("expected activity state traveling, got %s", m.activityState) 873 } 874 875 remaining := time.Until(m.activityUntil) 876 if remaining < constants.WaitStateNudgeInterval-2*time.Second || remaining > constants.WaitStateNudgeInterval+2*time.Second { 877 t.Fatalf("expected travel fallback wait around %s, got %s", constants.WaitStateNudgeInterval, remaining) 878 } 879} 880 881func TestMysisActivityTravelArrivalTickReached(t *testing.T) { 882 m := &Mysis{} 883 884 result := &mcp.ToolResult{ 885 Content: []mcp.ContentBlock{{Type: "text", Text: `{"current_tick":120,"arrival_tick":120}`}}, 886 } 887 888 m.updateActivityFromToolResult(result, nil) 889 890 if m.activityState != ActivityStateIdle { 891 t.Fatalf("expected activity state idle, got %s", m.activityState) 892 } 893 if !m.activityUntil.IsZero() { 894 t.Fatal("expected activityUntil to be zero when arrival tick reached") 895 } 896} 897 898func TestMysisActivityTravelArrivalTickField(t *testing.T) { 899 m := &Mysis{} 900 901 result := &mcp.ToolResult{ 902 Content: []mcp.ContentBlock{{Type: "text", Text: `{"current_tick":200,"travel_arrival_tick":210}`}}, 903 } 904 905 m.updateActivityFromToolResult(result, nil) 906 907 if m.activityState != ActivityStateTraveling { 908 t.Fatalf("expected activity state traveling, got %s", m.activityState) 909 } 910} 911 912func TestFindCurrentTick(t *testing.T) { 913 tests := []struct { 914 name string 915 payload interface{} 916 want int64 917 ok bool 918 }{ 919 { 920 name: "top_level_current_tick", 921 payload: map[string]interface{}{"current_tick": int64(42)}, 922 want: 42, 923 ok: true, 924 }, 925 { 926 name: "wrapper_current_tick", 927 payload: map[string]interface{}{"data": map[string]interface{}{"current_tick": int64(88)}}, 928 want: 88, 929 ok: true, 930 }, 931 { 932 name: "wrapper_tick_fallback", 933 payload: map[string]interface{}{"result": map[string]interface{}{"tick": int64(9)}}, 934 want: 9, 935 ok: true, 936 }, 937 { 938 name: "missing_tick", 939 payload: map[string]interface{}{"status": "ok"}, 940 want: 0, 941 ok: false, 942 }, 943 } 944 945 for _, test := range tests { 946 t.Run(test.name, func(t *testing.T) { 947 got, ok := findCurrentTick(test.payload) 948 if ok != test.ok { 949 t.Fatalf("expected ok=%v, got %v", test.ok, ok) 950 } 951 if got != test.want { 952 t.Fatalf("expected tick %d, got %d", test.want, got) 953 } 954 }) 955 } 956} 957 958// TestMysisStopDoesNotOverrideWithError tests that stopping a mysis 959// doesn't allow concurrent error to override Stopped state. 960func TestMysisStopDoesNotOverrideWithError(t *testing.T) { 961 s, bus, cleanup := setupMysisTest(t) 962 defer cleanup() 963 964 stored, _ := s.CreateMysis("stop-test", "mock", "test-model", 0.7) 965 966 mock := provider.NewMock("mock", "test response") 967 m := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 968 969 // Start the mysis 970 if err := m.Start(); err != nil { 971 t.Fatalf("Start() error: %v", err) 972 } 973 974 // Give it a moment to stabilize 975 time.Sleep(100 * time.Millisecond) 976 977 // Stop the mysis 978 if err := m.Stop(); err != nil { 979 t.Fatalf("Stop() error: %v", err) 980 } 981 982 // Verify state is Stopped (not Errored) 983 if m.State() != MysisStateStopped { 984 t.Errorf("expected state=stopped, got %s (lastError: %v)", m.State(), m.LastError()) 985 } 986 987 // Verify no error is set 988 if m.LastError() != nil { 989 t.Errorf("expected no lastError after clean stop, got: %v", m.LastError()) 990 } 991} 992 993// TestStopDuringInitialMessage tests the critical race condition: 994// Stop() called IMMEDIATELY after Start(), during the initial SendMessage. 995// 996// Timeline: 997// - Line 268: Start() spawns `go a.SendMessage(ContinuePrompt, ...)` 998// - Line 270: Start() returns 999// - HERE: Test calls Stop() (within 5-10ms) 1000// - SendMessage goroutine may still be waiting to acquire turnMu 1001// 1002// Expected: Final state is Stopped, no deadlock, no panic. 1003func TestStopDuringInitialMessage(t *testing.T) { 1004 s, bus, cleanup := setupMysisTest(t) 1005 defer cleanup() 1006 1007 stored, _ := s.CreateMysis("race-test", "mock", "test-model", 0.7) 1008 1009 // Use a mock provider with NO delay - we want to test the race 1010 // between Start() spawning SendMessage and Stop() being called 1011 mock := provider.NewMock("mock", "response") 1012 m := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1013 1014 // Start the mysis (spawns initial SendMessage goroutine) 1015 if err := m.Start(); err != nil { 1016 t.Fatalf("Start() error: %v", err) 1017 } 1018 1019 // IMMEDIATELY call Stop() - this creates the race condition 1020 // The initial SendMessage may not have acquired turnMu yet 1021 // No sleep = tightest race window possible 1022 // time.Sleep(5 * time.Millisecond) 1023 1024 done := make(chan error, 1) 1025 go func() { 1026 done <- m.Stop() 1027 }() 1028 1029 // Stop should complete within a reasonable timeout 1030 select { 1031 case err := <-done: 1032 if err != nil { 1033 t.Fatalf("Stop() error: %v", err) 1034 } 1035 case <-time.After(2 * time.Second): 1036 t.Fatal("timeout waiting for Stop() - possible deadlock") 1037 } 1038 1039 // Verify final state is Stopped 1040 if m.State() != MysisStateStopped { 1041 t.Errorf("expected state=stopped after immediate Stop(), got %s", m.State()) 1042 } 1043 1044 // Verify no error was set 1045 if m.LastError() != nil { 1046 t.Errorf("expected no lastError after immediate Stop(), got: %v", m.LastError()) 1047 } 1048} 1049 1050// TestStopDuringInitialMessageWithSlowProvider tests an even tighter race: 1051// Stop() called while the initial SendMessage is INSIDE the provider.Chat() call. 1052// 1053// Timeline: 1054// - Start() spawns SendMessage goroutine 1055// - SendMessage acquires turnMu and enters provider.Chat() (50ms delay) 1056// - Test calls Stop() immediately (no sleep) 1057// - Stop() waits for turnMu while provider is processing 1058// 1059// Expected: Stop waits for turn to complete, then succeeds. 1060func TestStopDuringInitialMessageWithSlowProvider(t *testing.T) { 1061 s, bus, cleanup := setupMysisTest(t) 1062 defer cleanup() 1063 1064 stored, _ := s.CreateMysis("slow-provider-race", "mock", "test-model", 0.7) 1065 1066 // Use a provider with delay to simulate the mysis being mid-turn when Stop is called 1067 mock := provider.NewMock("mock", "response").SetDelay(50 * time.Millisecond) 1068 m := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1069 1070 // Start the mysis 1071 if err := m.Start(); err != nil { 1072 t.Fatalf("Start() error: %v", err) 1073 } 1074 1075 // Call Stop IMMEDIATELY (no sleep) - this should catch the initial 1076 // SendMessage while it's inside provider.Chat() 1077 done := make(chan error, 1) 1078 go func() { 1079 done <- m.Stop() 1080 }() 1081 1082 // Stop should wait for the current turn to finish, then succeed 1083 select { 1084 case err := <-done: 1085 if err != nil { 1086 t.Fatalf("Stop() error: %v", err) 1087 } 1088 case <-time.After(2 * time.Second): 1089 t.Fatal("timeout waiting for Stop() - possible deadlock") 1090 } 1091 1092 // Verify final state is Stopped 1093 if m.State() != MysisStateStopped { 1094 t.Errorf("expected state=stopped, got %s", m.State()) 1095 } 1096 1097 // Verify no error was set 1098 if m.LastError() != nil { 1099 t.Errorf("expected no lastError, got: %v", m.LastError()) 1100 } 1101} 1102 1103// TestStopDuringIdleNudge removed - ticker-based system obsolete. 1104// Encouragement is now database-driven via getContextMemories(). 1105 1106// TestStopAtVariousTimings is a parameterized test that calls Stop() at 1107// different delays after Start() to systematically explore timing windows. 1108// 1109// This test helps identify which timing windows consistently fail or pass, 1110// revealing patterns in race conditions. 1111// 1112// Test delays: 1113// - 0ms: Immediate (before initial SendMessage goroutine starts) 1114// - 10ms: Very fast (goroutine just started, may not have acquired turnMu) 1115// - 50ms: During initial message processing (inside provider.Chat) 1116// - 100ms: After initial message likely done 1117// - 500ms: After sufficient time for initial turn 1118// 1119// Run each timing 10 times with: 1120// 1121// go test ./internal/core -run TestStopAtVariousTimings -count=10 1122func TestStopAtVariousTimings(t *testing.T) { 1123 delays := []time.Duration{ 1124 0, // 0ms - immediate 1125 10 * time.Millisecond, // 10ms - very fast 1126 50 * time.Millisecond, // 50ms - during initial message 1127 100 * time.Millisecond, // 100ms - after initial message likely done 1128 500 * time.Millisecond, // 500ms - after sufficient time for initial turn 1129 } 1130 1131 for _, delay := range delays { 1132 t.Run(fmt.Sprintf("delay_%dms", delay.Milliseconds()), func(t *testing.T) { 1133 s, bus, cleanup := setupMysisTest(t) 1134 defer cleanup() 1135 1136 stored, err := s.CreateMysis( 1137 fmt.Sprintf("timing-test-%dms", delay.Milliseconds()), 1138 "mock", 1139 "test-model", 1140 0.7, 1141 ) 1142 if err != nil { 1143 t.Fatalf("CreateMysis() error: %v", err) 1144 } 1145 1146 // Use a mock with a delay to simulate real LLM processing 1147 mock := provider.NewMock("mock", "test response").SetDelay(25 * time.Millisecond) 1148 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1149 1150 // Start mysis 1151 if err := mysis.Start(); err != nil { 1152 t.Fatalf("Start() error: %v", err) 1153 } 1154 1155 // Wait for the specified delay 1156 time.Sleep(delay) 1157 1158 // Stop mysis 1159 if err := mysis.Stop(); err != nil { 1160 t.Fatalf("Stop() error: %v", err) 1161 } 1162 1163 // Verify final state is Stopped (critical assertion) 1164 finalState := mysis.State() 1165 if finalState != MysisStateStopped { 1166 t.Errorf("expected state=stopped, got %s (lastError: %v)", finalState, mysis.LastError()) 1167 } 1168 1169 // Verify no error is set 1170 if mysis.LastError() != nil { 1171 t.Errorf("expected no lastError after clean stop, got: %v", mysis.LastError()) 1172 } 1173 }) 1174 } 1175} 1176 1177// TestNudgeCircuitBreaker removed - ticker-based nudge system obsolete. 1178// Encouragement counter now increments in getContextMemories() when no user message exists. 1179// See TestEncouragementLimit and TestEncouragementReset for new behavior. 1180 1181// TestEncouragementLimit tests that getContextMemories() returns the correct addedSynthetic flag 1182// when no user messages exist. The counter increment happens in SendMessageFrom(), not here. 1183func TestEncouragementLimit(t *testing.T) { 1184 s, bus, cleanup := setupMysisTest(t) 1185 defer cleanup() 1186 1187 stored, err := s.CreateMysis("limit-test", "mock", "test-model", 0.7) 1188 if err != nil { 1189 t.Fatalf("CreateMysis() error: %v", err) 1190 } 1191 1192 mock := provider.NewMock("mock", "response") 1193 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1194 1195 // Add system prompt only (no user messages) 1196 err = s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "", "") 1197 if err != nil { 1198 t.Fatalf("AddMemory error: %v", err) 1199 } 1200 1201 // Call getContextMemories() with no user messages - should return addedSynthetic=true 1202 _, addedSynthetic, err := mysis.getContextMemories() 1203 if err != nil { 1204 t.Fatalf("getContextMemories() error: %v", err) 1205 } 1206 1207 if !addedSynthetic { 1208 t.Errorf("expected addedSynthetic=true when no user message exists, got false") 1209 } 1210 1211 // Verify counter is still 0 (increment happens in SendMessageFrom, not here) 1212 mysis.mu.RLock() 1213 count := mysis.encouragementCount 1214 mysis.mu.RUnlock() 1215 1216 if count != 0 { 1217 t.Errorf("expected encouragementCount=0 (not incremented by getContextMemories), got %d", count) 1218 } 1219 1220 // Note: Full autonomous turn behavior (counter increment after turn completes) 1221 // is tested in TestMysisCounterBehavior_* tests. 1222} 1223 1224// TestEncouragementReset tests that encouragementCount resets to 0 when a real user message 1225// (broadcast or direct) is received. 1226func TestEncouragementReset(t *testing.T) { 1227 s, bus, cleanup := setupMysisTest(t) 1228 defer cleanup() 1229 1230 t.Run("reset_on_broadcast", func(t *testing.T) { 1231 stored, err := s.CreateMysis("reset-broadcast-test", "mock", "test-model", 0.7) 1232 if err != nil { 1233 t.Fatalf("CreateMysis() error: %v", err) 1234 } 1235 1236 mock := provider.NewMock("mock", "response") 1237 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1238 1239 // Set encouragementCount to 2 (simulate 2 synthetic messages) 1240 mysis.mu.Lock() 1241 mysis.encouragementCount = 2 1242 mysis.mu.Unlock() 1243 1244 // Verify counter is at 2 1245 mysis.mu.RLock() 1246 count := mysis.encouragementCount 1247 mysis.mu.RUnlock() 1248 if count != 2 { 1249 t.Fatalf("expected encouragementCount=2 before broadcast, got %d", count) 1250 } 1251 1252 // Queue broadcast message 1253 err = mysis.QueueBroadcast("Test broadcast", "sender-id") 1254 if err != nil { 1255 t.Fatalf("QueueBroadcast() error: %v", err) 1256 } 1257 1258 // Verify counter was reset to 0 1259 mysis.mu.RLock() 1260 count = mysis.encouragementCount 1261 mysis.mu.RUnlock() 1262 if count != 0 { 1263 t.Errorf("expected encouragementCount=0 after broadcast, got %d", count) 1264 } 1265 }) 1266 1267 t.Run("reset_on_direct_message", func(t *testing.T) { 1268 stored, err := s.CreateMysis("reset-direct-test", "mock", "test-model", 0.7) 1269 if err != nil { 1270 t.Fatalf("CreateMysis() error: %v", err) 1271 } 1272 1273 mock := provider.NewMock("mock", "response") 1274 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1275 1276 // Set encouragementCount to 2 1277 mysis.mu.Lock() 1278 mysis.encouragementCount = 2 1279 mysis.mu.Unlock() 1280 1281 // Send direct message 1282 err = mysis.SendMessageFrom("Test direct", store.MemorySourceDirect, "") 1283 if err != nil { 1284 t.Fatalf("SendMessageFrom() error: %v", err) 1285 } 1286 1287 // Verify counter was reset to 0 1288 mysis.mu.RLock() 1289 count := mysis.encouragementCount 1290 mysis.mu.RUnlock() 1291 if count != 0 { 1292 t.Errorf("expected encouragementCount=0 after direct message, got %d", count) 1293 } 1294 }) 1295 1296 t.Run("no_reset_on_getContextMemories_with_user_message", func(t *testing.T) { 1297 stored, err := s.CreateMysis("no-reset-test", "mock", "test-model", 0.7) 1298 if err != nil { 1299 t.Fatalf("CreateMysis() error: %v", err) 1300 } 1301 1302 mock := provider.NewMock("mock", "response") 1303 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1304 1305 // Add system prompt 1306 err = s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "", "") 1307 if err != nil { 1308 t.Fatalf("AddMemory error: %v", err) 1309 } 1310 1311 // Add user message (real message exists) 1312 err = s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "User message", "", "") 1313 if err != nil { 1314 t.Fatalf("AddMemory error: %v", err) 1315 } 1316 1317 // Set encouragementCount to 2 1318 mysis.mu.Lock() 1319 mysis.encouragementCount = 2 1320 mysis.mu.Unlock() 1321 1322 // Call getContextMemories() - should NOT reset counter because real user message exists 1323 _, _, err = mysis.getContextMemories() 1324 if err != nil { 1325 t.Fatalf("getContextMemories() error: %v", err) 1326 } 1327 1328 // Counter should still be 2 (NOT reset by getContextMemories when user message exists) 1329 mysis.mu.RLock() 1330 count := mysis.encouragementCount 1331 mysis.mu.RUnlock() 1332 if count != 2 { 1333 t.Errorf("expected encouragementCount=2 (NOT reset when user message exists), got %d", count) 1334 } 1335 }) 1336} 1337 1338// TestMysisWithBroadcastsKeepsRunning tests the truth table scenario "Running (With Broadcasts)". 1339// Verifies that when a broadcast is present, the encouragementCount stays at 0 through multiple 1340// turns (because the broadcast remains the most recent user message), keeping the mysis running 1341// without going idle. 1342// 1343// Reference: documentation/architecture/MESSAGE_FORMAT_GUARANTEES.md lines 123-146 1344func TestMysisWithBroadcastsKeepsRunning(t *testing.T) { 1345 s, bus, cleanup := setupMysisTest(t) 1346 defer cleanup() 1347 1348 // Create mysis 1349 stored, err := s.CreateMysis("broadcast-test", "mock", "test-model", 0.7) 1350 if err != nil { 1351 t.Fatalf("CreateMysis() error: %v", err) 1352 } 1353 1354 // Use mock provider with no delay for fast test 1355 mock := provider.NewMock("mock", "I will continue exploring") 1356 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1357 1358 // Step 1-2: Send broadcast "Explore the universe!" via QueueBroadcast 1359 // This will be stored as a user message with source=broadcast 1360 // QueueBroadcast will auto-start the idle mysis 1361 err = mysis.QueueBroadcast("Explore the universe!", "commander-id") 1362 if err != nil { 1363 t.Fatalf("QueueBroadcast() error: %v", err) 1364 } 1365 defer mysis.Stop() 1366 1367 // Step 3: Verify mysis was auto-started by QueueBroadcast 1368 // Give it a moment to transition to running state 1369 time.Sleep(50 * time.Millisecond) 1370 if mysis.State() != MysisStateRunning { 1371 t.Fatalf("expected mysis to be auto-started by broadcast, got state: %s", mysis.State()) 1372 } 1373 1374 // Step 4: Verify encouragementCount = 0 (reset by broadcast in QueueBroadcast) 1375 mysis.mu.RLock() 1376 count := mysis.encouragementCount 1377 mysis.mu.RUnlock() 1378 if count != 0 { 1379 t.Errorf("expected encouragementCount=0 after broadcast (reset in QueueBroadcast), got %d", count) 1380 } 1381 1382 // Step 5: Trigger a turn by sending a message (QueueBroadcast stored the message but doesn't trigger processing) 1383 // The broadcast is now in the database, and SendMessageFrom will trigger getContextMemories() which will find it 1384 err = mysis.SendMessageFrom("Status check", store.MemorySourceDirect, "") 1385 if err != nil { 1386 t.Fatalf("SendMessageFrom() error: %v", err) 1387 } 1388 1389 // Step 6: Check encouragementCount = 0 (reset by the direct message we just sent) 1390 mysis.mu.RLock() 1391 count = mysis.encouragementCount 1392 mysis.mu.RUnlock() 1393 if count != 0 { 1394 t.Errorf("expected encouragementCount=0 after turn (reset by direct message), got %d", count) 1395 } 1396 1397 // Check mysis is still running (not idle) 1398 if mysis.State() != MysisStateRunning { 1399 t.Errorf("expected state=running, got %s", mysis.State()) 1400 } 1401 1402 // Step 7-8: Send additional messages to trigger more turns and verify counter stays at 0 1403 for i := 0; i < 5; i++ { 1404 err = mysis.SendMessageFrom("Continue task", store.MemorySourceDirect, "") 1405 if err != nil { 1406 t.Fatalf("turn %d: SendMessageFrom() error: %v", i+2, err) 1407 } 1408 1409 // Verify counter was reset by direct message 1410 mysis.mu.RLock() 1411 count = mysis.encouragementCount 1412 mysis.mu.RUnlock() 1413 if count != 0 { 1414 t.Errorf("turn %d: expected encouragementCount=0 after direct message (reset), got %d", i+2, count) 1415 } 1416 } 1417 1418 // Step 9: After 6+ turns with user messages, verify mysis is still running (not idle) 1419 if mysis.State() != MysisStateRunning { 1420 t.Errorf("expected state=running after 6+ turns with user messages, got %s", mysis.State()) 1421 } 1422 1423 t.Logf("✅ Mysis with broadcasts/direct messages stays running: counter reset to 0 on each turn, never went idle") 1424} 1425func TestCanAcceptMessages(t *testing.T) { 1426 tests := []struct { 1427 state MysisState 1428 canAccept bool 1429 errMsg string 1430 }{ 1431 {MysisStateIdle, true, ""}, 1432 {MysisStateRunning, true, ""}, 1433 {MysisStateStopped, false, "mysis stopped - press 'r' to relaunch"}, 1434 {MysisStateErrored, false, "mysis errored - press 'r' to relaunch"}, 1435 } 1436 1437 for _, tt := range tests { 1438 t.Run(string(tt.state), func(t *testing.T) { 1439 err := validateCanAcceptMessage(tt.state) 1440 1441 if tt.canAccept { 1442 if err != nil { 1443 t.Errorf("state %s should accept messages, got error: %v", tt.state, err) 1444 } 1445 } else { 1446 if err == nil { 1447 t.Errorf("state %s should reject messages, got nil error", tt.state) 1448 } else if err.Error() != tt.errMsg { 1449 t.Errorf("state %s: expected error %q, got %q", tt.state, tt.errMsg, err.Error()) 1450 } 1451 } 1452 }) 1453 } 1454} 1455 1456// TestExecuteToolCall_ErrorPaths tests error handling in executeToolCall 1457func TestExecuteToolCall_ErrorPaths(t *testing.T) { 1458 s, bus, cleanup := setupMysisTest(t) 1459 defer cleanup() 1460 1461 // Create a shared MCP proxy for tests that need it 1462 proxy := mcp.NewProxy(nil) 1463 1464 t.Run("nil_mcp_proxy", func(t *testing.T) { 1465 stored, _ := s.CreateMysis("nil-proxy-test", "mock", "test-model", 0.7) 1466 mock := provider.NewMock("mock", "response") 1467 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1468 1469 // Call executeToolCall with nil proxy 1470 tc := provider.ToolCall{ 1471 ID: "call_1", 1472 Name: "test_tool", 1473 Arguments: json.RawMessage(`{}`), 1474 } 1475 1476 result, err := mysis.executeToolCall(context.Background(), nil, tc) 1477 1478 // Should return error result (not error), as per MCP design 1479 if err != nil { 1480 t.Errorf("expected no error, got %v", err) 1481 } 1482 if result == nil { 1483 t.Fatal("expected result, got nil") 1484 } 1485 if !result.IsError { 1486 t.Error("expected IsError=true when proxy is nil") 1487 } 1488 if !strings.Contains(result.Content[0].Text, "MCP not configured") { 1489 t.Errorf("expected 'MCP not configured' error, got: %s", result.Content[0].Text) 1490 } 1491 }) 1492 1493 t.Run("tool_call_timeout", func(t *testing.T) { 1494 stored, _ := s.CreateMysis("timeout-test", "mock", "test-model", 0.7) 1495 mock := provider.NewMock("mock", "response") 1496 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1497 1498 // Create a context with very short timeout 1499 ctx, cancel := context.WithTimeout(context.Background(), 1*time.Nanosecond) 1500 defer cancel() 1501 time.Sleep(10 * time.Millisecond) // Ensure timeout fires 1502 1503 tc := provider.ToolCall{ 1504 ID: "call_1", 1505 Name: "get_status", 1506 Arguments: json.RawMessage(`{}`), 1507 } 1508 1509 result, err := mysis.executeToolCall(ctx, proxy, tc) 1510 1511 // When tool is not found, MCP returns an error result (not an error) 1512 // This is testing that executeToolCall handles missing tools gracefully 1513 if err != nil { 1514 t.Errorf("expected no error (tool not found returns error result), got: %v", err) 1515 } 1516 if result == nil { 1517 t.Fatal("expected result, got nil") 1518 } 1519 if !result.IsError { 1520 t.Error("expected IsError=true for tool not found") 1521 } 1522 }) 1523 1524 t.Run("invalid_tool_arguments", func(t *testing.T) { 1525 stored, _ := s.CreateMysis("invalid-args-test", "mock", "test-model", 0.7) 1526 mock := provider.NewMock("mock", "response") 1527 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1528 1529 // Register a tool that validates arguments 1530 proxy.RegisterTool( 1531 mcp.Tool{ 1532 Name: "strict_tool", 1533 Description: "Tool with strict arg validation", 1534 InputSchema: json.RawMessage(`{"type":"object","properties":{"required_field":{"type":"string"}},"required":["required_field"]}`), 1535 }, 1536 func(ctx context.Context, args json.RawMessage) (*mcp.ToolResult, error) { 1537 var params struct { 1538 RequiredField string `json:"required_field"` 1539 } 1540 if err := json.Unmarshal(args, ¶ms); err != nil { 1541 return &mcp.ToolResult{ 1542 Content: []mcp.ContentBlock{{Type: "text", Text: "invalid JSON"}}, 1543 IsError: true, 1544 }, nil 1545 } 1546 if params.RequiredField == "" { 1547 return &mcp.ToolResult{ 1548 Content: []mcp.ContentBlock{{Type: "text", Text: "missing required_field"}}, 1549 IsError: true, 1550 }, nil 1551 } 1552 return &mcp.ToolResult{ 1553 Content: []mcp.ContentBlock{{Type: "text", Text: "success"}}, 1554 }, nil 1555 }, 1556 ) 1557 1558 tc := provider.ToolCall{ 1559 ID: "call_1", 1560 Name: "strict_tool", 1561 Arguments: json.RawMessage(`{}`), // Missing required field 1562 } 1563 1564 result, err := mysis.executeToolCall(context.Background(), proxy, tc) 1565 1566 if err != nil { 1567 t.Errorf("expected no error, got %v", err) 1568 } 1569 if result == nil { 1570 t.Fatal("expected result, got nil") 1571 } 1572 if !result.IsError { 1573 t.Error("expected IsError=true for invalid arguments") 1574 } 1575 }) 1576 1577 t.Run("mcp_call_tool_error", func(t *testing.T) { 1578 stored, _ := s.CreateMysis("mcp-error-test", "mock", "test-model", 0.7) 1579 mock := provider.NewMock("mock", "response") 1580 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1581 1582 // Register a tool that returns an error 1583 proxy.RegisterTool( 1584 mcp.Tool{ 1585 Name: "error_tool", 1586 Description: "Tool that fails", 1587 InputSchema: json.RawMessage(`{"type":"object","properties":{}}`), 1588 }, 1589 func(ctx context.Context, args json.RawMessage) (*mcp.ToolResult, error) { 1590 return nil, fmt.Errorf("tool execution failed") 1591 }, 1592 ) 1593 1594 tc := provider.ToolCall{ 1595 ID: "call_1", 1596 Name: "error_tool", 1597 Arguments: json.RawMessage(`{}`), 1598 } 1599 1600 result, err := mysis.executeToolCall(context.Background(), proxy, tc) 1601 1602 // executeToolCall should propagate the error 1603 if err == nil { 1604 t.Error("expected error from tool execution") 1605 } 1606 if !strings.Contains(err.Error(), "tool execution failed") { 1607 t.Errorf("expected 'tool execution failed' error, got: %v", err) 1608 } 1609 // Result should be nil when handler returns error 1610 if result != nil { 1611 t.Errorf("expected nil result on error, got: %v", result) 1612 } 1613 }) 1614 1615 t.Run("tool_result_parsing_with_empty_content", func(t *testing.T) { 1616 stored, _ := s.CreateMysis("parse-test", "mock", "test-model", 0.7) 1617 mock := provider.NewMock("mock", "response") 1618 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1619 1620 // Register a tool that returns empty content 1621 proxy.RegisterTool( 1622 mcp.Tool{ 1623 Name: "empty_tool", 1624 Description: "Tool with empty result", 1625 InputSchema: json.RawMessage(`{"type":"object","properties":{}}`), 1626 }, 1627 func(ctx context.Context, args json.RawMessage) (*mcp.ToolResult, error) { 1628 return &mcp.ToolResult{ 1629 Content: []mcp.ContentBlock{}, // Empty content 1630 }, nil 1631 }, 1632 ) 1633 1634 tc := provider.ToolCall{ 1635 ID: "call_1", 1636 Name: "empty_tool", 1637 Arguments: json.RawMessage(`{}`), 1638 } 1639 1640 result, err := mysis.executeToolCall(context.Background(), proxy, tc) 1641 1642 if err != nil { 1643 t.Errorf("expected no error, got %v", err) 1644 } 1645 if result == nil { 1646 t.Fatal("expected result, got nil") 1647 } 1648 // Should handle empty content gracefully 1649 if result.IsError { 1650 t.Error("empty content should not be an error") 1651 } 1652 }) 1653} 1654 1655// TestSendEphemeralMessage_IdleState removed - SendEphemeralMessage method removed. 1656// Ephemeral messages (synthetic nudges) are now generated by getContextMemories(). 1657 1658// TestSendEphemeralMessage_StoppedState removed - SendEphemeralMessage method removed. 1659// Ephemeral messages (synthetic nudges) are now generated by getContextMemories(). 1660 1661// setupTestMysis creates a mysis for testing with a mock provider 1662func setupTestMysis(t *testing.T) (*Mysis, func()) { 1663 t.Helper() 1664 1665 s, bus, cleanup := setupMysisTest(t) 1666 1667 stored, err := s.CreateMysis("test-mysis", "mock", "test-model", 0.7) 1668 if err != nil { 1669 t.Fatalf("CreateMysis() error: %v", err) 1670 } 1671 1672 mock := provider.NewMock("mock", "test response") 1673 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1674 1675 return mysis, cleanup 1676} 1677 1678// setupTestMysisWithErrorProvider creates a mysis with a provider that returns errors 1679func setupTestMysisWithErrorProvider(t *testing.T) (*Mysis, func()) { 1680 t.Helper() 1681 1682 s, bus, cleanup := setupMysisTest(t) 1683 1684 stored, err := s.CreateMysis("error-mysis", "mock", "test-model", 0.7) 1685 if err != nil { 1686 t.Fatalf("CreateMysis() error: %v", err) 1687 } 1688 1689 // Create a mock provider that returns errors 1690 mock := provider.NewMock("mock", "").WithChatError(errors.New("provider error")) 1691 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1692 1693 return mysis, cleanup 1694} 1695 1696func TestSendMessageFrom_IdleState(t *testing.T) { 1697 mysis, cleanup := setupTestMysis(t) 1698 defer cleanup() 1699 1700 // Mysis starts in idle state 1701 if mysis.State() != MysisStateIdle { 1702 t.Fatalf("expected idle state, got %s", mysis.State()) 1703 } 1704 1705 // Should be able to send message to idle mysis 1706 err := mysis.SendMessageFrom("test message", store.MemorySourceDirect, "") 1707 if err != nil { 1708 t.Errorf("should accept message in idle state, got error: %v", err) 1709 } 1710 1711 // Verify message was stored 1712 memories, err := mysis.store.GetMemories(mysis.ID()) 1713 if err != nil { 1714 t.Fatalf("failed to get memories: %v", err) 1715 } 1716 if len(memories) == 0 { 1717 t.Error("message was not stored") 1718 } 1719 if len(memories) == 0 { 1720 t.Error("message was not stored") 1721 } 1722} 1723 1724func TestSendMessageFrom_StoppedState(t *testing.T) { 1725 mysis, cleanup := setupTestMysis(t) 1726 defer cleanup() 1727 1728 // Start then stop the mysis 1729 if err := mysis.Start(); err != nil { 1730 t.Fatalf("failed to start mysis: %v", err) 1731 } 1732 if err := mysis.Stop(); err != nil { 1733 t.Fatalf("failed to stop mysis: %v", err) 1734 } 1735 1736 if mysis.State() != MysisStateStopped { 1737 t.Fatalf("expected stopped state, got %s", mysis.State()) 1738 } 1739 1740 // Should NOT be able to send message to stopped mysis 1741 err := mysis.SendMessageFrom("test message", store.MemorySourceDirect, "") 1742 if err == nil { 1743 t.Error("should reject message in stopped state") 1744 } 1745 if !strings.Contains(err.Error(), "stopped") || !strings.Contains(err.Error(), "relaunch") { 1746 t.Errorf("error should mention stopped and relaunch, got: %v", err) 1747 } 1748} 1749 1750func TestSendMessageFrom_ErroredState(t *testing.T) { 1751 mysis, cleanup := setupTestMysisWithErrorProvider(t) 1752 defer cleanup() 1753 1754 // Start mysis and trigger error 1755 if err := mysis.Start(); err != nil { 1756 t.Fatalf("failed to start mysis: %v", err) 1757 } 1758 1759 // Send message to trigger error 1760 _ = mysis.SendMessageFrom("trigger error", store.MemorySourceDirect, "") 1761 1762 // Wait for error state 1763 time.Sleep(100 * time.Millisecond) 1764 1765 if mysis.State() != MysisStateErrored { 1766 t.Fatalf("expected errored state, got %s", mysis.State()) 1767 } 1768 1769 // Should NOT be able to send message to errored mysis 1770 err := mysis.SendMessageFrom("test message", store.MemorySourceDirect, "") 1771 if err == nil { 1772 t.Error("should reject message in errored state") 1773 } 1774 if !strings.Contains(err.Error(), "errored") || !strings.Contains(err.Error(), "relaunch") { 1775 t.Errorf("error should mention errored and relaunch, got: %v", err) 1776 } 1777} 1778func TestQueueBroadcast_IdleState(t *testing.T) { 1779 s, bus, cleanup := setupMysisTest(t) 1780 defer cleanup() 1781 1782 // Create stored mysis 1783 stored, err := s.CreateMysis("test-mysis", "mock", "test-model", 0.7) 1784 if err != nil { 1785 t.Fatalf("CreateMysis() error: %v", err) 1786 } 1787 1788 mock := provider.NewMock("mock", "Hello!") 1789 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1790 1791 // Mysis starts in idle state 1792 if mysis.State() != MysisStateIdle { 1793 t.Fatalf("expected idle state, got %s", mysis.State()) 1794 } 1795 1796 // Should be able to queue broadcast to idle mysis 1797 err = mysis.QueueBroadcast("broadcast test", "sender-id") 1798 if err != nil { 1799 t.Errorf("should accept broadcast in idle state, got error: %v", err) 1800 } 1801 1802 // Verify message was stored 1803 memories, err := s.GetMemories(mysis.ID()) 1804 if err != nil { 1805 t.Fatalf("failed to get memories: %v", err) 1806 } 1807 if len(memories) == 0 { 1808 t.Error("broadcast was not stored") 1809 } 1810} 1811 1812func TestQueueBroadcast_StoppedState(t *testing.T) { 1813 s, bus, cleanup := setupMysisTest(t) 1814 defer cleanup() 1815 1816 // Create stored mysis 1817 stored, err := s.CreateMysis("test-mysis", "mock", "test-model", 0.7) 1818 if err != nil { 1819 t.Fatalf("CreateMysis() error: %v", err) 1820 } 1821 1822 mock := provider.NewMock("mock", "Hello!") 1823 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 1824 1825 // Start then stop 1826 if err := mysis.Start(); err != nil { 1827 t.Fatalf("failed to start: %v", err) 1828 } 1829 if err := mysis.Stop(); err != nil { 1830 t.Fatalf("failed to stop: %v", err) 1831 } 1832 1833 if mysis.State() != MysisStateStopped { 1834 t.Fatalf("expected stopped state, got %s", mysis.State()) 1835 } 1836 1837 // Should reject broadcast in stopped state 1838 err = mysis.QueueBroadcast("broadcast test", "sender-id") 1839 if err == nil { 1840 t.Error("should reject broadcast in stopped state") 1841 } 1842 if !strings.Contains(err.Error(), "stopped") { 1843 t.Errorf("error should mention stopped, got: %v", err) 1844 } 1845} 1846 1847func TestFindLastUserPromptIndex(t *testing.T) { 1848 tests := []struct { 1849 name string 1850 memories []*store.Memory 1851 expected int 1852 }{ 1853 { 1854 name: "last message is user", 1855 memories: []*store.Memory{ 1856 {Role: store.MemoryRoleSystem, Content: "system"}, 1857 {Role: store.MemoryRoleUser, Content: "hello", Source: store.MemorySourceDirect}, 1858 }, 1859 expected: 1, 1860 }, 1861 { 1862 name: "user followed by tool loop", 1863 memories: []*store.Memory{ 1864 {Role: store.MemoryRoleSystem, Content: "system"}, 1865 {Role: store.MemoryRoleUser, Content: "check status", Source: store.MemorySourceDirect}, 1866 {Role: store.MemoryRoleAssistant, Content: "[TOOL_CALLS]call_1:get_status:{}"}, 1867 {Role: store.MemoryRoleTool, Content: "call_1:status data"}, 1868 }, 1869 expected: 1, 1870 }, 1871 { 1872 name: "multiple user messages", 1873 memories: []*store.Memory{ 1874 {Role: store.MemoryRoleUser, Content: "first", Source: store.MemorySourceDirect}, 1875 {Role: store.MemoryRoleAssistant, Content: "response"}, 1876 {Role: store.MemoryRoleUser, Content: "second", Source: store.MemorySourceDirect}, 1877 }, 1878 expected: 2, 1879 }, 1880 { 1881 name: "no user messages", 1882 memories: []*store.Memory{ 1883 {Role: store.MemoryRoleSystem, Content: "system"}, 1884 }, 1885 expected: -1, 1886 }, 1887 { 1888 name: "broadcast is user prompt", 1889 memories: []*store.Memory{ 1890 {Role: store.MemoryRoleUser, Content: "broadcast msg", Source: store.MemorySourceBroadcast}, 1891 }, 1892 expected: 0, 1893 }, 1894 } 1895 1896 for _, tt := range tests { 1897 t.Run(tt.name, func(t *testing.T) { 1898 mysis := &Mysis{} 1899 result := mysis.findLastUserPromptIndex(tt.memories) 1900 if result != tt.expected { 1901 t.Errorf("expected %d, got %d", tt.expected, result) 1902 } 1903 }) 1904 } 1905} 1906 1907func TestGetContextMemories_CurrentTurnPreserved(t *testing.T) { 1908 mysis, cleanup := setupTestMysis(t) 1909 defer cleanup() 1910 1911 // Add historical turn (should be compressed) 1912 err := mysis.store.AddMemory(mysis.id, store.MemoryRoleUser, store.MemorySourceDirect, "old user msg", "", "") 1913 if err != nil { 1914 t.Fatalf("AddMemory error: %v", err) 1915 } 1916 err = mysis.store.AddMemory(mysis.id, store.MemoryRoleAssistant, store.MemorySourceLLM, "[TOOL_CALLS]call_old:get_status:{}", "", "") 1917 if err != nil { 1918 t.Fatalf("AddMemory error: %v", err) 1919 } 1920 err = mysis.store.AddMemory(mysis.id, store.MemoryRoleTool, store.MemorySourceTool, "call_old:old status", "", "") 1921 if err != nil { 1922 t.Fatalf("AddMemory error: %v", err) 1923 } 1924 1925 // Add current turn with multiple tool loops 1926 err = mysis.store.AddMemory(mysis.id, store.MemoryRoleUser, store.MemorySourceDirect, "current user msg", "", "") 1927 if err != nil { 1928 t.Fatalf("AddMemory error: %v", err) 1929 } 1930 // First tool loop in current turn 1931 err = mysis.store.AddMemory(mysis.id, store.MemoryRoleAssistant, store.MemorySourceLLM, "[TOOL_CALLS]call_1:login:{}", "", "") 1932 if err != nil { 1933 t.Fatalf("AddMemory error: %v", err) 1934 } 1935 err = mysis.store.AddMemory(mysis.id, store.MemoryRoleTool, store.MemorySourceTool, "call_1:login successful", "", "") 1936 if err != nil { 1937 t.Fatalf("AddMemory error: %v", err) 1938 } 1939 // Second tool loop in current turn 1940 err = mysis.store.AddMemory(mysis.id, store.MemoryRoleAssistant, store.MemorySourceLLM, "[TOOL_CALLS]call_2:get_status:{}", "", "") 1941 if err != nil { 1942 t.Fatalf("AddMemory error: %v", err) 1943 } 1944 err = mysis.store.AddMemory(mysis.id, store.MemoryRoleTool, store.MemorySourceTool, "call_2:status data", "", "") 1945 if err != nil { 1946 t.Fatalf("AddMemory error: %v", err) 1947 } 1948 1949 memories, _, err := mysis.getContextMemories() 1950 if err != nil { 1951 t.Fatalf("getContextMemories error: %v", err) 1952 } 1953 1954 // Verify structure: current turn should have both tool loops 1955 hasCurrentUser := false 1956 hasLoginCall := false 1957 hasLoginResult := false 1958 hasStatusCall := false 1959 hasStatusResult := false 1960 1961 for _, mem := range memories { 1962 if mem.Role == store.MemoryRoleUser && mem.Content == "current user msg" { 1963 hasCurrentUser = true 1964 } 1965 if mem.Role == store.MemoryRoleAssistant && strings.Contains(mem.Content, "call_1:login") { 1966 hasLoginCall = true 1967 } 1968 if mem.Role == store.MemoryRoleTool && strings.Contains(mem.Content, "call_1") && strings.Contains(mem.Content, "login") { 1969 hasLoginResult = true 1970 } 1971 if mem.Role == store.MemoryRoleAssistant && strings.Contains(mem.Content, "call_2:get_status") { 1972 hasStatusCall = true 1973 } 1974 if mem.Role == store.MemoryRoleTool && strings.Contains(mem.Content, "call_2") { 1975 hasStatusResult = true 1976 } 1977 } 1978 1979 if !hasCurrentUser { 1980 t.Error("Missing current user message") 1981 } 1982 if !hasLoginCall { 1983 t.Error("Missing login tool call from current turn") 1984 } 1985 if !hasLoginResult { 1986 t.Error("Missing login result from current turn - THIS IS THE KEY FIX") 1987 } 1988 if !hasStatusCall { 1989 t.Error("Missing status tool call from current turn") 1990 } 1991 if !hasStatusResult { 1992 t.Error("Missing status result from current turn") 1993 } 1994} 1995 1996func TestGetContextMemories_NoUserPrompt(t *testing.T) { 1997 s, bus, cleanup := setupMysisTest(t) 1998 defer cleanup() 1999 2000 stored, _ := s.CreateMysis("no-prompt-test", "mock", "test-model", 0.7) 2001 mock := provider.NewMock("mock", "response") 2002 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 2003 2004 // Add only system and assistant messages (no user prompt) 2005 err := s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "", "") 2006 if err != nil { 2007 t.Fatalf("AddMemory error: %v", err) 2008 } 2009 err = s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "assistant msg", "", "") 2010 if err != nil { 2011 t.Fatalf("AddMemory error: %v", err) 2012 } 2013 2014 memories, _, err := mysis.getContextMemories() 2015 if err != nil { 2016 t.Fatalf("getContextMemories error: %v", err) 2017 } 2018 2019 // Should generate synthetic encouragement when no user prompt exists 2020 hasEncouragement := false 2021 for _, mem := range memories { 2022 if mem.Role == store.MemoryRoleUser && mem.Source == store.MemorySourceSystem { 2023 hasEncouragement = true 2024 break 2025 } 2026 } 2027 2028 if !hasEncouragement { 2029 t.Error("Expected synthetic encouragement when no user prompt exists") 2030 } 2031} 2032 2033func TestGetContextMemories_OnlyHistoricalTurns(t *testing.T) { 2034 s, bus, cleanup := setupMysisTest(t) 2035 defer cleanup() 2036 2037 stored, _ := s.CreateMysis("historical-test", "mock", "test-model", 0.7) 2038 mock := provider.NewMock("mock", "response") 2039 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 2040 2041 // Add system prompt 2042 err := s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "", "") 2043 if err != nil { 2044 t.Fatalf("AddMemory error: %v", err) 2045 } 2046 2047 // Add complete historical turn 2048 err = s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "old msg", "", "") 2049 if err != nil { 2050 t.Fatalf("AddMemory error: %v", err) 2051 } 2052 err = s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "old response", "", "") 2053 if err != nil { 2054 t.Fatalf("AddMemory error: %v", err) 2055 } 2056 2057 memories, _, err := mysis.getContextMemories() 2058 if err != nil { 2059 t.Fatalf("getContextMemories error: %v", err) 2060 } 2061 2062 // Should include system + historical context (user+assistant from last turn) 2063 if len(memories) < 2 { 2064 t.Fatalf("Expected at least 2 memories (system + historical), got %d", len(memories)) 2065 } 2066 2067 if memories[0].Role != store.MemoryRoleSystem { 2068 t.Error("First memory should be system") 2069 } 2070 2071 // Last user message should be included as current turn 2072 hasOldUser := false 2073 for _, mem := range memories { 2074 if mem.Content == "old msg" { 2075 hasOldUser = true 2076 } 2077 } 2078 2079 if !hasOldUser { 2080 t.Error("Expected historical user message to be included as current turn") 2081 } 2082} 2083 2084// TestMysisName verifies the Name getter returns the mysis name. 2085func TestMysisName(t *testing.T) { 2086 s, bus, cleanup := setupMysisTest(t) 2087 defer cleanup() 2088 2089 mock := provider.NewMock("mock", "response") 2090 2091 expectedName := "test-mysis-name" 2092 stored, err := s.CreateMysis(expectedName, "mock", "mock-model", 0.7) 2093 if err != nil { 2094 t.Fatalf("CreateMysis() error: %v", err) 2095 } 2096 2097 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 2098 2099 if got := mysis.Name(); got != expectedName { 2100 t.Errorf("Name() = %q, want %q", got, expectedName) 2101 } 2102} 2103 2104// TestMysisCreatedAt verifies the CreatedAt getter returns the creation timestamp. 2105func TestMysisCreatedAt(t *testing.T) { 2106 s, bus, cleanup := setupMysisTest(t) 2107 defer cleanup() 2108 2109 mock := provider.NewMock("mock", "response") 2110 2111 beforeCreate := time.Now().Add(-time.Second) 2112 stored, err := s.CreateMysis("test-mysis-time", "mock", "mock-model", 0.7) 2113 if err != nil { 2114 t.Fatalf("CreateMysis() error: %v", err) 2115 } 2116 afterCreate := time.Now().Add(time.Second) 2117 2118 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 2119 2120 got := mysis.CreatedAt() 2121 if got.Before(beforeCreate) || got.After(afterCreate) { 2122 t.Errorf("CreatedAt() = %v, want between %v and %v", got, beforeCreate, afterCreate) 2123 } 2124} 2125 2126// TestBuildSystemPrompt_EdgeCases tests buildSystemPrompt error handling 2127func TestBuildSystemPrompt_EdgeCases(t *testing.T) { 2128 t.Run("no_broadcasts_fallback", func(t *testing.T) { 2129 s, bus, cleanup := setupMysisTest(t) 2130 defer cleanup() 2131 2132 stored, _ := s.CreateMysis("no-broadcasts", "mock", "test-model", 0.7) 2133 mock := provider.NewMock("mock", "response") 2134 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 2135 2136 // Build system prompt with no broadcasts 2137 prompt := mysis.buildSystemPrompt() 2138 2139 // Should contain fallback message 2140 if !strings.Contains(prompt, "Continue to play the game") { 2141 t.Error("expected fallback message when no broadcasts") 2142 } 2143 if !strings.Contains(prompt, "SWARM BROADCAST") { 2144 t.Error("expected SWARM BROADCAST header in fallback") 2145 } 2146 // Should still contain base SystemPrompt content 2147 if !strings.Contains(prompt, "Nova Zoea") { 2148 t.Error("expected base system prompt content") 2149 } 2150 }) 2151 2152 t.Run("commander_broadcast", func(t *testing.T) { 2153 s, bus, cleanup := setupMysisTest(t) 2154 defer cleanup() 2155 2156 stored, _ := s.CreateMysis("receiver-mysis", "mock", "test-model", 0.7) 2157 mock := provider.NewMock("mock", "response") 2158 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 2159 2160 // Add a commander broadcast (empty sender_id) 2161 s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceBroadcast, "Attack coordinates: X=100, Y=200", "", "") 2162 2163 prompt := mysis.buildSystemPrompt() 2164 2165 // Should include broadcast content 2166 if !strings.Contains(prompt, "Attack coordinates") { 2167 t.Error("expected broadcast content in prompt") 2168 } 2169 // Should have SWARM BROADCAST header 2170 if !strings.Contains(prompt, "SWARM BROADCAST") { 2171 t.Error("expected SWARM BROADCAST header") 2172 } 2173 // Should NOT include sender name (commander broadcasts don't show sender) 2174 if strings.Contains(prompt, "From:") { 2175 t.Error("commander broadcasts should not show 'From:' field") 2176 } 2177 }) 2178 2179 t.Run("mysis_broadcast_ignored", func(t *testing.T) { 2180 s, bus, cleanup := setupMysisTest(t) 2181 defer cleanup() 2182 2183 sender, _ := s.CreateMysis("sender-mysis-2", "mock", "test-model", 0.7) 2184 receiver, _ := s.CreateMysis("receiver-mysis-2", "mock", "test-model", 0.7) 2185 2186 mock := provider.NewMock("mock", "response") 2187 receiverMysis := NewMysis(receiver.ID, receiver.Name, receiver.CreatedAt, mock, s, bus, "") 2188 2189 // Add a commander broadcast first 2190 s.AddMemory(receiver.ID, store.MemoryRoleUser, store.MemorySourceBroadcast, "Commander orders", "", "") 2191 // Add a broadcast from another mysis (has sender_id) - should be ignored 2192 s.AddMemory(receiver.ID, store.MemoryRoleUser, store.MemorySourceBroadcast, "Mysis broadcast", "", sender.ID) 2193 2194 prompt := receiverMysis.buildSystemPrompt() 2195 2196 // Should show commander broadcast, not mysis broadcast 2197 if !strings.Contains(prompt, "Commander orders") { 2198 t.Error("expected commander broadcast to be shown") 2199 } 2200 // Should NOT include mysis broadcast content 2201 if strings.Contains(prompt, "Mysis broadcast") { 2202 t.Error("mysis broadcasts should be ignored in system prompt") 2203 } 2204 }) 2205} 2206 2207// TestSendEphemeralMessage_ErroredState removed - SendEphemeralMessage method removed. 2208// Ephemeral messages (synthetic nudges) are now generated by getContextMemories(). 2209 2210// TestSendEphemeralMessage_EmptyContent removed - SendEphemeralMessage method removed. 2211// Ephemeral messages (synthetic nudges) are now generated by getContextMemories(). 2212 2213// TestSendEphemeralMessage_MCPListToolsError removed - SendEphemeralMessage method removed. 2214// Ephemeral messages (synthetic nudges) are now generated by getContextMemories(). 2215 2216// TestIdleRecoveryOnBroadcast tests the Idle Recovery scenario from MESSAGE_FORMAT_GUARANTEES.md. 2217// 2218// Scenario: 2219// 1. Mysis has gone idle after 3 encouragements (no user messages) 2220// 2. Commander sends broadcast "Mine iron ore" via QueueBroadcast 2221// 3. Broadcast triggers auto-start (QueueBroadcast calls Start() on idle mysis) 2222// 4. Counter resets to 0 2223// 5. Mysis processes the broadcast and stays active 2224// 2225// Reference: documentation/architecture/MESSAGE_FORMAT_GUARANTEES.md lines 148-163 2226func TestIdleRecoveryOnBroadcast(t *testing.T) { 2227 s, bus, cleanup := setupMysisTest(t) 2228 defer cleanup() 2229 2230 // Step 1: Create mysis and store 2231 stored, err := s.CreateMysis("idle-recovery-test", "mock", "test-model", 0.7) 2232 if err != nil { 2233 t.Fatalf("CreateMysis() error: %v", err) 2234 } 2235 2236 // Use mock provider with no delay for fast test 2237 mock := provider.NewMock("mock", "Working on mining iron ore") 2238 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 2239 2240 // Step 2: Simulate idle state (mysis has already gone idle after 3 encouragements) 2241 // Set encouragementCount to 3 and transition to idle state 2242 mysis.mu.Lock() 2243 mysis.encouragementCount = 3 2244 mysis.state = MysisStateIdle 2245 mysis.mu.Unlock() 2246 2247 // Update state in store 2248 if err := s.UpdateMysisState(stored.ID, store.MysisStateIdle); err != nil { 2249 t.Fatalf("UpdateMysisState() error: %v", err) 2250 } 2251 2252 // Verify mysis is in idle state 2253 if mysis.State() != MysisStateIdle { 2254 t.Fatalf("expected state=idle, got %s", mysis.State()) 2255 } 2256 2257 // Verify encouragementCount is 3 2258 mysis.mu.RLock() 2259 count := mysis.encouragementCount 2260 mysis.mu.RUnlock() 2261 if count != 3 { 2262 t.Fatalf("expected encouragementCount=3, got %d", count) 2263 } 2264 2265 // Subscribe to events to track state changes 2266 events := bus.Subscribe() 2267 2268 // Step 3: Send broadcast "Mine iron ore" via QueueBroadcast 2269 senderID := "commander-mysis-id" 2270 err = mysis.QueueBroadcast("Mine iron ore", senderID) 2271 if err != nil { 2272 t.Fatalf("QueueBroadcast() error: %v", err) 2273 } 2274 2275 // Step 4: Verify mysis auto-starts (state = running) 2276 // QueueBroadcast should have called Start() since mysis was idle 2277 autoStartTimeout := time.After(2 * time.Second) 2278 autoStarted := false 2279 2280waitForAutoStart: 2281 for { 2282 select { 2283 case e := <-events: 2284 if e.Type == EventMysisStateChanged { 2285 if e.State != nil && e.State.NewState == MysisStateRunning { 2286 autoStarted = true 2287 break waitForAutoStart 2288 } 2289 } 2290 case <-autoStartTimeout: 2291 // Check if we're already running (event may have been consumed earlier) 2292 if mysis.State() == MysisStateRunning { 2293 autoStarted = true 2294 break waitForAutoStart 2295 } 2296 t.Fatalf("timeout waiting for mysis to auto-start on broadcast (current state: %s)", mysis.State()) 2297 } 2298 } 2299 2300 if !autoStarted { 2301 t.Error("mysis did not auto-start on broadcast") 2302 } 2303 2304 if mysis.State() != MysisStateRunning { 2305 t.Errorf("expected state=running after broadcast auto-start, got %s", mysis.State()) 2306 } 2307 2308 // Step 5: Verify encouragementCount reset to 0 2309 mysis.mu.RLock() 2310 count = mysis.encouragementCount 2311 mysis.mu.RUnlock() 2312 if count != 0 { 2313 t.Errorf("expected encouragementCount=0 after broadcast, got %d", count) 2314 } 2315 2316 // Step 6: Wait for LLM response 2317 // Mysis should process the broadcast and generate a response 2318 responseTimeout := time.After(2 * time.Second) 2319 gotResponse := false 2320 2321waitForResponse: 2322 for { 2323 select { 2324 case e := <-events: 2325 if e.Type == EventMysisResponse { 2326 if e.Message != nil { 2327 gotResponse = true 2328 break waitForResponse 2329 } 2330 } 2331 case <-responseTimeout: 2332 // Not fatal - response may have already been processed 2333 break waitForResponse 2334 } 2335 } 2336 2337 if !gotResponse { 2338 t.Log("Warning: Did not receive expected LLM response event (may have been processed quickly)") 2339 } 2340 2341 // Step 7: Verify mysis is running (not idle again) 2342 if mysis.State() != MysisStateRunning { 2343 t.Errorf("expected state=running after processing broadcast, got %s", mysis.State()) 2344 } 2345 2346 // Verify broadcast was stored in database 2347 memories, err := s.GetMemories(stored.ID) 2348 if err != nil { 2349 t.Fatalf("GetMemories() error: %v", err) 2350 } 2351 2352 foundBroadcast := false 2353 for _, m := range memories { 2354 if m.Source == store.MemorySourceBroadcast && m.Content == "Mine iron ore" && m.SenderID == senderID { 2355 foundBroadcast = true 2356 break 2357 } 2358 } 2359 2360 if !foundBroadcast { 2361 t.Error("broadcast message was not stored in database") 2362 } 2363 2364 // Step 8: Stop mysis 2365 if err := mysis.Stop(); err != nil { 2366 t.Fatalf("Stop() error: %v", err) 2367 } 2368 2369 if mysis.State() != MysisStateStopped { 2370 t.Errorf("expected state=stopped after Stop(), got %s", mysis.State()) 2371 } 2372} 2373 2374// TestBroadcastSlidingWindowBug tests that broadcasts outside the 20-message 2375// sliding window still keep myses running (don't trigger idle state). 2376// 2377// Bug: When a mysis processes a broadcast and generates 20+ messages, 2378// the original broadcast is pushed out of the GetRecentMemories(20) window. 2379// This causes findLastUserPromptIndex to return -1, triggering synthetic 2380// encouragements and eventual idle state. 2381// 2382// Expected: Mysis should stay running because broadcast exists in DB. 2383// Reference: MESSAGE_FORMAT_GUARANTEES.md line 44 2384func TestBroadcastSlidingWindowBug(t *testing.T) { 2385 s, bus, cleanup := setupMysisTest(t) 2386 defer cleanup() 2387 2388 // Create mysis 2389 stored, err := s.CreateMysis("window-test", "mock", "test-model", 0.7) 2390 if err != nil { 2391 t.Fatalf("CreateMysis() error: %v", err) 2392 } 2393 2394 // Send broadcast (message #1) 2395 err = s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceBroadcast, "Explore the universe!", "", "commander-id") 2396 if err != nil { 2397 t.Fatalf("AddMemory(broadcast) error: %v", err) 2398 } 2399 2400 // Simulate 25 messages (push broadcast out of 20-message window) 2401 // Pattern: assistant response + tool call + tool result (repeated) 2402 for i := 0; i < 8; i++ { 2403 // Assistant response 2404 err = s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, fmt.Sprintf("Response %d", i), "", "") 2405 if err != nil { 2406 t.Fatalf("AddMemory(assistant) error: %v", err) 2407 } 2408 2409 // Tool call (stored as assistant message with tool call prefix) 2410 toolCall := fmt.Sprintf("[TOOL_CALLS]call_%d:get_status:{}", i) 2411 err = s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, toolCall, "", "") 2412 if err != nil { 2413 t.Fatalf("AddMemory(tool call) error: %v", err) 2414 } 2415 2416 // Tool result 2417 toolResult := fmt.Sprintf("call_%d:Status OK", i) 2418 err = s.AddMemory(stored.ID, store.MemoryRoleTool, store.MemorySourceTool, toolResult, "", "") 2419 if err != nil { 2420 t.Fatalf("AddMemory(tool result) error: %v", err) 2421 } 2422 } 2423 2424 // Verify we have 25 messages total (1 broadcast + 24 from loop) 2425 allMemories, err := s.GetMemories(stored.ID) 2426 if err != nil { 2427 t.Fatalf("GetMemories() error: %v", err) 2428 } 2429 if len(allMemories) != 25 { 2430 t.Fatalf("expected 25 messages, got %d", len(allMemories)) 2431 } 2432 2433 // Verify broadcast is message #1 (oldest) 2434 if allMemories[0].Source != store.MemorySourceBroadcast { 2435 t.Fatalf("expected first message to be broadcast, got source=%s", allMemories[0].Source) 2436 } 2437 2438 // Create mysis instance 2439 mock := provider.NewMock("mock", "Continuing mission...") 2440 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus, "") 2441 2442 // Call getContextMemories - this should find the broadcast even though 2443 // it's outside the 20-message sliding window 2444 memories, _, err := mysis.getContextMemories() 2445 if err != nil { 2446 t.Fatalf("getContextMemories() error: %v", err) 2447 } 2448 2449 // Check if broadcast is in context 2450 foundBroadcast := false 2451 foundCorrectBroadcast := false 2452 for _, m := range memories { 2453 if m.Source == store.MemorySourceBroadcast { 2454 foundBroadcast = true 2455 if m.Content == "Explore the universe!" { 2456 foundCorrectBroadcast = true 2457 } 2458 break 2459 } 2460 } 2461 2462 if !foundBroadcast { 2463 t.Error("REGRESSION: broadcast not in context despite existing in DB - mysis will incorrectly go idle") 2464 } 2465 2466 if !foundCorrectBroadcast { 2467 t.Error("Wrong broadcast in context - expected 'Explore the universe!'") 2468 } 2469 2470 // Verify encouragementCount is 0 (not incremented) 2471 mysis.mu.RLock() 2472 count := mysis.encouragementCount 2473 mysis.mu.RUnlock() 2474 2475 if count != 0 { 2476 t.Errorf("expected encouragementCount=0 when broadcast exists, got %d", count) 2477 } 2478 2479 // Verify no synthetic encouragement was added 2480 foundSynthetic := false 2481 for _, m := range memories { 2482 if m.Role == store.MemoryRoleUser && m.Source == store.MemorySourceSystem { 2483 if strings.Contains(m.Content, "Continue your mission") { 2484 foundSynthetic = true 2485 break 2486 } 2487 } 2488 } 2489 2490 if foundSynthetic { 2491 t.Error("synthetic encouragement added despite broadcast existing - will cause incorrect idle state") 2492 } 2493} 2494 2495// TestNewMysisInheritsGlobalBroadcast tests that a new mysis created after 2496// a broadcast was sent inherits the global swarm mission. 2497// 2498// Bug: New myses created after broadcasts have no broadcast in their memories. 2499// GetMostRecentBroadcast(mysisID) returns nil, causing idle state. 2500// 2501// Expected: New mysis should inherit most recent global broadcast. 2502// Reference: Issue reported by user - "new mysis went idle despite commander broadcast" 2503func TestNewMysisInheritsGlobalBroadcast(t *testing.T) { 2504 s, bus, cleanup := setupMysisTest(t) 2505 defer cleanup() 2506 2507 // Step 1: Create first mysis and send it a broadcast 2508 mysis1, err := s.CreateMysis("existing-mysis", "mock", "test-model", 0.7) 2509 if err != nil { 2510 t.Fatalf("CreateMysis(1) error: %v", err) 2511 } 2512 2513 // Send broadcast to first mysis (simulates commander broadcast) 2514 err = s.AddMemory(mysis1.ID, store.MemoryRoleUser, store.MemorySourceBroadcast, "Explore the universe!", "", "commander-id") 2515 if err != nil { 2516 t.Fatalf("AddMemory(broadcast) error: %v", err) 2517 } 2518 2519 // Step 2: Create second mysis AFTER the broadcast (simulates new mysis joining swarm) 2520 mysis2, err := s.CreateMysis("new-mysis", "mock", "test-model", 0.7) 2521 if err != nil { 2522 t.Fatalf("CreateMysis(2) error: %v", err) 2523 } 2524 2525 // Verify new mysis has no broadcasts in its own memories 2526 mysis2Memories, err := s.GetMemories(mysis2.ID) 2527 if err != nil { 2528 t.Fatalf("GetMemories(mysis2) error: %v", err) 2529 } 2530 2531 hasBroadcast := false 2532 for _, m := range mysis2Memories { 2533 if m.Source == store.MemorySourceBroadcast { 2534 hasBroadcast = true 2535 break 2536 } 2537 } 2538 2539 if hasBroadcast { 2540 t.Fatal("Test setup error: new mysis should not have broadcast in its own memories") 2541 } 2542 2543 // Step 3: Create mysis instance and call getContextMemories 2544 mock := provider.NewMock("mock", "Continuing mission...") 2545 mysisInstance := NewMysis(mysis2.ID, mysis2.Name, mysis2.CreatedAt, mock, s, bus, "") 2546 2547 memories, _, err := mysisInstance.getContextMemories() 2548 if err != nil { 2549 t.Fatalf("getContextMemories() error: %v", err) 2550 } 2551 2552 // Step 4: Verify the global broadcast was inherited 2553 foundGlobalBroadcast := false 2554 for _, m := range memories { 2555 if m.Source == store.MemorySourceBroadcast && m.Content == "Explore the universe!" { 2556 foundGlobalBroadcast = true 2557 break 2558 } 2559 } 2560 2561 if !foundGlobalBroadcast { 2562 t.Error("REGRESSION: new mysis did not inherit global broadcast - will incorrectly go idle") 2563 } 2564 2565 // Step 5: Verify encouragementCount is 0 (not incremented) 2566 mysisInstance.mu.RLock() 2567 count := mysisInstance.encouragementCount 2568 mysisInstance.mu.RUnlock() 2569 2570 if count != 0 { 2571 t.Errorf("expected encouragementCount=0 when global broadcast inherited, got %d", count) 2572 } 2573 2574 // Step 6: Verify no synthetic encouragement was added 2575 foundSynthetic := false 2576 for _, m := range memories { 2577 if m.Role == store.MemoryRoleUser && m.Source == store.MemorySourceSystem { 2578 if strings.Contains(m.Content, "Continue your mission") { 2579 foundSynthetic = true 2580 break 2581 } 2582 } 2583 } 2584 2585 if foundSynthetic { 2586 t.Error("synthetic encouragement added despite global broadcast existing") 2587 } 2588} 2589 2590// TestGetContextMemories_WithCompression verifies that getContextMemories() 2591// applies both compactSnapshots() and removeOrphanedToolCalls() to ensure: 2592// 1. Duplicate snapshot tool results are removed (only latest kept) 2593// 2. Orphaned assistant tool calls without matching results are removed 2594func TestGetContextMemories_WithCompression(t *testing.T) { 2595 mysis, cleanup := setupTestMysis(t) 2596 defer cleanup() 2597 2598 // Add current turn with duplicate snapshots and orphaned tool calls 2599 // User prompt 2600 err := mysis.store.AddMemory(mysis.id, store.MemoryRoleUser, store.MemorySourceDirect, "Check game status", "", "") 2601 if err != nil { 2602 t.Fatalf("AddMemory error: %v", err) 2603 } 2604 2605 // First get_status call (will be compacted - duplicate) 2606 err = mysis.store.AddMemory(mysis.id, store.MemoryRoleAssistant, store.MemorySourceLLM, "[TOOL_CALLS]call_status_1:get_status:{}", "", "") 2607 if err != nil { 2608 t.Fatalf("AddMemory error: %v", err) 2609 } 2610 err = mysis.store.AddMemory(mysis.id, store.MemoryRoleTool, store.MemorySourceTool, "call_status_1:old status data", "", "") 2611 if err != nil { 2612 t.Fatalf("AddMemory error: %v", err) 2613 } 2614 2615 // First get_system call (will be compacted - duplicate) 2616 err = mysis.store.AddMemory(mysis.id, store.MemoryRoleAssistant, store.MemorySourceLLM, "[TOOL_CALLS]call_system_1:get_system:{}", "", "") 2617 if err != nil { 2618 t.Fatalf("AddMemory error: %v", err) 2619 } 2620 err = mysis.store.AddMemory(mysis.id, store.MemoryRoleTool, store.MemorySourceTool, "call_system_1:old system data", "", "") 2621 if err != nil { 2622 t.Fatalf("AddMemory error: %v", err) 2623 } 2624 2625 // Second get_status call (latest - will be kept) 2626 err = mysis.store.AddMemory(mysis.id, store.MemoryRoleAssistant, store.MemorySourceLLM, "[TOOL_CALLS]call_status_2:get_status:{}", "", "") 2627 if err != nil { 2628 t.Fatalf("AddMemory error: %v", err) 2629 } 2630 err = mysis.store.AddMemory(mysis.id, store.MemoryRoleTool, store.MemorySourceTool, "call_status_2:latest status data", "", "") 2631 if err != nil { 2632 t.Fatalf("AddMemory error: %v", err) 2633 } 2634 2635 // Second get_system call (latest - will be kept) 2636 err = mysis.store.AddMemory(mysis.id, store.MemoryRoleAssistant, store.MemorySourceLLM, "[TOOL_CALLS]call_system_2:get_system:{}", "", "") 2637 if err != nil { 2638 t.Fatalf("AddMemory error: %v", err) 2639 } 2640 err = mysis.store.AddMemory(mysis.id, store.MemoryRoleTool, store.MemorySourceTool, "call_system_2:latest system data", "", "") 2641 if err != nil { 2642 t.Fatalf("AddMemory error: %v", err) 2643 } 2644 2645 // Orphaned tool call (no matching tool result - will be removed) 2646 err = mysis.store.AddMemory(mysis.id, store.MemoryRoleAssistant, store.MemorySourceLLM, "[TOOL_CALLS]call_orphan:get_notifications:{}", "", "") 2647 if err != nil { 2648 t.Fatalf("AddMemory error: %v", err) 2649 } 2650 2651 memories, _, err := mysis.getContextMemories() 2652 if err != nil { 2653 t.Fatalf("getContextMemories error: %v", err) 2654 } 2655 2656 // Verify compression applied: only latest snapshots present 2657 statusCount := 0 2658 systemCount := 0 2659 hasLatestStatus := false 2660 hasLatestSystem := false 2661 hasOrphanedCall := false 2662 2663 for _, mem := range memories { 2664 if mem.Role == store.MemoryRoleTool { 2665 if strings.Contains(mem.Content, "call_status_1") { 2666 t.Error("Found old get_status result - compactSnapshots() not applied") 2667 } 2668 if strings.Contains(mem.Content, "call_system_1") { 2669 t.Error("Found old get_system result - compactSnapshots() not applied") 2670 } 2671 if strings.Contains(mem.Content, "call_status_2") && strings.Contains(mem.Content, "latest status") { 2672 statusCount++ 2673 hasLatestStatus = true 2674 } 2675 if strings.Contains(mem.Content, "call_system_2") && strings.Contains(mem.Content, "latest system") { 2676 systemCount++ 2677 hasLatestSystem = true 2678 } 2679 } 2680 if mem.Role == store.MemoryRoleAssistant && strings.Contains(mem.Content, "call_orphan") { 2681 hasOrphanedCall = true 2682 } 2683 } 2684 2685 if !hasLatestStatus { 2686 t.Error("Missing latest get_status snapshot") 2687 } 2688 if !hasLatestSystem { 2689 t.Error("Missing latest get_system snapshot") 2690 } 2691 if statusCount != 1 { 2692 t.Errorf("Expected exactly 1 get_status result, got %d", statusCount) 2693 } 2694 if systemCount != 1 { 2695 t.Errorf("Expected exactly 1 get_system result, got %d", systemCount) 2696 } 2697 if hasOrphanedCall { 2698 t.Error("Found orphaned tool call - removeOrphanedToolCalls() not applied") 2699 } 2700} 2701 2702// TestCompactSnapshots_MultipleSnapshots verifies that compactSnapshots() 2703// correctly removes duplicate snapshot tool results, keeping only the latest 2704// for each tool type while preserving order and non-snapshot tools. 2705func TestCompactSnapshots_MultipleSnapshots(t *testing.T) { 2706 mysis, cleanup := setupTestMysis(t) 2707 defer cleanup() 2708 2709 // Create test memories with multiple snapshots 2710 memories := []*store.Memory{ 2711 {Role: store.MemoryRoleUser, Content: "user message", Source: store.MemorySourceDirect}, 2712 // First get_status (old - should be removed) 2713 {Role: store.MemoryRoleAssistant, Content: "[TOOL_CALLS]call_status_1:get_status:{}", Source: store.MemorySourceLLM}, 2714 {Role: store.MemoryRoleTool, Content: "call_status_1:old status", Source: store.MemorySourceTool}, 2715 // Non-snapshot tool (should be kept) 2716 {Role: store.MemoryRoleAssistant, Content: "[TOOL_CALLS]call_action:send_message:{\"text\":\"hello\"}", Source: store.MemorySourceLLM}, 2717 {Role: store.MemoryRoleTool, Content: "call_action:message sent", Source: store.MemorySourceTool}, 2718 // Second get_status (latest - should be kept) 2719 {Role: store.MemoryRoleAssistant, Content: "[TOOL_CALLS]call_status_2:get_status:{}", Source: store.MemorySourceLLM}, 2720 {Role: store.MemoryRoleTool, Content: "call_status_2:latest status", Source: store.MemorySourceTool}, 2721 // First get_system (old - should be removed) 2722 {Role: store.MemoryRoleAssistant, Content: "[TOOL_CALLS]call_system_1:get_system:{}", Source: store.MemorySourceLLM}, 2723 {Role: store.MemoryRoleTool, Content: "call_system_1:old system", Source: store.MemorySourceTool}, 2724 // Third get_status (latest - should be kept) 2725 {Role: store.MemoryRoleAssistant, Content: "[TOOL_CALLS]call_status_3:get_status:{}", Source: store.MemorySourceLLM}, 2726 {Role: store.MemoryRoleTool, Content: "call_status_3:newest status", Source: store.MemorySourceTool}, 2727 // Second get_system (latest - should be kept) 2728 {Role: store.MemoryRoleAssistant, Content: "[TOOL_CALLS]call_system_2:get_system:{}", Source: store.MemorySourceLLM}, 2729 {Role: store.MemoryRoleTool, Content: "call_system_2:latest system", Source: store.MemorySourceTool}, 2730 {Role: store.MemoryRoleAssistant, Content: "Based on the data...", Source: store.MemorySourceLLM}, 2731 } 2732 2733 result := mysis.compactSnapshots(memories) 2734 2735 // Count snapshots and verify correct ones kept 2736 statusCount := 0 2737 systemCount := 0 2738 nonSnapshotCount := 0 2739 hasNewestStatus := false 2740 hasLatestSystem := false 2741 hasOldStatus := false 2742 hasOldSystem := false 2743 2744 for _, mem := range result { 2745 if mem.Role == store.MemoryRoleTool { 2746 if strings.Contains(mem.Content, "call_status_1") { 2747 hasOldStatus = true 2748 } 2749 if strings.Contains(mem.Content, "call_status_2") { 2750 hasOldStatus = true 2751 } 2752 if strings.Contains(mem.Content, "call_status_3") && strings.Contains(mem.Content, "newest") { 2753 statusCount++ 2754 hasNewestStatus = true 2755 } 2756 if strings.Contains(mem.Content, "call_system_1") { 2757 hasOldSystem = true 2758 } 2759 if strings.Contains(mem.Content, "call_system_2") && strings.Contains(mem.Content, "latest") { 2760 systemCount++ 2761 hasLatestSystem = true 2762 } 2763 if strings.Contains(mem.Content, "call_action") && strings.Contains(mem.Content, "message sent") { 2764 nonSnapshotCount++ 2765 } 2766 } 2767 } 2768 2769 if hasOldStatus { 2770 t.Error("Found old get_status results - should be compacted") 2771 } 2772 if hasOldSystem { 2773 t.Error("Found old get_system results - should be compacted") 2774 } 2775 if !hasNewestStatus { 2776 t.Error("Missing newest get_status snapshot") 2777 } 2778 if !hasLatestSystem { 2779 t.Error("Missing latest get_system snapshot") 2780 } 2781 if statusCount != 1 { 2782 t.Errorf("Expected exactly 1 get_status result, got %d", statusCount) 2783 } 2784 if systemCount != 1 { 2785 t.Errorf("Expected exactly 1 get_system result, got %d", systemCount) 2786 } 2787 if nonSnapshotCount != 1 { 2788 t.Errorf("Expected 1 non-snapshot tool result, got %d - non-snapshots should be preserved", nonSnapshotCount) 2789 } 2790 2791 // Verify order preserved (user message should still be first) 2792 if len(result) > 0 && result[0].Role != store.MemoryRoleUser { 2793 t.Error("Message order not preserved - user message should be first") 2794 } 2795}