@vellumai/assistant 0.7.1 → 0.7.2

package/src/memory/context-search/agent-protocol.ts

@@ -4,13 +4,13 @@ import type { RecallEvidence, RecallSource } from "./types.js";
 
 export type RecallAgentConfidence = "high" | "medium" | "low";
 
-export interface RecallAgentToolDefinition {
+interface RecallAgentToolDefinition {
   name: string;
   description: string;
   input_schema: Record<string, unknown>;
 }
 
-export interface RecallAgentPromptOptions {
+interface RecallAgentPromptOptions {
   query: string;
   availableSources?: readonly RecallSource[];
   evidence: readonly RecallEvidence[];
@@ -18,7 +18,7 @@ export interface RecallAgentPromptOptions {
   maxSearchCalls?: number;
 }
 
-export interface RecallAgentPromptBundle {
+interface RecallAgentPromptBundle {
   prompt: string;
   evidence: RecallEvidence[];
 }
@@ -30,14 +30,14 @@ export interface RecallAgentFinish {
   unresolved?: string[];
 }
 
-export type RecallFinishFallbackReason =
+type RecallFinishFallbackReason =
   | "malformed_finish_payload"
   | "invalid_confidence"
   | "invalid_citation_ids"
   | "unknown_citation_ids"
   | "empty_answer";
 
-export type RecallFinishValidationResult =
+type RecallFinishValidationResult =
   | { ok: true; finish: RecallAgentFinish }
   | {
       ok: false;
@@ -46,7 +46,7 @@ export type RecallFinishValidationResult =
       missingCitationIds?: string[];
     };
 
-export interface RecallCitationValidationResult {
+interface RecallCitationValidationResult {
   ok: boolean;
   validCitationIds: string[];
   missingCitationIds: string[];

package/src/memory/context-search/agent-runner.ts

@@ -5,6 +5,7 @@ import type {
   ProviderResponse,
   ToolUseContent,
 } from "../../providers/types.js";
+import { redactSecrets } from "../../security/secret-scanner.js";
 import {
   buildRecallAgentPromptBundle,
   FINISH_RECALL_TOOL_DEFINITION,
@@ -42,7 +43,7 @@ import type {
   RecallSource,
 } from "./types.js";
 
-export type AgenticRecallFallbackReason =
+type AgenticRecallFallbackReason =
   | "no_provider"
   | "provider_error"
   | "timeout"
@@ -51,7 +52,7 @@ export type AgenticRecallFallbackReason =
   | "citation_validation_failed"
   | "finish_answer_validation_failed";
 
-export interface AgenticRecallSearchDebug {
+interface AgenticRecallSearchDebug {
   round: number;
   query: string;
   sources: RecallSource[];
@@ -61,7 +62,7 @@ export interface AgenticRecallSearchDebug {
   error?: string;
 }
 
-export interface AgenticRecallInspectDebug {
+interface AgenticRecallInspectDebug {
   round: number;
   paths: string[];
   reason: string;
@@ -69,7 +70,7 @@ export interface AgenticRecallInspectDebug {
   errors?: Array<{ path: string; reason: string }>;
 }
 
-export interface AgenticRecallDebug {
+interface AgenticRecallDebug {
   mode: "agentic" | "deterministic_fallback";
   normalizedInput: NormalizedRecallInput;
   roundLimit: number;
@@ -86,12 +87,12 @@ export interface AgenticRecallDebug {
   fallbackDetail?: string;
 }
 
-export interface AgenticRecallAnswer extends RecallAnswer {
+interface AgenticRecallAnswer extends RecallAnswer {
   content: string;
   debug: AgenticRecallDebug;
 }
 
-export interface RunAgenticRecallOptions {
+interface RunAgenticRecallOptions {
   searchOptions?: DeterministicRecallSearchOptions;
 }
 
@@ -414,6 +415,30 @@ export async function runAgenticRecall(
   );
 }
 
+/**
+ * Redact secrets from workspace-sourced evidence excerpts before they are
+ * serialised into a prompt that will be sent to an external LLM provider.
+ *
+ * Memory, PKB, and conversation evidence is already controlled content —
+ * only workspace files can contain arbitrary secrets (API keys, tokens, etc.)
+ * written by the user or by tools. This runs the same pattern-based scanner
+ * used for shell command summaries and approval prompts, replacing any
+ * detected secrets with `<redacted type="…" />` markers.
+ *
+ * The original evidence array is not mutated; citations and local fallback
+ * paths continue to reference unredacted values.
+ */
+export function redactWorkspaceEvidence(
+  evidence: readonly RecallEvidence[],
+): readonly RecallEvidence[] {
+  return evidence.map((item) => {
+    if (item.source !== "workspace") return item;
+    const redacted = redactSecrets(item.excerpt);
+    if (redacted === item.excerpt) return item;
+    return { ...item, excerpt: redacted };
+  });
+}
+
 function buildPromptBundle(
   input: NormalizedRecallInput,
   evidence: readonly RecallEvidence[],
@@ -422,7 +447,7 @@ function buildPromptBundle(
   return buildRecallAgentPromptBundle({
     query: input.query,
     availableSources: input.sources,
-    evidence,
+    evidence: redactWorkspaceEvidence(evidence),
     maxSearchCalls: roundLimit,
   });
 }

package/src/memory/context-search/sources/memory-v2.ts

@@ -62,11 +62,20 @@ export function isMemoryV2ReadActive(config: AssistantConfig): boolean {
 const log = getLogger("context-search-memory-v2-source");
 
 /**
- * Top-K size for the un-restricted ANN candidate query against the v2
- * concept-page collection. Larger than the per-call recall limit so spreading
- * has neighbors to pull in.
+ * Sentinel passed to Qdrant when `config.memory.v2.ann_candidate_limit` is
+ * `null` (unlimited). Qdrant's query API requires an explicit numeric
+ * `limit`, so unlimited is represented as a number large enough that any
+ * realistic concept-page collection is returned in full.
+ *
+ * Why not `Number.MAX_SAFE_INTEGER`: Qdrant's sparse-vector `SearchContext`
+ * pre-allocates `limit * 16` bytes per query, so passing `MAX_SAFE_INTEGER`
+ * triggers a ~144 PB allocation and SIGABRTs the Qdrant process. 1_000_000
+ * is ~16 MB of pre-allocation in Qdrant — generous headroom over realistic
+ * concept-page counts (low thousands today) while staying well clear of
+ * the OOM cliff. Bump explicitly via `ann_candidate_limit` if you ever
+ * outgrow it.
  */
-const MEMORY_V2_ANN_CANDIDATE_LIMIT = 50;
+const UNLIMITED_ANN_CANDIDATE_LIMIT = 1_000_000;
 
 /** Cap individual concept-page files we are willing to read for lexical scan. */
 const MEMORY_V2_LEXICAL_MAX_FILE_SIZE_BYTES = 256 * 1024;
@@ -181,10 +190,13 @@ async function activationEvidence(
   if (!denseVector || denseVector.length === 0) return [];
   const sparseVector = generateSparseEmbedding(trimmedQuery);
 
+  const annLimit =
+    context.config.memory.v2.ann_candidate_limit ??
+    UNLIMITED_ANN_CANDIDATE_LIMIT;
   const hits = await hybridQueryConceptPages(
     denseVector,
     sparseVector,
-    MEMORY_V2_ANN_CANDIDATE_LIMIT,
+    annLimit,
   );
   if (hits.length === 0) return [];
 

package/src/memory/conversation-crud.ts

@@ -32,7 +32,7 @@ import {
   deleteOrphanAttachments,
   linkAttachmentToMessage,
 } from "./attachments-store.js";
-import { AUTO_ANALYSIS_SOURCE } from "./auto-analysis-guard.js";
+import { AUTO_ANALYSIS_SOURCE } from "./auto-analysis-constants.js";
 import {
   projectAssistantMessage,
   seedForkedConversationAttention,

package/src/memory/conversation-key-store.ts

@@ -7,20 +7,15 @@
  * first contact.
  */
 
-import { existsSync, unlinkSync } from "node:fs";
-
 import { eq } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getLogger } from "../util/logger.js";
-import { getWorkspacePromptPath } from "../util/platform.js";
+import { cleanupBootstrapFiles } from "../prompts/bootstrap-cleanup.js";
 import { initConversationDir } from "./conversation-disk-view.js";
 import { GENERATING_TITLE } from "./conversation-title-service.js";
 import { getDb } from "./db-connection.js";
 import { conversationKeys, conversations } from "./schema.js";
 
-const log = getLogger("conversation-key-store");
-
 /** Set after the first conversation is created so BOOTSTRAP.md is deleted on the second. */
 let firstConversationSeen = false;
 
@@ -204,15 +199,7 @@ export function getOrCreateConversation(
     // for its entire duration. Any subsequent conversation means
     // onboarding is over.
     if (firstConversationSeen) {
-      const bp = getWorkspacePromptPath("BOOTSTRAP.md");
-      if (existsSync(bp)) {
-        try {
-          unlinkSync(bp);
-          log.info("Deleted BOOTSTRAP.md — onboarding conversation ended");
-        } catch {
-          // Best-effort
-        }
-      }
+      cleanupBootstrapFiles("new conversation created after onboarding");
     }
     firstConversationSeen = true;
 

package/src/memory/db-init.ts

@@ -102,6 +102,7 @@ import {
   migrateGuardianTimestampsEpochMs,
   migrateGuardianVerificationPurpose,
   migrateGuardianVerificationSessions,
+  migrateHeartbeatRuns,
   migrateInviteCodeHashColumn,
   migrateInviteContactId,
   migrateLlmRequestLogMessageId,
@@ -153,6 +154,7 @@ import {
   migrateRenameVoiceToPhone,
   migrateScheduleOneShotRouting,
   migrateScheduleQuietFlag,
+  migrateScheduleRetryPolicy,
   migrateScheduleReuseConversation,
   migrateScheduleScriptColumn,
   migrateScheduleWakeConversationId,
@@ -401,9 +403,11 @@ export function initializeDb(): void {
     migrateLlmUsageAttribution,
     migrateSlackCompactionWatermark,
     migrateToolInvocationsMatchedRuleId,
+    migrateHeartbeatRuns,
     function migrateBackfillAppConversationIds() {
       backfillAppConversationIds();
     },
+    migrateScheduleRetryPolicy,
   ];
 
   // Run each migration step, catching and logging individual failures so one

package/src/memory/embedding-backend.ts

@@ -21,6 +21,7 @@ import {
   type SparseEmbedding,
   type TextEmbeddingInput,
 } from "./embedding-types.js";
+import { SPARSE_VOCAB_SIZE, tokenHash, tokenize } from "./sparse-tokenize.js";
 
 export type { EmbeddingInput, MultimodalEmbeddingInput, TextEmbeddingInput };
 
@@ -787,31 +788,18 @@ async function isOllamaConfigured(config: AssistantConfig): Promise<boolean> {
 // Simple tokenizer + TF-IDF sparse encoder. Produces a SparseEmbedding
 // with term indices (hashed to a fixed vocabulary) and TF-IDF weights.
 // Can be upgraded to a learned sparse encoder (e.g. SPLADE) later.
-
-const SPARSE_VOCAB_SIZE = 30_000;
+// Tokenization primitives (`tokenize`, `tokenHash`, `SPARSE_VOCAB_SIZE`) live
+// in `./sparse-tokenize.ts` so the BM25 encoder can share them without
+// transitively depending on this module.
 
 /**
  * Bump this version whenever the sparse embedding algorithm changes
- * (e.g. hash function fix, tokenizer change) to trigger re-indexing
- * of existing sparse vectors via the sentinel mismatch mechanism.
+ * (e.g. hash function fix, tokenizer change). Now inert metadata — the v1
+ * Qdrant sentinel was decoupled from this constant, so a bump no longer
+ * forces an automatic rebuild. Operators must explicitly run
+ * `assistant memory v2 reembed` to rematerialize the v2 sparse index.
  */
-export const SPARSE_EMBEDDING_VERSION = 2;
-
-/** Tokenize text into lowercase alphanumeric tokens (Unicode-aware). */
-function tokenize(text: string): string[] {
-  return text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
-}
-
-/** Hash a token to a stable index in [0, vocabSize). */
-function tokenHash(token: string, vocabSize: number): number {
-  // FNV-1a 32-bit hash for speed
-  let hash = 0x811c9dc5;
-  for (let i = 0; i < token.length; i++) {
-    hash ^= token.charCodeAt(i);
-    hash = Math.imul(hash, 0x01000193) >>> 0;
-  }
-  return hash % vocabSize;
-}
+export const SPARSE_EMBEDDING_VERSION = 4;
 
 /**
  * Generate a TF-IDF-based sparse embedding for the given text.

package/src/memory/graph/__tests__/conversation-graph-memory-v2-routing.test.ts

@@ -333,16 +333,54 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
 
     expect(result.mode).toBe("per-turn");
     expect(result.injectedBlockText).not.toBeNull();
-    expect(result.injectedBlockText).toContain("<memory>");
+    expect(result.injectedBlockText).not.toContain("<memory>");
     expect(result.injectedBlockText).toContain("### alice-vscode");
 
-    // The leading content block on the user message is the v2 block.
+    // The leading content block on the user message is the v2 block,
+    // wrapped exactly once.
     const lastMsg = result.runMessages[result.runMessages.length - 1];
     expect(lastMsg?.role).toBe("user");
     const firstBlock = lastMsg?.content[0];
     expect(firstBlock?.type).toBe("text");
     if (firstBlock?.type !== "text") throw new Error("unexpected block type");
-    expect(firstBlock.text).toContain("<memory>");
+    expect(firstBlock.text.startsWith("<memory>\n")).toBe(true);
+    expect(firstBlock.text.endsWith("\n</memory>")).toBe(true);
+    // No nested wrapper.
+    expect(firstBlock.text.match(/<memory>/g)?.length).toBe(1);
+  });
+
+  test("reinjectCachedMemory after v2 injection wraps exactly once (no double-wrap)", async () => {
+    // Regression for the double-wrap bug: v2 cached `lastInjectedBlock`
+    // already wrapped, then `reinjectCachedMemory` re-wrapped via
+    // `injectTextBlock`, producing `<memory>\n<memory>\n...\n</memory>\n</memory>`.
+    _setOverridesForTesting({ "memory-v2-enabled": true });
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = makeMemory();
+    const config = makeConfig(true);
+    const messages = makeMessages("Tell me about Alice's editor preferences");
+
+    const initial = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+    expect(initial.injectedBlockText).not.toBeNull();
+
+    // Simulate post-compaction: caller re-runs `applyRuntimeInjections`
+    // (which strips memory injections) and then asks for the cached
+    // memory to be re-prepended.
+    const reinjected = memory.reinjectCachedMemory(messages);
+    const lastMsg = reinjected.runMessages[reinjected.runMessages.length - 1];
+    const firstBlock = lastMsg?.content[0];
+    expect(firstBlock?.type).toBe("text");
+    if (firstBlock?.type !== "text") throw new Error("unexpected block type");
+    expect(firstBlock.text.startsWith("<memory>\n")).toBe(true);
+    expect(firstBlock.text.endsWith("\n</memory>")).toBe(true);
+    expect(firstBlock.text.match(/<memory>/g)?.length).toBe(1);
+    expect(firstBlock.text.match(/<\/memory>/g)?.length).toBe(1);
+    expect(firstBlock.text).toContain("### alice-vscode");
   });
 
   test("flag on + config on with empty Qdrant hits → no v2 block, v1 fallback skipped", async () => {
@@ -384,7 +422,14 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load pat
 
     expect(result.mode).toBe("context-load");
     expect(result.injectedBlockText).not.toBeNull();
-    expect(result.injectedBlockText).toContain("<memory>");
+    expect(result.injectedBlockText).toContain("### alice-vscode");
+    // injectedBlockText is the unwrapped inner content; the wrapper is
+    // applied at injection time on the run message.
+    expect(result.injectedBlockText).not.toContain("<memory>");
+    const lastMsg = result.runMessages[result.runMessages.length - 1];
+    const firstBlock = lastMsg?.content[0];
+    if (firstBlock?.type !== "text") throw new Error("unexpected block type");
+    expect(firstBlock.text.match(/<memory>/g)?.length).toBe(1);
   });
 
   test("flag off → v2 not run on first turn either", async () => {

package/src/memory/graph/conversation-graph-memory.ts

@@ -691,7 +691,7 @@ export class ConversationGraphMemory {
 
     return {
       routed: true,
-      runMessages: prependMemoryV2Block(messages, result.block),
+      runMessages: injectTextBlock(messages, result.block),
       injectedBlockText: result.block,
     };
   }
@@ -881,26 +881,3 @@ function readRawUserText(message: Message | undefined): string | null {
   if (texts.length === 0) return null;
   return texts.join(" ");
 }
-
-/**
- * Prepend a pre-rendered `<memory>` block (produced by
- * `injectMemoryV2Block`) to the last user message. Unlike v1's
- * {@link injectMemoryBlock}, the input here is already wrapped — we
- * just need to attach it as a leading text block. We still strip any
- * pre-existing memory injections first so the layer is idempotent
- * across compaction-driven re-injection.
- */
-function prependMemoryV2Block(messages: Message[], block: string): Message[] {
-  if (block.trim().length === 0) return messages;
-  if (messages.length === 0) return messages;
-  const cleaned = stripExistingMemoryInjections(messages);
-  const userTail = cleaned[cleaned.length - 1];
-  if (!userTail || userTail.role !== "user") return messages;
-  return [
-    ...cleaned.slice(0, -1),
-    {
-      ...userTail,
-      content: [{ type: "text" as const, text: block }, ...userTail.content],
-    },
-  ];
-}

package/src/memory/graph/graph-search.ts

@@ -2,8 +2,10 @@
 // Memory Graph — Qdrant vector search for graph nodes
 // ---------------------------------------------------------------------------
 
+import { getConfig } from "../../config/loader.js";
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
+import { isMemoryV2ReadActive } from "../context-search/sources/memory-v2.js";
 import { selectedBackendSupportsMultimodal } from "../embedding-backend.js";
 import type { EmbeddingInput } from "../embedding-types.js";
 import { embedAndUpsert } from "../job-utils.js";
@@ -48,6 +50,12 @@ export async function searchGraphNodes(
   dateRange?: { afterMs?: number; beforeMs?: number },
   excludeScopeIds?: string[],
 ): Promise<GraphSearchResult[]> {
+  // v2 owns the read path when both gates are on. The v1 `memory` collection
+  // is in active retirement and a corrupted sparse segment can OOM-crash the
+  // shared Qdrant process — short-circuiting here keeps v1 background work
+  // and stale callers from taking v2 down with them.
+  if (isMemoryV2ReadActive(getConfig())) return [];
+
   if (isQdrantBreakerOpen()) {
     log.warn("Qdrant circuit breaker open, skipping graph search");
     return [];

package/src/memory/graph/retriever.ts

@@ -14,6 +14,7 @@ import {
 } from "../../providers/provider-send-message.js";
 import type { ContentBlock, ImageContent } from "../../providers/types.js";
 import { getLogger } from "../../util/logger.js";
+import { isMemoryV2ReadActive } from "../context-search/sources/memory-v2.js";
 import { embedWithRetry } from "../embed.js";
 import {
   generateSparseEmbedding,
@@ -425,6 +426,33 @@ export interface ContextLoadResult {
 export async function loadContextMemory(
   opts: ContextLoadOpts,
 ): Promise<ContextLoadResult> {
+  // v2 owns the read path when both gates are on. The v1 collection is in
+  // active retirement and querying it can OOM-crash Qdrant via a corrupted
+  // sparse segment, so we skip the embedding work and downstream searches
+  // entirely. Caller (`runContextLoad`) sees zero nodes and routes to the
+  // v2 activation pipeline.
+  if (isMemoryV2ReadActive(opts.config)) {
+    return {
+      nodes: [],
+      serendipityNodes: [],
+      triggeredNodes: [],
+      latencyMs: 0,
+      metrics: {
+        semanticHits: 0,
+        mergedCount: 0,
+        selectedCount: 0,
+        tier1Count: 0,
+        tier2Count: 0,
+        hybridSearchLatencyMs: 0,
+        sparseVectorUsed: false,
+        embeddingProvider: null,
+        embeddingModel: null,
+        queryContext: null,
+        topCandidates: [],
+      },
+    };
+  }
+
   const start = Date.now();
   const ctxLoadCfg = opts.config.memory.retrieval.injection.contextLoad;
   const maxNodes = opts.maxNodes ?? ctxLoadCfg.maxNodes;

package/src/memory/graph/tools.ts

@@ -76,7 +76,7 @@ export const graphRememberDefinition: ToolDefinition = {
       finish_turn: {
         type: "boolean",
         description:
-          "Set to true ONLY on the final `remember` call when you have nothing else to say and want to hand control back to the user. When true, the assistant turn ends after this tool call and no further LLM call is made. Do NOT set true on intermediate `remember` calls. Default: false.",
+          "When you have nothing else to say and want to hand control back to the user you MUST set this to true. When true, your turn ends after this tool call. It's critical that you do this in order to avoid unnecessary LLM calls.",
       },
     },
     required: ["content"],

package/src/memory/jobs/__tests__/embed-concept-page.test.ts

@@ -103,6 +103,12 @@ mock.module("../../v2/qdrant.js", () => ({
   deleteConceptPageEmbedding: async (slug: string) => {
     deleteCalls.push(slug);
   },
+  // Other exports from the real module — stubbed so transitive imports
+  // don't crash on missing names when the mock replaces the module wholesale.
+  hybridQueryConceptPages: async () => [],
+  _resetMemoryV2QdrantForTests: () => {},
+  ensureConceptPageCollection: async () => {},
+  MEMORY_V2_COLLECTION: "memory_v2_concept_pages",
 }));
 
 // ── Workspace setup ────────────────────────────────────────────────
@@ -321,7 +327,7 @@ describe("enqueueEmbedConceptPageJob", () => {
     const id = enqueueEmbedConceptPageJob({ slug: "alice-prefers-vs-code" });
     expect(id).toBeTruthy();
 
-    const claimed = claimMemoryJobs(10);
+    const claimed = claimMemoryJobs({ slowLlm: 10, fast: 10, embed: 10 });
     expect(claimed).toHaveLength(1);
     const [job] = claimed;
     expect(job.type).toBe("embed_concept_page");
@@ -337,7 +343,7 @@ describe("enqueueEmbedConceptPageJob", () => {
 
     enqueueEmbedConceptPageJob({ slug: "round-trip-slug" });
 
-    const claimed = claimMemoryJobs(10);
+    const claimed = claimMemoryJobs({ slowLlm: 10, fast: 10, embed: 10 });
     expect(claimed).toHaveLength(1);
     const [job] = claimed;
     expect(job.type).toBe("embed_concept_page");

package/src/memory/jobs/embed-concept-page.ts

@@ -24,6 +24,7 @@ import type { AssistantConfig } from "../../config/types.js";
 import { BackendUnavailableError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
+import { applyCorrectionIfCalibrated } from "../anisotropy.js";
 import { getDb } from "../db-connection.js";
 import {
   embedWithBackend,
@@ -39,6 +40,10 @@ import {
   deleteConceptPageEmbedding,
   upsertConceptPageEmbedding,
 } from "../v2/qdrant.js";
+import {
+  generateBm25DocEmbedding,
+  getConceptPageCorpusStats,
+} from "../v2/sparse-bm25.js";
 
 const log = getLogger("memory-v2-embed-concept-page");
 
@@ -141,7 +146,17 @@ export async function embedConceptPageJob(
 
   // Sparse is cheap (in-process tokenization) and changes any time the body
   // changes, so we always recompute it rather than caching alongside dense.
-  const sparse = generateSparseEmbedding(text);
+  // BM25 weights live on the doc side; queries embed binary occurrence in
+  // sim.ts. When corpus stats aren't built yet (cold daemon, walking the
+  // corpus for the first time), fall back to the legacy TF-only encoding —
+  // the next reembed pass overwrites the page once stats are available.
+  const corpusStats = getConceptPageCorpusStats();
+  const sparse = corpusStats
+    ? generateBm25DocEmbedding(text, corpusStats, {
+        k1: config.memory.v2.bm25_k1,
+        b: config.memory.v2.bm25_b,
+      })
+    : generateSparseEmbedding(text);
 
   const now = Date.now();
   // Persist freshly embedded vectors for cross-restart reuse. On cache hit
@@ -189,9 +204,20 @@ export async function embedConceptPageJob(
     }
   }
 
+  // Apply anisotropy correction at the boundary between the (raw) cached
+  // dense vector and the Qdrant collection. Storing raw in SQLite and
+  // corrected in Qdrant means a recalibration just needs a reembed pass —
+  // the cache survives and the (cheap) correction math reruns over each
+  // cached vector. Pass-through when no calibration is fit yet.
+  const correctedDense = await applyCorrectionIfCalibrated(
+    dense,
+    provider,
+    model,
+  );
+
   await upsertConceptPageEmbedding({
     slug,
-    dense,
+    dense: correctedDense,
     sparse,
     updatedAt: now,
   });

package/src/memory/jobs/embed-pkb-file.test.ts

@@ -134,7 +134,7 @@ describe("enqueuePkbIndexJob", () => {
     });
     expect(id).toBeTruthy();
 
-    const claimed = claimMemoryJobs(10);
+    const claimed = claimMemoryJobs({ slowLlm: 10, fast: 10, embed: 10 });
     expect(claimed).toHaveLength(1);
     const [job] = claimed;
     const expectedType: MemoryJobType = "embed_pkb_file";
@@ -153,7 +153,7 @@ describe("enqueuePkbIndexJob", () => {
       memoryScopeId: "scope-rt",
     });
 
-    const claimed = claimMemoryJobs(10);
+    const claimed = claimMemoryJobs({ slowLlm: 10, fast: 10, embed: 10 });
     expect(claimed).toHaveLength(1);
     const [job] = claimed;
     expect(job.type).toBe("embed_pkb_file");