feat: LLM episode ranking using SimpleCall

- NewLLMRanker creates a RankStrategy that asks the LLM to rank
  episode summaries by relevance to the query
- Falls back to recency ordering on LLM failure
- Automatic wiring: MemoryManager uses LLM ranker when llc != nil
- Prompt returns comma-separated indices for efficient parsing

Author: jkyberneees

internal/memory/episodes.go

@@ -1,11 +1,13 @@
 package memory
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
 	"sort"
+	"strings"
 	"time"
 )
 
@@ -178,10 +180,73 @@ func truncateForIndex(summary string) string {
 // ── Default ranker ────────────────────────────────────────────────────
 
 // defaultRanker returns all episodes sorted by recency (no LLM).
-// The MemoryManager wraps this with a real SimpleCall when available.
 func defaultRanker(query string, episodes []EpisodeMeta) ([]EpisodeMeta, error) {
-	// Already sorted newest-first by ReadIndex
 	out := make([]EpisodeMeta, len(episodes))
 	copy(out, episodes)
 	return out, nil
 }
+
+// NewLLMRanker creates a RankStrategy that uses an LLM client to rank
+// episodes by semantic relevance to the query. Falls back to recency
+// ordering if the LLM call fails or returns unparseable output.
+func NewLLMRanker(llm LLMClient) RankStrategy {
+	return func(query string, episodes []EpisodeMeta) ([]EpisodeMeta, error) {
+		if len(episodes) == 0 {
+			return episodes, nil
+		}
+
+		// Build a compact prompt listing episodes
+		var b strings.Builder
+		fmt.Fprintf(&b, "Rank these memory summaries by relevance to: %s\n\n", query)
+		for i, ep := range episodes {
+			// Truncate summary for the prompt (already truncated in index, but be safe)
+			summary := ep.Summary
+			if len(summary) > 200 {
+				summary = summary[:197] + "..."
+			}
+			fmt.Fprintf(&b, "[%d] %s\n", i, summary)
+		}
+		b.WriteString("\nReturn only the indices of the most relevant entries, ordered by relevance (most relevant first).\n")
+		b.WriteString("Format: a single line of comma-separated numbers, e.g. \"3,0,1\"\n")
+		b.WriteString("If none are relevant, return \"none\".")
+
+		resp, err := llm.SimpleCall(context.Background(),
+			"You are a relevance ranking system. Given a query and a list of items, return the indices of the most relevant items ordered by relevance. Return only a comma-separated list of numbers or the word 'none'.",
+			b.String(),
+		)
+		if err != nil {
+			return defaultRanker(query, episodes)
+		}
+
+		resp = strings.TrimSpace(resp)
+		if resp == "" || resp == "none" {
+			return nil, nil
+		}
+
+		// Parse "3,0,1" or "3, 0, 1" into indices
+		parts := strings.Split(resp, ",")
+		seen := make(map[int]bool)
+		var ranked []EpisodeMeta
+		for _, p := range parts {
+			p = strings.TrimSpace(p)
+			if p == "" {
+				continue
+			}
+			idx := 0
+			for _, c := range p {
+				if c >= '0' && c <= '9' {
+					idx = idx*10 + int(c-'0')
+				}
+			}
+			if idx >= 0 && idx < len(episodes) && !seen[idx] {
+				ranked = append(ranked, episodes[idx])
+				seen[idx] = true
+			}
+		}
+
+		if len(ranked) == 0 {
+			return defaultRanker(query, episodes)
+		}
+		return ranked, nil
+	}
+}

internal/memory/memory.go

@@ -73,7 +73,12 @@ func NewMemoryManager(memoryDir string, llc LLMClient, cfg MemoryConfig) *Memory
 	episodesDir := memoryDir
 
 	factStore := NewFactStore(factsDir, cfg.FactsLimitUser, cfg.FactsLimitEnv)
-	episodeStore := NewEpisodeStore(episodesDir, nil)
+	// Use LLM-based episode ranker when an LLM client is available
+	var rankFn RankStrategy
+	if llc != nil {
+		rankFn = NewLLMRanker(llc)
+	}
+	episodeStore := NewEpisodeStore(episodesDir, rankFn)
 	mergeDetector := NewMergeDetector(0) // default 256 dims
 
 	return &MemoryManager{