code-context-control 2.153.0__tar.gz → 2.154.0__tar.gz

{code_context_control-2.153.0 → code_context_control-2.154.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.153.0
+Version: 2.154.0
 Summary: Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.153.0 → code_context_control-2.154.0}/cli/c3.py

@@ -91,7 +91,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.153.0"
+__version__ = "2.154.0"
 
 # The PreToolUse matcher for native subagent calls (installer and hub migration).
 AGENT_MATCHER = "Agent|Task"
@@ -1288,6 +1288,14 @@ def cmd_init(args):
     except Exception:
         pass
 
+    swept = _prune_project_quarantines(project_path)
+    if swept["pruned"]:
+        print(f"  Fixed : freed {_format_bytes(swept['bytes'])} from "
+              f"{len(swept['pruned'])} old embedding quarantine dir(s)")
+    for name in swept["failed"]:
+        print(f"  [warn] {name} could not be fully removed (in use?); "
+              "run 'c3 prune-quarantine' later")
+
     # Delegate backends
     try:
         from services.ollama_client import OllamaClient as _OC
@@ -1463,6 +1471,59 @@ def cmd_index(args):
     return common_cmd_index(args, _command_deps())
 
 
+def _format_bytes(n: float) -> str:
+    for unit in ("B", "KB", "MB", "GB"):
+        if n < 1024:
+            return f"{n:.0f} {unit}" if unit == "B" else f"{n:.1f} {unit}"
+        n /= 1024
+    return f"{n:.1f} TB"
+
+
+def _prune_project_quarantines(project_path: str, keep=None, dry_run: bool = False) -> dict:
+    """Prune one project's ``.c3/embeddings/quarantine_corrupt_*`` dirs; returns the sweep result."""
+    from cli.progress import ProgressLine
+    from services.embedding_index import prune_quarantines
+
+    prog = ProgressLine()
+    try:
+        return prune_quarantines(
+            Path(project_path) / CONFIG_DIR / "embeddings", keep=keep, dry_run=dry_run,
+            on_progress=lambda done, total: prog.update(
+                f"  removing quarantine copies {done}/{total}"))
+    finally:
+        prog.done()
+
+
+def cmd_prune_quarantine(args):
+    """Delete old corrupt-embedding-store quarantine copies, keeping the newest few."""
+    if args.all:
+        from services.project_manager import ProjectManager
+        projects = [p["path"] for p in ProjectManager().list_registered()]
+    else:
+        projects = [str(Path(args.project_path or ".").resolve())]
+
+    verb = "would remove" if args.dry_run else "removed"
+    pruned = failed = freed = 0
+    for project in projects:
+        res = _prune_project_quarantines(project, keep=args.keep, dry_run=args.dry_run)
+        if not (res["pruned"] or res["failed"]):
+            continue
+        pruned += len(res["pruned"])
+        failed += len(res["failed"])
+        freed += res["bytes"]
+        print(f"{project}: {verb} {len(res['pruned'])} quarantine dir(s), "
+              f"{_format_bytes(res['bytes'])}; kept {len(res['kept'])}")
+        for name in res["failed"]:
+            print(f"  [warn] {name} could not be fully removed (in use?); run again later")
+
+    if not (pruned or failed):
+        print(f"Nothing to prune in {len(projects)} project(s).")
+        return
+    print(f"\n{verb.capitalize()} {pruned} quarantine dir(s), {_format_bytes(freed)}.")
+    if failed:
+        sys.exit(1)
+
+
 def cmd_compress(args):
     """Compress a file and show results."""
     return common_cmd_compress(args, _command_deps())
@@ -9603,6 +9664,7 @@ def main():
         "enforce": cmd_enforce,
         "override": cmd_override,
         "locks": cmd_locks,
+        "prune-quarantine": cmd_prune_quarantine,
         "ci": cmd_ci,
         "oracle": cmd_oracle,
         "upgrade": cmd_upgrade,

