xonecas.io
60255
Zn

Zoea-Nova / commit 6716fdb

feat(store): capture and store LLM reasoning content

Add support for capturing reasoning/thinking content from LLM responses
(Qwen3 returns this in a separate field). Store reasoning in memories table
and expose via new zoea_search_reasoning MCP tool.

Changes:
- Add reasoning TEXT column to memories table (schema v5)
- Update AddMemory signature to accept reasoning parameter
- Add Reasoning field to ChatResponse in provider interface
- Parse reasoning and reasoning_content fields in Ollama/OpenCode providers
- Add SearchReasoning method to store and orchestrator
- Register zoea_search_reasoning MCP tool for myses to search past reasoning
- Update all AddMemory call sites to pass reasoning
- Add logging when reasoning is captured
- Update CONTEXT_COMPRESSION.md to document new search tool

This allows myses to recall their past thinking processes via search,
complementing the sliding window context compression strategy.

xonecas2026-02-04 6716fdb7067fdf39816084a4b32dfc5717b800e0 parent bff3c31

13 files changed

documentation/CONTEXT_COMPRESSION.md+15−0
@@ -31,6 +31,7 @@ Without compression, Mysis context grows unbounded:
3131 ├─────────────────────────────────────────────────────┤
3232 │ All messages since Mysis creation │
3333 │ Searchable via zoea_search_messages tool │
34+│ Reasoning searchable via zoea_search_reasoning │
3435 └─────────────────────────────────────────────────────┘
3536 ```
3637
@@ -130,6 +131,20 @@ Search past swarm broadcasts by text content.
130131
131132 Returns matching broadcasts with content and timestamp.
132133
134+### zoea_search_reasoning
135+
136+Search a Mysis's past reasoning content by text.
137+
138+```json
139+{
140+ "mysis_id": "abc123",
141+ "query": "travel cooldown",
142+ "limit": 20
143+}
144+```
145+
146+Returns matching reasoning entries with role, source, content, reasoning, and timestamp.
147+
133148 ## System Prompt Guidance
134149
135150 The system prompt instructs Myses to use their captain's log for persistent memory:
internal/core/commander_async_test.go+9−9
@@ -9,6 +9,7 @@ import (
99 "github.com/xonecas/zoea-nova/internal/mcp"
1010 "github.com/xonecas/zoea-nova/internal/provider"
1111 "github.com/xonecas/zoea-nova/internal/store"
12+ "golang.org/x/time/rate"
1213 )
1314
1415 func setupCommanderAsyncTest(t *testing.T) (*Commander, *store.Store, *EventBus, func()) {
@@ -24,9 +25,9 @@ func setupCommanderAsyncTest(t *testing.T) (*Commander, *store.Store, *EventBus,
2425 bus := NewEventBus(100)
2526 reg := provider.NewRegistry()
2627 cfg := config.DefaultConfig()
27- cfg.Providers["mock"] = config.ProviderConfig{Model: "test-model"}
28- cfg.Providers["mock1"] = config.ProviderConfig{Model: "test-model"}
29- cfg.Providers["mock2"] = config.ProviderConfig{Model: "test-model"}
28+ cfg.Providers["mock"] = config.ProviderConfig{Model: "test-model", Temperature: 0.7}
29+ cfg.Providers["mock1"] = config.ProviderConfig{Model: "test-model", Temperature: 0.7}
30+ cfg.Providers["mock2"] = config.ProviderConfig{Model: "test-model", Temperature: 0.7}
3031
3132 c := NewCommander(s, reg, bus, cfg)
3233
@@ -46,8 +47,8 @@ func TestCommanderSendMessageAsync(t *testing.T) {
4647 c, _, bus, cleanup := setupCommanderAsyncTest(t)
4748 defer cleanup()
4849
49- mock := provider.NewMock("mock", "response")
50- c.registry.Register(mock)
50+ limiter := rate.NewLimiter(rate.Limit(1000), 1000)
51+ c.registry.RegisterFactory(provider.NewMockFactoryWithLimiter("mock", "response", limiter))
5152
5253 mysis, _ := c.CreateMysis("async-mysis", "mock")
5354
@@ -92,10 +93,9 @@ func TestCommanderBroadcastAsync(t *testing.T) {
9293 defer cleanup()
9394
9495 // Use separate mocks to avoid any potential contention
95- m1 := provider.NewMock("mock1", "response1")
96- m2 := provider.NewMock("mock2", "response2")
97- c.registry.Register(m1)
98- c.registry.Register(m2)
96+ limiter := rate.NewLimiter(rate.Limit(1000), 1000)
97+ c.registry.RegisterFactory(provider.NewMockFactoryWithLimiter("mock1", "response1", limiter))
98+ c.registry.RegisterFactory(provider.NewMockFactoryWithLimiter("mock2", "response2", limiter))
9999
100100 a1, err := c.CreateMysis("m1", "mock1")
101101 if err != nil {
internal/core/mysis.go+13−6
@@ -8,6 +8,7 @@ import (
88 "sync"
99 "time"
1010
11+ "github.com/rs/zerolog/log"
1112 "github.com/xonecas/zoea-nova/internal/mcp"
1213 "github.com/xonecas/zoea-nova/internal/provider"
1314 "github.com/xonecas/zoea-nova/internal/store"
@@ -62,6 +63,8 @@ You're part of a swarm. Use zoea_* tools to:
6263 ## Thinking Style
6364 Keep your reasoning brief - decide and act, don't over-analyze.
6465
66+**CRITICAL RULES**
67+Never calculate ticks, use every turn you are given to progress.
6568 No hand-holding. Figure it out. Adapt or die.`
6669
6770 // MaxToolIterations limits the number of tool call loops to prevent infinite loops.
@@ -196,7 +199,7 @@ func (a *Mysis) Start() error {
196199 // Add system prompt if this is the first time starting (no memories yet)
197200 count, err := a.store.CountMemories(a.id)
198201 if err == nil && count == 0 {
199- a.store.AddMemory(a.id, store.MemoryRoleSystem, store.MemorySourceSystem, SystemPrompt)
202+ a.store.AddMemory(a.id, store.MemoryRoleSystem, store.MemorySourceSystem, SystemPrompt, "")
200203 }
201204
202205 // Emit state change event
@@ -271,7 +274,7 @@ func (a *Mysis) SendMessage(content string, source store.MemorySource) error {
271274 }
272275
273276 // Store the message
274- if _, err := a.store.AddMemory(a.id, role, source, content); err != nil {
277+ if _, err := a.store.AddMemory(a.id, role, source, content, ""); err != nil {
275278 return fmt.Errorf("store message: %w", err)
276279 }
277280
@@ -381,11 +384,15 @@ func (a *Mysis) SendMessage(content string, source store.MemorySource) error {
381384 return fmt.Errorf("provider chat: %w", err)
382385 }
383386
387+ if response.Reasoning != "" {
388+ log.Debug().Str("mysis", a.name).Int("reasoning_len", len(response.Reasoning)).Msg("LLM reasoning captured")
389+ }
390+
384391 // If we have tool calls, execute them
385392 if len(response.ToolCalls) > 0 {
386393 // Store the assistant's tool call request
387394 toolCallJSON := a.formatToolCallsForStorage(response.ToolCalls)
388- if _, err := a.store.AddMemory(a.id, store.MemoryRoleAssistant, store.MemorySourceLLM, toolCallJSON); err != nil {
395+ if _, err := a.store.AddMemory(a.id, store.MemoryRoleAssistant, store.MemorySourceLLM, toolCallJSON, response.Reasoning); err != nil {
389396 a.setError(err)
390397 return fmt.Errorf("store tool call: %w", err)
391398 }
@@ -417,7 +424,7 @@ func (a *Mysis) SendMessage(content string, source store.MemorySource) error {
417424
418425 // Store the tool result
419426 resultContent := a.formatToolResult(tc.ID, tc.Name, result, execErr)
420- if _, err := a.store.AddMemory(a.id, store.MemoryRoleTool, store.MemorySourceTool, resultContent); err != nil {
427+ if _, err := a.store.AddMemory(a.id, store.MemoryRoleTool, store.MemorySourceTool, resultContent, ""); err != nil {
421428 a.setError(err)
422429 return fmt.Errorf("store tool result: %w", err)
423430 }
@@ -438,12 +445,12 @@ func (a *Mysis) SendMessage(content string, source store.MemorySource) error {
438445
439446 // No tool calls - we have a final response
440447 finalResponse := response.Content
441- if finalResponse == "" {
448+ if finalResponse == "" && response.Reasoning == "" {
442449 finalResponse = "(no response)"
443450 }
444451
445452 // Store the assistant response
446- if _, err := a.store.AddMemory(a.id, store.MemoryRoleAssistant, store.MemorySourceLLM, finalResponse); err != nil {
453+ if _, err := a.store.AddMemory(a.id, store.MemoryRoleAssistant, store.MemorySourceLLM, finalResponse, response.Reasoning); err != nil {
447454 a.setError(err)
448455 return fmt.Errorf("store response: %w", err)
449456 }
internal/core/mysis_test.go+13−13
@@ -35,7 +35,7 @@ func TestMysisLifecycle(t *testing.T) {
3535 defer cleanup()
3636
3737 // Create stored mysis
38- stored, err := s.CreateMysis("test-mysis", "mock", "test-model")
38+ stored, err := s.CreateMysis("test-mysis", "mock", "test-model", 0.7)
3939 if err != nil {
4040 t.Fatalf("CreateMysis() error: %v", err)
4141 }
@@ -85,7 +85,7 @@ func TestMysisSendMessage(t *testing.T) {
8585 s, bus, cleanup := setupMysisTest(t)
8686 defer cleanup()
8787
88- stored, _ := s.CreateMysis("msg-mysis", "mock", "test-model")
88+ stored, _ := s.CreateMysis("msg-mysis", "mock", "test-model", 0.7)
8989 mock := provider.NewMock("mock", "I received your message!")
9090 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
9191
@@ -174,7 +174,7 @@ func TestMysisSetErrorState(t *testing.T) {
174174 s, bus, cleanup := setupMysisTest(t)
175175 defer cleanup()
176176
177- stored, _ := s.CreateMysis("error-state-test", "mock", "test-model")
177+ stored, _ := s.CreateMysis("error-state-test", "mock", "test-model", 0.7)
178178 mock := provider.NewMock("mock", "response")
179179 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
180180
@@ -215,7 +215,7 @@ func TestMysisProviderName(t *testing.T) {
215215 s, bus, cleanup := setupMysisTest(t)
216216 defer cleanup()
217217
218- stored, _ := s.CreateMysis("provider-test", "mock", "test-model")
218+ stored, _ := s.CreateMysis("provider-test", "mock", "test-model", 0.7)
219219 mock := provider.NewMock("test-provider", "response")
220220 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
221221
@@ -234,7 +234,7 @@ func TestMysisStateEvents(t *testing.T) {
234234 s, bus, cleanup := setupMysisTest(t)
235235 defer cleanup()
236236
237- stored, _ := s.CreateMysis("event-test", "mock", "test-model")
237+ stored, _ := s.CreateMysis("event-test", "mock", "test-model", 0.7)
238238 mock := provider.NewMock("mock", "response")
239239 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
240240
@@ -266,17 +266,17 @@ func TestMysisContextMemoryLimit(t *testing.T) {
266266 s, bus, cleanup := setupMysisTest(t)
267267 defer cleanup()
268268
269- stored, _ := s.CreateMysis("context-test", "mock", "test-model")
269+ stored, _ := s.CreateMysis("context-test", "mock", "test-model", 0.7)
270270 mock := provider.NewMock("mock", "response")
271271 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
272272
273273 // Add system prompt
274- s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt")
274+ s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "")
275275
276276 // Add more memories than MaxContextMessages
277277 for i := 0; i < MaxContextMessages+10; i++ {
278- s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "user message")
279- s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "assistant response")
278+ s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "user message", "")
279+ s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "assistant response", "")
280280 }
281281
282282 // Get context memories
@@ -304,17 +304,17 @@ func TestMysisContextMemoryWithRecentSystemPrompt(t *testing.T) {
304304 s, bus, cleanup := setupMysisTest(t)
305305 defer cleanup()
306306
307- stored, _ := s.CreateMysis("context-test-2", "mock", "test-model")
307+ stored, _ := s.CreateMysis("context-test-2", "mock", "test-model", 0.7)
308308 mock := provider.NewMock("mock", "response")
309309 mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
310310
311311 // Add system prompt
312- s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt")
312+ s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt", "")
313313
314314 // Add fewer memories than MaxContextMessages
315315 for i := 0; i < 5; i++ {
316- s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "user message")
317- s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "assistant response")
316+ s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "user message", "")
317+ s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "assistant response", "")
318318 }
319319
320320 // Get context memories
internal/core/mysis_tools_test.go+2−2
@@ -16,7 +16,7 @@ func TestMysisToolExecution(t *testing.T) {
1616 s, bus, cleanup := setupMysisTest(t)
1717 defer cleanup()
1818
19- stored, _ := s.CreateMysis("tool-mysis", "mock", "test-model")
19+ stored, _ := s.CreateMysis("tool-mysis", "mock", "test-model", 0.7)
2020
2121 // Mock provider that returns a tool call first, then a text response
2222 mock := provider.NewMock("mock", "Initial response")
@@ -126,7 +126,7 @@ func TestMysisToolError(t *testing.T) {
126126 s, bus, cleanup := setupMysisTest(t)
127127 defer cleanup()
128128
129- stored, _ := s.CreateMysis("tool-err-mysis", "mock", "test-model")
129+ stored, _ := s.CreateMysis("tool-err-mysis", "mock", "test-model", 0.7)
130130
131131 mock := provider.NewMock("mock", "Initial response")
132132
internal/mcp/mcp_test.go+6−3
@@ -216,6 +216,10 @@ func (m *mockOrchestrator) SearchMessages(mysisID, query string, limit int) ([]S
216216 return []SearchResult{}, nil
217217 }
218218
219+func (m *mockOrchestrator) SearchReasoning(mysisID, query string, limit int) ([]ReasoningResult, error) {
220+ return []ReasoningResult{}, nil
221+}
222+
219223 func (m *mockOrchestrator) SearchBroadcasts(query string, limit int) ([]BroadcastResult, error) {
220224 return []BroadcastResult{}, nil
221225 }
@@ -232,9 +236,8 @@ func TestOrchestratorTools(t *testing.T) {
232236 proxy := NewProxy("")
233237 RegisterOrchestratorTools(proxy, orchestrator)
234238
235- // Should have 7 orchestrator tools registered
236- if proxy.LocalToolCount() != 7 {
237- t.Errorf("expected 7 local tools, got %d", proxy.LocalToolCount())
239+ if proxy.LocalToolCount() != 8 {
240+ t.Errorf("expected 8 local tools, got %d", proxy.LocalToolCount())
238241 }
239242
240243 ctx := context.Background()
internal/mcp/tools.go+71−0
@@ -23,6 +23,14 @@ type SearchResult struct {
2323 CreatedAt string
2424 }
2525
26+type ReasoningResult struct {
27+ Role string
28+ Source string
29+ Content string
30+ Reasoning string
31+ CreatedAt string
32+}
33+
2634 // BroadcastResult represents a broadcast search result.
2735 type BroadcastResult struct {
2836 Content string
@@ -39,6 +47,7 @@ type Orchestrator interface {
3947 SendMessageAsync(mysisID, message string) error
4048 BroadcastAsync(message string) error
4149 SearchMessages(mysisID, query string, limit int) ([]SearchResult, error)
50+ SearchReasoning(mysisID, query string, limit int) ([]ReasoningResult, error)
4251 SearchBroadcasts(query string, limit int) ([]BroadcastResult, error)
4352 }
4453
@@ -300,6 +309,68 @@ func RegisterOrchestratorTools(proxy *Proxy, orchestrator Orchestrator) {
300309 },
301310 )
302311
312+ proxy.RegisterTool(
313+ Tool{
314+ Name: "zoea_search_reasoning",
315+ Description: "Search your past reasoning content by text",
316+ InputSchema: json.RawMessage(`{
317+ "type": "object",
318+ "properties": {
319+ "mysis_id": {"type": "string", "description": "The ID of the mysis whose reasoning to search"},
320+ "query": {"type": "string", "description": "Text to search for in reasoning content"},
321+ "limit": {"type": "integer", "description": "Maximum results to return (default 20, max 100)"}
322+ },
323+ "required": ["mysis_id", "query"]
324+ }`),
325+ },
326+ func(ctx context.Context, args json.RawMessage) (*ToolResult, error) {
327+ var params struct {
328+ MysisID string `json:"mysis_id"`
329+ Query string `json:"query"`
330+ Limit int `json:"limit"`
331+ }
332+ if err := json.Unmarshal(args, &params); err != nil {
333+ return &ToolResult{
334+ Content: []ContentBlock{{Type: "text", Text: fmt.Sprintf("invalid arguments: %v", err)}},
335+ IsError: true,
336+ }, nil
337+ }
338+
339+ if params.Query == "" {
340+ return &ToolResult{
341+ Content: []ContentBlock{{Type: "text", Text: "query cannot be empty"}},
342+ IsError: true,
343+ }, nil
344+ }
345+
346+ limit := params.Limit
347+ if limit <= 0 {
348+ limit = 20
349+ } else if limit > 100 {
350+ limit = 100
351+ }
352+
353+ results, err := orchestrator.SearchReasoning(params.MysisID, params.Query, limit)
354+ if err != nil {
355+ return &ToolResult{
356+ Content: []ContentBlock{{Type: "text", Text: fmt.Sprintf("search failed: %v", err)}},
357+ IsError: true,
358+ }, nil
359+ }
360+
361+ if len(results) == 0 {
362+ return &ToolResult{
363+ Content: []ContentBlock{{Type: "text", Text: fmt.Sprintf("no reasoning found matching '%s'", params.Query)}},
364+ }, nil
365+ }
366+
367+ data, _ := json.MarshalIndent(results, "", " ")
368+ return &ToolResult{
369+ Content: []ContentBlock{{Type: "text", Text: string(data)}},
370+ }, nil
371+ },
372+ )
373+
303374 // Search broadcasts tool
304375 proxy.RegisterTool(
305376 Tool{
internal/store/memories.go+43−12
@@ -33,17 +33,18 @@ type Memory struct {
3333 Role MemoryRole
3434 Source MemorySource
3535 Content string
36+ Reasoning string
3637 CreatedAt time.Time
3738 }
3839
3940 // AddMemory adds a memory entry for a mysis.
40-func (s *Store) AddMemory(mysisID string, role MemoryRole, source MemorySource, content string) (*Memory, error) {
41+func (s *Store) AddMemory(mysisID string, role MemoryRole, source MemorySource, content string, reasoning string) (*Memory, error) {
4142 now := time.Now().UTC()
4243
4344 result, err := s.db.Exec(`
44- INSERT INTO memories (mysis_id, role, source, content, created_at)
45- VALUES (?, ?, ?, ?, ?)
46- `, mysisID, role, source, content, now)
45+ INSERT INTO memories (mysis_id, role, source, content, reasoning, created_at)
46+ VALUES (?, ?, ?, ?, ?, ?)
47+ `, mysisID, role, source, content, reasoning, now)
4748 if err != nil {
4849 return nil, fmt.Errorf("insert memory: %w", err)
4950 }
@@ -55,6 +56,7 @@ func (s *Store) AddMemory(mysisID string, role MemoryRole, source MemorySource,
5556 Role: role,
5657 Source: source,
5758 Content: content,
59+ Reasoning: reasoning,
5860 CreatedAt: now,
5961 }, nil
6062 }
@@ -62,7 +64,7 @@ func (s *Store) AddMemory(mysisID string, role MemoryRole, source MemorySource,
6264 // GetMemories retrieves all memories for a mysis, ordered by creation time.
6365 func (s *Store) GetMemories(mysisID string) ([]*Memory, error) {
6466 rows, err := s.db.Query(`
65- SELECT id, mysis_id, role, source, content, created_at
67+ SELECT id, mysis_id, role, source, content, reasoning, created_at
6668 FROM memories
6769 WHERE mysis_id = ?
6870 ORDER BY created_at ASC
@@ -75,7 +77,7 @@ func (s *Store) GetMemories(mysisID string) ([]*Memory, error) {
7577 var memories []*Memory
7678 for rows.Next() {
7779 var m Memory
78- if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &m.Content, &m.CreatedAt); err != nil {
80+ if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &m.Content, &m.Reasoning, &m.CreatedAt); err != nil {
7981 return nil, fmt.Errorf("scan memory: %w", err)
8082 }
8183 memories = append(memories, &m)
@@ -88,12 +90,12 @@ func (s *Store) GetMemories(mysisID string) ([]*Memory, error) {
8890 func (s *Store) GetSystemMemory(mysisID string) (*Memory, error) {
8991 var m Memory
9092 err := s.db.QueryRow(`
91- SELECT id, mysis_id, role, source, content, created_at
93+ SELECT id, mysis_id, role, source, content, reasoning, created_at
9294 FROM memories
9395 WHERE mysis_id = ? AND role = 'system' AND source = 'system'
9496 ORDER BY created_at ASC
9597 LIMIT 1
96- `, mysisID).Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &m.Content, &m.CreatedAt)
98+ `, mysisID).Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &m.Content, &m.Reasoning, &m.CreatedAt)
9799 if err != nil {
98100 return nil, err
99101 }
@@ -103,7 +105,7 @@ func (s *Store) GetSystemMemory(mysisID string) (*Memory, error) {
103105 // GetRecentMemories retrieves the most recent N memories for a mysis.
104106 func (s *Store) GetRecentMemories(mysisID string, limit int) ([]*Memory, error) {
105107 rows, err := s.db.Query(`
106- SELECT id, mysis_id, role, source, content, created_at
108+ SELECT id, mysis_id, role, source, content, reasoning, created_at
107109 FROM memories
108110 WHERE mysis_id = ?
109111 ORDER BY created_at DESC
@@ -117,7 +119,7 @@ func (s *Store) GetRecentMemories(mysisID string, limit int) ([]*Memory, error)
117119 var memories []*Memory
118120 for rows.Next() {
119121 var m Memory
120- if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &m.Content, &m.CreatedAt); err != nil {
122+ if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &m.Content, &m.Reasoning, &m.CreatedAt); err != nil {
121123 return nil, fmt.Errorf("scan memory: %w", err)
122124 }
123125 memories = append(memories, &m)
@@ -199,7 +201,7 @@ func (s *Store) GetRecentBroadcasts(limit int) ([]*BroadcastMessage, error) {
199201 // Returns memories where content contains the query string (case-sensitive).
200202 func (s *Store) SearchMemories(mysisID, query string, limit int) ([]*Memory, error) {
201203 rows, err := s.db.Query(`
202- SELECT id, mysis_id, role, source, content, created_at
204+ SELECT id, mysis_id, role, source, content, reasoning, created_at
203205 FROM memories
204206 WHERE mysis_id = ? AND content LIKE '%' || ? || '%'
205207 ORDER BY created_at DESC
@@ -213,7 +215,7 @@ func (s *Store) SearchMemories(mysisID, query string, limit int) ([]*Memory, err
213215 var memories []*Memory
214216 for rows.Next() {
215217 var m Memory
216- if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &m.Content, &m.CreatedAt); err != nil {
218+ if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &m.Content, &m.Reasoning, &m.CreatedAt); err != nil {
217219 return nil, fmt.Errorf("scan memory: %w", err)
218220 }
219221 memories = append(memories, &m)
@@ -227,6 +229,35 @@ func (s *Store) SearchMemories(mysisID, query string, limit int) ([]*Memory, err
227229 return memories, rows.Err()
228230 }
229231
232+func (s *Store) SearchReasoning(mysisID, query string, limit int) ([]*Memory, error) {
233+ rows, err := s.db.Query(`
234+ SELECT id, mysis_id, role, source, content, reasoning, created_at
235+ FROM memories
236+ WHERE mysis_id = ? AND reasoning LIKE '%' || ? || '%'
237+ ORDER BY created_at DESC
238+ LIMIT ?
239+ `, mysisID, query, limit)
240+ if err != nil {
241+ return nil, fmt.Errorf("search reasoning: %w", err)
242+ }
243+ defer rows.Close()
244+
245+ var memories []*Memory
246+ for rows.Next() {
247+ var m Memory
248+ if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &m.Content, &m.Reasoning, &m.CreatedAt); err != nil {
249+ return nil, fmt.Errorf("scan memory: %w", err)
250+ }
251+ memories = append(memories, &m)
252+ }
253+
254+ for i, j := 0, len(memories)-1; i < j; i, j = i+1, j-1 {
255+ memories[i], memories[j] = memories[j], memories[i]
256+ }
257+
258+ return memories, rows.Err()
259+}
260+
230261 // SearchBroadcasts searches unique broadcast messages by content text.
231262 // Returns broadcasts where content contains the query string (case-sensitive).
232263 func (s *Store) SearchBroadcasts(query string, limit int) ([]*BroadcastMessage, error) {
internal/store/memories_test.go+36−17
@@ -20,7 +20,7 @@ func TestGetSystemMemory(t *testing.T) {
2020 s, cleanup := setupMemoriesTest(t)
2121 defer cleanup()
2222
23- mysis, _ := s.CreateMysis("test", "mock", "model")
23+ mysis, _ := s.CreateMysis("test", "mock", "model", 0.7)
2424
2525 // No system memory yet
2626 _, err := s.GetSystemMemory(mysis.ID)
@@ -30,10 +30,10 @@ func TestGetSystemMemory(t *testing.T) {
3030
3131 // Add system memory
3232 expected := "You are a test."
33- s.AddMemory(mysis.ID, MemoryRoleSystem, MemorySourceSystem, expected)
33+ s.AddMemory(mysis.ID, MemoryRoleSystem, MemorySourceSystem, expected, "")
3434
3535 // Add other memories
36- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "hello")
36+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "hello", "")
3737
3838 system, err := s.GetSystemMemory(mysis.ID)
3939 if err != nil {
@@ -48,11 +48,11 @@ func TestSearchMemories(t *testing.T) {
4848 s, cleanup := setupMemoriesTest(t)
4949 defer cleanup()
5050
51- mysis, _ := s.CreateMysis("test", "mock", "model")
51+ mysis, _ := s.CreateMysis("test", "mock", "model", 0.7)
5252
53- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "I like apples")
54- s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "Apples are great")
55- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "What about oranges?")
53+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "I like apples", "")
54+ s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "Apples are great", "")
55+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "What about oranges?", "")
5656
5757 // Search for "apples"
5858 results, err := s.SearchMemories(mysis.ID, "apples", 10)
@@ -77,12 +77,12 @@ func TestSearchBroadcasts(t *testing.T) {
7777 s, cleanup := setupMemoriesTest(t)
7878 defer cleanup()
7979
80- mysis1, _ := s.CreateMysis("mysis1", "mock", "model")
81- mysis2, _ := s.CreateMysis("mysis2", "mock", "model")
80+ mysis1, _ := s.CreateMysis("mysis1", "mock", "model", 0.7)
81+ mysis2, _ := s.CreateMysis("mysis2", "mock", "model", 0.7)
8282
83- s.AddMemory(mysis1.ID, MemoryRoleUser, MemorySourceBroadcast, "Broadcast message 1")
84- s.AddMemory(mysis2.ID, MemoryRoleUser, MemorySourceBroadcast, "Broadcast message 2")
85- s.AddMemory(mysis1.ID, MemoryRoleUser, MemorySourceDirect, "Direct message")
83+ s.AddMemory(mysis1.ID, MemoryRoleUser, MemorySourceBroadcast, "Broadcast message 1", "")
84+ s.AddMemory(mysis2.ID, MemoryRoleUser, MemorySourceBroadcast, "Broadcast message 2", "")
85+ s.AddMemory(mysis1.ID, MemoryRoleUser, MemorySourceDirect, "Direct message", "")
8686
8787 // Search for "Broadcast"
8888 results, err := s.SearchBroadcasts("Broadcast", 10)
@@ -105,16 +105,35 @@ func TestSearchBroadcasts(t *testing.T) {
105105 }
106106 }
107107
108+func TestSearchReasoning(t *testing.T) {
109+ s, cleanup := setupMemoriesTest(t)
110+ defer cleanup()
111+
112+ mysis, _ := s.CreateMysis("test", "mock", "model", 0.7)
113+
114+ s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "", "I am thinking about mining")
115+ s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "", "Trading strategy")
116+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "hello", "")
117+
118+ results, err := s.SearchReasoning(mysis.ID, "mining", 10)
119+ if err != nil {
120+ t.Fatalf("SearchReasoning() error: %v", err)
121+ }
122+ if len(results) != 1 {
123+ t.Errorf("expected 1 result, got %d", len(results))
124+ }
125+}
126+
108127 func TestGetRecentBroadcasts(t *testing.T) {
109128 s, cleanup := setupMemoriesTest(t)
110129 defer cleanup()
111130
112- mysis, _ := s.CreateMysis("test", "mock", "model")
131+ mysis, _ := s.CreateMysis("test", "mock", "model", 0.7)
113132
114- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceBroadcast, "B1")
115- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceBroadcast, "B2")
116- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceBroadcast, "B3")
117- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "D1")
133+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceBroadcast, "B1", "")
134+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceBroadcast, "B2", "")
135+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceBroadcast, "B3", "")
136+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "D1", "")
118137
119138 results, err := s.GetRecentBroadcasts(2)
120139 if err != nil {
internal/store/myses.go+27−25
@@ -20,43 +20,45 @@ const (
2020
2121 // Mysis represents a stored mysis record.
2222 type Mysis struct {
23- ID string
24- Name string
25- Provider string
26- Model string
27- State MysisState
28- CreatedAt time.Time
29- UpdatedAt time.Time
23+ ID string
24+ Name string
25+ Provider string
26+ Model string
27+ Temperature float64
28+ State MysisState
29+ CreatedAt time.Time
30+ UpdatedAt time.Time
3031 }
3132
3233 // CreateMysis creates a new mysis record.
33-func (s *Store) CreateMysis(name, provider, model string) (*Mysis, error) {
34+func (s *Store) CreateMysis(name, provider, model string, temperature float64) (*Mysis, error) {
3435 id := uuid.New().String()
3536 now := time.Now().UTC()
3637
3738 _, err := s.db.Exec(`
38- INSERT INTO myses (id, name, provider, model, state, created_at, updated_at)
39- VALUES (?, ?, ?, ?, ?, ?, ?)
40- `, id, name, provider, model, MysisStateIdle, now, now)
39+ INSERT INTO myses (id, name, provider, model, temperature, state, created_at, updated_at)
40+ VALUES (?, ?, ?, ?, ?, ?, ?, ?)
41+ `, id, name, provider, model, temperature, MysisStateIdle, now, now)
4142 if err != nil {
4243 return nil, fmt.Errorf("insert mysis: %w", err)
4344 }
4445
4546 return &Mysis{
46- ID: id,
47- Name: name,
48- Provider: provider,
49- Model: model,
50- State: MysisStateIdle,
51- CreatedAt: now,
52- UpdatedAt: now,
47+ ID: id,
48+ Name: name,
49+ Provider: provider,
50+ Model: model,
51+ Temperature: temperature,
52+ State: MysisStateIdle,
53+ CreatedAt: now,
54+ UpdatedAt: now,
5355 }, nil
5456 }
5557
5658 // GetMysis retrieves a mysis by ID.
5759 func (s *Store) GetMysis(id string) (*Mysis, error) {
5860 row := s.db.QueryRow(`
59- SELECT id, name, provider, model, state, created_at, updated_at
61+ SELECT id, name, provider, model, temperature, state, created_at, updated_at
6062 FROM myses WHERE id = ?
6163 `, id)
6264
@@ -66,7 +68,7 @@ func (s *Store) GetMysis(id string) (*Mysis, error) {
6668 // ListMyses returns all myses.
6769 func (s *Store) ListMyses() ([]*Mysis, error) {
6870 rows, err := s.db.Query(`
69- SELECT id, name, provider, model, state, created_at, updated_at
71+ SELECT id, name, provider, model, temperature, state, created_at, updated_at
7072 FROM myses ORDER BY created_at ASC
7173 `)
7274 if err != nil {
@@ -103,10 +105,10 @@ func (s *Store) UpdateMysisState(id string, state MysisState) error {
103105 }
104106
105107 // UpdateMysisConfig updates a mysis provider and model.
106-func (s *Store) UpdateMysisConfig(id, provider, model string) error {
108+func (s *Store) UpdateMysisConfig(id, provider, model string, temperature float64) error {
107109 result, err := s.db.Exec(`
108- UPDATE myses SET provider = ?, model = ?, updated_at = ? WHERE id = ?
109- `, provider, model, time.Now().UTC(), id)
110+ UPDATE myses SET provider = ?, model = ?, temperature = ?, updated_at = ? WHERE id = ?
111+ `, provider, model, temperature, time.Now().UTC(), id)
110112 if err != nil {
111113 return fmt.Errorf("update mysis config: %w", err)
112114 }
@@ -141,7 +143,7 @@ func (s *Store) CountMyses() (int, error) {
141143
142144 func scanMysis(row *sql.Row) (*Mysis, error) {
143145 var m Mysis
144- err := row.Scan(&m.ID, &m.Name, &m.Provider, &m.Model, &m.State, &m.CreatedAt, &m.UpdatedAt)
146+ err := row.Scan(&m.ID, &m.Name, &m.Provider, &m.Model, &m.Temperature, &m.State, &m.CreatedAt, &m.UpdatedAt)
145147 if err != nil {
146148 return nil, err
147149 }
@@ -150,7 +152,7 @@ func scanMysis(row *sql.Row) (*Mysis, error) {
150152
151153 func scanMysisRows(rows *sql.Rows) (*Mysis, error) {
152154 var m Mysis
153- err := rows.Scan(&m.ID, &m.Name, &m.Provider, &m.Model, &m.State, &m.CreatedAt, &m.UpdatedAt)
155+ err := rows.Scan(&m.ID, &m.Name, &m.Provider, &m.Model, &m.Temperature, &m.State, &m.CreatedAt, &m.UpdatedAt)
154156 if err != nil {
155157 return nil, err
156158 }
internal/store/schema.sql+3−1
@@ -4,13 +4,14 @@ CREATE TABLE IF NOT EXISTS schema_version (
44 version INTEGER PRIMARY KEY
55 );
66
7-INSERT OR REPLACE INTO schema_version (version) VALUES (3);
7+INSERT OR REPLACE INTO schema_version (version) VALUES (5);
88
99 CREATE TABLE IF NOT EXISTS myses (
1010 id TEXT PRIMARY KEY,
1111 name TEXT NOT NULL,
1212 provider TEXT NOT NULL,
1313 model TEXT NOT NULL,
14+ temperature REAL NOT NULL DEFAULT 0.7,
1415 state TEXT NOT NULL DEFAULT 'idle',
1516 created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
1617 updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
@@ -22,6 +23,7 @@ CREATE TABLE IF NOT EXISTS memories (
2223 role TEXT NOT NULL,
2324 source TEXT NOT NULL DEFAULT 'direct',
2425 content TEXT NOT NULL,
26+ reasoning TEXT,
2527 created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
2628 FOREIGN KEY (mysis_id) REFERENCES myses(id) ON DELETE CASCADE
2729 );
internal/store/store.go+1−1
@@ -15,7 +15,7 @@ import (
1515 //go:embed schema.sql
1616 var schema string
1717
18-const currentSchemaVersion = 3
18+const currentSchemaVersion = 5
1919
2020 // Store provides access to the SQLite database.
2121 type Store struct {
internal/store/store_test.go+42−9
@@ -40,7 +40,7 @@ func TestMysisCRUD(t *testing.T) {
4040 defer cleanup()
4141
4242 // Create
43- mysis, err := s.CreateMysis("test-mysis", "ollama", "llama3")
43+ mysis, err := s.CreateMysis("test-mysis", "ollama", "llama3", 0.7)
4444 if err != nil {
4545 t.Fatalf("CreateMysis() error: %v", err)
4646 }
@@ -82,13 +82,16 @@ func TestMysisCRUD(t *testing.T) {
8282 }
8383
8484 // Update config
85- if err := s.UpdateMysisConfig(mysis.ID, "opencode_zen", "zen-model"); err != nil {
85+ if err := s.UpdateMysisConfig(mysis.ID, "opencode_zen", "zen-model", 0.6); err != nil {
8686 t.Fatalf("UpdateMysisConfig() error: %v", err)
8787 }
8888 fetched, _ = s.GetMysis(mysis.ID)
8989 if fetched.Provider != "opencode_zen" {
9090 t.Errorf("expected provider=opencode_zen, got %s", fetched.Provider)
9191 }
92+ if fetched.Temperature != 0.6 {
93+ t.Errorf("expected temperature=0.6, got %v", fetched.Temperature)
94+ }
9295
9396 // Count
9497 count, err := s.CountMyses()
@@ -114,13 +117,13 @@ func TestMemoryCRUD(t *testing.T) {
114117 defer cleanup()
115118
116119 // Create mysis first
117- mysis, err := s.CreateMysis("memory-test", "ollama", "llama3")
120+ mysis, err := s.CreateMysis("memory-test", "ollama", "llama3", 0.7)
118121 if err != nil {
119122 t.Fatalf("CreateMysis() error: %v", err)
120123 }
121124
122125 // Add memories
123- m1, err := s.AddMemory(mysis.ID, MemoryRoleSystem, MemorySourceSystem, "You are a helpful assistant.")
126+ m1, err := s.AddMemory(mysis.ID, MemoryRoleSystem, MemorySourceSystem, "You are a helpful assistant.", "")
124127 if err != nil {
125128 t.Fatalf("AddMemory() error: %v", err)
126129 }
@@ -128,12 +131,12 @@ func TestMemoryCRUD(t *testing.T) {
128131 t.Error("expected non-zero memory ID")
129132 }
130133
131- m2, err := s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "Hello!")
134+ m2, err := s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "Hello!", "")
132135 if err != nil {
133136 t.Fatalf("AddMemory() error: %v", err)
134137 }
135138
136- m3, err := s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "Hi there!")
139+ m3, err := s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "Hi there!", "thinking...")
137140 if err != nil {
138141 t.Fatalf("AddMemory() error: %v", err)
139142 }
@@ -146,6 +149,9 @@ func TestMemoryCRUD(t *testing.T) {
146149 if len(memories) != 3 {
147150 t.Errorf("expected 3 memories, got %d", len(memories))
148151 }
152+ if memories[2].Reasoning != "thinking..." {
153+ t.Errorf("expected reasoning=thinking..., got %q", memories[2].Reasoning)
154+ }
149155
150156 // Verify order (chronological)
151157 if memories[0].Role != MemoryRoleSystem {
@@ -188,12 +194,39 @@ func TestMemoryCRUD(t *testing.T) {
188194 _ = m3.ID
189195 }
190196
197+func TestMemoryWithReasoning(t *testing.T) {
198+ s, cleanup := setupStoreTest(t)
199+ defer cleanup()
200+
201+ mysis, err := s.CreateMysis("reasoning-test", "ollama", "llama3", 0.7)
202+ if err != nil {
203+ t.Fatalf("CreateMysis() error: %v", err)
204+ }
205+
206+ reasoning := "Step by step thinking"
207+ _, err = s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "", reasoning)
208+ if err != nil {
209+ t.Fatalf("AddMemory() error: %v", err)
210+ }
211+
212+ memories, err := s.GetMemories(mysis.ID)
213+ if err != nil {
214+ t.Fatalf("GetMemories() error: %v", err)
215+ }
216+ if len(memories) != 1 {
217+ t.Fatalf("expected 1 memory, got %d", len(memories))
218+ }
219+ if memories[0].Reasoning != reasoning {
220+ t.Errorf("expected reasoning=%q, got %q", reasoning, memories[0].Reasoning)
221+ }
222+}
223+
191224 func TestCascadeDelete(t *testing.T) {
192225 s, cleanup := setupStoreTest(t)
193226 defer cleanup()
194227
195- mysis, _ := s.CreateMysis("cascade-test", "ollama", "llama3")
196- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "test message")
228+ mysis, _ := s.CreateMysis("cascade-test", "ollama", "llama3", 0.7)
229+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "test message", "")
197230
198231 // Delete mysis should cascade to memories
199232 if err := s.DeleteMysis(mysis.ID); err != nil {
@@ -219,7 +252,7 @@ func TestUpdateNonExistentMysis(t *testing.T) {
219252 t.Error("expected error updating non-existent mysis")
220253 }
221254
222- err = s.UpdateMysisConfig("nonexistent-id", "ollama", "llama3")
255+ err = s.UpdateMysisConfig("nonexistent-id", "ollama", "llama3", 0.7)
223256 if err == nil {
224257 t.Error("expected error updating non-existent mysis config")
225258 }