xonecas.io
60255
Zn

Zoea-Nova / commit 5f83b0a

fix: move encouragementCount increment outside tool loop

Problem: encouragementCount was incrementing on every tool iteration
(inside getContextMemories() at line 1275), causing myses to hit the
3-encouragement limit during a single turn with multiple tool calls.

Solution: Move counter increment to SendMessageFrom() after the tool
loop completes successfully. Counter now increments once per autonomous
turn instead of once per tool iteration.

Changes:
- Modified getContextMemories() to return (memories, bool, error)
- Added addedSynthetic flag to track synthetic encouragement
- Removed counter increment from getContextMemories() (line 1275)
- Added counter increment in SendMessageFrom() after turn completes
- Updated all test calls to handle 3-value return signature

Truth table compliance:
- Running + No user msg → Add synthetic, +1, Running (once per turn)
- Running + No user msg (3 turns) → Counter reaches 3, Idle
- Running + Broadcast exists → Counter stays 0, Running indefinitely

Tests: All pass (83.3% coverage)

xonecas2026-02-08 5f83b0a4a9ae030c531d3d592b492684d375d890 parent 50abb3c

4 files changed

internal/core/agent3_reproduction_test.go+2−2
@@ -129,7 +129,7 @@ func TestAgent3Finding_OrphanedToolResults(t *testing.T) {
129129 bus: bus,
130130 }
131131
132- memories, err := mysis.getContextMemories()
132+ memories, _, err := mysis.getContextMemories()
133133 if err != nil {
134134 t.Fatalf("getContextMemories() error: %v", err)
135135 }
@@ -292,7 +292,7 @@ func TestLoopContextSlice_ToolCallResultPairing(t *testing.T) {
292292 bus: bus,
293293 }
294294
295- memories, err := mysis.getContextMemories()
295+ memories, _, err := mysis.getContextMemories()
296296 if err != nil {
297297 t.Fatalf("getContextMemories() error: %v", err)
298298 }
internal/core/mysis.go+42−21
@@ -476,22 +476,31 @@ func (m *Mysis) SendMessageFrom(content string, source store.MemorySource, sende
476476 })
477477 }
478478
479+ // Track if synthetic encouragement was added (for counter increment after turn completes)
480+ var addedSyntheticEncouragement bool
481+
479482 // Loop: keep calling LLM until we get a final text response
480483 for iteration := 0; iteration < constants.MaxToolIterations; iteration++ {
481484 // Get recent conversation history (keeps context small for faster inference)
482- memories, err := a.getContextMemories()
485+ memories, addedSynthetic, err := a.getContextMemories()
483486 if err != nil {
484487 a.setError(err)
485488 return fmt.Errorf("get memories: %w", err)
486489 }
487490
488- // Check if encouragement limit reached (getContextMemories increments counter)
491+ // Track if synthetic encouragement was added on first iteration
492+ // (subsequent iterations reuse same context, so only first matters)
493+ if iteration == 0 {
494+ addedSyntheticEncouragement = addedSynthetic
495+ }
496+
497+ // Check if encouragement limit reached (counter incremented after turn completes)
489498 a.mu.RLock()
490499 count := a.encouragementCount
491500 a.mu.RUnlock()
492501
493502 if count >= 3 {
494- // No real user messages for 3 consecutive iterations - go idle
503+ // No real user messages for 3 consecutive autonomous turns - go idle
495504 a.setIdle("No user messages after 3 encouragements")
496505 return nil
497506 }
@@ -683,6 +692,26 @@ func (m *Mysis) SendMessageFrom(content string, source store.MemorySource, sende
683692 Timestamp: time.Now(),
684693 })
685694
695+ // Increment encouragement counter if this was an autonomous turn (no user message)
696+ // If synthetic encouragement was added, this means no real user message existed
697+ if addedSyntheticEncouragement {
698+ a.mu.Lock()
699+ a.encouragementCount++
700+ count := a.encouragementCount
701+ a.mu.Unlock()
702+
703+ log.Debug().
704+ Str("mysis", a.name).
705+ Int("count", count).
706+ Msg("Autonomous turn completed - incremented encouragement counter")
707+
708+ // If we've hit the limit, transition to idle immediately
709+ if count >= 3 {
710+ a.setIdle("No user messages after 3 encouragements")
711+ return nil
712+ }
713+ }
714+
686715 return nil
687716 }
688717
@@ -1169,11 +1198,14 @@ func (m *Mysis) findLastUserPromptIndex(memories []*store.Memory) int {
11691198 // {role: assistant, content: "[TOOL_CALLS]call_2:get_status:{\"session_id\":\"abc123\"}"},
11701199 // {role: tool, content: "call_2:Ship health: 100%"}
11711200 // ]
1172-func (m *Mysis) getContextMemories() ([]*store.Memory, error) {
1201+func (m *Mysis) getContextMemories() ([]*store.Memory, bool, error) {
1202+ // Track if synthetic encouragement was added this call
1203+ addedSynthetic := false
1204+
11731205 // Get all recent memories
11741206 allMemories, err := m.store.GetRecentMemories(m.id, constants.MaxContextMessages)
11751207 if err != nil {
1176- return nil, err
1208+ return nil, false, err
11771209 }
11781210
11791211 // Find current turn boundary
@@ -1209,7 +1241,7 @@ func (m *Mysis) getContextMemories() ([]*store.Memory, error) {
12091241 broadcast, err := m.store.GetMostRecentBroadcast(m.id)
12101242 if err != nil {
12111243 // Database error - return error to caller rather than treating as "no broadcast"
1212- return nil, fmt.Errorf("check for broadcast: %w", err)
1244+ return nil, false, fmt.Errorf("check for broadcast: %w", err)
12131245 }
12141246
12151247 if broadcast != nil {
@@ -1257,24 +1289,13 @@ func (m *Mysis) getContextMemories() ([]*store.Memory, error) {
12571289 }
12581290 result = append(result, nudgeMemory)
12591291
1260- // Increment encouragement counter since we added synthetic message
1261- m.mu.Lock()
1262- m.encouragementCount++
1263- count := m.encouragementCount
1264- m.mu.Unlock()
1265-
1266- // If 3 encouragements sent, prepare to idle (will be checked in loop)
1267- if count >= 3 {
1268- // Store that we hit limit - the loop will handle state transition
1269- log.Warn().
1270- Str("mysis", m.name).
1271- Int("count", count).
1272- Msg("Encouragement limit reached - mysis should idle")
1273- }
1292+ // Mark that synthetic encouragement was added
1293+ // Counter will be incremented once per turn by caller after turn completes
1294+ addedSynthetic = true
12741295 }
12751296 }
12761297
1277- return result, nil
1298+ return result, addedSynthetic, nil
12781299 }
12791300
12801301 // compactSnapshots removes redundant snapshot tool results, keeping only the most recent
internal/core/mysis_test.go+23−30
@@ -459,7 +459,7 @@ func TestZoeaListMysesCompaction(t *testing.T) {
459459 }
460460
461461 // Get context memories
462- memories, err := mysis.getContextMemories()
462+ memories, _, err := mysis.getContextMemories()
463463 if err != nil {
464464 t.Fatalf("getContextMemories() error: %v", err)
465465 }
@@ -581,7 +581,7 @@ func TestGetContextMemories_CurrentTurnBoundary(t *testing.T) {
581581 tt.setupMemories()
582582
583583 // Get context memories
584- memories, err := mysis.getContextMemories()
584+ memories, _, err := mysis.getContextMemories()
585585 if err != nil {
586586 t.Fatalf("getContextMemories() error: %v", err)
587587 }
@@ -1190,8 +1190,8 @@ func TestStopAtVariousTimings(t *testing.T) {
11901190 // Encouragement counter now increments in getContextMemories() when no user message exists.
11911191 // See TestEncouragementLimit and TestEncouragementReset for new behavior.
11921192
1193-// TestEncouragementLimit tests that encouragementCount reaches 3 after 3 getContextMemories() calls
1194-// with no user messages, and that a warning is logged.
1193+// TestEncouragementLimit tests that getContextMemories() returns the correct addedSynthetic flag
1194+// when no user messages exist. The counter increment happens in SendMessageFrom(), not here.
11951195 func TestEncouragementLimit(t *testing.T) {
11961196 s, bus, cleanup := setupMysisTest(t)
11971197 defer cleanup()
@@ -1210,34 +1210,27 @@ func TestEncouragementLimit(t *testing.T) {
12101210 t.Fatalf("AddMemory error: %v", err)
12111211 }
12121212
1213- // Call getContextMemories() 3 times with no user messages
1214- for i := 1; i <= 3; i++ {
1215- _, err := mysis.getContextMemories()
1216- if err != nil {
1217- t.Fatalf("getContextMemories() error on call %d: %v", i, err)
1218- }
1219-
1220- // Check counter value
1221- mysis.mu.RLock()
1222- count := mysis.encouragementCount
1223- mysis.mu.RUnlock()
1213+ // Call getContextMemories() with no user messages - should return addedSynthetic=true
1214+ _, addedSynthetic, err := mysis.getContextMemories()
1215+ if err != nil {
1216+ t.Fatalf("getContextMemories() error: %v", err)
1217+ }
12241218
1225- if count != i {
1226- t.Errorf("after call %d: expected encouragementCount=%d, got %d", i, i, count)
1227- }
1219+ if !addedSynthetic {
1220+ t.Errorf("expected addedSynthetic=true when no user message exists, got false")
12281221 }
12291222
1230- // Verify counter reached 3
1223+ // Verify counter is still 0 (increment happens in SendMessageFrom, not here)
12311224 mysis.mu.RLock()
1232- finalCount := mysis.encouragementCount
1225+ count := mysis.encouragementCount
12331226 mysis.mu.RUnlock()
12341227
1235- if finalCount != 3 {
1236- t.Errorf("expected final encouragementCount=3, got %d", finalCount)
1228+ if count != 0 {
1229+ t.Errorf("expected encouragementCount=0 (not incremented by getContextMemories), got %d", count)
12371230 }
12381231
1239- // Note: Testing the warning log would require capturing log output,
1240- // which is not done here. The warning is verified in integration tests.
1232+ // Note: Full autonomous turn behavior (counter increment after turn completes)
1233+ // is tested in TestMysisCounterBehavior_* tests.
12411234 }
12421235
12431236 // TestEncouragementReset tests that encouragementCount resets to 0 when a real user message
@@ -1339,7 +1332,7 @@ func TestEncouragementReset(t *testing.T) {
13391332 mysis.mu.Unlock()
13401333
13411334 // Call getContextMemories() - should NOT reset counter because real user message exists
1342- _, err = mysis.getContextMemories()
1335+ _, _, err = mysis.getContextMemories()
13431336 if err != nil {
13441337 t.Fatalf("getContextMemories() error: %v", err)
13451338 }
@@ -1966,7 +1959,7 @@ func TestGetContextMemories_CurrentTurnPreserved(t *testing.T) {
19661959 t.Fatalf("AddMemory error: %v", err)
19671960 }
19681961
1969- memories, err := mysis.getContextMemories()
1962+ memories, _, err := mysis.getContextMemories()
19701963 if err != nil {
19711964 t.Fatalf("getContextMemories error: %v", err)
19721965 }
@@ -2031,7 +2024,7 @@ func TestGetContextMemories_NoUserPrompt(t *testing.T) {
20312024 t.Fatalf("AddMemory error: %v", err)
20322025 }
20332026
2034- memories, err := mysis.getContextMemories()
2027+ memories, _, err := mysis.getContextMemories()
20352028 if err != nil {
20362029 t.Fatalf("getContextMemories error: %v", err)
20372030 }
@@ -2074,7 +2067,7 @@ func TestGetContextMemories_OnlyHistoricalTurns(t *testing.T) {
20742067 t.Fatalf("AddMemory error: %v", err)
20752068 }
20762069
2077- memories, err := mysis.getContextMemories()
2070+ memories, _, err := mysis.getContextMemories()
20782071 if err != nil {
20792072 t.Fatalf("getContextMemories error: %v", err)
20802073 }
@@ -2452,7 +2445,7 @@ func TestBroadcastSlidingWindowBug(t *testing.T) {
24522445
24532446 // Call getContextMemories - this should find the broadcast even though
24542447 // it's outside the 20-message sliding window
2455- memories, err := mysis.getContextMemories()
2448+ memories, _, err := mysis.getContextMemories()
24562449 if err != nil {
24572450 t.Fatalf("getContextMemories() error: %v", err)
24582451 }
@@ -2555,7 +2548,7 @@ func TestNewMysisInheritsGlobalBroadcast(t *testing.T) {
25552548 mock := provider.NewMock("mock", "Continuing mission...")
25562549 mysisInstance := NewMysis(mysis2.ID, mysis2.Name, mysis2.CreatedAt, mock, s, bus)
25572550
2558- memories, err := mysisInstance.getContextMemories()
2551+ memories, _, err := mysisInstance.getContextMemories()
25592552 if err != nil {
25602553 t.Fatalf("getContextMemories() error: %v", err)
25612554 }
internal/core/orphaned_tool_results_test.go+2−2
@@ -97,7 +97,7 @@ func TestOrphanedToolResults_ContextCompression(t *testing.T) {
9797 bus: bus,
9898 }
9999
100- memories, err := mysis.getContextMemories()
100+ memories, _, err := mysis.getContextMemories()
101101 if err != nil {
102102 t.Fatalf("getContextMemories() error: %v", err)
103103 }
@@ -416,7 +416,7 @@ func TestLoopContextSlice(t *testing.T) {
416416 bus: bus,
417417 }
418418
419- memories, err := mysis.getContextMemories()
419+ memories, _, err := mysis.getContextMemories()
420420 if err != nil {
421421 t.Fatalf("getContextMemories() error: %v", err)
422422 }