diff --git a/README.md b/README.md
index fcfd189..baf4329 100644
--- a/README.md
+++ b/README.md
@@ -402,6 +402,24 @@ What is kept, all beside the database files in that folder:
   `.corrupt-<id>` file and a valid backup looks like exactly that interrupted
   recovery and is restored, so to start over on purpose remove the backups and
   the `.corrupt-<id>` files along with it (they hold copies of your chats).
+- Deleting chats frees space inside `cortex_db.sqlite` but not on disk. At
+  launch, once that launch's backup has been written and verified, Cortex hands
+  the space back when more than a quarter of the file is free. A database
+  created by this release does it in small steps; an older one is rewritten
+  once (which needs roughly twice its size free on the data drive and the
+  temporary-files drive, and is skipped when there is not, when the database
+  holds over 1 GiB, or when it takes over 20 seconds). A skipped or interrupted
+  pass changes nothing. One that was skipped for lack of room or because
+  another program had the database open is tried again on the next launch; a
+  rewrite that failed or ran out of its 20 seconds is not tried again for seven
+  days (a small `cortex_db.sqlite.reclaim-backoff` file beside the database
+  holds only the time it failed; deleting it lifts the wait), so a very large
+  old database does not add those seconds to every launch.
+- Chats imported from the old JSON `chat_history` folder are moved to
+  `chat_history_migrated_<time>` and files that could not be read to
+  `chat_history/quarantine`. Once the `chat_history` folder is completely empty
+  it is renamed to `chat_history.retired` (never deleted, so it is yours to
+  remove); anything still in it is left where it is.
 
 Cortex needs write-ahead logging, so the data directory has to be on a local
 drive SQLite can use it on; some network, cloud-synced and removable drives
