@@ -20,8 +20,9 @@
 
 * **Marker items track the boundary.** Each compaction writes the summary into
   the conversation as a recognizable *marker* message (a message whose text
-  starts with ``MARKER_SENTINEL``). The items after the last marker are the
-  recent verbatim turns; the marker texts are the additive summaries. This is
+  starts with ``MARKER_SENTINEL``) recording how many leading items it covers.
+  The items past that count are the recent verbatim turns; the marker texts are
+  the additive summaries. This is
   lightspeed's own bookkeeping — OGX never interprets it (we no longer
   pass ``conversation`` to inference once a marker exists).
 
@@ -42,6 +43,7 @@
 """
 
 import asyncio
+import re
 from collections.abc import AsyncIterator, Sequence
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
@@ -92,6 +94,16 @@
 the model (:func:`_summary_input_message`).
 """
 
+MARKER_COVERS_PREFIX = "[covers:"
+"""Prefix of the item count a marker records, e.g. ``[covers:4]``.
+
+A marker is appended to the end of the conversation, after the turns the
+compaction kept verbatim, so its position does not mark the boundary between
+summarized history and recent turns. The count does: it is how many leading
+conversation items the summary covers (LCORE-4219). Markers written before
+that fix carry no count and fall back to their position.
+"""
+
 
 # Per-conversation locks (R11). A request that triggers compaction holds the
 # conversation's lock across the summarization LLM call so concurrent requests
@@ -197,22 +209,71 @@ def is_marker_item(item: Any) -> bool:
     return extract_message_text(item).startswith(MARKER_SENTINEL)
 
 
+def _split_marker_text(item: Any) -> tuple[Optional[int], str]:
+    """Split a marker item into its covered-item count and its summary text.
+
+    The count is absent on markers written before LCORE-4219; the caller then
+    falls back to the marker's position in the conversation.
+    """
+    body = extract_message_text(item)[len(MARKER_SENTINEL) :].strip()
+    match = re.match(rf"{re.escape(MARKER_COVERS_PREFIX)}(\d+)\]\s*", body)
+    if match is None:
+        return None, body
+    return int(match.group(1)), body[match.end() :]
+
+
 def _summary_text_of(item: Any) -> str:
     """Extract the summary text from a marker item (sentinel stripped)."""
-    return extract_message_text(item)[len(MARKER_SENTINEL) :].strip()
+    return _split_marker_text(item)[1]
 
 
 def _items_after_last_marker(items: list[Any]) -> list[Any]:
-    """Return the conversation items that follow the last summary marker.
+    """Return the conversation items that are not covered by any summary.
+
+    These are the recent turns replayed verbatim. When there is no marker the
+    whole list is returned (no compaction has happened yet).
+
+    A marker records how many leading items its summary covers, because it is
+    appended to the end of the conversation, *after* the turns the compaction
+    deliberately kept verbatim (the buffer). Taking the items that follow the
+    marker's position would drop those turns from every later request
+    (LCORE-4219): they are in no summary and would never reach the model
+    again. Markers written before that fix carry no count, so they keep the
+    old position-based boundary.
 
