@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/plugins/defaults/memory/v2/reranker.ts

@@ -5,8 +5,8 @@ import { createHash } from "node:crypto";
 import type { AssistantConfig } from "../../../../config/types.js";
 import { getLogger } from "../logging.js";
 import { getWorkspaceDir } from "../paths.js";
-import { getOrCreateRerankBackend } from "../rerank-local.js";
-import { readPage } from "../v3/substrate/page-store.js";
+import { readPage } from "../substrate/page-store.js";
+import { getOrCreateRerankBackend } from "./rerank-local.js";
 
 const log = getLogger("memory-v2-reranker");
 
@@ -36,13 +36,17 @@ function cacheKey(
 
 function evictExpired(now: number): void {
   for (const [k, v] of cache) {
-    if (now - v.ts > CACHE_TTL_MS) cache.delete(k);
+    if (now - v.ts > CACHE_TTL_MS) {
+      cache.delete(k);
+    }
   }
   if (cache.size > CACHE_MAX_ENTRIES) {
     const toDrop = cache.size - CACHE_MAX_ENTRIES;
     let i = 0;
     for (const k of cache.keys()) {
-      if (i++ >= toDrop) break;
+      if (i++ >= toDrop) {
+        break;
+      }
       cache.delete(k);
     }
   }
@@ -77,8 +81,12 @@ export async function rerankCandidates(
   candidates: readonly string[],
   config: AssistantConfig,
 ): Promise<Array<Map<string, number>>> {
-  if (queries.length === 0) return [];
-  if (candidates.length === 0) return queries.map(() => new Map());
+  if (queries.length === 0) {
+    return [];
+  }
+  if (candidates.length === 0) {
+    return queries.map(() => new Map());
+  }
 
   const { model, dtype } = config.memory.v2.rerank;
   const now = Date.now();
@@ -107,7 +115,9 @@ export async function rerankCandidates(
   const finalize = (): Array<Map<string, number>> =>
     results.map((r) => r ?? new Map());
 
-  if (uncachedIndices.length === 0) return finalize();
+  if (uncachedIndices.length === 0) {
+    return finalize();
+  }
 
   const workspaceDir = getWorkspaceDir();
   const pages = await Promise.all(
@@ -122,13 +132,17 @@ export async function rerankCandidates(
   const slugsForPassages: string[] = [];
   for (let i = 0; i < candidates.length; i++) {
     const page = pages[i];
-    if (!page) continue;
+    if (!page) {
+      continue;
+    }
     passages.push(buildPassage(candidates[i], page.body));
     slugsForPassages.push(candidates[i]);
   }
 
   if (passages.length === 0) {
-    for (const i of uncachedIndices) results[i] = new Map();
+    for (const i of uncachedIndices) {
+      results[i] = new Map();
+    }
     return finalize();
   }
 
@@ -154,7 +168,9 @@ export async function rerankCandidates(
       { err, model, n: batchPassages.length },
       "Rerank backend failed; falling back to pure fused scores",
     );
-    for (const i of uncachedIndices) results[i] = new Map();
+    for (const i of uncachedIndices) {
+      results[i] = new Map();
+    }
     return finalize();
   }
 
@@ -164,7 +180,9 @@ export async function rerankCandidates(
     const result = new Map<string, number>();
     for (let i = 0; i < slugsForPassages.length; i++) {
       const s = scores[offset + i];
-      if (typeof s !== "number" || Number.isNaN(s)) continue;
+      if (typeof s !== "number" || Number.isNaN(s)) {
+        continue;
+      }
       // sigmoid output should already be in [0, 1]; clamp defensively.
       result.set(slugsForPassages[i], Math.max(0, Math.min(1, s)));
     }

package/src/plugins/defaults/memory/v2/router.ts

@@ -47,14 +47,14 @@ import {
   type ToolDefinition,
 } from "../llm-helpers.js";
 import { getLogger } from "../logging.js";
-import type { PageIndex } from "../v3/substrate/page-index.js";
+import type { PageIndex } from "../substrate/page-index.js";
 import {
   getPageIndex,
   partitionPageIndex,
   splitTier1,
   splitTier2,
-} from "../v3/substrate/page-index.js";
-import type { EverInjectedEntry } from "../v3/substrate/types.js";
+} from "../substrate/page-index.js";
+import type { EverInjectedEntry } from "../substrate/types.js";
 import { computeInjectionScores } from "./injection-events.js";
 import { resolveRouterPrompt } from "./prompts/router.js";
 
@@ -285,8 +285,12 @@ export async function runRouter(
   // Tag each batch with its provenance string. Tier 3 batches carry their
   // bucket index so the inspector can attribute selections per-bucket.
   const taggedBatches: Array<{ source: RouterSource; index: PageIndex }> = [];
-  if (tier1) taggedBatches.push({ source: "tier1", index: tier1 });
-  if (tier2) taggedBatches.push({ source: "tier2", index: tier2 });
+  if (tier1) {
+    taggedBatches.push({ source: "tier1", index: tier1 });
+  }
+  if (tier2) {
+    taggedBatches.push({ source: "tier2", index: tier2 });
+  }
   tier3Batches.forEach((index, i) => {
     taggedBatches.push({ source: `tier3:${i}` as const, index });
   });
@@ -322,7 +326,9 @@ export async function runRouter(
     const result = batchResults[i];
     const source = taggedBatches[i].source;
     for (const slug of result.selectedSlugs) {
-      if (sourceBySlug.has(slug)) continue;
+      if (sourceBySlug.has(slug)) {
+        continue;
+      }
       sourceBySlug.set(slug, source);
       selectedSlugs.push(slug);
     }
@@ -354,7 +360,9 @@ export async function runRouter(
         "Router union across batches exceeded max_page_ids; truncating",
       );
       const dropped = selectedSlugs.splice(maxPageIds);
-      for (const slug of dropped) sourceBySlug.delete(slug);
+      for (const slug of dropped) {
+        sourceBySlug.delete(slug);
+      }
     }
   }
   return { selectedSlugs, sourceBySlug, failureReason: null };
@@ -402,7 +410,9 @@ async function runRouterBatch(
   const priorIds: number[] = [];
   for (const entry of priorEverInjected) {
     const local = batchIndex.bySlug.get(entry.slug);
-    if (local) priorIds.push(local.id);
+    if (local) {
+      priorIds.push(local.id);
+    }
   }
 
   // Trim the pairs down to the configured `<last_turn>` content budget,
@@ -513,7 +523,9 @@ async function runRouterBatch(
   const selectedSlugs: string[] = [];
   for (const id of finalIds) {
     const entry = batchIndex.byId.get(id);
-    if (!entry) continue;
+    if (!entry) {
+      continue;
+    }
     selectedSlugs.push(entry.slug);
   }
 
@@ -542,7 +554,9 @@ export function applyHistoricalCharBudget(
   pairs: readonly RouterTurnPair[],
   maxChars: number | null,
 ): RouterTurnPair[] {
-  if (maxChars === null || maxChars <= 0) return [...pairs];
+  if (maxChars === null || maxChars <= 0) {
+    return [...pairs];
+  }
 
   type WalkedMsg = {
     role: "user" | "assistant";
@@ -566,7 +580,9 @@ export function applyHistoricalCharBudget(
   const included = new Map<number, { assistant: string; user: string }>();
   for (const msg of walked) {
     const remaining = maxChars - used;
-    if (remaining <= 0) break;
+    if (remaining <= 0) {
+      break;
+    }
     let textToInclude: string;
     let stop = false;
     if (msg.text.length <= remaining) {
@@ -577,17 +593,24 @@ export function applyHistoricalCharBudget(
       // connects to the next message (in chronological order) without
       // a syntactic seam. The marker counts toward the budget so the
       // emitted text never exceeds `maxChars` cumulatively.
-      if (remaining <= HISTORICAL_TRUNCATION_MARKER.length) break;
+      if (remaining <= HISTORICAL_TRUNCATION_MARKER.length) {
+        break;
+      }
       const keepChars = remaining - HISTORICAL_TRUNCATION_MARKER.length;
       textToInclude = HISTORICAL_TRUNCATION_MARKER + msg.text.slice(-keepChars);
       used = maxChars;
       stop = true;
     }
     const slot = included.get(msg.pairIdx) ?? { assistant: "", user: "" };
-    if (msg.role === "user") slot.user = textToInclude;
-    else slot.assistant = textToInclude;
+    if (msg.role === "user") {
+      slot.user = textToInclude;
+    } else {
+      slot.assistant = textToInclude;
+    }
     included.set(msg.pairIdx, slot);
-    if (stop) break;
+    if (stop) {
+      break;
+    }
   }
 
   const sortedIdxs = [...included.keys()].sort((a, b) => a - b);

package/src/plugins/defaults/memory/v3/__tests__/candidate-match.test.ts

@@ -44,8 +44,8 @@ let simBatchImpl: (
   text: string,
   slugs: readonly string[],
 ) => Promise<Map<string, number>> = async () => new Map();
-const realSim = await import("../substrate/sim.js");
-mock.module("../substrate/sim.js", () => ({
+const realSim = await import("../../substrate/sim.js");
+mock.module("../../substrate/sim.js", () => ({
   ...realSim,
   simBatch: (text: string, slugs: readonly string[]) =>
     simBatchImpl(text, slugs),
@@ -262,7 +262,9 @@ describe("nearestExistingSkills — default scorer retries transient failures",
     let calls = 0;
     simBatchImpl = async (_text, slugs) => {
       calls++;
-      if (calls === 1) throw transientError();
+      if (calls === 1) {
+        throw transientError();
+      }
       // Second attempt succeeds: the skill's capability page scores high.
       return new Map(
         slugs

package/src/plugins/defaults/memory/v3/__tests__/carry-integration.test.ts

@@ -62,13 +62,13 @@ import { ensureMemoryV3SelectionsSchema } from "../../../../../persistence/migra
 import { ensureMemoryV3EverInjectedSchema } from "../../../../../persistence/migrations/345-move-memory-v3-ever-injected-to-memory-db.js";
 import * as schema from "../../../../../persistence/schema/index.js";
 import { unwrapMemoryBlock, wrapMemoryBlock } from "../../memory-marker.js";
+import type { PageIndexEntry } from "../../substrate/page-index.js";
 import { cardBytes, renderCard } from "../card.js";
 import { loadCoreSet } from "../core-set.js";
 import type { EdgeGraph } from "../edge.js";
 import { buildEdgeGraph } from "../edge.js";
 import { buildSectionNeedle } from "../section-needle.js";
 import { buildSectionIndex } from "../sections.js";
-import type { PageIndexEntry } from "../substrate/page-index.js";
 import {
   MEMORY_V3_COMMIT_META_KEY,
   type SectionIndex,
@@ -490,7 +490,9 @@ function candidateSlugs(messages: Message[]): Slug[] {
   const entries: Array<{ id: number; slug: string }> = [];
   for (const msg of messages) {
     for (const block of msg.content) {
-      if (block.type !== "text") continue;
+      if (block.type !== "text") {
+        continue;
+      }
       const cards = /<candidate_cards>\n([\s\S]*?)\n<\/candidate_cards>/.exec(
         block.text,
       );
@@ -507,7 +509,9 @@ function candidateSlugs(messages: Message[]): Slug[] {
       if (finder) {
         for (const line of finder[1].split("\n")) {
           const m = /^\[(\d+)\] (?:\([^)]*\) )?(\S+)(?: — |$)/.exec(line);
-          if (m) entries.push({ id: Number(m[1]), slug: m[2]! });
+          if (m) {
+            entries.push({ id: Number(m[1]), slug: m[2]! });
+          }
         }
       }
     }
@@ -530,7 +534,9 @@ function makeProviderStub(): Provider {
       );
       const ids: number[] = [];
       candidateSlugs(messages).forEach((slug, i) => {
-        if (keep.includes(slug)) ids.push(i + 1);
+        if (keep.includes(slug)) {
+          ids.push(i + 1);
+        }
       });
       return toolUseResponse({ ids });
     },
@@ -614,13 +620,16 @@ async function runTurn(
 
   const activeBefore = getActiveSlugs(convId);
   const cards = await memoryV3Injector.produce(ctx);
-  if (!cards)
+  if (!cards) {
     throw new Error(`turn ${turnIndex}: cards injector returned null`);
+  }
   // Runtime assembly invokes the block's attachment-commit callback at its
   // user-tail commit point — this is where the everInjected store records
   // the turn's cards (and the prune valve is scheduled).
   const commit = cards.meta?.[MEMORY_V3_COMMIT_META_KEY];
-  if (typeof commit === "function") (commit as () => void)();
+  if (typeof commit === "function") {
+    (commit as () => void)();
+  }
   const netNewSlugs = [...getActiveSlugs(convId)].filter(
     (slug) => !activeBefore.has(slug),
   );
@@ -883,7 +892,9 @@ beforeAll(async () => {
 afterAll(async () => {
   await flushPruneValveForTests();
   carryMockActive = false;
-  if (workspaceDir) rmSync(workspaceDir, { recursive: true, force: true });
+  if (workspaceDir) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
 });
 
 // ---------------------------------------------------------------------------
@@ -993,7 +1004,9 @@ describe("memory-v3 carry integration — cache contract", () => {
     let expected = 0;
     for (const record of records) {
       expected += record.netNewBytes;
-      if (record.turn === 7) expected -= pruneWindow.bytesFreedExpected;
+      if (record.turn === 7) {
+        expected -= pruneWindow.bytesFreedExpected;
+      }
       expect(record.residentBytes).toBe(expected);
     }
   });

package/src/plugins/defaults/memory/v3/__tests__/edge.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
+import type { PageIndexEntry } from "../../substrate/page-index.js";
 import { buildEdgeGraph, edgeExpand } from "../edge.js";
-import type { PageIndexEntry } from "../substrate/page-index.js";
 import type { Slug } from "../types.js";
 
 /** Minimal page-index entry factory — only the fields the edge lane reads. */

package/src/plugins/defaults/memory/v3/__tests__/live-integration.test.ts

@@ -35,12 +35,12 @@ import { ensureMemoryV3SelectionsSchema } from "../../../../../persistence/migra
 import { ensureMemoryV3EverInjectedSchema } from "../../../../../persistence/migrations/345-move-memory-v3-ever-injected-to-memory-db.js";
 import * as schema from "../../../../../persistence/schema/index.js";
 import { wrapMemoryBlock } from "../../memory-marker.js";
+import type { PageIndexEntry } from "../../substrate/page-index.js";
 import { cardBytes, renderCard } from "../card.js";
 import type { EdgeGraph } from "../edge.js";
 import { buildEdgeGraph } from "../edge.js";
 import { buildSectionNeedle } from "../section-needle.js";
 import { buildSectionIndex } from "../sections.js";
-import type { PageIndexEntry } from "../substrate/page-index.js";
 import type { MemoryRoutingTurn, SectionIndex, Slug } from "../types.js";
 
 // ---------------------------------------------------------------------------

package/src/plugins/defaults/memory/v3/__tests__/maintain-job.test.ts

@@ -7,6 +7,7 @@ import { EmbeddingBackendUnavailableError } from "../../../../../persistence/emb
 import { EmbeddingBillingBlockError } from "../../../../../persistence/embeddings/embedding-billing-breaker.js";
 import type { MemoryJob } from "../../../../../persistence/jobs-store.js";
 import type { SkillInstallMeta } from "../../../../../skills/install-meta.js";
+import { skillSlugFor } from "../../substrate/skill-store.js";
 import { renderCapabilityBody } from "../capabilities.js";
 import {
   backfillAllSections,
@@ -17,7 +18,6 @@ import {
   type MaintainJobDeps,
 } from "../maintain-job.js";
 import { buildSectionIndex } from "../sections.js";
-import { skillSlugFor } from "../substrate/skill-store.js";
 import type { Section, SectionIndex, Slug } from "../types.js";
 
 // The skill usage-prune stage reads `memory.maintenance.skillPruneDays`; default
@@ -36,6 +36,9 @@ const CONFIG = makeConfig();
 let memoryV3LiveSlot = false;
 mock.module("../../../../../config/memory-v3-gate.js", () => ({
   isMemoryV3Live: () => memoryV3LiveSlot,
+  isV3TierActive: () => memoryV3LiveSlot,
+  isMemoryEnabled: (config?: { memory?: { enabled?: boolean } }) =>
+    config?.memory?.enabled !== false,
   usesConceptPageMemory: (memory?: {
     enabled?: boolean;
     v2?: { enabled?: boolean };

package/src/plugins/defaults/memory/v3/__tests__/orchestrate.test.ts

@@ -32,6 +32,7 @@ import {
   MEMORY_CONTEXT_PHASE_KEY,
   TurnLatencyTracker,
 } from "../../../../../daemon/turn-latency-tracker.js";
+import type { PageIndexEntry } from "../../substrate/page-index.js";
 import { renderCard } from "../card.js";
 import type { EdgeGraph } from "../edge.js";
 import { buildEdgeGraph } from "../edge.js";
@@ -39,7 +40,6 @@ import type { V3GateConfig } from "../gate.js";
 import type { OrchestrateDeps } from "../orchestrate.js";
 import { buildSectionNeedle } from "../section-needle.js";
 import { buildSectionIndex } from "../sections.js";
-import type { PageIndexEntry } from "../substrate/page-index.js";
 import type { MemoryRoutingTurn, SectionIndex, Slug } from "../types.js";
 
 // ---------------------------------------------------------------------------
@@ -71,6 +71,12 @@ mock.module("../../../../../util/logger.js", () => ({
 const realDense = { ...(await import("../dense.js")) };
 let denseMockActive = false;
 let denseHits: Array<{ article: Slug; section: number; score?: number }> = [];
+// Per-query hit override for tests that need the full-message and span-chunk
+// dense calls to return DIFFERENT results; falls back to `denseHits`.
+let denseHitsByQuery = new Map<
+  string,
+  Array<{ article: Slug; section: number; score?: number }>
+>();
 let denseCalls: Array<{ query: string; k: number }> = [];
 mock.module("../dense.js", () => ({
   ...realDense,
@@ -79,7 +85,7 @@ mock.module("../dense.js", () => ({
       return realDense.denseLane(...args);
     }
     denseCalls.push({ query: args[1], k: args[2] });
-    return args[2] <= 0 ? [] : denseHits;
+    return args[2] <= 0 ? [] : (denseHitsByQuery.get(args[1]) ?? denseHits);
   },
   // Orchestrate now calls the SCORED variant; the mock must intercept it too
   // (else the `...realDense` spread resolves the real lane and hits Qdrant).
@@ -94,7 +100,10 @@ mock.module("../dense.js", () => ({
     denseCalls.push({ query: args[1], k: args[2] });
     return args[2] <= 0
       ? []
-      : denseHits.map((h) => ({ ...h, score: h.score ?? 1 }));
+      : (denseHitsByQuery.get(args[1]) ?? denseHits).map((h) => ({
+          ...h,
+          score: h.score ?? 1,
+        }));
   },
 }));
 
@@ -330,6 +339,7 @@ beforeEach(() => {
   watchdogMockActive = true;
   providerStub = null;
   denseHits = [];
+  denseHitsByQuery = new Map();
   denseCalls = [];
   recordedGateEvents = [];
   recordedSelectionEvents = [];
@@ -1753,3 +1763,171 @@ describe("latency sub-spans", () => {
     }
   });
 });
+
+// ---------------------------------------------------------------------------
+// Span-query pass: the dense lane re-run over the current message's clause
+// chunks as separate queries at `spanQueryK`, union-additive into the pool.
+// ---------------------------------------------------------------------------
+
+describe("orchestrate — span-query pass", () => {
+  const TWO_CHUNK_MESSAGE =
+    "apple appears in the first sentence here. elderberry shows up in the second sentence.";
+  const CHUNK_1 = "apple appears in the first sentence here.";
+  const CHUNK_2 = "elderberry shows up in the second sentence.";
+
+  test("spanQueryK omitted (default) runs no span dense calls", async () => {
+    const lanes = await buildLanes();
+
+    await orchestrate(
+      makeTurn(1, TWO_CHUNK_MESSAGE),
+      depsOf(lanes, { denseK: 100, selectorEnabled: false }),
+    );
+
+    expect(denseCalls).toEqual([{ query: TWO_CHUNK_MESSAGE, k: 100 }]);
+  });
+
+  test("span pass is inert when denseK=0", async () => {
+    const lanes = await buildLanes();
+
+    await orchestrate(
+      makeTurn(1, TWO_CHUNK_MESSAGE),
+      depsOf(lanes, { denseK: 0, spanQueryK: 7, selectorEnabled: false }),
+    );
+
+    expect(denseCalls).toEqual([]);
+  });
+
+  test("single-chunk message skips the span pass", async () => {
+    const lanes = await buildLanes();
+
+    await orchestrate(
+      makeTurn(1, "apple in one single sentence."),
+      depsOf(lanes, { denseK: 100, spanQueryK: 7, selectorEnabled: false }),
+    );
+
+    expect(denseCalls).toEqual([
+      { query: "apple in one single sentence.", k: 100 },
+    ]);
+  });
+
+  test("multi-chunk message adds span-lane candidates additively", async () => {
+    const lanes = await buildLanes();
+    // Full-message dense (and any chunk without an override) returns topic-b;
+    // chunk 1 re-surfaces topic-a (already a needle hit — attribution must
+    // stay "needle"); chunk 2 surfaces topic-d, which no other lane reaches
+    // ("grape" is not in the message, and the topic-a → topic-d curated edge
+    // must not re-surface an already-seen slug).
+    denseHits = [{ article: "topic-b", section: 0 }];
+    denseHitsByQuery.set(CHUNK_1, [{ article: "topic-a", section: 1 }]);
+    denseHitsByQuery.set(CHUNK_2, [{ article: "topic-d", section: 0 }]);
+
+    const result = await orchestrate(
+      makeTurn(1, TWO_CHUNK_MESSAGE),
+      depsOf(lanes, { denseK: 100, spanQueryK: 7, selectorEnabled: false }),
+    );
+
+    expect(denseCalls).toEqual([
+      { query: TWO_CHUNK_MESSAGE, k: 100 },
+      { query: CHUNK_1, k: 7 },
+      { query: CHUNK_2, k: 7 },
+    ]);
+    const laneOf = new Map(
+      result.lanes.finder.map((c) => [c.slug, c.lane] as const),
+    );
+    // "apple"/"elderberry" needle hits keep their lanes; the full-message
+    // dense hit keeps "dense"; only the genuinely span-surfaced page tags
+    // "span".
+    expect(laneOf.get("topic-a")).toBe("needle");
+    expect(laneOf.get("topic-c")).toBe("needle");
+    expect(laneOf.get("topic-b")).toBe("dense");
+    expect(laneOf.get("topic-d")).toBe("span");
+    expect(result.lanes.finder.filter((c) => c.slug === "topic-a").length).toBe(
+      1,
+    );
+    // The span hit's matched section is recorded for injection/spotlight.
+    expect(result.matchedSections.get("topic-d")?.article).toBe("topic-d");
+    expect(result.matchedSections.get("topic-d")?.text).toContain(
+      "lead for topic d",
+    );
+    // Additive: the span-only page joins the passthrough selections alongside
+    // every other lane's candidates.
+    expect(new Set(result.selections.map((s) => s.slug))).toEqual(
+      new Set(["topic-a", "topic-b", "topic-c", "topic-d"]),
+    );
+  });
+
+  test("an article hit by several chunks records its highest-scoring section", async () => {
+    const lanes = await buildLanes();
+    // Both chunks surface topic-d; the EARLIER chunk's hit is the weaker one.
+    // Chunk order must not decide the recorded section — the strong match
+    // (ordinal 1, `## Notes`) wins over the lead (ordinal 0).
+    denseHits = [];
+    denseHitsByQuery.set(CHUNK_1, [
+      { article: "topic-d", section: 0, score: 0.2 },
+    ]);
+    denseHitsByQuery.set(CHUNK_2, [
+      { article: "topic-d", section: 1, score: 0.9 },
+    ]);
+
+    const result = await orchestrate(
+      makeTurn(1, TWO_CHUNK_MESSAGE),
+      depsOf(lanes, { denseK: 100, spanQueryK: 7, selectorEnabled: false }),
+    );
+
+    expect(result.matchedSections.get("topic-d")?.ordinal).toBe(1);
+    expect(result.matchedSections.get("topic-d")?.text).toContain("grape");
+    expect(
+      result.lanes.finder.filter((c) => c.slug === "topic-d"),
+    ).toHaveLength(1);
+  });
+
+  test("a strictly stronger span cosine upgrades a dense-recorded section, keeping the lane", async () => {
+    const lanes = await buildLanes();
+    // Full-message dense records topic-b's lead (ordinal 0) at cosine 0.4;
+    // chunk 2 finds `## More` (ordinal 1) at 0.9 — same encoder and
+    // collection, strictly stronger, so the recorded section and finder
+    // descriptor upgrade while the lane attribution stays "dense".
+    denseHits = [{ article: "topic-b", section: 0, score: 0.4 }];
+    denseHitsByQuery.set(CHUNK_2, [
+      { article: "topic-b", section: 1, score: 0.9 },
+    ]);
+
+    const result = await orchestrate(
+      makeTurn(1, TWO_CHUNK_MESSAGE),
+      depsOf(lanes, { denseK: 100, spanQueryK: 7, selectorEnabled: false }),
+    );
+
+    expect(result.matchedSections.get("topic-b")?.ordinal).toBe(1);
+    expect(result.matchedSections.get("topic-b")?.text).toContain(
+      "cherry date",
+    );
+    const entry = result.lanes.finder.find((c) => c.slug === "topic-b");
+    expect(entry?.lane).toBe("dense");
+    expect(entry?.descriptor).toContain("cherry date");
+  });
+
+  test("weaker span hits and needle-recorded sections are not overridden", async () => {
+    const lanes = await buildLanes();
+    // topic-b: span cosine 0.3 < full-message 0.4 — the lead stays recorded.
+    // topic-a: needle recorded the `## Details` match; span scores are not
+    // comparable to BM25, so the span hit must not touch it.
+    denseHits = [{ article: "topic-b", section: 0, score: 0.4 }];
+    denseHitsByQuery.set(CHUNK_1, [
+      { article: "topic-a", section: 0, score: 0.99 },
+    ]);
+    denseHitsByQuery.set(CHUNK_2, [
+      { article: "topic-b", section: 1, score: 0.3 },
+    ]);
+
+    const result = await orchestrate(
+      makeTurn(1, TWO_CHUNK_MESSAGE),
+      depsOf(lanes, { denseK: 100, spanQueryK: 7, selectorEnabled: false }),
+    );
+
+    expect(result.matchedSections.get("topic-b")?.ordinal).toBe(0);
+    expect(result.matchedSections.get("topic-a")?.text).toContain("apple");
+    expect(result.lanes.finder.find((c) => c.slug === "topic-a")?.lane).toBe(
+      "needle",
+    );
+  });
+});

package/src/plugins/defaults/memory/v3/__tests__/selection-log-store.test.ts

@@ -403,6 +403,7 @@ describe("summarizeSelections", () => {
       dense: 0,
       edge: 2,
       reply: 0,
+      span: 0,
       learned: 0,
       entity: 0,
     });
@@ -421,6 +422,7 @@ describe("summarizeSelections", () => {
         dense: 0,
         edge: 0,
         reply: 0,
+        span: 0,
         learned: 0,
         entity: 0,
       },
@@ -443,6 +445,7 @@ describe("summarizeSelections", () => {
         dense: 0,
         edge: 0,
         reply: 0,
+        span: 0,
         learned: 0,
         entity: 0,
       },