From c1e62877aec54e4cd51f730a6e5317ea25d32491 Mon Sep 17 00:00:00 2001
From: Edwin Jose <edwin.jose@datastax.com>
Date: Wed, 21 Oct 2026 13:55:17 -0500
Subject: [PATCH 1/4] fix: keep interrupted Langflow streams owned and
 resumable (#2527)

* fix: persist Langflow session ownership before streaming IDs

* style: ruff autofix (auto)

* fix: persist session aliases and require durable ownership claims

* style: ruff autofix (auto)

* style: apply CI Ruff fixes for session persistence

* fix: remove unused session ownership imports

* fix: type SQLModel column expressions for CI mypy

---------

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
(cherry picked from commit 93a3ad15d402937541e2fe0d3525a9f44c2a7904)
---
 .../versions/0008_session_conversation_id.py  |  27 +
 docs/docs/core-components/chat.mdx            |  20 +
 src/agent.py                                  | 232 +++++---
 src/db/migrations_runtime.py                  |   1 +
 src/db/models/session_ownership.py            |   2 +
 src/db/repositories/permission_repo.py        |   9 +-
 src/db/repositories/session_ownership_repo.py |  44 +-
 src/services/chat_service.py                  |  17 +-
 .../conversation_persistence_service.py       |  57 +-
 src/services/session_ownership_service.py     | 205 ++++++-
 .../migrations/test_chat_history_migration.py | 139 +++--
 .../test_session_ownership_service_modes.py   | 218 ++++++-
 .../unit/test_agent_stream_fence_stripped.py  |   3 +
 .../test_langflow_stream_provider_errors.py   | 542 +++++++++++++++++-
 14 files changed, 1300 insertions(+), 216 deletions(-)
 create mode 100644 alembic/versions/0008_session_conversation_id.py

diff --git a/alembic/versions/0008_session_conversation_id.py b/alembic/versions/0008_session_conversation_id.py
new file mode 100644
index 0000000000..a28a6a34d1
--- /dev/null
+++ b/alembic/versions/0008_session_conversation_id.py
@@ -0,0 +1,27 @@
+"""Persist canonical conversation IDs for session aliases.
+
+Revision ID: 0008_session_conversation_id
+Revises: 0007_add_knowledge_delete_anonymous
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "0008_session_conversation_id"
+down_revision = "0007_add_knowledge_delete_anonymous"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column("session_ownership", sa.Column("conversation_id", sa.String(64), nullable=True))
+    op.create_index(
+        "ix_session_ownership_conversation_id", "session_ownership", ["conversation_id"]
+    )
+    op.execute("UPDATE session_ownership SET conversation_id = response_id")
+
+
+def downgrade() -> None:
+    op.drop_index("ix_session_ownership_conversation_id", table_name="session_ownership")
+    op.drop_column("session_ownership", "conversation_id")
diff --git a/docs/docs/core-components/chat.mdx b/docs/docs/core-components/chat.mdx
index 6ee554d9c7..91255de7c4 100644
--- a/docs/docs/core-components/chat.mdx
+++ b/docs/docs/core-components/chat.mdx
@@ -22,6 +22,26 @@ To add or change the available tools, you must edit the [**OpenRAG OpenSearch Ag
 Try chatting, uploading documents, and modifying chat settings in the [quickstart](/quickstart).
 :::
 
+## Interrupted chat responses
+
+If you stop a response or the connection closes while an answer is streaming, OpenRAG retains ownership of response IDs already sent to your client.
+You can send a follow-up in the same conversation without losing access solely because the previous stream was interrupted.
+The backend keeps the partial answer in the active conversation and records the updated conversation metadata when the stream is closed.
+An interrupted answer is not automatically regenerated, and ingestion or other tool calls are not automatically replayed.
+
+For API clients, `conversation_id` identifies the OpenRAG sidebar thread, while `previous_response_id` continues the Langflow session.
+These IDs can differ when Langflow returns a new response ID.
+Both IDs are checked against the authenticated user's session ownership; interruption recovery does not bypass those checks.
+
+Response aliases are durably associated with their canonical conversation, including across backend restarts.
+Deleting a conversation revokes its canonical ID and all recorded aliases and attempts to remove every associated Langflow session.
+A deleted alias cannot be used to resume the conversation.
+
+IDs are sent only after ownership and its conversation association have been persisted.
+In `files` mode this requires a successful file write; in `db` mode it requires a committed database write.
+In `hybrid` mode the database is preferred, with a successful durable JSON write as fallback if the database is unavailable.
+If neither configured destination can persist the claim, the stream returns an error without exposing a new response ID; an in-memory cache entry is not sufficient.
+
 ## OpenRAG OpenSearch Agent flow {#flow}
 
 When you use the OpenRAG <Icon name="MessageSquare" aria-hidden="true"/> **Chat**, the **OpenRAG OpenSearch Agent** flow runs in the background to retrieve relevant information from your knowledge base and generate a response.
diff --git a/src/agent.py b/src/agent.py
index 4e01c9f8b8..8172039af6 100644
--- a/src/agent.py
+++ b/src/agent.py
@@ -1,6 +1,10 @@
+import asyncio
 import uuid
+from contextlib import aclosing
 from typing import Any
 
+import anyio
+
 from config.config_manager import DEFAULT_SYSTEM_PROMPT
 from services.conversation_persistence_service import conversation_persistence
 from utils.langflow_utils import parse_knowledge_chunks, strip_untrusted_fence_recursive
@@ -91,13 +95,10 @@ async def _persist_error_conversation(
 
     from services.session_ownership_service import session_ownership_service
 
+    if not await session_ownership_service.claim_session(user_id, store_id):
+        raise RuntimeError("Unable to establish chat session ownership")
     conversation_state["last_activity"] = datetime.now()
     await store_conversation_thread(user_id, store_id, conversation_state)
-    try:
-        await session_ownership_service.claim_session(user_id, store_id)
-        logger.debug(f"Claimed session {store_id} for user {user_id} after stream error")
-    except Exception as e:
-        logger.warning(f"Failed to claim session ownership after stream error: {e}")
 
 
 def _stream_error_chunk(message: str, response_id: str | None = None) -> bytes:
@@ -228,6 +229,7 @@ async def async_response_stream(
 ):
     logger.info("User prompt received", prompt=prompt)
 
+    response = None
     try:
         # Build request parameters
         request_params = {
@@ -422,6 +424,10 @@ async def async_response_stream(
     except Exception:
         logger.exception("[AGENT] Streaming failed")
         raise
+    finally:
+        if response is not None:
+            with anyio.CancelScope(shield=True):
+                await response.close()
 
 
 # Generic async response function for non-streaming
@@ -494,15 +500,18 @@ async def async_stream(
     previous_response_id: str = None,
     log_prefix: str = "response",
 ):
-    async for chunk in async_response_stream(
-        client,
-        prompt,
-        model,
-        extra_headers=extra_headers,
-        previous_response_id=previous_response_id,
-        log_prefix=log_prefix,
-    ):
-        yield chunk
+    async with aclosing(
+        async_response_stream(
+            client,
+            prompt,
+            model,
+            extra_headers=extra_headers,
+            previous_response_id=previous_response_id,
+            log_prefix=log_prefix,
+        )
+    ) as stream:
+        async for chunk in stream:
+            yield chunk
 
 
 # Async langflow function (non-streaming only)
@@ -718,6 +727,7 @@ async def async_chat_stream(
             await _persist_error_conversation(user_id, store_id, conversation_state)
         except Exception as store_error:
             logger.error(f"Failed to store error conversation: {store_error}")
+            store_id = None
         yield _stream_error_chunk(display_text, store_id)
 
 
@@ -850,18 +860,13 @@ async def async_langflow_chat(
 
     # Store the conversation thread with its response_id
     if response_id:
+        from services.session_ownership_service import session_ownership_service
+
+        if not await session_ownership_service.claim_session(user_id, response_id):
+            raise RuntimeError("Unable to establish chat session ownership")
         conversation_state["last_activity"] = datetime.now()
         await store_conversation_thread(user_id, response_id, conversation_state)
 
-        # Claim session ownership for this user
-        try:
-            from services.session_ownership_service import session_ownership_service
-
-            await session_ownership_service.claim_session(user_id, response_id)
-            logger.debug(f"Claimed session {response_id} for user {user_id}")
-        except Exception as e:
-            logger.warning(f"Failed to claim session ownership: {e}")
-
         logger.debug(
             "Stored langflow conversation thread",
             user_id=user_id,
@@ -894,6 +899,16 @@ async def async_langflow_chat_stream(
     # conversation_id keeps the OpenRAG sidebar thread; previous_response_id chains
     # the Langflow session. After errors the client omits previous_response_id.
     thread_id = conversation_id or previous_response_id
+    if not _conversation_thread_in_memory(user_id, thread_id):
+        # Clients may continue using the latest Langflow id without a sidebar id.
+        thread_id = next(
+            (
+                stored_id
+                for stored_id, state in active_conversations.get(user_id, {}).items()
+                if thread_id and thread_id in state.get("response_ids", [])
+            ),
+            thread_id,
+        )
     previous_loaded_from_memory = _conversation_thread_in_memory(user_id, thread_id)
     conversation_state = get_conversation_thread(user_id, thread_id)
 
@@ -915,30 +930,74 @@ async def async_langflow_chat_stream(
     usage_data = None
     collected_chunks = []  # Store all chunks for function call data
     error_occurred = False
+    store_id = None
+    claimed_ids: set[str] = set()
+    turn_finished = False
+
+    async def persist_stream_state(*session_ids, mint_if_missing=False):
+        nonlocal store_id
+        from services.session_ownership_service import session_ownership_service
+
+        if store_id is None:
+            store_id = _resolve_conversation_store_id(
+                response_id,
+                thread_id,
+                previous_loaded_from_memory=previous_loaded_from_memory,
+                mint_if_missing=mint_if_missing,
+            )
+        if store_id is None:
+            return
+        for session_id in dict.fromkeys((store_id, *session_ids)):
+            if not session_id or session_id in claimed_ids:
+                continue
+            if not await session_ownership_service.claim_session(
+                user_id, session_id, conversation_id=store_id
+            ):
+                raise RuntimeError("Unable to establish chat session ownership")
+            claimed_ids.add(session_id)
+            response_ids = conversation_state.setdefault("response_ids", [])
+            if session_id not in response_ids:
+                response_ids.append(session_id)
+        conversation_state["last_activity"] = datetime.now()
+        await store_conversation_thread(user_id, store_id, conversation_state)
+
+    upstream = async_stream(
+        langflow_client,
+        prompt,
+        flow_id,
+        extra_headers=extra_headers,
+        previous_response_id=langflow_previous_response_id,
+        log_prefix="langflow",
+    )
 
     try:
-        async for chunk in async_stream(
-            langflow_client,
-            prompt,
-            flow_id,
-            extra_headers=extra_headers,
-            previous_response_id=langflow_previous_response_id,
-            log_prefix="langflow",
-        ):
+        async for chunk in upstream:
             # Extract text content to build full response for history
+            chunk_ids = []
             try:
                 import json
 
                 chunk_data = json.loads(chunk.decode("utf-8"))
                 collected_chunks.append(chunk_data)  # Collect all chunk data
 
+                # Own every response/session ID callers can use for continuation,
+                # not tool item IDs. OpenAI events may nest the ID in response.
+                response_obj = chunk_data.get("response")
+                if not isinstance(response_obj, dict):
+                    response_obj = {}
+                chunk_ids = [
+                    value
+                    for value in (
+                        chunk_data.get("id"),
+                        chunk_data.get("response_id"),
+                        response_obj.get("id"),
+                    )
+                    if isinstance(value, str) and value
+                ]
+                if chunk_ids:
+                    response_id = chunk_ids[0]
                 if "delta" in chunk_data and "content" in chunk_data["delta"]:
                     full_response += chunk_data["delta"]["content"]
-                # Extract response_id from chunk
-                if "id" in chunk_data:
-                    response_id = chunk_data["id"]
-                elif "response_id" in chunk_data:
-                    response_id = chunk_data["response_id"]
 
                 # Check for error status. Do not forward bare Langflow error
                 # chunks — they often lack a useful message and the client would
@@ -972,6 +1031,10 @@ async def async_langflow_chat_stream(
                     usage_data = response_obj.get("usage")
             except Exception:
                 pass
+            # This await must stay outside the permissive JSON parser above.
+            # Persist/claim BEFORE yielding the first occurrence of any ID.
+            if any(session_id not in claimed_ids for session_id in chunk_ids):
+                await persist_stream_state(*chunk_ids)
             yield chunk
 
         from api.provider_validation import (
@@ -994,16 +1057,8 @@ async def async_langflow_chat_stream(
                     "error": True,
                 }
             )
-            store_id = _resolve_conversation_store_id(
-                response_id,
-                thread_id,
-                previous_loaded_from_memory=previous_loaded_from_memory,
-                mint_if_missing=True,
-            )
-            try:
-                await _persist_error_conversation(user_id, store_id, conversation_state)
-            except Exception as store_error:
-                logger.error(f"Failed to store error conversation: {store_error}")
+            turn_finished = True
+            await persist_stream_state(response_id, mint_if_missing=True)
             yield _stream_error_chunk(display_text, store_id)
             return
 
@@ -1020,20 +1075,29 @@ async def async_langflow_chat_stream(
                 assistant_message["response_data"] = {"usage": usage_data}
             conversation_state["messages"].append(assistant_message)
 
-        persist_id = _resolve_conversation_store_id(
-            response_id,
-            thread_id,
-            previous_loaded_from_memory=previous_loaded_from_memory,
-        )
-        if persist_id:
-            conversation_state["last_activity"] = datetime.now()
-            await store_conversation_thread(user_id, persist_id, conversation_state)
+        turn_finished = True
+        await persist_stream_state(response_id)
+    except (asyncio.CancelledError, GeneratorExit):
+        # Disconnects do not run the normal tail and are not provider failures.
+        # Keep exactly one partial assistant turn and propagate cancellation;
+        # never replay the prompt or synthesize a terminal event to a dead client.
+        with anyio.CancelScope(shield=True):
+            if not turn_finished and full_response:
+                conversation_state["messages"].append(
+                    {
+                        "role": "assistant",
+                        "content": full_response,
+                        "response_id": response_id,
+                        "timestamp": datetime.now(),
+                        "chunks": collected_chunks,
+                        "interrupted": True,
+                    }
+                )
             try:
-                from services.session_ownership_service import session_ownership_service
-
-                await session_ownership_service.claim_session(user_id, persist_id)
-            except Exception as e:
-                logger.warning(f"Failed to claim session ownership: {e}")
+                await persist_stream_state(response_id)
+            except Exception:
+                logger.exception("Failed to store interrupted Langflow turn")
+        raise
     except Exception as e:
         logger.error(f"Error in langflow chat stream: {e}", exc_info=True)
         from api.provider_validation import resolve_chat_stream_error_message_async
@@ -1051,17 +1115,16 @@ async def async_langflow_chat_stream(
                 "error": True,
             }
         )
-        store_id = _resolve_conversation_store_id(
-            response_id,
-            thread_id,
-            previous_loaded_from_memory=previous_loaded_from_memory,
-            mint_if_missing=True,
-        )
+        error_store_id = None
         try:
-            await _persist_error_conversation(user_id, store_id, conversation_state)
+            await persist_stream_state(response_id, mint_if_missing=True)
+            error_store_id = store_id
         except Exception as store_error:
             logger.error(f"Failed to store error conversation: {store_error}")
-        yield _stream_error_chunk(display_text, store_id)
+        yield _stream_error_chunk(display_text, error_store_id)
+    finally:
+        with anyio.CancelScope(shield=True):
+            await upstream.aclose()
 
 
 async def delete_user_conversation(user_id: str, response_id: str) -> bool:
@@ -1075,31 +1138,18 @@ async def delete_user_conversation(user_id: str, response_id: str) -> bool:
         Exception — on unexpected storage errors so callers can distinguish
                     a confirmed "not found" from a backend failure.
     """
-    deleted = False
-
-    # Delete from in-memory storage (cannot raise)
-    if user_id in active_conversations and response_id in active_conversations[user_id]:
-        del active_conversations[user_id][response_id]
-        logger.debug(f"Deleted conversation {response_id} from memory for user {user_id}")
-        deleted = True
+    from services.session_ownership_service import session_ownership_service
 
-    # Delete from persistent storage — let real errors propagate to the caller
-    conversation_deleted = await conversation_persistence.delete_conversation_thread(
-        user_id, response_id
-    )
-    if conversation_deleted:
-        logger.debug(
-            f"Deleted conversation {response_id} from persistent storage for user {user_id}"
-        )
+    session_ids = await session_ownership_service.get_conversation_sessions(user_id, response_id)
+    if not session_ids:
+        return False
+    canonical_id = session_ids[0]
+    # Revoke ALL durable aliases before removing the local index. Failures must
+    # reach the caller, not turn into a successful delete with reusable IDs.
+    await session_ownership_service.release_conversation_sessions(user_id, session_ids)
+    deleted = await conversation_persistence.delete_conversation_thread(user_id, canonical_id)
+    if canonical_id in active_conversations.get(user_id, {}):
+        del active_conversations[user_id][canonical_id]
         deleted = True
 
-    # Release session ownership (best-effort; never masks storage errors above)
-    try:
-        from services.session_ownership_service import session_ownership_service
-
-        await session_ownership_service.release_session(user_id, response_id)
-        logger.debug(f"Released session ownership for {response_id} for user {user_id}")
-    except Exception as e:
-        logger.warning(f"Failed to release session ownership: {e}")
-
     return deleted
diff --git a/src/db/migrations_runtime.py b/src/db/migrations_runtime.py
index 489601288b..659a9b0d2f 100644
--- a/src/db/migrations_runtime.py
+++ b/src/db/migrations_runtime.py
@@ -232,6 +232,7 @@ async def migrate_chat_history_json_to_db(session: AsyncSession) -> dict[str, in
                 user_id=str(uid),
                 created_at=created,
                 last_accessed=last,
+                conversation_id=data.get("conversation_id") or str(sid),
             )
             if inserted:
                 stats["sessions_inserted"] += 1
diff --git a/src/db/models/session_ownership.py b/src/db/models/session_ownership.py
index eebc6d83a1..204fcb960b 100644
--- a/src/db/models/session_ownership.py
+++ b/src/db/models/session_ownership.py
@@ -19,5 +19,7 @@ class SessionOwnership(SQLModel, table=True):
 
     response_id: str = Field(primary_key=True, max_length=64)
     user_id: str = Field(max_length=64, index=True)
+    # Null legacy rows are their own canonical conversation.
+    conversation_id: str | None = Field(default=None, max_length=64, index=True)
     created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
     last_accessed: datetime | None = Field(default=None)
diff --git a/src/db/repositories/permission_repo.py b/src/db/repositories/permission_repo.py
index 2b899140b3..1a9e570c57 100644
--- a/src/db/repositories/permission_repo.py
+++ b/src/db/repositories/permission_repo.py
@@ -1,7 +1,6 @@
-from typing import Optional
-
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import col
 
 from db.models import Permission
 
@@ -16,8 +15,6 @@ async def list_all(self) -> list[Permission]:
         )
         return list(result.scalars().all())
 
-    async def get_by_name(self, name: str) -> Optional[Permission]:
-        result = await self.session.execute(
-            select(Permission).where(Permission.name == name)
-        )
+    async def get_by_name(self, name: str) -> Permission | None:
+        result = await self.session.execute(select(Permission).where(col(Permission.name) == name))
         return result.scalar_one_or_none()
diff --git a/src/db/repositories/session_ownership_repo.py b/src/db/repositories/session_ownership_repo.py
index 93baef94de..44b6bbd521 100644
--- a/src/db/repositories/session_ownership_repo.py
+++ b/src/db/repositories/session_ownership_repo.py
@@ -1,10 +1,10 @@
 """Async CRUD over the ``session_ownership`` table."""
 
 from datetime import UTC, datetime
-from typing import Optional
 
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import col
 
 from db.models import SessionOwnership
 
@@ -13,29 +13,37 @@ class SessionOwnershipRepo:
     def __init__(self, session: AsyncSession):
         self.session = session
 
-    async def get(self, response_id: str) -> Optional[SessionOwnership]:
+    async def get(self, response_id: str) -> SessionOwnership | None:
         return await self.session.get(SessionOwnership, response_id)
 
     async def claim(
-        self, response_id: str, user_id: str
+        self, response_id: str, user_id: str, conversation_id: str | None = None
     ) -> SessionOwnership:
-        """Idempotent claim. If the row exists, only update last_accessed
-        — never silently re-assign ownership (that would be a security
-        bug). The caller is responsible for ensuring the user_id matches
-        the existing owner before calling this for an existing row.
-        """
+        """Claim without transferring ownership or moving an existing alias."""
         existing = await self.get(response_id)
         now = datetime.now(UTC)
+        canonical_id = conversation_id or response_id
+        if canonical_id != response_id:
+            canonical = await self.get(canonical_id)
+            if canonical is None or canonical.user_id != user_id:
+                raise PermissionError("Conversation is not owned by this user")
+        if existing is not None and (
+            existing.user_id != user_id
+            or (existing.conversation_id is not None and existing.conversation_id != canonical_id)
+        ):
+            raise PermissionError("Session ownership or conversation conflict")
         if existing is None:
             row = SessionOwnership(
                 response_id=response_id,
                 user_id=user_id,
+                conversation_id=canonical_id,
                 created_at=now,
                 last_accessed=now,
             )
             self.session.add(row)
             await self.session.flush()
             return row
+        existing.conversation_id = canonical_id
         existing.last_accessed = now
         self.session.add(existing)
         await self.session.flush()
