conexus 4.2.0__tar.gz → 4.2.2__tar.gz

{conexus-4.2.0 → conexus-4.2.2}/.claude-plugin/marketplace.json

@@ -9,13 +9,13 @@
       "name": "nx",
       "source": "./nx",
       "description": "Self-hosted three-tier knowledge management with 16 specialized agents, analytical query pipelines, semantic search, and RDR decision tracking for Claude Code.",
-      "version": "4.2.0"
+      "version": "4.2.2"
     },
     {
       "name": "sn",
       "source": "./sn",
       "description": "Injects Serena and Context7 MCP tool usage guidance into subagents via SubagentStart hook.",
-      "version": "4.2.0"
+      "version": "4.2.2"
     }
   ]
 }

{conexus-4.2.0 → conexus-4.2.2}/CHANGELOG.md

@@ -6,6 +6,28 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [4.2.2] - 2026-04-14
+
+(Note: v4.2.1 was tagged but never published due to a test failure. v4.2.2 supersedes it and includes all 4.2.1 changes plus the ChromaDB Cloud quota audit and observability improvements found during a live shakeout.)
+
+### Added
+
+- **`nx doctor` PyPI version check**: `_check_cli_version` queries https://pypi.org/pypi/conexus/json (3-second timeout) and reports current vs latest. When behind, suggests `uv tool upgrade conexus`. Network failures are silent (offline-tolerant).
+- **`nx upgrade --skip-t3` flag**: skip T3 upgrade steps (e.g., heavy cross-collection projection backfill) for fast T2-only migrations.
+- **`backfill_projection` per-collection progress**: prints `[i/N] collection: chunks, matches, attempted (elapsed)` to stderr during the T3 backfill, plus a final summary with total time and actual rows stored. Previously the backfill was silent for many minutes on large repos.
+- **`CatalogTaxonomy._paginated_get`** + **`_batched_upsert`** helpers: wrap ChromaDB calls with the 300-record per-call cap (`MAX_QUERY_RESULTS` / `MAX_RECORDS_PER_WRITE`).
+- **CLAUDE.md "External Service Limits" section**: documents ChromaDB Cloud + Voyage AI quotas with a reference table. Mandatory consult before any new ChromaDB call.
+
+### Fixed
+
+- **`project_against` paginated `coll.get()`**: `_PAGE = 2000` exceeded the ChromaDB Cloud Get quota of 300, causing `nx taxonomy project` to fail on real cloud collections. Now `_PAGE = 300` with paginated source-collection fetch via `_paginated_get`.
+- **4 unbounded `coll.get()` calls** in `catalog_taxonomy.py` (`_discover_cross_links`, `project_against` centroid filter, `rebuild_taxonomy` rebuild + cleanup paths) wrapped in `_paginated_get` to avoid OOM and quota errors at scale.
+- **3 `centroid_coll.upsert()` sites** wrapped in `_batched_upsert` (defensive against `MAX_RECORDS_PER_WRITE = 300`).
+- **`rebuild_taxonomy` cleanup**: paginated GET + batched DELETE so collections with >300 centroids don't fail rebuild.
+- **`nx taxonomy links` invisible cross-collection links**: command queried `compute_topic_links` (catalog-derived only) and ignored the `topic_links` table. Cross-collection projection links written by `_discover_cross_links` and `generate_cooccurrence_links` were invisible. Now displays all rows in `topic_links` with `[collection]` prefix on each topic. New `--refresh` flag re-runs catalog-derived computation explicitly.
+- **`backfill_projection` misleading count**: reported "X assignments" using the per-call attempt count, but `INSERT OR IGNORE` deduplicates. Now reports "X stored (Y attempted)" using `COUNT(*) FROM topic_assignments WHERE assigned_by = 'projection'`.
+- **Plugin/CLI version mismatch UX**: when the nx plugin is upgraded but the conexus CLI is not, the `nx upgrade --auto` SessionStart hook would print a cryptic Click error. Now prints a helpful message: `nx plugin requires conexus >= 4.2.0 — run: uv tool upgrade conexus`.
+
 ## [4.2.0] - 2026-04-14
 
 ### Added