diff --git a/backend/cortex_backend/api/routers/chats.py b/backend/cortex_backend/api/routers/chats.py
index 267b71b..840e0f6 100644
--- a/backend/cortex_backend/api/routers/chats.py
+++ b/backend/cortex_backend/api/routers/chats.py
@@ -367,6 +367,7 @@ async def regenerate_chat(
                         reservation=reservation,
                         target_message_id=payload.message_id,
                         transcript=messages,
+                        transcript_revision=current_revision,
                     )
                 finally:
                     request.app.state.jobs.abort_reservation(
diff --git a/backend/cortex_backend/api/routes.py b/backend/cortex_backend/api/routes.py
index 2dbc672..e4ffa79 100644
--- a/backend/cortex_backend/api/routes.py
+++ b/backend/cortex_backend/api/routes.py
@@ -13,10 +13,12 @@
 from pathlib import Path
 from threading import Event as ThreadEvent, Thread
 import asyncio
+import errno
 import hashlib
 import json
 import logging
 import re
+import sqlite3
 from typing import Any, NoReturn, cast
 from uuid import uuid4
 
@@ -311,17 +313,24 @@ async def _start_generation_job(
     reservation: JobReservation | None = None,
     target_message_id: str | None = None,
     transcript: Sequence[Mapping[str, Any]] | None = None,
+    transcript_revision: int | None = None,
 ) -> tuple[JobSnapshot, str | None]:
     """Atomically admit, prepare, and run one authoritative generation job.
 
     A regeneration passes ``transcript``, the messages its route already read to
-    validate the target, so the chat is not read again. A new turn passes
-    nothing: admission needs only the chat's overview, and preparation reads
-    the transcript once, because the model needs it as history. Either way the
-    generation service is handed its history and never loads it itself.
+    validate the target, and ``transcript_revision``, the revision that read
+    returned (a regeneration changes a message without changing how many there
+    are, so the revision cannot be derived from the transcript), so the chat is
+    not read again. A new turn passes neither: admission needs only the chat's
+    overview, and preparation reads the transcript once, because the model
+    needs it as history. Either way the generation service is handed its
+    history and never loads it itself.
     """
-    if (target_message_id is None) != (transcript is None):
-        raise ValueError("a regeneration needs its transcript and a new turn has none")
+    regenerating = target_message_id is not None
+    if regenerating != (transcript is not None) or regenerating != (transcript_revision is not None):
+        raise ValueError(
+            "a regeneration needs its transcript and its revision and a new turn has neither"
+        )
     jobs = request.app.state.jobs
     candidate_thread_id = payload.thread_id or uuid4().hex
     if reservation is None:
@@ -347,12 +356,16 @@ async def _start_generation_job(
     try:
         target_position = -1
         target_role = ""
-        if transcript is not None and target_message_id is not None:
+        if (
+            transcript is not None
+            and target_message_id is not None
+            and transcript_revision is not None
+        ):
             # The route read the chat and answered 404 if it was missing.
             target_position, target_role = _regeneration_target(
                 transcript, target_message_id
             )
-            admission_revision = len(transcript)
+            admission_revision = transcript_revision
         else:
             # Only the revision is needed to admit a new turn, so read the
             # overview rather than every message of what may be a long thread.
@@ -459,8 +472,8 @@ def prepare() -> Mapping[str, Any]:
                 # The route validated this target against the transcript it
                 # read. That still holds as long as nothing was appended since:
                 # a chat only grows, and this reserved job is the only writer
-                # that replaces a reply. The message count is the revision, so
-                # the overview answers it without reading the transcript again.
+                # that replaces a reply. The overview carries the revision, so
+                # it answers this without reading the transcript again.
                 overview = deps.chats.get_chat_overview(thread_id)
                 if overview is None:
                     raise ChatDomainError("Chat not found.", code="not_found")
@@ -477,7 +490,7 @@ def prepare() -> Mapping[str, Any]:
             # and that write is guarded by the revision it was read at.
             current_chat = deps.chats.get_chat(thread_id)
             existing = list(current_chat.get("messages", ())) if current_chat else []
-            if len(existing) != admission_revision:
+            if (chat_revision(current_chat) if current_chat else 0) != admission_revision:
                 raise ChatDomainError(
                     "This chat changed. Reload it before generating again.",
                     code="stale_revision",
@@ -1467,6 +1480,34 @@ def _raise_job_error(exc: Exception) -> NoReturn:
     ) from exc
 
 
+# Windows reports a full volume as ERROR_DISK_FULL or ERROR_HANDLE_DISK_FULL,
+# which Python only sometimes maps to ENOSPC.
+_WINDOWS_DISK_FULL = frozenset({39, 112})
+
+
+def _is_disk_full(exc: BaseException) -> bool:
+    """Whether a repository failure, or anything it was raised from, is a full disk.
+
+    A store wraps what went wrong (``PersistenceError.cause``, or ``raise ...
+    from``), so the chain is followed. SQLite says "database or disk is full"
+    for SQLITE_FULL, and the file-copy paths raise ENOSPC.
+    """
+    seen: set[int] = set()
+    current: BaseException | None = exc
+    while current is not None and id(current) not in seen:
+        seen.add(id(current))
+        if isinstance(current, OSError) and (
+            current.errno in (errno.ENOSPC, getattr(errno, "EDQUOT", errno.ENOSPC))
+            or getattr(current, "winerror", None) in _WINDOWS_DISK_FULL
+        ):
+            return True
+        if isinstance(current, sqlite3.OperationalError) and "disk is full" in str(current).lower():
+            return True
+        cause = getattr(current, "cause", None)
+        current = cause if isinstance(cause, BaseException) else current.__cause__
+    return False
+
+
 def _raise_repository_error(operation: str, exc: Exception) -> NoReturn:
     if isinstance(exc, HTTPException):
         raise exc
@@ -1476,6 +1517,13 @@ def _raise_repository_error(operation: str, exc: Exception) -> NoReturn:
     # reports "Could not list chats" can be matched to the failure.
     request_id = current_request_id()
     log_failure(logger, f"Cortex API {operation} failed", exc, request_id=request_id)
+    if _is_disk_full(exc):
+        # Not the server's fault and not a bug: nothing was saved because there
+        # is no room, and the user can fix that.
+        raise HTTPException(
+            status_code=status.HTTP_507_INSUFFICIENT_STORAGE,
+            detail=f"Could not {operation} because the disk is full. Free some disk space and try again.",
+        ) from exc
     raise HTTPException(
         status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
         detail=f"Could not {operation}." + (f" (Request ID: {request_id})" if request_id else ""),
diff --git a/backend/cortex_backend/repositories/chats.py b/backend/cortex_backend/repositories/chats.py
index 51114b4..ce8ab90 100644
--- a/backend/cortex_backend/repositories/chats.py
+++ b/backend/cortex_backend/repositories/chats.py
@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from copy import deepcopy
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from threading import RLock
 from typing import Any, Protocol
 
@@ -104,6 +104,23 @@ def replace_message(
     ) -> None: ...
 
 
+def _typed_failure(exc: Exception) -> Exception:
+    """The repository error for an outcome the store reports by ``operation``.
+
+    The SQLite manager raises one ``PersistenceError`` type and names what
+    happened in ``operation``; callers and the in-memory double speak in typed
+    errors. Anything else comes back unchanged.
+    """
+    operation = getattr(exc, "operation", None)
+    if operation == "chat_revision_conflict":
+        return ChatRevisionConflict(str(exc))
+    if operation == "chat_not_found":
+        return ChatNotFound("Chat does not exist.")
+    if operation == "message_not_found":
+        return MessageNotFound("Message does not exist.")
+    return exc
+
+
 class LegacyDatabaseChatRepository:
     """Adapt the merged SQLite manager without importing the legacy module."""
 
@@ -161,9 +178,10 @@ def add_message(
         try:
             result = self._database.add_message(thread_id, role, content, **kwargs)
         except Exception as exc:
-            if getattr(exc, "operation", None) == "chat_revision_conflict":
-                raise ChatRevisionConflict(str(exc)) from exc
-            raise
+            typed = _typed_failure(exc)
+            if typed is exc:
+                raise
+            raise typed from exc
         if result is None:
             chat = self._database.load_chat(thread_id) or {}
             messages = chat.get("messages", [])
@@ -171,7 +189,13 @@ def add_message(
         return str(result)
 
     def rename_chat(self, thread_id: str, title: str) -> None:
-        self._database.update_chat_title(thread_id, title)
+        try:
+            self._database.update_chat_title(thread_id, title)
+        except Exception as exc:
+            typed = _typed_failure(exc)
+            if typed is exc:
+                raise
+            raise typed from exc
 
     def delete_chat(self, thread_id: str) -> None:
         self._database.delete_chat(thread_id)
@@ -220,9 +244,10 @@ def replace_message(
                 original_content=original_content,
             )
         except Exception as exc:
-            if getattr(exc, "operation", None) == "chat_revision_conflict":
-                raise ChatRevisionConflict(str(exc)) from exc
-            raise
+            typed = _typed_failure(exc)
+            if typed is exc:
+                raise
+            raise typed from exc
 
 
 class InMemoryChatRepository:
@@ -241,6 +266,8 @@ def __init__(self, chats: list[dict[str, Any]] | None = None):
                     message["id"] = self._new_message_id()
                 else:
                     self._advance_message_counter(message["id"])
+            # A seeded chat starts from its message count, as a stored one does.
+            copied.setdefault("revision", len(copied.get("messages", [])))
             self._chats[str(chat["id"])] = copied
 
     def _new_message_id(self) -> str:
@@ -289,7 +316,9 @@ def create_group(self, group_id: str, name: str) -> None:
             self._groups[group_id] = {
                 "id": group_id,
                 "name": name,
-                "position": len(self._groups),
+                # After the highest position, not the count: a delete leaves
+                # gaps, and the count would then reuse a position still taken.
+                "position": max((group["position"] for group in self._groups.values()), default=-1) + 1,
                 "collapsed": False,
                 "timestamp": self._timestamp(),
             }
@@ -340,7 +369,7 @@ def get_chat_overview(self, thread_id: str) -> dict[str, Any] | None:
                 "title": chat.get("title"),
                 "timestamp": chat.get("timestamp"),
                 "group_id": chat.get("group_id"),
-                "revision": len(chat.get("messages", ())),
+                "revision": chat["revision"],
             }
 
     def create_chat(self, thread_id: str, title: str) -> None:
@@ -352,6 +381,7 @@ def create_chat(self, thread_id: str, title: str) -> None:
                 "title": title,
                 "timestamp": self._timestamp(),
                 "group_id": None,
+                "revision": 0,
                 "messages": [],
             }
 
@@ -363,7 +393,7 @@ def _check_expected_revision(
             return
         if type(expected_revision) is not int or expected_revision < 0:
             raise ValueError("expected_revision must be a non-negative integer")
-        actual_revision = len(chat.get("messages", ()))
+        actual_revision = chat["revision"]
         if actual_revision != expected_revision:
             raise ChatRevisionConflict(
                 f"Chat revision changed (expected {expected_revision}, found {actual_revision})."
@@ -402,14 +432,17 @@ def add_message(
                     "role": role,
                     "content": content,
                     "timestamp": self._timestamp(),
-                    "sources": deepcopy(sources),
+                    # Empty means absent, as in the database, which stores no
+                    # column for an empty list or mapping.
+                    "sources": deepcopy(sources) or None,
                     "thoughts": _assistant_thoughts(role, thoughts),
-                    "attachments": deepcopy(attachments),
-                    "stats": deepcopy(stats) if role == "assistant" else None,
+                    "attachments": deepcopy(attachments) or None,
+                    "stats": (deepcopy(stats) or None) if role == "assistant" else None,
                     "original_content": original_content if role == "assistant" else None,
                 }
             )
             chat["timestamp"] = self._timestamp()
+            chat["revision"] += 1
             return message_id
 
     def rename_chat(self, thread_id: str, title: str) -> None:
@@ -417,8 +450,9 @@ def rename_chat(self, thread_id: str, title: str) -> None:
             chat = self._chats.get(thread_id)
             if chat is None:
                 raise ChatNotFound("Chat does not exist.")
+            # Only the title: a rename is not activity, so the chat keeps its
+            # place in the recency-ordered list, as it does in the database.
             chat["title"] = title
-            chat["timestamp"] = self._timestamp()
 
     def delete_chat(self, thread_id: str) -> None:
         with self._lock:
@@ -436,19 +470,28 @@ def fork_chat(self, thread_id: str, message_id: str, new_thread_id: str) -> None
                 )
             except StopIteration as exc:
                 raise MessageNotFound("Message does not exist.") from exc
+            if new_thread_id in self._chats:
+                raise ChatRepositoryError("Chat already exists.")
             copied = deepcopy(source)
             copied["id"] = new_thread_id
             copied["title"] = f"Fork of {source.get('title') or 'Untitled Chat'}"
             copied["timestamp"] = self._timestamp()
+            # A fork is filed nowhere until the user files it.
+            copied["group_id"] = None
             copied["messages"] = []
-            for message in source["messages"][: position + 1]:
+            forked_at = datetime.now(timezone.utc)
+            for index, message in enumerate(source["messages"][: position + 1]):
                 copied["messages"].append(
                     {
                         **deepcopy(message),
                         "id": self._new_message_id(),
-                        "timestamp": self._timestamp(),
+                        # Each message keeps the time it was really sent; the
+                        # offset only orders messages that never had one.
+                        "timestamp": message.get("timestamp")
+                        or (forked_at + timedelta(microseconds=index)).isoformat(),
                     }
                 )
+            copied["revision"] = len(copied["messages"])
             self._chats[new_thread_id] = copied
 
     def replace_message(
@@ -475,14 +518,17 @@ def replace_message(
                         raise ChatRepositoryError("Only assistant messages can be replaced.")
                     message.update(
                         content=content,
-                        sources=deepcopy(sources),
+                        sources=deepcopy(sources) or None,
                         thoughts=thoughts,
-                        stats=deepcopy(stats),
+                        stats=deepcopy(stats) or None,
                         original_content=original_content,
                         timestamp=self._timestamp(),
                     )
                     if attachments is not None:
                         message["attachments"] = deepcopy(attachments)
                     chat["timestamp"] = self._timestamp()
+                    # The count did not change, the reply did: the revision
+                    # moves so a second regeneration from the same state is stale.
+                    chat["revision"] += 1
                     return
             raise MessageNotFound("Message does not exist.")
diff --git a/backend/cortex_backend/repositories/sqlite_backup.py b/backend/cortex_backend/repositories/sqlite_backup.py
index a87c38d..2dbf54f 100644
--- a/backend/cortex_backend/repositories/sqlite_backup.py
+++ b/backend/cortex_backend/repositories/sqlite_backup.py
@@ -7,6 +7,8 @@
 * ``snapshot_database`` copies a live database through SQLite's online backup
   API, so the copy includes commits that are still only in the ``-wal``
   sidecar.
+* ``replace_with_retry`` publishes a file over another one, waiting out the
+  short sharing violations Windows reports while a scanner has the target open.
 * ``open_at_rest`` / ``quick_check_at_rest`` read a backup that nothing is
   writing without leaving ``-wal`` and ``-shm`` files beside it, and bound the
   time a check may take.
@@ -41,6 +43,10 @@
 
 SIDECAR_SUFFIXES = ("-wal", "-shm")
 
+# How often replace_with_retry tries, and how long it first waits between tries.
+REPLACE_ATTEMPTS = 4
+REPLACE_RETRY_DELAY_SECONDS = 0.05
+
 # SQLite result codes (sqlite3.SQLITE_BUSY / SQLITE_LOCKED only exist from
 # Python 3.11, and this project supports 3.10).
 _SQLITE_BUSY = 5
@@ -100,6 +106,35 @@ def failure_detail(message: str, cause: BaseException | None) -> str:
     return f"{message} ({type(cause).__name__})" if cause is not None else message
 
 
+def replace_with_retry(
+    source: str | os.PathLike[str],
+    destination: str | os.PathLike[str],
+    *,
+    attempts: int = REPLACE_ATTEMPTS,
+    delay: float = REPLACE_RETRY_DELAY_SECONDS,
+) -> None:
+    """``os.replace`` that waits out a target another program is briefly holding.
+
+    On Windows a virus scanner, search indexer or backup agent can have the
+    target open without ``FILE_SHARE_DELETE`` for a few tens of milliseconds,
+    and renaming over it then fails with ``PermissionError`` -- a sharing
+    violation that is almost always gone by the next try. Only that error is
+    retried, at most ``attempts`` times in all with the wait doubling from
+    ``delay`` (about a third of a second by default), so a lock that does not
+    lift is still reported promptly and unchanged: nothing has been moved when
+    ``os.replace`` raises. Any other ``OSError`` is raised at once. The retry
+    is not limited to Windows; where nothing holds files open it never fires.
+    """
+    for attempt in range(1, attempts + 1):
+        try:
+            os.replace(source, destination)
+            return
+        except PermissionError:
+            if attempt == attempts:
+                raise
+            time.sleep(delay * 2 ** (attempt - 1))
+
+
 def snapshot_database(
     source: str | os.PathLike[str],
     destination: str | os.PathLike[str],
diff --git a/backend/cortex_backend/repositories/sqlite_reclaim.py b/backend/cortex_backend/repositories/sqlite_reclaim.py
new file mode 100644
index 0000000..8f3168c
--- /dev/null
+++ b/backend/cortex_backend/repositories/sqlite_reclaim.py
@@ -0,0 +1,267 @@
+"""Give a database file back the space that deleted rows left in it.
+
+SQLite never shrinks a file by itself: deleting a chat turns its pages into free
+pages that later writes reuse, and the file stays as large as it ever was. A
+history that was once big and has been cleared keeps its disk space for good.
+
+Two mechanisms return it, and this module uses whichever the file supports:
+
+* A file created with ``auto_vacuum = INCREMENTAL`` keeps a map of its free
+  pages, and ``PRAGMA incremental_vacuum`` hands them back a few at a time.
+  Each step is its own small transaction, so stopping part-way (time ran out,
+  the process ended) loses nothing and the next start carries on.
+* A file created without it can only shrink by ``VACUUM``, which rewrites the
+  whole database into a temporary file and swaps it in. It is atomic -- an
+  interruption, a full disk or a crash leaves the original untouched -- but it
+  needs room for a second copy and holds the write lock throughout. Running it
+  once with ``auto_vacuum = INCREMENTAL`` set also converts the file, so every
+  later start can use the cheap path.
+
+A rewrite that fails or runs out of time is rolled back, and it would fail the
+same way at the next start: a file just under the size ceiling whose rewrite
+takes longer than the time limit would add that whole limit to every launch,
+for good. So the failure is noted in a small marker file beside the database
+(``<database>.reclaim-backoff``, holding only the time), and no rewrite is tried
+again until ``BACKOFF_SECONDS`` have passed. The marker is only ever read as a
+time: one that is unreadable, or dated in the future, is ignored, and another
+program holding the write lock is not a failure of the rewrite and leaves none.
+The incremental path needs no such delay, because every pass keeps what it freed.
+
+Nothing here runs unless more than a quarter of the file is free pages, so a
+healthy database is never touched. Callers own the safety around it: the chat
+store calls this once at startup, after a verified backup of the same content
+has been written, and before the application serves anything. Every outcome
+that is not a success is reported, never raised: reclaiming space is a courtesy
+and must not stop Cortex from starting.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+import logging
+import os
+from pathlib import Path
+import shutil
+import sqlite3
+import tempfile
+import time
+from typing import Literal
+
+# Act only when more than this fraction of the file is free pages, and at least
+# MIN_FREE_PAGES of them, so a small file is not rewritten over a few pages.
+FREE_PAGE_FRACTION = 0.25
+MIN_FREE_PAGES = 64
+
+# Wall-clock budget for one call, and for waiting on another connection's lock.
+TIME_LIMIT_SECONDS = 20.0
+BUSY_TIMEOUT_SECONDS = 5.0
+
+# After a rewrite fails or times out, none is tried again for this long. A week
+# is long enough to stop a slow rewrite costing every launch its time limit, and
+# short enough that a database that has since shrunk or a drive that has since
+# been cleaned out is tried again soon.
+BACKOFF_SECONDS = 7 * 24 * 60 * 60
+BACKOFF_MARKER_SUFFIX = ".reclaim-backoff"
+
+# A VACUUM rewrites everything that is kept. Past this much live content it could
+# outlast the time limit on every start and never finish, so it is left alone.
+MAX_VACUUM_LIVE_BYTES = 1024 * 1024 * 1024
+# Room to spare beyond the copies themselves (journal, WAL frames, filesystem slack).
+_SPACE_MARGIN_BYTES = 16 * 1024 * 1024
+
+# Pages handed back per incremental step: small enough to check the clock often.
+_INCREMENTAL_STEP_PAGES = 512
+# The progress handler runs every this many SQLite virtual-machine steps.
+_PROGRESS_INTERVAL = 1000
+
+_AUTO_VACUUM_NONE = 0
+_AUTO_VACUUM_INCREMENTAL = 2
+
+Outcome = Literal[
+    "nothing_to_do",
+    "trimmed",
+    "rewritten",
+    "too_large",
+    "not_enough_space",
+    "backed_off",
+    "gave_up",
+]
+
+
+def reclaim_free_space(
+    path: str | os.PathLike[str],
+    *,
+    time_limit: float = TIME_LIMIT_SECONDS,
+    busy_timeout: float = BUSY_TIMEOUT_SECONDS,
+    clock: Callable[[], float] = time.monotonic,
+    backoff: float = BACKOFF_SECONDS,
+    wall_clock: Callable[[], float] = time.time,
+) -> Outcome:
+    """Return a database's free pages to the file system if there are many.
+
+    ``"nothing_to_do"`` is the answer for a file that is not mostly empty (and
+    for one that is missing); ``"trimmed"`` and ``"rewritten"`` say the
+    incremental vacuum or a full ``VACUUM`` ran to the end; the rest say why
+    nothing was done or finished; ``"backed_off"`` is a rewrite that was not
+    tried because an earlier one failed less than ``backoff`` seconds ago (by
+    ``wall_clock``, since the marker has to outlive the process). In every case
+    the database holds exactly the rows it held before, and it is safe to call
+    again.
+    """
+    if not os.path.exists(path):
+        return "nothing_to_do"
+    deadline = clock() + time_limit
+    connection: sqlite3.Connection | None = None
+    try:
+        # mode=rw: never create a database where there is none.
+        connection = sqlite3.connect(
+            f"{Path(path).resolve().as_uri()}?mode=rw",
+            timeout=busy_timeout,
+            isolation_level=None,
+            uri=True,
+        )
+        # Non-zero from the handler interrupts whatever is running, VACUUM
+        # included, and SQLite rolls it back.
+        connection.set_progress_handler(lambda: int(clock() >= deadline), _PROGRESS_INTERVAL)
+        page_size = _pragma(connection, "page_size")
+        page_count = _pragma(connection, "page_count")
+        free_pages = _pragma(connection, "freelist_count")
+        if free_pages < MIN_FREE_PAGES or free_pages <= page_count * FREE_PAGE_FRACTION:
+            return "nothing_to_do"
+        mode = _pragma(connection, "auto_vacuum")
+        if mode == _AUTO_VACUUM_INCREMENTAL:
+            return _trim(connection, deadline, clock)
+        if mode != _AUTO_VACUUM_NONE:
+            return "nothing_to_do"  # full auto-vacuum keeps the file trimmed by itself
+        live_bytes = (page_count - free_pages) * page_size
+        if live_bytes > MAX_VACUUM_LIVE_BYTES:
+            return "too_large"
+        if not _room_for_a_second_copy(Path(path).resolve().parent, live_bytes):
+            return "not_enough_space"
+        marker = _backoff_marker(path)
+        if _backed_off(marker, wall_clock(), backoff):
+            return "backed_off"
+        try:
+            outcome = _rewrite(connection)
+        except (sqlite3.Error, OSError) as exc:
+            # A rewrite that was cut off, ran out of room or failed some other
+            # way would do the same at the next start. Another connection
+            # holding the lock says nothing about the rewrite itself.
+            if not _is_lock_contention(exc):
+                _note_failed_rewrite(marker, wall_clock())
+            raise
+        _forget_failed_rewrite(marker)
+        return outcome
+    except (sqlite3.Error, OSError) as exc:
+        # The type only: the message of an OS or SQLite error can carry the path.
+        logging.warning("Could not reclaim unused space in a database (%s).", type(exc).__name__)
+        return "gave_up"
+    finally:
+        if connection is not None:
+            connection.close()
+
+
+def _pragma(connection: sqlite3.Connection, name: str) -> int:
+    return int(connection.execute(f"PRAGMA {name}").fetchone()[0])
+
+
+def _trim(connection: sqlite3.Connection, deadline: float, clock: Callable[[], float]) -> Outcome:
+    """Hand free pages back in small steps until none are left or time is up."""
+    remaining = _pragma(connection, "freelist_count")
+    while remaining > 0:
+        if clock() >= deadline:
+            return "gave_up"
+        # The pragma only frees a page for each row it is asked to produce.
+        connection.execute(f"PRAGMA incremental_vacuum({_INCREMENTAL_STEP_PAGES})").fetchall()
+        freed = remaining - _pragma(connection, "freelist_count")
+        if freed <= 0:
+            # A step that frees nothing would otherwise spin until the clock
+            # ran out, at every start.
+            return "gave_up"
+        remaining -= freed
+    _shrink_the_file(connection)
+    return "trimmed"
+
+
+def _rewrite(connection: sqlite3.Connection) -> Outcome:
+    """Convert to incremental auto-vacuum and rewrite the file, all or nothing."""
+    connection.execute(f"PRAGMA auto_vacuum = {_AUTO_VACUUM_INCREMENTAL}")
+    connection.execute("VACUUM")
+    _shrink_the_file(connection)
+    return "rewritten"
+
+
+def _shrink_the_file(connection: sqlite3.Connection) -> None:
+    """Move the freed pages out of the write-ahead log so the main file gets shorter.
+
+    Best effort, and outside the time limit: the pages are already free, and a
+    checkpoint that cannot finish (a reader still needs older frames, or the
+    log is busy) is finished by a later write anyway.
+    """
+    connection.set_progress_handler(None, 0)
+    try:
+        connection.execute("PRAGMA wal_checkpoint(TRUNCATE)").fetchall()
+    except sqlite3.Error as exc:
+        logging.info("The database log could not be truncated yet (%s).", type(exc).__name__)
+
+
+def _backoff_marker(path: str | os.PathLike[str]) -> Path:
+    return Path(f"{os.fspath(path)}{BACKOFF_MARKER_SUFFIX}")
+
+
+def _backed_off(marker: Path, now: float, backoff: float) -> bool:
+    """Whether a failed rewrite is recent enough that another is not tried yet.
+
+    A missing or unreadable marker is no marker. So is one dated in the future,
+    which only a clock that was set back can produce: honouring it would delay
+    the next attempt by more than ``backoff``.
+    """
+    try:
+        failed_at = float(marker.read_text(encoding="ascii").strip())
+    except (OSError, ValueError):
+        return False
+    return 0 <= now - failed_at < backoff
+
+
+def _note_failed_rewrite(marker: Path, now: float) -> None:
+    """Record when a rewrite failed. Best effort: not being able to is not an error."""
+    try:
+        marker.write_text(f"{int(now)}\n", encoding="ascii")
+    except OSError as exc:
+        logging.info("Could not note the failed rewrite of a database (%s).", type(exc).__name__)
+
+
+def _forget_failed_rewrite(marker: Path) -> None:
+    try:
+        marker.unlink()
+    except FileNotFoundError:
+        pass
+    except OSError as exc:
+        logging.info("Could not remove the note of a failed database rewrite (%s).", type(exc).__name__)
+
+
+def _is_lock_contention(exc: BaseException) -> bool:
+    """Whether SQLite gave up because another connection held the database."""
+    if not isinstance(exc, sqlite3.OperationalError):
+        return False
+    text = str(exc).lower()
+    return "locked" in text or "busy" in text
+
+
+def _room_for_a_second_copy(directory: Path, live_bytes: int) -> bool:
+    """Whether the drives involved can hold what a VACUUM writes.
+
+    It builds the new database in the temporary directory and then writes it
+    back through the write-ahead log beside the file, so both are checked, the
+    second twice over in case they are one drive. Free space that cannot be
+    read is not room.
+    """
+    try:
+        beside_the_file = shutil.disk_usage(directory).free
+        for_the_copy = shutil.disk_usage(tempfile.gettempdir()).free
+    except OSError:
+        return False
+    return (
+        beside_the_file >= 2 * live_bytes + _SPACE_MARGIN_BYTES
+        and for_the_copy >= live_bytes + _SPACE_MARGIN_BYTES
+    )
diff --git a/backend/cortex_backend/repositories/sqlite_settings.py b/backend/cortex_backend/repositories/sqlite_settings.py
index bc30ba9..5d38007 100644
--- a/backend/cortex_backend/repositories/sqlite_settings.py
+++ b/backend/cortex_backend/repositories/sqlite_settings.py
@@ -27,6 +27,7 @@
     find_interrupted_recovery,
     move_sidecars,
     put_sidecars_back,
+    replace_with_retry,
     snapshot_database,
     utc_now_iso,
 )
@@ -370,7 +371,7 @@ def _publish_verified_copy(
             populate(temporary_path)
             if not cls._database_is_valid(temporary_path):
                 raise OSError("database copy failed integrity validation")
-            os.replace(temporary_path, destination)
+            replace_with_retry(temporary_path, destination)
             # Validating the copy opened it, so SQLite made "<temp>-wal" and
             # "<temp>-shm". os.replace moves only the file itself.
             for suffix in ("-wal", "-shm"):
diff --git a/backend/cortex_backend/repositories/storage.py b/backend/cortex_backend/repositories/storage.py
index 896fea2..c28e666 100644
--- a/backend/cortex_backend/repositories/storage.py
+++ b/backend/cortex_backend/repositories/storage.py
@@ -38,9 +38,11 @@
     open_at_rest,
     put_sidecars_back,
     quick_check_at_rest,
+    replace_with_retry,
     snapshot_database,
     utc_now_iso,
 )
+from cortex_backend.repositories.sqlite_reclaim import reclaim_free_space
 from cortex_backend.repositories.sqlite_schema import (
     Migration,
     SchemaTooNewError,
@@ -243,12 +245,33 @@ def _migrate_to_v5(connection: sqlite3.Connection) -> None:
     add_column_if_missing(connection, "messages", "original_content", "TEXT")
 
 
+def _migrate_to_v6(connection: sqlite3.Connection) -> None:
+    """A revision that moves whenever a chat's messages do.
+
+    The revision used to be the number of messages, which a regeneration leaves
+    unchanged: it replaces the last reply, so two regenerations started from the
+    same state both passed the compare-and-swap. It is now its own counter,
+    raised by every write to a chat's messages. Existing chats start from their
+    message count, which is what the clients last saw, and the column is only
+    ever added: nothing is rewritten or dropped, and an older release refuses
+    the file (see DatabaseManager._unsupported_schema_error) instead of
+    misreading it.
+    """
+    add_column_if_missing(connection, "threads", "revision", "INTEGER NOT NULL DEFAULT 0")
+    # MAX() keeps a re-run from ever lowering a revision that has moved on.
+    connection.execute(
+        "UPDATE threads SET revision = MAX(revision, "
+        "(SELECT COUNT(*) FROM messages WHERE messages.thread_id = threads.id))"
+    )
+
+
 _MIGRATIONS: dict[int, Migration] = {
     1: _migrate_to_v1,
     2: _migrate_to_v2,
     3: _migrate_to_v3,
     4: _migrate_to_v4,
     5: _migrate_to_v5,
+    6: _migrate_to_v6,
 }
 
 
@@ -295,7 +318,7 @@ def _content_digest(path: str, *, at_rest: bool = False) -> str | None:
 
 class DatabaseManager:
     """Manages the persistence of chat conversations to a local SQLite database."""
-    SCHEMA_VERSION = 5
+    SCHEMA_VERSION = 6
 
     def __init__(
         self,
@@ -340,6 +363,7 @@ def __init__(
             self._snapshot_before_upgrade()
             self._create_tables()
             self._refresh_startup_backup(primary_verified=primary_verified)
+            self._reclaim_free_space()
 
     def _ensure_parent_directory(self):
         parent = os.path.dirname(os.path.abspath(self.db_path))
@@ -474,17 +498,17 @@ def _publish_verified_copy(
             if displace_existing_to is not None and os.path.exists(destination):
                 older_file_kept_as = cls._link_to_spare_name(displace_existing_to)
                 try:
-                    os.replace(destination, displace_existing_to)
+                    replace_with_retry(destination, displace_existing_to)
                 except OSError:
                     cls._drop_spare_name(older_file_kept_as)
                     raise
                 displaced_to = displace_existing_to
             try:
-                os.replace(temporary_path, destination)
+                replace_with_retry(temporary_path, destination)
             except OSError:
                 if displaced_to is not None:
                     try:
-                        os.replace(displaced_to, destination)
+                        replace_with_retry(displaced_to, destination)
                     except OSError:
                         logging.warning("Could not return a displaced database file to its name.")
                     else:
@@ -553,7 +577,7 @@ def _restore_from_spare_name(spare: str | None, path: str) -> None:
         if spare is None:
             return
         try:
-            os.replace(spare, path)
+            replace_with_retry(spare, path)
         except OSError:
             logging.warning("Could not return an older database backup to its name.")
 
@@ -950,6 +974,13 @@ def _create_tables(self) -> None:
         connection: sqlite3.Connection | None = None
         try:
             connection = open_for_upgrade(self.db_path)
+            if self._is_new_database(connection):
+                # Only a database with no tables yet can be given this, and it
+                # has to come before write-ahead logging is switched on: it lets
+                # a history that has been cleared give its disk space back (see
+                # sqlite_reclaim). Existing files are converted later, when
+                # there is enough to give back to make that worth doing.
+                connection.execute("PRAGMA auto_vacuum = INCREMENTAL")
             prepare_database(connection, _MIGRATIONS, target=self.SCHEMA_VERSION)
         except SchemaTooNewError as exc:
             raise self._unsupported_schema_error(exc.version) from exc
@@ -989,6 +1020,44 @@ def _create_tables(self) -> None:
             )
             logging.info("Database schema is at version %d.", stored_version(conn))
 
+    @staticmethod
+    def _is_new_database(connection: sqlite3.Connection) -> bool:
+        """Whether the file has never held a table: brand new, or created empty."""
+        return (
+            stored_version(connection) == 0
+            and connection.execute("SELECT 1 FROM sqlite_master LIMIT 1").fetchone() is None
+        )
+
+    def _reclaim_free_space(self) -> None:
+        """Give the disk space of deleted chats back, at startup and only when safe.
+
+        Deleting history frees pages inside the file but never makes the file
+        smaller. When more than a quarter of it is free (see sqlite_reclaim) they
+        are handed back, and only under these conditions:
+
+        * a backup of this very content was just written and verified this
+          launch, so the one operation that rewrites the whole file has a
+          restore point (a failed backup skips it, and the next launch tries);
+        * it runs here, in the constructor, before the application serves a
+          request, so it never competes with a write, and another connection
+          holding the write lock only makes it give up;
+        * it is bounded in time and in size, and it is all-or-nothing, so
+          whatever the outcome the file holds exactly the rows it held;
+        * a full rewrite that fails or runs out of time is not tried again for a
+          week (a marker beside the database, see sqlite_reclaim), so a file it
+          cannot finish on does not cost every launch the whole time limit.
+
+        A failure is logged and ignored, like a failed backup: it is not a
+        reason to refuse to start.
+        """
+        if self.backup_status.state != "ok" or not os.path.exists(self.backup_path):
+            return
+        outcome = reclaim_free_space(self.db_path)
+        if outcome in ("trimmed", "rewritten"):
+            logging.info("Returned unused space in the chat database to the disk (%s).", outcome)
+        elif outcome != "nothing_to_do":
+            logging.info("Left unused space in the chat database in place (%s).", outcome)
+
     @staticmethod
     def _parse_legacy_attachment(value: object) -> dict | None:
         """Keep only attachment metadata that the API response accepts."""
@@ -1101,21 +1170,91 @@ def _archive_legacy_file(file_path: str, archive_dir: str) -> str:
         os.makedirs(archive_dir, exist_ok=True)
         return shutil.move(file_path, os.path.join(archive_dir, os.path.basename(file_path)))
 
+    @staticmethod
+    def _retired_directory_name(directory: str) -> str | None:
+        """An unused ``<dir>.retired`` name (``.retired-2``, ``.retired-3``, ...), or None."""
+        base = os.path.normpath(directory)
+        for number in range(1, 1000):
+            candidate = f"{base}.retired" if number == 1 else f"{base}.retired-{number}"
+            if not os.path.lexists(candidate):
+                return candidate
+        return None
+
+    def _retire_legacy_directory(self) -> None:
+        """Take the legacy history directory out of the way once it holds nothing.
+
+        Migrated files move to ``<dir>_migrated_<time>`` and unreadable ones to
+        ``<dir>/quarantine``, so the directory itself outlives every pass, and
+        with it the "legacy history found" warning on every launch. Once it is
+        verified to hold nothing (an empty ``quarantine`` folder counts as
+        nothing) it is renamed to ``<dir>.retired`` -- ``.retired-2`` and so on
+        if that name is taken -- and never deleted: no folder, empty or not, is
+        removed by this. Renaming rather than ``rmdir`` was chosen so that
+        nothing is destroyed even if the emptiness check is wrong or a file
+        lands in the folder between the check and the rename: whatever is in it
+        is still there, under the new name, and the ``.retired`` folder is one
+        the user can delete when they like. The name is not the one the
+        migration looks at, so the folder is not scanned again. No chat file,
+        quarantined or not, and no stray file of the user's is ever moved or
+        deleted here: a directory that still holds any of them is left exactly
+        as it is.
+        """
+        directory = self.legacy_history_dir
+        quarantine = os.path.join(directory, "quarantine")
+        try:
+            others = [name for name in os.listdir(directory) if name != "quarantine"]
+            # A link is somebody's arrangement, not ours to look through or remove.
+            has_quarantine = os.path.lexists(quarantine)
+            quarantined = (
+                os.listdir(quarantine)
+                if has_quarantine and os.path.isdir(quarantine) and not os.path.islink(quarantine)
+                else None
+            )
+            if others or (has_quarantine and quarantined is None):
+                return
+            if quarantined:
+                logging.info(
+                    "Legacy chat files that could not be migrated are kept in the quarantine "
+                    "folder of the old chat history directory."
+                )
+                return
+            retired_as = self._retired_directory_name(directory)
+            if retired_as is None:
+                return
+            os.rename(directory, retired_as)
+        except OSError as exc:
+            logging.info(
+                "The old chat history directory was left where it is (%s).", type(exc).__name__
+            )
+            return
+        logging.info(
+            "The old chat history directory held nothing more and was renamed to %s.",
+            os.path.basename(retired_as),
+        )
+
     def migrate_from_json_if_needed(self) -> MigrationResult:
         """Migrate valid legacy files transactionally and isolate invalid files."""
         if not os.path.isdir(self.legacy_history_dir):
             return MigrationResult()
 
+        pending = [
+            filename
+            for filename in sorted(os.listdir(self.legacy_history_dir))
+            if filename.lower().endswith('.json')
+            and os.path.isfile(os.path.join(self.legacy_history_dir, filename))
+        ]
+        if not pending:
+            # Nothing to import: an earlier pass already did, or the directory
+            # was never used. Stay quiet rather than warn at every launch.
+            self._retire_legacy_directory()
+            return MigrationResult()
+
         logging.warning("Legacy JSON chat history found. Starting migration to SQLite...")
         migrated = skipped = quarantined = 0
         archive_dir = f"{self.legacy_history_dir}_migrated_{int(datetime.now().timestamp())}"
 
-        for filename in sorted(os.listdir(self.legacy_history_dir)):
-            if not filename.lower().endswith('.json'):
-                continue
+        for filename in pending:
             file_path = os.path.join(self.legacy_history_dir, filename)
-            if not os.path.isfile(file_path):
-                continue
 
             try:
                 chat_data = self._parse_legacy_chat(self._load_legacy_chat_file(file_path))
@@ -1144,8 +1283,13 @@ def migrate_from_json_if_needed(self) -> MigrationResult:
                         skipped += 1
                     else:
                         conn.execute(
-                            "INSERT INTO threads (id, title, timestamp) VALUES (?, ?, ?)",
-                            (chat_data['id'], chat_data['title'], chat_data['timestamp']),
+                            "INSERT INTO threads (id, title, timestamp, revision) VALUES (?, ?, ?, ?)",
+                            (
+                                chat_data['id'],
+                                chat_data['title'],
+                                chat_data['timestamp'],
+                                len(chat_data['messages']),
+                            ),
                         )
                         try:
                             base_timestamp = datetime.fromisoformat(
@@ -1194,6 +1338,7 @@ def migrate_from_json_if_needed(self) -> MigrationResult:
             result.skipped,
             result.quarantined,
         )
+        self._retire_legacy_directory()
         return result
 
     def create_chat(self, thread_id: str, title: str):
@@ -1215,10 +1360,12 @@ def create_chat_from_messages(self, thread_id: str, title: str, messages: list[d
         """Creates a new chat thread and bulk-inserts a list of messages."""
         try:
             with self.connect() as conn:
-                # 1. Create the new thread entry
+                # 1. Create the new thread entry. Its revision starts at the number
+                # of messages it is about to hold, like any chat that has had
+                # that many appended.
                 conn.execute(
-                    "INSERT INTO threads (id, title, timestamp) VALUES (?, ?, ?)",
-                    (thread_id, title, _utc_now_iso())
+                    "INSERT INTO threads (id, title, timestamp, revision) VALUES (?, ?, ?, ?)",
+                    (thread_id, title, _utc_now_iso(), len(messages))
                 )
                 
                 # 2. Prepare and insert all messages for the new thread
@@ -1288,6 +1435,12 @@ def add_message(
                         (thread_id, thread_title, _utc_now_iso()),
                     )
                 self._check_chat_revision(conn, thread_id, expected_revision)
+                if thread_title is None and conn.execute(
+                    "SELECT 1 FROM threads WHERE id = ?", (thread_id,)
+                ).fetchone() is None:
+                    # Without a title there is nothing to create the chat from.
+                    # Say so, rather than let the foreign key report it.
+                    raise PersistenceError("Chat does not exist.", operation="chat_not_found")
                 conn.execute("""
                     INSERT INTO messages (thread_id, role, content, sources, thoughts, attachments, generation_stats_json, original_content, timestamp)
                     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -1302,14 +1455,15 @@ def add_message(
                     original_content,
                     _utc_now_iso()
                 ))
-                # Update the thread's main timestamp to reflect recent activity
+                # Update the thread's main timestamp to reflect recent activity,
+                # and move its revision so anyone holding the old one is stale.
                 conn.execute(
-                    "UPDATE threads SET timestamp = ? WHERE id = ?",
+                    "UPDATE threads SET timestamp = ?, revision = revision + 1 WHERE id = ?",
                     (_utc_now_iso(), thread_id)
                 )
                 return str(conn.execute("SELECT last_insert_rowid()").fetchone()[0])
         except PersistenceError as exc:
-            if exc.operation == "chat_revision_conflict":
+            if exc.operation in ("chat_revision_conflict", "chat_not_found"):
                 raise
             raise PersistenceError(
                 f"Failed to add message to thread {thread_id}.",
@@ -1327,12 +1481,12 @@ def _check_chat_revision(
             return
         if type(expected_revision) is not int or expected_revision < 0:
             raise ValueError("expected_revision must be a non-negative integer")
-        actual_revision = int(
-            conn.execute(
-                "SELECT COUNT(*) FROM messages WHERE thread_id = ?",
-                (thread_id,),
-            ).fetchone()[0]
-        )
+        row = conn.execute(
+            "SELECT revision FROM threads WHERE id = ?",
+            (thread_id,),
+        ).fetchone()
+        # A chat that does not exist yet is at revision 0.
+        actual_revision = int(row[0]) if row is not None else 0
         if actual_revision != expected_revision:
             raise PersistenceError(
                 f"Chat revision changed (expected {expected_revision}, found {actual_revision}).",
@@ -1340,30 +1494,23 @@ def _check_chat_revision(
             )
 
     def load_chat_overview(self, thread_id: str) -> dict | None:
-        """Thread metadata and message count, without loading the messages.
+        """Thread metadata and revision, without loading the messages.
 
-        chat_revision() is the message count, and a caller that needs only the
-        revision or the title should not pay for every row of a long thread
-        being read and JSON-decoded. Returns the same keys load_chat does,
-        minus "messages", plus "revision".
+        A caller that needs only the revision or the title should not pay for
+        every row of a long thread being read and JSON-decoded. Returns the same
+        keys load_chat does, minus "messages".
         """
         try:
             with self.connect() as conn:
                 row = conn.execute(
-                    "SELECT id, title, timestamp, group_id FROM threads WHERE id = ?",
+                    "SELECT id, title, timestamp, group_id, revision FROM threads WHERE id = ?",
                     (thread_id,),
                 ).fetchone()
                 if not row:
                     return None
                 overview = dict(row)
-                if "timestamp" in overview:
-                    overview["timestamp"] = _as_utc_iso(overview["timestamp"])
-                overview["revision"] = int(
-                    conn.execute(
-                        "SELECT COUNT(*) FROM messages WHERE thread_id = ?",
-                        (thread_id,),
-                    ).fetchone()[0]
-                )
+                overview["timestamp"] = _as_utc_iso(overview["timestamp"])
+                overview["revision"] = int(overview["revision"])
                 return overview
         except PersistenceError as exc:
             raise PersistenceError(
@@ -1376,9 +1523,13 @@ def load_chat(self, thread_id: str) -> dict | None:
         """Loads a full chat thread (metadata and messages) from the database."""
         try:
             with self.connect() as conn:
+                # One read transaction, so the revision and the messages come
+                # from the same moment: a write landing between two separate
+                # reads would otherwise pair an older revision with newer rows.
+                conn.execute("BEGIN")
                 cursor = conn.cursor()
                 cursor.execute(
-                    "SELECT id, title, timestamp, group_id FROM threads WHERE id = ?",
+                    "SELECT id, title, timestamp, group_id, revision FROM threads WHERE id = ?",
                     (thread_id,),
                 )
                 thread_row = cursor.fetchone()
@@ -1386,8 +1537,8 @@ def load_chat(self, thread_id: str) -> dict | None:
                     return None
                 
                 chat_data = dict(thread_row)
-                if 'timestamp' in chat_data:
-                    chat_data['timestamp'] = _as_utc_iso(chat_data['timestamp'])
+                chat_data['timestamp'] = _as_utc_iso(chat_data['timestamp'])
+                chat_data['revision'] = int(chat_data['revision'])
                 
                 cursor.execute(
                     "SELECT id, role, content, sources, thoughts, attachments, generation_stats_json, original_content, timestamp FROM messages "
@@ -1438,7 +1589,7 @@ def delete_last_assistant_message(self, thread_id: str):
         """Deletes the most recent 'assistant' role message from a given thread."""
         try:
             with self.connect() as conn:
-                conn.execute("""
+                cursor = conn.execute("""
                     DELETE FROM messages 
                     WHERE id = (
                         SELECT id FROM messages 
@@ -1447,6 +1598,11 @@ def delete_last_assistant_message(self, thread_id: str):
                         LIMIT 1
                     )
                 """, (thread_id,))
+                if cursor.rowcount > 0:
+                    # The messages changed, so the revision moves with them.
+                    conn.execute(
+                        "UPDATE threads SET revision = revision + 1 WHERE id = ?", (thread_id,)
+                    )
                 logging.info("Deleted the last assistant message for a chat thread.")
         except PersistenceError as exc:
             raise PersistenceError(
@@ -1515,14 +1671,17 @@ def replace_message(
                 if cursor.rowcount != 1:
                     raise PersistenceError(
                         f"Assistant message {message_id} was not found.",
-                        operation="replace_message",
+                        operation="message_not_found",
                     )
+                # A regeneration leaves the message count as it was, so the
+                # revision has to move on its own for a second regeneration
+                # started from the same state to be recognised as stale.
                 conn.execute(
-                    "UPDATE threads SET timestamp = ? WHERE id = ?",
+                    "UPDATE threads SET timestamp = ?, revision = revision + 1 WHERE id = ?",
                     (_utc_now_iso(), thread_id),
                 )
         except PersistenceError as exc:
-            if exc.operation == "chat_revision_conflict":
+            if exc.operation in ("chat_revision_conflict", "message_not_found"):
                 raise
             raise PersistenceError(
                 f"Failed to replace message {message_id}.",
@@ -1534,9 +1693,17 @@ def update_chat_title(self, thread_id: str, new_title: str):
         """Updates the title of a specific chat thread."""
         try:
             with self.connect() as conn:
-                conn.execute("UPDATE threads SET title = ? WHERE id = ?", (new_title, thread_id))
+                # Only the title changes: a rename is not activity, so the chat
+                # keeps its place in the recency-ordered sidebar.
+                cursor = conn.execute(
+                    "UPDATE threads SET title = ? WHERE id = ?", (new_title, thread_id)
+                )
+                if cursor.rowcount == 0:
+                    raise PersistenceError("Chat does not exist.", operation="chat_not_found")
                 logging.info("Renamed chat thread (private title omitted).")
         except PersistenceError as exc:
+            if exc.operation == "chat_not_found":
+                raise
             raise PersistenceError(
                 f"Failed to rename chat {thread_id}.",
                 operation="update_chat_title",
@@ -1589,13 +1756,14 @@ def create_group(self, group_id: str, name: str) -> None:
         """Append a group after every existing one."""
         try:
             with self.connect() as conn:
-                next_position = conn.execute(
-                    "SELECT COALESCE(MAX(position), -1) + 1 FROM chat_groups"
-                ).fetchone()[0]
+                # One statement, so choosing the next position and inserting it
+                # cannot be split by another writer. Reading the maximum first
+                # and inserting afterwards let two groups made at the same
+                # moment (routes run on a thread pool) take the same position.
                 conn.execute(
                     "INSERT INTO chat_groups (id, name, position, collapsed, timestamp) "
-                    "VALUES (?, ?, ?, 0, ?)",
-                    (group_id, name, next_position, _utc_now_iso()),
+                    "SELECT ?, ?, COALESCE(MAX(position), -1) + 1, 0, ? FROM chat_groups",
+                    (group_id, name, _utc_now_iso()),
                 )
         except PersistenceError as exc:
             raise PersistenceError(
@@ -1665,6 +1833,11 @@ def set_chat_group(self, thread_id: str, group_id: str | None) -> bool:
         """Move a chat into a group, or out of every group when ``group_id`` is None."""
         try:
             with self.connect() as conn:
+                # The write lock is taken before the group is looked at. Without
+                # it, a delete_group landing between this check and the UPDATE
+                # left the chat filed under a group that no longer exists, and
+                # the sidebar hid it until the next startup sweep.
+                conn.execute("BEGIN IMMEDIATE")
                 if group_id is not None and conn.execute(
                     "SELECT 1 FROM chat_groups WHERE id = ?", (group_id,)
                 ).fetchone() is None:
@@ -1745,8 +1918,13 @@ def _atomic_copy_memos(cls, source: str, destination: str) -> None:
             )
             os.close(fd)
             shutil.copy2(source, temporary_path)
+            # The copy is the recovery file for the next launch, so it gets the
+            # same flush to disk the primary gets in _save_memos before it is
+            # moved into place; copy2 only hands the bytes to the OS.
+            with open(temporary_path, "r+b") as copy:
+                os.fsync(copy.fileno())
             cls._read_memos(temporary_path)
-            os.replace(temporary_path, destination)
+            replace_with_retry(temporary_path, destination)
             temporary_path = None
         except (OSError, shutil.Error, TypeError, ValueError, json.JSONDecodeError) as exc:
             raise PersistenceError(
@@ -1856,7 +2034,7 @@ def _set_aside_corrupt_memory_file(self, cause: BaseException) -> None:
         """
         damaged_path = f"{self.memory_file_path}.corrupt"
         try:
-            os.replace(self.memory_file_path, damaged_path)
+            replace_with_retry(self.memory_file_path, damaged_path)
         except OSError as exc:
             # Usually a lock. The save that follows would fail on the same
             # file anyway, so report the condition rather than pressing on.
@@ -1893,7 +2071,7 @@ def _save_memos(self):
             self._prepare_primary_for_save()
             if os.path.exists(self.memory_file_path):
                 self._atomic_copy_memos(self.memory_file_path, self.backup_file_path)
-            os.replace(temporary_path, self.memory_file_path)
+            replace_with_retry(temporary_path, self.memory_file_path)
             temporary_path = None
         except (OSError, TypeError, ValueError, json.JSONDecodeError) as exc:
             raise PersistenceError(
diff --git a/backend/cortex_backend/services/chat.py b/backend/cortex_backend/services/chat.py
index e9f1c2b..c5d3e7e 100644
--- a/backend/cortex_backend/services/chat.py
+++ b/backend/cortex_backend/services/chat.py
@@ -32,7 +32,17 @@ def __init__(self, message: str, *, code: ChatErrorCode) -> None:
 
 
 def chat_revision(chat: Mapping[str, Any]) -> int:
-    """Use the persisted ordered message count as the current chat revision."""
+    """The chat's persisted revision: a counter that moves whenever its messages do.
+
+    Appending, replacing (regenerating) or removing a message all move it, so a
+    write guarded by the revision it was read at fails if any of them happened
+    in between. It is not the message count: a regeneration changes a message
+    without changing the count. A chat mapping that carries no revision (a test
+    double that predates the counter) falls back to the count.
+    """
+    revision = chat.get("revision")
+    if type(revision) is int and revision >= 0:
+        return revision
     return len(chat.get("messages", ()))
 
 
diff --git a/tests/sqlite_faults.py b/tests/sqlite_faults.py
index 3e08e25..616768e 100644
--- a/tests/sqlite_faults.py
+++ b/tests/sqlite_faults.py
@@ -7,6 +7,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 import re
 import sqlite3
 
@@ -36,3 +37,35 @@ def connect(*args, **kwargs):
         return real_connect(*args, **kwargs)
 
     monkeypatch.setattr(sqlite3, "connect", connect)
+
+
+def disk_full_when(monkeypatch: pytest.MonkeyPatch, matches: Callable[[str], bool]) -> None:
+    """Make every statement ``matches`` accepts fail as SQLite does on a full volume.
+
+    The error is the one SQLite raises for SQLITE_FULL, at the statement that
+    needed a new page, so whatever the caller had already done in the same
+    transaction is left for it to roll back -- which is the point of the tests
+    that use this.
+    """
+
+    def out_of_space() -> sqlite3.OperationalError:
+        return sqlite3.OperationalError("database or disk is full")
+
+    class FullDiskConnection(sqlite3.Connection):
+        def execute(self, sql, *args):
+            if matches(sql):
+                raise out_of_space()
+            return super().execute(sql, *args)
+
+        def executemany(self, sql, *args):
+            if matches(sql):
+                raise out_of_space()
+            return super().executemany(sql, *args)
+
+    real_connect = sqlite3.connect
+
+    def connect(*args, **kwargs):
+        kwargs.setdefault("factory", FullDiskConnection)
+        return real_connect(*args, **kwargs)
+
+    monkeypatch.setattr(sqlite3, "connect", connect)
diff --git a/tests/test_chat_correctness.py b/tests/test_chat_correctness.py
index efc1b4b..6919a2d 100644
--- a/tests/test_chat_correctness.py
+++ b/tests/test_chat_correctness.py
@@ -1003,9 +1003,9 @@ class ChatOverviewTests(unittest.TestCase):
     """The overview must agree with the full load on everything it reports.
 
     A generation turn reads the thread five times. Three of those reads want
-    only the title or the revision, and chat_revision() is the message count --
-    so the cheap read has to produce exactly the number the expensive one
-    would, or a compare-and-swap starts rejecting valid writes.
+    only the title or the revision, and chat_revision() reads the stored
+    counter -- so the cheap read has to produce exactly the number the
+    expensive one would, or a compare-and-swap starts rejecting valid writes.
     """
 
     def _repository(self, directory):
diff --git a/tests/test_chat_db_recovery.py b/tests/test_chat_db_recovery.py
index 2975c56..e229f82 100644
--- a/tests/test_chat_db_recovery.py
+++ b/tests/test_chat_db_recovery.py
@@ -16,7 +16,7 @@
 import pytest
 
 from sqlite_faults import volume_without_write_ahead_logging
-from cortex_backend.repositories import storage
+from cortex_backend.repositories import sqlite_reclaim, storage
 from cortex_backend.repositories.storage import DatabaseManager, PersistenceError
 
 
@@ -719,8 +719,9 @@ def replace(source, destination, *args, **kwargs):
         if (
             os.path.normcase(os.path.abspath(destination)) == backup
             and str(source).endswith(".tmp")
-            and not refused
         ):
+            # Refused on every try: a lock that lifts is retried and succeeds
+            # (see tests/test_persistence.py), so this one has to stay.
             refused.append(str(source))
             raise PermissionError(errno.EACCES, "The process cannot access the file")
         return real_replace(source, destination, *args, **kwargs)
@@ -738,6 +739,72 @@ def replace(source, destination, *args, **kwargs):
     assert _reopen(manager).backup_status == ("ok", None)
 
 
+def _files_beside(directory: Path) -> dict[str, bytes]:
+    """Every file in the data directory but SQLite's transient -wal and -shm, with its bytes."""
+    return {
+        entry.name: entry.read_bytes()
+        for entry in directory.iterdir()
+        if entry.is_file() and not entry.name.endswith(("-wal", "-shm"))
+    }
+
+
+def test_a_database_from_a_newer_build_is_refused_without_being_modified(tmp_path: Path) -> None:
+    """Downgrading must not half-modify the file it cannot read: no index, no
+    journal-mode switch, no backup rotated over the older generations, no
+    snapshot -- nothing but the refusal."""
+    manager, _ = _manager_with_data(tmp_path)
+    stamp = sqlite3.connect(manager.db_path)
+    stamp.execute("PRAGMA user_version = 99")
+    stamp.commit()
+    stamp.close()
+    before = _files_beside(tmp_path)
+    assert Path(manager.backup_path).name in before
+
+    with pytest.raises(PersistenceError, match=r"schema version 99; this release reads up to"):
+        DatabaseManager(db_path=manager.db_path, legacy_history_dir=manager.legacy_history_dir)
+
+    assert _files_beside(tmp_path) == before
+    probe = sqlite3.connect(manager.db_path)
+    try:
+        assert probe.execute("PRAGMA user_version").fetchone()[0] == 99
+    finally:
+        probe.close()
+
+
+def test_a_backup_held_briefly_by_another_program_is_still_published(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A scanner holding the backup for a few milliseconds is not a failed backup."""
+    manager, _ = _manager_with_data(tmp_path)
+    manager.update_chat_title("thread-1", "Changed after the last backup")
+    backup_before = Path(manager.backup_path).read_bytes()
+    real_replace = os.replace
+    backup = os.path.normcase(os.path.abspath(manager.backup_path))
+    refused: list[str] = []
+    monkeypatch.setattr("time.sleep", lambda _seconds: None)
+
+    def replace(source, destination, *args, **kwargs):
+        if (
+            os.path.normcase(os.path.abspath(destination)) == backup
+            and str(source).endswith(".tmp")
+            and len(refused) < 2
+        ):
+            refused.append(str(source))
+            raise PermissionError(errno.EACCES, "The process cannot access the file")
+        return real_replace(source, destination, *args, **kwargs)
+
+    monkeypatch.setattr(os, "replace", replace)
+
+    reopened = _reopen(manager)
+    monkeypatch.undo()
+
+    assert len(refused) == 2
+    assert reopened.backup_status == ("ok", None)
+    assert Path(manager.backup_path).read_bytes() != backup_before
+    assert reopened.load_chat("thread-1")["title"] == "Changed after the last backup"
+    assert DatabaseManager._database_is_valid(manager.backup_path)
+
+
 def _stray_files(directory: Path) -> list[str]:
     """Anything a rotation may set aside while it works and must not leave behind."""
     return sorted(entry.name for entry in directory.iterdir() if entry.name.endswith((".old", ".tmp")))
@@ -762,8 +829,9 @@ def replace(source, destination, *args, **kwargs):
         if (
             os.path.normcase(os.path.abspath(destination)) == backup
             and str(source).endswith(".tmp")
-            and not refused
         ):
+            # Refused on every try: a lock that lifts is retried and succeeds
+            # (see tests/test_persistence.py), so this one has to stay.
             refused.append(str(source))
             raise PermissionError(errno.EACCES, "The process cannot access the file")
         return real_replace(source, destination, *args, **kwargs)
@@ -1077,3 +1145,172 @@ def test_adoption_never_overwrites_a_log_already_beside_the_quarantined_file(tmp
     assert Path(f"{report.quarantined_path}-wal").read_bytes() == b"the log of the primary being quarantined now"
     assert report.adopted_sidecars == ()
     assert orphan.read_bytes() == b"stranded by an earlier attempt"
+
+
+# -- returning the disk space of deleted history ----------------------------------
+
+
+def _space_facts(path: str) -> dict[str, int]:
+    """Free pages, auto-vacuum mode and file size once the write-ahead log is folded in."""
+    connection = sqlite3.connect(path)
+    try:
+        connection.execute("PRAGMA wal_checkpoint(TRUNCATE)").fetchall()
+        return {
+            "free_pages": connection.execute("PRAGMA freelist_count").fetchone()[0],
+            "auto_vacuum": connection.execute("PRAGMA auto_vacuum").fetchone()[0],
+            "bytes": os.path.getsize(path),
+        }
+    finally:
+        connection.close()
+
+
+def _fill_then_delete(manager: DatabaseManager, *, keep: int) -> dict[str, dict]:
+    """40 chats of 12 messages of about 4 KB, of which all but ``keep`` are deleted."""
+    turns = [
+        {"role": "user" if index % 2 == 0 else "assistant", "content": f"{index:02d} " + "y" * 4000}
+        for index in range(12)
+    ]
+    for number in range(40):
+        manager.create_chat_from_messages(f"chat-{number}", f"Chat {number}", turns)
+    for number in range(keep, 40):
+        manager.delete_chat(f"chat-{number}")
+    return {f"chat-{number}": manager.load_chat(f"chat-{number}") for number in range(keep)}
+
+
+def _reclaimable_paths(tmp_path: Path) -> tuple[str, str]:
+    return str(tmp_path / "chat.sqlite"), str(tmp_path / "legacy")
+
+
+def test_startup_reclaims_free_pages_after_large_deletes(tmp_path: Path) -> None:
+    db_path, legacy_dir = _reclaimable_paths(tmp_path)
+    manager = DatabaseManager(db_path=db_path, legacy_history_dir=legacy_dir)
+    assert _space_facts(db_path)["auto_vacuum"] == 2  # a new database is created reclaimable
+    kept = _fill_then_delete(manager, keep=3)
+    before = _space_facts(db_path)
+    assert before["free_pages"] > 300
+
+    reopened = DatabaseManager(db_path=db_path, legacy_history_dir=legacy_dir)
+
+    after = _space_facts(db_path)
+    assert after["free_pages"] == 0
+    assert after["bytes"] < before["bytes"] / 4
+    assert {chat_id: reopened.load_chat(chat_id) for chat_id in kept} == kept
+    assert reopened.backup_status == ("ok", None)
+    assert DatabaseManager._database_is_valid(reopened.backup_path)
+    assert DatabaseManager._database_is_valid(db_path)
+
+
+def _database_without_auto_vacuum(db_path: str) -> None:
+    """An empty current-schema database as a release before auto-vacuum created it."""
+    connection = sqlite3.connect(db_path)
+    for step in range(1, DatabaseManager.SCHEMA_VERSION + 1):
+        storage._MIGRATIONS[step](connection)
+    connection.execute(f"PRAGMA user_version = {DatabaseManager.SCHEMA_VERSION}")
+    connection.commit()
+    connection.close()
+
+
+def test_startup_converts_an_existing_database_once_most_of_it_is_free(tmp_path: Path) -> None:
+    """A file made before this release has no auto-vacuum; one rewrite fixes that."""
+    db_path, legacy_dir = _reclaimable_paths(tmp_path)
+    _database_without_auto_vacuum(db_path)
+    manager = DatabaseManager(db_path=db_path, legacy_history_dir=legacy_dir)
+    assert _space_facts(db_path)["auto_vacuum"] == 0  # an existing file is not silently altered
+    kept = _fill_then_delete(manager, keep=3)
+    before = _space_facts(db_path)
+
+    reopened = DatabaseManager(db_path=db_path, legacy_history_dir=legacy_dir)
+
+    after = _space_facts(db_path)
+    assert (after["free_pages"], after["auto_vacuum"]) == (0, 2)
+    assert after["bytes"] < before["bytes"] / 4
+    assert {chat_id: reopened.load_chat(chat_id) for chat_id in kept} == kept
+    assert DatabaseManager._database_is_valid(db_path)
+
+
+def test_a_rewrite_that_failed_at_one_launch_is_not_retried_at_the_next_ones(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A file whose rewrite cannot finish in the time limit must not cost every launch that limit."""
+    db_path, legacy_dir = _reclaimable_paths(tmp_path)
+    _database_without_auto_vacuum(db_path)
+    kept = _fill_then_delete(
+        DatabaseManager(db_path=db_path, legacy_history_dir=legacy_dir), keep=3
+    )
+    before = _space_facts(db_path)
+    marker = Path(f"{db_path}.reclaim-backoff")
+
+    # A launch whose rewrite cannot finish (out of time or out of room, as SQLite
+    # reports it): it is rolled back, and the launch carries on regardless.
+    def cannot_finish(_connection: sqlite3.Connection):
+        raise sqlite3.OperationalError("interrupted")
+
+    monkeypatch.setattr(sqlite_reclaim, "_rewrite", cannot_finish)
+    DatabaseManager(db_path=db_path, legacy_history_dir=legacy_dir)
+    monkeypatch.undo()
+    assert _space_facts(db_path) == before
+    assert marker.exists()
+
+    # The launches after it leave the file alone, however much time they would have had.
+    rewrites: list[str] = []
+    real_rewrite = sqlite_reclaim._rewrite
+
+    def counted(connection: sqlite3.Connection):
+        rewrites.append("ran")
+        return real_rewrite(connection)
+
+    monkeypatch.setattr(sqlite_reclaim, "_rewrite", counted)
+    for _launch in range(3):
+        DatabaseManager(db_path=db_path, legacy_history_dir=legacy_dir)
+    assert rewrites == []
+    assert _space_facts(db_path) == before
+
+    # Once the back-off is over (the marker holds only the time of the failure) it is tried again.
+    marker.write_text("0\n", encoding="ascii")
+    reopened = DatabaseManager(db_path=db_path, legacy_history_dir=legacy_dir)
+    assert rewrites == ["ran"]
+    after = _space_facts(db_path)
+    assert (after["free_pages"], after["auto_vacuum"]) == (0, 2)
+    assert {chat_id: reopened.load_chat(chat_id) for chat_id in kept} == kept
+    assert not marker.exists()
+
+
+def test_a_database_that_is_mostly_in_use_is_not_touched_at_startup(tmp_path: Path) -> None:
+    db_path, legacy_dir = _reclaimable_paths(tmp_path)
+    manager = DatabaseManager(db_path=db_path, legacy_history_dir=legacy_dir)
+    _fill_then_delete(manager, keep=38)
+    before = _space_facts(db_path)
+
+    DatabaseManager(db_path=db_path, legacy_history_dir=legacy_dir)
+
+    assert _space_facts(db_path) == before
+
+
+def test_free_pages_are_left_alone_when_the_startup_backup_failed(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The rewrite is only ever done with a backup of the same content taken first."""
+    db_path, legacy_dir = _reclaimable_paths(tmp_path)
+    manager = DatabaseManager(db_path=db_path, legacy_history_dir=legacy_dir)
+    _fill_then_delete(manager, keep=3)
+    before = _space_facts(db_path)
+    attempts: list[str] = []
+
+    def reclaim(*_args, **_kwargs):
+        attempts.append("ran")
+        return "trimmed"
+
+    def no_backup(self, **_kwargs):
+        raise PersistenceError("injected: the disk is full", operation="backup")
+
+    monkeypatch.setattr(storage, "reclaim_free_space", reclaim)
+    monkeypatch.setattr(DatabaseManager, "_create_backup", no_backup)
+    reopened = DatabaseManager(db_path=db_path, legacy_history_dir=legacy_dir)
+    monkeypatch.undo()
+
+    assert reopened.backup_status[0] == "failed"
+    assert attempts == []
+    assert _space_facts(db_path) == before
+    # The next launch, with a backup, does it.
+    DatabaseManager(db_path=db_path, legacy_history_dir=legacy_dir)
+    assert _space_facts(db_path)["free_pages"] == 0
diff --git a/tests/test_chat_groups.py b/tests/test_chat_groups.py
index 337015d..0e9e3f1 100644
--- a/tests/test_chat_groups.py
+++ b/tests/test_chat_groups.py
@@ -10,6 +10,7 @@
 import os
 import shutil
 import sqlite3
+import threading
 from pathlib import Path
 
 import pytest
@@ -99,6 +100,97 @@ def test_moving_an_unknown_chat_reports_miss_without_raising(tmp_path: Path) ->
         assert repository.set_chat_group("missing-thread", "g1") is False
 
 
+class _InterleavingConnection(sqlite3.Connection):
+    """A connection that lets a test run another writer at a chosen statement.
+
+    ``before`` is called with each statement's text just before it executes, so
+    a test can land a second connection's write exactly between two statements
+    of the operation under test instead of hoping two threads collide.
+    """
+
+    before = None
+
+    def execute(self, sql, *args):
+        hook = type(self).before
+        if hook is not None:
+            hook(sql)
+        return super().execute(sql, *args)
+
+
+def test_concurrent_group_creation_never_produces_duplicate_positions(tmp_path: Path) -> None:
+    database = DatabaseManager(db_path=str(tmp_path / "chats.sqlite"))
+    workers = 8
+    start = threading.Barrier(workers)
+    failures: list[BaseException] = []
+
+    def create(index: int) -> None:
+        try:
+            start.wait(timeout=10)
+            database.create_group(f"g{index}", f"Group {index}")
+        except BaseException as exc:  # reported below, from the test thread
+            failures.append(exc)
+
+    threads = [threading.Thread(target=create, args=(index,)) for index in range(workers)]
+    for thread in threads:
+        thread.start()
+    for thread in threads:
+        thread.join(timeout=30)
+        assert not thread.is_alive(), "a group-creating thread did not finish"
+
+    assert failures == []
+    assert sorted(group["position"] for group in database.list_groups()) == list(range(workers))
+
+
+def test_a_group_deleted_while_a_chat_is_being_moved_cannot_orphan_the_chat(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The check that the group exists and the move must be one atomic step.
+
+    A second connection deletes the group at the moment the move is about to be
+    written. Whether that delete is held off until the move commits, or lands
+    first and refuses the move, the chat must never end up filed under a group
+    that is gone -- the sidebar hides such a chat until the next startup sweep.
+    """
+    path = str(tmp_path / "chats.sqlite")
+    database = DatabaseManager(db_path=path)
+    database.create_chat("t1", "Alpha")
+    database.create_group("g1", "Research")
+    real_connect = sqlite3.connect
+    interleaved: list[str] = []
+
+    def delete_the_group_now(sql: str) -> None:
+        if interleaved or not sql.lstrip().upper().startswith("UPDATE THREADS SET GROUP_ID = ?"):
+            return
+        interleaved.append("tried")
+        other = real_connect(path, timeout=0.05)
+        try:
+            other.execute("UPDATE threads SET group_id = NULL WHERE group_id = 'g1'")
+            other.execute("DELETE FROM chat_groups WHERE id = 'g1'")
+            other.commit()
+            interleaved[0] = "deleted"
+        except sqlite3.OperationalError:
+            interleaved[0] = "held off"
+        finally:
+            other.close()
+
+    def connect(*args, **kwargs):
+        kwargs.setdefault("factory", _InterleavingConnection)
+        return real_connect(*args, **kwargs)
+
+    monkeypatch.setattr(sqlite3, "connect", connect)
+    monkeypatch.setattr(_InterleavingConnection, "before", staticmethod(delete_the_group_now))
+    try:
+        database.set_chat_group("t1", "g1")
+    except PersistenceError:
+        pass  # a refused move is acceptable; an orphaned chat is not
+    monkeypatch.undo()
+
+    assert interleaved, "the second writer never got a chance to run"
+    known = {group["id"] for group in database.list_groups()}
+    filed_under = database.get_all_chats_summary()[0]["group_id"]
+    assert filed_under is None or filed_under in known
+
+
 # -- schema migration ------------------------------------------------------
 
 
@@ -474,20 +566,22 @@ def test_a_newer_database_is_refused_untouched_and_names_the_snapshot_to_restore
     refuse it. It now refuses first, and says which file goes back."""
     path = tmp_path / "newer.sqlite"
     _write_old_schema_database(path, user_version=99)
-    # What the newer release kept when it upgraded from versions 3 and 4, plus
-    # one from the future that this release could not read anyway.
-    for version in (3, 4, 7):
+    # What the newer release kept when it upgraded from versions 3 and 4 and from
+    # this release's own, plus one from the future that this release could not
+    # read anyway.
+    current = DatabaseManager.SCHEMA_VERSION
+    for version in (3, 4, current, current + 1):
         Path(f"{path}.pre-v{version}.bak").write_bytes(b"snapshot")
     before = path.read_bytes()
 
     with pytest.raises(PersistenceError, match=r"schema version 99") as refused:
         DatabaseManager(db_path=str(path))
 
-    assert "newer.sqlite.pre-v4.bak" in str(refused.value)
+    assert f"newer.sqlite.pre-v{current}.bak" in str(refused.value)
     # Restoring replaces the database, so the message says where to put it first.
     assert "move the current database" in str(refused.value)
     assert "written since the upgrade" in str(refused.value)
-    assert "pre-v7" not in str(refused.value)
+    assert f"pre-v{current + 1}" not in str(refused.value)
     assert str(tmp_path) not in str(refused.value)
     assert path.read_bytes() == before
 
@@ -619,6 +713,173 @@ def test_a_new_database_ends_up_with_the_same_shape_as_an_upgraded_one(tmp_path:
         assert _column_names(tmp_path / "fresh.sqlite", table) == _column_names(old, table)
 
 
+ORIGINAL_OF_M1 = "m1 as the model wrote it"
+
+
+def _write_database_at(path: Path, version: int) -> None:
+    """A database as the release that stopped at schema ``version`` left it.
+
+    Built from the ladder's own first ``version`` steps, so it has exactly the
+    shape that release created: two chats, one with three messages and one
+    empty. From version 5 on the busy chat's answer also carries the original
+    text that a translated answer keeps beside what it displays.
+    """
+    connection = sqlite3.connect(path)
+    for step in range(1, version + 1):
+        storage._MIGRATIONS[step](connection)
+    connection.execute(
+        "INSERT INTO threads (id, title, timestamp) VALUES ('busy', 'Busy chat', '2026-01-02T00:00:00+00:00')"
+    )
+    connection.execute(
+        "INSERT INTO threads (id, title, timestamp) VALUES ('empty', 'Empty chat', '2026-01-01T00:00:00+00:00')"
+    )
+    for index, role in enumerate(("user", "assistant", "user")):
+        connection.execute(
+            "INSERT INTO messages (thread_id, role, content, timestamp) VALUES ('busy', ?, ?, ?)",
+            (role, f"m{index}", f"2026-01-02T00:00:0{index}+00:00"),
+        )
+    if version >= 5:
+        connection.execute(
+            "UPDATE messages SET original_content = ? WHERE thread_id = 'busy' AND content = 'm1'",
+            (ORIGINAL_OF_M1,),
+        )
+    connection.execute(f"PRAGMA user_version = {version}")
+    connection.commit()
+    connection.close()
+
+
+def _message_texts(path: Path, thread_id: str) -> list[str]:
+    probe = sqlite3.connect(path)
+    try:
+        return [
+            row[0]
+            for row in probe.execute(
+                "SELECT content FROM messages WHERE thread_id = ? ORDER BY timestamp, id", (thread_id,)
+            )
+        ]
+    finally:
+        probe.close()
+
+
+def _original_of(path: Path, content: str) -> str | None:
+    probe = sqlite3.connect(path)
+    try:
+        return probe.execute("SELECT original_content FROM messages WHERE content = ?", (content,)).fetchone()[0]
+    finally:
+        probe.close()
+
+
+def test_a_v4_database_upgrades_through_5_and_6_with_each_chats_revision_set_to_its_message_count(
+    tmp_path: Path,
+) -> None:
+    path = tmp_path / "chats.sqlite"
+    _write_database_at(path, 4)
+
+    database = DatabaseManager(db_path=str(path))
+
+    assert _user_version(path) == 6
+    assert database.load_chat_overview("busy")["revision"] == 3
+    assert database.load_chat_overview("empty")["revision"] == 0
+    assert [message["content"] for message in database.load_chat("busy")["messages"]] == ["m0", "m1", "m2"]
+    # Step 5 ran on the way: the column is there and the earlier answers have no original.
+    assert "original_content" in _column_names(path, "messages")
+    assert {message["original_content"] for message in database.load_chat("busy")["messages"]} == {None}
+    assert "revision" in _column_names(path, "threads")
+    # The upgrade kept what it started from, in the shape the previous release reads.
+    snapshot = Path(f"{path}.pre-v4.bak")
+    assert _user_version(snapshot) == 4
+    assert "revision" not in _column_names(snapshot, "threads")
+    assert "original_content" not in _column_names(snapshot, "messages")
+    assert not Path(f"{path}.pre-v5.bak").exists()  # one snapshot per upgrade, of where it began
+    # And the counter carries on from there.
+    database.add_message("busy", "user", "next", expected_revision=3)
+    assert database.load_chat_overview("busy")["revision"] == 4
+
+
+def test_a_v5_database_upgrades_to_v6_keeping_its_originals_and_backfilling_revisions(tmp_path: Path) -> None:
+    """A database written by the release that added ``original_content``."""
+    path = tmp_path / "chats.sqlite"
+    _write_database_at(path, 5)
+
+    database = DatabaseManager(db_path=str(path))
+
+    assert _user_version(path) == 6
+    assert database.load_chat_overview("busy")["revision"] == 3
+    assert database.load_chat_overview("empty")["revision"] == 0
+    messages = database.load_chat("busy")["messages"]
+    assert [message["content"] for message in messages] == ["m0", "m1", "m2"]
+    assert [message["original_content"] for message in messages] == [None, ORIGINAL_OF_M1, None]
+    snapshot = Path(f"{path}.pre-v5.bak")
+    assert _user_version(snapshot) == 5
+    assert "revision" not in _column_names(snapshot, "threads")
+    assert _original_of(snapshot, "m1") == ORIGINAL_OF_M1
+    assert not Path(f"{path}.pre-v4.bak").exists()
+    database.add_message("busy", "user", "next", expected_revision=3)
+    assert database.load_chat_overview("busy")["revision"] == 4
+
+
+@pytest.mark.parametrize("previous_release_reads", [4, 5], ids=["reads-4", "reads-5"])
+def test_the_previous_release_refuses_the_upgraded_database_and_the_named_snapshot_restores_it(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, previous_release_reads: int
+) -> None:
+    """The rollback procedure for the revision column, end to end.
+
+    Schema 6 is what this release writes. The release before it reads schema 5
+    and the one before that reads 4. Each must refuse the upgraded file without
+    touching it and name the snapshot to go back to; following that advice (move
+    the database and its logs aside, copy the snapshot into place) gives back
+    every chat as it was when the upgrade ran.
+    """
+    path = tmp_path / "chats.sqlite"
+    _write_database_at(path, previous_release_reads)
+    upgraded = DatabaseManager(db_path=str(path))
+    upgraded.add_message("busy", "user", "written after the upgrade", expected_revision=3)
+    monkeypatch.setattr(DatabaseManager, "SCHEMA_VERSION", previous_release_reads)
+    snapshot_name = f"{path.name}.pre-v{previous_release_reads}.bak"
+
+    with pytest.raises(PersistenceError, match="schema version 6") as refused:
+        DatabaseManager(db_path=str(path))
+    assert snapshot_name in str(refused.value)
+
+    aside = tmp_path / "aside"
+    aside.mkdir()
+    for suffix in ("", "-wal", "-shm"):
+        if Path(f"{path}{suffix}").exists():
+            shutil.move(f"{path}{suffix}", aside / f"{path.name}{suffix}")
+    shutil.copy2(tmp_path / snapshot_name, path)
+    DatabaseManager(db_path=str(path))  # the previous release opens it again
+
+    assert _user_version(path) == previous_release_reads
+    assert "revision" not in _column_names(path, "threads")
+    assert _message_texts(path, "busy") == ["m0", "m1", "m2"]
+    if previous_release_reads >= 5:
+        assert _original_of(path, "m1") == ORIGINAL_OF_M1
+    # What was written after the upgrade is still in the file that was moved aside.
+    assert _message_texts(aside / path.name, "busy") == ["m0", "m1", "m2", "written after the upgrade"]
+    # Going forward again upgrades the restored file once more.
+    monkeypatch.undo()
+    again = DatabaseManager(db_path=str(path))
+    assert _user_version(path) == 6
+    assert again.load_chat_overview("busy")["revision"] == 3
+
+
+def test_running_the_revision_step_again_never_lowers_a_revision(tmp_path: Path) -> None:
+    database = DatabaseManager(db_path=str(tmp_path / "chats.sqlite"))
+    database.add_message("t", "user", "q", thread_title="T")
+    answer = database.add_message("t", "assistant", "a")
+    database.replace_message("t", int(answer), "a again")
+    assert database.load_chat_overview("t")["revision"] == 3  # two messages, one regeneration
+
+    connection = sqlite3.connect(database.db_path)
+    try:
+        storage._MIGRATIONS[6](connection)
+        connection.commit()
+    finally:
+        connection.close()
+
+    assert database.load_chat_overview("t")["revision"] == 3
+
+
 def test_a_chat_pointing_at_a_vanished_group_is_returned_to_ungrouped(tmp_path: Path) -> None:
     """There is no FOREIGN KEY on threads.group_id (SQLite cannot add one via
     ALTER TABLE), so a chat could outlive its group after an interrupted
diff --git a/tests/test_chat_repository_contract.py b/tests/test_chat_repository_contract.py
new file mode 100644
index 0000000..75b73ca
--- /dev/null
+++ b/tests/test_chat_repository_contract.py
@@ -0,0 +1,499 @@
+"""One behavioural contract for both chat repositories.
+
+Every API test runs against ``InMemoryChatRepository`` (the demo and test
+dependencies use it), while the application itself runs on
+``LegacyDatabaseChatRepository`` over SQLite. The two were written separately
+and drifted: renaming a chat moved it to the top of the sidebar in one and not
+the other, a fork could overwrite an existing chat in one, a new group could
+reuse a position in one. Route behaviour proven against the double is only
+worth anything if the double behaves like the real store, so each test below
+runs against both, and a difference between them is a failing test.
+
+Where the two legitimately differ the test says so instead of hiding it:
+duplicate ids are refused with each store's own error type, and SQLite hands
+message ids back from ``get_chat`` as integers where the double uses strings, so
+ids are compared as strings.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+import itertools
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from cortex_backend.repositories import storage
+from cortex_backend.repositories.chats import (
+    ChatGroupNotFound,
+    ChatNotFound,
+    ChatRepository,
+    ChatRepositoryError,
+    ChatRevisionConflict,
+    InMemoryChatRepository,
+    LegacyDatabaseChatRepository,
+    MessageNotFound,
+)
+from cortex_backend.repositories.storage import DatabaseManager, PersistenceError
+
+ATTACHMENT = {
+    "attachment_id": "doc-1",
+    "filename": "notes.md",
+    "mime_type": "text/markdown",
+    "size": 12,
+    "sha256": "a" * 64,
+    "kind": "document",
+    "expires_at": "2099-01-01T00:00:00+00:00",
+}
+SOURCES = [{"title": "Reference", "url": "https://example.test/reference"}]
+STATS = {"tokens": 12, "seconds": 0.5}
+
+# What a store raises when it refuses to create something that already exists.
+_REFUSED_AS_DUPLICATE = (ChatRepositoryError, PersistenceError)
+
+
+@pytest.fixture
+def clock(monkeypatch: pytest.MonkeyPatch) -> None:
+    """One strictly increasing clock for both stores.
+
+    Recency ordering is part of the contract, and the wall clock on Windows can
+    return the same reading for two consecutive calls, which would make a
+    correct implementation look like it tied.
+    """
+    ticks = itertools.count(1)
+
+    def now() -> str:
+        moment = datetime(2030, 1, 1, tzinfo=timezone.utc) + timedelta(seconds=next(ticks))
+        return moment.isoformat(timespec="microseconds")
+
+    monkeypatch.setattr(storage, "_utc_now_iso", now)
+    monkeypatch.setattr(InMemoryChatRepository, "_timestamp", staticmethod(now))
+
+
+@pytest.fixture(params=["memory", "sqlite"])
+def repository(request: pytest.FixtureRequest, tmp_path: Path, clock: None) -> ChatRepository:
+    if request.param == "memory":
+        return InMemoryChatRepository()
+    database = DatabaseManager(
+        db_path=str(tmp_path / "chats.sqlite"),
+        legacy_history_dir=str(tmp_path / "legacy"),
+    )
+    return LegacyDatabaseChatRepository(database)
+
+
+def _ids(chats: list[dict[str, Any]]) -> list[str]:
+    return [chat["id"] for chat in chats]
+
+
+def _messages(repository: ChatRepository, thread_id: str) -> list[dict[str, Any]]:
+    chat = repository.get_chat(thread_id)
+    assert chat is not None
+    return chat["messages"]
+
+
+def _a_turn(repository: ChatRepository, thread_id: str = "t1", title: str = "Topic") -> tuple[str, str]:
+    """A chat with a user turn and an answer carrying every optional field."""
+    repository.create_chat(thread_id, title)
+    user_id = repository.add_message(thread_id, "user", "question", attachments=[ATTACHMENT])
+    assistant_id = repository.add_message(
+        thread_id,
+        "assistant",
+        "answer",
+        sources=SOURCES,
+        thoughts="reasoning",
+        stats=STATS,
+    )
+    return user_id, assistant_id
+
+
+# -- create, read, overview ---------------------------------------------------
+
+
+def test_a_new_chat_is_empty_ungrouped_and_listed(repository: ChatRepository) -> None:
+    repository.create_chat("t1", "Topic")
+
+    chat = repository.get_chat("t1")
+
+    assert chat is not None
+    assert (chat["id"], chat["title"], chat["group_id"], chat["messages"]) == ("t1", "Topic", None, [])
+    assert datetime.fromisoformat(chat["timestamp"]).tzinfo is not None
+    assert [(item["id"], item["title"]) for item in repository.list_summaries()] == [("t1", "Topic")]
+
+
+def test_creating_a_chat_twice_is_refused_and_keeps_the_first(repository: ChatRepository) -> None:
+    repository.create_chat("t1", "First")
+    repository.add_message("t1", "user", "kept")
+
+    with pytest.raises(_REFUSED_AS_DUPLICATE):
+        repository.create_chat("t1", "Second")
+
+    chat = repository.get_chat("t1")
+    assert chat is not None
+    assert chat["title"] == "First"
+    assert [message["content"] for message in chat["messages"]] == ["kept"]
+
+
+def test_an_unknown_chat_reads_as_none(repository: ChatRepository) -> None:
+    assert repository.get_chat("missing") is None
+    assert repository.get_chat_overview("missing") is None
+
+
+def test_the_overview_agrees_with_the_full_chat(repository: ChatRepository) -> None:
+    _a_turn(repository)
+    repository.create_group("g1", "Research")
+    repository.set_chat_group("t1", "g1")
+
+    chat = repository.get_chat("t1")
+    overview = repository.get_chat_overview("t1")
+
+    assert chat is not None and overview is not None
+    assert set(overview) == {"id", "title", "timestamp", "group_id", "revision"}
+    for field in ("id", "title", "timestamp", "group_id"):
+        assert overview[field] == chat[field], field
+    assert overview["group_id"] == "g1"
+
+
+# -- listing order ---------------------------------------------------------------
+
+
+def test_a_new_message_moves_its_chat_to_the_top_of_the_list(repository: ChatRepository) -> None:
+    repository.create_chat("older", "Older")
+    repository.create_chat("newer", "Newer")
+    assert _ids(repository.list_summaries()) == ["newer", "older"]
+
+    repository.add_message("older", "user", "hello")
+
+    assert _ids(repository.list_summaries()) == ["older", "newer"]
+
+
+def test_renaming_a_chat_does_not_change_its_place_in_the_list(repository: ChatRepository) -> None:
+    """A rename is not activity: it must not jump the chat to the top of the sidebar."""
+    repository.create_chat("older", "Older")
+    repository.create_chat("newer", "Newer")
+    stamp_before = repository.get_chat_overview("older")["timestamp"]  # type: ignore[index]
+
+    repository.rename_chat("older", "Older, renamed")
+
+    assert _ids(repository.list_summaries()) == ["newer", "older"]
+    overview = repository.get_chat_overview("older")
+    assert overview is not None
+    assert overview["title"] == "Older, renamed"
+    assert overview["timestamp"] == stamp_before
+
+
+def test_renaming_an_unknown_chat_is_not_found(repository: ChatRepository) -> None:
+    with pytest.raises(ChatNotFound):
+        repository.rename_chat("missing", "Title")
+    assert repository.list_summaries() == []
+
+
+# -- adding messages ------------------------------------------------------------
+
+
+def test_a_message_on_an_unknown_chat_needs_a_title_to_create_it(repository: ChatRepository) -> None:
+    with pytest.raises(ChatNotFound):
+        repository.add_message("missing", "user", "hello")
+    assert repository.get_chat("missing") is None
+    assert repository.list_summaries() == []
+
+    repository.add_message("missing", "user", "hello", thread_title="Created by the first message")
+
+    chat = repository.get_chat("missing")
+    assert chat is not None and chat["title"] == "Created by the first message"
+    assert [message["content"] for message in chat["messages"]] == ["hello"]
+
+
+def test_a_title_is_only_used_to_create_a_chat_never_to_rename_one(repository: ChatRepository) -> None:
+    repository.create_chat("t1", "Original")
+
+    repository.add_message("t1", "user", "hello", thread_title="Ignored")
+
+    assert repository.get_chat_overview("t1")["title"] == "Original"  # type: ignore[index]
+
+
+def test_every_field_of_a_message_round_trips(repository: ChatRepository) -> None:
+    user_id, assistant_id = _a_turn(repository)
+
+    user, assistant = _messages(repository, "t1")
+
+    assert (str(user["id"]), str(assistant["id"])) == (user_id, assistant_id)
+    assert user_id != assistant_id
+    assert (user["role"], user["content"], user["attachments"]) == ("user", "question", [ATTACHMENT])
+    assert (assistant["role"], assistant["content"]) == ("assistant", "answer")
+    assert (assistant["sources"], assistant["thoughts"], assistant["stats"]) == (SOURCES, "reasoning", STATS)
+    assert (user["sources"], user["thoughts"], user["stats"]) == (None, None, None)
+    for message in (user, assistant):
+        assert datetime.fromisoformat(message["timestamp"]).tzinfo is not None
+
+
+def test_reasoning_and_stats_belong_to_assistant_messages_only(repository: ChatRepository) -> None:
+    repository.create_chat("t1", "Topic")
+
+    repository.add_message("t1", "user", "question", thoughts="must not persist", stats=STATS)
+
+    (message,) = _messages(repository, "t1")
+    assert message["thoughts"] is None
+    assert message["stats"] is None
+
+
+def test_empty_optional_fields_read_back_as_none(repository: ChatRepository) -> None:
+    repository.create_chat("t1", "Topic")
+
+    repository.add_message("t1", "assistant", "answer", sources=[], attachments=[], stats={})
+
+    (message,) = _messages(repository, "t1")
+    assert (message["sources"], message["attachments"], message["stats"]) == (None, None, None)
+
+
+def test_messages_come_back_in_the_order_they_were_added(repository: ChatRepository) -> None:
+    repository.create_chat("t1", "Topic")
+    added = [repository.add_message("t1", "user" if index % 2 == 0 else "assistant", f"m{index}") for index in range(6)]
+
+    messages = _messages(repository, "t1")
+
+    assert [str(message["id"]) for message in messages] == added
+    assert [message["content"] for message in messages] == [f"m{index}" for index in range(6)]
+
+
+def test_an_invalid_expected_revision_is_a_value_error(repository: ChatRepository) -> None:
+    repository.create_chat("t1", "Topic")
+
+    for bad in (-1, True, "0", 1.5):
+        with pytest.raises(ValueError):
+            repository.add_message("t1", "user", "x", expected_revision=bad)  # type: ignore[arg-type]
+
+    assert _messages(repository, "t1") == []
+
+
+def test_a_stale_expected_revision_is_a_conflict_and_writes_nothing(repository: ChatRepository) -> None:
+    repository.create_chat("t1", "Topic")
+    repository.add_message("t1", "user", "one", expected_revision=0)
+
+    with pytest.raises(ChatRevisionConflict):
+        repository.add_message("t1", "user", "stale", expected_revision=0)
+    with pytest.raises(ChatRevisionConflict):
+        repository.add_message("missing", "user", "stale", expected_revision=3, thread_title="New")
+
+    assert [message["content"] for message in _messages(repository, "t1")] == ["one"]
+    assert repository.get_chat("missing") is None
+
+
+# -- replacing a response ------------------------------------------------------
+
+
+def test_replacing_a_response_keeps_its_place_and_its_user_turn(repository: ChatRepository) -> None:
+    user_id, assistant_id = _a_turn(repository)
+
+    repository.replace_message(
+        "t1", assistant_id, "better answer", sources=None, thoughts="second thoughts", stats={"tokens": 3}
+    )
+
+    user, assistant = _messages(repository, "t1")
+    assert (str(user["id"]), user["content"], user["attachments"]) == (user_id, "question", [ATTACHMENT])
+    assert (str(assistant["id"]), assistant["content"]) == (assistant_id, "better answer")
+    assert (assistant["sources"], assistant["thoughts"], assistant["stats"]) == (None, "second thoughts", {"tokens": 3})
+
+
+def test_replacing_a_response_leaves_attachments_alone_unless_they_are_given(repository: ChatRepository) -> None:
+    repository.create_chat("t1", "Topic")
+    repository.add_message("t1", "user", "question")
+    assistant_id = repository.add_message("t1", "assistant", "answer", attachments=[ATTACHMENT])
+
+    repository.replace_message("t1", assistant_id, "second")
+    assert _messages(repository, "t1")[1]["attachments"] == [ATTACHMENT]
+
+    repository.replace_message("t1", assistant_id, "third", attachments=[])
+    assert not _messages(repository, "t1")[1]["attachments"]
+
+
+def test_replacing_something_that_is_not_an_assistant_message_is_refused(repository: ChatRepository) -> None:
+    user_id, assistant_id = _a_turn(repository)
+    repository.create_chat("t2", "Other")
+    other_assistant = repository.add_message("t2", "assistant", "elsewhere")
+    before = repository.get_chat("t1")
+
+    # An unknown message, a user turn, another chat's message and an unknown
+    # chat are all refused; which subclass says why differs (see the module
+    # docstring), the refusal and the untouched chat do not.
+    for thread_id, message_id in (
+        ("t1", "999999"),
+        ("t1", user_id),
+        ("t1", other_assistant),
+        ("missing", assistant_id),
+    ):
+        with pytest.raises(ChatRepositoryError):
+            repository.replace_message(thread_id, message_id, "overwritten")
+
+    assert repository.get_chat("t1") == before
+    assert _messages(repository, "t2")[0]["content"] == "elsewhere"
+
+
+def test_replacing_with_a_stale_revision_is_a_conflict_and_changes_nothing(repository: ChatRepository) -> None:
+    _, assistant_id = _a_turn(repository)
+
+    with pytest.raises(ChatRevisionConflict):
+        repository.replace_message("t1", assistant_id, "stale", expected_revision=0)
+
+    assert _messages(repository, "t1")[1]["content"] == "answer"
+
+
+# -- forking --------------------------------------------------------------------
+
+
+def test_a_fork_copies_everything_up_to_the_chosen_message(repository: ChatRepository) -> None:
+    user_id, assistant_id = _a_turn(repository)
+    repository.add_message("t1", "user", "a later question")
+    source = _messages(repository, "t1")
+
+    repository.fork_chat("t1", assistant_id, "fork")
+
+    fork = repository.get_chat("fork")
+    assert fork is not None
+    assert fork["title"] == "Fork of Topic"
+    copied = fork["messages"]
+    assert len(copied) == 2
+    for original, duplicate in zip(source[:2], copied, strict=True):
+        for field in ("role", "content", "sources", "thoughts", "attachments", "stats", "timestamp"):
+            assert duplicate[field] == original[field], field
+    assert [str(message["id"]) for message in copied] != [user_id, assistant_id]  # its own rows
+    assert len(_messages(repository, "t1")) == 3
+
+
+def test_a_fork_keeps_the_original_message_times_and_order(repository: ChatRepository) -> None:
+    _, assistant_id = _a_turn(repository)
+    source = _messages(repository, "t1")
+
+    repository.fork_chat("t1", assistant_id, "fork")
+
+    stamps = [message["timestamp"] for message in _messages(repository, "fork")]
+    assert stamps == [message["timestamp"] for message in source]
+    assert stamps == sorted(stamps)
+
+
+def test_a_fork_starts_ungrouped_and_independent_of_its_source(repository: ChatRepository) -> None:
+    _, assistant_id = _a_turn(repository)
+    repository.create_group("g1", "Research")
+    repository.set_chat_group("t1", "g1")
+
+    repository.fork_chat("t1", assistant_id, "fork")
+    repository.add_message("fork", "user", "only in the fork")
+    repository.rename_chat("fork", "Renamed fork")
+
+    assert repository.get_chat_overview("fork")["group_id"] is None  # type: ignore[index]
+    assert repository.get_chat_overview("t1")["group_id"] == "g1"  # type: ignore[index]
+    assert len(_messages(repository, "t1")) == 2
+    assert repository.get_chat_overview("t1")["title"] == "Topic"  # type: ignore[index]
+
+
+def test_forking_an_unknown_chat_or_message_is_not_found(repository: ChatRepository) -> None:
+    _a_turn(repository)
+
+    with pytest.raises(ChatNotFound):
+        repository.fork_chat("missing", "1", "fork")
+    with pytest.raises(MessageNotFound):
+        repository.fork_chat("t1", "999999", "fork")
+
+    assert repository.get_chat("fork") is None
+
+
+def test_forking_onto_an_existing_chat_is_refused_and_keeps_that_chat(repository: ChatRepository) -> None:
+    _, assistant_id = _a_turn(repository)
+    repository.create_chat("taken", "Already here")
+    repository.add_message("taken", "user", "precious")
+
+    with pytest.raises(_REFUSED_AS_DUPLICATE):
+        repository.fork_chat("t1", assistant_id, "taken")
+
+    chat = repository.get_chat("taken")
+    assert chat is not None and chat["title"] == "Already here"
+    assert [message["content"] for message in chat["messages"]] == ["precious"]
+
+
+# -- groups ----------------------------------------------------------------------
+
+
+def test_groups_are_appended_after_every_existing_one_even_after_a_delete(repository: ChatRepository) -> None:
+    for group_id in ("g1", "g2", "g3"):
+        repository.create_group(group_id, group_id.upper())
+    repository.delete_group("g1")
+
+    repository.create_group("g4", "G4")
+
+    groups = repository.list_groups()
+    assert [group["id"] for group in groups] == ["g2", "g3", "g4"]
+    positions = [group["position"] for group in groups]
+    assert len(set(positions)) == 3 and positions == sorted(positions)
+
+
+def test_creating_a_group_twice_is_refused_and_keeps_the_first(repository: ChatRepository) -> None:
+    repository.create_group("g1", "First")
+
+    with pytest.raises(_REFUSED_AS_DUPLICATE):
+        repository.create_group("g1", "Second")
+
+    assert [(group["id"], group["name"]) for group in repository.list_groups()] == [("g1", "First")]
+
+
+def test_filing_a_chat_reports_what_it_did(repository: ChatRepository) -> None:
+    repository.create_chat("t1", "Topic")
+    repository.create_group("g1", "Research")
+
+    assert repository.set_chat_group("t1", "g1") is True
+    assert repository.get_chat_overview("t1")["group_id"] == "g1"  # type: ignore[index]
+    assert repository.set_chat_group("t1", None) is True
+    assert repository.get_chat_overview("t1")["group_id"] is None  # type: ignore[index]
+    assert repository.set_chat_group("missing", "g1") is False
+    assert repository.set_chat_group("missing", None) is False
+    with pytest.raises(ChatGroupNotFound):
+        repository.set_chat_group("t1", "ghost")
+    with pytest.raises(ChatGroupNotFound):
+        repository.set_chat_group("missing", "ghost")
+
+
+def test_filing_a_chat_is_not_activity(repository: ChatRepository) -> None:
+    repository.create_chat("older", "Older")
+    repository.create_chat("newer", "Newer")
+    repository.create_group("g1", "Research")
+
+    repository.set_chat_group("older", "g1")
+
+    assert _ids(repository.list_summaries()) == ["newer", "older"]
+
+
+def test_deleting_a_group_returns_its_chats_to_the_ungrouped_list(repository: ChatRepository) -> None:
+    repository.create_chat("t1", "Topic")
+    repository.create_group("g1", "Research")
+    repository.set_chat_group("t1", "g1")
+
+    repository.delete_group("g1")
+    repository.delete_group("g1")  # already gone: nothing to do
+
+    assert repository.list_groups() == []
+    assert repository.get_chat_overview("t1")["group_id"] is None  # type: ignore[index]
+
+
+# -- deleting -----------------------------------------------------------------
+
+
+def test_deleting_a_chat_removes_its_messages_too(repository: ChatRepository) -> None:
+    _a_turn(repository)
+    _a_turn(repository, "keep", "Kept")
+
+    repository.delete_chat("t1")
+
+    assert repository.get_chat("t1") is None
+    assert repository.get_chat_overview("t1") is None
+    assert _ids(repository.list_summaries()) == ["keep"]
+    # Nothing of the old chat comes back when its id is reused.
+    repository.create_chat("t1", "Reused")
+    assert _messages(repository, "t1") == []
+    assert len(_messages(repository, "keep")) == 2
+
+
+def test_deleting_an_unknown_chat_is_a_no_op(repository: ChatRepository) -> None:
+    _a_turn(repository)
+
+    repository.delete_chat("missing")
+
+    assert _ids(repository.list_summaries()) == ["t1"]
diff --git a/tests/test_chat_revision_cas.py b/tests/test_chat_revision_cas.py
index 0feb5e2..3b7b6f5 100644
--- a/tests/test_chat_revision_cas.py
+++ b/tests/test_chat_revision_cas.py
@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from concurrent.futures import ThreadPoolExecutor
+import sqlite3
 from threading import Barrier
 from pathlib import Path
 
@@ -17,11 +18,34 @@
     LegacyDatabaseChatRepository,
 )
 from cortex_backend.repositories.storage import DatabaseManager
+from cortex_backend.services.chat import chat_revision
 from cortex_backend.testing.fake_ollama import FakeOllamaState
 from support import parse_sse_events as _events
 from support import session_headers as _session
 
 
+@pytest.fixture(params=["memory", "sqlite"])
+def repository(request: pytest.FixtureRequest, tmp_path: Path):
+    """Both chat repositories: the revision must mean the same in each."""
+    if request.param == "memory":
+        return InMemoryChatRepository()
+    database = DatabaseManager(db_path=str(tmp_path / "chats.sqlite"))
+    return LegacyDatabaseChatRepository(database)
+
+
+def _revision(repository, thread_id: str = "thread") -> int:
+    overview = repository.get_chat_overview(thread_id)
+    assert overview is not None
+    return overview["revision"]
+
+
+def _chat_with_an_answer(repository) -> str:
+    """A chat holding one exchange, at revision 2; returns the answer's id."""
+    repository.create_chat("thread", "Thread")
+    repository.add_message("thread", "user", "question", expected_revision=0)
+    return repository.add_message("thread", "assistant", "first answer", expected_revision=1)
+
+
 def test_inmemory_append_is_compare_and_swap_and_atomic():
     repository = InMemoryChatRepository()
     repository.create_chat("thread", "Thread")
@@ -61,6 +85,198 @@ def test_sqlite_chat_revision_conflict_is_atomic(tmp_path: Path):
     assert [message["content"] for message in chat["messages"]] == ["one"]
 
 
+def test_a_regenerate_moves_the_revision(repository):
+    """Replacing the last reply leaves the message count alone, but it is a
+    change: two regenerations started from the same state must not both win."""
+    answer = _chat_with_an_answer(repository)
+    assert _revision(repository) == 2
+
+    repository.replace_message("thread", answer, "second answer", expected_revision=2)
+
+    assert _revision(repository) == 3
+    assert len(repository.get_chat("thread")["messages"]) == 2
+    for stale_write in (
+        lambda: repository.replace_message("thread", answer, "third answer", expected_revision=2),
+        lambda: repository.add_message("thread", "assistant", "late", expected_revision=2),
+    ):
+        with pytest.raises(ChatRevisionConflict):
+            stale_write()
+    assert [message["content"] for message in repository.get_chat("thread")["messages"]] == [
+        "question",
+        "second answer",
+    ]
+    assert _revision(repository) == 3
+
+
+def test_two_regenerations_from_the_same_revision_cannot_both_win(repository):
+    answer = _chat_with_an_answer(repository)
+    start = Barrier(2)
+
+    def regenerate(content: str) -> str | None:
+        start.wait(timeout=5)
+        try:
+            repository.replace_message("thread", answer, content, expected_revision=2)
+        except ChatRevisionConflict:
+            return None
+        return content
+
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        futures = [executor.submit(regenerate, name) for name in ("a", "b")]
+        outcomes = [future.result(timeout=10) for future in futures]
+
+    winners = [outcome for outcome in outcomes if outcome is not None]
+    assert len(winners) == 1
+    assert repository.get_chat("thread")["messages"][1]["content"] == winners[0]
+    assert _revision(repository) == 3
+
+
+def test_chat_revision_prefers_the_persisted_counter_and_falls_back_to_the_count():
+    assert chat_revision({"revision": 7, "messages": [{}, {}]}) == 7
+    assert chat_revision({"revision": 0, "messages": []}) == 0
+    # A chat that carries no counter (or a nonsense one) is counted, as before.
+    assert chat_revision({"messages": [{}, {}, {}]}) == 3
+    assert chat_revision({"revision": -1, "messages": [{}]}) == 1
+    assert chat_revision({"revision": True, "messages": [{}]}) == 1
+    assert chat_revision({}) == 0
+
+
+def test_the_chat_and_its_overview_report_the_same_revision(repository):
+    answer = _chat_with_an_answer(repository)
+    repository.replace_message("thread", answer, "second answer")
+
+    assert repository.get_chat("thread")["revision"] == _revision(repository) == 3
+
+
+def test_load_chat_reads_the_revision_and_the_messages_of_the_same_moment(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+):
+    """A write landing between the two reads of load_chat must not be half seen.
+
+    A guarded write is compared against the revision the caller read, so a chat
+    that pairs an older revision with newer messages would let the caller build
+    on rows it never saw. The write is made, through the store's own write path,
+    the instant the statement that reads the messages starts.
+    """
+    database = DatabaseManager(db_path=str(tmp_path / "chats.sqlite"))
+    database.add_message("thread", "user", "one", thread_title="Topic", expected_revision=0)
+    database.add_message("thread", "assistant", "two", expected_revision=1)
+    landed: list[str] = []
+    failures: list[BaseException] = []
+
+    def write_between_the_reads(statement: str) -> None:
+        if landed or "FROM messages" not in statement or not statement.lstrip().upper().startswith("SELECT"):
+            return
+        landed.append("written")
+        try:
+            database.add_message("thread", "user", "three", expected_revision=2)
+        except BaseException as exc:  # a trace callback's errors vanish, so keep them for the test
+            failures.append(exc)
+
+    class TracedConnection(sqlite3.Connection):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            self.set_trace_callback(write_between_the_reads)
+
+    real_connect = sqlite3.connect
+    monkeypatch.setattr(
+        sqlite3, "connect", lambda *args, **kwargs: real_connect(*args, factory=TracedConnection, **kwargs)
+    )
+    chat = database.load_chat("thread")
+    monkeypatch.undo()
+
+    assert failures == []
+    assert landed == ["written"], "the second write never got its chance"
+    # Both halves are from before the write, and agree with each other.
+    assert chat is not None
+    assert [message["content"] for message in chat["messages"]] == ["one", "two"]
+    assert chat["revision"] == len(chat["messages"]) == 2
+    # The write itself was not lost: the next read sees it, at the revision it produced.
+    assert database.load_chat("thread")["revision"] == 3
+
+
+def test_renaming_or_filing_a_chat_does_not_move_its_revision(repository):
+    """A rename or a move landing while an answer is being generated must not
+    turn that answer into a conflict: neither touches the messages."""
+    _chat_with_an_answer(repository)
+    repository.create_group("g1", "Research")
+
+    repository.rename_chat("thread", "Renamed")
+    repository.set_chat_group("thread", "g1")
+
+    assert _revision(repository) == 2
+    repository.add_message("thread", "user", "still accepted", expected_revision=2)
+
+
+def test_a_fork_starts_at_its_message_count_and_moves_from_there(repository):
+    answer = _chat_with_an_answer(repository)
+    repository.replace_message("thread", answer, "second answer")  # revision 3 over two messages
+
+    repository.fork_chat("thread", answer, "fork")
+
+    assert _revision(repository, "fork") == 2
+    repository.add_message("fork", "user", "next", expected_revision=2)
+    assert _revision(repository, "fork") == 3
+
+
+def test_removing_the_last_answer_moves_the_revision(tmp_path: Path):
+    database = DatabaseManager(db_path=str(tmp_path / "chats.sqlite"))
+    repository = LegacyDatabaseChatRepository(database)
+    _chat_with_an_answer(repository)
+
+    database.delete_last_assistant_message("thread")
+    assert _revision(repository) == 3
+    database.delete_last_assistant_message("thread")  # nothing left to remove
+    assert _revision(repository) == 3
+
+    with pytest.raises(ChatRevisionConflict):
+        repository.add_message("thread", "assistant", "stale", expected_revision=2)
+
+
+def _complete(client: TestClient, headers: dict[str, str], accepted: dict) -> None:
+    with client.stream(
+        "GET", f"/api/v1/generations/{accepted['job_id']}/events", headers=headers
+    ) as response:
+        events = _events("".join(response.iter_text()))
+    assert events[-1]["event"] == "generation.completed"
+
+
+def test_a_second_regeneration_from_the_same_base_revision_is_a_conflict(
+    client: TestClient, headers: dict[str, str]
+):
+    """The route-level view of the same guarantee: the client that regenerated
+    from revision 2 moved the chat to 3, so another client still holding 2 is
+    told to reload."""
+    accepted = client.post(
+        "/api/v1/generations",
+        json={"request_id": "regen-base", "user_input": "hello", "base_revision": 0},
+        headers=headers,
+    ).json()
+    _complete(client, headers, accepted)
+    thread_id = accepted["thread_id"]
+    chat = client.get(f"/api/v1/chats/{thread_id}", headers=headers).json()
+    assert chat["revision"] == 2
+    answer_id = chat["messages"][-1]["id"]
+
+    first = client.post(
+        f"/api/v1/chats/{thread_id}/regenerations",
+        json={"request_id": "regen-1", "message_id": answer_id, "base_revision": 2},
+        headers=headers,
+    )
+    assert first.status_code == 202
+    _complete(client, headers, first.json())
+    regenerated = client.get(f"/api/v1/chats/{thread_id}", headers=headers).json()
+    assert regenerated["revision"] == 3
+    assert len(regenerated["messages"]) == 2
+
+    second = client.post(
+        f"/api/v1/chats/{thread_id}/regenerations",
+        json={"request_id": "regen-2", "message_id": answer_id, "base_revision": 2},
+        headers=headers,
+    )
+
+    assert second.status_code == 409
+    assert "changed" in second.json()["detail"].lower()
+    assert client.get(f"/api/v1/chats/{thread_id}", headers=headers).json()["revision"] == 3
 
 
 def test_generation_route_rejects_a_stale_base_revision():
diff --git a/tests/test_event_loop_hygiene.py b/tests/test_event_loop_hygiene.py
index a56d33d..614314f 100644
--- a/tests/test_event_loop_hygiene.py
+++ b/tests/test_event_loop_hygiene.py
@@ -381,7 +381,7 @@ def test_retrying_an_unanswered_message_does_not_repeat_it_in_the_history() -> N
 
 def test_the_sqlite_repository_takes_the_same_single_read_path(tmp_path: Path) -> None:
     """The same flow over the real database, where the transcript is decoded
-    from rows and the revision is a count."""
+    from rows and the revision is a stored counter."""
     app, probe = _probed_app(
         chats=LegacyDatabaseChatRepository(DatabaseManager(db_path=str(tmp_path / "chats.sqlite")))
     )
diff --git a/tests/test_persistence.py b/tests/test_persistence.py
index 4362fc1..16f05fd 100644
--- a/tests/test_persistence.py
+++ b/tests/test_persistence.py
@@ -1,8 +1,12 @@
 """Persistence, migration, and recovery tests for local Cortex data."""
 
+import errno
 import json
+import logging
 import os
 import shutil
+import sqlite3
+import sys
 import tempfile
 import threading
 import unittest
@@ -10,6 +14,9 @@
 from pathlib import Path
 from unittest.mock import patch
 
+import pytest
+
+from sqlite_faults import disk_full_when
 import cortex_backend.repositories.storage as storage
 from cortex_backend.repositories.storage import (
     DatabaseManager,
@@ -25,6 +32,7 @@ def test_persistence_logs_omit_private_paths_and_chat_titles(self):
             private_title = "Alice's confidential launch plan"
             with self.assertLogs(level="INFO") as captured:
                 manager = DatabaseManager(db_path=str(private_db_path))
+                manager.create_chat("private-thread-id", "Untitled")
                 manager.update_chat_title("private-thread-id", private_title)
 
             rendered_logs = "\n".join(captured.output)
@@ -474,3 +482,470 @@ def test_forking_keeps_each_message_timestamp(self):
                 [message["content"] for message in forked],
                 ["first", "second"],
             )
+
+
+# -- Windows sharing violations and the memory backup copy ---------------------------
+
+
+def _memory_manager(tmp_path: Path) -> tuple[PermanentMemoryManager, Path]:
+    memory_file = tmp_path / "memory.json"
+    manager = PermanentMemoryManager(memory_file_path=str(memory_file))
+    manager.add_memo("first")  # the next save has a primary to back up
+    return manager, memory_file
+
+
+def _on_disk_memos(path: Path) -> list[str]:
+    return json.loads(path.read_text(encoding="utf-8"))["memos"]
+
+
+def _leftover_temporaries(directory: Path) -> list[str]:
+    return sorted(entry.name for entry in directory.iterdir() if entry.name.endswith(".tmp"))
+
+
+def _hold_the_memory_file(monkeypatch: pytest.MonkeyPatch, memory_file: Path, *, refusals: int):
+    """Refuse the first ``refusals`` renames onto the memory file, as a scanner holding it would."""
+    real_replace = os.replace
+    target = os.path.normcase(os.path.abspath(memory_file))
+    attempts: list[str] = []
+    waits: list[float] = []
+
+    def replace(source, destination, *args, **kwargs):
+        if os.path.normcase(os.path.abspath(destination)) == target:
+            attempts.append(str(source))
+            if len(attempts) <= refusals:
+                raise PermissionError(errno.EACCES, "The process cannot access the file")
+        return real_replace(source, destination, *args, **kwargs)
+
+    monkeypatch.setattr(os, "replace", replace)
+    monkeypatch.setattr("time.sleep", waits.append)
+    return attempts, waits
+
+
+def test_a_transient_sharing_violation_does_not_fail_a_memory_save(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    manager, memory_file = _memory_manager(tmp_path)
+    attempts, waits = _hold_the_memory_file(monkeypatch, memory_file, refusals=2)
+
+    manager.add_memo("second")
+    monkeypatch.undo()
+
+    assert len(attempts) == 3 and len(waits) == 2
+    assert manager.get_memos() == ["first", "second"]
+    assert _on_disk_memos(memory_file) == ["first", "second"]
+    assert _on_disk_memos(Path(manager.backup_file_path)) == ["first"]
+    assert _leftover_temporaries(tmp_path) == []
+
+
+def test_a_sharing_violation_that_does_not_lift_fails_the_save_and_changes_nothing(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    manager, memory_file = _memory_manager(tmp_path)
+    before = memory_file.read_bytes()
+    attempts, _ = _hold_the_memory_file(monkeypatch, memory_file, refusals=10_000)
+
+    with pytest.raises(PersistenceError):
+        manager.add_memo("second")
+    monkeypatch.undo()
+
+    assert len(attempts) == 4  # bounded, not a loop
+    assert manager.get_memos() == ["first"]  # the in-memory list rolled back with the file
+    assert memory_file.read_bytes() == before
+    assert _leftover_temporaries(tmp_path) == []
+
+
+def test_the_memory_backup_copy_is_flushed_to_disk_before_it_replaces_the_backup(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The backup is what the next launch restores from, so it gets the same
+    fsync the primary gets: one for the new file and one for the backup copy."""
+    manager, _ = _memory_manager(tmp_path)
+    backup = os.path.normcase(os.path.abspath(manager.backup_file_path))
+    real_replace, real_fsync = os.replace, os.fsync
+    flushed_before_backup_replaced: list[int] = []
+    flushes = 0
+
+    def fsync(descriptor):
+        nonlocal flushes
+        flushes += 1
+        return real_fsync(descriptor)
+
+    def replace(source, destination, *args, **kwargs):
+        if os.path.normcase(os.path.abspath(destination)) == backup:
+            flushed_before_backup_replaced.append(flushes)
+        return real_replace(source, destination, *args, **kwargs)
+
+    monkeypatch.setattr(os, "fsync", fsync)
+    monkeypatch.setattr(os, "replace", replace)
+
+    manager.add_memo("second")
+    monkeypatch.undo()
+
+    assert flushed_before_backup_replaced == [2]
+
+
+# -- the legacy JSON directory is retired once it is empty ---------------------------
+
+
+def _legacy_chat(directory: Path, name: str, *, valid: bool = True) -> Path:
+    path = directory / f"{name}.json"
+    if valid:
+        path.write_text(
+            json.dumps({"id": name, "title": name, "messages": [{"role": "user", "content": "hi"}]}),
+            encoding="utf-8",
+        )
+    else:
+        path.write_text("{not json", encoding="utf-8")
+    return path
+
+
+def _legacy_manager(tmp_path: Path) -> tuple[DatabaseManager, Path]:
+    legacy = tmp_path / "chat_history"
+    legacy.mkdir()
+    return DatabaseManager(db_path=str(tmp_path / "chats.sqlite"), legacy_history_dir=str(legacy)), legacy
+
+
+def _warnings(caplog: pytest.LogCaptureFixture) -> list[str]:
+    return [record.getMessage() for record in caplog.records if record.levelno >= logging.WARNING]
+
+
+def test_a_second_migration_pass_is_silent_and_retires_the_source_directory(
+    tmp_path: Path, caplog: pytest.LogCaptureFixture
+) -> None:
+    manager, legacy = _legacy_manager(tmp_path)
+    _legacy_chat(legacy, "one")
+    _legacy_chat(legacy, "two")
+
+    with caplog.at_level(logging.INFO):
+        first = manager.migrate_from_json_if_needed()
+    assert first.migrated == 2
+    assert len(_warnings(caplog)) == 1  # the one-time "legacy history found"
+    archives = list(tmp_path.glob("chat_history_migrated_*"))
+    assert len(archives) == 1
+    assert sorted(entry.name for entry in archives[0].iterdir()) == ["one.json", "two.json"]
+    assert not legacy.exists()  # nothing left in it, so it is out of the way ...
+    retired = tmp_path / "chat_history.retired"
+    assert retired.is_dir() and list(retired.iterdir()) == []  # ... under a name that says so
+
+    caplog.clear()
+    with caplog.at_level(logging.INFO):
+        second = manager.migrate_from_json_if_needed()
+
+    assert second == storage.MigrationResult()
+    assert caplog.records == []
+    assert sorted(entry.name for entry in archives[0].iterdir()) == ["one.json", "two.json"]
+    assert {chat["id"] for chat in manager.get_all_chats_summary()} == {"one", "two"}
+
+
+def test_an_imported_legacy_chat_starts_at_the_revision_of_its_message_count(tmp_path: Path) -> None:
+    """The revision a client reads after an import is what its next write is checked against."""
+    manager, legacy = _legacy_manager(tmp_path)
+    for name, count in (("three", 3), ("one", 1)):
+        (legacy / f"{name}.json").write_text(
+            json.dumps(
+                {
+                    "id": name,
+                    "title": name,
+                    "messages": [
+                        {"role": "user" if index % 2 == 0 else "assistant", "content": f"turn {index}"}
+                        for index in range(count)
+                    ],
+                }
+            ),
+            encoding="utf-8",
+        )
+
+    assert manager.migrate_from_json_if_needed().migrated == 2
+
+    for name, count in (("three", 3), ("one", 1)):
+        chat = manager.load_chat(name)
+        assert chat is not None and len(chat["messages"]) == count
+        assert chat["revision"] == count
+        assert manager.load_chat_overview(name)["revision"] == count
+    # A client that loaded the imported chat can continue it; one holding revision 0 cannot.
+    with pytest.raises(PersistenceError) as stale:
+        manager.add_message("three", "user", "from a stale client", expected_revision=0)
+    assert stale.value.operation == "chat_revision_conflict"
+    manager.add_message("three", "user", "next", expected_revision=3)
+    assert manager.load_chat_overview("three")["revision"] == 4
+
+
+def test_an_empty_legacy_directory_is_retired_without_a_warning(
+    tmp_path: Path, caplog: pytest.LogCaptureFixture
+) -> None:
+    manager, legacy = _legacy_manager(tmp_path)
+    (legacy / "quarantine").mkdir()  # left empty by an earlier pass
+
+    with caplog.at_level(logging.INFO):
+        result = manager.migrate_from_json_if_needed()
+
+    assert result == storage.MigrationResult()
+    assert _warnings(caplog) == []
+    assert not legacy.exists()
+    # Renamed as it was, so the folder that was empty is still there, still empty, and not deleted.
+    retired = tmp_path / "chat_history.retired"
+    assert [entry.name for entry in retired.iterdir()] == ["quarantine"]
+    assert list((retired / "quarantine").iterdir()) == []
+
+
+def test_retiring_the_legacy_directory_never_deletes_a_folder(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    manager, legacy = _legacy_manager(tmp_path)
+    (legacy / "quarantine").mkdir()
+
+    def forbidden(*_args, **_kwargs):
+        raise AssertionError("a folder was deleted")
+
+    monkeypatch.setattr(storage.os, "rmdir", forbidden)
+    monkeypatch.setattr(storage.shutil, "rmtree", forbidden)
+    manager.migrate_from_json_if_needed()
+    monkeypatch.undo()
+
+    assert (tmp_path / "chat_history.retired" / "quarantine").is_dir()
+
+
+def test_a_retired_name_that_is_taken_is_never_reused(tmp_path: Path) -> None:
+    """History dropped into the old folder again is imported again, and retired under a new name."""
+    manager, legacy = _legacy_manager(tmp_path)
+    manager.migrate_from_json_if_needed()
+    first = tmp_path / "chat_history.retired"
+    (first / "kept.txt").write_text("from the first retirement", encoding="utf-8")
+    assert first.is_dir() and not legacy.exists()
+
+    legacy.mkdir()
+    _legacy_chat(legacy, "again")
+    result = manager.migrate_from_json_if_needed()
+
+    assert result.migrated == 1
+    assert (first / "kept.txt").read_text(encoding="utf-8") == "from the first retirement"
+    second = tmp_path / "chat_history.retired-2"
+    assert second.is_dir() and list(second.iterdir()) == []
+    assert not legacy.exists()
+
+
+def test_a_folder_that_cannot_be_renamed_is_left_where_it_is(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
+) -> None:
+    manager, legacy = _legacy_manager(tmp_path)
+
+    def held(*_args, **_kwargs):
+        raise PermissionError(errno.EACCES, "held by another program")
+
+    monkeypatch.setattr(storage.os, "rename", held)
+    with caplog.at_level(logging.INFO):
+        result = manager.migrate_from_json_if_needed()
+    monkeypatch.undo()
+
+    assert result == storage.MigrationResult()
+    assert legacy.is_dir() and not (tmp_path / "chat_history.retired").exists()
+    assert _warnings(caplog) == []
+    # The next launch, with the folder free, retires it.
+    manager.migrate_from_json_if_needed()
+    assert not legacy.exists() and (tmp_path / "chat_history.retired").is_dir()
+
+
+def test_quarantined_files_keep_the_legacy_directory_and_are_never_touched(
+    tmp_path: Path, caplog: pytest.LogCaptureFixture
+) -> None:
+    manager, legacy = _legacy_manager(tmp_path)
+    _legacy_chat(legacy, "good")
+    _legacy_chat(legacy, "broken", valid=False)
+    manager.migrate_from_json_if_needed()
+    quarantined = legacy / "quarantine" / "broken.json"
+    assert quarantined.read_text(encoding="utf-8") == "{not json"
+
+    caplog.clear()
+    with caplog.at_level(logging.INFO):
+        again = manager.migrate_from_json_if_needed()
+
+    assert again == storage.MigrationResult()
+    assert _warnings(caplog) == []
+    assert any("quarantine" in record.getMessage() for record in caplog.records)
+    assert quarantined.read_text(encoding="utf-8") == "{not json"
+
+
+def test_a_stray_file_keeps_the_legacy_directory(tmp_path: Path) -> None:
+    manager, legacy = _legacy_manager(tmp_path)
+    _legacy_chat(legacy, "one")
+    (legacy / "notes.txt").write_text("mine", encoding="utf-8")
+
+    manager.migrate_from_json_if_needed()
+    manager.migrate_from_json_if_needed()
+
+    assert (legacy / "notes.txt").read_text(encoding="utf-8") == "mine"
+
+
+def test_a_chat_file_that_could_not_be_archived_stays_and_keeps_the_directory(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    manager, legacy = _legacy_manager(tmp_path)
+    source = _legacy_chat(legacy, "one")
+
+    def refuse(*_args, **_kwargs):
+        raise PermissionError(errno.EACCES, "held by another program")
+
+    monkeypatch.setattr(manager, "_archive_legacy_file", refuse)
+    manager.migrate_from_json_if_needed()
+    monkeypatch.undo()
+
+    assert source.exists()  # the source is what the next launch imports again
+    again = manager.migrate_from_json_if_needed()
+    assert again.skipped == 1  # already imported, so it is archived rather than duplicated
+    assert not source.exists()
+    assert len(manager.get_all_chats_summary()) == 1
+
+
+# -- a full disk ---------------------------------------------------------------------
+
+
+def _writes_a_message(sql: str) -> bool:
+    return sql.lstrip().upper().startswith(("INSERT INTO MESSAGES", "UPDATE MESSAGES"))
+
+
+def _a_chat_with_an_exchange(tmp_path: Path) -> tuple[DatabaseManager, dict]:
+    manager = DatabaseManager(db_path=str(tmp_path / "chats.sqlite"))
+    manager.add_message("t", "user", "kept", thread_title="Topic", expected_revision=0)
+    manager.add_message("t", "assistant", "answer", expected_revision=1)
+    chat = manager.load_chat("t")
+    assert chat is not None and chat["revision"] == 2
+    return manager, chat
+
+
+def test_a_full_disk_leaves_the_chat_consistent_and_reports_it(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    manager, before = _a_chat_with_an_exchange(tmp_path)
+    answer_id = int(before["messages"][1]["id"])
+    disk_full_when(monkeypatch, _writes_a_message)
+
+    with pytest.raises(PersistenceError) as appended:
+        manager.add_message("t", "user", "lost", expected_revision=2)
+    with pytest.raises(PersistenceError) as forked:
+        manager.create_chat_from_messages("fork", "Fork", before["messages"])
+    with pytest.raises(PersistenceError) as replaced:
+        manager.replace_message("t", answer_id, "rewritten", expected_revision=2)
+    monkeypatch.undo()
+
+    # The failure is reported as what it was, however many layers wrapped it.
+    for failure in (appended.value, forked.value, replaced.value):
+        assert isinstance(failure.cause, PersistenceError)
+        assert isinstance(failure.cause.cause, sqlite3.OperationalError)
+        assert "disk is full" in str(failure.cause.cause)
+    # Nothing was half written: the chat, its revision and its timestamp are as they were,
+    # and no empty fork was left behind.
+    assert manager.load_chat("t") == before
+    assert manager.load_chat("fork") is None
+    assert [item["id"] for item in manager.get_all_chats_summary()] == ["t"]
+    # The revision the failed write was guarded by was not spent: once there is room it goes through.
+    manager.replace_message("t", answer_id, "saved", expected_revision=2)
+    manager.add_message("t", "user", "next", expected_revision=3)
+    assert [message["content"] for message in manager.load_chat("t")["messages"]] == ["kept", "saved", "next"]
+    assert DatabaseManager._database_is_valid(manager.db_path)
+
+
+@pytest.mark.parametrize(
+    ("failure", "expected"),
+    [
+        pytest.param(OSError(errno.ENOSPC, "No space left on device"), True, id="enospc"),
+        pytest.param(sqlite3.OperationalError("database or disk is full"), True, id="sqlite-full"),
+        pytest.param(sqlite3.OperationalError("database is locked"), False, id="locked"),
+        pytest.param(sqlite3.IntegrityError("FOREIGN KEY constraint failed"), False, id="constraint"),
+        pytest.param(PermissionError(errno.EACCES, "held by another program"), False, id="permission"),
+        pytest.param(RuntimeError("something else"), False, id="unrelated"),
+    ],
+)
+def test_only_a_full_disk_is_recognised_as_one(failure: BaseException, expected: bool) -> None:
+    from cortex_backend.api.routes import _is_disk_full
+
+    wrapped = PersistenceError("Failed to add message.", operation="add_message", cause=PersistenceError(
+        "SQLite operation failed.", operation="sqlite", cause=failure
+    ))
+    assert _is_disk_full(failure) is expected
+    assert _is_disk_full(wrapped) is expected  # found through the wrapping stores add
+    chained = RuntimeError("Could not save.")
+    chained.__cause__ = failure
+    assert _is_disk_full(chained) is expected
+
+
+@pytest.mark.skipif(sys.platform != "win32", reason="winerror only exists on Windows")
+def test_windows_disk_full_errors_are_recognised() -> None:
+    from cortex_backend.api.routes import _is_disk_full
+
+    for winerror in (39, 112):
+        assert _is_disk_full(OSError(0, "There is not enough space on the disk", None, winerror))
+    assert not _is_disk_full(OSError(0, "Access is denied", None, 5))
+
+
+def test_a_full_disk_is_reported_as_insufficient_storage_and_the_chat_is_unchanged(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    from fastapi.testclient import TestClient
+
+    from cortex_backend.api import create_app
+    from cortex_backend.repositories.chats import LegacyDatabaseChatRepository
+    from cortex_backend.testing import build_demo_dependencies
+    from support import session_headers
+
+    manager, before = _a_chat_with_an_exchange(tmp_path)
+    fork_url = "/api/v1/chats/t/forks"
+    first_message = str(before["messages"][0]["id"])
+    dependencies = build_demo_dependencies()
+    dependencies.chats = LegacyDatabaseChatRepository(manager)
+    app = create_app(dependencies, allowed_hosts=("testserver",))
+    with TestClient(app) as client:
+        headers = session_headers(client, app)
+        disk_full_when(monkeypatch, _writes_a_message)
+
+        full = client.post(fork_url, json={"message_id": first_message}, headers=headers)
+        monkeypatch.undo()
+
+        assert full.status_code == 507
+        detail = full.json()["detail"]
+        assert detail == (
+            "Could not fork chat because the disk is full. Free some disk space and try again."
+        )
+        assert str(tmp_path) not in detail and "kept" not in detail
+        # Nothing was saved: the chat is as it was and no empty fork was left behind.
+        assert manager.load_chat("t") == before
+        assert [item["id"] for item in manager.get_all_chats_summary()] == ["t"]
+        # The same request goes through once there is room.
+        again = client.post(fork_url, json={"message_id": first_message}, headers=headers)
+        assert again.status_code == 201
+        assert [message["content"] for message in again.json()["messages"]] == ["kept"]
+        assert again.json()["revision"] == 1
+
+
+def test_a_failure_that_is_not_a_full_disk_is_still_an_internal_error(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    from fastapi.testclient import TestClient
+
+    from cortex_backend.api import create_app
+    from cortex_backend.repositories.chats import LegacyDatabaseChatRepository
+    from cortex_backend.testing import build_demo_dependencies
+    from support import session_headers
+
+    manager, before = _a_chat_with_an_exchange(tmp_path)
+    fork_url = "/api/v1/chats/t/forks"
+    first_message = str(before["messages"][0]["id"])
+    dependencies = build_demo_dependencies()
+    dependencies.chats = LegacyDatabaseChatRepository(manager)
+    app = create_app(dependencies, allowed_hosts=("testserver",))
+    real_fork = manager.create_chat_from_messages
+
+    def broken(*_args, **_kwargs):
+        raise PersistenceError(
+            "Failed to create forked chat.", operation="create_chat_from_messages", cause=sqlite3.DatabaseError("x")
+        )
+
+    with TestClient(app) as client:
+        headers = session_headers(client, app)
+        monkeypatch.setattr(manager, "create_chat_from_messages", broken)
+        response = client.post(fork_url, json={"message_id": first_message}, headers=headers)
+        monkeypatch.setattr(manager, "create_chat_from_messages", real_fork)
+
+    assert response.status_code == 500
+    # The request id is the one thing added to the text, so a report can be matched to the log.
+    assert response.json()["detail"] == f"Could not fork chat. (Request ID: {response.headers['X-Request-ID']})"
+    assert manager.load_chat("t") == before
diff --git a/tests/test_sqlite_backup.py b/tests/test_sqlite_backup.py
index eddcb0b..7eeb17c 100644
--- a/tests/test_sqlite_backup.py
+++ b/tests/test_sqlite_backup.py
@@ -11,9 +11,11 @@
 
 from cortex_backend.repositories import sqlite_backup
 from cortex_backend.repositories.sqlite_backup import (
+    REPLACE_ATTEMPTS,
     failure_detail,
     move_sidecars,
     put_sidecars_back,
+    replace_with_retry,
     snapshot_database,
 )
 
@@ -182,3 +184,68 @@ def test_put_sidecars_back_never_overwrites_a_file_at_the_original_name(tmp_path
     assert Path(f"{destination}-wal").read_bytes() == b"write-ahead log"
     # The other sidecar had no such conflict and still went back.
     assert Path(f"{database}-shm").read_bytes() == b"shared memory"
+
+
+# -- replace_with_retry --------------------------------------------------------
+
+
+def _refuse_replacing_until(monkeypatch: pytest.MonkeyPatch, *, refusals: int, error=PermissionError):
+    """Make os.replace fail ``refusals`` times, then work; record the waits between tries."""
+    real_replace = os.replace
+    calls: list[str] = []
+    waits: list[float] = []
+
+    def replace(source, destination, *args, **kwargs):
+        calls.append(str(destination))
+        if len(calls) <= refusals:
+            raise error(13, "The process cannot access the file because it is being used")
+        return real_replace(source, destination, *args, **kwargs)
+
+    monkeypatch.setattr(os, "replace", replace)
+    monkeypatch.setattr(time, "sleep", waits.append)
+    return calls, waits
+
+
+def test_a_sharing_violation_that_lifts_is_waited_out(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    source, destination = tmp_path / "new", tmp_path / "current"
+    source.write_bytes(b"new")
+    destination.write_bytes(b"current")
+    calls, waits = _refuse_replacing_until(monkeypatch, refusals=2)
+
+    replace_with_retry(source, destination)
+
+    assert destination.read_bytes() == b"new"
+    assert not source.exists()
+    assert len(calls) == 3
+    assert waits == [0.05, 0.1]  # doubling, and only between tries
+
+
+def test_a_sharing_violation_that_does_not_lift_is_raised_after_a_bounded_number_of_tries(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    source, destination = tmp_path / "new", tmp_path / "current"
+    source.write_bytes(b"new")
+    destination.write_bytes(b"current")
+    calls, waits = _refuse_replacing_until(monkeypatch, refusals=10_000)
+
+    with pytest.raises(PermissionError):
+        replace_with_retry(source, destination)
+
+    assert len(calls) == REPLACE_ATTEMPTS
+    assert len(waits) == REPLACE_ATTEMPTS - 1
+    assert sum(waits) < 1.0  # a lock that stays is reported promptly
+    # Nothing was moved: the file that was there is intact and so is the new one.
+    assert destination.read_bytes() == b"current"
+    assert source.read_bytes() == b"new"
+
+
+def test_an_error_other_than_a_sharing_violation_is_not_retried(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    calls, waits = _refuse_replacing_until(monkeypatch, refusals=10_000, error=FileNotFoundError)
+
+    with pytest.raises(FileNotFoundError):
+        replace_with_retry(tmp_path / "missing", tmp_path / "current")
+
+    assert len(calls) == 1
+    assert waits == []
diff --git a/tests/test_sqlite_reclaim.py b/tests/test_sqlite_reclaim.py
new file mode 100644
index 0000000..eafcc09
--- /dev/null
+++ b/tests/test_sqlite_reclaim.py
@@ -0,0 +1,346 @@
+"""Returning the disk space of deleted history: what may run, and that it never costs a row."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+import sqlite3
+import time
+from types import SimpleNamespace
+
+import pytest
+
+from cortex_backend.repositories import sqlite_reclaim
+from cortex_backend.repositories.sqlite_reclaim import BACKOFF_SECONDS, reclaim_free_space
+
+ROWS_KEPT = 100
+
+
+def _history(path: Path, *, incremental: bool, deleted: bool = True, keep: int = ROWS_KEPT) -> None:
+    """A database that held 1500 rows of about 2 KB and now holds ``keep`` of them."""
+    connection = sqlite3.connect(path, isolation_level=None)
+    if incremental:
+        connection.execute("PRAGMA auto_vacuum = INCREMENTAL")  # only possible before WAL is switched on
+    connection.execute("PRAGMA journal_mode = WAL")
+    connection.execute("CREATE TABLE t (id INTEGER PRIMARY KEY, body TEXT)")
+    connection.execute("BEGIN")
+    connection.executemany("INSERT INTO t (body) VALUES (?)", ((f"{index:05d}" + "x" * 2000,) for index in range(1500)))
+    connection.execute("COMMIT")
+    if deleted:
+        connection.execute("DELETE FROM t WHERE id > ?", (keep,))
+    connection.execute("PRAGMA wal_checkpoint(TRUNCATE)")
+    connection.close()
+
+
+class _Facts(SimpleNamespace):
+    free_pages: int
+    auto_vacuum: int
+    file_bytes: int
+    rows: list[tuple[int, str]]
+    intact: bool
+
+
+def _facts(path: Path) -> _Facts:
+    connection = sqlite3.connect(path)
+    try:
+        connection.execute("PRAGMA wal_checkpoint(TRUNCATE)").fetchall()
+        return _Facts(
+            free_pages=connection.execute("PRAGMA freelist_count").fetchone()[0],
+            auto_vacuum=connection.execute("PRAGMA auto_vacuum").fetchone()[0],
+            file_bytes=os.path.getsize(path),
+            rows=connection.execute("SELECT id, body FROM t ORDER BY id").fetchall(),
+            intact=connection.execute("PRAGMA integrity_check").fetchone()[0] == "ok",
+        )
+    finally:
+        connection.close()
+
+
+def test_an_incremental_database_gives_its_free_pages_back(tmp_path: Path) -> None:
+    path = tmp_path / "chats.sqlite"
+    _history(path, incremental=True)
+    before = _facts(path)
+    assert before.free_pages > 300 and before.auto_vacuum == 2
+
+    assert reclaim_free_space(path) == "trimmed"
+
+    after = _facts(path)
+    assert after.free_pages == 0
+    assert after.file_bytes < before.file_bytes / 5
+    assert after.rows == before.rows and len(after.rows) == ROWS_KEPT
+    assert after.intact
+
+
+def test_a_database_made_without_auto_vacuum_is_rewritten_once_and_converted(tmp_path: Path) -> None:
+    path = tmp_path / "chats.sqlite"
+    _history(path, incremental=False)
+    before = _facts(path)
+    assert before.free_pages > 300 and before.auto_vacuum == 0
+
+    assert reclaim_free_space(path) == "rewritten"
+
+    after = _facts(path)
+    assert after.free_pages == 0
+    assert after.file_bytes < before.file_bytes / 5
+    assert after.rows == before.rows and len(after.rows) == ROWS_KEPT
+    assert after.intact
+    assert after.auto_vacuum == 2  # so every later start can use the cheap path
+
+
+def test_a_database_that_is_mostly_full_is_left_untouched(tmp_path: Path) -> None:
+    path = tmp_path / "chats.sqlite"
+    _history(path, incremental=False, deleted=False)
+    before = path.read_bytes()
+
+    assert reclaim_free_space(path) == "nothing_to_do"
+
+    assert path.read_bytes() == before
+
+
+def test_a_missing_database_is_not_created(tmp_path: Path) -> None:
+    assert reclaim_free_space(tmp_path / "missing.sqlite") == "nothing_to_do"
+    assert list(tmp_path.iterdir()) == []
+
+
+def test_running_out_of_time_rewrites_nothing_and_a_later_run_finishes(tmp_path: Path) -> None:
+    """A VACUUM that is interrupted rolls back; an incremental one keeps what it freed."""
+    for incremental in (False, True):
+        path = tmp_path / f"chats-{incremental}.sqlite"
+        # Enough rows kept that a rewrite has real work for the clock to interrupt.
+        _history(path, incremental=incremental, keep=700)
+        before = _facts(path)
+
+        assert reclaim_free_space(path, time_limit=0.0) == "gave_up"
+
+        untouched = _facts(path)
+        assert (untouched.rows, untouched.free_pages, untouched.auto_vacuum) == (
+            before.rows,
+            before.free_pages,
+            before.auto_vacuum,
+        )
+        assert untouched.intact
+        # An interrupted rewrite is not retried at once (see the back-off tests
+        # below); a later launch, past the back-off, finishes it.
+        assert reclaim_free_space(path, wall_clock=lambda: time.time() + BACKOFF_SECONDS + 1) in (
+            "trimmed",
+            "rewritten",
+        )
+        assert _facts(path).rows == before.rows
+
+
+def test_a_step_that_frees_nothing_ends_the_pass_instead_of_spinning(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    path = tmp_path / "chats.sqlite"
+    _history(path, incremental=True)
+    real_pragma = sqlite_reclaim._pragma
+    steps: list[str] = []
+
+    def stuck(connection: sqlite3.Connection, name: str) -> int:
+        if name == "freelist_count":
+            steps.append(name)
+            return 500  # the free list never shrinks
+        return real_pragma(connection, name)
+
+    monkeypatch.setattr(sqlite_reclaim, "_pragma", stuck)
+
+    assert reclaim_free_space(path, time_limit=5.0) == "gave_up"
+    assert len(steps) <= 3  # the check, one step, the check that saw no progress
+
+
+def test_a_database_another_connection_is_writing_is_left_alone(tmp_path: Path) -> None:
+    for incremental in (False, True):
+        path = tmp_path / f"chats-{incremental}.sqlite"
+        _history(path, incremental=incremental)
+        before = _facts(path)
+        writer = sqlite3.connect(path, isolation_level=None)
+        try:
+            writer.execute("BEGIN IMMEDIATE")
+            outcome = reclaim_free_space(path, busy_timeout=0.05)
+        finally:
+            writer.execute("ROLLBACK")
+            writer.close()
+
+        assert outcome == "gave_up"
+        after = _facts(path)
+        assert (after.rows, after.free_pages, after.auto_vacuum) == (
+            before.rows,
+            before.free_pages,
+            before.auto_vacuum,
+        )
+
+
+def test_a_rewrite_is_not_attempted_without_room_for_a_second_copy(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    path = tmp_path / "chats.sqlite"
+    _history(path, incremental=False)
+    before = _facts(path)
+    monkeypatch.setattr(sqlite_reclaim.shutil, "disk_usage", lambda _path: SimpleNamespace(free=1024))
+
+    assert reclaim_free_space(path) == "not_enough_space"
+
+    after = _facts(path)
+    assert (after.rows, after.free_pages, after.auto_vacuum) == (before.rows, before.free_pages, 0)
+
+
+def test_free_space_that_cannot_be_read_is_not_room(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    path = tmp_path / "chats.sqlite"
+    _history(path, incremental=False)
+
+    def unreadable(_path):
+        raise OSError("no such volume")
+
+    monkeypatch.setattr(sqlite_reclaim.shutil, "disk_usage", unreadable)
+
+    assert reclaim_free_space(path) == "not_enough_space"
+    assert _facts(path).auto_vacuum == 0
+
+
+def test_a_database_too_big_to_rewrite_within_the_time_limit_is_left_alone(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    path = tmp_path / "chats.sqlite"
+    _history(path, incremental=False)
+    monkeypatch.setattr(sqlite_reclaim, "MAX_VACUUM_LIVE_BYTES", 1024)
+
+    assert reclaim_free_space(path) == "too_large"
+    assert _facts(path).auto_vacuum == 0
+
+
+def test_a_file_that_is_not_a_database_is_reported_not_raised(tmp_path: Path) -> None:
+    path = tmp_path / "chats.sqlite"
+    path.write_bytes(b"this is not a database" * 100)
+    before = path.read_bytes()
+
+    assert reclaim_free_space(path) == "gave_up"
+    assert path.read_bytes() == before
+
+
+# -- a rewrite that fails is not retried at every launch -------------------------------
+
+
+def _marker(path: Path) -> Path:
+    return Path(f"{path}.reclaim-backoff")
+
+
+class _Rewrites:
+    """Counts the full rewrites a test lets through, without changing what they do."""
+
+    def __init__(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        self.count = 0
+        real = sqlite_reclaim._rewrite
+
+        def counted(connection: sqlite3.Connection):
+            self.count += 1
+            return real(connection)
+
+        monkeypatch.setattr(sqlite_reclaim, "_rewrite", counted)
+
+
+def test_a_rewrite_that_ran_out_of_time_is_not_tried_again_until_the_backoff_has_passed(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Without this, a file whose rewrite needs more than the limit adds the limit to every launch."""
+    path = tmp_path / "chats.sqlite"
+    _history(path, incremental=False, keep=700)
+    before = _facts(path)
+    rewrites = _Rewrites(monkeypatch)
+    failed_at = 1_000_000.0
+
+    assert reclaim_free_space(path, time_limit=0.0, wall_clock=lambda: failed_at) == "gave_up"
+    assert rewrites.count == 1
+    assert _marker(path).read_text(encoding="ascii").strip() == str(int(failed_at))
+
+    # Every launch for the next week costs nothing and touches nothing.
+    for launch in (1, 3600, BACKOFF_SECONDS - 1):
+        now = failed_at + launch
+        assert reclaim_free_space(path, wall_clock=lambda now=now: now) == "backed_off"
+    assert rewrites.count == 1
+    assert (_facts(path).rows, _facts(path).free_pages, _facts(path).auto_vacuum) == (
+        before.rows,
+        before.free_pages,
+        0,
+    )
+
+    # After it, the rewrite is tried again, finishes, and the note of the failure goes.
+    assert reclaim_free_space(path, wall_clock=lambda: failed_at + BACKOFF_SECONDS) == "rewritten"
+    assert rewrites.count == 2
+    after = _facts(path)
+    assert (after.free_pages, after.auto_vacuum, after.rows, after.intact) == (0, 2, before.rows, True)
+    assert not _marker(path).exists()
+
+
+def test_a_rewrite_that_fails_for_any_other_reason_is_backed_off_too(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    path = tmp_path / "chats.sqlite"
+    _history(path, incremental=False)
+
+    def full_disk(_connection: sqlite3.Connection):
+        raise sqlite3.OperationalError("database or disk is full")
+
+    monkeypatch.setattr(sqlite_reclaim, "_rewrite", full_disk)
+    assert reclaim_free_space(path, wall_clock=lambda: 5_000.0) == "gave_up"
+    assert _marker(path).exists()
+    monkeypatch.undo()
+
+    assert reclaim_free_space(path, wall_clock=lambda: 5_001.0) == "backed_off"
+    assert _facts(path).auto_vacuum == 0
+
+
+def test_a_rewrite_held_off_by_another_writer_is_not_backed_off(tmp_path: Path) -> None:
+    """A lock says nothing about the rewrite: the next launch may well succeed."""
+    path = tmp_path / "chats.sqlite"
+    _history(path, incremental=False)
+    writer = sqlite3.connect(path, isolation_level=None)
+    try:
+        writer.execute("BEGIN IMMEDIATE")
+        assert reclaim_free_space(path, busy_timeout=0.05) == "gave_up"
+    finally:
+        writer.execute("ROLLBACK")
+        writer.close()
+
+    assert not _marker(path).exists()
+    assert reclaim_free_space(path) == "rewritten"
+
+
+@pytest.mark.parametrize(
+    "content",
+    ["not a time", "", "\x00\x01", "1e999999", "-1", "99999999999"],
+    ids=["text", "empty", "binary", "overflow", "ancient", "in-the-future"],
+)
+def test_a_marker_that_says_nothing_usable_does_not_hold_the_rewrite_off(tmp_path: Path, content: str) -> None:
+    path = tmp_path / "chats.sqlite"
+    _history(path, incremental=False)
+    _marker(path).write_bytes(content.encode("ascii"))
+
+    assert reclaim_free_space(path, wall_clock=lambda: 1_000_000.0) == "rewritten"
+
+    assert not _marker(path).exists()
+
+
+def test_the_backoff_does_not_slow_the_incremental_path(tmp_path: Path) -> None:
+    """Only the whole-file rewrite is repeated cost; incremental steps keep what they freed."""
+    path = tmp_path / "chats.sqlite"
+    _history(path, incremental=True)
+    _marker(path).write_text(f"{int(time.time())}\n", encoding="ascii")
+
+    assert reclaim_free_space(path) == "trimmed"
+
+
+def test_a_marker_that_cannot_be_written_or_read_is_not_an_error(tmp_path: Path) -> None:
+    path = tmp_path / "chats.sqlite"
+    _history(path, incremental=False, keep=700)
+    _marker(path).mkdir()  # nothing can be written to, or read from, this name
+
+    assert reclaim_free_space(path, time_limit=0.0) == "gave_up"
+    assert reclaim_free_space(path, wall_clock=lambda: time.time() + BACKOFF_SECONDS + 1) == "rewritten"
+
+
+def test_a_database_with_nothing_to_reclaim_leaves_no_marker(tmp_path: Path) -> None:
+    path = tmp_path / "chats.sqlite"
+    _history(path, incremental=False, deleted=False)
+
+    assert reclaim_free_space(path, time_limit=0.0) == "nothing_to_do"
+
+    assert not _marker(path).exists()
diff --git a/tests/test_sqlite_settings_recovery.py b/tests/test_sqlite_settings_recovery.py
index a1ab16a..bc5eeb8 100644
--- a/tests/test_sqlite_settings_recovery.py
+++ b/tests/test_sqlite_settings_recovery.py
@@ -335,6 +335,104 @@ def replace(source, destination, *args, **kwargs):
     monkeypatch.setattr(os, "replace", replace)
 
 
+def test_a_backup_held_briefly_by_another_program_is_still_published(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+):
+    """A scanner holding the backup for a few milliseconds is not a failed backup."""
+    repository, _ = _repository_with_valid_backup(tmp_path)
+    backup_before = repository.backup_path.read_bytes()
+    real_replace = os.replace
+    backup = os.path.normcase(os.path.abspath(repository.backup_path))
+    refused: list[str] = []
+    monkeypatch.setattr("time.sleep", lambda _seconds: None)
+
+    def replace(source, destination, *args, **kwargs):
+        if os.path.normcase(os.path.abspath(destination)) == backup and len(refused) < 2:
+            refused.append(str(source))
+            raise PermissionError(errno.EACCES, "The process cannot access the file")
+        return real_replace(source, destination, *args, **kwargs)
+
+    monkeypatch.setattr(os, "replace", replace)
+
+    reopened = SQLiteSettingsRepository(repository.db_path)
+    monkeypatch.undo()
+
+    assert len(refused) == 2
+    assert reopened.backup_status == ("ok", None)
+    assert repository.backup_path.read_bytes() != backup_before
+    assert SQLiteSettingsRepository._database_is_valid(repository.backup_path)
+
+
+def _files_beside(directory: Path) -> dict[str, bytes]:
+    return {
+        entry.name: entry.read_bytes()
+        for entry in directory.iterdir()
+        if entry.is_file() and not entry.name.endswith(("-wal", "-shm"))
+    }
+
+
+def _run(path: Path, statement: str) -> None:
+    connection = sqlite3.connect(path)
+    try:
+        connection.execute(statement)
+        connection.commit()
+    finally:
+        connection.close()
+
+
+def test_a_settings_database_from_a_newer_build_is_refused_without_being_modified(tmp_path: Path):
+    """The file gate: refused on its stored version before any backup is
+    rotated, so the older-schema generations survive the downgrade."""
+    repository, _ = _repository_with_valid_backup(tmp_path)
+    _run(repository.db_path, "PRAGMA user_version = 99")
+    before = _files_beside(tmp_path)
+    assert repository.backup_path.name in before
+
+    with pytest.raises(SettingsRepositoryError, match="newer Cortex release"):
+        SQLiteSettingsRepository(repository.db_path)
+
+    assert _files_beside(tmp_path) == before
+
+
+def test_a_newer_settings_schema_is_reported_not_crashed(tmp_path: Path):
+    """The row gate: settings a newer build stored in a shape this one does not
+    know are reported as an error, never parsed as if they were current."""
+    repository, _ = _repository_with_valid_backup(tmp_path)
+    _run(repository.db_path, "UPDATE cortex_settings SET schema_version = 99 WHERE id = 1")
+    reopened = SQLiteSettingsRepository(repository.db_path)  # the file itself is this build's shape
+
+    with pytest.raises(SettingsRepositoryError, match="newer than this release"):
+        reopened.load()
+
+    probe = sqlite3.connect(repository.db_path)
+    try:
+        assert probe.execute("SELECT schema_version FROM cortex_settings WHERE id = 1").fetchone()[0] == 99
+    finally:
+        probe.close()
+
+
+def test_a_newer_settings_schema_is_a_reported_error_at_the_api_not_a_crash(tmp_path: Path):
+    from fastapi.testclient import TestClient
+
+    from cortex_backend.api import create_app
+    from cortex_backend.testing import build_demo_dependencies
+    from support import session_headers
+
+    repository, _ = _repository_with_valid_backup(tmp_path)
+    _run(repository.db_path, "UPDATE cortex_settings SET schema_version = 99 WHERE id = 1")
+    dependencies = build_demo_dependencies()
+    dependencies.settings = SQLiteSettingsRepository(repository.db_path)
+    app = create_app(dependencies, allowed_hosts=("testserver",))
+    with TestClient(app, raise_server_exceptions=False) as client:
+        response = client.get("/api/v1/settings", headers=session_headers(client, app))
+
+    assert response.status_code == 500
+    # The message is the same as ever; the request id is appended so a report can be matched to the log.
+    assert response.json()["detail"] == (
+        f"Could not load settings. (Request ID: {response.headers['X-Request-ID']})"
+    )
+
+
 def _snapshot_that_fails_verification(monkeypatch: pytest.MonkeyPatch, repository) -> None:
     def torn(_source, destination, **_kwargs):
         Path(destination).write_bytes(b"torn snapshot")