fix: generation-versioned relation persistence

src/basic_memory/alembic/versions/r1m2n3o4p5q6_add_relation_generation.py

@@ -0,0 +1,95 @@
+"""Add generation ownership to relation projections.
+
+Revision ID: r1m2n3o4p5q6
+Revises: q0l1m2n3o4p5
+Create Date: 2026-08-09 17:00:00.000000
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+
+revision: str = "r1m2n3o4p5q6"
+down_revision: Union[str, None] = "q0l1m2n3o4p5"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Backfill relation rows with their source note's accepted generation."""
+    op.add_column(
+        "relation_search_refresh",
+        sa.Column("publication_generation", sa.BigInteger(), nullable=True),
+    )
+    op.create_index(
+        "ix_relation_search_refresh_project_publication_generation",
+        "relation_search_refresh",
+        ["project_id", "publication_generation"],
+        unique=False,
+    )
+    op.add_column(
+        "relation",
+        sa.Column(
+            "generation",
+            sa.BigInteger(),
+            nullable=False,
+            server_default=sa.text("0"),
+        ),
+    )
+
+    connection = op.get_bind()
+    if connection.dialect.name == "postgresql":
+        op.execute(
+            """
+            UPDATE relation
+            SET generation = note_content.db_version
+            FROM note_content
+            WHERE relation.from_id = note_content.entity_id
+              AND relation.project_id = note_content.project_id
+            """
+        )
+    else:
+        op.execute(
+            """
+            UPDATE relation
+            SET generation = COALESCE(
+                (
+                    SELECT note_content.db_version
+                    FROM note_content
+                    WHERE note_content.entity_id = relation.from_id
+                      AND note_content.project_id = relation.project_id
+                ),
+                0
+            )
+            """
+        )
+
+    op.create_index(
+        "ix_relation_project_from_generation",
+        "relation",
+        ["project_id", "from_id", "generation"],
+        unique=False,
+    )
+
+
+def downgrade() -> None:
+    """Remove relation generation ownership."""
+    op.drop_index("ix_relation_project_from_generation", table_name="relation")
+    if op.get_bind().dialect.name == "postgresql":
+        op.drop_column("relation", "generation")
+    else:
+        with op.batch_alter_table("relation") as batch_op:
+            batch_op.drop_column("generation")
+
+    op.drop_index(
+        "ix_relation_search_refresh_project_publication_generation",
+        table_name="relation_search_refresh",
+    )
+    if op.get_bind().dialect.name == "postgresql":
+        op.drop_column("relation_search_refresh", "publication_generation")
+    else:
+        with op.batch_alter_table("relation_search_refresh") as batch_op:
+            batch_op.drop_column("publication_generation")

src/basic_memory/deps/services.py

@@ -283,6 +283,7 @@ async def get_index_file_executor_v2_external(
         raise RuntimeError("Index file executor requires a project-scoped entity repository")
 
     batch_indexer = BatchIndexer(
+        project_id=project_id,
         app_config=app_config,
         entity_service=entity_service,
         entity_repository=entity_repository,

src/basic_memory/index/local_dependencies.py

@@ -39,6 +39,7 @@
     FileIndexOperation,
     FileIndexResult,
     IndexEntitySearchWriter,
+    IndexedEntity,
     IndexInputFile,
     IndexingBatchResult,
     StorageIndexFileWriter,
@@ -321,21 +322,33 @@ async def index_markdown_file(
                 resolve_relations=True,
                 refresh_unchanged_derived_state=existing is not None,
             )
-            outcome = await self.note_content_reconciler.reconcile(
+            reconciliation = await self.note_content_reconciler.reconcile(
                 entity=synced.entity,
                 markdown_content=synced.markdown_content,
                 observed_at=synced.updated_at,
                 source=source,
                 anchor=anchor,
             )
-            if outcome == "current":
+            # Trigger: the indexed file is older than the accepted DB generation.
+            # Why: retrying identical bytes cannot make that file lineage current.
+            # Outcome: preserve accepted relations and finish without publishing this pass.
+            if reconciliation.status == "deferred":
                 break
 
+            if reconciliation.generation is not None:
+                generation_is_current = await self.publish_relation_generation(
+                    synced,
+                    generation=reconciliation.generation,
+                )
+                if generation_is_current:
+                    break
+
             logger.info(
-                "Retrying markdown index after concurrent accepted note write: {}",
+                "Retrying markdown index without a current relation generation: {}",
                 file_path,
                 entity_id=synced.entity.id,
                 attempt=attempt + 1,
+                reconciliation_status=reconciliation.status,
             )
         else:
             raise NoteContentChangedDuringIndexError(
@@ -428,6 +441,39 @@ async def index_regular_file(
             operation=operation,
         )
 
+    async def publish_relation_generation(
+        self,
+        synced: SyncedMarkdownFile,
+        *,
+        generation: int,
+    ) -> bool:
+        """Publish one claimed relation set, then preserve legacy inline resolution."""
+        indexed = IndexedEntity(
+            path=synced.file_path,
+            entity_id=synced.entity.id,
+            permalink=synced.entity.permalink,
+            checksum=synced.checksum,
+            content_type=synced.content_type,
+            markdown_content=synced.markdown_content,
+            relations=synced.relations,
+            resolve_relations=synced.resolve_relations,
+        )
+        generation_is_current = await self.batch_indexer.publish_relation_generation(
+            indexed,
+            generation=generation,
+        )
+        if generation_is_current and synced.resolve_relations:
+            await self.batch_indexer.resolve_relation_targets(
+                [synced.entity.id],
+                max_concurrent=1,
+            )
+        if generation_is_current:
+            await self.batch_indexer.refresh_indexed_entity_search(
+                indexed,
+                generation=generation,
+            )
+        return generation_is_current
+
     async def index_current_markdown_file(
         self,
         path: RuntimeFilePath,
@@ -488,6 +534,8 @@ async def index_current_markdown_file(
                 content_type=self.file_service.content_type(path),
                 updated_at=file_metadata.modified_at,
                 size=file_metadata.size,
+                relations=(),
+                resolve_relations=resolve_relations,
             )
 
         return await self.index_changed_markdown_file(
@@ -536,6 +584,8 @@ async def refresh_unchanged_markdown_file(
             content_type=self.file_service.content_type(input_file.path),
             updated_at=file_metadata.modified_at,
             size=file_metadata.size,
+            relations=indexed.relations,
+            resolve_relations=resolve_relations,
         )
 
     async def index_changed_markdown_file(
@@ -602,6 +652,8 @@ async def index_changed_markdown_file(
             content_type=self.file_service.content_type(input_file.path),
             updated_at=file_metadata.modified_at,
             size=file_metadata.size,
+            relations=indexed.relations,
+            resolve_relations=resolve_relations,
         )
 
 
@@ -671,6 +723,7 @@ async def build_local_index_project_dependencies(
         app_config=app_config,
     )
     batch_indexer = BatchIndexer(
+        project_id=project.id,
         app_config=app_config,
         entity_service=entity_service,
         entity_repository=entity_repository,