fix: refuse documents that are not the source's own cut

refresh_source reads len(documents) as the first index the source no longer
uses. That is only true when the documents are that source's entire cut, so
another source's documents — or a filtered slice of this one's — would delete
live chunks and then add documents belonging to something else. IDs are now
checked against chunk_id(source, position) before anything is deleted.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: adityachawla005

packages/moss-chunking/src/ingest.py

@@ -78,6 +78,11 @@ async def refresh_source(
     the add's `MutationResult`, which the caller can wait on in turn — or `None`
     when there was nothing to add.
 
+    `documents` must be `source`'s entire cut, in order — `chunk_document`'s
+    output for that source and nothing else. A mismatched ID raises before
+    anything is deleted, since the whole reconciliation is arithmetic on
+    `len(documents)` and the wrong list would delete live chunks.
+
     Passing no documents deletes every chunk for `source`, which is how a deleted
     file is removed from the index.
 
@@ -86,6 +91,21 @@ async def refresh_source(
     """
     docs = list(documents)
 
+    # Everything below reads `len(docs)` as "the first index this source no
+    # longer uses", which is only true if these documents really are this
+    # source's whole cut. Handed another source's documents, or a filtered slice
+    # of this one's, that arithmetic would delete live chunks and then add
+    # documents that do not belong to `source` — a destructive way to discover a
+    # mistaken argument. `chunk_document` output passes this by construction.
+    for position, doc in enumerate(docs):
+        expected = chunk_id(source, position)
+        if doc.id != expected:
+            raise ValueError(
+                f"documents[{position}] has id {doc.id!r}, expected {expected!r}: "
+                f"refresh_source replaces everything under {source!r}, so it needs "
+                "that source's chunks, all of them, in cut order"
+            )
+
     stale: list[str] = []
     start = len(docs)
     while start <= MAX_CHUNK_INDEX:

packages/moss-chunking/tests/test_ingest.py

@@ -155,6 +155,30 @@ async def test_a_tail_longer_than_one_probe_window_is_still_cleared():
     assert len(deleted(client)) == 599
 
 
+async def test_documents_from_another_source_are_refused_before_anything_is_deleted():
+    """The wrong argument would otherwise be discovered destructively."""
+    client = FakeClient(existing=ids_for("notes.md", 5))
+    docs = [DocumentInfo(id=doc_id, text="fresh") for doc_id in ids_for("other.md", 2)]
+
+    with pytest.raises(ValueError, match="expected 'notes.md#chunk-0000'"):
+        await refresh_source(client, "idx", "notes.md", docs)
+
+    assert client.calls == []
+    assert client.existing == set(ids_for("notes.md", 5))
+
+
+async def test_a_gapped_document_list_is_refused():
+    """A filtered list would make `len(docs)` mean the wrong index."""
+    client = FakeClient(existing=ids_for("notes.md", 5))
+    kept = [chunk_id("notes.md", 0), chunk_id("notes.md", 2)]
+    docs = [DocumentInfo(id=doc_id, text="fresh") for doc_id in kept]
+
+    with pytest.raises(ValueError, match=r"documents\[1\]"):
+        await refresh_source(client, "idx", "notes.md", docs)
+
+    assert client.calls == []
+
+
 def test_the_client_surface_this_module_calls_actually_exists():
     """The fake client above cannot catch a method that the real one lacks.