conexus 3.2.2__tar.gz → 3.2.3__tar.gz

{conexus-3.2.2 → conexus-3.2.3}/.claude-plugin/marketplace.json

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

{conexus-3.2.2 → conexus-3.2.3}/CHANGELOG.md

@@ -6,6 +6,11 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [3.2.3] - 2026-04-07
+
+### Fixed
+- **Pagination completeness** — all list-returning MCP tools and CLI commands now include pagination footers when results are truncated. Tools fixed: `query`, `scratch` (search/list), `plan_search`, `catalog_search`, `catalog_list`, `catalog_link_query`. CLI commands fixed: `nx catalog list`, `nx catalog search`, `nx catalog links`. Docstrings updated to document pagination behavior.
+
 ## [3.2.2] - 2026-04-07
 
 ### Fixed

{conexus-3.2.2 → conexus-3.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conexus
-Version: 3.2.2
+Version: 3.2.3
 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-3.2.2 → conexus-3.2.3}/nx/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "3.2.2",
+  "version": "3.2.3",
   "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-3.2.2 → conexus-3.2.3}/nx/CHANGELOG.md

@@ -6,6 +6,10 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [3.2.3] - 2026-04-07
+
+Plugin version aligned with Nexus CLI 3.2.3. No plugin-level functional changes.
+
 ## [3.2.2] - 2026-04-07
 
 ### Fixed

{conexus-3.2.2 → conexus-3.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "conexus"
-version = "3.2.2"
+version = "3.2.3"
 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-3.2.2 → conexus-3.2.3}/sn/.claude-plugin/plugin.json

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

{conexus-3.2.2 → conexus-3.2.3}/src/nexus/commands/catalog.py

@@ -300,23 +300,27 @@ def setup_cmd(remote: str) -> None:
 @click.option("--owner", default="")
 @click.option("--type", "content_type", default="")
 @click.option("--limit", "-n", default=50)
+@click.option("--offset", default=0)
 @click.option("--json", "as_json", is_flag=True)
-def list_cmd(owner: str, content_type: str, limit: int, as_json: bool) -> None:
+def list_cmd(owner: str, content_type: str, limit: int, offset: int, as_json: bool) -> None:
     """List catalog entries."""
     cat = _get_catalog()
     if owner:
         entries = cat.by_owner(Tumbler.parse(owner))
     else:
-        entries = cat.all_documents(limit=limit)
+        entries = cat.all_documents(limit=limit + offset + 1)
     if content_type:
         entries = [e for e in entries if e.content_type == content_type]
-    entries = entries[:limit]
+    total = len(entries)
+    entries = entries[offset:offset + limit]
 
     if as_json:
         click.echo(json.dumps([_entry_to_dict(e) for e in entries], indent=2))
     else:
         for e in entries:
             click.echo(f"{str(e.tumbler):<12} {e.content_type:<10} {e.title}")
+        if offset + limit < total:
+            click.echo(f"\n  Next page: --offset {offset + limit}")
 
 
 @catalog.command("show")
@@ -378,15 +382,18 @@ def show_cmd(tumbler_or_title: str, as_json: bool) -> None:
 @catalog.command("search")
 @click.argument("query")
 @click.option("--limit", "-n", default=20)
+@click.option("--offset", default=0)
 @click.option("--json", "as_json", is_flag=True)
-def search_cmd(query: str, limit: int, as_json: bool) -> None:
+def search_cmd(query: str, limit: int, offset: int, as_json: bool) -> None:
     """Find documents by title, author, corpus, or file path.
 
     Uses full-text search across document metadata. Faster than T3 semantic
     search for exact metadata lookups. Returns tumbler, type, and title.
     """
     cat = _get_catalog()
-    results = cat.find(query)[:limit]
+    all_results = cat.find(query)
+    total = len(all_results)
+    results = all_results[offset:offset + limit]
     if as_json:
         click.echo(json.dumps([_entry_to_dict(e) for e in results], indent=2))
     else:
@@ -395,6 +402,8 @@ def search_cmd(query: str, limit: int, as_json: bool) -> None:
             return
         for e in results:
             click.echo(f"{str(e.tumbler):<12} {e.content_type:<10} {e.title}")
+        if offset + limit < total:
+            click.echo(f"\n  Next page: --offset {offset + limit}")
 
 
 @catalog.command("register", hidden=True)
