xonecas.io
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, &params); 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}