{conexus-4.2.0 → conexus-4.2.2}/CLAUDE.md

@@ -179,6 +179,28 @@ tests/               # pytest suite (unit + integration + e2e/)
 docs/                # Documentation (architecture.md is the module map)
 ```
 
+## External Service Limits — CHECK BEFORE EVERY CALL
+
+**ALWAYS** consult `src/nexus/db/chroma_quotas.py` (the `QUOTAS` dataclass and `QuotaValidator`) before writing any ChromaDB call. Violating these at runtime produces `ChromaError: Quota exceeded` — costly to debug, embarrassing in release.
+
+**ChromaDB Cloud free-tier caps** (single source of truth: `chroma_quotas.py`):
+
+| Operation | Limit | Notes |
+|-----------|-------|-------|
+| `coll.get(limit=N)` | N ≤ 300 | Same cap as queries. `_PAGE = 300` max for pagination |
+| `coll.query(n_results=N)` | N ≤ 300 | `MAX_QUERY_RESULTS` |
+| `coll.upsert/add(ids=[...])` | ≤ 300 records | `MAX_RECORDS_PER_WRITE` |
+| Concurrent reads per coll | ≤ 10 | `MAX_CONCURRENT_READS` |
+| Concurrent writes per coll | ≤ 10 | `MAX_CONCURRENT_WRITES` |
+| Document size | ≤ 16384 bytes | `MAX_DOCUMENT_BYTES` (use `SAFE_CHUNK_BYTES = 12288`) |
+| Query string | ≤ 256 chars | `MAX_QUERY_STRING_CHARS` |
+| `where` predicates | ≤ 8 top-level | `MAX_WHERE_PREDICATES` |
+| Embedding dims | ≤ 4096 | `MAX_EMBEDDING_DIMENSIONS` |
+
+**Voyage AI**: `voyage-3` / `voyage-code-3` / `voyage-context-3` = 1024 dims, 32k tokens/request. Batch requests up to 128 inputs. Use `nexus.retry._voyage_with_retry` for transient failure handling.
+
+**Rule of thumb**: paginating through a large ChromaDB collection requires `limit ≤ 300` per call. When fetching N documents, use `offset += 300` in a loop. `MAX_RECORDS_PER_WRITE = 300` means upsert batches must also be capped.
+
 ## Development Conventions
 
 - **Python 3.12+**: use `match/case`, `tomllib`, `typing.Protocol`, walrus operator freely

{conexus-4.2.0 → conexus-4.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conexus
-Version: 4.2.0
+Version: 4.2.2
 Summary: Self-hosted semantic search and knowledge management for LLM-driven development
 Project-URL: Homepage, https://github.com/Hellblazer/nexus
 Project-URL: Repository, https://github.com/Hellblazer/nexus

{conexus-4.2.0 → conexus-4.2.2}/nx/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "4.2.0",
+  "version": "4.2.2",
   "description": "Self-hosted three-tier knowledge management with specialized agents, analytical query pipelines, semantic search, and RDR decision tracking for Claude Code.",
   "author": {
     "name": "Hal Hildebrand",

{conexus-4.2.0 → conexus-4.2.2}/nx/CHANGELOG.md

@@ -6,6 +6,14 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [4.2.2] - 2026-04-14
+
+(v4.2.1 was tagged but never published due to a CLI test failure. v4.2.2 supersedes it.)
+
+### Fixed
+
+- **SessionStart hook fallback for old CLI**: when `nx upgrade --auto` fails (CLI < 4.2.0 doesn't have the upgrade command), the hook now prints `nx plugin requires conexus >= 4.2.0 — run: uv tool upgrade conexus` to stderr instead of the raw Click error.
+
 ## [4.2.0] - 2026-04-14
 
 ### Added

{conexus-4.2.0 → conexus-4.2.2}/nx/hooks/hooks.json

@@ -6,7 +6,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "nx upgrade --auto",
+            "command": "nx upgrade --auto 2>/dev/null || echo 'nx plugin requires conexus >= 4.2.0 — run: uv tool upgrade conexus' >&2",
             "timeout": 30
           },
           {

{conexus-4.2.0 → conexus-4.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "conexus"
-version = "4.2.0"
+version = "4.2.2"
 description = "Self-hosted semantic search and knowledge management for LLM-driven development"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.12,<3.14"

{conexus-4.2.0 → conexus-4.2.2}/sn/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "sn",
-  "version": "4.2.0",
+  "version": "4.2.2",
   "description": "Injects Serena and Context7 MCP tool usage guidance into subagents via SubagentStart hook."
 }

{conexus-4.2.0 → conexus-4.2.2}/src/nexus/commands/taxonomy_cmd.py

@@ -756,27 +756,64 @@ def compute_topic_links(
 
 @taxonomy.command("links")
 @click.option("--collection", "-c", default="", help="Filter by collection")
-def links_cmd(collection: str) -> None:
-    """Show inter-topic relationships derived from catalog links."""
+@click.option(
+    "--refresh", is_flag=True,
+    help="Recompute catalog-derived links before displaying (requires catalog).",
+)
+def links_cmd(collection: str, refresh: bool) -> None:
+    """Show all inter-topic relationships in topic_links.
+
+    Includes cross-collection projection links from RDR-075 (link_types
+    contains 'projection' or 'cooccurrence') AND catalog-derived links
+    from compute_topic_links (link_types contains 'cites', 'implements',
+    etc.).  Use --refresh to recompute catalog-derived links first.
+    """
     with _T2Database(_default_db_path()) as db:
-        catalog = _try_load_catalog()
-        if catalog is None:
-            click.echo("No catalog initialized. Run `nx catalog setup` first.")
-            return
+        if refresh:
+            catalog = _try_load_catalog()
+            if catalog is None:
+                click.echo("No catalog initialized — skipping --refresh.")
+            else:
+                compute_topic_links(
+                    db.taxonomy, catalog, collection=collection, persist=True,
+                )
 
-        result = compute_topic_links(
-            db.taxonomy, catalog, collection=collection, persist=True,
-        )
-        if not result:
+        # Display all rows in topic_links, joined with topic labels
+        if collection:
+            rows = db.taxonomy.conn.execute(
+                "SELECT t1.label, t1.collection, t2.label, t2.collection, "
+                "       tl.link_count, tl.link_types "
+                "FROM topic_links tl "
+                "JOIN topics t1 ON tl.from_topic_id = t1.id "
+                "JOIN topics t2 ON tl.to_topic_id = t2.id "
+                "WHERE t1.collection = ? OR t2.collection = ? "
+                "ORDER BY tl.link_count DESC",
+                (collection, collection),
+            ).fetchall()
+        else:
+            rows = db.taxonomy.conn.execute(
+                "SELECT t1.label, t1.collection, t2.label, t2.collection, "
+                "       tl.link_count, tl.link_types "
+                "FROM topic_links tl "
+                "JOIN topics t1 ON tl.from_topic_id = t1.id "
+                "JOIN topics t2 ON tl.to_topic_id = t2.id "
+                "ORDER BY tl.link_count DESC"
+            ).fetchall()
+
+        if not rows:
             click.echo("No topic links found.")
             return
 
-        click.echo(f"Topic relationships ({len(result)} pairs):\n")
-        for pair in result:
-            types_str = ", ".join(pair["link_types"])
+        click.echo(f"Topic relationships ({len(rows)} pairs):\n")
+        for from_label, from_coll, to_label, to_coll, count, types_json in rows:
+            try:
+                import json as _json
+                types_str = ", ".join(_json.loads(types_json))
+            except Exception:
+                types_str = types_json
             click.echo(
-                f"  {pair['from_topic']} <-> {pair['to_topic']}"
-                f"  ({pair['link_count']} links: {types_str})"
+                f"  [{from_coll}] {from_label} <-> [{to_coll}] {to_label}"
+                f"  ({count} links: {types_str})"
             )
 
 

{conexus-4.2.0 → conexus-4.2.2}/src/nexus/commands/upgrade.py

@@ -42,10 +42,11 @@ def _current_version() -> str:
 @click.option("--dry-run", is_flag=True, help="List pending migrations without executing (creates base tables if absent).")
 @click.option("--force", is_flag=True, help="Reset version gate and re-run all migrations.")
 @click.option("--auto", "auto_mode", is_flag=True, help="Quiet mode for hook invocation (T2 only, exit 0 always).")
-def upgrade(dry_run: bool, force: bool, auto_mode: bool) -> None:
+@click.option("--skip-t3", is_flag=True, help="Skip T3 upgrade steps (e.g., cross-collection projection backfill). Useful for fast T2-only migrations.")
+def upgrade(dry_run: bool, force: bool, auto_mode: bool, skip_t3: bool) -> None:
     """Run pending database migrations and upgrade steps."""
     try:
-        _run_upgrade(dry_run=dry_run, force=force, auto_mode=auto_mode)
+        _run_upgrade(dry_run=dry_run, force=force, auto_mode=auto_mode, skip_t3=skip_t3)
     except Exception:
         if auto_mode:
             _log.warning("upgrade_auto_error", exc_info=True)
@@ -53,7 +54,7 @@ def upgrade(dry_run: bool, force: bool, auto_mode: bool) -> None:
         raise
 
 
-def _run_upgrade(*, dry_run: bool, force: bool, auto_mode: bool) -> None:
+def _run_upgrade(*, dry_run: bool, force: bool, auto_mode: bool, skip_t3: bool = False) -> None:
     from pathlib import Path
 
     db_path = _db_path()
@@ -90,9 +91,9 @@ def _run_upgrade(*, dry_run: bool, force: bool, auto_mode: bool) -> None:
             and _parse_version(m.introduced) <= current_t
         ]
 
-        # Compute pending T3 steps (skip in auto mode)
+        # Compute pending T3 steps (skip in auto mode or when --skip-t3)
         pending_t3 = []
-        if not auto_mode:
+        if not auto_mode and not skip_t3:
             pending_t3 = [
                 s
                 for s in T3_UPGRADES
@@ -109,7 +110,7 @@ def _run_upgrade(*, dry_run: bool, force: bool, auto_mode: bool) -> None:
             for m in pending_t2:
                 click.echo(f"  T2: [{m.introduced}] {m.name}")
             for s in pending_t3:
-                click.echo(f"  T3: [{s.introduced}] {s.name}")
+                click.echo(f"  T3: [{s.introduced}] {s.name} (heavy — skip with --skip-t3)")
             return
 
         # Execute T2 migrations

{conexus-4.2.0 → conexus-4.2.2}/src/nexus/db/migrations.py

@@ -311,26 +311,39 @@ def backfill_projection(t3_db: Any, taxonomy: Any) -> None:
     collections' centroids and stores assignments with ``assigned_by='projection'``.
     Then generates co-occurrence topic links.
 
+    **Heavy operation** — scales O(collections²) with each pair requiring
+    paginated ChromaDB fetches.  For a repo with N collections, expect
+    N*(N-1) projection calls.  Prints per-collection progress to stderr.
+
     RDR-075 RF-11.  Idempotent via ``INSERT OR IGNORE`` in ``assign_topic``.
     """
+    import sys
+    import time
+
     import structlog
 
     log = structlog.get_logger()
 
-    # Find all collections with existing topics
     collections = taxonomy.get_distinct_collections()
-
     if not collections:
         log.info("backfill_projection_skip", reason="no topics discovered yet")
         return
 
-    log.info("backfill_projection_start", collections=len(collections))
+    n = len(collections)
+    print(
+        f"  Backfilling projection across {n} collections "
+        f"(~{n * (n - 1)} projection calls).",
+        file=sys.stderr,
+    )
+    log.info("backfill_projection_start", collections=n)
     total_assigned = 0
+    total_start = time.monotonic()
 
-    for src in collections:
+    for i, src in enumerate(collections, 1):
         targets = [c for c in collections if c != src]
         if not targets:
             continue
+        t0 = time.monotonic()
         try:
             result = taxonomy.project_against(
                 src, targets, t3_db._client, threshold=0.85,
@@ -339,16 +352,42 @@ def backfill_projection(t3_db: Any, taxonomy: Any) -> None:
             for doc_id, topic_id in assignments:
                 taxonomy.assign_topic(doc_id, topic_id, assigned_by="projection")
             total_assigned += len(assignments)
-        except Exception:
-            log.debug("backfill_projection_collection_failed", collection=src, exc_info=True)
+            elapsed = time.monotonic() - t0
+            print(
+                f"  [{i}/{n}] {src}: "
+                f"{result.get('total_chunks', 0)} chunks, "
+                f"{len(result.get('matched_topics', []))} matches, "
+                f"{len(assignments)} attempted ({elapsed:.1f}s)",
+                file=sys.stderr,
+            )
+        except Exception as e:
+            log.warning("backfill_projection_collection_failed",
+                        collection=src, exc_info=True)
+            print(f"  [{i}/{n}] {src}: SKIPPED ({type(e).__name__})",
+                  file=sys.stderr)
 
     # Generate co-occurrence links from the new projection assignments
+    print("  Generating co-occurrence topic links...", file=sys.stderr)
     try:
-        taxonomy.generate_cooccurrence_links()
+        link_count = taxonomy.generate_cooccurrence_links()
+        print(f"  Generated {link_count} co-occurrence links.", file=sys.stderr)
     except Exception:
-        log.debug("backfill_cooccurrence_failed", exc_info=True)
-
-    log.info("backfill_projection_complete", total_assigned=total_assigned)
+        log.warning("backfill_cooccurrence_failed", exc_info=True)
+        print("  Co-occurrence link generation: SKIPPED", file=sys.stderr)
+
+    total_elapsed = time.monotonic() - total_start
+    # Count actual rows written (INSERT OR IGNORE deduplicates; the per-call
+    # 'attempted' counts may exceed actual writes).
+    actual_written = taxonomy.conn.execute(
+        "SELECT COUNT(*) FROM topic_assignments WHERE assigned_by = 'projection'"
+    ).fetchone()[0]
+    print(
+        f"  Backfill complete: {actual_written} projection assignments stored "
+        f"({total_assigned} attempted) in {total_elapsed:.1f}s across {n} collections.",
+        file=sys.stderr,
+    )
+    log.info("backfill_projection_complete",
+             total_assigned=total_assigned, elapsed_s=round(total_elapsed, 1))
 
 
 T3_UPGRADES: list[T3UpgradeStep] = [

{conexus-4.2.0 → conexus-4.2.2}/src/nexus/db/t2/catalog_taxonomy.py

@@ -773,7 +773,7 @@ class CatalogTaxonomy:
         except Exception:
             pass  # Parent centroid may not exist
         if c_ids:
-            centroid_coll.upsert(ids=c_ids, embeddings=c_embs, metadatas=c_metas)
+            self._batched_upsert(centroid_coll, c_ids, c_embs, c_metas)
 
         return child_count
 
@@ -1040,9 +1040,9 @@ class CatalogTaxonomy:
 
             self.conn.commit()
 
-        # Upsert centroids outside the lock
+        # Upsert centroids outside the lock (batched at 300 per write)
         if c_ids_out:
-            centroid_coll.upsert(ids=c_ids_out, embeddings=c_embs, metadatas=c_metas)
+            self._batched_upsert(centroid_coll, c_ids_out, c_embs, c_metas)
 
         # Cross-collection post-pass: find topic links to other collections'
         # centroids (RDR-075 SC-6, Phase 3).  Lightweight: only new centroids
@@ -1109,6 +1109,77 @@ class CatalogTaxonomy:
 
     _PROJECTION_THRESHOLD = 0.85
 
+    @staticmethod
+    def _batched_upsert(
+        coll: Any,
+        ids: list[str],
+        embeddings: list,
+        metadatas: list[dict],
+        *,
+        batch_size: int = 300,
+    ) -> None:
+        """Batched wrapper for ``coll.upsert()`` — caps at ChromaDB Cloud's
+        300-record per-write limit (MAX_RECORDS_PER_WRITE).
+        """
+        for i in range(0, len(ids), batch_size):
+            j = i + batch_size
+            coll.upsert(
+                ids=ids[i:j],
+                embeddings=embeddings[i:j],
+                metadatas=metadatas[i:j],
+            )
+
+    @staticmethod
+    def _paginated_get(
+        coll: Any,
+        *,
+        where: dict | None = None,
+        include: list[str] | None = None,
+        page_size: int = 300,
+    ) -> dict[str, list]:
+        """Paginated wrapper for ``coll.get()`` — caps at ChromaDB Cloud's
+        300-record limit per call (MAX_QUERY_RESULTS).
+
+        Returns a dict with the same shape as ``coll.get()`` (keys: ids,
+        embeddings, metadatas, documents) but with ALL pages concatenated.
+        """
+        ids: list[str] = []
+        embeddings: list[Any] = []
+        metadatas: list[Any] = []
+        documents: list[Any] = []
+        offset = 0
+        while True:
+            kwargs: dict[str, Any] = {"limit": page_size, "offset": offset}
+            if where is not None:
+                kwargs["where"] = where
+            if include is not None:
+                kwargs["include"] = include
+            page = coll.get(**kwargs)
+            page_ids = page.get("ids") or []
+            if not page_ids:
+                break
+            ids.extend(page_ids)
+            if "embeddings" in (include or []):
+                page_embs = page.get("embeddings")
+                if page_embs is not None:
+                    embeddings.extend(page_embs)
+            if "metadatas" in (include or []):
+                metadatas.extend(page.get("metadatas") or [])
+            if "documents" in (include or []):
+                documents.extend(page.get("documents") or [])
+            if len(page_ids) < page_size:
+                break
+            offset += page_size
+
+        result: dict[str, list] = {"ids": ids}
+        if "embeddings" in (include or []):
+            result["embeddings"] = embeddings
+        if "metadatas" in (include or []):
+            result["metadatas"] = metadatas
+        if "documents" in (include or []):
+            result["documents"] = documents
+        return result
+
     def _discover_cross_links(
         self,
         collection_name: str,
@@ -1122,9 +1193,10 @@ class CatalogTaxonomy:
         existing centroids from all OTHER collections. Store matches
         above ``_PROJECTION_THRESHOLD`` as ``topic_links`` entries.
         """
-        # Fetch all centroids NOT in this collection
+        # Fetch all centroids NOT in this collection (paginated, ChromaDB cap = 300)
         try:
-            other = centroid_coll.get(
+            other = self._paginated_get(
+                centroid_coll,
                 where={"collection": {"$ne": collection_name}},
                 include=["embeddings", "metadatas"],
             )
@@ -1327,8 +1399,8 @@ class CatalogTaxonomy:
                 "total_centroids": 0,
             }
 
-        # Paginated fetch to avoid OOM on large collections
-        _PAGE = 2000
+        # Paginated fetch — ChromaDB Cloud caps Get at 300 (MAX_QUERY_RESULTS)
+        _PAGE = 300
         src_ids: list[str] = []
         src_emb_pages: list[np.ndarray] = []
         offset = 0
@@ -1372,8 +1444,9 @@ class CatalogTaxonomy:
                 "total_centroids": 0,
             }
 
-        # Filter centroids to target collections
-        ctr_data = centroid_coll.get(
+        # Filter centroids to target collections (paginated, ChromaDB cap = 300)
+        ctr_data = self._paginated_get(
+            centroid_coll,
             where={"collection": {"$in": target_collections}},
             include=["embeddings", "metadatas"],
         )
@@ -1569,9 +1642,11 @@ class CatalogTaxonomy:
         }
 
         # Read old centroids from ChromaDB, resolve labels from T2
+        # (paginated, ChromaDB cap = 300)
         old_centroid_topic_ids: list[int] = []  # old topic_id per centroid index
         try:
-            old_data = centroid_coll.get(
+            old_data = self._paginated_get(
+                centroid_coll,
                 where={"collection": collection_name},
                 include=["embeddings", "metadatas"],
             )
@@ -1611,12 +1686,14 @@ class CatalogTaxonomy:
             )
             self.conn.commit()
 
-        # Clear old centroids from ChromaDB
-        old_centroid_ids = centroid_coll.get(
+        # Clear old centroids from ChromaDB.  Paginated GET (cap 300) +
+        # batched DELETE (MAX_RECORDS_PER_WRITE = 300).
+        old_centroid_ids = self._paginated_get(
+            centroid_coll,
             where={"collection": collection_name},
         ).get("ids", [])
-        if old_centroid_ids:
-            centroid_coll.delete(ids=old_centroid_ids)
+        for i in range(0, len(old_centroid_ids), 300):
+            centroid_coll.delete(ids=old_centroid_ids[i:i + 300])
 
         # ── Step 3: HDBSCAN ──────────────────────────────────────────
         n = len(doc_ids)
@@ -1757,9 +1834,9 @@ class CatalogTaxonomy:
 
             self.conn.commit()
 
-        # Upsert new centroids
+        # Upsert new centroids (batched at 300 per write)
         if c_ids:
-            centroid_coll.upsert(ids=c_ids, embeddings=c_embs, metadatas=c_metas)
+            self._batched_upsert(centroid_coll, c_ids, c_embs, c_metas)
 
         # Record doc count for rebalance tracking
         self.record_discover_count(collection_name, n)

{conexus-4.2.0 → conexus-4.2.2}/src/nexus/health.py

@@ -104,6 +104,64 @@ def _check_python() -> list[HealthResult]:
     return [r]
 
 
+def _check_cli_version() -> list[HealthResult]:
+    """Check whether a newer conexus version is available on PyPI."""
+    try:
+        from importlib.metadata import version as _pkg_version
+
+        current = _pkg_version("conexus")
+    except Exception:
+        return []  # silent — installed version unknown
+
+    # Check PyPI for latest (3-second timeout, network-tolerant)
+    import json
+    import urllib.error
+    import urllib.request
+
+    try:
+        req = urllib.request.Request(
+            "https://pypi.org/pypi/conexus/json",
+            headers={"User-Agent": f"nx-doctor/{current}"},
+        )
+        with urllib.request.urlopen(req, timeout=3) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+        latest = data["info"]["version"]
+    except (urllib.error.URLError, OSError, json.JSONDecodeError, KeyError, TimeoutError):
+        return [HealthResult(
+            label="conexus version",
+            ok=True,
+            detail=f"{current} (PyPI check skipped — offline?)",
+        )]
+
+    # Compare via tuple parsing
+    def _parse(v: str) -> tuple[int, ...]:
+        try:
+            parts = tuple(int(x) for x in v.split(".")[:3])
+            return parts + (0,) * (3 - len(parts))
+        except ValueError:
+            return (0, 0, 0)
+
+    cur_t = _parse(current)
+    latest_t = _parse(latest)
+
+    if cur_t >= latest_t:
+        return [HealthResult(
+            label="conexus version",
+            ok=True,
+            detail=f"{current} (latest)",
+        )]
+
+    r = HealthResult(
+        label="conexus version",
+        ok=True,  # not fatal — just informational
+        detail=f"{current} → {latest} available",
+    )
+    r.fix_suggestions = [
+        f"uv tool upgrade conexus    # → {latest}",
+    ]
+    return [r]
+
+
 def _check_t3_local() -> list[HealthResult]:
     from nexus.config import _default_local_path
 
@@ -637,6 +695,7 @@ def run_health_checks() -> tuple[list[HealthResult], bool]:
     results: list[HealthResult] = []
 
     results.extend(_check_python())
+    results.extend(_check_cli_version())
 
     _local = is_local_mode()
     if _local:

{conexus-4.2.0 → conexus-4.2.2}/tests/test_phase5_integration.py

@@ -45,7 +45,9 @@ class TestHooksJson:
             for h in data["hooks"]["SessionStart"]
             if "startup" in h["matcher"]
         )
-        assert startup_hooks[0]["command"] == "nx upgrade --auto"
+        # The first hook must start with `nx upgrade --auto`.  The 4.2.1
+        # fallback appends a helpful error message for older CLIs.
+        assert startup_hooks[0]["command"].startswith("nx upgrade --auto")
         assert startup_hooks[0]["timeout"] == 30