fix: memory system — config wiring, *bool migration, per-turn refresh, LLM merge

Critical fixes:
- overlayFile now passes Memory section through (was silently dropped)
- resolveMemory merges user config onto defaults (partial configs
  no longer zero out all boolean features)
- MemoryConfig bool fields switched to *bool (same pattern as
  FileConfig) to distinguish 'not set' from 'explicitly false'

Behavioral improvements:
- Per-turn memory injection via SetMemoryPromptFunc callback:
  agent sees fresh facts after mutating memory during a session
- mergeEntries now uses LLM for semantic merging, falls back to
  simple concatenation when LLM unavailable
- Memory tool reports updated entries after add/replace/remove
- Consolidate reports actual new entry count instead of '?'
- New 'view' action to read full episode content by session ID

Tests:
- 6 new config tests for memory section merge chain
- 4 new memory tests: view episodes, entries in response,
  LLM merge path, fallback merge
- Full suite passes with -race, memory coverage at 87.3%

Author: jkyberneees

internal/config/loader.go

@@ -597,11 +597,51 @@ func resolveDangerous(cfg *danger.DangerousConfig) danger.DangerousConfig {
 }
 
 // resolveMemory merges file-level memory config with defaults.
+// Starts from DefaultMemoryConfig and overlays any non-zero/non-nil
+// fields from cfg. This means a partial config like {"buffer_lines": 10}
+// won't silently disable all the boolean features.
 func resolveMemory(cfg *memory.MemoryConfig) memory.MemoryConfig {
-	if cfg != nil {
-		return *cfg
+	def := memory.DefaultMemoryConfig()
+	if cfg == nil {
+		return def
+	}
+	if cfg.Enabled != nil {
+		def.Enabled = cfg.Enabled
+	}
+	if cfg.BufferEnabled != nil {
+		def.BufferEnabled = cfg.BufferEnabled
+	}
+	if cfg.MergeOnWrite != nil {
+		def.MergeOnWrite = cfg.MergeOnWrite
+	}
+	if cfg.ExtractOnEnd != nil {
+		def.ExtractOnEnd = cfg.ExtractOnEnd
+	}
+	if cfg.LLMSearch != nil {
+		def.LLMSearch = cfg.LLMSearch
 	}
-	return memory.DefaultMemoryConfig()
+	if cfg.LLMExtract != nil {
+		def.LLMExtract = cfg.LLMExtract
+	}
+	if cfg.LLMConsolidate != nil {
+		def.LLMConsolidate = cfg.LLMConsolidate
+	}
+	if cfg.FactsLimitUser > 0 {
+		def.FactsLimitUser = cfg.FactsLimitUser
+	}
+	if cfg.FactsLimitEnv > 0 {
+		def.FactsLimitEnv = cfg.FactsLimitEnv
+	}
+	if cfg.BufferLines > 0 {
+		def.BufferLines = cfg.BufferLines
+	}
+	if cfg.MergeThreshold > 0 {
+		def.MergeThreshold = cfg.MergeThreshold
+	}
+	if cfg.AddThreshold > 0 {
+		def.AddThreshold = cfg.AddThreshold
+	}
+	return def
 }
 
 // resolveTelegram merges file-level telegram config with defaults.
@@ -719,6 +759,9 @@ func overlayFile(base, override FileConfig) FileConfig {
 	if override.Skills != nil {
 		base.Skills = override.Skills
 	}
+	if override.Memory != nil {
+		base.Memory = override.Memory
+	}
 	if override.Telegram != nil {
 		base.Telegram = override.Telegram
 	}

internal/config/loader_test.go

@@ -4,6 +4,8 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
+
+	"github.com/BackendStack21/kode/internal/memory"
 )
 
 func boolPtr(b bool) *bool { return &b }
@@ -503,3 +505,189 @@ func TestLoadConfig_SkillsLearnCLIDoesNotClobberSkillsConfig(t *testing.T) {
 		t.Errorf("Skills.Curation.StalenessDays = %d, want 30", cfg.Skills.Curation.StalenessDays)
 	}
 }