-    These are the recent turns kept verbatim. When there is no marker the whole
-    list is returned (no compaction has happened yet).
+    Marker items themselves are never part of the result: their text is
+    replayed as a summary, not as a conversation turn.
     """
-    last = -1
+    last_index = -1
+    covered: Optional[int] = None
     for index, item in enumerate(items):
         if is_marker_item(item):
-            last = index
-    return items[last + 1 :]
+            last_index = index
+            covered, _ = _split_marker_text(item)
+    if last_index < 0:
+        return items
+    boundary = covered if covered is not None else last_index + 1
+    return [item for item in items[boundary:] if not is_marker_item(item)]
+
+
+def _covered_item_count(items: list[Any], keep_items: list[Any]) -> int:
+    """Return how many leading items of *items* a new summary covers.
+
+    That is the position of the first kept turn, so the count is a raw index
+    into the stored items, markers included. It cannot be derived by
+    subtracting the kept turns from the total: markers are filtered out of the
+    recent turns, so an older marker may sit among the items being kept, and
+    subtracting would then place the boundary past a turn that is still
+    verbatim (which would drop it, the bug LCORE-4219 fixes). An empty buffer
+    means the summary covers everything stored so far.
+    """
+    if not keep_items:
+        return len(items)
+    first_kept = keep_items[0]
+    for index, item in enumerate(items):
+        if item is first_kept:
+            return index
+    return len(items) - len(keep_items)
 
 
 def _marker_summaries(items: list[Any]) -> list[str]:
@@ -361,16 +422,26 @@ async def _write_summary_marker(
     client: AsyncOgxClient,
     conversation_id: str,
     summary_text: str,
+    covered_items: int,
 ) -> None:
-    """Write the summary into the conversation as a recognizable marker message."""
+    """Write the summary into the conversation as a recognizable marker message.
+
+    ``covered_items`` is how many leading conversation items the summary
+    covers. It is recorded in the marker because the marker is appended to the
+    end of the conversation, after the turns kept verbatim in the buffer, so
+    the marker's own position cannot mark the boundary (LCORE-4219).
+    """
     await client.items.create(
         conversation_id,
         add_items_request=build_add_items_request(
             [
                 {
                     "type": "message",
                     "role": "user",
-                    "content": f"{MARKER_SENTINEL} {summary_text}",
+                    "content": (
+                        f"{MARKER_SENTINEL} {MARKER_COVERS_PREFIX}{covered_items}] "
+                        f"{summary_text}"
+                    ),
                 }
             ]
         ),
@@ -516,8 +587,18 @@ async def _persist_new_summary_chunk(  # pylint: disable=too-many-arguments,too-
     user_id: str,
     skip_user_id_check: bool,
 ) -> None:
-    """Persist a fresh summary chunk: write the OGX marker + best-effort cache."""
-    await _write_summary_marker(client, conversation_id, summary.summary_text)
+    """Persist a fresh summary chunk: write the OGX marker + best-effort cache.
+
+    ``summary.summarized_through_turn`` is the number of leading conversation
+    items the summary covers; it is recorded in the marker so later requests
+    keep replaying the buffered turns (LCORE-4219).
+    """
+    await _write_summary_marker(
+        client,
+        conversation_id,
+        summary.summary_text,
+        summary.summarized_through_turn,
+    )
     _store_cached_summary(cache, user_id, conversation_id, summary, skip_user_id_check)
 
 
@@ -659,12 +740,11 @@ async def apply_compaction(  # pylint: disable=too-many-arguments,too-many-posit
                     encoding_name=encoding_name,
                 )
                 if old_items:
-                    already = len(items) - len(recent_items)
                     summary = await summarize_chunk(
                         client,
                         model,
                         old_items,
-                        summarized_through_turn=already + len(old_items),
+                        summarized_through_turn=_covered_item_count(items, keep_items),
                         encoding_name=encoding_name,
                     )
                     await _persist_new_summary_chunk(
 
@@ -8,14 +8,17 @@ Feature: Conversation compaction
   context window, older turns are summarized before the request reaches
   the model. The compaction fixtures register a 2000-token window with a
   10% threshold and keep one recent turn verbatim, so a long third query
-  is what crosses it: turn one ends up in the summary, turn two stays in
-  the verbatim buffer, and the third query asks for a fact from each.
-  A fourth query states one more fact without summarizing anything (only
-  one turn follows the summary), and the fifth summarizes the long third
-  turn into a second summary. It asks for the datacenter name, which only
-  the first summary holds (the third query asks for the other two names,
-  so its answer never repeats it), so the second summary must not replace
-  the first.
+  is what crosses it first: turn one is summarized, turn two stays in the
+  verbatim buffer, and the third query asks for a fact from each.
+
+  From there every query summarizes the turn that has just fallen out of
+  the buffer, so the fifth query runs against three summaries plus the
+  verbatim fourth turn: the first holds the datacenter name, the second
+  the team name (the turn the third query had kept verbatim), the third
+  the long query itself, and the buffer holds the database name. The
+  fifth query asks for those three names, which no later answer repeats,
+  so it passes only if no summary replaced an earlier one and no
+  buffered turn was dropped on the way (LCORE-4219).
 
   Background:
     Given The service is started locally
@@ -24,7 +27,7 @@ Feature: Conversation compaction
       And the Lightspeed stack configuration directory is "tests/e2e/configuration"
 
 
-  Scenario: the third query crosses the threshold, a second summary keeps the first, recall and history survive
+  Scenario: the third query crosses the threshold, later summaries keep the earlier ones, recall and history survive
     Given The service uses the lightspeed-stack-compaction.yaml configuration
       And the active model has a registered context window
       And The service is restarted
@@ -37,7 +40,7 @@ Feature: Conversation compaction
       And I store conversation details
      When I use "query" to ask question with same conversation_id
      """