@@ -43,8 +51,18 @@ async def claim(
 
     async def list_for_user(self, user_id: str) -> list[str]:
         result = await self.session.execute(
-            select(SessionOwnership.response_id).where(
-                SessionOwnership.user_id == user_id
+            select(col(SessionOwnership.response_id)).where(
+                col(SessionOwnership.user_id) == user_id
+            )
+        )
+        return list(result.scalars().all())
+
+    async def list_for_conversation(self, conversation_id: str, user_id: str) -> list[str]:
+        result = await self.session.execute(
+            select(col(SessionOwnership.response_id)).where(
+                col(SessionOwnership.user_id) == user_id,
+                (col(SessionOwnership.conversation_id) == conversation_id)
+                | (col(SessionOwnership.response_id) == conversation_id),
             )
         )
         return list(result.scalars().all())
@@ -66,8 +84,9 @@ async def upsert_raw(
         self,
         response_id: str,
         user_id: str,
-        created_at: Optional[datetime] = None,
-        last_accessed: Optional[datetime] = None,
+        created_at: datetime | None = None,
+        last_accessed: datetime | None = None,
+        conversation_id: str | None = None,
     ) -> bool:
         """Used by the runtime migration to copy JSON rows verbatim
         without overwriting timestamps. Returns True when a row was inserted."""
@@ -77,6 +96,7 @@ async def upsert_raw(
         row = SessionOwnership(
             response_id=response_id,
             user_id=user_id,
+            conversation_id=conversation_id or response_id,
             created_at=created_at or datetime.now(UTC),
             last_accessed=last_accessed,
         )
diff --git a/src/services/chat_service.py b/src/services/chat_service.py
index dec8501cfc..7b139cc48e 100644
--- a/src/services/chat_service.py
+++ b/src/services/chat_service.py
@@ -933,8 +933,20 @@ async def get_langflow_history(self, user_id: str):
     async def delete_session(self, user_id: str, session_id: str):
         """Delete a session from both local storage and Langflow"""
         try:
-            # Delete from local conversation storage
+            # Resolve the complete, owned group before removing any associations.
             from agent import delete_user_conversation
+            from services.session_ownership_service import session_ownership_service
+
+            session_ids = await session_ownership_service.get_conversation_sessions(
+                user_id, session_id
+            )
+
+            # Attempt every upstream deletion first: local revocation failures
+            # must not erase JSON-only aliases before their cleanup is attempted.
+            upstream_results = [
+                await self._delete_langflow_session(owned_id) for owned_id in session_ids
+            ]
+            langflow_deleted = bool(upstream_results) and all(upstream_results)
 
             local_deleted = await delete_user_conversation(user_id, session_id)
 
@@ -945,9 +957,6 @@ async def delete_session(self, user_id: str, session_id: str):
                     "error": "Conversation not found",
                 }
 
-            # Delete from Langflow using the monitor API (best-effort)
-            langflow_deleted = await self._delete_langflow_session(session_id)
-
             return {
                 "success": True,
                 "local_deleted": local_deleted,
diff --git a/src/services/conversation_persistence_service.py b/src/services/conversation_persistence_service.py
index bc028ec4cc..0570df59be 100644
--- a/src/services/conversation_persistence_service.py
+++ b/src/services/conversation_persistence_service.py
@@ -19,8 +19,9 @@
 import json
 import os
 import threading
+from collections.abc import Callable
 from datetime import datetime
-from typing import Any, Callable, Dict, Optional
+from typing import Any
 
 from config.paths import get_data_file
 from config.storage_mode import (
@@ -38,23 +39,23 @@ class ConversationPersistenceService:
 
     def __init__(
         self,
-        storage_file: Optional[str] = None,
-        session_factory: Optional[Callable] = None,
+        storage_file: str | None = None,
+        session_factory: Callable | None = None,
     ):
         self.storage_file = storage_file or get_data_file("conversations.json")
         os.makedirs(os.path.dirname(self.storage_file), exist_ok=True)
         self.lock = threading.Lock()
         self._session_factory = session_factory
-        self._conversations: Dict[str, Dict[str, Any]] = self._load_conversations()
+        self._conversations: dict[str, dict[str, Any]] = self._load_conversations()
 
     # ------------------------------------------------------------------
     # JSON helpers
     # ------------------------------------------------------------------
 
-    def _load_conversations(self) -> Dict[str, Dict[str, Any]]:
+    def _load_conversations(self) -> dict[str, dict[str, Any]]:
         if os.path.exists(self.storage_file):
             try:
-                with open(self.storage_file, "r", encoding="utf-8") as f:
+                with open(self.storage_file, encoding="utf-8") as f:
                     return json.load(f)
             except Exception as exc:  # noqa: BLE001
                 logger.error(f"Error loading conversations: {exc}")
@@ -88,7 +89,7 @@ def _serialize_datetime(self, obj: Any) -> Any:
             return [self._serialize_datetime(x) for x in obj]
         return obj
 
-    def _count_total(self, data: Dict[str, Any]) -> int:
+    def _count_total(self, data: dict[str, Any]) -> int:
         total = 0
         for user_conv in data.values():
             if isinstance(user_conv, dict):
@@ -99,7 +100,7 @@ def _count_total(self, data: Dict[str, Any]) -> int:
     # Public async API
     # ------------------------------------------------------------------
 
-    async def get_user_conversations(self, user_id: str) -> Dict[str, Any]:
+    async def get_user_conversations(self, user_id: str) -> dict[str, Any]:
         mode = get_storage_mode()
         if mode == "files":
             if user_id not in self._conversations:
@@ -121,7 +122,7 @@ async def store_conversation_thread(
         self,
         user_id: str,
         response_id: str,
-        conversation_state: Dict[str, Any],
+        conversation_state: dict[str, Any],
     ) -> None:
         serialized = self._serialize_datetime(conversation_state)
 
@@ -134,9 +135,7 @@ async def store_conversation_thread(
         if db_writes_enabled():
             await self._db_upsert(user_id, response_id, serialized)
 
-    async def get_conversation_thread(
-        self, user_id: str, response_id: str
-    ) -> Dict[str, Any]:
+    async def get_conversation_thread(self, user_id: str, response_id: str) -> dict[str, Any]:
         mode = get_storage_mode()
         if mode != "files":
             payload = await self._db_get_one(response_id, user_id)
@@ -147,16 +146,11 @@ async def get_conversation_thread(
         # files or hybrid-with-no-db-row → JSON
         return self._conversations.get(user_id, {}).get(response_id, {})
 
-    async def delete_conversation_thread(
-        self, user_id: str, response_id: str
-    ) -> bool:
+    async def delete_conversation_thread(self, user_id: str, response_id: str) -> bool:
         deleted = False
 
         if file_writes_enabled():
-            if (
-                user_id in self._conversations
-                and response_id in self._conversations[user_id]
-            ):
+            if user_id in self._conversations and response_id in self._conversations[user_id]:
                 del self._conversations[user_id][response_id]
                 await self._save_conversations()
                 deleted = True
@@ -175,7 +169,7 @@ async def clear_user_conversations(self, user_id: str) -> None:
         if db_writes_enabled():
             await self._db_delete_all(user_id)
 
-    async def get_storage_stats(self) -> Dict[str, Any]:
+    async def get_storage_stats(self) -> dict[str, Any]:
         # Snapshot — uses whichever storage the mode prioritizes.
         mode = get_storage_mode()
         if mode == "files":
@@ -187,20 +181,20 @@ async def get_storage_stats(self) -> Dict[str, Any]:
             }
         # db / hybrid summary from DB
         try:
+            from sqlalchemy import func, select
+            from sqlmodel import col
+
             from db.models import Conversation
-            from sqlalchemy import select, func
 
             sess_factory = self._resolve_session_factory()
             if sess_factory is None:
                 return {"total_users": 0, "total_conversations": 0}
             async with sess_factory() as session:
                 total = (
-                    await session.execute(select(func.count(Conversation.response_id)))
+                    await session.execute(select(func.count(col(Conversation.response_id))))
                 ).scalar_one()
                 users = (
-                    await session.execute(
-                        select(func.count(func.distinct(Conversation.user_id)))
-                    )
+                    await session.execute(select(func.count(func.distinct(Conversation.user_id))))
                 ).scalar_one()
             return {
                 "total_users": int(users or 0),
@@ -221,12 +215,13 @@ def _resolve_session_factory(self):
             return self._session_factory
         try:
             from db.engine import SessionLocal
+
             return SessionLocal
         except Exception:  # noqa: BLE001
             return None
 
     @staticmethod
-    def _payload_from_row(row) -> Dict[str, Any]:
+    def _payload_from_row(row) -> dict[str, Any]:
         return {
             "response_id": row.response_id,
             "title": row.title,
@@ -238,9 +233,7 @@ def _payload_from_row(row) -> Dict[str, Any]:
             "last_activity": row.last_activity.isoformat() if row.last_activity else None,
         }
 
-    async def _db_upsert(
-        self, user_id: str, response_id: str, payload: Dict[str, Any]
-    ) -> None:
+    async def _db_upsert(self, user_id: str, response_id: str, payload: dict[str, Any]) -> None:
         from db.repositories import ConversationRepo
 
         sess_factory = self._resolve_session_factory()
@@ -262,7 +255,7 @@ async def _db_upsert(
         except Exception as exc:  # noqa: BLE001
             logger.error("DB store_conversation failed", error=str(exc))
 
-    async def _db_get_for_user(self, user_id: str) -> Dict[str, Dict[str, Any]]:
+    async def _db_get_for_user(self, user_id: str) -> dict[str, dict[str, Any]]:
         from db.repositories import ConversationRepo
 
         sess_factory = self._resolve_session_factory()
@@ -276,9 +269,7 @@ async def _db_get_for_user(self, user_id: str) -> Dict[str, Dict[str, Any]]:
             logger.debug("DB get_for_user failed", error=str(exc))
             return {}
 
-    async def _db_get_one(
-        self, response_id: str, user_id: str
-    ) -> Optional[Dict[str, Any]]:
+    async def _db_get_one(self, response_id: str, user_id: str) -> dict[str, Any] | None:
         from db.repositories import ConversationRepo
 
         sess_factory = self._resolve_session_factory()
diff --git a/src/services/session_ownership_service.py b/src/services/session_ownership_service.py
index a0dcd25ff0..6ecb2cae13 100644
--- a/src/services/session_ownership_service.py
+++ b/src/services/session_ownership_service.py
@@ -16,6 +16,7 @@
 
 import json
 import os
+import tempfile
 from collections.abc import Callable
 from datetime import UTC, datetime
 from typing import Any
@@ -56,32 +57,71 @@ def _load_ownership_data(self) -> dict[str, dict[str, Any]]:
                 return {}
         return {}
 
-    def _save_ownership_data(self) -> None:
+    def _save_ownership_data(self, data: dict[str, dict[str, Any]]) -> None:
+        """Publish a complete file before changing the authorization cache."""
+        temporary = None
         try:
-            with open(self.ownership_file, "w") as f:
-                json.dump(self.ownership_data, f, indent=2)
-        except Exception as exc:  # noqa: BLE001
-            logger.error(f"Error saving session ownership data: {exc}")
+            with tempfile.NamedTemporaryFile(
+                mode="w", dir=os.path.dirname(self.ownership_file), delete=False
+            ) as f:
+                temporary = f.name
+                json.dump(data, f, indent=2)
+                f.flush()
+                os.fsync(f.fileno())
+            os.replace(temporary, self.ownership_file)
+            self.ownership_data = data
+        finally:
+            if temporary is not None and os.path.exists(temporary):
+                os.unlink(temporary)
 
     # ------------------------------------------------------------------
     # Public async API
     # ------------------------------------------------------------------
 
-    async def claim_session(self, user_id: str, session_id: str) -> None:
+    async def claim_session(
+        self, user_id: str, session_id: str, conversation_id: str | None = None
+    ) -> bool:
+        """True only after an owned claim AND its association are persisted.
+
+        Hybrid prefers the DB, with a successfully written JSON file as fallback.
+        Ownership conflicts are never treated as backend failures or bypassed.
+        An unsuccessful write never adds an authorization entry to the cache.
+        """
+        canonical_id = conversation_id or session_id
+        if file_writes_enabled() and self._file_claim_conflicts(user_id, session_id, canonical_id):
+            return False
+        durable = False
+        if db_writes_enabled():
+            try:
+                durable = await self._db_claim(user_id, session_id, canonical_id)
+            except PermissionError:
+                return False
         if file_writes_enabled():
+            # Another claim may have published while the DB write was awaiting.
+            if self._file_claim_conflicts(user_id, session_id, canonical_id):
+                return False
             now = datetime.now(UTC).isoformat()
-            if session_id not in self.ownership_data:
-                self.ownership_data[session_id] = {
+            existing = self.ownership_data.get(session_id, {})
+            if canonical_id != session_id and not durable:
+                canonical = self.ownership_data.get(canonical_id)
+                if not canonical or canonical.get("user_id") != user_id:
+                    return False
+            updated = {
+                **self.ownership_data,
+                session_id: {
+                    **existing,
                     "user_id": user_id,
-                    "created_at": now,
+                    "conversation_id": canonical_id,
+                    "created_at": existing.get("created_at", now),
                     "last_accessed": now,
-                }
-            else:
-                self.ownership_data[session_id]["last_accessed"] = now
-            self._save_ownership_data()
-
-        if db_writes_enabled():
-            await self._db_claim(user_id, session_id)
+                },
+            }
+            try:
+                self._save_ownership_data(updated)
+                durable = True
+            except Exception as exc:  # noqa: BLE001
+                logger.error("File claim_session failed", error=str(exc))
+        return durable
 
     async def get_session_owner(self, session_id: str) -> str | None:
         mode = get_storage_mode()
@@ -116,13 +156,99 @@ async def filter_sessions_for_user(self, session_ids: list[str], user_id: str) -
         owned = set(await self.get_user_sessions(user_id))
         return [sid for sid in session_ids if sid in owned]
 
+    async def get_conversation_sessions(self, user_id: str, session_id: str) -> list[str]:
+        """Return owned canonical ID first, then aliases, including after restart.
+
+        Deletion must not guess after a DB read failure: otherwise it could leave
+        durable aliases authorized while reporting successful removal.
+        """
+        mode = get_storage_mode()
+        files = self.ownership_data if mode != "db" else {}
+        data = files.get(session_id, {})
+        canonical_id = (
+            data.get("conversation_id") or session_id if data.get("user_id") == user_id else None
+        )
+        sessions = []
+        if mode != "files":
+            from db.repositories import SessionOwnershipRepo
+
+            factory = self._resolve_session_factory()
+            if factory is None and mode == "db":
+                raise RuntimeError("Session ownership database unavailable")
+            if factory is not None:
+                async with factory() as session:
+                    repo = SessionOwnershipRepo(session)
+                    row = await repo.get(session_id)
+                    if row is not None:
+                        if row.user_id != user_id:
+                            return []
+                        canonical_id = row.conversation_id or session_id
+                    if canonical_id is None:
+                        return []
+                    canonical = await repo.get(canonical_id)
+                    if canonical is not None:
+                        if canonical.user_id != user_id:
+                            return []
+                    elif files.get(canonical_id, {}).get("user_id") != user_id:
+                        return []
+                    sessions = await repo.list_for_conversation(canonical_id, user_id)
+                    for sid, entry in files.items():
+                        if (
+                            entry.get("user_id") != user_id
+                            or (entry.get("conversation_id") or sid) != canonical_id
+                        ):
+                            continue
+                        authoritative = await repo.get(sid)
+                        if authoritative is None or (
+                            authoritative.user_id == user_id
+                            and (authoritative.conversation_id or sid) == canonical_id
+                        ):
+                            sessions.append(sid)
+                    return list(dict.fromkeys([canonical_id, *sessions]))
+        if canonical_id is None or files.get(canonical_id, {}).get("user_id") != user_id:
+            return []
+        sessions = [
+            sid
+            for sid, entry in files.items()
+            if entry.get("user_id") == user_id
+            and (entry.get("conversation_id") or sid) == canonical_id
+        ]
+        return list(dict.fromkeys([canonical_id, *sessions]))
+
+    async def release_conversation_sessions(self, user_id: str, session_ids: list[str]) -> None:
+        """Revoke a complete owned group atomically in each destination.
+
+        The caller must attempt upstream cleanup before revoking associations:
+        hybrid groups can contain JSON-only aliases absent from a DB rollback.
+        """
+        if file_writes_enabled():
+            updated = dict(self.ownership_data)
+            for session_id in session_ids:
+                if updated.get(session_id, {}).get("user_id") == user_id:
+                    del updated[session_id]
+            self._save_ownership_data(updated)
+        if db_writes_enabled():
+            from db.repositories import SessionOwnershipRepo
+
+            factory = self._resolve_session_factory()
+            if factory is None:
+                if get_storage_mode() == "db":
+                    raise RuntimeError("Session ownership database unavailable")
+                return
+            async with factory() as session:
+                repo = SessionOwnershipRepo(session)
+                for session_id in session_ids:
+                    await repo.release(session_id, user_id)
+                await session.commit()
+
     async def release_session(self, user_id: str, session_id: str) -> bool:
         released = False
 
         if file_writes_enabled() and session_id in self.ownership_data:
             if self.ownership_data[session_id].get("user_id") == user_id:
-                del self.ownership_data[session_id]
-                self._save_ownership_data()
+                updated = dict(self.ownership_data)
+                del updated[session_id]
+                self._save_ownership_data(updated)
                 released = True
             else:
                 logger.warning(
@@ -186,18 +312,51 @@ def _resolve_session_factory(self):
         except Exception:  # noqa: BLE001
             return None
 
-    async def _db_claim(self, user_id: str, session_id: str) -> None:
+    def _file_claim_conflicts(self, user_id: str, session_id: str, canonical_id: str) -> bool:
+        existing = self.ownership_data.get(session_id)
+        canonical = self.ownership_data.get(canonical_id)
+        return bool(
+            existing
+            and (
+                existing.get("user_id") != user_id
+                or (existing.get("conversation_id") or canonical_id) != canonical_id
+            )
+            or canonical
+            and canonical.get("user_id") != user_id
+        )
+
+    async def _db_claim(self, user_id: str, session_id: str, conversation_id: str) -> bool:
+        from sqlalchemy.exc import IntegrityError
+
         from db.repositories import SessionOwnershipRepo
 
         sess_factory = self._resolve_session_factory()
         if sess_factory is None:
-            return
+            logger.error("DB claim_session failed: database unavailable")
+            return False
         try:
             async with sess_factory() as session:
-                await SessionOwnershipRepo(session).claim(session_id, user_id)
+                repo = SessionOwnershipRepo(session)
+                canonical = self.ownership_data.get(conversation_id, {})
+                if (
+                    file_writes_enabled()
+                    and conversation_id != session_id
+                    and canonical.get("user_id") == user_id
+                ):
+                    # Reconcile a durable JSON-only canonical claim after DB recovery.
+                    await repo.claim(conversation_id, user_id, conversation_id)
+                await repo.claim(session_id, user_id, conversation_id)
                 await session.commit()
+            return True
+        except PermissionError:
+            raise
+        except IntegrityError as exc:
+            # A competing insert may now own the ID. Never turn a uniqueness
+            # conflict into permission to publish a JSON fallback for this user.
+            raise PermissionError("Concurrent session ownership conflict") from exc
         except Exception as exc:  # noqa: BLE001
             logger.error("DB claim_session failed", error=str(exc))
+            return False
 
     async def _db_get_owner(self, session_id: str) -> str | None:
         from db.repositories import SessionOwnershipRepo
@@ -231,7 +390,7 @@ async def _db_release(self, session_id: str, user_id: str) -> bool:
 
         sess_factory = self._resolve_session_factory()
         if sess_factory is None:
-            return False
+            raise RuntimeError("Session ownership database unavailable")
         try:
             async with sess_factory() as session:
                 ok = await SessionOwnershipRepo(session).release(session_id, user_id)
@@ -239,7 +398,7 @@ async def _db_release(self, session_id: str, user_id: str) -> bool:
                 return ok
         except Exception as exc:  # noqa: BLE001
             logger.error("DB release_session failed", error=str(exc))
-            return False
+            raise
 
 
 # Global instance — session_factory plumbed in main.py at startup.
diff --git a/tests/unit/db/migrations/test_chat_history_migration.py b/tests/unit/db/migrations/test_chat_history_migration.py
index bf48dc66db..f1dba92d8f 100644
--- a/tests/unit/db/migrations/test_chat_history_migration.py
+++ b/tests/unit/db/migrations/test_chat_history_migration.py
@@ -1,11 +1,15 @@
 """Runtime migration: session_ownership.json + conversations.json → DB."""
 
+import importlib.util
 import json
 import sys
 from pathlib import Path
 
 import pytest
 import pytest_asyncio
+import sqlalchemy as sa
+from alembic.migration import MigrationContext
+from alembic.operations import Operations
 from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
 from sqlmodel import SQLModel
 
@@ -14,9 +18,9 @@
 if str(SRC) not in sys.path:
     sys.path.insert(0, str(SRC))
 
+import db.migrations_runtime as migrations_runtime  # noqa: E402
 import db.models  # noqa: E402,F401
 from db.repositories import ConversationRepo, SessionOwnershipRepo  # noqa: E402
-from db import migrations_runtime  # noqa: E402
 
 
 @pytest_asyncio.fixture
@@ -38,41 +42,49 @@ def staged_files(tmp_path, monkeypatch):
     so_path = tmp_path / "session_ownership.json"
     conv_path = tmp_path / "conversations.json"
 
-    so_path.write_text(json.dumps({
-        "sess-1": {
-            "user_id": "alice",
-            "created_at": "2026-04-01T10:00:00",
-            "last_accessed": "2026-04-02T11:00:00",
-        },
-        "sess-2": {
-            "user_id": "bob",
-            "created_at": "2026-04-03T09:00:00",
-            "last_accessed": "2026-04-03T09:00:00",
-        },
-    }))
-
-    conv_path.write_text(json.dumps({
-        "alice": {
-            "r-1": {
-                "title": "Project sync",
-                "endpoint": "chat",
-                "previous_response_id": None,
-                "filter_id": None,
-                "total_messages": 4,
-                "created_at": "2026-04-01T10:00:00",
-                "last_activity": "2026-04-02T11:00:00",
-            },
-        },
-        "bob": {
-            "r-2": {
-                "title": "Bug triage",
-                "endpoint": "langflow",
-                "total_messages": 1,
-                "created_at": "2026-04-03T09:00:00",
-                "last_activity": "2026-04-03T09:00:00",
-            },
-        },
-    }))
+    so_path.write_text(
+        json.dumps(
+            {
+                "sess-1": {
+                    "user_id": "alice",
+                    "created_at": "2026-04-01T10:00:00",
+                    "last_accessed": "2026-04-02T11:00:00",
+                },
+                "sess-2": {
+                    "user_id": "bob",
+                    "created_at": "2026-04-03T09:00:00",
+                    "last_accessed": "2026-04-03T09:00:00",
+                },
+            }
+        )
+    )
+
+    conv_path.write_text(
+        json.dumps(
+            {
+                "alice": {
+                    "r-1": {
+                        "title": "Project sync",
+                        "endpoint": "chat",
+                        "previous_response_id": None,
+                        "filter_id": None,
+                        "total_messages": 4,
+                        "created_at": "2026-04-01T10:00:00",
+                        "last_activity": "2026-04-02T11:00:00",
+                    },
+                },
+                "bob": {
+                    "r-2": {
+                        "title": "Bug triage",
+                        "endpoint": "langflow",
+                        "total_messages": 1,
+                        "created_at": "2026-04-03T09:00:00",
+                        "last_activity": "2026-04-03T09:00:00",
+                    },
+                },
+            }
+        )
+    )
 
     def _resolver(name):
         return str(tmp_path / name)
@@ -147,3 +159,58 @@ async def test_run_marks_migration_done(staged_files, session_factory):
         assert await migrations_runtime._already_done(
             session, migrations_runtime.CHAT_HISTORY_JSON_TO_DB_V1
         )
+
+
+@pytest.mark.asyncio
+async def test_json_migration_preserves_alias_association(staged_files, session_factory):
+    ownership_file = staged_files / "session_ownership.json"
+    payload = json.loads(ownership_file.read_text())
+    payload["alias"] = {"user_id": "alice", "conversation_id": "sess-1"}
+    ownership_file.write_text(json.dumps(payload))
+    async with session_factory() as session:
+        await migrations_runtime.migrate_chat_history_json_to_db(session)
+        await session.commit()
+    async with session_factory() as session:
+        repo = SessionOwnershipRepo(session)
+        assert (await repo.get("alias")).conversation_id == "sess-1"
+        assert set(await repo.list_for_conversation("sess-1", "alice")) == {"sess-1", "alias"}
+
+
+def test_session_alias_schema_upgrade_and_downgrade():
+    migration_path = ROOT / "alembic" / "versions" / "0008_session_conversation_id.py"
+    spec = importlib.util.spec_from_file_location("migration_0008", migration_path)
+    migration = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(migration)
+    engine = sa.create_engine("sqlite:///:memory:")
+    with engine.begin() as connection:
+        connection.execute(
+            sa.text(
+                "CREATE TABLE session_ownership (response_id VARCHAR(64) PRIMARY KEY, "
+                "user_id VARCHAR(64) NOT NULL)"
+            )
+        )
+        connection.execute(sa.text("INSERT INTO session_ownership VALUES ('legacy', 'alice')"))
+        migration.op = Operations(MigrationContext.configure(connection))
+        migration.upgrade()
+        assert (
+            connection.execute(
+                sa.text(
+                    "SELECT conversation_id FROM session_ownership WHERE response_id = 'legacy'"
+                )
+            ).scalar_one()
+            == "legacy"
+        )
+        assert "ix_session_ownership_conversation_id" in {
+            index["name"] for index in sa.inspect(connection).get_indexes("session_ownership")
+        }
+        migration.downgrade()
+        assert (
+            connection.execute(
+                sa.text("SELECT user_id FROM session_ownership WHERE response_id = 'legacy'")
+            ).scalar_one()
+            == "alice"
+        )
+        assert "conversation_id" not in {
+            column["name"] for column in sa.inspect(connection).get_columns("session_ownership")
+        }
+    engine.dispose()
diff --git a/tests/unit/services/test_session_ownership_service_modes.py b/tests/unit/services/test_session_ownership_service_modes.py
index 62f4ef4103..10f1ec2a1b 100644
--- a/tests/unit/services/test_session_ownership_service_modes.py
+++ b/tests/unit/services/test_session_ownership_service_modes.py
@@ -1,7 +1,6 @@
 """SessionOwnershipService — hybrid / db / files mode coverage."""
 
 import json
-import os
 import sys
 from pathlib import Path
 
@@ -106,9 +105,11 @@ async def test_hybrid_mode_writes_both(monkeypatch, tmp_data_dir, session_factor
 async def test_db_mode_ignores_pre_existing_json(monkeypatch, tmp_data_dir, session_factory):
     """Stale JSON on disk must not bleed through in db mode."""
     tmp_data_dir.parent.mkdir(parents=True, exist_ok=True)
-    tmp_data_dir.write_text(json.dumps({
-        "ghost-sess": {"user_id": "ghost-user", "created_at": "x", "last_accessed": "x"}
-    }))
+    tmp_data_dir.write_text(
+        json.dumps(
+            {"ghost-sess": {"user_id": "ghost-user", "created_at": "x", "last_accessed": "x"}}
+        )
+    )
 
     monkeypatch.setenv("OPENRAG_STORAGE_MODE", "db")
     svc = _svc(session_factory)
@@ -146,3 +147,212 @@ async def test_release_only_owner_can_release(monkeypatch, tmp_data_dir, session
     released = await svc.release_session("alice", "sess-1")
     assert released is True
     assert await svc.get_session_owner("sess-1") is None
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("mode", ["db", "hybrid", "files"])
+async def test_claim_rejects_owner_and_alias_reassignment(
+    monkeypatch, tmp_data_dir, session_factory, mode
+):
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", mode)
+    svc = _svc(session_factory)
+    assert await svc.claim_session("alice", "canonical") is True
+    assert await svc.claim_session("alice", "other") is True
+    assert await svc.claim_session("alice", "alias", conversation_id="canonical") is True
+    assert await svc.claim_session("mallory", "alias", conversation_id="other") is False
+    assert await svc.claim_session("alice", "alias", conversation_id="other") is False
+    assert await svc.claim_session("mallory", "foreign", conversation_id="canonical") is False
+    fresh = _svc(session_factory)
+    assert await fresh.get_session_owner("alias") == "alice"
+    assert await fresh.get_session_owner("foreign") is None
+    assert set(await fresh.get_conversation_sessions("alice", "canonical")) == {
+        "canonical",
+        "alias",
+    }
+    assert await fresh.get_conversation_sessions("mallory", "canonical") == []
+
+
+@pytest.mark.asyncio
+async def test_hybrid_committed_db_claim_survives_file_failure(
+    monkeypatch, tmp_data_dir, session_factory
+):
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "hybrid")
+    svc = _svc(session_factory)
+    tmp_data_dir.mkdir()
+    assert await svc.claim_session("alice", "canonical") is True
+    assert await svc.claim_session("alice", "alias", conversation_id="canonical") is True
+    assert svc.ownership_data == {}
+    fresh = _svc(session_factory)
+    assert await fresh.get_session_owner("alias") == "alice"
+    assert set(await fresh.get_conversation_sessions("alice", "canonical")) == {
+        "canonical",
+        "alias",
+    }
+
+
+@pytest.mark.asyncio
+async def test_hybrid_file_fallback_survives_failed_db_commit(
+    monkeypatch, tmp_data_dir, session_factory
+):
+    from contextlib import asynccontextmanager
+
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "hybrid")
+
+    @asynccontextmanager
+    async def broken_database():
+        async with session_factory() as session:
+
+            async def fail_commit():
+                raise OSError("commit unavailable")
+
+            monkeypatch.setattr(session, "commit", fail_commit)
+            yield session
+
+    svc = _svc(broken_database)
+    assert await svc.claim_session("alice", "canonical") is True
+    assert await svc.claim_session("alice", "alias", conversation_id="canonical") is True
+    fresh = _svc(session_factory)
+    assert await fresh.get_session_owner("alias") == "alice"
+    assert set(await fresh.get_conversation_sessions("alice", "canonical")) == {
+        "canonical",
+        "alias",
+    }
+    async with session_factory() as session:
+        assert await SessionOwnershipRepo(session).get("alias") is None
+
+
+@pytest.mark.asyncio
+async def test_hybrid_database_conflict_cannot_fall_back_to_stale_file(
+    monkeypatch, tmp_data_dir, session_factory
+):
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "db")
+    assert await _svc(session_factory).claim_session("mallory", "session") is True
+    tmp_data_dir.write_text(json.dumps({"session": {"user_id": "alice"}}))
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "hybrid")
+    svc = _svc(session_factory)
+    assert await svc.claim_session("alice", "session") is False
+    assert await svc.get_session_owner("session") == "mallory"
+
+
+@pytest.mark.asyncio
+async def test_hybrid_db_recovery_backfills_json_only_canonical(
+    monkeypatch, tmp_data_dir, session_factory
+):
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "hybrid")
+
+    def unavailable_database():
+        raise OSError("database unavailable")
+
+    svc = _svc(unavailable_database)
+    assert await svc.claim_session("alice", "canonical") is True
+    svc._session_factory = session_factory
+    assert await svc.claim_session("alice", "alias", conversation_id="canonical") is True
+    async with session_factory() as session:
+        repo = SessionOwnershipRepo(session)
+        assert (await repo.get("canonical")).user_id == "alice"
+        assert (await repo.get("alias")).conversation_id == "canonical"
+
+
+@pytest.mark.asyncio
+async def test_hybrid_deletion_group_ignores_foreign_or_reassigned_db_aliases(
+    monkeypatch, tmp_data_dir, session_factory
+):
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "db")
+    svc = _svc(session_factory)
+    assert await svc.claim_session("alice", "canonical") is True
+    assert await svc.claim_session("mallory", "foreign") is True
+    assert await svc.claim_session("alice", "other") is True
+    assert await svc.claim_session("alice", "moved", conversation_id="other") is True
+    tmp_data_dir.write_text(
+        json.dumps(
+            {
+                "canonical": {"user_id": "alice", "conversation_id": "canonical"},
+                "foreign": {"user_id": "alice", "conversation_id": "canonical"},
+                "moved": {"user_id": "alice", "conversation_id": "canonical"},
+            }
+        )
+    )
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "hybrid")
+    fresh = _svc(session_factory)
+    assert await fresh.get_conversation_sessions("alice", "canonical") == ["canonical"]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("mode", ["db", "hybrid"])
+async def test_failed_group_revocation_preserves_all_ids_for_retry(
+    monkeypatch, tmp_data_dir, session_factory, mode
+):
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", mode)
+    svc = _svc(session_factory)
+    for response_id in ("canonical", "alias-1", "alias-2"):
+        assert await svc.claim_session("alice", response_id, conversation_id="canonical") is True
+    original = SessionOwnershipRepo.release
+
+    async def fail_partway(repo, response_id, user_id):
+        if response_id == "alias-1":
+            raise OSError("revocation unavailable")
+        return await original(repo, response_id, user_id)
+
+    monkeypatch.setattr(SessionOwnershipRepo, "release", fail_partway)
+    with pytest.raises(OSError, match="revocation unavailable"):
+        await svc.release_conversation_sessions("alice", ["alias-2", "alias-1", "canonical"])
+    fresh = _svc(session_factory)
+    sessions = await fresh.get_conversation_sessions("alice", "canonical")
+    assert set(sessions) == {"canonical", "alias-1", "alias-2"}
+    monkeypatch.setattr(SessionOwnershipRepo, "release", original)
+    await fresh.release_conversation_sessions("alice", sessions)
+    assert await _svc(session_factory).get_user_sessions("alice") == []
+
+
+@pytest.mark.asyncio
+async def test_hybrid_losing_db_insert_cannot_publish_fallback_owner(
+    monkeypatch, tmp_data_dir, session_factory
+):
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "db")
+    winner = _svc(session_factory)
+    assert await winner.claim_session("alice", "contended") is True
+    # Model a competing claimant whose SELECT happened just before the winner's
+    # insert. The ensuing flush hits the real DB primary-key constraint.
+    original = SessionOwnershipRepo.get
+
+    async def stale_get(repo, response_id):
+        if response_id == "contended":
+            return None
+        return await original(repo, response_id)
+
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "hybrid")
+    loser = _svc(session_factory)
+    monkeypatch.setattr(SessionOwnershipRepo, "get", stale_get)
+    assert await loser.claim_session("bob", "contended") is False
+    assert loser.ownership_data == {}
+    assert not tmp_data_dir.exists()
+    monkeypatch.setattr(SessionOwnershipRepo, "get", original)
+    assert await _svc(session_factory).get_session_owner("contended") == "alice"
+
+
+@pytest.mark.asyncio
+async def test_hybrid_rechecks_cache_after_awaiting_database(
+    monkeypatch, tmp_data_dir, session_factory
+):
+    import asyncio
+
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "hybrid")
+    svc = _svc(session_factory)
+    waiting = asyncio.Event()
+    winner_published = asyncio.Event()
+    original = svc._db_claim
+
+    async def delayed_claim(user_id, session_id, conversation_id):
+        if user_id == "bob":
+            waiting.set()
+            await winner_published.wait()
+            return False
+        return await original(user_id, session_id, conversation_id)
+
+    monkeypatch.setattr(svc, "_db_claim", delayed_claim)
+    losing_claim = asyncio.create_task(svc.claim_session("bob", "contended"))
+    await waiting.wait()
+    assert await svc.claim_session("alice", "contended") is True
+    winner_published.set()
+    assert await losing_claim is False
+    assert json.loads(tmp_data_dir.read_text())["contended"]["user_id"] == "alice"
diff --git a/tests/unit/test_agent_stream_fence_stripped.py b/tests/unit/test_agent_stream_fence_stripped.py
index 58ae383fdc..c0031ded02 100644
--- a/tests/unit/test_agent_stream_fence_stripped.py
+++ b/tests/unit/test_agent_stream_fence_stripped.py
@@ -46,6 +46,9 @@ async def __anext__(self):
         except StopIteration:
             raise StopAsyncIteration from None
 
