conexus 6.3.4__tar.gz → 6.3.6__tar.gz

{conexus-6.3.4 → conexus-6.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conexus
-Version: 6.3.4
+Version: 6.3.6
 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-6.3.4 → conexus-6.3.6}/mcpb/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "conexus-mcpb"
-version = "6.3.4"
+version = "6.3.6"
 description = "Conexus packaged as Claude Desktop .mcpb (Desktop Extension)"
 requires-python = ">=3.12"
 dependencies = [
@@ -10,7 +10,7 @@ dependencies = [
     # while collections are indexed at 768/1024-dim, so every T3 search hits a
     # dimension mismatch and returns zero results. The .mcpb cannot run the
     # interactive `nx init` embedder choice, so it must pin [local] explicitly.
-    "conexus[local]>=6.3.4",
+    "conexus[local]>=6.3.6",
 ]
 
 [tool.uv]

{conexus-6.3.4 → conexus-6.3.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "conexus"
-version = "6.3.4"
+version = "6.3.6"
 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-6.3.4 → conexus-6.3.6}/service/src/main/java/dev/nexus/service/db/AspectRepository.java

@@ -869,6 +869,61 @@ public final class AspectRepository {
      * Re-enqueue at the same (collection, source_path) resets to pending.
      */
     public void enqueue(String tenant, Map<String, Object> body) {
+        tenantScope.withTenant(tenant, ctx -> {
+            buildEnqueueQuery(ctx, tenant, body).execute();
+            return null;
+        });
+    }
+
+    /**
+     * Batch-enqueue N documents for extraction in ONE round trip
+     * (nexus-nj4ch, nexus-duoak follow-up: the indexer's per-file
+     * ``aspect_extraction_enqueue_hook`` call, fired once per document
+     * boundary under the ChunkBatcher, paid one WAN round trip per
+     * document — measured ~34.7s across ~250 real inserts in this repo's
+     * own shakeout). Same {@code ctx.batch(queries).execute()} pattern as
+     * {@link CatalogRepository#updateDocumentsMany} (heterogeneous
+     * per-row ON CONFLICT DO UPDATE — a single hand-built multi-row
+     * VALUES statement was rejected there for the same reason it would be
+     * here: jOOQ's typed VALUES API needs uniform per-column types, and
+     * Postgres NULL-parameter type inference fights optional per-row
+     * fields like {@code doc_id}).
+     *
+     * <p>Each map has the same shape as {@link #enqueue}'s {@code body}.
+     * A malformed row (missing collection/source_path) is skipped rather
+     * than aborting the whole batch — ghost-class isolation, mirroring
+     * {@code register_many}/{@code update_many}'s per-doc failure
+     * tolerance; the indexer's own {@code select_config(collection) is
+     * None} gate already filters out rows that don't need enqueueing
+     * before this is ever called, so a skip here should be rare (a
+     * genuine caller bug, not a routine collection-type filter).
+     */
+    public int enqueueMany(String tenant, List<Map<String, Object>> rows) {
+        if (rows.isEmpty()) return 0;
+        return tenantScope.withTenant(tenant, ctx -> {
+            var queries = new ArrayList<org.jooq.Query>();
+            for (var row : rows) {
+                String collection = (String) row.get("collection");
+                String sourcePath = (String) row.get("source_path");
+                if (collection == null || collection.isBlank()) continue;
+                if (sourcePath == null || sourcePath.isBlank()) continue;
+                queries.add(buildEnqueueQuery(ctx, tenant, row));
+            }
+            if (!queries.isEmpty()) {
+                ctx.batch(queries).execute();
+            }
+            return queries.size();
+        });
+    }
+
+    /**
+     * Shared query-builder for {@link #enqueue} and {@link #enqueueMany} —
+     * same INSERT ... ON CONFLICT DO UPDATE shape, same
+     * {@code ensureCollectionRegistered} precondition (the caller runs it
+     * before calling this, once per row, since it must happen before the
+     * row's own INSERT within the same transaction).
+     */
+    private org.jooq.Query buildEnqueueQuery(DSLContext ctx, String tenant, Map<String, Object> body) {
         String collection = (String) body.get("collection");
         String sourcePath = (String) body.get("source_path");
         if (collection == null || collection.isBlank()) throw new IllegalArgumentException("collection required");
@@ -877,55 +932,51 @@ public final class AspectRepository {
             OffsetDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ISO_OFFSET_DATE_TIME));
         OffsetDateTime enqueuedAtTs = parseTs(enqueuedAt);
 
-        tenantScope.withTenant(tenant, ctx -> {
-            ensureCollectionRegistered(ctx, tenant, collection);
-            ctx.insertInto(ASPECT_EXTRACTION_QUEUE,
-                    ASPECT_EXTRACTION_QUEUE.TENANT_ID,
-                    ASPECT_EXTRACTION_QUEUE.COLLECTION,
-                    ASPECT_EXTRACTION_QUEUE.SOURCE_PATH,
-                    ASPECT_EXTRACTION_QUEUE.DOC_ID,
-                    ASPECT_EXTRACTION_QUEUE.CONTENT_HASH,
-                    ASPECT_EXTRACTION_QUEUE.CONTENT,
-                    ASPECT_EXTRACTION_QUEUE.STATUS,
-                    ASPECT_EXTRACTION_QUEUE.RETRY_COUNT,
-                    ASPECT_EXTRACTION_QUEUE.ENQUEUED_AT,
-                    ASPECT_EXTRACTION_QUEUE.LAST_ATTEMPT_AT,
-                    ASPECT_EXTRACTION_QUEUE.LAST_ERROR)
-                .values(
-                    tenant, collection, sourcePath,
-                    nullIfBlank((String) body.get("doc_id")),
-                    (String) body.getOrDefault("content_hash", ""),
-                    (String) body.getOrDefault("content", ""),
-                    "pending", 0, enqueuedAtTs, null, null)
-                .onConflict(
-                    ASPECT_EXTRACTION_QUEUE.TENANT_ID,
-                    ASPECT_EXTRACTION_QUEUE.COLLECTION,
-                    ASPECT_EXTRACTION_QUEUE.SOURCE_PATH)
-                .doUpdate()
-                // nexus-nyout: a doc_id-less re-enqueue (blank -> NULL via
-                // nullIfBlank; e.g. collection re-embed) must not erase an
-                // existing correct tumbler — COALESCE keeps the old linkage;
-                // a real incoming tumbler still overwrites. The queue IMPORT
-                // path stays verbatim EXCLUDED.doc_id: fidelity import
-                // reproduces exported rows exactly, including blanks.
-                .set(ASPECT_EXTRACTION_QUEUE.DOC_ID,
-                     coalesce(EX_Q_DOC_ID, ASPECT_EXTRACTION_QUEUE.DOC_ID))
-                .set(ASPECT_EXTRACTION_QUEUE.CONTENT_HASH,    EX_Q_CONTENT_HASH)
-                .set(ASPECT_EXTRACTION_QUEUE.CONTENT,         EX_Q_CONTENT)
-                .set(ASPECT_EXTRACTION_QUEUE.STATUS,          "pending")
-                .set(ASPECT_EXTRACTION_QUEUE.RETRY_COUNT,     0)
-                .set(ASPECT_EXTRACTION_QUEUE.ENQUEUED_AT,     EX_Q_ENQUEUED_AT)
-                .set(ASPECT_EXTRACTION_QUEUE.LAST_ATTEMPT_AT, (OffsetDateTime) null)
-                .set(ASPECT_EXTRACTION_QUEUE.LAST_ERROR,      (String) null)
-                // RDR-163 P1 (nexus-ztpt6): a re-enqueue is a fresh request — it
-                // resets retry_count to 0, so it must also clear any stale backoff
-                // (next_retry_at) left by a prior mark_retry. Otherwise the claim
-                // gate would silently hold the re-enqueued row until the old
-                // backoff elapses (up to base*2^(cap-1) seconds).
-                .set(ASPECT_EXTRACTION_QUEUE.NEXT_RETRY_AT,   (OffsetDateTime) null)
-                .execute();
-            return null;
-        });
+        ensureCollectionRegistered(ctx, tenant, collection);
+        return ctx.insertInto(ASPECT_EXTRACTION_QUEUE,
+                ASPECT_EXTRACTION_QUEUE.TENANT_ID,
+                ASPECT_EXTRACTION_QUEUE.COLLECTION,
+                ASPECT_EXTRACTION_QUEUE.SOURCE_PATH,
+                ASPECT_EXTRACTION_QUEUE.DOC_ID,
+                ASPECT_EXTRACTION_QUEUE.CONTENT_HASH,
+                ASPECT_EXTRACTION_QUEUE.CONTENT,
+                ASPECT_EXTRACTION_QUEUE.STATUS,
+                ASPECT_EXTRACTION_QUEUE.RETRY_COUNT,
+                ASPECT_EXTRACTION_QUEUE.ENQUEUED_AT,
+                ASPECT_EXTRACTION_QUEUE.LAST_ATTEMPT_AT,
+                ASPECT_EXTRACTION_QUEUE.LAST_ERROR)
+            .values(
+                tenant, collection, sourcePath,
+                nullIfBlank((String) body.get("doc_id")),
+                (String) body.getOrDefault("content_hash", ""),
+                (String) body.getOrDefault("content", ""),
+                "pending", 0, enqueuedAtTs, null, null)
+            .onConflict(
+                ASPECT_EXTRACTION_QUEUE.TENANT_ID,
+                ASPECT_EXTRACTION_QUEUE.COLLECTION,
+                ASPECT_EXTRACTION_QUEUE.SOURCE_PATH)
+            .doUpdate()
+            // nexus-nyout: a doc_id-less re-enqueue (blank -> NULL via
+            // nullIfBlank; e.g. collection re-embed) must not erase an
+            // existing correct tumbler — COALESCE keeps the old linkage;
+            // a real incoming tumbler still overwrites. The queue IMPORT
+            // path stays verbatim EXCLUDED.doc_id: fidelity import
+            // reproduces exported rows exactly, including blanks.
+            .set(ASPECT_EXTRACTION_QUEUE.DOC_ID,
+                 coalesce(EX_Q_DOC_ID, ASPECT_EXTRACTION_QUEUE.DOC_ID))
+            .set(ASPECT_EXTRACTION_QUEUE.CONTENT_HASH,    EX_Q_CONTENT_HASH)
+            .set(ASPECT_EXTRACTION_QUEUE.CONTENT,         EX_Q_CONTENT)
+            .set(ASPECT_EXTRACTION_QUEUE.STATUS,          "pending")
+            .set(ASPECT_EXTRACTION_QUEUE.RETRY_COUNT,     0)
+            .set(ASPECT_EXTRACTION_QUEUE.ENQUEUED_AT,     EX_Q_ENQUEUED_AT)
+            .set(ASPECT_EXTRACTION_QUEUE.LAST_ATTEMPT_AT, (OffsetDateTime) null)
+            .set(ASPECT_EXTRACTION_QUEUE.LAST_ERROR,      (String) null)
+            // RDR-163 P1 (nexus-ztpt6): a re-enqueue is a fresh request — it
+            // resets retry_count to 0, so it must also clear any stale backoff
+            // (next_retry_at) left by a prior mark_retry. Otherwise the claim
+            // gate would silently hold the re-enqueued row until the old
+            // backoff elapses (up to base*2^(cap-1) seconds).
+            .set(ASPECT_EXTRACTION_QUEUE.NEXT_RETRY_AT,   (OffsetDateTime) null);
     }
 
     /**

{conexus-6.3.4 → conexus-6.3.6}/service/src/main/java/dev/nexus/service/http/AspectHandler.java

@@ -47,6 +47,7 @@ import java.util.Optional;
  *   POST  /v1/aspects/highlights/rename_collection rename collection denorm
 
  *   POST  /v1/aspects/queue/enqueue               enqueue document
+ *   POST  /v1/aspects/queue/enqueue_many          batch-enqueue N documents in ONE round trip (nexus-nj4ch)
  *   POST  /v1/aspects/queue/claim_next            atomically claim one pending row
  *   POST  /v1/aspects/queue/claim_batch           claim up to limit= pending rows
  *   POST  /v1/aspects/queue/mark_done             delete row on success
@@ -122,6 +123,7 @@ public final class AspectHandler implements HttpHandler {
                 case "/highlights/rename_collection"    -> handleHighlightRenameCollection(exchange, tenant, method);
                 // ── aspect_extraction_queue ───────────────────────────────────
                 case "/queue/enqueue"                   -> handleQueueEnqueue(exchange, tenant, method);
+                case "/queue/enqueue_many"               -> handleQueueEnqueueMany(exchange, tenant, method);
                 case "/queue/claim_next"                -> handleQueueClaimNext(exchange, tenant, method);
                 case "/queue/claim_batch"               -> handleQueueClaimBatch(exchange, tenant, method);
                 case "/queue/mark_done"                 -> handleQueueMarkDone(exchange, tenant, method);
@@ -485,6 +487,38 @@ public final class AspectHandler implements HttpHandler {
         HttpUtil.send(ex, 200, "{\"enqueued\":true}");
     }
 
+    /**
+     * POST /v1/aspects/queue/enqueue_many (nexus-nj4ch: batches the
+     * indexer's per-document aspect-extraction enqueue into ONE round
+     * trip, mirroring the catalog update_many/delete_many and vectors
+     * get-all-metadata pattern).
+     *
+     * <p>Body: {"rows": [{"collection": "...", "source_path": "...", ...}, ...]}
+     * (each row has the same shape as {@code /queue/enqueue}'s body).
+     * Response 200: {"enqueued": N} (count of rows actually enqueued;
+     * malformed rows -- missing collection/source_path -- are silently
+     * skipped, not counted, mirroring register_many's per-doc isolation).
+     *
+     * <p>A malformed *shape* (non-list body, non-object element) 400s
+     * rather than silently shrinking the input, mirroring
+     * handleManifestWriteMany / handleUpdateMany's validation pattern.
+     */
+    @SuppressWarnings("unchecked")
+    private void handleQueueEnqueueMany(HttpExchange ex, String tenant, String method) throws IOException {
+        if (!"POST".equals(method)) { HttpUtil.send(ex, 405, "{\"error\":\"POST required\"}"); return; }
+        Map<String, Object> body = readBody(ex);
+        Object raw = body.get("rows");
+        if (!(raw instanceof List<?> l)) {
+            HttpUtil.send(ex, 400, "{\"error\":\"'rows' must be a list\"}"); return;
+        }
+        if (l.stream().anyMatch(o -> !(o instanceof Map))) {
+            HttpUtil.send(ex, 400, "{\"error\":\"every 'rows' element must be an object\"}"); return;
+        }
+        List<Map<String, Object>> rows = l.stream().map(o -> (Map<String, Object>) o).toList();
+        int enqueued = repo.enqueueMany(tenant, rows);
+        HttpUtil.send(ex, 200, "{\"enqueued\":" + enqueued + "}");
+    }
+
     private void handleQueueClaimNext(HttpExchange ex, String tenant, String method) throws IOException {
         if (!"POST".equals(method)) { HttpUtil.send(ex, 405, "{\"error\":\"POST required\"}"); return; }
         Optional<Map<String, Object>> row = repo.claimNext(tenant);

{conexus-6.3.4 → conexus-6.3.6}/service/src/main/java/dev/nexus/service/http/VectorHandler.java

@@ -35,6 +35,7 @@ import java.util.Map;
  *   POST /v1/vectors/hybrid-search   pgvector hybrid fusion (tsvector+pg_trgm gate, vector rank) — RDR-155 P3
  *   POST /v1/vectors/store-put       single-chunk put (MCP store_put path)
  *   POST /v1/vectors/get             get chunks by metadata where-filter (incremental-sync staleness check)
+ *   POST /v1/vectors/get-all-metadata  ids+metadata for an ENTIRE collection in one round trip (nexus-duoak)
  *   POST /v1/vectors/store-get       fetch chunks by IDs (MCP store_get/store_get_many)
  *   POST /v1/vectors/store-list      list collection (MCP store_list)
  *   POST /v1/vectors/store-delete    delete by IDs (MCP store_delete)
@@ -125,6 +126,7 @@ public final class VectorHandler implements HttpHandler {
                 case "/search-graph-hop"       -> handleSearchGraphHop(exchange, method);        // RDR-156 P4 (houg9)
                 case "/store-put"     -> handleStorePut(exchange, method);
                 case "/get"           -> handleGet(exchange, method);
+                case "/get-all-metadata" -> handleGetAllMetadata(exchange, method);
                 case "/store-get"     -> handleStoreGet(exchange, method);
                 case "/get-embeddings" -> handleGetEmbeddings(exchange, method);
                 case "/store-list"    -> handleStoreList(exchange, method);
@@ -147,6 +149,14 @@ public final class VectorHandler implements HttpHandler {
         } catch (IllegalArgumentException e) {
             log.debug("event=vector_bad_request op={} error={}", op, e.getMessage());
             HttpUtil.send(exchange, 400, json(Map.of("error", e.getMessage())));
+        } catch (IllegalStateException e) {
+            // get-all-metadata's row-count cap (well-formed request, just too
+            // big for the single-round-trip fast path) — 422 distinguishes
+            // this from a malformed request (400) or a real server error
+            // (500); the Python client falls back to paginated /get on any
+            // non-2xx, so the exact code just needs to be non-2xx and logged.
+            log.debug("event=vector_get_all_metadata_row_cap_exceeded op={} error={}", op, e.getMessage());
+            HttpUtil.send(exchange, 422, json(Map.of("error", e.getMessage())));
         } catch (Exception e) {
             // Shared typed-DB-error ladder: pool-exhaustion 503 + class-23 409
             // (nexus-h8rf6.2 / nexus-7e057) — see HttpUtil.sendTypedDbError.
@@ -487,6 +497,33 @@ public final class VectorHandler implements HttpHandler {
         HttpUtil.send(ex, 200, json(result));
     }
 
+    /**
+     * POST /v1/vectors/get-all-metadata (nexus-duoak follow-up).
+     *
+     * <p>ids + metadata for EVERY chunk in a collection in ONE round trip —
+     * collapses the ``ceil(chunk_count / 300)`` client round trips the
+     * indexer's staleness-cache-build phase otherwise pays through paginated
+     * {@code /v1/vectors/get} calls. No {@code documents} field (staleness
+     * only needs metadata) and no pagination — see
+     * {@link PgVectorRepository#getAllMetadata}.
+     *
+     * <p>Request: {"collection": "...", "where": {...}}  (where optional)
+     * <p>Response 200: {"ids": [...], "metadatas": [...]}
+     * <p>Response 422: row count exceeds {@link PgVectorRepository#GET_ALL_METADATA_MAX_ROWS}
+     *   — caller falls back to paginated {@code /get}.
+     */
+    private void handleGetAllMetadata(HttpExchange ex, String method) throws IOException {
+        requireMethod(ex, method, "POST");
+        var repo   = requirePgRepo(ex);
+        var tenant = requireTenant(ex);
+        Map<String, Object> body = readBody(ex);
+        String collection         = requireString(body, "collection");
+        Map<String, Object> where = optMap(body, "where");
+
+        var result = repo.getAllMetadata(tenant, collection, where);
+        HttpUtil.send(ex, 200, json(result));
+    }
+
     /**
      * POST /v1/vectors/store-get
      *

{conexus-6.3.4 → conexus-6.3.6}/service/src/main/java/dev/nexus/service/vectors/PgVectorRepository.java

@@ -1457,6 +1457,74 @@ public final class PgVectorRepository {
         return getWhere(tenant, collection, where, limit, offset, false);
     }
 
+    /**
+     * Upper bound on rows a single {@link #getAllMetadata} call will return.
+     * Above this, the caller (indexer staleness-cache build) falls back to
+     * paginated {@code /v1/vectors/get} rather than the server materializing
+     * an unbounded response in memory.
+     */
+    public static final int GET_ALL_METADATA_MAX_ROWS = 200_000;
+
+    /**
+     * Fetch ids + metadata for EVERY chunk in *collection* in ONE round trip
+     * (nexus-duoak follow-up: staleness-cache-build phase). No {@code
+     * documents} column (staleness only needs metadata: {@code
+     * chunk_text_hash}, spans, {@code doc_id}) and no LIMIT/OFFSET — this
+     * collapses the ``ceil(chunk_count / 300)`` client round trips
+     * {@code build_staleness_cache}'s paginated {@code /v1/vectors/get} loop
+     * pays (measured: ~113s of the phase's ~116s total on this repo's own
+     * 24k-chunk {@code code__} collection) into ONE Postgres query + ONE
+     * HTTP response. Same rationale as the catalog {@code update_many}/
+     * {@code delete_many} batch endpoints: server-to-Postgres round trips
+     * are same-process and cheap; client-to-server round trips pay real
+     * network latency each time.
+     *
+     * <p>Capped at {@value #GET_ALL_METADATA_MAX_ROWS} rows — above that the
+     * caller should fall back to the paginated path rather than have the
+     * server materialize an unbounded result set in memory. Throws {@link
+     * IllegalStateException} when the cap is exceeded (fail loud, not a
+     * silent truncation — a caller silently getting a partial staleness
+     * cache would treat un-fetched rows as "unknown", which the existing
+     * cache-miss contract already treats as safely stale-and-reindex, but
+     * silently truncating without signaling would hide that this fast path
+     * degraded).
+     */
+    public Map<String, Object> getAllMetadata(String tenant, String collection,
+                                              Map<String, Object> where) {
+        int dim = dimForCollection(collection);
+        DimTables.ChunkTable ch = DimTables.CHUNKS.get(dim);
+        org.jooq.Condition cond = ch.collection().eq(collection);
+        if (where != null) {
+            for (Map.Entry<String, Object> e : where.entrySet()) {
+                cond = cond.and(metadataCondition(e.getKey(), e.getValue()));
+            }
+        }
+        org.jooq.Condition finalCond = cond;
+        var result = tenantScope.withTenant(tenant, ctx ->
+            ctx.select(ch.chash(), ch.metadata())
+               .from(ch.table())
+               .where(finalCond)
+               .orderBy(ch.chash().asc())
+               .limit(GET_ALL_METADATA_MAX_ROWS + 1)
+               .fetch());
+
+        if (result.size() > GET_ALL_METADATA_MAX_ROWS) {
+            throw new IllegalStateException(
+                "getAllMetadata: collection '" + collection + "' has more than "
+                + GET_ALL_METADATA_MAX_ROWS + " matching rows; caller must fall "
+                + "back to paginated /v1/vectors/get");
+        }
+
+        List<String> outIds = new ArrayList<>(result.size());
+        List<Map<String, Object>> outMetas = new ArrayList<>(result.size());
+        for (var rec : result) {
+            outIds.add(rec.value1());
+            JSONB meta = rec.value2();
+            outMetas.add(fromJson(meta != null ? meta.data() : null));
+        }
+        return new LinkedHashMap<>(Map.of("ids", outIds, "metadatas", outMetas));
+    }
+
     /**
      * List the collections visible to {@code tenant} (RDR-155 P4a.2,
      * bead nexus-1k8s1).

{conexus-6.3.4 → conexus-6.3.6}/service/src/test/java/dev/nexus/service/AspectRepositoryTest.java

@@ -129,7 +129,7 @@ class AspectRepositoryTest {
             // document_aspects doc_ids: "1.2.3" (makeAspect default), "2.4.6", "3.1.4"
             // document_highlights doc_ids: "highlight-1", "by-uri-doc", "list-hl-0", "list-hl-1",
             //   "del-highlight", "import-hl-1", "rls-hl-private", "hl-rename-doc-1", "hl-rename-doc-2", "hl-rls-doc"
-            // aspect_extraction_queue doc_ids: "q-doc-1", "done-doc-id-unique", "etl-q-doc"
+            // aspect_extraction_queue doc_ids: "q-doc-1", "done-doc-id-unique", "etl-q-doc", "many-doc-a"
             // (queue items without doc_id are doc_id=NULL — no FK entry needed)
             for (String tumbler : List.of(
                     "1.2.3", "2.4.6", "3.1.4",
@@ -140,7 +140,9 @@ class AspectRepositoryTest {
                     // nexus-1usso importHighlightsBatch multi-row conversion tests
                     "batch-hl-1", "batch-hl-2",
                     // nexus-nyout doc_id COALESCE-on-NULL tests
-                    "coalesce-doc-1", "coalesce-doc-2")) {
+                    "coalesce-doc-1", "coalesce-doc-2",
+                    // nexus-nj4ch enqueueMany batch tests
+                    "many-doc-a")) {
                 su.createStatement().execute(
                     "INSERT INTO nexus.catalog_documents (tenant_id, tumbler, title) " +
                     "VALUES ('" + TENANT_A + "', '" + tumbler + "', 'Test fixture: " + tumbler + "') " +
@@ -600,6 +602,72 @@ class AspectRepositoryTest {
             .isEqualTo("");
     }
 
+    @Test @Order(73)
+    void enqueueMany_batchesHeterogeneousRowsInOneRoundTrip() {
+        // nexus-nj4ch: replaces N serial enqueue() calls with one
+        // enqueueMany() batch — rows may carry DIFFERENT optional fields
+        // (doc_id present or absent), mirroring updateDocumentsMany's
+        // heterogeneous-SET-clause shape.
+        var rowA = new java.util.LinkedHashMap<String, Object>();
+        rowA.put("collection", "enqmany-coll");
+        rowA.put("source_path", "many-a.md");
+        rowA.put("doc_id", "many-doc-a");
+        var rowB = new java.util.LinkedHashMap<String, Object>();
+        rowB.put("collection", "enqmany-coll");
+        rowB.put("source_path", "many-b.md");
+        rowB.put("content", "content for b");
+
+        int n = repo.enqueueMany(TENANT_A, List.of(rowA, rowB));
+
+        assertThat(n).isEqualTo(2);
+        var pending = repo.listPending(TENANT_A, 100);
+        assertThat(pending.stream().map(r -> r.get("source_path")))
+            .contains("many-a.md", "many-b.md");
+        var rowAResult = pending.stream()
+            .filter(r -> "many-a.md".equals(r.get("source_path"))).findFirst().orElseThrow();
+        assertThat(rowAResult.get("doc_id")).isEqualTo("many-doc-a");
+    }
+
+    @Test @Order(74)
+    void enqueueMany_skipsMalformedRowsWithoutAbortingBatch() {
+        // A row missing collection/source_path must not sink the rest of
+        // the batch -- ghost-class isolation, mirroring register_many's
+        // per-doc failure tolerance.
+        var badRow = new java.util.LinkedHashMap<String, Object>();
+        badRow.put("collection", "");
+        badRow.put("source_path", "bad.md");
+        var goodRow = new java.util.LinkedHashMap<String, Object>();
+        goodRow.put("collection", "enqmany-skip-coll");
+        goodRow.put("source_path", "good.md");
+
+        int n = repo.enqueueMany(TENANT_A, List.of(badRow, goodRow));
+
+        assertThat(n).as("only the well-formed row counts").isEqualTo(1);
+        var pending = repo.listPending(TENANT_A, 100);
+        assertThat(pending.stream().map(r -> r.get("source_path"))).contains("good.md");
+    }
+
+    @Test @Order(75)
+    void enqueueMany_reEnqueue_resetsToPending() {
+        // Same ON CONFLICT DO UPDATE semantics as the single-row enqueue()
+        // path -- a batch re-enqueue at an existing key resets to pending.
+        var body = new java.util.LinkedHashMap<String, Object>();
+        body.put("collection", "enqmany-reenq-coll");
+        body.put("source_path", "reenq.md");
+        repo.enqueue(TENANT_A, body);
+        repo.claimNext(TENANT_A);
+
+        repo.enqueueMany(TENANT_A, List.of(body));
+
+        Optional<Map<String, Object>> reclaimed = repo.claimNext(TENANT_A);
+        assertThat(reclaimed).as("batch re-enqueue must be claimable again").isPresent();
+    }
+
+    @Test @Order(76)
+    void enqueueMany_emptyListIsNoop() {
+        assertThat(repo.enqueueMany(TENANT_A, List.of())).isEqualTo(0);
+    }
+
     @Test @Order(32)
     void markDone_byDocId_deletesRow() {
         var body = new java.util.LinkedHashMap<String, Object>();

{conexus-6.3.4 → conexus-6.3.6}/service/src/test/java/dev/nexus/service/PgVectorRepositoryContractTest.java

@@ -675,6 +675,79 @@ class PgVectorRepositoryContractTest {
             .containsExactly("gwa10000000000000000000000000000");
     }
 
+    @Test
+    void getAllMetadata_returnsEveryChunkInOneCall_noDocuments() {
+        // nexus-duoak follow-up: collapses the staleness-cache-build phase's
+        // paginated /get loop into one round trip. No "documents" key in the
+        // response -- staleness only needs metadata, keeping the payload lean.
+        String col = "code__getallmeta__voyage-code-3__v1";
+        embedder1024.register("gam a", 1.0f, 0.0f);
+        embedder1024.register("gam b", 0.8f, 0.6f);
+        embedder1024.register("gam c", 0.6f, 0.8f);
+        repo1024.upsertChunks(TENANT_A, col,
+            List.of("gama0000000000000000000000000000", "gamb0000000000000000000000000000",
+                    "gamc0000000000000000000000000000"),
+            List.of("gam a", "gam b", "gam c"),
+            List.of(Map.of("chunk_text_hash", "ha"), Map.of("chunk_text_hash", "hb"),
+                    Map.of("chunk_text_hash", "hc")));
+
+        var result = repo1024.getAllMetadata(TENANT_A, col, null);
+
+        assertThat(result).doesNotContainKey("documents");
+        @SuppressWarnings("unchecked")
+        List<String> ids = (List<String>) result.get("ids");
+        assertThat(ids).containsExactlyInAnyOrder(
+            "gama0000000000000000000000000000", "gamb0000000000000000000000000000",
+            "gamc0000000000000000000000000000");
+        @SuppressWarnings("unchecked")
+        List<Map<String, Object>> metas = (List<Map<String, Object>>) result.get("metadatas");
+        assertThat(metas).hasSize(3);
+        assertThat(metas).extracting(m -> m.get("chunk_text_hash"))
+            .containsExactlyInAnyOrder("ha", "hb", "hc");
+    }
+
+    @Test
+    void getAllMetadata_withWhere_filtersExactly() {
+        String col = "code__getallmetawhere__voyage-code-3__v1";
+        embedder1024.register("gamw a", 1.0f, 0.0f);
+        embedder1024.register("gamw b", 0.8f, 0.6f);
+        repo1024.upsertChunks(TENANT_A, col,
+            List.of("gawa0000000000000000000000000000", "gawb0000000000000000000000000000"),
+            List.of("gamw a", "gamw b"),
+            List.of(Map.of("kind", "a"), Map.of("kind", "b")));
+
+        @SuppressWarnings("unchecked")
+        List<String> ids = (List<String>) repo1024.getAllMetadata(
+            TENANT_A, col, Map.of("kind", "a")).get("ids");
+
+        assertThat(ids).containsExactly("gawa0000000000000000000000000000");
+    }
+
+    @Test
+    void getAllMetadata_scopedToTenant_noCrossTenantLeak() {
+        String col = "code__getallmetatenant__voyage-code-3__v1";
+        embedder1024.register("gamt a", 1.0f, 0.0f);
+        embedder1024.register("gamt b", 0.8f, 0.6f);
+        repo1024.upsertChunks(TENANT_A, col,
+            List.of("gata0000000000000000000000000000"), List.of("gamt a"), List.of(Map.of()));
+        repo1024.upsertChunks(TENANT_B, col,
+            List.of("gatb0000000000000000000000000000"), List.of("gamt b"), List.of(Map.of()));
+
+        @SuppressWarnings("unchecked")
+        List<String> idsA = (List<String>) repo1024.getAllMetadata(TENANT_A, col, null).get("ids");
+
+        assertThat(idsA).containsExactly("gata0000000000000000000000000000");
+    }
+
+    @Test
+    void getAllMetadata_emptyCollection_returnsEmptyLists() {
+        var result = repo1024.getAllMetadata(
+            TENANT_A, "code__getallmetaempty__voyage-code-3__v1", null);
+
+        assertThat((List<?>) result.get("ids")).isEmpty();
+        assertThat((List<?>) result.get("metadatas")).isEmpty();
+    }
+
     @Test
     void search_mixedDimCollections_failsLoud() {
         // COL_CODE_1024 dispatches to chunks_1024, COL_BGE_768 to chunks_768: one query