feat(extended-memory): wire memory LLM resolution and MemoryManager integration

Author: jkyberneees

internal/memory/memory.go

@@ -9,6 +9,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/BackendStack21/odek/internal/memory/extended"
 	"github.com/BackendStack21/odek/internal/session"
 )
 
@@ -102,6 +103,12 @@ type MemoryConfig struct {
 	// See EmbeddingConfig for the "http" provider that enables real
 	// semantic similarity via any OpenAI-compatible embeddings API.
 	Embedding *EmbeddingConfig `json:"embedding,omitempty"`
+
+	// Extended configures the Extended Memory subsystem (atomic facts/
+	// observations extracted from user messages and recalled via semantic
+	// search). nil means "use subsystem defaults"; the subsystem is opt-in
+	// and invisible when Extended.Enabled is false.
+	Extended *extended.Config `json:"extended,omitempty"`
 }
 
 // BoolPtr returns a pointer to a bool value.
@@ -131,6 +138,7 @@ func DefaultMemoryConfig() MemoryConfig {
 		EpisodeDedupThreshold: defaultEpisodeDedupThreshold,
 		MaxEpisodes:           defaultMaxEpisodes,
 		EpisodeTTLDays:        0, // TTL disabled by default
+		Extended:              nil,
 	}
 }
 
@@ -150,6 +158,13 @@ type MemoryManager struct {
 	merge    *MergeDetector
 	llm      LLMClient
 	cfg      MemoryConfig
+	extended *extended.ExtendedMemory
+
+	// extendedContext caches the current session context for user-message
+	// extraction callbacks that arrive without explicit provenance.
+	extSessionID string
+	extProject   string
+	extTurn      int
 
 	// notifier receives memory lifecycle events (facts + episodes). Defaults to
 	// a NoopMemoryNotifier so the fire path is always safe without a nil check.
@@ -230,6 +245,9 @@ func NewMemoryManager(memoryDir string, llc LLMClient, cfg MemoryConfig) *Memory
 	if cfg.Embedding != nil {
 		def.Embedding = cfg.Embedding
 	}
+	if cfg.Extended != nil {
+		def.Extended = cfg.Extended
+	}
 	cfg = def
 
 	factsDir := memoryDir
@@ -281,6 +299,76 @@ func (m *MemoryManager) SetNotifier(n MemoryNotifier) {
 	}
 }
 
+// InitExtended creates the Extended Memory subsystem using the provided
+// dedicated memory LLM client. It is safe to call multiple times; subsequent
+// calls are ignored. Callers should invoke this after NewMemoryManager once
+// the memory LLM has been resolved.
+func (m *MemoryManager) InitExtended(memoryLLM extended.LLMClient, memoryDir string) {
+	if m.extended != nil {
+		return
+	}
+	if m.cfg.Extended == nil {
+		m.cfg.Extended = &extended.Config{}
+	}
+	cfg := extended.Resolve(*m.cfg.Extended)
+	if cfg.Embedding == nil && m.cfg.Embedding != nil {
+		cfg.Embedding = m.cfg.Embedding
+	}
+	if memoryDir == "" {
+		memoryDir = m.facts.dir
+	}
+	extDir := filepath.Join(memoryDir, "extended")
+	m.extended = extended.New(extDir, memoryLLM, cfg)
+}
+
+// OnUserMessage routes a user message to Extended Memory for atom extraction.
+func (m *MemoryManager) OnUserMessage(ctx extended.AtomContext, msg string) {
+	if m.extended == nil {
+		return
+	}
+	m.extended.OnUserMessage(ctx, msg)
+}
+
+// FormatExtendedContext returns ranked Extended Memory context for the query.
+func (m *MemoryManager) FormatExtendedContext(query string) string {
+	if m.extended == nil {
+		return ""
+	}
+	return m.extended.FormatExtendedContext(query)
+}
+
+// SetSessionContext propagates session/project identifiers to all memory tiers
+// that need them (currently Extended Memory).
+func (m *MemoryManager) SetSessionContext(sessionID, project string) {
+	m.extSessionID = sessionID
+	m.extProject = project
+	if m.extended != nil {
+		m.extended.SetSessionContext(sessionID, project)
+	}
+}
+
+// OnUserMessageLoop routes a user message to Extended Memory using the
+// session context previously set via SetSessionContext. It is the callback
+// used by the agent loop to trigger atom extraction when a new user message
+// arrives.
+func (m *MemoryManager) OnUserMessageLoop(msg string) {
+	if m.extended == nil {
+		return
+	}
+	m.extTurn++
+	ctx := extended.AtomContext{
+		SessionID: m.extSessionID,
+		Project:   m.extProject,
+		Turn:      m.extTurn,
+	}
+	m.extended.OnUserMessage(ctx, msg)
+}
+
+// Extended returns the Extended Memory subsystem, or nil if not initialized.
+func (m *MemoryManager) Extended() *extended.ExtendedMemory {
+	return m.extended
+}
+
 // notify fires an event on the configured notifier, stamping the UTC timestamp
 // when the caller left it zero. Safe even before SetNotifier (nil → no-op).
 func (m *MemoryManager) notify(ev MemoryEvent) {

odek.go

@@ -31,6 +31,7 @@ import (
 	"github.com/BackendStack21/odek/internal/llm"
 	"github.com/BackendStack21/odek/internal/loop"
 	"github.com/BackendStack21/odek/internal/memory"
+	"github.com/BackendStack21/odek/internal/memory/extended"
 	"github.com/BackendStack21/odek/internal/narrate"
 	"github.com/BackendStack21/odek/internal/render"
 	"github.com/BackendStack21/odek/internal/skills"
@@ -519,6 +520,15 @@ func New(cfg Config) (*Agent, error) {
 	}
 	memoryManager := memory.NewMemoryManager(memoryDir, client, cfg.MemoryConfig)
 
+	// Resolve a dedicated LLM for Extended Memory. Falls back to the main agent
+	// LLM when not configured; warns if the main model has thinking enabled
+	// because reasoning tokens are wasted on memory-only calls.
+	var memoryLLM extended.LLMClient = client
+	if cfg.MemoryConfig.Extended != nil {
+		memoryLLM = extended.ResolveLLM(*cfg.MemoryConfig.Extended, client, cfg.Thinking)
+	}
+	memoryManager.InitExtended(memoryLLM, memoryDir)
+
 	// Wire memory lifecycle observability: fan out events to the programmatic
 	// handler (WebUI/Telegram/embedders) and the terminal renderer. Mirrors the
 	// skills notifier pattern so memory activity is no longer silent.
@@ -650,6 +660,24 @@ func New(cfg Config) (*Agent, error) {
 		return memoryManager.FormatEpisodeContext(userInput)
 	})
 
+	// Wire per-turn Extended Memory search. Injected after the legacy memory
+	// prompt block so recent facts/buffer take precedence.
+	engine.SetExtendedMemoryContextFunc(func(userInput string) string {
+		return memoryManager.FormatExtendedContext(userInput)
+	})
+
+	// Notify memory manager when a new user message arrives so Extended Memory
+	// can extract atomic facts/preferences.
+	engine.SetUserMessageHandler(func(msg string) {
+		memoryManager.OnUserMessageLoop(msg)
+	})
+
+	// Wire per-turn Extended Memory search. Injected after the legacy memory
+	// prompt block so recent facts/buffer take precedence.
+	engine.SetExtendedMemoryContextFunc(func(userInput string) string {
+		return memoryManager.FormatExtendedContext(userInput)
+	})
+
 	agent.engine = engine
 	agent.registry = registry
 	agent.sandboxCleanup = cfg.SandboxCleanup