{code_context_control-2.153.0 → code_context_control-2.154.0}/cli/commands/parser.py

@@ -37,6 +37,17 @@ def build_parser(version: str, parse_cli_ide_arg):
     p_upgrade.add_argument("--check", action="store_true",
                            help="Only report whether a newer version exists; don't install")
 
+    p_prune = subparsers.add_parser(
+        "prune-quarantine",
+        help="Delete old corrupt-embedding-store quarantine copies (frees disk)")
+    p_prune.add_argument("project_path", nargs="?", default=".")
+    p_prune.add_argument("--all", action="store_true",
+                         help="Every project registered with the hub, not just this one")
+    p_prune.add_argument("--keep", type=int, default=None,
+                         help="Newest quarantine dirs to keep per project (default 2)")
+    p_prune.add_argument("--dry-run", action="store_true",
+                         help="Report what would be removed without deleting")
+
     p_index = subparsers.add_parser("index", help="Rebuild code index")
     p_index.add_argument("--max-files", type=int, default=None,
                          help="Cap files indexed this run. Unset reads "

{code_context_control-2.153.0 → code_context_control-2.154.0}/cli/guide/index.html

@@ -663,6 +663,10 @@
             <code>c3 map {status|ensure|refresh}</code>
             <span>Inspect or rebuild the live repo map at .c3/MAP.md</span>
           </div>
+          <div class="quick-item">
+            <code>c3 prune-quarantine [--all] [--dry-run]</code>
+            <span>Free disk held by old corrupt-embedding-store copies in .c3/embeddings (<code>c3 init</code> runs it too)</span>
+          </div>
           <div class="quick-item">
             <code>c3 hub</code>
             <span>Launch the Project Hub web dashboard (localhost:3330)</span>

{code_context_control-2.153.0 → code_context_control-2.154.0}/code_context_control.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.153.0
+Version: 2.154.0
 Summary: Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.153.0 → code_context_control-2.154.0}/code_context_control.egg-info/SOURCES.txt

@@ -407,6 +407,7 @@ tests/test_edit_stale.py
 tests/test_edit_verify.py
 tests/test_embedding_index_corrupt_store.py
 tests/test_embedding_index_deadlock.py
+tests/test_embedding_store_safety.py
 tests/test_enforcement_flip.py
 tests/test_enforcement_policy.py
 tests/test_enforcement_routes.py
@@ -511,6 +512,7 @@ tests/test_pm_api.py
 tests/test_project_manager.py
 tests/test_project_manager_merge.py
 tests/test_project_tool.py
+tests/test_quarantine_sweep.py
 tests/test_read_coercion.py
 tests/test_read_edit_parity.py
 tests/test_read_outside_root.py

