archgraph-argo 0.20.1 → 0.20.3

package/argo/scripts/graph-rag/defaultSemanticRetrieval.js

@@ -240,12 +240,12 @@ async function executeWpP2Retrieval({
   const lexicalTopK = hybridTopK();
   const fusionK = rrfK();
   const fusionWeights = hybridWeights();
-  const rerank = isRerankEnabled();
+  const rerank = isRerankEnabled() && request.rerank !== false;
   const rerankOptions = rerankConfig();
   const rerankProvider = rerank ? resolveRerankProvider(configurationEvidence.configuration) : null;
   // Rerank needs a larger candidate pool than the final top-K.
   const pool = rerank ? Math.max(topK, rerankOptions.poolSize) : topK;
-  const seedsByType = {};
+  const channelSeeds = [];
   for (const channel of CHANNELS) {
     const vectorSeeds = await exhaustChannel({
       channel,
@@ -266,17 +266,27 @@ async function executeWpP2Retrieval({
       });
       seeds = fuseChannelSeeds({ vectorSeeds, lexicalSeeds, k: fusionK, limit: Math.max(pool, lexicalTopK), weights: fusionWeights });
     }
-    if (rerank && seeds.length > 1) {
-      const ordered = await rerankCandidates({
-        query: request.intent,
-        candidates: seeds,
-        provider: rerankProvider,
-        transport: composition.transport,
-        maxReturn: rerankOptions.maxReturn,
-      });
-      // fail-open: a null/empty order keeps the original ordering
-      seeds = applyRerankOrder(seeds, ordered, topK);
-    }
+    channelSeeds.push({ channel, seeds });
+  }
+  if (rerank) {
+    // Rerank every channel CONCURRENTLY: the LLM calls dominate latency and are
+    // independent, so parallelizing turns the cost from sum(channels) into
+    // ~one call. fail-open: a null/empty order keeps the original ordering.
+    const rerankedSeeds = await Promise.all(channelSeeds.map(({ seeds }) => (
+      seeds.length > 1
+        ? rerankCandidates({
+          query: request.intent,
+          candidates: seeds,
+          provider: rerankProvider,
+          transport: composition.transport,
+          maxReturn: rerankOptions.maxReturn,
+        }).then(ordered => applyRerankOrder(seeds, ordered, topK))
+        : seeds
+    )));
+    channelSeeds.forEach((entry, index) => { entry.seeds = rerankedSeeds[index]; });
+  }
+  const seedsByType = {};
+  for (const { channel, seeds } of channelSeeds) {
     seedsByType[channel.key] = seeds;
   }
   return completeSemanticResult({
@@ -835,15 +845,26 @@ function scopeCanonicalIdentitiesForChannel(identities, channel) {
   });
 }
 
+// Semantic vector records store their canonicalIdentity channel-prefixed
+// (e.g. "Element:widget-1") so the scoped Cypher `node.canonicalIdentity IN
+// $canonicalIdentities` matches. Every consumer of a seed's `id` — purpose
+// closure anchors, provenance keys, and the canonical-subset score lookup —
+// however keys on the BARE canonical graph id. Expose the bare id as `id` and
+// keep the prefixed value as `canonicalIdentity` so a seed resolves against the
+// canonical graph instead of a phantom prefixed id.
+function bareCanonicalId(id) {
+  return String(id).replace(/^[^:]*:/, '');
+}
+
 function normalizeVectorRecord(raw, channel) {
   if (!raw || typeof raw !== 'object') return undefined;
-  const id = raw.canonicalIdentity || raw.id || raw.objectId;
+  const canonicalIdentity = raw.canonicalIdentity || raw.id || raw.objectId;
   const score = numberValue(raw.score);
-  if (!id || !Number.isFinite(score)) return undefined;
+  if (!canonicalIdentity || !Number.isFinite(score)) return undefined;
   return {
     ...raw,
-    id,
-    canonicalIdentity: id,
+    id: bareCanonicalId(canonicalIdentity),
+    canonicalIdentity,
     objectType: channel.objectType,
     channel: channel.channel,
     score,
@@ -1157,5 +1178,7 @@ module.exports = {
   auditThresholdFor,
   resolveTopK,
   scopeCanonicalIdentitiesForChannel,
+  bareCanonicalId,
+  normalizeVectorRecord,
   AUDIT_PURPOSES,
 };

package/argo/scripts/graph-rag/rerankRetrieval.js

@@ -6,9 +6,18 @@
 // the caller keeps the original ordering. Pure helpers are exported for tests.
 
 const DEFAULT_RERANK_MODEL = 'qwen-turbo';
+// Candidate pool size. The pool is the recall CEILING: a target the seed stage
+// ranks outside the pool can never be recovered by rerank, so it must NOT be
+// shrunk for speed. Keep the original 20. With DeepSeek thinking disabled a
+// single rerank call is ~flat across candidate counts (8-40 all ~1s), so a
+// larger pool costs ~nothing -- never trade recall for latency here.
 const DEFAULT_RERANK_POOL = 20;
 const DEFAULT_RERANK_RETURN = 8;
-const DEFAULT_RERANK_TIMEOUT_MS = 8000;
+// Per-call timeout. Channel reranks run concurrently, so the end-to-end rerank
+// cost is ~one timeout, not N. 3.5s keeps the whole semantic query under ~5s
+// while still letting typical calls (1-4s) complete; slower calls fail open to
+// the pre-rerank (fused) order. Overridable via ARGO_SEMANTIC_RERANK_TIMEOUT_MS.
+const DEFAULT_RERANK_TIMEOUT_MS = 3500;
 
 function rerankTimeoutMs(env = process.env) {
   const value = Number(env && env.ARGO_SEMANTIC_RERANK_TIMEOUT_MS);
@@ -110,6 +119,11 @@ async function rerankCandidates({ query, candidates, provider, transport, maxRet
     model,
     temperature: 0,
     response_format: { type: 'json_object' },
+    // DeepSeek's default is a "thinking" model: for a listwise ranking it spends
+    // 5k-10k reasoning tokens per call (measured 6-12s, highly variable) with no
+    // accuracy gain. Disable thinking for a fast, deterministic rerank
+    // (deepseek-flash: ~6s -> ~0.7s, reasoning tokens -> 0).
+    ...(provider.provider === 'deepseek' ? { thinking: { type: 'disabled' } } : {}),
     messages: [
       { role: 'system', content: 'You rank architecture elements by relevance to a query. Return ONLY JSON {"order":[ids best-first]} using only the candidate ids.' },
       { role: 'user', content: `Query: ${query}\n\nCandidates (id\\ttext):\n${list.map(candidate => `${candidate.id}\t${candidateText(candidate)}`).join('\n')}\n\nReturn up to ${Math.min(maxReturn || DEFAULT_RERANK_RETURN, list.length)} ids best-first.` },

package/argo/scripts/systemarchitecture-mcp-server.js

@@ -2801,7 +2801,7 @@ async function buildSemanticDedupAdvisory(context, mutations, dependencies) {
       const intent = [element.type, element.name, element.description]
         .filter(part => typeof part === 'string' && part.trim() !== '')
         .join(' ');
-      const retrieved = await journey.query({ purpose: 'general', intent, topK: SEMANTIC_DEDUP_TOP_K });
+      const retrieved = await journey.query({ purpose: 'general', intent, topK: SEMANTIC_DEDUP_TOP_K, rerank: false });
       const source = retrieved && (retrieved.result || retrieved.document) || retrieved;
       const subset = buildCanonicalSemanticDocumentSubset(source, context.document);
       const elements = subset && subset.status === 'passed' && subset.document
@@ -3462,7 +3462,11 @@ function buildCanonicalSemanticDocumentSubset(source, canonicalDocument = undefi
     if (!item) continue;
     const numericScore = Number(item.semanticScore);
     if (!Number.isFinite(numericScore)) continue;
-    const key = String(item.id !== undefined ? item.id : item.view_id);
+    // Evidence ids may still carry the channel prefix (real Neo4j shape); the
+    // seed-score map and canonical lookups are keyed on the bare canonical id,
+    // so normalize before comparing (otherwise the rank-derived score lands on
+    // a phantom prefixed key and the tiny fused RRF score wins for the element).
+    const key = String(item.id !== undefined ? item.id : item.view_id).replace(/^[^:]*:/, '');
     if (key && (!semanticScoreById.has(key) || numericScore > semanticScoreById.get(key))) {
       semanticScoreById.set(key, numericScore);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archgraph-argo",
-  "version": "0.20.1",
+  "version": "0.20.3",
   "description": "Deploy the ArchGraph ARGO toolchain, skills, and rules (schema, scripts, argo-init skill, global rule) with one command.",
   "license": "MIT",
   "bin": {