+    async def close(self):
+        self._chunks = iter(())
+
 
 class FakeResponses:
     def __init__(self, chunks):
diff --git a/tests/unit/test_langflow_stream_provider_errors.py b/tests/unit/test_langflow_stream_provider_errors.py
index 8a862cf61c..faa4ea1ba9 100644
--- a/tests/unit/test_langflow_stream_provider_errors.py
+++ b/tests/unit/test_langflow_stream_provider_errors.py
@@ -1,18 +1,31 @@
-"""Provider errors must reach the client as a final stream error chunk.
+"""Langflow stream lifecycle and provider-error regressions.
 
-These tests mock the upstream stream to raise exceptions shaped like real
-provider failures (watsonx rate limit, invalid key, permission). That proves
-the yield path without hardcoding a raise in production code.
+Only the upstream provider is replaced; cancellation regressions use the real
+conversation store and ownership guard, including durable SQLite ownership.
 """
 
 from __future__ import annotations
 
+import asyncio
 import json
 from collections.abc import AsyncIterator
+from pathlib import Path
+from types import SimpleNamespace
 
+import anyio
+import httpx
 import pytest
+import pytest_asyncio
+from fastapi import HTTPException
+from openai import AsyncOpenAI
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from sqlmodel import SQLModel
 
 import agent as agent_module
+from api.chat import ChatBody, _assert_owns, delete_session_endpoint, langflow_endpoint
+from services.chat_service import ChatService
+from services.conversation_persistence_service import ConversationPersistenceService
+from services.session_ownership_service import SessionOwnershipService
 
 
 def test_format_provider_error_message_extracts_embedded_json():
@@ -99,8 +112,12 @@ async def _store(user_id, response_id, conversation_state):
         agent_module.active_conversations[user_id][response_id] = conversation_state
 
     class _Ownership:
-        async def claim_session(self, user_id, session_id):
+        async def claim_session(self, user_id, session_id, conversation_id=None):
             claimed.append((user_id, session_id))
+            return True
+
+        async def get_session_owner(self, session_id):
+            return next((user_id for user_id, sid in claimed if sid == session_id), None)
 
     monkeypatch.setattr(agent_module, "store_conversation_thread", _store)
     monkeypatch.setattr(
@@ -377,7 +394,7 @@ async def stream_dump(*_args, **_kwargs) -> AsyncIterator[bytes]:
     error_chunk = next(c for c in chunks if c.get("status") == "failed")
     assert "{" not in error_chunk["error"]["message"]
     assert "Provided API key is Invalid" in error_chunk["error"]["message"]
-    assert store_in_memory["stored"] == [(user_id, "resp_dump")]
+    assert store_in_memory["stored"] == [(user_id, "resp_dump")] * 2
     assert store_in_memory["claimed"] == [(user_id, "resp_dump")]
     stored = agent_module.active_conversations[user_id]["resp_dump"]
     assert stored["messages"][-1]["error"] is True
@@ -417,7 +434,7 @@ async def partial_then_fail(*_args, **_kwargs) -> AsyncIterator[bytes]:
     assert len(chunks) == 2
     assert chunks[0]["delta"]["content"] == "Here is a partial answer"
     assert chunks[1]["error"]["message"] == (f"Here is a partial answer\n\n{provider_message}")
-    assert store_in_memory["stored"] == [(user_id, "resp_partial")]
+    assert store_in_memory["stored"] == [(user_id, "resp_partial")] * 2
     assert store_in_memory["claimed"] == [(user_id, "resp_partial")]
 
 
@@ -451,3 +468,514 @@ async def raise_provider_error(*_args, **_kwargs) -> AsyncIterator[bytes]:
     assert not stored_id.startswith("error_")
     assert chunks[0].get("id") == stored_id
     assert stored_id in agent_module.active_conversations.get(user_id, {})
+
+
+@pytest_asyncio.fixture(params=["db", "hybrid", "files"])
+async def durable_stream_stores(request, monkeypatch, tmp_path):
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", request.param)
+    engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'chat.db'}")
+    async with engine.begin() as connection:
+        await connection.run_sync(SQLModel.metadata.create_all)
+    factory = async_sessionmaker(engine, expire_on_commit=False)
+    monkeypatch.setattr(
+        "services.session_ownership_service.get_data_file",
+        lambda name: str(tmp_path / name),
+    )
+    ownership = SessionOwnershipService(session_factory=factory)
+    persistence = ConversationPersistenceService(
+        storage_file=str(tmp_path / "conversations.json"), session_factory=factory
+    )
+    monkeypatch.setattr("services.session_ownership_service.session_ownership_service", ownership)
+    monkeypatch.setattr(agent_module, "conversation_persistence", persistence)
+    monkeypatch.setattr(agent_module, "active_conversations", {})
+    yield ownership, persistence, factory
+    await engine.dispose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("abort", ["close", "cancel"])
+async def test_aborted_langflow_stream_keeps_owned_id_and_partial_turn(
+    monkeypatch, durable_stream_stores, abort
+):
+    ownership, persistence, factory = durable_stream_stores
+    waiting = asyncio.Event()
+    upstream_closed = asyncio.Event()
+    calls = []
+
+    async def upstream(*_args, **kwargs):
+        calls.append(kwargs.get("previous_response_id"))
+        try:
+            yield b'{"id":"resp-first","delta":{"content":"Partial answer"}}\n'
+            waiting.set()
+            await asyncio.Event().wait()
+        finally:
+            upstream_closed.set()
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    stream = agent_module.async_langflow_chat_stream(object(), "flow", "First question", "alice")
+    chunk = json.loads(await anext(stream))
+    # The ID must already be durable when it first crosses the generator boundary.
+    await _assert_owns(chunk["id"], "alice")
+    assert (await persistence.get_conversation_thread("alice", chunk["id"]))["total_messages"] >= 1
+    if abort == "close":
+        await stream.aclose()
+    else:
+        pending = asyncio.create_task(anext(stream))
+        await waiting.wait()
+        pending.cancel()
+        with pytest.raises(asyncio.CancelledError):
+            await pending
+    assert upstream_closed.is_set()
+    # Reload ownership rather than relying on the live service's cache.
+    reloaded = SessionOwnershipService(session_factory=factory)
+    assert await reloaded.get_session_owner(chunk["id"]) == "alice"
+    with pytest.raises(HTTPException) as forbidden:
+        await _assert_owns(chunk["id"], "mallory")
+    assert forbidden.value.status_code == 403
+    with pytest.raises(HTTPException) as missing:
+        await _assert_owns("unknown-session", "alice")
+    assert missing.value.status_code == 404
+
+    async def continuation(*_args, **kwargs):
+        calls.append(kwargs.get("previous_response_id"))
+        yield b'{"id":"resp-next","response_id":"resp-next-alias","delta":{"content":"Next"}}\n'
+
+    monkeypatch.setattr(agent_module, "async_stream", continuation)
+    await _assert_owns(chunk["id"], "alice")
+    followup = agent_module.async_langflow_chat_stream(
+        object(),
+        "flow",
+        "Follow-up",
+        "alice",
+        previous_response_id=chunk["id"],
+        conversation_id=chunk["id"],
+    )
+    next_chunk = json.loads(await anext(followup))
+    await _assert_owns(next_chunk["id"], "alice")
+    await _assert_owns(next_chunk["response_id"], "alice")
+    assert await _collect_error_chunks(followup) == []
+    assert calls == [None, "resp-first"]  # Never replay the interrupted prompt.
+    conversations = await persistence.get_user_conversations("alice")
+    assert list(conversations) == ["resp-first"]  # Stable sidebar id, changing response ids.
+    messages = agent_module.active_conversations["alice"]["resp-first"]["messages"]
+    assert [(m["role"], m["content"]) for m in messages if m["role"] != "system"] == [
+        ("user", "First question"),
+        ("assistant", "Partial answer"),
+        ("user", "Follow-up"),
+        ("assistant", "Next"),
+    ]
+    assert conversations["resp-first"]["total_messages"] == 4
+
+    # SDK callers may only carry the changing response ID, not conversation_id.
+    await _collect_error_chunks(
+        agent_module.async_langflow_chat_stream(
+            object(),
+            "flow",
+            "Third question",
+            "alice",
+            previous_response_id=next_chunk["response_id"],
+        )
+    )
+    assert list(await persistence.get_user_conversations("alice")) == ["resp-first"]
+    assert calls == [None, "resp-first", "resp-next-alias"]
+    assert [m["content"] for m in messages if m["role"] == "user"] == [
+        "First question",
+        "Follow-up",
+        "Third question",
+    ]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("claim_failure", ["unavailable", "foreign"])
+async def test_stream_does_not_expose_unowned_response_id(
+    monkeypatch, durable_stream_stores, claim_failure
+):
+    ownership, persistence, _ = durable_stream_stores
+    if claim_failure == "foreign":
+        await ownership.claim_session("mallory", "resp-unclaimable")
+    else:
+
+        async def unavailable(*_args, **_kwargs):
+            return False
+
+        monkeypatch.setattr(ownership, "claim_session", unavailable)
+
+    async def upstream(*_args, **_kwargs):
+        yield b'{"id":"resp-unclaimable","delta":{"content":"Not exposed"}}\n'
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    chunks = await _collect_error_chunks(
+        agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")
+    )
+    assert len(chunks) == 1
+    assert chunks[0]["status"] == "failed"
+    assert "id" not in chunks[0] and "response_id" not in chunks[0]
+    assert await persistence.get_user_conversations("alice") == {}
+    assert await ownership.get_session_owner("resp-unclaimable") == (
+        "mallory" if claim_failure == "foreign" else None
+    )
+
+
+@pytest.mark.asyncio
+async def test_local_asgi_disconnect_smoke_preserves_followup(monkeypatch, durable_stream_stores):
+    """Real endpoint → generator → OpenAI SSE adapter → durable stores, locally."""
+    _, persistence, factory = durable_stream_stores
+    disconnected = anyio.Event()
+    upstream_closed = anyio.Event()
+    calls = []
+
+    class ProviderStream(httpx.AsyncByteStream):
+        async def __aiter__(self):
+            yield (
+                b"event: response.created\n"
+                b'data: {"type":"response.created","response":{"id":"resp-http"}}\n\n'
+            )
+            yield (
+                b"event: response.output_text.delta\n"
+                b'data: {"type":"response.output_text.delta","id":"resp-http",'
+                b'"delta":{"content":"Partial HTTP answer"}}\n\n'
+            )
+            await anyio.sleep_forever()
+
+        async def aclose(self):
+            upstream_closed.set()
+
+    async def provider(request):
+        payload = json.loads(request.content)
+        calls.append(payload)
+        if len(calls) == 1:
+            return httpx.Response(
+                200, headers={"content-type": "text/event-stream"}, stream=ProviderStream()
+            )
+        return httpx.Response(
+            200,
+            headers={"content-type": "text/event-stream"},
+            content=(
+                b"event: response.output_text.delta\n"
+                b'data: {"type":"response.output_text.delta","id":"resp-http-next",'
+                b'"delta":{"content":"Follow-up HTTP answer"}}\n\n'
+                b"event: response.completed\n"
+                b'data: {"type":"response.completed","response":{"id":"resp-http-next",'
+                b'"usage":{"input_tokens":3,"output_tokens":4,"total_tokens":7}}}\n\n'
+            ),
+        )
+
+    async with AsyncOpenAI(
+        api_key="local-test-only",
+        base_url="https://provider.invalid/v1",
+        http_client=httpx.AsyncClient(transport=httpx.MockTransport(provider)),
+        max_retries=0,
+    ) as client:
+
+        class EndpointChatService:
+            async def langflow_chat(self, prompt, _subject, _jwt, **kwargs):
+                return agent_module.async_langflow_chat_stream(
+                    client,
+                    "flow",
+                    prompt,
+                    kwargs["storage_user_id"],
+                    previous_response_id=kwargs["previous_response_id"],
+                    conversation_id=kwargs["conversation_id"],
+                )
+
+        user = SimpleNamespace(
+            user_id="oauth-alice",
+            db_user_id="alice",
+            jwt_token="local-test-only",
+            name="Alice",
+            email="alice@example.invalid",
+        )
+        service = EndpointChatService()
+        response = await langflow_endpoint(
+            ChatBody(prompt="First HTTP question", stream=True),
+            chat_service=service,
+            session_manager=None,
+            user=user,
+        )
+        emitted = []
+
+        async def send(message):
+            if message["type"] == "http.response.body" and message.get("body"):
+                chunk = json.loads(message["body"])
+                emitted.append(chunk)
+                response_id = chunk.get("id") or (chunk.get("response") or {}).get("id")
+                if response_id:
+                    await _assert_owns(response_id, "alice")
+                if chunk.get("delta", {}).get("content"):
+                    disconnected.set()
+
+        async def receive():
+            await disconnected.wait()
+            return {"type": "http.disconnect"}
+
+        # Starlette's real disconnect listener cancels the body iterator using an
+        # AnyIO cancel scope, rather than manually throwing into our generator.
+        with anyio.fail_after(5):
+            await response({"type": "http", "asgi": {"spec_version": "2.3"}}, receive, send)
+        assert upstream_closed.is_set()
+        assert len(emitted) == 2
+        metadata = await persistence.get_conversation_thread("alice", "resp-http")
+        assert metadata["total_messages"] == 2
+
+        followup = await langflow_endpoint(
+            ChatBody(
+                prompt="Next HTTP question",
+                stream=True,
+                previous_response_id="resp-http",
+                conversation_id="resp-http",
+            ),
+            chat_service=service,
+            session_manager=None,
+            user=user,
+        )
+        chunks = await _collect_error_chunks(followup.body_iterator)
+        await _assert_owns("resp-http-next", "alice")
+        assert chunks[-1]["response"]["usage"]["total_tokens"] == 7
+        assert calls[1]["previous_response_id"] == "resp-http"
+        assert [call["input"] for call in calls] == ["First HTTP question", "Next HTTP question"]
+        conversations = await persistence.get_user_conversations("alice")
+        assert list(conversations) == ["resp-http"]
+        assert conversations["resp-http"]["total_messages"] == 4
+        messages = agent_module.active_conversations["alice"]["resp-http"]["messages"]
+        assert [m["content"] for m in messages if m["role"] != "system"] == [
+            "First HTTP question",
+            "Partial HTTP answer",
+            "Next HTTP question",
+            "Follow-up HTTP answer",
+        ]
+
+        # Restart before canonical deletion: aliases must come from durable state.
+        reloaded = SessionOwnershipService(session_factory=factory)
+        monkeypatch.setattr(
+            "services.session_ownership_service.session_ownership_service", reloaded
+        )
+        monkeypatch.setattr(agent_module, "active_conversations", {})
+        upstream_deletes = []
+
+        async def monitor_delete(method, path):
+            assert method == "DELETE"
+            upstream_deletes.append(path.rsplit("/", 1)[-1])
+            return httpx.Response(204)
+
+        monkeypatch.setattr("services.chat_service.clients.langflow_request", monitor_delete)
+        deletion = await delete_session_endpoint(
+            session_id="resp-http", chat_service=ChatService(), user=user
+        )
+        assert deletion.status_code == 200
+        assert set(upstream_deletes) == {"resp-http", "resp-http-next"}
+        fresh = SessionOwnershipService(session_factory=factory)
+        monkeypatch.setattr("services.session_ownership_service.session_ownership_service", fresh)
+        with pytest.raises(HTTPException) as missing:
+            await langflow_endpoint(
+                ChatBody(
+                    prompt="Cannot resurrect", stream=True, previous_response_id="resp-http-next"
+                ),
+                chat_service=service,
+                session_manager=None,
+                user=user,
+            )
+        assert missing.value.status_code == 404
+        assert len(calls) == 2
+
+        # Actual endpoint + SSE adapter with both persistent destinations broken.
+        ownership_path = Path(fresh.ownership_file)
+        if ownership_path.exists():
+            ownership_path.unlink()
+        ownership_path.mkdir()
+
+        def unavailable_database():
+            raise OSError("local smoke database unavailable")
+
+        monkeypatch.setattr(fresh, "_resolve_session_factory", lambda: unavailable_database)
+        failed = await langflow_endpoint(
+            ChatBody(prompt="Fail closed", stream=True),
+            chat_service=service,
+            session_manager=None,
+            user=user,
+        )
+        failed_chunks = await _collect_error_chunks(failed.body_iterator)
+        assert len(failed_chunks) == 1 and failed_chunks[0]["status"] == "failed"
+        assert "id" not in failed_chunks[0] and "response_id" not in failed_chunks[0]
+        assert (
+            await SessionOwnershipService(session_factory=factory).get_session_owner(
+                "resp-http-next"
+            )
+            is None
+        )
+        print(
+            "LOCAL SMOKE: disconnect/follow-up retained 4 messages; restart + "
+            "canonical deletion removed both upstream sessions and alias authorization; "
+            "persistent failures emitted no client ID"
+        )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("delta", [None, {"content": None}])
+async def test_metadata_only_chunk_claims_id_before_exposure(
+    monkeypatch, durable_stream_stores, delta
+):
+    async def upstream(*_args, **_kwargs):
+        yield (json.dumps({"id": "resp-metadata", "delta": delta}) + "\n").encode()
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    stream = agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")
+    chunk = json.loads(await anext(stream))
+    await _assert_owns(chunk["id"], "alice")
+    await stream.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("delete_id", ["resp-first", "resp-second"])
+async def test_delete_canonical_revokes_aliases_after_reload(
+    monkeypatch, durable_stream_stores, delete_id
+):
+    ownership, persistence, factory = durable_stream_stores
+
+    async def upstream(*_args, **kwargs):
+        response_id = "resp-second" if kwargs.get("previous_response_id") else "resp-first"
+        yield (json.dumps({"id": response_id, "delta": {"content": "Answer"}}) + "\n").encode()
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    for previous in (None, "resp-first"):
+        await _collect_error_chunks(
+            agent_module.async_langflow_chat_stream(
+                object(), "flow", "Question", "alice", previous_response_id=previous
+            )
+        )
+    await ownership.claim_session("mallory", "resp-foreign")
+    await ownership.claim_session("alice", "resp-unrelated")
+    assert list(await persistence.get_user_conversations("alice")) == ["resp-first"]
+    assert await agent_module.delete_user_conversation("mallory", "resp-first") is False
+    assert agent_module.active_conversations["alice"]["resp-first"]["messages"]
+    # Restart: neither ownership cache nor the in-memory response_ids can help.
+    reloaded = SessionOwnershipService(session_factory=factory)
+    monkeypatch.setattr("services.session_ownership_service.session_ownership_service", reloaded)
+    monkeypatch.setattr(agent_module, "active_conversations", {})
+    persistence = ConversationPersistenceService(
+        storage_file=persistence.storage_file, session_factory=factory
+    )
+    monkeypatch.setattr(agent_module, "conversation_persistence", persistence)
+    assert await agent_module.delete_user_conversation("alice", delete_id) is True
+    fresh = SessionOwnershipService(session_factory=factory)
+    monkeypatch.setattr("services.session_ownership_service.session_ownership_service", fresh)
+    for response_id in ("resp-first", "resp-second"):
+        with pytest.raises(HTTPException) as missing:
+            await _assert_owns(response_id, "alice")
+        assert missing.value.status_code == 404
+    assert await fresh.get_session_owner("resp-foreign") == "mallory"
+    assert await fresh.get_session_owner("resp-unrelated") == "alice"
+    assert await persistence.get_user_conversations("alice") == {}
+
+
+@pytest.mark.asyncio
+async def test_persistent_claim_failure_never_exposes_cached_id(monkeypatch, durable_stream_stores):
+    ownership, persistence, factory = durable_stream_stores
+    # A real IO failure, not a stubbed claim: cache echo must not prove durability.
+    Path(ownership.ownership_file).mkdir()
+
+    def unavailable_database():
+        raise OSError("local database unavailable")
+
+    monkeypatch.setattr(ownership, "_resolve_session_factory", lambda: unavailable_database)
+
+    async def upstream(*_args, **_kwargs):
+        yield b'{"id":"resp-file-failure","delta":{"content":"Not exposed"}}\n'
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    chunks = await _collect_error_chunks(
+        agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")
+    )
+    assert len(chunks) == 1
+    assert chunks[0]["status"] == "failed"
+    assert "id" not in chunks[0] and "response_id" not in chunks[0]
+    assert await ownership.get_session_owner("resp-file-failure") is None
+    assert (
+        await SessionOwnershipService(session_factory=factory).get_session_owner(
+            "resp-file-failure"
+        )
+        is None
+    )
+    assert await persistence.get_user_conversations("alice") == {}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("durable_stream_stores", ["hybrid", "files"], indirect=True)
+async def test_failed_file_revocation_is_not_reported_as_success(
+    monkeypatch, durable_stream_stores
+):
+    ownership, _, _ = durable_stream_stores
+
+    async def upstream(*_args, **_kwargs):
+        yield b'{"id":"resp-delete-failure","delta":{"content":"Answer"}}\n'
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    await _collect_error_chunks(
+        agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")
+    )
+    ownership_path = Path(ownership.ownership_file)
+    ownership_path.unlink()
+    ownership_path.mkdir()
+
+    async def monitor_delete(_self, _session_id):
+        return True
+
+    monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)
+    result = await ChatService().delete_session("alice", "resp-delete-failure")
+    assert result["success"] is False
+    await _assert_owns("resp-delete-failure", "alice")
+    assert "resp-delete-failure" in agent_module.active_conversations["alice"]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("durable_stream_stores", ["hybrid"], indirect=True)
+async def test_json_only_alias_cleanup_precedes_failed_db_revocation(
+    monkeypatch, durable_stream_stores
+):
+    from db.repositories import SessionOwnershipRepo
+
+    ownership, _, factory = durable_stream_stores
+
+    async def upstream(*_args, **kwargs):
+        response_id = "alias" if kwargs.get("previous_response_id") else "canonical"
+        yield (json.dumps({"id": response_id, "delta": {"content": "Answer"}}) + "\n").encode()
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    await _collect_error_chunks(
+        agent_module.async_langflow_chat_stream(object(), "flow", "First", "alice")
+    )
+
+    def unavailable_database():
+        raise OSError("database temporarily unavailable")
+
+    ownership._session_factory = unavailable_database
+    await _collect_error_chunks(
+        agent_module.async_langflow_chat_stream(
+            object(), "flow", "Next", "alice", previous_response_id="canonical"
+        )
+    )
+    ownership._session_factory = factory
+    async with factory() as session:
+        assert await SessionOwnershipRepo(session).get("alias") is None
+    assert await ownership.get_session_owner("alias") == "alice"
+    original = SessionOwnershipRepo.release
+
+    async def failed_release(*_args):
+        raise OSError("database revocation failed")
+
+    upstream_deletes = []
+
+    async def monitor_delete(_self, session_id):
+        upstream_deletes.append(session_id)
+        return True
+
+    monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)
+    monkeypatch.setattr(SessionOwnershipRepo, "release", failed_release)
+    result = await ChatService().delete_session("alice", "canonical")
+    assert result["success"] is False
+    assert set(upstream_deletes) == {"canonical", "alias"}
+    # Even though JSON-only ownership was revoked, its upstream cleanup was not
+    # lost. The surviving canonical DB row can be retried after a restart.
+    reloaded = SessionOwnershipService(session_factory=factory)
+    monkeypatch.setattr("services.session_ownership_service.session_ownership_service", reloaded)
+    monkeypatch.setattr(SessionOwnershipRepo, "release", original)
+    assert (await ChatService().delete_session("alice", "canonical"))["success"] is True

From ba5e00a993f7ba008186fa468dc4194e9bf05bbc Mon Sep 17 00:00:00 2001
From: Edwin Jose <edwinjose900@gmail.com>
Date: Thu, 22 Oct 2026 09:00:51 -0500
Subject: [PATCH 2/4] fix: address interrupted-session ownership review
 follow-ups

---
 .../versions/0008_session_conversation_id.py  |   5 +-
 docs/docs/core-components/chat.mdx            |   5 +
 src/agent.py                                  |  62 +-
 src/db/repositories/session_ownership_repo.py |  35 +-
 src/services/chat_service.py                  |   6 +-
 src/services/session_ownership_service.py     | 119 +--
 .../services/test_chat_session_lifecycle.py   | 728 ++++++++++++++++++
 .../test_session_ownership_service_modes.py   | 268 ++++++-
 tests/unit/test_chat_service_bulk_delete.py   |  16 -
 .../test_langflow_stream_provider_errors.py   | 534 +------------
 10 files changed, 1159 insertions(+), 619 deletions(-)
 create mode 100644 tests/unit/services/test_chat_session_lifecycle.py

diff --git a/alembic/versions/0008_session_conversation_id.py b/alembic/versions/0008_session_conversation_id.py
index a28a6a34d1..20cf679d86 100644
--- a/alembic/versions/0008_session_conversation_id.py
+++ b/alembic/versions/0008_session_conversation_id.py
@@ -23,5 +23,6 @@ def upgrade() -> None:
 
 
 def downgrade() -> None:
-    op.drop_index("ix_session_ownership_conversation_id", table_name="session_ownership")
-    op.drop_column("session_ownership", "conversation_id")
+    with op.batch_alter_table("session_ownership") as batch:
+        batch.drop_index("ix_session_ownership_conversation_id")
+        batch.drop_column("conversation_id")
diff --git a/docs/docs/core-components/chat.mdx b/docs/docs/core-components/chat.mdx
index 91255de7c4..9ed17bfe21 100644
--- a/docs/docs/core-components/chat.mdx
+++ b/docs/docs/core-components/chat.mdx
@@ -34,11 +34,16 @@ These IDs can differ when Langflow returns a new response ID.
 Both IDs are checked against the authenticated user's session ownership; interruption recovery does not bypass those checks.
 
 Response aliases are durably associated with their canonical conversation, including across backend restarts.
+After a backend restart, continuing with an owned response alias reuses the canonical sidebar thread and preserves its saved title and message count.
+Successful message bodies are still retrieved from Langflow; the backend does not reconstruct them from metadata.
 Deleting a conversation revokes its canonical ID and all recorded aliases and attempts to remove every associated Langflow session.
 A deleted alias cannot be used to resume the conversation.
+Bulk deletion also removes the caller's own legacy local conversation records that have no ownership row.
+Those orphan records do not authorize upstream session deletion or bypass the ownership checks on chat requests.
 
 IDs are sent only after ownership and its conversation association have been persisted.
 In `files` mode this requires a successful file write; in `db` mode it requires a committed database write.
+File updates are serialized and persisted on a worker thread, so durable writes do not block the event loop or overwrite concurrent ownership changes.
 In `hybrid` mode the database is preferred, with a successful durable JSON write as fallback if the database is unavailable.
 If neither configured destination can persist the claim, the stream returns an error without exposing a new response ID; an in-memory cache entry is not sufficient.
 
diff --git a/src/agent.py b/src/agent.py
index 8172039af6..f25a558a81 100644
--- a/src/agent.py
+++ b/src/agent.py
@@ -161,6 +161,8 @@ async def store_conversation_thread(user_id: str, response_id: str, conversation
 
     # 2. Store only essential metadata to disk (simplified JSON)
     messages = conversation_state.get("messages", [])
+    # A restarted thread has durable metadata, but not successful message bodies.
+    persisted_metadata = conversation_state.get("_persisted_metadata", {})
     first_user_msg = next((msg for msg in messages if msg.get("role") == "user"), None)
     title = "New Chat"
     if first_user_msg:
@@ -170,17 +172,21 @@ async def store_conversation_thread(user_id: str, response_id: str, conversation
     user_assistant_messages = [msg for msg in messages if msg.get("role") in ["user", "assistant"]]
     metadata_only = {
         "response_id": response_id,
-        "title": title,
+        "title": persisted_metadata.get("title") or title,
         "endpoint": "langflow",
         "created_at": conversation_state.get("created_at"),
         "last_activity": conversation_state.get("last_activity"),
-        "previous_response_id": conversation_state.get("previous_response_id"),
+        "previous_response_id": persisted_metadata.get(
+            "previous_response_id", conversation_state.get("previous_response_id")
+        ),
         "filter_id": conversation_state.get("filter_id"),
-        "total_messages": len(user_assistant_messages),
+        "total_messages": (persisted_metadata.get("total_messages") or 0)
+        + len(user_assistant_messages),
     }
     # Snapshot error-thread turns: Langflow history is incomplete after fresh-session retries.
-    if any(msg.get("error") for msg in user_assistant_messages):
-        metadata_only["messages"] = [
+    persisted_messages = persisted_metadata.get("messages", [])
+    if persisted_messages or any(msg.get("error") for msg in user_assistant_messages):
+        metadata_only["messages"] = persisted_messages + [
             {
                 "role": msg.get("role"),
                 "content": msg.get("content"),
@@ -910,7 +916,27 @@ async def async_langflow_chat_stream(
             thread_id,
         )
     previous_loaded_from_memory = _conversation_thread_in_memory(user_id, thread_id)
+    owned_session_ids = []
+    persisted_metadata = {}
+    if thread_id and not previous_loaded_from_memory:
+        from services.session_ownership_service import session_ownership_service
+
+        owned_session_ids = await session_ownership_service.get_conversation_sessions(
+            user_id, thread_id
+        )
+        if owned_session_ids:
+            thread_id = owned_session_ids[0]
+            previous_loaded_from_memory = _conversation_thread_in_memory(user_id, thread_id)
+            if not previous_loaded_from_memory:
+                persisted_metadata = await conversation_persistence.get_conversation_thread(
+                    user_id, thread_id
+                )
     conversation_state = get_conversation_thread(user_id, thread_id)
+    if persisted_metadata:
+        conversation_state["_persisted_metadata"] = persisted_metadata
+        conversation_state["created_at"] = persisted_metadata.get("created_at")
+        conversation_state["filter_id"] = persisted_metadata.get("filter_id")
+        conversation_state["response_ids"] = list(owned_session_ids)
 
     from datetime import datetime
 
@@ -930,7 +956,8 @@ async def async_langflow_chat_stream(
     usage_data = None
     collected_chunks = []  # Store all chunks for function call data
     error_occurred = False
-    store_id = None
+    # A durable owned group can safely retain its canonical sidebar ID on restart.
+    store_id = thread_id if owned_session_ids else None
     claimed_ids: set[str] = set()
     turn_finished = False
 
@@ -1127,9 +1154,14 @@ async def persist_stream_state(*session_ids, mint_if_missing=False):
             await upstream.aclose()
 
 
-async def delete_user_conversation(user_id: str, response_id: str) -> bool:
+async def delete_user_conversation(
+    user_id: str, response_id: str, *, session_ids: list[str] | None = None
+) -> bool:
     """Delete a conversation for a user from both memory and persistent storage.
 