{code_context_control-2.153.0 → code_context_control-2.154.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.153.0"
+version = "2.154.0"
 description = "Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub."
 readme = "README.md"
 requires-python = ">=3.10"

{code_context_control-2.153.0 → code_context_control-2.154.0}/services/embedding_index.py

@@ -10,8 +10,12 @@ import gc
 import hashlib
 import json
 import logging
+import os
 import shutil
+import subprocess
+import sys
 import threading
+import time
 from datetime import datetime
 from pathlib import Path
 
@@ -28,6 +32,336 @@ DEFAULT_MIN_SCORE_OTHER = 0.55
 # and degrade rather than block. See _acquire_build_lock().
 _BUILD_LOCK_WAIT_SECONDS = 30.0
 
+# ── Store safety (issue #180) ─────────────────────────────
+# A damaged HNSW segment does not just fail to load. chromadb's loader
+# allocates as it reads, so one bad segment made a single MCP server commit
+# 140-200 GB before the load gave up, and every new session repeated it
+# (measured 2026-10-02: count() on a copy of the store, 165 GB private, 0.25 GB
+# working set, then "Error loading hnsw index"). An in-process probe cannot
+# undo that commit, so an existing store is first opened in a child process
+# under a memory cap, and only opened here if the child could read it.
+_PROBE_TIMEOUT_SECONDS = 180.0
+_PROBE_POLL_SECONDS = 0.1
+_PROBE_MIN_CAP_BYTES = 4 * 1024 ** 3  # floor; scaled up for big stores below
+_PROBE_CAP_STORE_MULTIPLE = 4
+_PROBE_OK_FILE = "store_probe_ok.json"
+_PROBE_OK_MARKER = "C3_STORE_PROBE_OK"
+# Each quarantine keeps a full copy of the store for post-mortem. Unbounded,
+# that reached 284 copies and 384 GB in one project; keep only the newest few.
+_QUARANTINE_KEEP = 2
+_OWNER_LOCK_FILE = "chromadb.owner.lock"
+
+_PROBE_CHILD_CODE = """
+import sys
+import chromadb
+from chromadb.config import Settings
+client = chromadb.PersistentClient(
+    path=sys.argv[1], settings=Settings(anonymized_telemetry=False))
+listed = client.list_collections()
+names = {c if isinstance(c, str) else getattr(c, "name", "") for c in listed}
+if sys.argv[2] in names:
+    client.get_collection(sys.argv[2]).count()
+print("C3_STORE_PROBE_OK", flush=True)
+"""
+
+
+class StoreBusyError(RuntimeError):
+    """Another C3 process owns this project's embedding store."""
+
+
+def _tree_bytes(path: Path) -> int:
+    total = 0
+    for root, _dirs, files in os.walk(path):
+        for name in files:
+            try:
+                total += os.lstat(os.path.join(root, name)).st_size
+            except OSError:
+                pass
+    return total
+
+
+def prune_quarantines(index_dir: Path, keep: int | None = None,
+                      dry_run: bool = False, on_progress=None) -> dict:
+    """Delete all but the newest *keep* ``quarantine_corrupt_*`` dirs in *index_dir*.
+
+    ``keep=None`` keeps the default of two.
+
+    Newest is by name, which embeds the quarantine timestamp. Symlinks and
+    non-directories matching the pattern are never touched. A dir that cannot
+    be fully removed is reported in ``failed`` and retried by the next call.
+    ``on_progress(done, total)`` runs after each dir. With ``dry_run`` nothing
+    is deleted and ``pruned`` / ``bytes`` describe what a real run would remove.
+
+    Returns ``{"kept": [...], "pruned": [...], "failed": [...], "bytes": int}``
+    with directory names; ``bytes`` is the size freed (or that would be freed).
+    """
+    try:
+        found = sorted(p for p in Path(index_dir).glob("quarantine_corrupt_*")
+                       if p.is_dir() and not p.is_symlink())
+    except OSError:
+        found = []
+    keep = _QUARANTINE_KEEP if keep is None else max(int(keep), 0)
+    doomed = found[:len(found) - keep] if keep < len(found) else []
+    result = {"kept": [p.name for p in found[len(doomed):]],
+              "pruned": [], "failed": [], "bytes": 0}
+    for done, old in enumerate(doomed, 1):
+        size = _tree_bytes(old)
+        if dry_run:
+            result["pruned"].append(old.name)
+            result["bytes"] += size
+        else:
+            shutil.rmtree(old, ignore_errors=True)
+            left = _tree_bytes(old) if old.exists() else 0
+            result["bytes"] += size - left
+            result["failed" if old.exists() else "pruned"].append(old.name)
+        if on_progress:
+            on_progress(done, len(doomed))
+    return result
+
+
+def _private_bytes(proc) -> int:
+    """Committed (Windows) or resident (POSIX) bytes of a psutil.Process."""
+    info = proc.memory_info()
+    return int(getattr(info, "private", 0) or info.rss)
+
+
+def _windows_job_memory_cap(pid: int, cap_bytes: int):
+    """Put *pid* in a Job Object whose per-process commit limit is *cap_bytes*.
+
+    Polling alone is not enough here: the corrupt-segment loader committed
+    ~100 GB between two 100 ms polls (measured 2026-10-02). Under a job limit
+    the allocation fails inside the child instead. Returns the job handle
+    (keep it open while the child runs) or None when unsupported.
+    """
+    if os.name != "nt":
+        return None
+    try:
+        import ctypes
+        from ctypes import wintypes
+
+        k32 = ctypes.WinDLL("kernel32", use_last_error=True)
+
+        class IO_COUNTERS(ctypes.Structure):
+            _fields_ = [(n, ctypes.c_ulonglong) for n in (
+                "ReadOperationCount", "WriteOperationCount", "OtherOperationCount",
+                "ReadTransferCount", "WriteTransferCount", "OtherTransferCount")]
+
+        class BASIC(ctypes.Structure):
+            _fields_ = [
+                ("PerProcessUserTimeLimit", ctypes.c_longlong),
+                ("PerJobUserTimeLimit", ctypes.c_longlong),
+                ("LimitFlags", wintypes.DWORD),
+                ("MinimumWorkingSetSize", ctypes.c_size_t),
+                ("MaximumWorkingSetSize", ctypes.c_size_t),
+                ("ActiveProcessLimit", wintypes.DWORD),
+                ("Affinity", ctypes.c_size_t),
+                ("PriorityClass", wintypes.DWORD),
+                ("SchedulingClass", wintypes.DWORD),
+            ]
+
+        class EXTENDED(ctypes.Structure):
+            _fields_ = [
+                ("BasicLimitInformation", BASIC),
+                ("IoInfo", IO_COUNTERS),
+                ("ProcessMemoryLimit", ctypes.c_size_t),
+                ("JobMemoryLimit", ctypes.c_size_t),
+                ("PeakProcessMemoryUsed", ctypes.c_size_t),
+                ("PeakJobMemoryUsed", ctypes.c_size_t),
+            ]
+
+        JOB_OBJECT_LIMIT_PROCESS_MEMORY = 0x100
+        JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x2000
+        JobObjectExtendedLimitInformation = 9
+        PROCESS_SET_QUOTA, PROCESS_TERMINATE = 0x0100, 0x0001
+
+        k32.CreateJobObjectW.restype = wintypes.HANDLE
+        k32.OpenProcess.restype = wintypes.HANDLE
+        job = k32.CreateJobObjectW(None, None)
+        if not job:
+            return None
+        info = EXTENDED()
+        info.BasicLimitInformation.LimitFlags = (
+            JOB_OBJECT_LIMIT_PROCESS_MEMORY | JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE)
+        info.ProcessMemoryLimit = cap_bytes
+        if not k32.SetInformationJobObject(
+                wintypes.HANDLE(job), JobObjectExtendedLimitInformation,
+                ctypes.byref(info), ctypes.sizeof(info)):
+            k32.CloseHandle(wintypes.HANDLE(job))
+            return None
+        proc = k32.OpenProcess(PROCESS_SET_QUOTA | PROCESS_TERMINATE, False, pid)
+        if not proc:
+            k32.CloseHandle(wintypes.HANDLE(job))
+            return None
+        try:
+            assigned = k32.AssignProcessToJobObject(wintypes.HANDLE(job), wintypes.HANDLE(proc))
+        finally:
+            k32.CloseHandle(wintypes.HANDLE(proc))
+        if not assigned:
+            k32.CloseHandle(wintypes.HANDLE(job))
+            return None
+        return job
+    except Exception:
+        return None
+
+
+def _close_job(job) -> None:
+    if job is None:
+        return
+    try:
+        import ctypes
+        from ctypes import wintypes
+        ctypes.WinDLL("kernel32").CloseHandle(wintypes.HANDLE(job))
+    except Exception:
+        pass
+
+
+def run_isolated_probe(
+    args: list,
+    *,
+    cap_bytes: int,
+    timeout: float = _PROBE_TIMEOUT_SECONDS,
+    marker: str = _PROBE_OK_MARKER,
+) -> tuple:
+    """Run ``python <args>`` in a child that is killed if it outgrows *cap_bytes*.
+
+    Returns ``(ok, reason)``. ``ok`` needs a zero exit AND *marker* on stdout,
+    so a child that dies quietly is a failure, not a pass. The cap is enforced
+    by polling the child's memory (psutil when installed; RLIMIT_AS on POSIX
+    otherwise), which bounds the damage to the cap plus one poll interval.
+    """
+    try:
+        import psutil  # optional: C3 does not declare it
+    except Exception:
+        psutil = None
+
+    preexec = None
+    if psutil is None and os.name != "nt":
+        def preexec():  # pragma: no cover - POSIX without psutil
+            try:  # best effort: macOS refuses to lower RLIMIT_AS
+                import resource
+                resource.setrlimit(resource.RLIMIT_AS, (cap_bytes, cap_bytes))
+            except (ValueError, OSError):
+                pass
+
+    creationflags = getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0
+    import tempfile
+
+    # Files, not pipes: a child that logs more than a pipe buffer while nobody
+    # reads it would block and be misreported as a timeout.
+    with tempfile.TemporaryFile() as out_f, tempfile.TemporaryFile() as err_f:
+        child = subprocess.Popen(
+            [sys.executable, *args],
+            stdin=subprocess.DEVNULL,
+            stdout=out_f,
+            stderr=err_f,
+            preexec_fn=preexec,
+            creationflags=creationflags,
+        )
+        job = _windows_job_memory_cap(child.pid, cap_bytes)
+        try:
+            reason = _watch_probe(child, psutil, cap_bytes, timeout)
+        finally:
+            _close_job(job)
+        if reason:
+            return False, reason
+        out_f.seek(0)
+        err_f.seek(0)
+        text = out_f.read().decode("utf-8", "replace")
+        err = err_f.read().decode("utf-8", "replace")
+    if child.returncode == 0 and marker in text:
+        return True, ""
+    tail = err.strip().splitlines()
+    detail = tail[-1] if tail else f"exit code {child.returncode}"
+    capped = " (under a hard memory cap)" if job is not None else ""
+    return False, f"probe failed{capped}: {detail[:300]}"
+
+
+def _watch_probe(child, psutil, cap_bytes, timeout) -> str:
+    """Wait for *child*; kill it on the cap or the deadline. Returns a reason or ""."""
+    watched = None
+    if psutil is not None:
+        try:
+            watched = psutil.Process(child.pid)
+        except Exception:
+            watched = None
+    deadline = time.monotonic() + timeout
+    peak = 0
+    reason = ""
+    while child.poll() is None:
+        if watched is not None:
+            try:
+                peak = max(peak, _private_bytes(watched))
+            except Exception:
+                pass
+            if peak > cap_bytes:
+                reason = (f"probe exceeded its memory cap "
+                          f"({peak / 1024 ** 3:.1f} GB > {cap_bytes / 1024 ** 3:.1f} GB)")
+                break
+        if time.monotonic() >= deadline:
+            reason = f"probe timed out after {timeout:.0f}s"
+            break
+        time.sleep(_PROBE_POLL_SECONDS)
+    if reason:
+        child.kill()
+    try:
+        child.wait(timeout=30)
+    except Exception:
+        pass
+    return reason
+
+
+class _OwnerLock:
+    """Non-blocking, process-lifetime exclusive lock on one file.
+
+    chromadb's PersistentClient is not safe for several processes at once, yet
+    every C3 MCP server for a project opened the same store. The OS drops the
+    lock when the holder dies, so a crashed server never strands it.
+    """
+
+    def __init__(self, path: Path):
+        self.path = path
+        self._fh = None
+
+    @property
+    def held(self) -> bool:
+        return self._fh is not None
+
+    def try_acquire(self) -> bool:
+        if self._fh is not None:
+            return True
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        fh = open(self.path, "ab")  # never read/written; fd exists to hold the lock
+        try:
+            if os.name == "nt":
+                import msvcrt
+                fh.seek(0)
+                msvcrt.locking(fh.fileno(), msvcrt.LK_NBLCK, 1)
+            else:
+                import fcntl
+                fcntl.flock(fh.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError:
+            fh.close()
+            return False
+        self._fh = fh
+        return True
+
+    def release(self) -> None:
+        fh, self._fh = self._fh, None
+        if fh is None:
+            return
+        try:
+            if os.name == "nt":
+                import msvcrt
+                fh.seek(0)
+                msvcrt.locking(fh.fileno(), msvcrt.LK_UNLCK, 1)
+            else:
+                import fcntl
+                fcntl.flock(fh.fileno(), fcntl.LOCK_UN)
+        except OSError:
+            pass
+        finally:
+            fh.close()
+
 
 class EmbeddingIndex:
     """Semantic code search via embeddings over CodeIndex chunks."""
@@ -62,6 +396,8 @@ class EmbeddingIndex:
         self._chroma_client = None
         self._collection = None
         self._available = False
+        self._unavailable_why = ""  # set when chromadb is installed but unusable
+        self._owner_lock = _OwnerLock(self._index_dir / _OWNER_LOCK_FILE)
         self._ollama_ok = False
         self._ollama_up = False
         self._model_ok = False
@@ -112,9 +448,17 @@ class EmbeddingIndex:
             self._open_chroma()
             self._available = True
             self._drop_legacy_collection()
-        except Exception as e:
+        except StoreBusyError as e:
+            log.info("embedding index disabled in this process: %s", e)
+            self._unavailable_why = str(e)
+            self._available = False
+        except ImportError as e:
             log.debug("chromadb unavailable for embedding index: %s", e)
             self._available = False
+        except Exception as e:
+            log.warning("embedding store unusable: %s", e)
+            self._unavailable_why = f"embedding store unusable: {e}"
+            self._available = False
 
         try:
             self._ollama_up = self.ollama.is_available(timeout=2)
@@ -144,7 +488,19 @@ class EmbeddingIndex:
         from chromadb.config import Settings
 
         persist_dir = self._index_dir / "chromadb"
+        if not self._owner_lock.try_acquire():
+            raise StoreBusyError(
+                "embedding store is in use by another C3 server for this "
+                "project; dense search is off in this one")
         persist_dir.mkdir(parents=True, exist_ok=True)
+        if not _retried and self._store_has_segments(persist_dir):
+            ok, why = self._probe_store_isolated(persist_dir)
+            if not ok:
+                log.warning(
+                    "embedding store failed its isolated probe (%s); "
+                    "quarantining and rebuilding", why)
+                self._quarantine_store(persist_dir)
+                persist_dir.mkdir(parents=True, exist_ok=True)
         self._chroma_client = chromadb.PersistentClient(
             path=str(persist_dir),
             settings=Settings(anonymized_telemetry=False),
@@ -179,17 +535,90 @@ class EmbeddingIndex:
             pass
         gc.collect()
 
+    @staticmethod
+    def _store_has_segments(persist_dir: Path) -> bool:
+        """True when the store holds at least one on-disk HNSW segment."""
+        try:
+            return any(persist_dir.glob("*/header.bin"))
+        except OSError:
+            return False
+
+    @staticmethod
+    def _store_signature(persist_dir: Path) -> dict:
+        sig = {}
+        for f in sorted(persist_dir.rglob("*")):
+            try:
+                if f.is_file():
+                    st = f.stat()
+                    sig[f.relative_to(persist_dir).as_posix()] = [st.st_size, st.st_mtime_ns]
+            except OSError:
+                continue
+        return sig
+
+    def _probe_store_isolated(self, persist_dir: Path) -> tuple:
+        """Open the store in a capped child first; skip if unchanged since a pass.
+
+        Returns ``(ok, reason)``. A pass is remembered against the files' sizes
+        and mtimes, so an untouched store is not re-probed on every start.
+        """
+        sig = self._store_signature(persist_dir)
+        ok_file = self._index_dir / _PROBE_OK_FILE
+        try:
+            if json.loads(ok_file.read_text(encoding="utf-8")) == sig:
+                return True, ""
+        except Exception:
+            pass
+        store_bytes = sum(v[0] for v in sig.values())
+        cap = max(_PROBE_MIN_CAP_BYTES, _PROBE_CAP_STORE_MULTIPLE * store_bytes)
+        started = time.monotonic()
+        try:
+            ok, why = run_isolated_probe(
+                ["-c", _PROBE_CHILD_CODE, str(persist_dir), COLLECTION_NAME],
+                cap_bytes=cap,
+            )
+        except Exception as e:  # could not spawn: the in-process probe still runs
+            log.warning("isolated store probe could not run (%s); skipping", e)
+            return True, ""
+        log.info("isolated store probe: ok=%s in %.1fs %s",
+                 ok, time.monotonic() - started, why)
+        if ok:
+            try:
+                # The child may have compacted the store; record what it left.
+                ok_file.write_text(json.dumps(self._store_signature(persist_dir)),
+                                   encoding="utf-8")
+            except OSError:
+                pass
+        return ok, why
+
+    def _prune_quarantines(self) -> None:
+        prune_quarantines(self._index_dir)
+
     def _quarantine_store(self, persist_dir: Path) -> None:
         """Move a corrupt store and its hash file aside for post-mortem.
 
         The hashes go with it: they claim vectors that the fresh store does not
         have, so leaving them behind would suppress the very rebuild this is
         meant to trigger.
+
+        Rename only, never copy. When another process still had the files open,
+        ``shutil.move`` fell back to copying the whole store and then failed to
+        delete the original, so every session left one more full copy behind
+        and reopened the same corrupt store (issue #180). A failed rename now
+        raises and the index degrades for this process.
         """
         self._close_chroma()
-        dest = self._index_dir / f"quarantine_corrupt_{datetime.now():%Y%m%d_%H%M%S}"
+        dest = self._index_dir / f"quarantine_corrupt_{datetime.now():%Y%m%d_%H%M%S_%f}"
         dest.mkdir(parents=True, exist_ok=True)
-        shutil.move(str(persist_dir), str(dest / persist_dir.name))
+        try:
+            os.rename(str(persist_dir), str(dest / persist_dir.name))
+        except OSError as e:
+            try:
+                dest.rmdir()
+            except OSError:
+                pass
+            raise RuntimeError(
+                f"could not move the corrupt embedding store aside ({e})") from e
+        (self._index_dir / _PROBE_OK_FILE).unlink(missing_ok=True)
         try:
             if self._hash_file.exists():
                 shutil.move(str(self._hash_file), str(dest / self._hash_file.name))
@@ -197,6 +626,7 @@ class EmbeddingIndex:
             self._hash_file.unlink(missing_ok=True)
         self._file_hashes = {}
         log.warning("quarantined corrupt embedding store to %s", dest)
+        self._prune_quarantines()
 
     def _drop_legacy_collection(self) -> None:
         """Best-effort removal of the pre-2.108.0 collection and hash file.
@@ -290,7 +720,7 @@ class EmbeddingIndex:
     def unavailable_reason(self) -> str:
         """Human-readable reason ``ready`` is False (after probe/init)."""
         if not self._available:
-            return "chromadb not installed"
+            return self._unavailable_why or "chromadb not installed"
         if not self._ollama_up:
             return "Ollama not reachable"
         if not self._model_ok: