Checkpoint frontend UI/UX overhaul and ingestion embed benchmark work

apps/ai-service/rag/conversation.py

@@ -87,23 +87,47 @@ class ConversationState:
     summary: str = ""
     focus: Focus = field(default_factory=Focus)
     turn_count: int = 0
+    # Turns evicted from `recent` since the last time `overflow()` was
+    # consumed and cleared (by the caller passing `pending_overflow=()` to
+    # `replace()` after folding them into the summary). NOT derivable from
+    # `recent` alone — `recent` is already capped at `window`, so comparing
+    # its length against `window` can never find anything (see the bug note
+    # on `overflow` below). Plumbing, not conversation content.
+    pending_overflow: tuple[Turn, ...] = ()
 
     def append(self, turn: Turn, window: int = RECENT_TURNS) -> "ConversationState":
         """Adds a turn and evicts the oldest beyond the window.
 
-        Eviction returns the dropped turns to the caller's summariser via
-        `overflow`, rather than discarding them here — this type does not
-        decide what a summary says.
+        Eviction accumulates the dropped turns into `pending_overflow` for
+        the caller's summariser to fold via `overflow()`, rather than
+        discarding them here — this type does not decide what a summary
+        says. Accumulates rather than overwrites because one turn commonly
+        triggers two `append()` calls in a row (user, then assistant); each
+        can evict at most one turn, and the second call must not lose the
+        first's.
         """
-        recent = (*self.recent, turn)[-window:]
+        combined = (*self.recent, turn)
+        recent = combined[-window:]
+        dropped = combined[:-window] if len(combined) > window else ()
         return replace(
             self,
             recent=recent,
             turn_count=self.turn_count + 1,
+            pending_overflow=(*self.pending_overflow, *dropped),
         )
 
-    def overflow(self, window: int = RECENT_TURNS) -> tuple[Turn, ...]:
-        return self.recent[:-window] if len(self.recent) > window else ()
+    def overflow(self) -> tuple[Turn, ...]:
+        """Turns evicted from `recent` and not yet folded into the summary.
+
+        Bug fixed 2026-08-06 (Codex review, F-06): this used to check
+        `len(self.recent) > window`, but `recent` is already truncated to
+        `window` by every `append()` call, so that comparison could never be
+        true — dropped turns were silently discarded and the summariser
+        never received them, no matter how long a conversation ran. The
+        caller must clear `pending_overflow` (pass `pending_overflow=()` to
+        `replace()`) after folding, or the same turns fold again next time.
+        """
+        return self.pending_overflow
 
     def inherited(self, name: str):
         """A focus value only if it is still fresh; otherwise None."""