+
+func TestLoadConfig_MemoryDefaults(t *testing.T) {
+	// When no memory section is configured, the resolved config must have
+	// sensible defaults (Enabled=true, all features on).
+	cfg := LoadConfig(CLIFlags{})
+	mem := cfg.Memory
+	if mem.Enabled == nil || !*mem.Enabled {
+		t.Error("Memory.Enabled should default to true")
+	}
+	if mem.BufferEnabled == nil || !*mem.BufferEnabled {
+		t.Error("Memory.BufferEnabled should default to true")
+	}
+	if mem.MergeOnWrite == nil || !*mem.MergeOnWrite {
+		t.Error("Memory.MergeOnWrite should default to true")
+	}
+	if mem.ExtractOnEnd == nil || !*mem.ExtractOnEnd {
+		t.Error("Memory.ExtractOnEnd should default to true")
+	}
+	if mem.LLMSearch == nil || !*mem.LLMSearch {
+		t.Error("Memory.LLMSearch should default to true")
+	}
+	if mem.LLMExtract == nil || !*mem.LLMExtract {
+		t.Error("Memory.LLMExtract should default to true")
+	}
+	if mem.LLMConsolidate == nil || !*mem.LLMConsolidate {
+		t.Error("Memory.LLMConsolidate should default to true")
+	}
+	if mem.BufferLines != 20 {
+		t.Errorf("Memory.BufferLines = %d, want 20", mem.BufferLines)
+	}
+}
+
+func TestLoadConfig_MemoryFromGlobalFile(t *testing.T) {
+	dir := t.TempDir()
+	prevHome := os.Getenv("HOME")
+	os.Setenv("HOME", dir)
+	defer os.Setenv("HOME", prevHome)
+
+	cfgDir := filepath.Join(dir, ".odek")
+	os.MkdirAll(cfgDir, 0755)
+	cfgPath := filepath.Join(cfgDir, "config.json")
+	if err := os.WriteFile(cfgPath, []byte(`{
+		"memory": {
+			"enabled": true,
+			"facts_limit_user": 800,
+			"buffer_lines": 15,
+			"merge_on_write": false
+		}
+	}`), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	cfg := LoadConfig(CLIFlags{})
+	mem := cfg.Memory
+
+	// Explicitly set values
+	if mem.Enabled == nil || !*mem.Enabled {
+		t.Error("Memory.Enabled should be true (from file)")
+	}
+	if mem.FactsLimitUser != 800 {
+		t.Errorf("Memory.FactsLimitUser = %d, want 800", mem.FactsLimitUser)
+	}
+	if mem.BufferLines != 15 {
+		t.Errorf("Memory.BufferLines = %d, want 15", mem.BufferLines)
+	}
+	if mem.MergeOnWrite == nil || *mem.MergeOnWrite {
+		t.Error("Memory.MergeOnWrite should be false (from file)")
+	}
+
+	// Unset fields must get defaults
+	if mem.ExtractOnEnd == nil || !*mem.ExtractOnEnd {
+		t.Error("Memory.ExtractOnEnd should default to true")
+	}
+	if mem.LLMSearch == nil || !*mem.LLMSearch {
+		t.Error("Memory.LLMSearch should default to true")
+	}
+}
+
+func TestLoadConfig_MemoryProjectOverridesGlobal(t *testing.T) {
+	dir := t.TempDir()
+	prevHome := os.Getenv("HOME")
+	os.Setenv("HOME", dir)
+	defer os.Setenv("HOME", prevHome)
+
+	// Global config with memory section
+	globalDir := filepath.Join(dir, ".odek")
+	os.MkdirAll(globalDir, 0755)
+	if err := os.WriteFile(filepath.Join(globalDir, "config.json"), []byte(`{
+		"memory": {
+			"facts_limit_user": 500,
+			"buffer_lines": 10,
+			"merge_on_write": true
+		}
+	}`), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	// Project config overrides some memory fields
+	cwd, _ := os.Getwd()
+	os.Chdir(dir)
+	defer os.Chdir(cwd)
+
+	if err := os.WriteFile(filepath.Join(dir, "odek.json"), []byte(`{
+		"memory": {
+			"facts_limit_user": 1200,
+			"buffer_lines": 25
+		}
+	}`), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	cfg := LoadConfig(CLIFlags{})
+	mem := cfg.Memory
+
+	// Project overrides
+	if mem.FactsLimitUser != 1200 {
+		t.Errorf("Memory.FactsLimitUser = %d, want 1200 (project overrides global)", mem.FactsLimitUser)
+	}
+	if mem.BufferLines != 25 {
+		t.Errorf("Memory.BufferLines = %d, want 25 (project overrides global)", mem.BufferLines)
+	}
+
+	// Global value preserved (not overridden by project)
+	if mem.MergeOnWrite == nil || !*mem.MergeOnWrite {
+		t.Error("Memory.MergeOnWrite should be true (preserved from global)")
+	}
+
+	// Defaults for fields not set in either file
+	if mem.Enabled == nil || !*mem.Enabled {
+		t.Error("Memory.Enabled should default to true")
+	}
+}
+
+func TestResolveMemoryMergesDefaults(t *testing.T) {
+	// resolveMemory must overlay user config onto DefaultMemoryConfig
+	// so partial configs don't zero out boolean features.
+	cfg := &memory.MemoryConfig{
+		FactsLimitUser: 300,
+		BufferLines:    5,
+	}
+	resolved := resolveMemory(cfg)
+
+	if resolved.FactsLimitUser != 300 {
+		t.Errorf("FactsLimitUser = %d, want 300", resolved.FactsLimitUser)
+	}
+	if resolved.BufferLines != 5 {
+		t.Errorf("BufferLines = %d, want 5", resolved.BufferLines)
+	}
+	// Bool defaults must be preserved
+	if resolved.Enabled == nil || !*resolved.Enabled {
+		t.Error("Enabled should default to true when not explicitly set")
+	}
+	if resolved.ExtractOnEnd == nil || !*resolved.ExtractOnEnd {
+		t.Error("ExtractOnEnd should default to true")
+	}
+}
+
+func TestResolveMemoryExplicitFalse(t *testing.T) {
+	// When user explicitly sets a bool to false, it must stay false.
+	cfg := &memory.MemoryConfig{
+		Enabled: memory.BoolPtr(false),
+	}
+	resolved := resolveMemory(cfg)
+
+	if resolved.Enabled == nil || *resolved.Enabled {
+		t.Error("Enabled should be false when explicitly set to false")
+	}
+	// Other bools still get defaults
+	if resolved.ExtractOnEnd == nil || !*resolved.ExtractOnEnd {
+		t.Error("ExtractOnEnd should default to true")
+	}
+}
+
+func TestLoadConfig_MemoryNotSetReturnsDefaults(t *testing.T) {
+	// When memory key is absent from all config layers, resolveMemory(nil)
+	// must return DefaultMemoryConfig.
+	resolved := resolveMemory(nil)
+	def := memory.DefaultMemoryConfig()
+
+	if resolved.FactsLimitUser != def.FactsLimitUser {
+		t.Errorf("FactsLimitUser = %d, want %d (default)", resolved.FactsLimitUser, def.FactsLimitUser)
+	}
+	if resolved.Enabled == nil || *resolved.Enabled != *def.Enabled {
+		t.Error("Enabled should match default")
+	}
+}

internal/loop/loop.go

@@ -49,15 +49,21 @@ type Engine struct {
 	renderer    *render.Renderer // optional: colored terminal output
 	maxIter     int
 	system      string
-	maxContext  int // max context tokens (0 = no limit)
-	skillLoader SkillLoader // optional: loads matching skills
-	lastSkillMsg string     // last user message that triggered skill loading (dedup)
+	baseSystem  string            // original system message without memory/skills
+	maxContext  int               // max context tokens (0 = no limit)
+	skillLoader SkillLoader       // optional: loads matching skills
+	lastSkillMsg string           // last user message that triggered skill loading (dedup)
 
 	toolEventHandler ToolEventHandler // optional: fires during tool execution
 
 	// iterationCallback is an optional callback fired after each iteration.
 	iterationCallback IterationCallback
 
+	// memoryPromptFunc is called before each LLM invocation to get fresh
+	// memory content. This ensures memory mutations during a session
+	// are visible to the agent on the next turn.
+	memoryPromptFunc func() string
+
 	// PromptCaching enables Anthropic/OpenAI/DeepSeek prompt caching markers.
 	// When enabled, the system prompt and first user message are annotated
 	// with cache_control markers, and the system prompt is moved to the
@@ -92,6 +98,17 @@ func New(client *llm.Client, registry *tool.Registry, maxIterations int, systemM
 // SetSkillLoader sets the optional skill loader callback.
 func (e *Engine) SetSkillLoader(sl SkillLoader) { e.skillLoader = sl }
 
+// SetMemoryPromptFunc sets the optional memory prompt callback.
+// When set, it is called before each LLM invocation to get fresh memory
+// content. This ensures the agent sees the latest facts even if it
+// modifies memory during a session.
+func (e *Engine) SetMemoryPromptFunc(fn func() string) {
+	e.memoryPromptFunc = fn
+	if fn != nil {
+		e.baseSystem = e.system
+	}
+}
+
 // SetToolEventHandler sets the optional tool event callback for live streaming.
 func (e *Engine) SetToolEventHandler(cb ToolEventHandler) { e.toolEventHandler = cb }
 
@@ -307,6 +324,18 @@ func (e *Engine) runLoop(ctx context.Context, messages []llm.Message) (string, [
 			}
 		}
 
+		// Refresh memory content before each LLM call so the agent sees
+		// the latest facts even if it mutated memory during this session.
+		if e.memoryPromptFunc != nil {
+			if memBlock := e.memoryPromptFunc(); memBlock != "" {
+				e.system = e.baseSystem + memBlock
+				// Update messages[0] if it's the system message
+				if len(messages) > 0 && messages[0].Role == "system" {
+					messages[0].Content = e.system
+				}
+			}
+		}
+
 		// THINK (timed)
 		start := time.Now()