feat: per-turn episode search + 3x memory capacity (Phase 2)

- EpisodeContextFunc: new callback type in loop.Engine, called once per
  new user message to search past session episodes using the user's
  input as a query. Injects relevant summaries as a system message.
  Uses recency-based ranking (no LLM) to avoid recursion.

- FormatEpisodeContext: new method on MemoryManager that searches
  episodes and formats them for injection. Gracefully returns empty
  string when no episodes exist or memory is disabled.

- Memory capacity increased from 4K to 12K chars:
  User facts: 1,500 → 4,000 chars
  Env facts:  2,500 → 8,000 chars

- Wired per-turn episode search in odek.New() alongside the existing
  skill loader and memory refresh callbacks.

This means odek will now automatically recall relevant past sessions
when the user references them — no manual memory(search=...) needed.

Author: molty3000

internal/loop/loop.go

@@ -18,6 +18,12 @@ import (
 // (formatted skill content) to inject, or empty string if no skills match.
 type SkillLoader func(userInput string) string
 
+// EpisodeContextFunc is an optional callback that the loop engine calls
+// before each LLM invocation to discover relevant past session episodes.
+// The callback receives the latest user input as a search query and returns
+// formatted episode context to inject, or empty string if nothing matches.
+type EpisodeContextFunc func(userInput string) string
+
 // ToolEventHandler is an optional callback invoked for each tool execution
 // during the agent loop — fires before (tool_call) and after (tool_result)
 // each tool invocation. Used by the WebUI for live streaming of tool events.
@@ -54,6 +60,7 @@ type Engine struct {
 	skillLoader SkillLoader       // optional: loads matching skills
 	lastSkillMsg string           // last user message that triggered skill loading (dedup)
 	skillVerbose bool             // show full skill banners (default: condensed)
+	episodeCtx   EpisodeContextFunc // optional: per-turn episode search
 
 	toolEventHandler ToolEventHandler // optional: fires during tool execution
 
@@ -99,6 +106,12 @@ 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 }
 
+// SetEpisodeContextFunc sets the optional per-turn episode search callback.
+// When set, it is called once per new user message to search for relevant
+// past session episodes. The returned context is injected as a system
+// message before the LLM invocation.
+func (e *Engine) SetEpisodeContextFunc(ef EpisodeContextFunc) { e.episodeCtx = ef }
+
 // SetSkillVerbose controls whether skill loading shows full banners (true)
 // or condensed markers (false, default). Condensed saves context window space.
 func (e *Engine) SetSkillVerbose(verbose bool) { e.skillVerbose = verbose }
@@ -333,6 +346,29 @@ func (e *Engine) runLoop(ctx context.Context, messages []llm.Message) (string, [
 			}
 		}
 
+		// Search relevant past session episodes based on latest user input.
+		// Only runs once per new user message (same dedup as skill loading).
+		if e.episodeCtx != nil {
+			if userMsg := lastUserMessage(messages); userMsg != "" && userMsg != e.lastSkillMsg {
+				if episodeContext := e.episodeCtx(userMsg); episodeContext != "" {
+					// Inject episode context as a system message before the user message
+					insertIdx := len(messages)
+					for j := len(messages) - 1; j >= 0; j-- {
+						if messages[j].Role == "system" && j != 0 {
+							insertIdx = j + 1
+							break
+						}
+					}
+					epMsg := llm.Message{Role: "system", Content: episodeContext}
+					newMsgs := make([]llm.Message, 0, len(messages)+1)
+					newMsgs = append(newMsgs, messages[:insertIdx]...)
+					newMsgs = append(newMsgs, epMsg)
+					newMsgs = append(newMsgs, messages[insertIdx:]...)
+					messages = newMsgs
+				}
+			}
+		}
+
 		// 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 {

internal/memory/facts.go

@@ -36,8 +36,8 @@ const (
 
 // Default character caps for fact files.
 const (
-	defaultFactsLimitUser = 1500
-	defaultFactsLimitEnv  = 2500
+	defaultFactsLimitUser = 4000
+	defaultFactsLimitEnv  = 8000
 )
 
 // entrySep is the delimiter between entries in a fact file.

internal/memory/facts_test.go

@@ -236,11 +236,11 @@ func TestFactStore_NewFactStoreZeroCaps(t *testing.T) {
 	// Zero caps should use defaults
 	dir := t.TempDir()
 	fs := NewFactStore(dir, 0, 0)
-	if fs.capUser != 1500 {
-		t.Errorf("expected default capUser 1500, got %d", fs.capUser)
+	if fs.capUser != 4000 {
+		t.Errorf("expected default capUser 4000, got %d", fs.capUser)
 	}
-	if fs.capEnv != 2500 {
-		t.Errorf("expected default capEnv 2500, got %d", fs.capEnv)
+	if fs.capEnv != 8000 {
+		t.Errorf("expected default capEnv 8000, got %d", fs.capEnv)
 	}
 }
 

internal/memory/memory.go

@@ -426,6 +426,31 @@ func (m *MemoryManager) SearchEpisodes(query string, limit int) ([]EpisodeMeta,
 	return m.episodes.Search(query, limit)
 }
 
+// FormatEpisodeContext searches episodes with a recency-based ranker
+// (no LLM — safe for per-turn use without recursion risk) and returns
+// formatted context to inject as a system message. Returns empty string
+// if no episodes found or memory is disabled.
+func (m *MemoryManager) FormatEpisodeContext(query string) string {
+	if m.cfg.Enabled == nil || !*m.cfg.Enabled {
+		return ""
+	}
+
+	episodes, err := m.episodes.Search(query, 3)
+	if err != nil || len(episodes) == 0 {
+		return ""
+	}
+
+	var b strings.Builder
+	b.WriteString("\n═══ RELEVANT PAST SESSIONS ═══\n")
+	b.WriteString("Summaries of past sessions related to the current task:\n")
+	for _, ep := range episodes {
+		fmt.Fprintf(&b, "• [%s] (%d turns): %s\n", ep.SessionID, ep.Turns, ep.Summary)
+	}
+	b.WriteString("─────────────────────────────────\n")
+	b.WriteString("Use this context to recall past decisions, fixes, and discussions.\n")
+	return b.String()
+}
+
 // ── System Prompt Builder ────────────────────────────────────────────
 
 // BuildSystemPrompt returns the memory section to inject into the system

odek.go

@@ -520,6 +520,14 @@ func New(cfg Config) (*Agent, error) {
 		engine.SetIterationCallback(cfg.IterationCallback)
 	}
 
+	// Wire per-turn episode search — searches past session episodes
+	// using the user's message as a query, then injects relevant summaries.
+	// Uses recency-based ranking (no LLM) to avoid recursion in the loop.
+	// Only active when memory is enabled.
+	engine.SetEpisodeContextFunc(func(userInput string) string {
+		return memoryManager.FormatEpisodeContext(userInput)
+	})
+
 	agent.engine = engine
 	agent.registry = registry
 	agent.sandboxCleanup = cfg.SandboxCleanup