+    ``session_ids`` is the caller's already-authorized ownership snapshot, when
+    provided. An empty group permits only user-scoped local orphan cleanup.
+
     Returns:
         True  — conversation was found and deleted from at least one store.
         False — conversation did not exist in any store (confirmed not-found).
@@ -1140,13 +1172,15 @@ async def delete_user_conversation(user_id: str, response_id: str) -> bool:
     """
     from services.session_ownership_service import session_ownership_service
 
-    session_ids = await session_ownership_service.get_conversation_sessions(user_id, response_id)
-    if not session_ids:
-        return False
-    canonical_id = session_ids[0]
-    # Revoke ALL durable aliases before removing the local index. Failures must
-    # reach the caller, not turn into a successful delete with reusable IDs.
-    await session_ownership_service.release_conversation_sessions(user_id, session_ids)
+    if session_ids is None:
+        session_ids = await session_ownership_service.get_conversation_sessions(
+            user_id, response_id
+        )
+    canonical_id = session_ids[0] if session_ids else response_id
+    if session_ids:
+        # Revoke only the snapshot used for upstream cleanup. Never revoke a late
+        # alias whose upstream deletion was not attempted.
+        await session_ownership_service.release_conversation_sessions(user_id, session_ids)
     deleted = await conversation_persistence.delete_conversation_thread(user_id, canonical_id)
     if canonical_id in active_conversations.get(user_id, {}):
         del active_conversations[user_id][canonical_id]
diff --git a/src/db/repositories/session_ownership_repo.py b/src/db/repositories/session_ownership_repo.py
index 44b6bbd521..537eae2448 100644
--- a/src/db/repositories/session_ownership_repo.py
+++ b/src/db/repositories/session_ownership_repo.py
@@ -3,6 +3,7 @@
 from datetime import UTC, datetime
 
 from sqlalchemy import select
+from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlmodel import col
 
@@ -27,11 +28,6 @@ async def claim(
             canonical = await self.get(canonical_id)
             if canonical is None or canonical.user_id != user_id:
                 raise PermissionError("Conversation is not owned by this user")
-        if existing is not None and (
-            existing.user_id != user_id
-            or (existing.conversation_id is not None and existing.conversation_id != canonical_id)
-        ):
-            raise PermissionError("Session ownership or conversation conflict")
         if existing is None:
             row = SessionOwnership(
                 response_id=response_id,
@@ -41,8 +37,33 @@ async def claim(
                 last_accessed=now,
             )
             self.session.add(row)
-            await self.session.flush()
-            return row
+            try:
+                await self.session.flush()
+            except IntegrityError as exc:
+                # Only primary-key/unique violations can be an INSERT race.
+                # Never hide another constraint failure behind a matching row.
+                if (
+                    getattr(exc.orig, "sqlstate", None) != "23505"
+                    and getattr(exc.orig, "sqlite_errorname", None)
+                    != "SQLITE_CONSTRAINT_PRIMARYKEY"
+                ):
+                    raise
+                # A failed flush leaves the transaction unusable. Roll it back
+                # before reading the committed winner of an INSERT race.
+                await self.session.rollback()
+                existing = await self.get(response_id)
+                if existing is None:
+                    raise
+                if canonical_id != response_id:
+                    canonical = await self.get(canonical_id)
+                    if canonical is None or canonical.user_id != user_id:
+                        raise PermissionError("Conversation is not owned by this user") from None
+            else:
+                return row
+        if existing.user_id != user_id or (
+            (existing.conversation_id or response_id) != canonical_id
+        ):
+            raise PermissionError("Session ownership or conversation conflict")
         existing.conversation_id = canonical_id
         existing.last_accessed = now
         self.session.add(existing)
diff --git a/src/services/chat_service.py b/src/services/chat_service.py
index 7b139cc48e..f7901ebe9c 100644
--- a/src/services/chat_service.py
+++ b/src/services/chat_service.py
@@ -948,7 +948,9 @@ async def delete_session(self, user_id: str, session_id: str):
             ]
             langflow_deleted = bool(upstream_results) and all(upstream_results)
 
-            local_deleted = await delete_user_conversation(user_id, session_id)
+            local_deleted = await delete_user_conversation(
+                user_id, session_id, session_ids=session_ids
+            )
 
             if not local_deleted:
                 return {
@@ -981,7 +983,7 @@ async def delete_sessions(self, user_id: str, session_ids: list[str]) -> dict[st
         for session_id in dict.fromkeys(session_ids):
             try:
                 owner = await session_ownership_service.get_session_owner(session_id)
-                if owner != user_id:
+                if owner is not None and owner != user_id:
                     logger.warning("bulk_delete: %s not owned by %s", session_id, user_id)
                     failed.append(session_id)
                     continue
diff --git a/src/services/session_ownership_service.py b/src/services/session_ownership_service.py
index 6ecb2cae13..e83ff2993e 100644
--- a/src/services/session_ownership_service.py
+++ b/src/services/session_ownership_service.py
@@ -14,8 +14,10 @@
 
 from __future__ import annotations
 
+import asyncio
 import json
 import os
+import stat
 import tempfile
 from collections.abc import Callable
 from datetime import UTC, datetime
@@ -39,6 +41,7 @@ def __init__(self, session_factory: Callable | None = None):
         self.ownership_file = get_data_file("session_ownership.json")
         os.makedirs(os.path.dirname(self.ownership_file), exist_ok=True)
         self._session_factory = session_factory
+        self._file_lock = asyncio.Lock()
         # JSON cache — eagerly loaded so `files` and `hybrid` modes
         # behave like the legacy implementation.
         self.ownership_data: dict[str, dict[str, Any]] = self._load_ownership_data()
@@ -58,22 +61,43 @@ def _load_ownership_data(self) -> dict[str, dict[str, Any]]:
         return {}
 
     def _save_ownership_data(self, data: dict[str, dict[str, Any]]) -> None:
-        """Publish a complete file before changing the authorization cache."""
+        """Write atomically on a worker thread; the caller publishes the cache."""
         temporary = None
         try:
+            try:
+                mode = stat.S_IMODE(os.stat(self.ownership_file).st_mode)
+            except FileNotFoundError:
+                mode = None
             with tempfile.NamedTemporaryFile(
                 mode="w", dir=os.path.dirname(self.ownership_file), delete=False
             ) as f:
                 temporary = f.name
+                if mode is not None:
+                    os.fchmod(f.fileno(), mode)
                 json.dump(data, f, indent=2)
                 f.flush()
                 os.fsync(f.fileno())
             os.replace(temporary, self.ownership_file)
-            self.ownership_data = data
         finally:
             if temporary is not None and os.path.exists(temporary):
                 os.unlink(temporary)
 
+    async def _persist_ownership_data(self, data: dict[str, dict[str, Any]]) -> None:
+        """Persist then publish while the caller holds ``_file_lock``."""
+        write = asyncio.create_task(asyncio.to_thread(self._save_ownership_data, data))
+        cancelled = False
+        while not write.done():
+            try:
+                await asyncio.shield(write)
+            except asyncio.CancelledError:
+                # Cancelling to_thread cannot stop its filesystem write. Keep
+                # the lock until it finishes so the next writer sees its state.
+                cancelled = True
+        write.result()
+        self.ownership_data = data
+        if cancelled:
+            raise asyncio.CancelledError
+
     # ------------------------------------------------------------------
     # Public async API
     # ------------------------------------------------------------------
@@ -97,30 +121,31 @@ async def claim_session(
             except PermissionError:
                 return False
         if file_writes_enabled():
-            # Another claim may have published while the DB write was awaiting.
-            if self._file_claim_conflicts(user_id, session_id, canonical_id):
-                return False
-            now = datetime.now(UTC).isoformat()
-            existing = self.ownership_data.get(session_id, {})
-            if canonical_id != session_id and not durable:
-                canonical = self.ownership_data.get(canonical_id)
-                if not canonical or canonical.get("user_id") != user_id:
+            async with self._file_lock:
+                # Recheck after DB work and after any pending file publication.
+                if self._file_claim_conflicts(user_id, session_id, canonical_id):
                     return False
-            updated = {
-                **self.ownership_data,
-                session_id: {
-                    **existing,
-                    "user_id": user_id,
-                    "conversation_id": canonical_id,
-                    "created_at": existing.get("created_at", now),
-                    "last_accessed": now,
-                },
-            }
-            try:
-                self._save_ownership_data(updated)
-                durable = True
-            except Exception as exc:  # noqa: BLE001
-                logger.error("File claim_session failed", error=str(exc))
+                now = datetime.now(UTC).isoformat()
+                existing = self.ownership_data.get(session_id, {})
+                if canonical_id != session_id and not durable:
+                    canonical = self.ownership_data.get(canonical_id)
+                    if not canonical or canonical.get("user_id") != user_id:
+                        return False
+                updated = {
+                    **self.ownership_data,
+                    session_id: {
+                        **existing,
+                        "user_id": user_id,
+                        "conversation_id": canonical_id,
+                        "created_at": existing.get("created_at", now),
+                        "last_accessed": now,
+                    },
+                }
+                try:
+                    await self._persist_ownership_data(updated)
+                    durable = True
+                except Exception as exc:  # noqa: BLE001
+                    logger.error("File claim_session failed", error=str(exc))
         return durable
 
     async def get_session_owner(self, session_id: str) -> str | None:
@@ -222,11 +247,12 @@ async def release_conversation_sessions(self, user_id: str, session_ids: list[st
         hybrid groups can contain JSON-only aliases absent from a DB rollback.
         """
         if file_writes_enabled():
