From 53b63ab45b7567fd946070d0841441a94e6cd8d4 Mon Sep 17 00:00:00 2001
From: Kent Overstreet <kent.overstreet@linux.dev>
Date: Sun, 22 Mar 2026 14:28:03 -0400
Subject: [PATCH] seen_recent: cap at 20 roots total across both seen sets

Budget of 20 roots split between current and prev. Current gets
priority, prev fills the remainder. Prevents flooding the agent
with hundreds of previously surfaced keys.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 poc-memory/src/agents/defs.rs | 42 +++++++++++++++++++++--------------
 1 file changed, 25 insertions(+), 17 deletions(-)

diff --git a/poc-memory/src/agents/defs.rs b/poc-memory/src/agents/defs.rs
index 78cd6a5..155be35 100644
--- a/poc-memory/src/agents/defs.rs
+++ b/poc-memory/src/agents/defs.rs
@@ -520,31 +520,39 @@ fn resolve_seen_recent() -> String {
 
     let mut out = String::new();
 
+    const MAX_ROOTS: usize = 20;
+
     // Current: already in this context, don't re-surface
-    if !current.is_empty() {
+    // Sort newest first, dedup, cap
+    let mut current_sorted = current.clone();
+    current_sorted.sort_by(|a, b| b.0.cmp(&a.0));
+    let mut seen_keys = std::collections::HashSet::new();
+    let current_deduped: Vec<_> = current_sorted.into_iter()
+        .filter(|(_, key)| seen_keys.insert(key.clone()))
+        .take(MAX_ROOTS)
+        .collect();
+
+    if !current_deduped.is_empty() {
         out.push_str("Already surfaced this context (don't re-surface unless conversation shifted):\n");
-        let mut seen = std::collections::HashSet::new();
-        for (ts, key) in &current {
-            if seen.insert(key.clone()) {
-                out.push_str(&format!("- {} (surfaced {})\n", key, ts));
-            }
+        for (ts, key) in &current_deduped {
+            out.push_str(&format!("- {} (surfaced {})\n", key, ts));
         }
     }
 
     // Prev: surfaced before compaction, MAY need re-surfacing
-    if !prev.is_empty() {
-        let current_keys: std::collections::HashSet<_> = current.iter()
-            .map(|(_, k)| k.as_str()).collect();
-        let prev_only: Vec<_> = prev.iter()
-            .filter(|(_, k)| !current_keys.contains(k.as_str()))
+    // Exclude anything already in current, sort newest first, cap at remaining budget
+    let remaining = MAX_ROOTS.saturating_sub(current_deduped.len());
+    if remaining > 0 && !prev.is_empty() {
+        let mut prev_sorted = prev.clone();
+        prev_sorted.sort_by(|a, b| b.0.cmp(&a.0));
+        let prev_deduped: Vec<_> = prev_sorted.into_iter()
+            .filter(|(_, key)| seen_keys.insert(key.clone()))
+            .take(remaining)
             .collect();
-        if !prev_only.is_empty() {
+        if !prev_deduped.is_empty() {
             out.push_str("\nSurfaced before compaction (context was reset — re-surface if still relevant):\n");
-            let mut seen = std::collections::HashSet::new();
-            for (ts, key) in prev_only {
-                if seen.insert(key.clone()) {
-                    out.push_str(&format!("- {} (pre-compaction, {})\n", key, ts));
-                }
+            for (ts, key) in &prev_deduped {
+                out.push_str(&format!("- {} (pre-compaction, {})\n", key, ts));
             }
         }
     }