@@ -599,8 +608,10 @@ def links_cmd(
     links = cat.link_query(
         from_t=resolved_from, to_t=resolved_to,
         link_type=link_type, created_by=created_by,
-        limit=limit, offset=offset,
+        limit=limit + 1, offset=offset,
     )
+    has_more = len(links) > limit
+    links = links[:limit]
     if as_json:
         click.echo(json.dumps([_link_to_dict(lnk) for lnk in links], indent=2))
     else:
@@ -609,6 +620,8 @@ def links_cmd(
             return
         for edge in links:
             click.echo(f"{edge.from_tumbler} → {edge.to_tumbler} ({edge.link_type}) by {edge.created_by}")
+        if has_more:
+            click.echo(f"\n  Next page: --offset {offset + limit}")
 
 
 @catalog.command("link-bulk-delete", hidden=True)

{conexus-3.2.2 → conexus-3.2.3}/src/nexus/mcp_server.py

@@ -391,6 +391,9 @@ def query(
 ) -> str:
     """Document-level semantic search for analytical questions.
 
+    Results are capped at ``limit``. When more documents match, a footer line shows
+    the total count. Increase ``limit`` to see more.
+
     Unlike ``search`` which returns individual chunks, ``query`` groups results
     by source document and returns the best-matching snippet per document along
     with full metadata (title, year, citations, page count, extraction method).
@@ -558,7 +561,9 @@ def query(
                 docs[doc_key]["snippet"] = r.content[:300].replace("\n", " ")
 
         # Sort by best match distance, limit
-        sorted_docs = sorted(docs.values(), key=lambda d: d["distance"])[:limit]
+        all_docs = sorted(docs.values(), key=lambda d: d["distance"])
+        sorted_docs = all_docs[:limit]
+        total = len(all_docs)
 
         header = f"Found {len(sorted_docs)} documents (from {len(results)} chunks across {len(target)} collections)"
         lines: list[str] = [f"{routing_note}\n{header}" if routing_note else header]
@@ -598,6 +603,9 @@ def query(
             lines.append(f"   {d['snippet']}")
             lines.append("")
 
+        if total > limit:
+            lines.append(f"\n--- showing 1-{len(sorted_docs)} of {total} documents. Results are capped at limit={limit}.")
+
         return "\n".join(lines)
     except Exception as e:
         return f"Error: {e}"
@@ -936,6 +944,9 @@ def scratch(
 ) -> str:
     """T1 session scratch pad — ephemeral within-session storage.
 
+    For ``search`` and ``list``, results are capped at ``limit``. A footer
+    indicates when more entries exist.
+
     Args:
         action: One of "put", "search", "list", "get", "delete"
         content: Content to store (for "put")
@@ -964,17 +975,23 @@ def scratch(
             for r in results:
                 snippet = r["content"][:200].replace("\n", " ")
                 lines.append(f"{prefix}[{r['id'][:12]}] {snippet}")
+            if len(results) >= limit:
+                lines.append(f"\n--- showing {len(results)} results (limit={limit}). Increase limit to see more.")
             return "\n".join(lines)
 
         elif action == "list":
             entries = t1.list_entries()
             if not entries:
                 return f"{prefix}No scratch entries."
+            total = len(entries)
+            entries = entries[:limit]
             lines = []
             for e in entries:
                 snippet = e["content"][:80].replace("\n", " ")
                 tags_str = f"  [{e.get('tags', '')}]" if e.get("tags") else ""
                 lines.append(f"{prefix}[{e['id'][:12]}] {snippet}{tags_str}")
+            if total > limit:
+                lines.append(f"\n--- showing {limit} of {total} entries. Increase limit to see all.")
             return "\n".join(lines)
 
         elif action == "get":
@@ -1159,17 +1176,25 @@ def plan_save(
 
 
 @mcp.tool()
-def plan_search(query: str, project: str = "", limit: int = 5) -> str:
+def plan_search(query: str, project: str = "", limit: int = 5, offset: int = 0) -> str:
     """Search the T2 plan library for similar query plans.
 
+    Results are paged. Response footer shows ``offset=N`` for next page.
+
     Args:
         query: Search query (matched against plan query text and tags)
         project: Optional project filter (e.g. "nexus")
-        limit: Maximum results to return
+        limit: Maximum results to return (default 5)
+        offset: Skip this many results (default 0). Use for pagination.
     """
     try:
         with _t2_ctx() as db:
-            results = db.search_plans(query, limit=limit, project=project)
+            # Over-fetch by 1 to detect if there are more
+            results = db.search_plans(query, limit=limit + 1, project=project)
+        if offset:
+            results = results[offset:]
+        has_more = len(results) > limit
+        results = results[:limit]
         if not results:
             return "No matching plans."
         lines: list[str] = []
@@ -1180,6 +1205,9 @@ def plan_search(query: str, project: str = "", limit: int = 5) -> str:
                 f"  outcome={r['outcome']}  tags={r['tags']}\n"
                 f"  plan: {plan_preview}..."
             )
+        shown_end = offset + len(results)
+        if has_more:
+            lines.append(f"\n--- showing {offset + 1}-{shown_end}. may have more: offset={shown_end}")
         return "\n\n".join(lines)
     except Exception as e:
         return f"Error: {e}"
@@ -1205,11 +1233,15 @@ def catalog_search(
     owner: str = "",
     file_path: str = "",
     limit: int = 20,
+    offset: int = 0,
 ) -> list[dict]:
     """Find documents by metadata (title, author, corpus, file path).
 
+    Results are paged. When results are truncated, a ``_pagination`` entry appears
+    at the end with ``next_offset``. Pass that value as ``offset`` to get the next page.
+
     Returns catalog entries with tumbler, physical_collection, and metadata — NOT document
-    content. Use the `search` tool for semantic content search within collections.
+    content. Use the ``search`` tool for semantic content search within collections.
     Use catalog_search first to discover WHICH collections to search, then search for content.
 
     Filters: query (free-text), author, corpus, owner, file_path, content_type (exact match).
@@ -1246,9 +1278,9 @@ def catalog_search(
             sql = (
                 "SELECT tumbler, title, author, year, content_type, file_path, "
                 "corpus, physical_collection, chunk_count, head_hash, indexed_at, metadata "
-                f"FROM documents WHERE {' AND '.join(conditions)} LIMIT ?"
+                f"FROM documents WHERE {' AND '.join(conditions)} LIMIT ? OFFSET ?"
             )
-            params.append(limit)
+            params.extend([limit + 1, offset])
             rows = cat._db.execute(sql, params).fetchall()
             from nexus.catalog.catalog import CatalogEntry
             entries = [
@@ -1260,7 +1292,12 @@ def catalog_search(
                 )
                 for r in rows
             ]
-            return [_entry_to_dict(e) for e in entries]
+            has_more = len(entries) > limit
+            entries = entries[:limit]
+            result = [_entry_to_dict(e) for e in entries]
+            if has_more:
+                result.append({"_pagination": {"next_offset": offset + limit, "limit": limit}})
+            return result
 
         # FTS5 free-text search (append author to query if both provided)
         fts_query = query
@@ -1268,8 +1305,12 @@ def catalog_search(
             fts_query = f"{query} {author}"
         if not fts_query.strip():
             return [{"error": "query or at least one filter required"}]
-        results = cat.find(fts_query, content_type=content_type or None)[:limit]
-        return [_entry_to_dict(e) for e in results]
+        all_results = cat.find(fts_query, content_type=content_type or None)
+        page = all_results[offset:offset + limit]
+        result = [_entry_to_dict(e) for e in page]
+        if offset + limit < len(all_results):
+            result.append({"_pagination": {"next_offset": offset + limit, "limit": limit}})
+        return result
     except Exception as e:
         return [{"error": str(e)}]
 
@@ -1315,7 +1356,10 @@ def catalog_list(
     limit: int = 50,
     offset: int = 0,
 ) -> list[dict]:
-    """List catalog entries with optional filters."""
+    """List catalog entries with optional filters.
+
+    Results are paged. When truncated, a ``_pagination`` entry appears at the end
+    with ``next_offset``. Pass that as ``offset`` to get the next page."""
     cat, err = _require_catalog()
     if err:
         return [{"error": err}]
@@ -1347,7 +1391,11 @@ def catalog_list(
             ]
         if content_type:
             entries = [e for e in entries if e.content_type == content_type]
-        return [_entry_to_dict(e) for e in entries[:limit]]
+        page = entries[:limit]
+        result = [_entry_to_dict(e) for e in page]
+        if len(entries) > limit:
+            result.append({"_pagination": {"next_offset": offset + limit, "limit": limit}})
+        return result
     except Exception as e:
         return [{"error": str(e)}]
 
@@ -1592,6 +1640,9 @@ def catalog_link_query(
 ) -> list[dict]:
     """Query links by any combination of filters. For admin/audit use.
 
+    Results are paged. When truncated, a ``_pagination`` entry appears at the end
+    with ``next_offset``. Pass that as ``offset`` to get the next page.
+
     NOT a query-planner step — use catalog_links for graph traversal.
     Use for: audit by creator, find all links of a type, count generator output.
     created_at_before: ISO timestamp — only links created before this time.
@@ -1606,9 +1657,14 @@ def catalog_link_query(
             from_t=from_tumbler, to_t=to_tumbler, link_type=link_type,
             created_by=created_by, direction=direction, tumbler=tumbler,
             created_at_before=created_at_before,
-            limit=limit, offset=offset,
+            limit=limit + 1, offset=offset,
         )
-        return [_link_to_dict(l) for l in links]
+        has_more = len(links) > limit
+        links = links[:limit]
+        result = [_link_to_dict(l) for l in links]
+        if has_more:
+            result.append({"_pagination": {"next_offset": offset + limit, "limit": limit}})
+        return result
     except Exception as e:
         return [{"error": str(e)}]
 

{conexus-3.2.2 → conexus-3.2.3}/uv.lock

@@ -673,7 +673,7 @@ wheels = [
 
 [[package]]
 name = "conexus"
-version = "3.2.2"
+version = "3.2.3"
 source = { editable = "." }
 dependencies = [
     { name = "chromadb" },