-     {"query": "My application namespace is called blue-lagoon. Remember that name too and reply with OK only.", "model": "{MODEL}", "provider": "{PROVIDER}"}
+     {"query": "My application namespace is called blue-lagoon and the team that owns it is called lantern-ops. Remember both names too and reply with OK only.", "model": "{MODEL}", "provider": "{PROVIDER}"}
      """
      Then The status code of the response is 200
       And The response context_status is "full"
@@ -59,20 +62,21 @@ Feature: Conversation compaction
       And The response context_status is "summarized"
      When I use "query" to ask question with same conversation_id
      """
-     {"query": "What is the name of my datacenter and what is the name of my database? Reply with the two names only, separated by a comma.", "model": "{MODEL}", "provider": "{PROVIDER}"}
+     {"query": "What is the name of my datacenter, what is the name of the team that owns my namespace, and what is the name of my database? Reply with the three names only, separated by commas.", "model": "{MODEL}", "provider": "{PROVIDER}"}
      """
      Then The status code of the response is 200
       And The response context_status is "summarized"
       And The response contains following fragments
           | Fragments in LLM response |
           | north-quarry              |
+          | lantern-ops               |
           | green-harbor              |
      When I use REST API conversation endpoint with conversation_id from above using HTTP GET method
      Then The status code of the response is 200
       And The conversation history includes the following user queries
-          | User query                                                                                                                                 |
-          | My OpenShift cluster is named aurora-prod-7 and it runs in the datacenter called north-quarry. Remember both names and reply with OK only. |
-          | My application namespace is called blue-lagoon. Remember that name too and reply with OK only.                                             |
+          | User query                                                                                                                                      |
+          | My OpenShift cluster is named aurora-prod-7 and it runs in the datacenter called north-quarry. Remember both names and reply with OK only.      |
+          | My application namespace is called blue-lagoon and the team that owns it is called lantern-ops. Remember both names too and reply with OK only. |
 
 
   Scenario: the native stream announces compaction on the query that crosses the threshold
 
@@ -14,7 +14,7 @@
 from models.config import CompactionConfiguration
 from models.database.conversations import UserConversation
 from tests.integration.conftest import InMemoryConversationStore
-from utils.conversation_compaction import MARKER_SENTINEL
+from utils.conversation_compaction import MARKER_COVERS_PREFIX, MARKER_SENTINEL
 
 EXISTING_CONV_ID = "22222222-2222-2222-2222-222222222222"
 CONV_ID_LLAMA = f"conv_{EXISTING_CONV_ID}"
@@ -29,11 +29,18 @@ def msg(role: str, text: str) -> OpenAIResponseMessage:
     return OpenAIResponseMessage(role=cast(Any, role), content=text)
 
 
-def marker(text: str) -> OpenAIResponseMessage:
-    """Build a compaction summary marker message."""
+def marker(text: str, covers: int | None = None) -> OpenAIResponseMessage:
+    """Build a compaction summary marker message.
+
+    ``covers`` is the number of leading conversation items the summary covers,
+    which the runtime records in every marker it writes (LCORE-4219). Omit it
+    to build a pre-LCORE-4219 marker, the shape existing conversations still
+    hold; :func:`verify_store_content` ignores the difference.
+    """
+    covers_part = "" if covers is None else f"{MARKER_COVERS_PREFIX}{covers}] "
     return OpenAIResponseMessage(
         role="user",
-        content=f"{MARKER_SENTINEL} {text}",
+        content=f"{MARKER_SENTINEL} {covers_part}{text}",
     )
 
 
@@ -78,6 +85,21 @@ async def collect_items(
     return items
 
 
+def _without_covers(value: Any) -> Any:
+    """Drop a marker's ``[covers:N]`` bookkeeping from message content.
+
+    Markers record how many items their summary covers (LCORE-4219). The
+    number depends on where a conversation stands, so comparisons here are on
+    the summary text; tests that care about the number assert it directly.
+    """
+    if not isinstance(value, str) or not value.startswith(MARKER_SENTINEL):
+        return value
+    body = value[len(MARKER_SENTINEL) :].strip()
+    if not body.startswith(MARKER_COVERS_PREFIX):
+        return value
+    return f"{MARKER_SENTINEL} {body[body.index(']') + 1 :].strip()}"
+
+
 def verify_store_content(
     actual: list[OpenAIResponseMessage], expected: list[OpenAIResponseMessage]
 ) -> bool:
@@ -86,7 +108,8 @@ def verify_store_content(
         return False
 
     return all(
-        getattr(a, field, None) == getattr(b, field, None)
+        _without_covers(getattr(a, field, None))
+        == _without_covers(getattr(b, field, None))
         for a, b in zip(actual, expected)
         for field in ("content", "role", "type")
     )