-            updated = dict(self.ownership_data)
-            for session_id in session_ids:
-                if updated.get(session_id, {}).get("user_id") == user_id:
-                    del updated[session_id]
-            self._save_ownership_data(updated)
+            async with self._file_lock:
+                updated = dict(self.ownership_data)
+                for session_id in session_ids:
+                    if updated.get(session_id, {}).get("user_id") == user_id:
+                        del updated[session_id]
+                await self._persist_ownership_data(updated)
         if db_writes_enabled():
             from db.repositories import SessionOwnershipRepo
 
@@ -244,16 +270,19 @@ async def release_conversation_sessions(self, user_id: str, session_ids: list[st
     async def release_session(self, user_id: str, session_id: str) -> bool:
         released = False
 
-        if file_writes_enabled() and session_id in self.ownership_data:
-            if self.ownership_data[session_id].get("user_id") == user_id:
-                updated = dict(self.ownership_data)
-                del updated[session_id]
-                self._save_ownership_data(updated)
-                released = True
-            else:
-                logger.warning(
-                    f"User {user_id} tried to release session {session_id} they don't own (json)"
-                )
+        if file_writes_enabled():
+            async with self._file_lock:
+                existing = self.ownership_data.get(session_id)
+                if existing is not None:
+                    if existing.get("user_id") == user_id:
+                        updated = dict(self.ownership_data)
+                        del updated[session_id]
+                        await self._persist_ownership_data(updated)
+                        released = True
+                    else:
+                        logger.warning(
+                            f"User {user_id} tried to release session {session_id} they don't own (json)"
+                        )
 
         if db_writes_enabled():
             db_released = await self._db_release(session_id, user_id)
@@ -319,7 +348,7 @@ def _file_claim_conflicts(self, user_id: str, session_id: str, canonical_id: str
             existing
             and (
                 existing.get("user_id") != user_id
-                or (existing.get("conversation_id") or canonical_id) != canonical_id
+                or (existing.get("conversation_id") or session_id) != canonical_id
             )
             or canonical
             and canonical.get("user_id") != user_id
@@ -350,10 +379,10 @@ async def _db_claim(self, user_id: str, session_id: str, conversation_id: str) -
             return True
         except PermissionError:
             raise
-        except IntegrityError as exc:
-            # A competing insert may now own the ID. Never turn a uniqueness
-            # conflict into permission to publish a JSON fallback for this user.
-            raise PermissionError("Concurrent session ownership conflict") from exc
+        except IntegrityError:
+            # The repository recovers only a confirmed, compatible INSERT
+            # winner. Any other integrity failure must not authorize fallback.
+            raise
         except Exception as exc:  # noqa: BLE001
             logger.error("DB claim_session failed", error=str(exc))
             return False
diff --git a/tests/unit/services/test_chat_session_lifecycle.py b/tests/unit/services/test_chat_session_lifecycle.py
new file mode 100644
index 0000000000..b8ad18ec03
--- /dev/null
+++ b/tests/unit/services/test_chat_session_lifecycle.py
@@ -0,0 +1,728 @@
+"""Durable chat ownership, continuation, cancellation, and deletion regressions."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from datetime import datetime
+from pathlib import Path
+from types import SimpleNamespace
+
+import anyio
+import httpx
+import pytest
+import pytest_asyncio
+from fastapi import HTTPException
+from openai import AsyncOpenAI
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from sqlmodel import SQLModel
+
+import agent as agent_module
+from api.chat import ChatBody, _assert_owns, delete_session_endpoint, langflow_endpoint
+from services.chat_service import ChatService
+from services.conversation_persistence_service import ConversationPersistenceService
+from services.session_ownership_service import SessionOwnershipService
+
+
+async def _collect_error_chunks(stream) -> list[dict]:
+    return [json.loads(raw.decode("utf-8")) async for raw in stream]
+
+
+@pytest_asyncio.fixture(params=["db", "hybrid", "files"])
+async def durable_stream_stores(request, monkeypatch, tmp_path):
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", request.param)
+    engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'chat.db'}")
+    async with engine.begin() as connection:
+        await connection.run_sync(SQLModel.metadata.create_all)
+    factory = async_sessionmaker(engine, expire_on_commit=False)
+    monkeypatch.setattr(
+        "services.session_ownership_service.get_data_file",
+        lambda name: str(tmp_path / name),
+    )
+    ownership = SessionOwnershipService(session_factory=factory)
+    persistence = ConversationPersistenceService(
+        storage_file=str(tmp_path / "conversations.json"), session_factory=factory
+    )
+    monkeypatch.setattr("services.session_ownership_service.session_ownership_service", ownership)
+    monkeypatch.setattr(agent_module, "conversation_persistence", persistence)
+    monkeypatch.setattr(agent_module, "active_conversations", {})
+    yield ownership, persistence, factory
+    await engine.dispose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("abort", ["close", "cancel"])
+async def test_aborted_langflow_stream_keeps_owned_id_and_partial_turn(
+    monkeypatch, durable_stream_stores, abort
+):
+    ownership, persistence, factory = durable_stream_stores
+    waiting = asyncio.Event()
+    upstream_closed = asyncio.Event()
+    calls = []
+
+    async def upstream(*_args, **kwargs):
+        calls.append(kwargs.get("previous_response_id"))
+        try:
+            yield b'{"id":"resp-first","delta":{"content":"Partial answer"}}\n'
+            waiting.set()
+            await asyncio.Event().wait()
+        finally:
+            upstream_closed.set()
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    stream = agent_module.async_langflow_chat_stream(object(), "flow", "First question", "alice")
+    chunk = json.loads(await anext(stream))
+    # The ID must already be durable when it first crosses the generator boundary.
+    await _assert_owns(chunk["id"], "alice")
+    assert (await persistence.get_conversation_thread("alice", chunk["id"]))["total_messages"] >= 1
+    if abort == "close":
+        await stream.aclose()
+    else:
+        pending = asyncio.create_task(anext(stream))
+        await waiting.wait()
+        pending.cancel()
+        with pytest.raises(asyncio.CancelledError):
+            await pending
+    assert upstream_closed.is_set()
+    # Reload ownership rather than relying on the live service's cache.
+    reloaded = SessionOwnershipService(session_factory=factory)
+    assert await reloaded.get_session_owner(chunk["id"]) == "alice"
+    with pytest.raises(HTTPException) as forbidden:
+        await _assert_owns(chunk["id"], "mallory")
+    assert forbidden.value.status_code == 403
+    with pytest.raises(HTTPException) as missing:
+        await _assert_owns("unknown-session", "alice")
+    assert missing.value.status_code == 404
+
+    async def continuation(*_args, **kwargs):
+        calls.append(kwargs.get("previous_response_id"))
+        yield b'{"id":"resp-next","response_id":"resp-next-alias","delta":{"content":"Next"}}\n'
+
+    monkeypatch.setattr(agent_module, "async_stream", continuation)
+    await _assert_owns(chunk["id"], "alice")
+    followup = agent_module.async_langflow_chat_stream(
+        object(),
+        "flow",
+        "Follow-up",
+        "alice",
+        previous_response_id=chunk["id"],
+        conversation_id=chunk["id"],
+    )
+    next_chunk = json.loads(await anext(followup))
+    await _assert_owns(next_chunk["id"], "alice")
+    await _assert_owns(next_chunk["response_id"], "alice")
+    assert await _collect_error_chunks(followup) == []
+    assert calls == [None, "resp-first"]  # Never replay the interrupted prompt.
+    conversations = await persistence.get_user_conversations("alice")
+    assert list(conversations) == ["resp-first"]  # Stable sidebar id, changing response ids.
+    messages = agent_module.active_conversations["alice"]["resp-first"]["messages"]
+    assert [(m["role"], m["content"]) for m in messages if m["role"] != "system"] == [
+        ("user", "First question"),
+        ("assistant", "Partial answer"),
+        ("user", "Follow-up"),
+        ("assistant", "Next"),
+    ]
+    assert conversations["resp-first"]["total_messages"] == 4
+
+    # SDK callers may only carry the changing response ID, not conversation_id.
+    await _collect_error_chunks(
+        agent_module.async_langflow_chat_stream(
+            object(),
+            "flow",
+            "Third question",
+            "alice",
+            previous_response_id=next_chunk["response_id"],
+        )
+    )
+    assert list(await persistence.get_user_conversations("alice")) == ["resp-first"]
+    assert calls == [None, "resp-first", "resp-next-alias"]
+    assert [m["content"] for m in messages if m["role"] == "user"] == [
+        "First question",
+        "Follow-up",
+        "Third question",
+    ]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("claim_failure", ["unavailable", "foreign"])
+async def test_stream_does_not_expose_unowned_response_id(
+    monkeypatch, durable_stream_stores, claim_failure
+):
+    ownership, persistence, _ = durable_stream_stores
+    if claim_failure == "foreign":
+        await ownership.claim_session("mallory", "resp-unclaimable")
+    else:
+
+        async def unavailable(*_args, **_kwargs):
+            return False
+
+        monkeypatch.setattr(ownership, "claim_session", unavailable)
+
+    async def upstream(*_args, **_kwargs):
+        yield b'{"id":"resp-unclaimable","delta":{"content":"Not exposed"}}\n'
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    chunks = await _collect_error_chunks(
+        agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")
+    )
+    assert len(chunks) == 1
+    assert chunks[0]["status"] == "failed"
+    assert "id" not in chunks[0] and "response_id" not in chunks[0]
+    assert await persistence.get_user_conversations("alice") == {}
+    assert await ownership.get_session_owner("resp-unclaimable") == (
+        "mallory" if claim_failure == "foreign" else None
+    )
+
+
+@pytest.mark.asyncio
+async def test_local_asgi_disconnect_smoke_preserves_followup(monkeypatch, durable_stream_stores):
+    """Real endpoint → generator → OpenAI SSE adapter → durable stores, locally."""
+    _, persistence, factory = durable_stream_stores
+    disconnected = anyio.Event()
+    upstream_closed = anyio.Event()
+    calls = []
+
+    class ProviderStream(httpx.AsyncByteStream):
+        async def __aiter__(self):
+            yield (
+                b"event: response.created\n"
+                b'data: {"type":"response.created","response":{"id":"resp-http"}}\n\n'
+            )
+            yield (
+                b"event: response.output_text.delta\n"
+                b'data: {"type":"response.output_text.delta","id":"resp-http",'
+                b'"delta":{"content":"Partial HTTP answer"}}\n\n'
+            )
+            await anyio.sleep_forever()
+
+        async def aclose(self):
+            upstream_closed.set()
+
+    async def provider(request):
+        payload = json.loads(request.content)
+        calls.append(payload)
+        if len(calls) == 1:
+            return httpx.Response(
+                200, headers={"content-type": "text/event-stream"}, stream=ProviderStream()
+            )
+        return httpx.Response(
+            200,
+            headers={"content-type": "text/event-stream"},
+            content=(
+                b"event: response.output_text.delta\n"
+                b'data: {"type":"response.output_text.delta","id":"resp-http-next",'
+                b'"delta":{"content":"Follow-up HTTP answer"}}\n\n'
+                b"event: response.completed\n"
+                b'data: {"type":"response.completed","response":{"id":"resp-http-next",'
+                b'"usage":{"input_tokens":3,"output_tokens":4,"total_tokens":7}}}\n\n'
+            ),
+        )
+
+    async with AsyncOpenAI(
+        api_key="local-test-only",
+        base_url="https://provider.invalid/v1",
+        http_client=httpx.AsyncClient(transport=httpx.MockTransport(provider)),
+        max_retries=0,
+    ) as client:
+
+        class EndpointChatService:
+            async def langflow_chat(self, prompt, _subject, _jwt, **kwargs):
+                return agent_module.async_langflow_chat_stream(
+                    client,
+                    "flow",
+                    prompt,
+                    kwargs["storage_user_id"],
+                    previous_response_id=kwargs["previous_response_id"],
+                    conversation_id=kwargs["conversation_id"],
+                )
+
+        user = SimpleNamespace(
+            user_id="oauth-alice",
+            db_user_id="alice",
+            jwt_token="local-test-only",
+            name="Alice",
+            email="alice@example.invalid",
+        )
+        service = EndpointChatService()
+        response = await langflow_endpoint(
+            ChatBody(prompt="First HTTP question", stream=True),
+            chat_service=service,
+            session_manager=None,
+            user=user,
+        )
+        emitted = []
+
+        async def send(message):
+            if message["type"] == "http.response.body" and message.get("body"):
+                chunk = json.loads(message["body"])
+                emitted.append(chunk)
+                response_id = chunk.get("id") or (chunk.get("response") or {}).get("id")
+                if response_id:
+                    await _assert_owns(response_id, "alice")
+                if chunk.get("delta", {}).get("content"):
+                    disconnected.set()
+
+        async def receive():
+            await disconnected.wait()
+            return {"type": "http.disconnect"}
+
+        # Starlette's real disconnect listener cancels the body iterator using an
+        # AnyIO cancel scope, rather than manually throwing into our generator.
+        with anyio.fail_after(5):
+            await response({"type": "http", "asgi": {"spec_version": "2.3"}}, receive, send)
+        assert upstream_closed.is_set()
+        assert len(emitted) == 2
+        metadata = await persistence.get_conversation_thread("alice", "resp-http")
+        assert metadata["total_messages"] == 2
+
+        followup = await langflow_endpoint(
+            ChatBody(
+                prompt="Next HTTP question",
+                stream=True,
+                previous_response_id="resp-http",
+                conversation_id="resp-http",
+            ),
+            chat_service=service,
+            session_manager=None,
+            user=user,
+        )
+        chunks = await _collect_error_chunks(followup.body_iterator)
+        await _assert_owns("resp-http-next", "alice")
+        assert chunks[-1]["response"]["usage"]["total_tokens"] == 7
+        assert calls[1]["previous_response_id"] == "resp-http"
+        assert [call["input"] for call in calls] == ["First HTTP question", "Next HTTP question"]
+        conversations = await persistence.get_user_conversations("alice")
+        assert list(conversations) == ["resp-http"]
+        assert conversations["resp-http"]["total_messages"] == 4
+        messages = agent_module.active_conversations["alice"]["resp-http"]["messages"]
+        assert [m["content"] for m in messages if m["role"] != "system"] == [
+            "First HTTP question",
+            "Partial HTTP answer",
+            "Next HTTP question",
+            "Follow-up HTTP answer",
+        ]
+
+        # Restart before canonical deletion: aliases must come from durable state.
+        reloaded = SessionOwnershipService(session_factory=factory)
+        monkeypatch.setattr(
+            "services.session_ownership_service.session_ownership_service", reloaded
+        )
+        monkeypatch.setattr(agent_module, "active_conversations", {})
+        upstream_deletes = []
+
+        async def monitor_delete(method, path):
+            assert method == "DELETE"
+            upstream_deletes.append(path.rsplit("/", 1)[-1])
+            return httpx.Response(204)
+
+        monkeypatch.setattr("services.chat_service.clients.langflow_request", monitor_delete)
+        deletion = await delete_session_endpoint(
+            session_id="resp-http", chat_service=ChatService(), user=user
+        )
+        assert deletion.status_code == 200
+        assert set(upstream_deletes) == {"resp-http", "resp-http-next"}
+        fresh = SessionOwnershipService(session_factory=factory)
+        monkeypatch.setattr("services.session_ownership_service.session_ownership_service", fresh)
+        with pytest.raises(HTTPException) as missing:
+            await langflow_endpoint(
+                ChatBody(
+                    prompt="Cannot resurrect", stream=True, previous_response_id="resp-http-next"
+                ),
+                chat_service=service,
+                session_manager=None,
+                user=user,
+            )
+        assert missing.value.status_code == 404
+        assert len(calls) == 2
+
+        # Actual endpoint + SSE adapter with both persistent destinations broken.
+        ownership_path = Path(fresh.ownership_file)
+        if ownership_path.exists():
+            ownership_path.unlink()
+        ownership_path.mkdir()
+
+        def unavailable_database():
+            raise OSError("local smoke database unavailable")
+
+        monkeypatch.setattr(fresh, "_resolve_session_factory", lambda: unavailable_database)
+        failed = await langflow_endpoint(
+            ChatBody(prompt="Fail closed", stream=True),
+            chat_service=service,
+            session_manager=None,
+            user=user,
+        )
+        failed_chunks = await _collect_error_chunks(failed.body_iterator)
+        assert len(failed_chunks) == 1 and failed_chunks[0]["status"] == "failed"
+        assert "id" not in failed_chunks[0] and "response_id" not in failed_chunks[0]
+        assert (
+            await SessionOwnershipService(session_factory=factory).get_session_owner(
+                "resp-http-next"
+            )
+            is None
+        )
+        print(
+            "LOCAL SMOKE: disconnect/follow-up retained 4 messages; restart + "
+            "canonical deletion removed both upstream sessions and alias authorization; "
+            "persistent failures emitted no client ID"
+        )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("delta", [None, {"content": None}])
+async def test_metadata_only_chunk_claims_id_before_exposure(
+    monkeypatch, durable_stream_stores, delta
+):
+    async def upstream(*_args, **_kwargs):
+        yield (json.dumps({"id": "resp-metadata", "delta": delta}) + "\n").encode()
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    stream = agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")
+    chunk = json.loads(await anext(stream))
+    await _assert_owns(chunk["id"], "alice")
+    await stream.aclose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("delete_id", ["resp-first", "resp-second"])
+async def test_delete_canonical_revokes_aliases_after_reload(
+    monkeypatch, durable_stream_stores, delete_id
+):
+    ownership, persistence, factory = durable_stream_stores
+
+    async def upstream(*_args, **kwargs):
+        response_id = "resp-second" if kwargs.get("previous_response_id") else "resp-first"
+        yield (json.dumps({"id": response_id, "delta": {"content": "Answer"}}) + "\n").encode()
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    for previous in (None, "resp-first"):
+        await _collect_error_chunks(
+            agent_module.async_langflow_chat_stream(
+                object(), "flow", "Question", "alice", previous_response_id=previous
+            )
+        )
+    await ownership.claim_session("mallory", "resp-foreign")
+    await ownership.claim_session("alice", "resp-unrelated")
+    assert list(await persistence.get_user_conversations("alice")) == ["resp-first"]
+    assert await agent_module.delete_user_conversation("mallory", "resp-first") is False
+    assert agent_module.active_conversations["alice"]["resp-first"]["messages"]
+    # Restart: neither ownership cache nor the in-memory response_ids can help.
+    reloaded = SessionOwnershipService(session_factory=factory)
+    monkeypatch.setattr("services.session_ownership_service.session_ownership_service", reloaded)
+    monkeypatch.setattr(agent_module, "active_conversations", {})
+    persistence = ConversationPersistenceService(
+        storage_file=persistence.storage_file, session_factory=factory
+    )
+    monkeypatch.setattr(agent_module, "conversation_persistence", persistence)
+    assert await agent_module.delete_user_conversation("alice", delete_id) is True
+    fresh = SessionOwnershipService(session_factory=factory)
+    monkeypatch.setattr("services.session_ownership_service.session_ownership_service", fresh)
+    for response_id in ("resp-first", "resp-second"):
+        with pytest.raises(HTTPException) as missing:
+            await _assert_owns(response_id, "alice")
+        assert missing.value.status_code == 404
+    assert await fresh.get_session_owner("resp-foreign") == "mallory"
+    assert await fresh.get_session_owner("resp-unrelated") == "alice"
+    assert await persistence.get_user_conversations("alice") == {}
+
+
+@pytest.mark.asyncio
+async def test_persistent_claim_failure_never_exposes_cached_id(monkeypatch, durable_stream_stores):
+    ownership, persistence, factory = durable_stream_stores
+    # A real IO failure, not a stubbed claim: cache echo must not prove durability.
+    Path(ownership.ownership_file).mkdir()
+
+    def unavailable_database():
+        raise OSError("local database unavailable")
+
+    monkeypatch.setattr(ownership, "_resolve_session_factory", lambda: unavailable_database)
+
+    async def upstream(*_args, **_kwargs):
+        yield b'{"id":"resp-file-failure","delta":{"content":"Not exposed"}}\n'
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    chunks = await _collect_error_chunks(
+        agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")
+    )
+    assert len(chunks) == 1
+    assert chunks[0]["status"] == "failed"
+    assert "id" not in chunks[0] and "response_id" not in chunks[0]
+    assert await ownership.get_session_owner("resp-file-failure") is None
+    assert (
+        await SessionOwnershipService(session_factory=factory).get_session_owner(
+            "resp-file-failure"
+        )
+        is None
+    )
+    assert await persistence.get_user_conversations("alice") == {}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("durable_stream_stores", ["hybrid", "files"], indirect=True)
+async def test_failed_file_revocation_is_not_reported_as_success(
+    monkeypatch, durable_stream_stores
+):
+    ownership, _, _ = durable_stream_stores
+
+    async def upstream(*_args, **_kwargs):
+        yield b'{"id":"resp-delete-failure","delta":{"content":"Answer"}}\n'
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    await _collect_error_chunks(
+        agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")
+    )
+    ownership_path = Path(ownership.ownership_file)
+    ownership_path.unlink()
+    ownership_path.mkdir()
+
+    async def monitor_delete(_self, _session_id):
+        return True
+
+    monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)
+    result = await ChatService().delete_session("alice", "resp-delete-failure")
+    assert result["success"] is False
+    await _assert_owns("resp-delete-failure", "alice")
+    assert "resp-delete-failure" in agent_module.active_conversations["alice"]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("durable_stream_stores", ["hybrid"], indirect=True)
+async def test_json_only_alias_cleanup_precedes_failed_db_revocation(
+    monkeypatch, durable_stream_stores
+):
+    from db.repositories import SessionOwnershipRepo
+
+    ownership, _, factory = durable_stream_stores
+
+    async def upstream(*_args, **kwargs):
+        response_id = "alias" if kwargs.get("previous_response_id") else "canonical"
+        yield (json.dumps({"id": response_id, "delta": {"content": "Answer"}}) + "\n").encode()
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    await _collect_error_chunks(
+        agent_module.async_langflow_chat_stream(object(), "flow", "First", "alice")
+    )
+
+    def unavailable_database():
+        raise OSError("database temporarily unavailable")
+
+    ownership._session_factory = unavailable_database
+    await _collect_error_chunks(
+        agent_module.async_langflow_chat_stream(
+            object(), "flow", "Next", "alice", previous_response_id="canonical"
+        )
+    )
+    ownership._session_factory = factory
+    async with factory() as session:
+        assert await SessionOwnershipRepo(session).get("alias") is None
+    assert await ownership.get_session_owner("alias") == "alice"
+    original = SessionOwnershipRepo.release
+
+    async def failed_release(*_args):
+        raise OSError("database revocation failed")
+
+    upstream_deletes = []
+
+    async def monitor_delete(_self, session_id):
+        upstream_deletes.append(session_id)
+        return True
+
+    monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)
+    monkeypatch.setattr(SessionOwnershipRepo, "release", failed_release)
+    result = await ChatService().delete_session("alice", "canonical")
+    assert result["success"] is False
+    assert set(upstream_deletes) == {"canonical", "alias"}
+    # Even though JSON-only ownership was revoked, its upstream cleanup was not
+    # lost. The surviving canonical DB row can be retried after a restart.
+    reloaded = SessionOwnershipService(session_factory=factory)
+    monkeypatch.setattr("services.session_ownership_service.session_ownership_service", reloaded)
+    monkeypatch.setattr(SessionOwnershipRepo, "release", original)
+    assert (await ChatService().delete_session("alice", "canonical"))["success"] is True
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("storage", ["persisted", "memory"])
+@pytest.mark.parametrize("operation", ["direct", "single", "bulk"])
+async def test_delete_own_orphan_without_upstream_authorization(
+    monkeypatch, durable_stream_stores, storage, operation
+):
+    ownership, persistence, _ = durable_stream_stores
+    state = {"messages": [], "created_at": datetime.now()}
+    if storage == "persisted":
+        await persistence.store_conversation_thread("alice", "orphan", state)
+    else:
+        agent_module.active_conversations["alice"] = {"orphan": state}
+    assert await ownership.get_session_owner("orphan") is None
+    upstream_deletes = []
+
+    async def monitor_delete(_self, session_id):
+        upstream_deletes.append(session_id)
+        return True
+
+    monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)
+    if operation == "direct":
+        assert await agent_module.delete_user_conversation("alice", "orphan") is True
+    elif operation == "single":
+        assert (await ChatService().delete_session("alice", "orphan"))["success"] is True
+    else:
+        assert await ChatService().delete_sessions("alice", ["orphan"]) == {
+            "deleted": ["orphan"],
+            "failed": [],
+        }
+    assert await persistence.get_conversation_thread("alice", "orphan") == {}
+    assert "orphan" not in agent_module.active_conversations.get("alice", {})
+    assert upstream_deletes == []
+    with pytest.raises(HTTPException) as missing:
+        await _assert_owns("orphan", "alice")
+    assert missing.value.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_delete_all_removes_persisted_orphans_only_for_caller(
+    monkeypatch, durable_stream_stores
+):
+    _, persistence, _ = durable_stream_stores
+    state = {"messages": [], "created_at": datetime.now()}
+    await persistence.store_conversation_thread("alice", "orphan", state)
+    await persistence.store_conversation_thread("mallory", "foreign", state)
+    upstream_deletes = []
+
+    async def monitor_delete(_self, session_id):
+        upstream_deletes.append(session_id)
+        return True
+
+    monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)
+    assert await ChatService().delete_all_user_sessions("alice") == {
+        "success": True,
+        "deleted_count": 1,
+        "total_count": 1,
+    }
+    assert await persistence.get_user_conversations("alice") == {}
+    assert await persistence.get_conversation_thread("mallory", "foreign")
+    assert upstream_deletes == []
+
+
+@pytest.mark.asyncio
+async def test_missing_and_foreign_deletes_never_touch_upstream(monkeypatch, durable_stream_stores):
+    ownership, persistence, _ = durable_stream_stores
+    state = {"messages": [], "created_at": datetime.now()}
+    await persistence.store_conversation_thread("mallory", "foreign", state)
+    await ownership.claim_session("mallory", "foreign")
+    upstream_deletes = []
+
+    async def monitor_delete(_self, session_id):
+        upstream_deletes.append(session_id)
+        return True
+
+    monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)
+    service = ChatService()
+    for session_id in ("missing", "foreign"):
+        assert await agent_module.delete_user_conversation("alice", session_id) is False
+        assert (await service.delete_session("alice", session_id))["not_found"] is True
+    assert await service.delete_sessions("alice", ["missing", "foreign"]) == {
+        "deleted": [],
+        "failed": ["missing", "foreign"],
+    }
+    assert await persistence.get_conversation_thread("mallory", "foreign")
+    assert await ownership.get_session_owner("foreign") == "mallory"
+    assert upstream_deletes == []
+    user = SimpleNamespace(db_user_id="alice", user_id="oauth-alice")
+    for session_id, status in (("missing", 404), ("foreign", 403)):
+        with pytest.raises(HTTPException) as denied:
+            await delete_session_endpoint(session_id=session_id, chat_service=service, user=user)
+        assert denied.value.status_code == status
+
+
+@pytest.mark.asyncio
+async def test_delete_uses_one_owned_snapshot_for_upstream_and_revocation(
+    monkeypatch, durable_stream_stores
+):
+    ownership, _, _ = durable_stream_stores
+
+    async def upstream(*_args, **_kwargs):
+        yield b'{"id":"canonical","response_id":"alias","delta":{"content":"Answer"}}\n'
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    await _collect_error_chunks(
+        agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")
+    )
+    resolve = ownership.get_conversation_sessions
+    resolutions = []
+
+    async def resolve_once(user_id, session_id):
+        resolutions.append(session_id)
+        assert len(resolutions) == 1, "Deletion resolved a different ownership snapshot"
+        return await resolve(user_id, session_id)
+
+    upstream_deletes = []
+
+    async def monitor_delete(_self, session_id):
+        upstream_deletes.append(session_id)
+        if session_id == "canonical":
+            assert await ownership.claim_session("alice", "late-alias", "canonical")
+        return True
+
+    monkeypatch.setattr(ownership, "get_conversation_sessions", resolve_once)
+    monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)
+    result = await ChatService().delete_session("alice", "alias")
+    assert result["success"] is True
+    assert resolutions == ["alias"]
+    assert set(upstream_deletes) == {"canonical", "alias"}
+    assert await ownership.get_session_owner("canonical") is None
+    assert await ownership.get_session_owner("alias") is None
+    # A claim arriving after the snapshot is not revoked without upstream cleanup.
+    assert await ownership.get_session_owner("late-alias") == "alice"
+
+
+@pytest.mark.asyncio
+async def test_restart_alias_only_continuation_keeps_durable_canonical(
+    monkeypatch, durable_stream_stores
+):
+    _, persistence, factory = durable_stream_stores
+    calls = []
+
+    async def upstream(*_args, **kwargs):
+        calls.append(kwargs.get("previous_response_id"))
+        response_id = ("canonical", "alias", "after-restart")[len(calls) - 1]
+        yield (json.dumps({"id": response_id, "delta": {"content": "Answer"}}) + "\n").encode()
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    for previous in (None, "canonical"):
+        await _collect_error_chunks(
+            agent_module.async_langflow_chat_stream(
+                object(),
+                "flow",
+                "First question" if previous is None else "Follow-up",
+                "alice",
+                previous_response_id=previous,
+                filter_id="knowledge-filter" if previous is None else None,
+            )
+        )
+    before_restart = await persistence.get_conversation_thread("alice", "canonical")
+    assert before_restart["total_messages"] == 4
+    reloaded = SessionOwnershipService(session_factory=factory)
+    monkeypatch.setattr("services.session_ownership_service.session_ownership_service", reloaded)
+    monkeypatch.setattr(agent_module, "active_conversations", {})
+    reloaded_persistence = ConversationPersistenceService(
+        storage_file=persistence.storage_file, session_factory=factory
+    )
+    monkeypatch.setattr(agent_module, "conversation_persistence", reloaded_persistence)
+    await _assert_owns("alias", "alice")
+    await _collect_error_chunks(
+        agent_module.async_langflow_chat_stream(
+            object(), "flow", "After restart", "alice", previous_response_id="alias"
+        )
+    )
+    assert calls == [None, "canonical", "alias"]
+    assert list(await reloaded_persistence.get_user_conversations("alice")) == ["canonical"]
+    after_restart = await reloaded_persistence.get_conversation_thread("alice", "canonical")
+    assert after_restart["title"] == before_restart["title"] == "First question"
+    assert after_restart["created_at"] == before_restart["created_at"]
+    assert after_restart["filter_id"] == "knowledge-filter"
+    assert after_restart["total_messages"] == 6
+    fresh = SessionOwnershipService(session_factory=factory)
+    assert set(await fresh.get_conversation_sessions("alice", "after-restart")) == {
+        "canonical",
+        "alias",
+        "after-restart",
+    }
+    assert set(agent_module.active_conversations["alice"]) == {"canonical"}
diff --git a/tests/unit/services/test_session_ownership_service_modes.py b/tests/unit/services/test_session_ownership_service_modes.py
index 10f1ec2a1b..fe93fecab1 100644
--- a/tests/unit/services/test_session_ownership_service_modes.py
+++ b/tests/unit/services/test_session_ownership_service_modes.py
@@ -1,7 +1,11 @@
 """SessionOwnershipService — hybrid / db / files mode coverage."""
 
+import asyncio
 import json
+import os
+import stat
 import sys
+import threading
 from pathlib import Path
 
 import pytest
@@ -314,9 +318,12 @@ async def test_hybrid_losing_db_insert_cannot_publish_fallback_owner(
     # Model a competing claimant whose SELECT happened just before the winner's
     # insert. The ensuing flush hits the real DB primary-key constraint.
     original = SessionOwnershipRepo.get
+    stale_read = False
 
     async def stale_get(repo, response_id):
-        if response_id == "contended":
+        nonlocal stale_read
+        if response_id == "contended" and not stale_read:
+            stale_read = True
             return None
         return await original(repo, response_id)
 
@@ -334,8 +341,6 @@ async def stale_get(repo, response_id):
 async def test_hybrid_rechecks_cache_after_awaiting_database(
     monkeypatch, tmp_data_dir, session_factory
 ):
-    import asyncio
-
     monkeypatch.setenv("OPENRAG_STORAGE_MODE", "hybrid")
     svc = _svc(session_factory)
     waiting = asyncio.Event()
@@ -356,3 +361,260 @@ async def delayed_claim(user_id, session_id, conversation_id):
     winner_published.set()
     assert await losing_claim is False
     assert json.loads(tmp_data_dir.read_text())["contended"]["user_id"] == "alice"
+
+
+@pytest.mark.asyncio
+async def test_file_fsync_keeps_event_loop_responsive(monkeypatch, tmp_data_dir):
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "files")
+    svc = _svc(None)
+    heartbeat = threading.Event()
+    responsive = []
+    original_fsync = os.fsync
+
+    def delayed_fsync(fd):
+        responsive.append(heartbeat.wait(timeout=1))
+        original_fsync(fd)
+
+    monkeypatch.setattr(os, "fsync", delayed_fsync)
+    claim = asyncio.create_task(svc.claim_session("alice", "canonical"))
+    await asyncio.sleep(0)
+    heartbeat.set()
+    assert await claim is True
+    assert responsive and all(responsive), "fsync blocked the event-loop heartbeat"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("mutation", ["claim", "release", "release_group"])
+async def test_concurrent_file_mutations_keep_every_committed_change(
+    monkeypatch, tmp_data_dir, mutation
+):
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "files")
+    svc = _svc(None)
+    assert await svc.claim_session("alice", "existing") is True
+    assert await svc.claim_session("alice", "victim") is True
+    entered = threading.Event()
+    finish = threading.Event()
+    original_fsync = os.fsync
+
+    def pause_first_fsync(fd):
+        if not entered.is_set():
+            entered.set()
+            assert finish.wait(timeout=2), "file persistence blocked the event loop"
+        original_fsync(fd)
+
+    monkeypatch.setattr(os, "fsync", pause_first_fsync)
+    first = asyncio.create_task(svc.claim_session("alice", "first"))
+    try:
+        assert await asyncio.to_thread(entered.wait, 2)
+        if mutation == "claim":
+            operation = svc.claim_session("alice", "second")
+        elif mutation == "release":
+            operation = svc.release_session("alice", "victim")
+        else:
+            operation = svc.release_conversation_sessions("alice", ["victim"])
+        second = asyncio.create_task(operation)
+        await asyncio.sleep(0)
+    finally:
+        finish.set()
+    first_result, _ = await asyncio.gather(first, second)
+    assert first_result is True
+    expected = (
+        {"existing", "first", "victim", "second"}
+        if mutation == "claim"
+        else {
+            "existing",
+            "first",
+        }
+    )
+    assert set(svc.ownership_data) == expected
+    assert set(json.loads(tmp_data_dir.read_text())) == expected
+    assert set(await _svc(None).get_user_sessions("alice")) == expected
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("mutation", ["claim", "release", "release_group"])
+async def test_failed_file_mutation_preserves_durable_ownership(
+    monkeypatch, tmp_data_dir, mutation
+):
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "files")
+    svc = _svc(None)
+    assert await svc.claim_session("alice", "canonical") is True
+    before = tmp_data_dir.read_bytes()
+
+    def fail_replace(*args):
+        raise OSError("atomic replacement unavailable")
+
+    monkeypatch.setattr(os, "replace", fail_replace)
+    if mutation == "claim":
+        assert await svc.claim_session("alice", "alias", conversation_id="canonical") is False
+    else:
+        with pytest.raises(OSError, match="atomic replacement unavailable"):
+            if mutation == "release":
+                await svc.release_session("alice", "canonical")
+            else:
+                await svc.release_conversation_sessions("alice", ["canonical"])
+    assert tmp_data_dir.read_bytes() == before
+    assert svc.ownership_data == json.loads(before)
+    assert await _svc(None).get_user_sessions("alice") == ["canonical"]
+    assert list(tmp_data_dir.parent.iterdir()) == [tmp_data_dir]
+
+
+@pytest.mark.asyncio
+async def test_atomic_file_replacement_preserves_existing_permissions(monkeypatch, tmp_data_dir):
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "files")
+    svc = _svc(None)
+    assert await svc.claim_session("alice", "canonical") is True
+    tmp_data_dir.chmod(0o640)
+    assert await svc.claim_session("alice", "alias", conversation_id="canonical") is True
+    assert stat.S_IMODE(tmp_data_dir.stat().st_mode) == 0o640
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("mode", ["db", "hybrid"])
+@pytest.mark.parametrize(
+    ("winner_user", "winner_canonical", "accepted"),
+    [
+        ("alice", "canonical", True),
+        ("bob", "foreign", False),
+        ("alice", "other", False),
+    ],
+)
+async def test_real_database_claim_race_checks_winning_owner_and_conversation(
+    monkeypatch, tmp_data_dir, tmp_path, mode, winner_user, winner_canonical, accepted
+):
+    engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'ownership-race.db'}")
+    async with engine.begin() as connection:
+        await connection.run_sync(SQLModel.metadata.create_all)
+    factory = async_sessionmaker(engine, expire_on_commit=False)
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "db")
+    setup = _svc(factory)
+    for user, canonical in (("alice", "canonical"), ("alice", "other"), ("bob", "foreign")):
+        assert await setup.claim_session(user, canonical) is True
+    selected_missing = asyncio.Event()
+    winner_committed = asyncio.Event()
+    original_get = SessionOwnershipRepo.get
+
+    async def pause_after_missing_read(repo, response_id):
+        row = await original_get(repo, response_id)
+        if response_id == "contended" and row is None and not selected_missing.is_set():
+            selected_missing.set()
+            await winner_committed.wait()
+        return row
+
+    monkeypatch.setattr(SessionOwnershipRepo, "get", pause_after_missing_read)
+    loser = _svc(factory)
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", mode)
+    pending = asyncio.create_task(
+        loser.claim_session("alice", "contended", conversation_id="canonical")
+    )
+    try:
+        await asyncio.wait_for(selected_missing.wait(), timeout=2)
+        # The loser already read no row; this insert commits on another real
+        # connection before its stale INSERT hits the primary-key constraint.
+        monkeypatch.setenv("OPENRAG_STORAGE_MODE", "db")
+        assert (
+            await _svc(factory).claim_session(
+                winner_user, "contended", conversation_id=winner_canonical
+            )
+            is True
+        )
+        monkeypatch.setenv("OPENRAG_STORAGE_MODE", mode)
+    finally:
+        winner_committed.set()
+    try:
+        assert await pending is accepted
+        fresh = _svc(factory)
+        assert await fresh.get_session_owner("contended") == winner_user
+        if accepted:
+            assert set(await fresh.get_conversation_sessions("alice", "canonical")) == {
+                "canonical",
+                "contended",
+            }
+        else:
+            assert "contended" not in loser.ownership_data
+        if mode == "hybrid":
+            assert tmp_data_dir.exists() is accepted
+    finally:
+        await engine.dispose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("mode", ["db", "hybrid"])
+async def test_unrelated_database_integrity_error_is_not_an_owned_race(
+    monkeypatch, tmp_data_dir, session_factory, mode
+):
+    from sqlalchemy.exc import IntegrityError
+
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "db")
+    assert await _svc(session_factory).claim_session("alice", "canonical") is True
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", mode)
+    svc = _svc(session_factory)
+
+    async def unrelated_failure(*args):
+        raise IntegrityError("UPDATE session_ownership", {}, ValueError("unrelated constraint"))
+
+    monkeypatch.setattr(SessionOwnershipRepo, "claim", unrelated_failure)
+    with pytest.raises(IntegrityError, match="unrelated constraint"):
+        await svc.claim_session("alice", "canonical")
+    assert svc.ownership_data == {}
+    assert not tmp_data_dir.exists()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("mode", ["db", "hybrid"])
+async def test_nonunique_insert_integrity_error_cannot_reuse_compatible_owner(
+    monkeypatch, tmp_data_dir, session_factory, mode
+):
+    from sqlalchemy import text
+    from sqlalchemy.exc import IntegrityError
+
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "db")
+    assert await _svc(session_factory).claim_session("alice", "canonical") is True
+    async with session_factory() as session:
+        await session.execute(
+            text(
+                "CREATE TRIGGER reject_ownership_insert BEFORE INSERT ON session_ownership "
+                "BEGIN SELECT RAISE(ABORT, 'unrelated ownership constraint'); END"
+            )
+        )
+        await session.commit()
+    original_get = SessionOwnershipRepo.get
+    stale_read = False
+
+    async def stale_once(repo, response_id):
+        nonlocal stale_read
+        if response_id == "canonical" and not stale_read:
+            stale_read = True
+            return None
+        return await original_get(repo, response_id)
+
+    monkeypatch.setattr(SessionOwnershipRepo, "get", stale_once)
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", mode)
+    svc = _svc(session_factory)
+    with pytest.raises(IntegrityError, match="unrelated ownership constraint"):
+        await svc.claim_session("alice", "canonical")
+    assert svc.ownership_data == {}
+    assert not tmp_data_dir.exists()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("mode", ["db", "hybrid", "files"])
+async def test_legacy_null_association_remains_its_own_canonical_conversation(
+    monkeypatch, tmp_data_dir, session_factory, mode
+):
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", mode)
+    svc = _svc(session_factory)
+    assert await svc.claim_session("alice", "legacy") is True
+    assert await svc.claim_session("alice", "other") is True
+    if mode != "files":
+        async with session_factory() as session:
+            row = await SessionOwnershipRepo(session).get("legacy")
+            row.conversation_id = None
+            await session.commit()
+    if mode != "db":
+        data = json.loads(tmp_data_dir.read_text())
+        data["legacy"]["conversation_id"] = None
+        tmp_data_dir.write_text(json.dumps(data))
+    fresh = _svc(session_factory)
+    assert await fresh.claim_session("alice", "legacy", conversation_id="other") is False
+    assert await fresh.get_conversation_sessions("alice", "legacy") == ["legacy"]
diff --git a/tests/unit/test_chat_service_bulk_delete.py b/tests/unit/test_chat_service_bulk_delete.py
index 81783308ba..33b44fa8b2 100644
--- a/tests/unit/test_chat_service_bulk_delete.py
+++ b/tests/unit/test_chat_service_bulk_delete.py
@@ -16,22 +16,6 @@ def _patch_owner(monkeypatch, owners):
     )
 
 
-@pytest.mark.asyncio
-async def test_bulk_delete_mixed_ownership(monkeypatch):
-    svc = _make_service()
-    # alice owns s1; s2 is bob's; s3 has no owner
-    _patch_owner(monkeypatch, {"s1": "alice", "s2": "bob", "s3": None})
-    svc.delete_session = AsyncMock(return_value={"success": True, "error": None})
-
-    result = await svc.delete_sessions("alice", ["s1", "s2", "s3"])
-
-    assert result["deleted"] == ["s1"]
-    assert sorted(result["failed"]) == ["s2", "s3"]
-    # only the owned id ever reaches delete_session
-    called = {c.args[1] for c in svc.delete_session.call_args_list}
-    assert called == {"s1"}
-
-
 @pytest.mark.asyncio
 async def test_bulk_delete_all_succeed(monkeypatch):
     svc = _make_service()
diff --git a/tests/unit/test_langflow_stream_provider_errors.py b/tests/unit/test_langflow_stream_provider_errors.py
index faa4ea1ba9..be6f0bff55 100644
--- a/tests/unit/test_langflow_stream_provider_errors.py
+++ b/tests/unit/test_langflow_stream_provider_errors.py
@@ -1,31 +1,13 @@
-"""Langflow stream lifecycle and provider-error regressions.
-
-Only the upstream provider is replaced; cancellation regressions use the real
-conversation store and ownership guard, including durable SQLite ownership.
-"""
+"""Langflow provider-error formatting and stream error regressions."""
 
 from __future__ import annotations
 
-import asyncio
 import json
 from collections.abc import AsyncIterator
-from pathlib import Path
-from types import SimpleNamespace
 
-import anyio
-import httpx
 import pytest
-import pytest_asyncio
-from fastapi import HTTPException
-from openai import AsyncOpenAI
-from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
-from sqlmodel import SQLModel
 
 import agent as agent_module
-from api.chat import ChatBody, _assert_owns, delete_session_endpoint, langflow_endpoint
-from services.chat_service import ChatService
-from services.conversation_persistence_service import ConversationPersistenceService
-from services.session_ownership_service import SessionOwnershipService
 
 
 def test_format_provider_error_message_extracts_embedded_json():
@@ -119,6 +101,9 @@ async def claim_session(self, user_id, session_id, conversation_id=None):
         async def get_session_owner(self, session_id):
             return next((user_id for user_id, sid in claimed if sid == session_id), None)
 
+        async def get_conversation_sessions(self, user_id, session_id):
+            return []
+
     monkeypatch.setattr(agent_module, "store_conversation_thread", _store)
     monkeypatch.setattr(
         "services.session_ownership_service.session_ownership_service",
@@ -468,514 +453,3 @@ async def raise_provider_error(*_args, **_kwargs) -> AsyncIterator[bytes]:
     assert not stored_id.startswith("error_")
     assert chunks[0].get("id") == stored_id
     assert stored_id in agent_module.active_conversations.get(user_id, {})
-
-
-@pytest_asyncio.fixture(params=["db", "hybrid", "files"])
-async def durable_stream_stores(request, monkeypatch, tmp_path):
-    monkeypatch.setenv("OPENRAG_STORAGE_MODE", request.param)
-    engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'chat.db'}")
-    async with engine.begin() as connection:
-        await connection.run_sync(SQLModel.metadata.create_all)
-    factory = async_sessionmaker(engine, expire_on_commit=False)
-    monkeypatch.setattr(
-        "services.session_ownership_service.get_data_file",
-        lambda name: str(tmp_path / name),
-    )
-    ownership = SessionOwnershipService(session_factory=factory)
-    persistence = ConversationPersistenceService(
-        storage_file=str(tmp_path / "conversations.json"), session_factory=factory
-    )
-    monkeypatch.setattr("services.session_ownership_service.session_ownership_service", ownership)
-    monkeypatch.setattr(agent_module, "conversation_persistence", persistence)
-    monkeypatch.setattr(agent_module, "active_conversations", {})
-    yield ownership, persistence, factory
-    await engine.dispose()
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("abort", ["close", "cancel"])
-async def test_aborted_langflow_stream_keeps_owned_id_and_partial_turn(
-    monkeypatch, durable_stream_stores, abort
-):
-    ownership, persistence, factory = durable_stream_stores
-    waiting = asyncio.Event()
-    upstream_closed = asyncio.Event()
-    calls = []
-
-    async def upstream(*_args, **kwargs):
-        calls.append(kwargs.get("previous_response_id"))
-        try:
-            yield b'{"id":"resp-first","delta":{"content":"Partial answer"}}\n'
-            waiting.set()
-            await asyncio.Event().wait()
-        finally:
-            upstream_closed.set()
-
-    monkeypatch.setattr(agent_module, "async_stream", upstream)
-    stream = agent_module.async_langflow_chat_stream(object(), "flow", "First question", "alice")
-    chunk = json.loads(await anext(stream))
-    # The ID must already be durable when it first crosses the generator boundary.
-    await _assert_owns(chunk["id"], "alice")
-    assert (await persistence.get_conversation_thread("alice", chunk["id"]))["total_messages"] >= 1
-    if abort == "close":
-        await stream.aclose()
-    else:
-        pending = asyncio.create_task(anext(stream))
-        await waiting.wait()
-        pending.cancel()
-        with pytest.raises(asyncio.CancelledError):
-            await pending
-    assert upstream_closed.is_set()
-    # Reload ownership rather than relying on the live service's cache.
-    reloaded = SessionOwnershipService(session_factory=factory)
-    assert await reloaded.get_session_owner(chunk["id"]) == "alice"
-    with pytest.raises(HTTPException) as forbidden:
-        await _assert_owns(chunk["id"], "mallory")
-    assert forbidden.value.status_code == 403
-    with pytest.raises(HTTPException) as missing:
-        await _assert_owns("unknown-session", "alice")
-    assert missing.value.status_code == 404
-
-    async def continuation(*_args, **kwargs):
-        calls.append(kwargs.get("previous_response_id"))
-        yield b'{"id":"resp-next","response_id":"resp-next-alias","delta":{"content":"Next"}}\n'
-
-    monkeypatch.setattr(agent_module, "async_stream", continuation)
-    await _assert_owns(chunk["id"], "alice")
-    followup = agent_module.async_langflow_chat_stream(
-        object(),
-        "flow",
-        "Follow-up",
-        "alice",
-        previous_response_id=chunk["id"],
-        conversation_id=chunk["id"],
-    )
-    next_chunk = json.loads(await anext(followup))
-    await _assert_owns(next_chunk["id"], "alice")
-    await _assert_owns(next_chunk["response_id"], "alice")
-    assert await _collect_error_chunks(followup) == []
-    assert calls == [None, "resp-first"]  # Never replay the interrupted prompt.
-    conversations = await persistence.get_user_conversations("alice")
-    assert list(conversations) == ["resp-first"]  # Stable sidebar id, changing response ids.
-    messages = agent_module.active_conversations["alice"]["resp-first"]["messages"]
-    assert [(m["role"], m["content"]) for m in messages if m["role"] != "system"] == [
-        ("user", "First question"),
-        ("assistant", "Partial answer"),
-        ("user", "Follow-up"),
-        ("assistant", "Next"),
-    ]
-    assert conversations["resp-first"]["total_messages"] == 4
-
-    # SDK callers may only carry the changing response ID, not conversation_id.
-    await _collect_error_chunks(
-        agent_module.async_langflow_chat_stream(
-            object(),
-            "flow",
-            "Third question",
-            "alice",
-            previous_response_id=next_chunk["response_id"],
-        )
-    )
-    assert list(await persistence.get_user_conversations("alice")) == ["resp-first"]
-    assert calls == [None, "resp-first", "resp-next-alias"]
-    assert [m["content"] for m in messages if m["role"] == "user"] == [
-        "First question",
-        "Follow-up",
-        "Third question",
-    ]
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("claim_failure", ["unavailable", "foreign"])
-async def test_stream_does_not_expose_unowned_response_id(
-    monkeypatch, durable_stream_stores, claim_failure
-):
-    ownership, persistence, _ = durable_stream_stores
-    if claim_failure == "foreign":
-        await ownership.claim_session("mallory", "resp-unclaimable")
-    else:
-
-        async def unavailable(*_args, **_kwargs):
-            return False
-
-        monkeypatch.setattr(ownership, "claim_session", unavailable)
-
-    async def upstream(*_args, **_kwargs):
-        yield b'{"id":"resp-unclaimable","delta":{"content":"Not exposed"}}\n'
-
-    monkeypatch.setattr(agent_module, "async_stream", upstream)
-    chunks = await _collect_error_chunks(
-        agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")
-    )
-    assert len(chunks) == 1
-    assert chunks[0]["status"] == "failed"
-    assert "id" not in chunks[0] and "response_id" not in chunks[0]
-    assert await persistence.get_user_conversations("alice") == {}
-    assert await ownership.get_session_owner("resp-unclaimable") == (
-        "mallory" if claim_failure == "foreign" else None
-    )
-
-
-@pytest.mark.asyncio
-async def test_local_asgi_disconnect_smoke_preserves_followup(monkeypatch, durable_stream_stores):
-    """Real endpoint → generator → OpenAI SSE adapter → durable stores, locally."""
-    _, persistence, factory = durable_stream_stores
-    disconnected = anyio.Event()
-    upstream_closed = anyio.Event()
-    calls = []
-
-    class ProviderStream(httpx.AsyncByteStream):
-        async def __aiter__(self):
-            yield (
-                b"event: response.created\n"
-                b'data: {"type":"response.created","response":{"id":"resp-http"}}\n\n'
-            )
-            yield (
-                b"event: response.output_text.delta\n"
-                b'data: {"type":"response.output_text.delta","id":"resp-http",'
-                b'"delta":{"content":"Partial HTTP answer"}}\n\n'
-            )
-            await anyio.sleep_forever()
-
-        async def aclose(self):
-            upstream_closed.set()
-
-    async def provider(request):
-        payload = json.loads(request.content)
-        calls.append(payload)
-        if len(calls) == 1:
-            return httpx.Response(
-                200, headers={"content-type": "text/event-stream"}, stream=ProviderStream()
-            )
-        return httpx.Response(
-            200,
-            headers={"content-type": "text/event-stream"},
-            content=(
-                b"event: response.output_text.delta\n"
-                b'data: {"type":"response.output_text.delta","id":"resp-http-next",'
-                b'"delta":{"content":"Follow-up HTTP answer"}}\n\n'
-                b"event: response.completed\n"
-                b'data: {"type":"response.completed","response":{"id":"resp-http-next",'
-                b'"usage":{"input_tokens":3,"output_tokens":4,"total_tokens":7}}}\n\n'
-            ),
-        )
-
-    async with AsyncOpenAI(
-        api_key="local-test-only",
-        base_url="https://provider.invalid/v1",
-        http_client=httpx.AsyncClient(transport=httpx.MockTransport(provider)),
-        max_retries=0,
-    ) as client:
-
-        class EndpointChatService:
-            async def langflow_chat(self, prompt, _subject, _jwt, **kwargs):
-                return agent_module.async_langflow_chat_stream(
-                    client,
-                    "flow",
-                    prompt,
-                    kwargs["storage_user_id"],
-                    previous_response_id=kwargs["previous_response_id"],
-                    conversation_id=kwargs["conversation_id"],
-                )
-
-        user = SimpleNamespace(
-            user_id="oauth-alice",
-            db_user_id="alice",
-            jwt_token="local-test-only",
-            name="Alice",
-            email="alice@example.invalid",
-        )
-        service = EndpointChatService()
-        response = await langflow_endpoint(
-            ChatBody(prompt="First HTTP question", stream=True),
-            chat_service=service,
-            session_manager=None,
-            user=user,
-        )
-        emitted = []
-
-        async def send(message):
-            if message["type"] == "http.response.body" and message.get("body"):
-                chunk = json.loads(message["body"])
-                emitted.append(chunk)
-                response_id = chunk.get("id") or (chunk.get("response") or {}).get("id")
-                if response_id:
-                    await _assert_owns(response_id, "alice")
-                if chunk.get("delta", {}).get("content"):
-                    disconnected.set()
-
-        async def receive():
-            await disconnected.wait()
-            return {"type": "http.disconnect"}
-
-        # Starlette's real disconnect listener cancels the body iterator using an
-        # AnyIO cancel scope, rather than manually throwing into our generator.
-        with anyio.fail_after(5):
-            await response({"type": "http", "asgi": {"spec_version": "2.3"}}, receive, send)
-        assert upstream_closed.is_set()
-        assert len(emitted) == 2
-        metadata = await persistence.get_conversation_thread("alice", "resp-http")
-        assert metadata["total_messages"] == 2
-
-        followup = await langflow_endpoint(
-            ChatBody(
-                prompt="Next HTTP question",
-                stream=True,
-                previous_response_id="resp-http",
-                conversation_id="resp-http",
-            ),
-            chat_service=service,
-            session_manager=None,
-            user=user,
-        )
-        chunks = await _collect_error_chunks(followup.body_iterator)
-        await _assert_owns("resp-http-next", "alice")
-        assert chunks[-1]["response"]["usage"]["total_tokens"] == 7
-        assert calls[1]["previous_response_id"] == "resp-http"
-        assert [call["input"] for call in calls] == ["First HTTP question", "Next HTTP question"]
-        conversations = await persistence.get_user_conversations("alice")
-        assert list(conversations) == ["resp-http"]
-        assert conversations["resp-http"]["total_messages"] == 4
-        messages = agent_module.active_conversations["alice"]["resp-http"]["messages"]
-        assert [m["content"] for m in messages if m["role"] != "system"] == [
-            "First HTTP question",
-            "Partial HTTP answer",
-            "Next HTTP question",
-            "Follow-up HTTP answer",
-        ]
-
-        # Restart before canonical deletion: aliases must come from durable state.
-        reloaded = SessionOwnershipService(session_factory=factory)
-        monkeypatch.setattr(
-            "services.session_ownership_service.session_ownership_service", reloaded
-        )
-        monkeypatch.setattr(agent_module, "active_conversations", {})
-        upstream_deletes = []
-
-        async def monitor_delete(method, path):
-            assert method == "DELETE"
-            upstream_deletes.append(path.rsplit("/", 1)[-1])
-            return httpx.Response(204)
-
-        monkeypatch.setattr("services.chat_service.clients.langflow_request", monitor_delete)
-        deletion = await delete_session_endpoint(
-            session_id="resp-http", chat_service=ChatService(), user=user
-        )
-        assert deletion.status_code == 200
-        assert set(upstream_deletes) == {"resp-http", "resp-http-next"}
-        fresh = SessionOwnershipService(session_factory=factory)
-        monkeypatch.setattr("services.session_ownership_service.session_ownership_service", fresh)
-        with pytest.raises(HTTPException) as missing:
-            await langflow_endpoint(
-                ChatBody(
-                    prompt="Cannot resurrect", stream=True, previous_response_id="resp-http-next"
-                ),
-                chat_service=service,
-                session_manager=None,
-                user=user,
-            )
-        assert missing.value.status_code == 404
-        assert len(calls) == 2
-
-        # Actual endpoint + SSE adapter with both persistent destinations broken.
-        ownership_path = Path(fresh.ownership_file)
-        if ownership_path.exists():
-            ownership_path.unlink()
-        ownership_path.mkdir()
-
-        def unavailable_database():
-            raise OSError("local smoke database unavailable")
-
-        monkeypatch.setattr(fresh, "_resolve_session_factory", lambda: unavailable_database)
-        failed = await langflow_endpoint(
-            ChatBody(prompt="Fail closed", stream=True),
-            chat_service=service,
-            session_manager=None,
-            user=user,
-        )
-        failed_chunks = await _collect_error_chunks(failed.body_iterator)
-        assert len(failed_chunks) == 1 and failed_chunks[0]["status"] == "failed"
-        assert "id" not in failed_chunks[0] and "response_id" not in failed_chunks[0]
-        assert (
-            await SessionOwnershipService(session_factory=factory).get_session_owner(
-                "resp-http-next"
-            )
-            is None
-        )
-        print(
-            "LOCAL SMOKE: disconnect/follow-up retained 4 messages; restart + "
-            "canonical deletion removed both upstream sessions and alias authorization; "
-            "persistent failures emitted no client ID"
-        )
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("delta", [None, {"content": None}])
-async def test_metadata_only_chunk_claims_id_before_exposure(
-    monkeypatch, durable_stream_stores, delta
-):
-    async def upstream(*_args, **_kwargs):
-        yield (json.dumps({"id": "resp-metadata", "delta": delta}) + "\n").encode()
-
-    monkeypatch.setattr(agent_module, "async_stream", upstream)
-    stream = agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")
-    chunk = json.loads(await anext(stream))
-    await _assert_owns(chunk["id"], "alice")
-    await stream.aclose()
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("delete_id", ["resp-first", "resp-second"])
-async def test_delete_canonical_revokes_aliases_after_reload(
-    monkeypatch, durable_stream_stores, delete_id
-):
-    ownership, persistence, factory = durable_stream_stores
-
-    async def upstream(*_args, **kwargs):
-        response_id = "resp-second" if kwargs.get("previous_response_id") else "resp-first"
-        yield (json.dumps({"id": response_id, "delta": {"content": "Answer"}}) + "\n").encode()
-
-    monkeypatch.setattr(agent_module, "async_stream", upstream)
-    for previous in (None, "resp-first"):
-        await _collect_error_chunks(
-            agent_module.async_langflow_chat_stream(
-                object(), "flow", "Question", "alice", previous_response_id=previous
-            )
-        )
-    await ownership.claim_session("mallory", "resp-foreign")
-    await ownership.claim_session("alice", "resp-unrelated")
-    assert list(await persistence.get_user_conversations("alice")) == ["resp-first"]
-    assert await agent_module.delete_user_conversation("mallory", "resp-first") is False
-    assert agent_module.active_conversations["alice"]["resp-first"]["messages"]
-    # Restart: neither ownership cache nor the in-memory response_ids can help.
-    reloaded = SessionOwnershipService(session_factory=factory)
-    monkeypatch.setattr("services.session_ownership_service.session_ownership_service", reloaded)
-    monkeypatch.setattr(agent_module, "active_conversations", {})
-    persistence = ConversationPersistenceService(
-        storage_file=persistence.storage_file, session_factory=factory
-    )
-    monkeypatch.setattr(agent_module, "conversation_persistence", persistence)
-    assert await agent_module.delete_user_conversation("alice", delete_id) is True
-    fresh = SessionOwnershipService(session_factory=factory)
-    monkeypatch.setattr("services.session_ownership_service.session_ownership_service", fresh)
-    for response_id in ("resp-first", "resp-second"):
-        with pytest.raises(HTTPException) as missing:
-            await _assert_owns(response_id, "alice")
-        assert missing.value.status_code == 404
-    assert await fresh.get_session_owner("resp-foreign") == "mallory"
-    assert await fresh.get_session_owner("resp-unrelated") == "alice"
-    assert await persistence.get_user_conversations("alice") == {}
-
-
-@pytest.mark.asyncio
-async def test_persistent_claim_failure_never_exposes_cached_id(monkeypatch, durable_stream_stores):
-    ownership, persistence, factory = durable_stream_stores
-    # A real IO failure, not a stubbed claim: cache echo must not prove durability.
-    Path(ownership.ownership_file).mkdir()
-
-    def unavailable_database():
-        raise OSError("local database unavailable")
-
-    monkeypatch.setattr(ownership, "_resolve_session_factory", lambda: unavailable_database)
-
-    async def upstream(*_args, **_kwargs):
-        yield b'{"id":"resp-file-failure","delta":{"content":"Not exposed"}}\n'
-
-    monkeypatch.setattr(agent_module, "async_stream", upstream)
-    chunks = await _collect_error_chunks(
-        agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")
-    )
-    assert len(chunks) == 1
-    assert chunks[0]["status"] == "failed"
-    assert "id" not in chunks[0] and "response_id" not in chunks[0]
-    assert await ownership.get_session_owner("resp-file-failure") is None
-    assert (
-        await SessionOwnershipService(session_factory=factory).get_session_owner(
-            "resp-file-failure"
-        )
-        is None
-    )
-    assert await persistence.get_user_conversations("alice") == {}
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("durable_stream_stores", ["hybrid", "files"], indirect=True)
-async def test_failed_file_revocation_is_not_reported_as_success(
-    monkeypatch, durable_stream_stores
-):
-    ownership, _, _ = durable_stream_stores
-
-    async def upstream(*_args, **_kwargs):
-        yield b'{"id":"resp-delete-failure","delta":{"content":"Answer"}}\n'
-
-    monkeypatch.setattr(agent_module, "async_stream", upstream)
-    await _collect_error_chunks(
-        agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")
-    )
-    ownership_path = Path(ownership.ownership_file)
-    ownership_path.unlink()
-    ownership_path.mkdir()
-
-    async def monitor_delete(_self, _session_id):
-        return True
-
-    monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)
-    result = await ChatService().delete_session("alice", "resp-delete-failure")
-    assert result["success"] is False
-    await _assert_owns("resp-delete-failure", "alice")
-    assert "resp-delete-failure" in agent_module.active_conversations["alice"]
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("durable_stream_stores", ["hybrid"], indirect=True)
-async def test_json_only_alias_cleanup_precedes_failed_db_revocation(
-    monkeypatch, durable_stream_stores
-):
-    from db.repositories import SessionOwnershipRepo
-
-    ownership, _, factory = durable_stream_stores
-
-    async def upstream(*_args, **kwargs):
-        response_id = "alias" if kwargs.get("previous_response_id") else "canonical"
-        yield (json.dumps({"id": response_id, "delta": {"content": "Answer"}}) + "\n").encode()
-
-    monkeypatch.setattr(agent_module, "async_stream", upstream)
-    await _collect_error_chunks(
-        agent_module.async_langflow_chat_stream(object(), "flow", "First", "alice")
-    )
-
-    def unavailable_database():
-        raise OSError("database temporarily unavailable")
-
-    ownership._session_factory = unavailable_database
-    await _collect_error_chunks(
-        agent_module.async_langflow_chat_stream(
-            object(), "flow", "Next", "alice", previous_response_id="canonical"
-        )
-    )
-    ownership._session_factory = factory
-    async with factory() as session:
-        assert await SessionOwnershipRepo(session).get("alias") is None
-    assert await ownership.get_session_owner("alias") == "alice"
-    original = SessionOwnershipRepo.release
-
-    async def failed_release(*_args):
-        raise OSError("database revocation failed")
-
-    upstream_deletes = []
-
-    async def monitor_delete(_self, session_id):
-        upstream_deletes.append(session_id)
-        return True
-
-    monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)
-    monkeypatch.setattr(SessionOwnershipRepo, "release", failed_release)
-    result = await ChatService().delete_session("alice", "canonical")
-    assert result["success"] is False
-    assert set(upstream_deletes) == {"canonical", "alias"}
-    # Even though JSON-only ownership was revoked, its upstream cleanup was not
-    # lost. The surviving canonical DB row can be retried after a restart.
-    reloaded = SessionOwnershipService(session_factory=factory)
-    monkeypatch.setattr("services.session_ownership_service.session_ownership_service", reloaded)
-    monkeypatch.setattr(SessionOwnershipRepo, "release", original)
-    assert (await ChatService().delete_session("alice", "canonical"))["success"] is True

From e8b073b15309bbdcba52f997839e0728c323a8b6 Mon Sep 17 00:00:00 2001
From: Edwin Jose <edwinjose900@gmail.com>
Date: Fri, 23 Oct 2026 13:03:32 -0500
Subject: [PATCH 3/4] fix: address restored chat and ownership review findings

---
 docs/docs/core-components/chat.mdx            |   2 +
 src/agent.py                                  |  13 +-
 src/db/repositories/session_ownership_repo.py |  20 +--
 src/services/chat_service.py                  |   6 +-
 src/services/session_ownership_service.py     |   9 +-
 .../test_session_ownership_repo_savepoint.py  | 115 ++++++++++++++++++
 .../services/test_chat_session_lifecycle.py   |  37 ++++++
 .../test_session_ownership_service_modes.py   |  40 ++++++
 8 files changed, 229 insertions(+), 13 deletions(-)
 create mode 100644 tests/unit/db/repositories/test_session_ownership_repo_savepoint.py

diff --git a/docs/docs/core-components/chat.mdx b/docs/docs/core-components/chat.mdx
index 9ed17bfe21..c140ea2a99 100644
--- a/docs/docs/core-components/chat.mdx
+++ b/docs/docs/core-components/chat.mdx
@@ -40,10 +40,12 @@ Deleting a conversation revokes its canonical ID and all recorded aliases and at
 A deleted alias cannot be used to resume the conversation.
 Bulk deletion also removes the caller's own legacy local conversation records that have no ownership row.
 Those orphan records do not authorize upstream session deletion or bypass the ownership checks on chat requests.
+Orphan cleanup is bulk-only at the API: single-conversation delete endpoints return `404` for records without an ownership row.
 
 IDs are sent only after ownership and its conversation association have been persisted.
 In `files` mode this requires a successful file write; in `db` mode it requires a committed database write.
 File updates are serialized and persisted on a worker thread, so durable writes do not block the event loop or overwrite concurrent ownership changes.
+File writes sync both the file contents and the parent directory after atomic replacement before ownership is acknowledged.
 In `hybrid` mode the database is preferred, with a successful durable JSON write as fallback if the database is unavailable.
 If neither configured destination can persist the claim, the stream returns an error without exposing a new response ID; an in-memory cache entry is not sufficient.
 
diff --git a/src/agent.py b/src/agent.py
index f25a558a81..39ac4d0cb0 100644
--- a/src/agent.py
+++ b/src/agent.py
@@ -931,15 +931,22 @@ async def async_langflow_chat_stream(
                 persisted_metadata = await conversation_persistence.get_conversation_thread(
                     user_id, thread_id
                 )
+    from datetime import datetime
+
     conversation_state = get_conversation_thread(user_id, thread_id)
     if persisted_metadata:
         conversation_state["_persisted_metadata"] = persisted_metadata
-        conversation_state["created_at"] = persisted_metadata.get("created_at")
+        restored_created_at = persisted_metadata.get("created_at")
+        if isinstance(restored_created_at, str):
+            try:
+                restored_created_at = datetime.fromisoformat(restored_created_at)
+            except ValueError:
+                restored_created_at = None
+        if isinstance(restored_created_at, datetime):
+            conversation_state["created_at"] = restored_created_at
         conversation_state["filter_id"] = persisted_metadata.get("filter_id")
         conversation_state["response_ids"] = list(owned_session_ids)
 
-    from datetime import datetime
-
     conversation_state["messages"].append(
         {"role": "user", "content": prompt, "timestamp": datetime.now()}
     )
diff --git a/src/db/repositories/session_ownership_repo.py b/src/db/repositories/session_ownership_repo.py
index 537eae2448..64ef9d42ca 100644
--- a/src/db/repositories/session_ownership_repo.py
+++ b/src/db/repositories/session_ownership_repo.py
@@ -36,9 +36,12 @@ async def claim(
                 created_at=now,
                 last_accessed=now,
             )
-            self.session.add(row)
             try:
-                await self.session.flush()
+                # begin_nested flushes pending caller work before establishing
+                # its savepoint, so add only this claim inside the savepoint.
+                async with self.session.begin_nested():
+                    self.session.add(row)
+                    await self.session.flush()
             except IntegrityError as exc:
                 # Only primary-key/unique violations can be an INSERT race.
                 # Never hide another constraint failure behind a matching row.
@@ -48,14 +51,17 @@ async def claim(
                     != "SQLITE_CONSTRAINT_PRIMARYKEY"
                 ):
                     raise
-                # A failed flush leaves the transaction unusable. Roll it back
-                # before reading the committed winner of an INSERT race.
-                await self.session.rollback()
-                existing = await self.get(response_id)
+                # The savepoint has rolled back only this insert; preserve the
+                # caller's transaction while reading the winning claim afresh.
+                existing = await self.session.get(
+                    SessionOwnership, response_id, populate_existing=True
+                )
                 if existing is None:
                     raise
                 if canonical_id != response_id:
-                    canonical = await self.get(canonical_id)
+                    canonical = await self.session.get(
+                        SessionOwnership, canonical_id, populate_existing=True
+                    )
                     if canonical is None or canonical.user_id != user_id:
                         raise PermissionError("Conversation is not owned by this user") from None
             else:
diff --git a/src/services/chat_service.py b/src/services/chat_service.py
index f7901ebe9c..d4df2d0e8e 100644
--- a/src/services/chat_service.py
+++ b/src/services/chat_service.py
@@ -688,11 +688,12 @@ async def get_chat_history(self, user_id: str):
                     if first_user_msg
                     else "New chat"
                 )
+                persisted_metadata = conversation_state.get("_persisted_metadata", {})
 
                 conversations.append(
                     {
                         "response_id": response_id,
-                        "title": title,
+                        "title": persisted_metadata.get("title") or title,
                         "endpoint": "chat",
                         "messages": messages,
                         "created_at": conversation_state.get("created_at").isoformat()
@@ -703,7 +704,8 @@ async def get_chat_history(self, user_id: str):
                         else None,
                         "previous_response_id": conversation_state.get("previous_response_id"),
                         "filter_id": conversation_state.get("filter_id"),
-                        "total_messages": len(messages),
+                        "total_messages": (persisted_metadata.get("total_messages") or 0)
+                        + len(messages),
                         "source": "in_memory",
                     }
                 )
diff --git a/src/services/session_ownership_service.py b/src/services/session_ownership_service.py
index e83ff2993e..2c1b0bb384 100644
--- a/src/services/session_ownership_service.py
+++ b/src/services/session_ownership_service.py
@@ -61,7 +61,7 @@ def _load_ownership_data(self) -> dict[str, dict[str, Any]]:
         return {}
 
     def _save_ownership_data(self, data: dict[str, dict[str, Any]]) -> None:
-        """Write atomically on a worker thread; the caller publishes the cache."""
+        """Atomically replace and sync file + directory on the caller's worker thread."""
         temporary = None
         try:
             try:
@@ -78,6 +78,13 @@ def _save_ownership_data(self, data: dict[str, dict[str, Any]]) -> None:
                 f.flush()
                 os.fsync(f.fileno())
             os.replace(temporary, self.ownership_file)
+            temporary = None
+            # Persist the replacement directory entry before publishing ownership.
+            directory_fd = os.open(os.path.dirname(self.ownership_file), os.O_RDONLY)
+            try:
+                os.fsync(directory_fd)
+            finally:
+                os.close(directory_fd)
         finally:
             if temporary is not None and os.path.exists(temporary):
                 os.unlink(temporary)
diff --git a/tests/unit/db/repositories/test_session_ownership_repo_savepoint.py b/tests/unit/db/repositories/test_session_ownership_repo_savepoint.py
new file mode 100644
index 0000000000..e84bc108a4
--- /dev/null
+++ b/tests/unit/db/repositories/test_session_ownership_repo_savepoint.py
@@ -0,0 +1,115 @@
+"""Claim-race recovery must not discard the caller's transaction."""
+
+import sys
+from pathlib import Path
+
+import pytest
+import pytest_asyncio
+from sqlalchemy import text
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from sqlmodel import SQLModel
+
+ROOT = Path(__file__).resolve().parents[4]
+SRC = ROOT / "src"
+if str(SRC) not in sys.path:
+    sys.path.insert(0, str(SRC))
+
+import db.models  # noqa: E402,F401
+from db.models import SessionOwnership  # noqa: E402
+from db.repositories.session_ownership_repo import SessionOwnershipRepo  # noqa: E402
+
+
+@pytest_asyncio.fixture
+async def session_factory():
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+    async with engine.begin() as connection:
+        await connection.run_sync(SQLModel.metadata.create_all)
+    yield async_sessionmaker(engine, expire_on_commit=False)
+    await engine.dispose()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "winner_user,winner_canonical,accepted",
+    [("alice", "canonical", True), ("bob", "canonical", False), ("alice", "other", False)],
+)
+async def test_alias_race_preserves_pending_canonical_claim(
+    monkeypatch, session_factory, winner_user, winner_canonical, accepted
+):
+    async with session_factory() as session:
+        session.add(
+            SessionOwnership(
+                response_id="alias", user_id=winner_user, conversation_id=winner_canonical
+            )
+        )
+        await session.commit()
+
+    async with session_factory() as session:
+        repo = SessionOwnershipRepo(session)
+        canonical = await repo.claim("canonical", "alice")
+        # Keep additional unflushed work pending as begin_nested is entered.
+        canonical.last_accessed = canonical.created_at
+        original_get = repo.get
+        stale_read = False
+
+        async def stale_get(response_id):
+            nonlocal stale_read
+            if response_id == "alias" and not stale_read:
+                stale_read = True
+                return None
+            return await original_get(response_id)
+
+        monkeypatch.setattr(repo, "get", stale_get)
+        if accepted:
+            row = await repo.claim("alias", "alice", "canonical")
+            assert row.conversation_id == "canonical"
+        else:
+            with pytest.raises(PermissionError, match="ownership or conversation conflict"):
+                await repo.claim("alias", "alice", "canonical")
+        assert session.in_transaction()
+        assert (await original_get("canonical")).user_id == "alice"
+        await session.commit()
+
+    async with session_factory() as session:
+        repo = SessionOwnershipRepo(session)
+        assert (await repo.get("canonical")).user_id == "alice"
+        winner = await repo.get("alias")
+        assert (winner.user_id, winner.conversation_id) == (winner_user, winner_canonical)
+
+
+@pytest.mark.asyncio
+async def test_nonunique_constraint_is_not_recovered_as_matching_winner(
+    monkeypatch, session_factory
+):
+    async with session_factory() as session:
+        repo = SessionOwnershipRepo(session)
+        await repo.claim("canonical", "alice")
+        await repo.claim("alias", "alice", "canonical")
+        await session.execute(
+            text(
+                "CREATE TRIGGER reject_alias BEFORE INSERT ON session_ownership "
+                "WHEN NEW.response_id = 'alias' BEGIN "
+                "SELECT RAISE(ABORT, 'unrelated ownership constraint'); END"
+            )
+        )
+        await session.commit()
+
+    async with session_factory() as session:
+        repo = SessionOwnershipRepo(session)
+        await repo.claim("prior", "alice")
+        original_get = repo.get
+
+        async def stale_get(response_id):
+            if response_id == "alias":
+                return None
+            return await original_get(response_id)
+
+        monkeypatch.setattr(repo, "get", stale_get)
+        with pytest.raises(IntegrityError, match="unrelated ownership constraint"):
+            await repo.claim("alias", "alice", "canonical")
+        assert session.is_active
+        await session.commit()
+
+    async with session_factory() as session:
+        assert (await SessionOwnershipRepo(session).get("prior")).user_id == "alice"
diff --git a/tests/unit/services/test_chat_session_lifecycle.py b/tests/unit/services/test_chat_session_lifecycle.py
index b8ad18ec03..f3750fbac2 100644
--- a/tests/unit/services/test_chat_session_lifecycle.py
+++ b/tests/unit/services/test_chat_session_lifecycle.py
@@ -719,6 +719,11 @@ async def upstream(*_args, **kwargs):
     assert after_restart["created_at"] == before_restart["created_at"]
     assert after_restart["filter_id"] == "knowledge-filter"
     assert after_restart["total_messages"] == 6
+    history = await ChatService().get_chat_history("alice")
+    restored = next(c for c in history["conversations"] if c["response_id"] == "canonical")
+    assert restored["created_at"] == before_restart["created_at"]
+    assert restored["title"] == "First question"
+    assert restored["total_messages"] == 6
     fresh = SessionOwnershipService(session_factory=factory)
     assert set(await fresh.get_conversation_sessions("alice", "after-restart")) == {
         "canonical",
@@ -726,3 +731,35 @@ async def upstream(*_args, **kwargs):
         "after-restart",
     }
     assert set(agent_module.active_conversations["alice"]) == {"canonical"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("durable_stream_stores", ["files"], indirect=True)
+@pytest.mark.parametrize("created_at", [None, "not-a-date", 123])
+async def test_restart_invalid_creation_time_keeps_default(
+    monkeypatch, durable_stream_stores, created_at
+):
+    ownership, persistence, _ = durable_stream_stores
+    await ownership.claim_session("alice", "canonical")
+    await ownership.claim_session("alice", "alias", conversation_id="canonical")
+    await persistence.store_conversation_thread(
+        "alice",
+        "canonical",
+        {"title": "Saved title", "created_at": created_at, "total_messages": 4},
+    )
+
+    async def upstream(*_args, **_kwargs):
+        yield b'{"id":"next","delta":{"content":"Answer"}}\n'
+
+    monkeypatch.setattr(agent_module, "async_stream", upstream)
+    started = datetime.now()
+    await _collect_error_chunks(
+        agent_module.async_langflow_chat_stream(
+            object(), "flow", "Follow-up", "alice", previous_response_id="alias"
+        )
+    )
+    history = await ChatService().get_chat_history("alice")
+    restored = next(c for c in history["conversations"] if c["response_id"] == "canonical")
+    assert started <= datetime.fromisoformat(restored["created_at"]) <= datetime.now()
+    assert restored["title"] == "Saved title"
+    assert restored["total_messages"] == 6
diff --git a/tests/unit/services/test_session_ownership_service_modes.py b/tests/unit/services/test_session_ownership_service_modes.py
index fe93fecab1..46e9648b52 100644
--- a/tests/unit/services/test_session_ownership_service_modes.py
+++ b/tests/unit/services/test_session_ownership_service_modes.py
@@ -459,6 +459,46 @@ def fail_replace(*args):
     assert list(tmp_data_dir.parent.iterdir()) == [tmp_data_dir]
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("sync_fails", [False, True])
+async def test_file_claim_waits_for_directory_durability_before_publishing(
+    monkeypatch, tmp_data_dir, sync_fails
+):
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", "files")
+    svc = _svc(None)
+    entered = threading.Event()
+    finish = threading.Event()
+    directory_fds = []
+    original_fsync = os.fsync
+
+    def pause_directory_fsync(fd):
+        if stat.S_ISDIR(os.fstat(fd).st_mode):
+            directory_fds.append(fd)
+            entered.set()
+            assert finish.wait(timeout=2), "directory sync blocked the event loop"
+            if sync_fails:
+                raise OSError("directory sync unavailable")
+        original_fsync(fd)
+
+    monkeypatch.setattr(os, "fsync", pause_directory_fsync)
+    claim = asyncio.create_task(svc.claim_session("alice", "canonical"))
+    try:
+        assert await asyncio.to_thread(entered.wait, 2)
+        # Replacement alone is not a durable claim and must not authorize it.
+        assert json.loads(tmp_data_dir.read_text())["canonical"]["user_id"] == "alice"
+        assert not claim.done()
+        assert await svc.get_session_owner("canonical") is None
+    finally:
+        finish.set()
+        result = await claim
+    assert result is not sync_fails
+    assert await svc.get_session_owner("canonical") == (None if sync_fails else "alice")
+    assert len(directory_fds) == 1
+    with pytest.raises(OSError):
+        os.fstat(directory_fds[0])
+    assert list(tmp_data_dir.parent.iterdir()) == [tmp_data_dir]
+
+
 @pytest.mark.asyncio
 async def test_atomic_file_replacement_preserves_existing_permissions(monkeypatch, tmp_data_dir):
     monkeypatch.setenv("OPENRAG_STORAGE_MODE", "files")

From 04b4f9fd551e892f27a75f8fdd2c6a3240a6f3f9 Mon Sep 17 00:00:00 2001
From: Edwin Jose <edwinjose900@gmail.com>
Date: Fri, 23 Oct 2026 13:29:02 -0500
Subject: [PATCH 4/4] fix: reconcile ownership after indeterminate file writes

---
 docs/docs/core-components/chat.mdx            |  1 +
 src/services/session_ownership_service.py     | 82 +++++++++++++++----
 .../test_session_ownership_service_modes.py   | 49 +++++++++++
 3 files changed, 117 insertions(+), 15 deletions(-)

diff --git a/docs/docs/core-components/chat.mdx b/docs/docs/core-components/chat.mdx
index c140ea2a99..7ed92b7c58 100644
--- a/docs/docs/core-components/chat.mdx
+++ b/docs/docs/core-components/chat.mdx
@@ -46,6 +46,7 @@ IDs are sent only after ownership and its conversation association have been per
 In `files` mode this requires a successful file write; in `db` mode it requires a committed database write.
 File updates are serialized and persisted on a worker thread, so durable writes do not block the event loop or overwrite concurrent ownership changes.
 File writes sync both the file contents and the parent directory after atomic replacement before ownership is acknowledged.
+If directory sync fails after replacement, file-backed authorization is suspended and further file mutations require a successful reload and directory sync, preventing updates from overwriting ownership changes with stale cached data.
 In `hybrid` mode the database is preferred, with a successful durable JSON write as fallback if the database is unavailable.
 If neither configured destination can persist the claim, the stream returns an error without exposing a new response ID; an in-memory cache entry is not sufficient.
 
diff --git a/src/services/session_ownership_service.py b/src/services/session_ownership_service.py
index 2c1b0bb384..e9c3277cae 100644
--- a/src/services/session_ownership_service.py
+++ b/src/services/session_ownership_service.py
@@ -34,6 +34,10 @@
 logger = get_logger(__name__)
 
 
+class _IndeterminateOwnershipWrite(OSError):
+    """The replacement is visible, but its directory entry was not synced."""
+
+
 class SessionOwnershipService:
     """Tracks which user owns which session."""
 
@@ -42,6 +46,7 @@ def __init__(self, session_factory: Callable | None = None):
         os.makedirs(os.path.dirname(self.ownership_file), exist_ok=True)
         self._session_factory = session_factory
         self._file_lock = asyncio.Lock()
+        self._file_state_indeterminate = False
         # JSON cache — eagerly loaded so `files` and `hybrid` modes
         # behave like the legacy implementation.
         self.ownership_data: dict[str, dict[str, Any]] = self._load_ownership_data()
@@ -80,27 +85,52 @@ def _save_ownership_data(self, data: dict[str, dict[str, Any]]) -> None:
             os.replace(temporary, self.ownership_file)
             temporary = None
             # Persist the replacement directory entry before publishing ownership.
-            directory_fd = os.open(os.path.dirname(self.ownership_file), os.O_RDONLY)
             try:
-                os.fsync(directory_fd)
-            finally:
-                os.close(directory_fd)
+                directory_fd = os.open(os.path.dirname(self.ownership_file), os.O_RDONLY)
+                try:
+                    os.fsync(directory_fd)
+                finally:
+                    os.close(directory_fd)
+            except OSError as exc:
+                raise _IndeterminateOwnershipWrite(str(exc)) from exc
         finally:
             if temporary is not None and os.path.exists(temporary):
                 os.unlink(temporary)
 
+    def _read_and_sync_ownership_data(self) -> dict[str, dict[str, Any]]:
+        """Strictly reload an uncertain replacement and make its name durable."""
+        with open(self.ownership_file) as f:
+            data = json.load(f)
+        directory_fd = os.open(os.path.dirname(self.ownership_file), os.O_RDONLY)
+        try:
+            os.fsync(directory_fd)
+        finally:
+            os.close(directory_fd)
+        return data
+
+    async def _reconcile_ownership_data(self) -> None:
+        """Reconcile before mutation, under ``_file_lock``; failures stay closed."""
+        if self._file_state_indeterminate:
+            data = await asyncio.to_thread(self._read_and_sync_ownership_data)
+            self.ownership_data = data
+            self._file_state_indeterminate = False
+
     async def _persist_ownership_data(self, data: dict[str, dict[str, Any]]) -> None:
         """Persist then publish while the caller holds ``_file_lock``."""
         write = asyncio.create_task(asyncio.to_thread(self._save_ownership_data, data))
         cancelled = False
-        while not write.done():
-            try:
-                await asyncio.shield(write)
-            except asyncio.CancelledError:
-                # Cancelling to_thread cannot stop its filesystem write. Keep
-                # the lock until it finishes so the next writer sees its state.
-                cancelled = True
-        write.result()
+        try:
+            while not write.done():
+                try:
+                    await asyncio.shield(write)
+                except asyncio.CancelledError:
+                    # Keep the lock until the worker finishes, even on cancellation.
+                    cancelled = True
+            write.result()
+        except _IndeterminateOwnershipWrite:
+            # A failed sync cannot undo an already completed replacement.
+            self._file_state_indeterminate = True
+            raise
         self.ownership_data = data
         if cancelled:
             raise asyncio.CancelledError
@@ -119,8 +149,15 @@ async def claim_session(
         An unsuccessful write never adds an authorization entry to the cache.
         """
         canonical_id = conversation_id or session_id
-        if file_writes_enabled() and self._file_claim_conflicts(user_id, session_id, canonical_id):
-            return False
+        if file_writes_enabled():
+            async with self._file_lock:
+                try:
+                    await self._reconcile_ownership_data()
+                except Exception as exc:
+                    logger.error("File ownership reconciliation failed", error=str(exc))
+                    return False
+                if self._file_claim_conflicts(user_id, session_id, canonical_id):
+                    return False
         durable = False
         if db_writes_enabled():
             try:
@@ -129,6 +166,11 @@ async def claim_session(
                 return False
         if file_writes_enabled():
             async with self._file_lock:
+                try:
+                    await self._reconcile_ownership_data()
+                except Exception as exc:
+                    logger.error("File ownership reconciliation failed", error=str(exc))
+                    return durable
                 # Recheck after DB work and after any pending file publication.
                 if self._file_claim_conflicts(user_id, session_id, canonical_id):
                     return False
@@ -164,6 +206,8 @@ async def get_session_owner(self, session_id: str) -> str | None:
             if mode == "db":
                 return None
         # files or hybrid-with-no-db-row → fall back to JSON
+        if self._file_state_indeterminate:
+            return None
         data = self.ownership_data.get(session_id)
         return data.get("user_id") if data else None
 
@@ -175,10 +219,14 @@ async def get_user_sessions(self, user_id: str) -> list[str]:
                 return db_sessions
             # hybrid: union with JSON-only entries
             json_sessions = [
-                sid for sid, data in self.ownership_data.items() if data.get("user_id") == user_id
+                sid
+                for sid, data in self.ownership_data.items()
+                if not self._file_state_indeterminate and data.get("user_id") == user_id
             ]
             return list(dict.fromkeys(db_sessions + json_sessions))
         # files mode
+        if self._file_state_indeterminate:
+            return []
         return [sid for sid, data in self.ownership_data.items() if data.get("user_id") == user_id]
 
     async def is_session_owned_by_user(self, session_id: str, user_id: str) -> bool:
@@ -195,6 +243,8 @@ async def get_conversation_sessions(self, user_id: str, session_id: str) -> list
         durable aliases authorized while reporting successful removal.
         """
         mode = get_storage_mode()
+        if mode != "db" and self._file_state_indeterminate:
+            raise RuntimeError("File ownership state requires reconciliation")
         files = self.ownership_data if mode != "db" else {}
         data = files.get(session_id, {})
         canonical_id = (
@@ -255,6 +305,7 @@ async def release_conversation_sessions(self, user_id: str, session_ids: list[st
         """
         if file_writes_enabled():
             async with self._file_lock:
+                await self._reconcile_ownership_data()
                 updated = dict(self.ownership_data)
                 for session_id in session_ids:
                     if updated.get(session_id, {}).get("user_id") == user_id:
@@ -279,6 +330,7 @@ async def release_session(self, user_id: str, session_id: str) -> bool:
 
         if file_writes_enabled():
             async with self._file_lock:
+                await self._reconcile_ownership_data()
                 existing = self.ownership_data.get(session_id)
                 if existing is not None:
                     if existing.get("user_id") == user_id:
diff --git a/tests/unit/services/test_session_ownership_service_modes.py b/tests/unit/services/test_session_ownership_service_modes.py
index 46e9648b52..af0f64034c 100644
--- a/tests/unit/services/test_session_ownership_service_modes.py
+++ b/tests/unit/services/test_session_ownership_service_modes.py
@@ -658,3 +658,52 @@ async def test_legacy_null_association_remains_its_own_canonical_conversation(
     fresh = _svc(session_factory)
     assert await fresh.claim_session("alice", "legacy", conversation_id="other") is False
     assert await fresh.get_conversation_sessions("alice", "legacy") == ["legacy"]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("mode", ["files", "hybrid"])
+@pytest.mark.parametrize("operation", ["claim", "release", "release_group"])
+async def test_directory_sync_failure_reconciles_before_next_mutation(
+    monkeypatch, tmp_data_dir, session_factory, mode, operation
+):
+    monkeypatch.setenv("OPENRAG_STORAGE_MODE", mode)
+    svc = _svc(session_factory)
+    if mode == "hybrid":
+        # Exercise the JSON fallback without a successful database write.
+        monkeypatch.setattr(svc, "_resolve_session_factory", lambda: None)
+    assert await svc.claim_session("alice", "existing")
+    real_fsync = os.fsync
+
+    def failed_directory_sync(fd):
+        if stat.S_ISDIR(os.fstat(fd).st_mode):
+            raise OSError("directory sync unavailable")
+        real_fsync(fd)
+
+    monkeypatch.setattr(os, "fsync", failed_directory_sync)
+    if operation == "claim":
+        assert await svc.claim_session("alice", "uncertain") is False
+    else:
+        with pytest.raises(OSError, match="directory sync unavailable"):
+            if operation == "release":
+                await svc.release_session("alice", "existing")
+            else:
+                await svc.release_conversation_sessions("alice", ["existing"])
+    replaced = json.loads(tmp_data_dir.read_text())
+    assert ("uncertain" in replaced) == (operation == "claim")
+    assert ("existing" in replaced) == (operation == "claim")
+    # Neither authorization nor subsequent mutations may use the stale cache.
+    assert await svc.get_session_owner("existing") is None
+    assert await svc.get_user_sessions("alice") == []
+    assert await svc.claim_session("alice", "later") is False
+    with pytest.raises(OSError, match="directory sync unavailable"):
+        await svc.release_session("alice", "existing")
+    assert json.loads(tmp_data_dir.read_text()) == replaced
+
+    monkeypatch.setattr(os, "fsync", real_fsync)
+    assert await svc.claim_session("alice", "later") is True
+    recovered = _svc(session_factory)
+    if mode == "hybrid":
+        monkeypatch.setattr(recovered, "_resolve_session_factory", lambda: None)
+    expected = {"existing", "uncertain", "later"} if operation == "claim" else {"later"}
+    assert set(await svc.get_user_sessions("alice")) == expected
+    assert set(await recovered.get_user_sessions("alice")) == expected