@vellumai/assistant 0.7.1 → 0.7.2

package/src/memory/qdrant-client.ts

@@ -73,19 +73,31 @@ export interface QdrantSearchResult {
   payload: QdrantPointPayload;
 }
 
+/**
+ * Strip a trailing `:sparse-v<digits>` segment from a sentinel string.
+ *
+ * Legacy v1 sentinels (pre-decouple) included the sparse encoder version in
+ * the embedding-model identity. The suffix is no longer written, but stored
+ * sentinels written by older daemons may still carry it — strip it before
+ * comparing identities so existing collections aren't unnecessarily rebuilt.
+ */
+export function stripLegacySparseSuffix(sentinel: string): string {
+  return sentinel.replace(/:sparse-v\d+$/, "");
+}
+
 let _instance: VellumQdrantClient | null = null;
 
 export function getQdrantClient(): VellumQdrantClient {
   if (!_instance) {
     throw new Error(
-      "Qdrant client not initialized. Call initQdrantClient() first."
+      "Qdrant client not initialized. Call initQdrantClient() first.",
     );
   }
   return _instance;
 }
 
 export function initQdrantClient(
-  config: QdrantClientConfig
+  config: QdrantClientConfig,
 ): VellumQdrantClient {
   _instance = new VellumQdrantClient(config);
   return _instance;
@@ -140,12 +152,28 @@ export class VellumQdrantClient {
           const dimMismatch =
             currentSize != null && currentSize !== this.vectorSize;
 
-          // Check model identity via a sentinel point that stores the embedding model
+          // Check model identity via a sentinel point that stores the embedding model.
+          //
+          // Legacy sentinels included a ":sparse-v<N>" suffix that conflated the
+          // sparse encoder version with the dense model identity. Sparse vectors
+          // are upserted in place and never require collection recreation, so a
+          // stored value matching the current dense identity after stripping any
+          // legacy sparse suffix is treated as compatible. Compatible-but-legacy
+          // sentinels are rewritten to the new format below to clean up gradually.
           let modelMismatch = false;
+          let needsSentinelRewrite = false;
           if (this.embeddingModel) {
             const sentinel = await this.readSentinel();
-            if (sentinel && sentinel !== this.embeddingModel) {
-              modelMismatch = true;
+            if (sentinel) {
+              const normalizedStored = stripLegacySparseSuffix(sentinel);
+              const normalizedCurrent = stripLegacySparseSuffix(
+                this.embeddingModel,
+              );
+              if (normalizedStored !== normalizedCurrent) {
+                modelMismatch = true;
+              } else if (sentinel !== this.embeddingModel) {
+                needsSentinelRewrite = true;
+              }
             }
           }
 
@@ -156,7 +184,7 @@ export class VellumQdrantClient {
                 currentSize,
                 expectedSize: this.vectorSize,
               },
-              "Qdrant collection uses unnamed vectors (legacy) — deleting and recreating with named vectors. Embeddings will be re-indexed."
+              "Qdrant collection uses unnamed vectors (legacy) — deleting and recreating with named vectors. Embeddings will be re-indexed.",
             );
             await this.client.deleteCollection(this.collection);
             migrated = true;
@@ -169,7 +197,7 @@ export class VellumQdrantClient {
                 expectedSize: this.vectorSize,
                 modelMismatch,
               },
-              "Qdrant collection incompatible (dimension or model change) — deleting and recreating. Embeddings will be regenerated on demand."
+              "Qdrant collection incompatible (dimension or model change) — deleting and recreating. Embeddings will be regenerated on demand.",
             );
             await this.client.deleteCollection(this.collection);
             migrated = true;
@@ -178,12 +206,15 @@ export class VellumQdrantClient {
             if (await this.ensurePayloadIndexesSafe()) {
               this.collectionReady = true;
             }
+            if (needsSentinelRewrite && this.embeddingModel) {
+              await this.writeSentinel(this.embeddingModel);
+            }
             return { migrated: false };
           }
         } catch (err) {
           log.warn(
             { err },
-            "Failed to verify collection compatibility, assuming compatible"
+            "Failed to verify collection compatibility, assuming compatible",
           );
           if (await this.ensurePayloadIndexesSafe()) {
             this.collectionReady = true;
@@ -197,7 +228,7 @@ export class VellumQdrantClient {
 
     log.info(
       { collection: this.collection, vectorSize: this.vectorSize },
-      "Creating Qdrant collection with named vectors (dense + sparse)"
+      "Creating Qdrant collection with named vectors (dense + sparse)",
     );
 
     try {
@@ -253,7 +284,7 @@ export class VellumQdrantClient {
       this.collectionReady = true;
       log.info(
         { collection: this.collection },
-        "Qdrant collection created with payload indexes"
+        "Qdrant collection created with payload indexes",
       );
     }
 
@@ -265,7 +296,7 @@ export class VellumQdrantClient {
     targetId: string,
     vector: number[],
     payload: Omit<QdrantPointPayload, "target_type" | "target_id">,
-    sparseVector?: QdrantSparseVector
+    sparseVector?: QdrantSparseVector,
   ): Promise<string> {
     await this.ensureCollection();
 
@@ -320,7 +351,7 @@ export class VellumQdrantClient {
   async search(
     vector: number[],
     limit: number,
-    filter?: Record<string, unknown>
+    filter?: Record<string, unknown>,
   ): Promise<QdrantSearchResult[]> {
     await this.ensureCollection();
 
@@ -348,7 +379,7 @@ export class VellumQdrantClient {
     return results.map((result) => ({
       id: typeof result.id === "string" ? result.id : String(result.id),
       score: result.score,
-      payload: (result.payload as unknown) as QdrantPointPayload,
+      payload: result.payload as unknown as QdrantPointPayload,
     }));
   }
 
@@ -357,7 +388,7 @@ export class VellumQdrantClient {
     limit: number,
     targetTypes: Array<"segment" | "item" | "summary" | "media">,
     excludeMessageIds?: string[],
-    scopeIds?: string[]
+    scopeIds?: string[],
   ): Promise<QdrantSearchResult[]> {
     const mustConditions: Array<Record<string, unknown>> = [
       {
@@ -434,7 +465,7 @@ export class VellumQdrantClient {
     const queryParams = {
       prefetch: [
         {
-          query: (denseVector as unknown) as number[],
+          query: denseVector as unknown as number[],
           using: "dense",
           limit: effectivePrefetchLimit,
         },
@@ -469,7 +500,7 @@ export class VellumQdrantClient {
     return (results.points ?? []).map((point) => ({
       id: typeof point.id === "string" ? point.id : String(point.id),
       score: point.score ?? 0,
-      payload: (point.payload as unknown) as QdrantPointPayload,
+      payload: point.payload as unknown as QdrantPointPayload,
     }));
   }
 
@@ -594,7 +625,7 @@ export class VellumQdrantClient {
     } catch (err) {
       log.warn(
         { err, collection: this.collection },
-        "Failed to delete Qdrant collection"
+        "Failed to delete Qdrant collection",
       );
       return false;
     }
@@ -762,8 +793,7 @@ export class VellumQdrantClient {
           ...(offset !== undefined ? { offset } : {}),
         });
         for (const point of result.points) {
-          const id =
-            typeof point.id === "string" ? point.id : String(point.id);
+          const id = typeof point.id === "string" ? point.id : String(point.id);
           const payload = (point.payload ?? {}) as Record<string, unknown>;
           out.push({ id, payload });
         }
@@ -788,7 +818,7 @@ export class VellumQdrantClient {
 
   private async findByTarget(
     targetType: string,
-    targetId: string
+    targetId: string,
   ): Promise<string | null> {
     try {
       const results = await this.client.scroll(this.collection, {

package/src/memory/schema/infrastructure.ts

@@ -19,6 +19,8 @@ export const cronJobs = sqliteTable("cron_jobs", {
   lastRunAt: integer("last_run_at"),
   lastStatus: text("last_status"), // 'ok' | 'error'
   retryCount: integer("retry_count").notNull().default(0),
+  maxRetries: integer("max_retries").notNull().default(3),
+  retryBackoffMs: integer("retry_backoff_ms").notNull().default(60000),
   createdBy: text("created_by").notNull(), // 'agent' | 'user'
   mode: text("mode").notNull().default("execute"), // 'notify' | 'execute'
   routingIntent: text("routing_intent").notNull().default("all_channels"), // 'single_channel' | 'multi_channel' | 'all_channels'
@@ -54,6 +56,19 @@ export const cronRuns = sqliteTable("cron_runs", {
 export const scheduleJobs = cronJobs;
 export const scheduleRuns = cronRuns;
 
+export const heartbeatRuns = sqliteTable("heartbeat_runs", {
+  id: text("id").primaryKey(),
+  scheduledFor: integer("scheduled_for").notNull(),
+  startedAt: integer("started_at"),
+  finishedAt: integer("finished_at"),
+  durationMs: integer("duration_ms"),
+  status: text("status").notNull(), // 'pending' | 'running' | 'ok' | 'error' | 'timeout' | 'skipped' | 'missed' | 'superseded'
+  skipReason: text("skip_reason"), // 'disabled' | 'outside_active_hours' | 'overlap'
+  error: text("error"),
+  conversationId: text("conversation_id"),
+  createdAt: integer("created_at").notNull(),
+});
+
 export const sharedAppLinks = sqliteTable("shared_app_links", {
   id: text("id").primaryKey(),
   shareToken: text("share_token").notNull().unique(),

package/src/memory/search/semantic.ts

@@ -1,5 +1,7 @@
 import { inArray } from "drizzle-orm";
 
+import { getConfig } from "../../config/loader.js";
+import { isMemoryV2ReadActive } from "../context-search/sources/memory-v2.js";
 import { getDb } from "../db-connection.js";
 import { withQdrantBreaker } from "../qdrant-circuit-breaker.js";
 import type {
@@ -55,6 +57,11 @@ export async function semanticSearch(
 ): Promise<Candidate[]> {
   if (limit <= 0) return [];
 
+  // v2 owns the read path when both gates are on; the v1 `memory` collection
+  // is in active retirement, and routing semantic recall there would re-enter
+  // the same corrupted sparse segments that can OOM-crash Qdrant.
+  if (isMemoryV2ReadActive(getConfig())) return [];
+
   const qdrant = getQdrantClient();
 
   // Overfetch to account for items filtered out post-query (invalidated, excluded, etc.)

package/src/memory/sparse-tokenize.ts

@@ -0,0 +1,49 @@
+// ---------------------------------------------------------------------------
+// Sparse-vector tokenization primitives
+// ---------------------------------------------------------------------------
+//
+// Shared by both the legacy TF-only encoder in `embedding-backend.ts`
+// (`generateSparseEmbedding`) and the BM25 encoder in `v2/sparse-bm25.ts`.
+//
+// Lives in its own module so consumers of the BM25 encoder don't transitively
+// depend on `embedding-backend.ts` for these primitives — that matters
+// because many tests mock `embedding-backend.js` wholesale via
+// `mock.module(...)`, and a missing export from the mock would break any
+// transitive importer of these helpers.
+
+import { stemmer } from "stemmer";
+
+/** Hashed-vocabulary size for sparse encoders. */
+export const SPARSE_VOCAB_SIZE = 30_000;
+
+/** Tokenize text into lowercase alphanumeric tokens (Unicode-aware). */
+export function tokenize(text: string): string[] {
+  return text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+}
+
+/**
+ * Tokenize and apply Porter stemming so morphological variants collapse to a
+ * shared bucket (e.g. `running`/`runs`/`ran` → `run`, `supplements` →
+ * `supplement`). Used only by the BM25 sparse channel in
+ * `v2/sparse-bm25.ts`; both the document-side and query-side encoders call
+ * this so doc and query tokens land in the same hash buckets.
+ *
+ * Other callers (workspace context-search, the legacy TF-only
+ * `generateSparseEmbedding`) intentionally keep the non-stemmed `tokenize()`
+ * because they predate this and rebuilding their on-disk indexes is out of
+ * scope here.
+ */
+export function tokenizeStemmed(text: string): string[] {
+  return tokenize(text).map((token) => stemmer(token));
+}
+
+/** Hash a token to a stable index in [0, vocabSize). */
+export 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;
+}

package/src/memory/v2/__tests__/activation.test.ts

@@ -148,7 +148,6 @@ const {
   computeSkillActivation,
   selectCandidates,
   selectInjections,
-  selectSkillCandidates,
   selectSkillInjections,
   spreadActivation,
 } = await import("../activation.js");
@@ -193,6 +192,7 @@ function makeConfig(
     epsilon: number;
     dense_weight: number;
     sparse_weight: number;
+    ann_candidate_limit: number | null;
   }> = {},
 ): AssistantConfig {
   return {
@@ -205,6 +205,7 @@ function makeConfig(
         epsilon: 0.01,
         dense_weight: 1.0,
         sparse_weight: 0.0,
+        ann_candidate_limit: null,
         ...overrides,
       },
     },
@@ -342,7 +343,13 @@ describe("selectCandidates", () => {
     expect(out.fromAnn).toEqual(new Set(["alice-vscode", "delta-recipe"]));
   });
 
-  test("ANN top-K limit equals 50 and runs without slug restriction", async () => {
+  test("ANN candidate query honors `config.memory.v2.ann_candidate_limit` and runs without slug restriction", async () => {
+    // Default `ann_candidate_limit: null` → unlimited, so the unlimited
+    // sentinel (1_000_000 — a Qdrant-safe stand-in for "every page") is
+    // passed to both channels. We don't pin to `MAX_SAFE_INTEGER` here:
+    // Qdrant's sparse `SearchContext` pre-allocates `limit * 16` bytes,
+    // and `MAX_SAFE_INTEGER` triggers a ~144 PB alloc that SIGABRTs the
+    // Qdrant process — so the constant deliberately undercuts it.
     stageHybridResponse([{ slug: "alpha", denseScore: 0.5, sparseScore: 1 }]);
     await selectCandidates({
       priorState: null,
@@ -351,10 +358,25 @@ describe("selectCandidates", () => {
       nowText: "",
       config: makeConfig(),
     });
-    // Both channels (dense + sparse) ran with limit=50 and no filter.
     expect(state.queryCalls).toHaveLength(2);
     for (const call of state.queryCalls) {
-      expect(call.limit).toBe(50);
+      expect(call.limit).toBe(1_000_000);
+      expect(call.filter).toBeUndefined();
+    }
+
+    // Explicit override flows through both channels verbatim.
+    state.queryCalls.length = 0;
+    stageHybridResponse([{ slug: "beta", denseScore: 0.5, sparseScore: 1 }]);
+    await selectCandidates({
+      priorState: null,
+      userText: "hello",
+      assistantText: "",
+      nowText: "",
+      config: makeConfig({ ann_candidate_limit: 25 }),
+    });
+    expect(state.queryCalls).toHaveLength(2);
+    for (const call of state.queryCalls) {
+      expect(call.limit).toBe(25);
       expect(call.filter).toBeUndefined();
     }
   });
@@ -682,15 +704,59 @@ describe("spreadActivation", () => {
     expect(out.final.get("bob")).toBeCloseTo(0.9, 6);
   });
 
-  test("missing predecessor activation contributes 0 to the numerator", () => {
-    // Edge alice→bob: bob has predecessor alice. alice is not in
-    // `ownActivation`, so it contributes 0 to the numerator while the
-    // denominator still counts the structural predecessor.
+  test("predecessors not in the candidate set are dropped from both numerator and denominator", () => {
+    // Edge alice→bob: bob has structural predecessor alice, but alice is not
+    // in `ownActivation`. With the new formula she contributes nothing —
+    // hop1 has no active predecessors so the whole hop drops out of both
+    // sides of the ratio. Bob therefore stays at his own activation.
     const edges = buildEdgeIndex([["alice", "bob"]]);
     const own = new Map([["bob", 0.6]]);
     const out = spreadActivation(own, edges, 0.5, 2);
-    // numerator = 0.6 + 0.5*0 = 0.6. denominator = 1 + 0.5*1 = 1.5.
-    expect(out.final.get("bob")).toBeCloseTo(0.4, 6);
+    expect(out.final.get("bob")).toBeCloseTo(0.6, 6);
+  });
+
+  test("L_2 norm over multiple active predecessors rewards strong outliers more than avg would", () => {
+    // bob has 4 predecessors in the candidate set: one strong, three weak.
+    // L_2 = √((0.8² + 0.1² + 0.1² + 0.1²) / 4) = √(0.1675) ≈ 0.40927
+    // Plain avg of the same set = 0.275, so L_2 lifts bob more than avg
+    // would — the design goal of preferring quality over quantity.
+    const edges = buildEdgeIndex([
+      ["a1", "bob"],
+      ["a2", "bob"],
+      ["a3", "bob"],
+      ["a4", "bob"],
+    ]);
+    const own = new Map([
+      ["a1", 0.8],
+      ["a2", 0.1],
+      ["a3", 0.1],
+      ["a4", 0.1],
+      ["bob", 0.0],
+    ]);
+    const out = spreadActivation(own, edges, 0.5, 2);
+    const rms = Math.sqrt((0.8 * 0.8 + 3 * 0.1 * 0.1) / 4);
+    // numerator   = 0 + 0.5 · rms
+    // denominator = 1 + 0.5
+    expect(out.final.get("bob")).toBeCloseTo((0.5 * rms) / 1.5, 6);
+  });
+
+  test("high-in-degree hub with mostly-inactive predecessors stays near A_o", () => {
+    // 100 structural predecessors point at hub; only one (`pred0`) is in
+    // the candidate set. The old formula would crush hub by the structural
+    // count (denominator ≈ 51); the new formula folds the empty bulk out
+    // and the L_2 averages over the single active predecessor only.
+    const rawEdges: Array<[string, string]> = [];
+    for (let i = 0; i < 100; i++) rawEdges.push([`pred${i}`, "hub"]);
+    const edges = buildEdgeIndex(rawEdges);
+    const own = new Map([
+      ["hub", 0.6],
+      ["pred0", 0.5],
+    ]);
+    const out = spreadActivation(own, edges, 0.5, 2);
+    // hop1 active = {pred0}, L_2([0.5]) = 0.5.
+    //   numerator   = 0.6 + 0.5 · 0.5 = 0.85
+    //   denominator = 1 + 0.5         = 1.5
+    expect(out.final.get("hub")).toBeCloseTo(0.85 / 1.5, 6);
   });
 
   test("empty own-activation map returns empty result", () => {
@@ -829,7 +895,7 @@ describe("selectInjections", () => {
 });
 
 // ---------------------------------------------------------------------------
-// selectSkillCandidates
+// computeSkillActivation
 // ---------------------------------------------------------------------------
 
 /** Stage a single hybrid response on the skills queues (payload key = `id`). */
@@ -848,90 +914,6 @@ function stageSkillHybridResponse(
   });
 }
 
-describe("selectSkillCandidates", () => {
-  test("returns hit ids from the skills collection", async () => {
-    stageSkillHybridResponse([
-      { id: "example-skill-a", denseScore: 0.5, sparseScore: 1 },
-      { id: "example-skill-b", denseScore: 0.3, sparseScore: 1 },
-    ]);
-    const out = await selectSkillCandidates({
-      userText: "user said hello",
-      assistantText: "",
-      nowText: "",
-      config: makeConfig(),
-      topK: 10,
-    });
-    expect(out).toEqual(new Set(["example-skill-a", "example-skill-b"]));
-  });
-
-  test("empty turn text short-circuits without backend calls", async () => {
-    const out = await selectSkillCandidates({
-      userText: "",
-      assistantText: "",
-      nowText: "",
-      config: makeConfig(),
-      topK: 10,
-    });
-    expect(out.size).toBe(0);
-    expect(state.embedCalls).toHaveLength(0);
-    expect(state.queryCalls).toHaveLength(0);
-  });
-
-  test("topK=0 short-circuits without backend calls", async () => {
-    const out = await selectSkillCandidates({
-      userText: "anything",
-      assistantText: "anything",
-      nowText: "anything",
-      config: makeConfig(),
-      topK: 0,
-    });
-    expect(out.size).toBe(0);
-    expect(state.embedCalls).toHaveLength(0);
-    expect(state.queryCalls).toHaveLength(0);
-  });
-
-  test("forwards topK and queries the skills collection unrestricted", async () => {
-    stageSkillHybridResponse([
-      { id: "example-skill-a", denseScore: 0.5, sparseScore: 1 },
-    ]);
-    await selectSkillCandidates({
-      userText: "hello",
-      assistantText: "",
-      nowText: "",
-      config: makeConfig(),
-      topK: 7,
-    });
-    // Both channels (dense + sparse) ran with limit=7 and no slug/id filter,
-    // against the dedicated skills collection.
-    expect(state.queryCalls).toHaveLength(2);
-    for (const call of state.queryCalls) {
-      expect(call.collection).toBe("memory_v2_skills");
-      expect(call.limit).toBe(7);
-      expect(call.filter).toBeUndefined();
-    }
-  });
-
-  test("embeds concatenated turn text exactly once", async () => {
-    stageSkillHybridResponse([]);
-    await selectSkillCandidates({
-      userText: "user line",
-      assistantText: "assistant line",
-      nowText: "now line",
-      config: makeConfig(),
-      topK: 5,
-    });
-    expect(state.embedCalls).toHaveLength(1);
-    expect(state.embedCalls[0].inputs).toEqual([
-      "user line\nassistant line\nnow line",
-    ]);
-    expect(state.sparseCalls).toEqual(["user line\nassistant line\nnow line"]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// computeSkillActivation
-// ---------------------------------------------------------------------------
-
 describe("computeSkillActivation", () => {
   test("empty candidates short-circuits without backend calls", async () => {
     const out = await computeSkillActivation({

package/src/memory/v2/__tests__/injection.test.ts

@@ -14,12 +14,12 @@
  *
  * Hermetic by design: the embedding backend, qdrant client, and `getConfig`
  * are mocked at the module level so the suite never reaches a real backend.
- * The skill activation pipeline (`selectSkillCandidates`,
- * `computeSkillActivation`, `selectSkillInjections`) and the skill-store
- * lookup (`getSkillCapability`) are also mocked at the module level so each
- * test can stage its skill slate without touching the dedicated skills
- * Qdrant collection. The activation-store uses an in-memory SQLite database
- * so writes are real but contained.
+ * The skill activation pipeline (`computeSkillActivation`,
+ * `selectSkillInjections`) and the skill-store helpers (`getAllSkillIds`,
+ * `getSkillCapability`) are also mocked at the module level so each test can
+ * stage its skill slate without touching the dedicated skills Qdrant
+ * collection. The activation-store uses an in-memory SQLite database so
+ * writes are real but contained.
  *
  * Tests use a temp workspace (mkdtemp) and never touch `~/.vellum/`. Sample
  * page content uses generic placeholders (Alice, Bob, etc.) per the cross-
@@ -127,18 +127,19 @@ mock.module("@qdrant/js-client-rest", () => ({
 // Skill pipeline mocks
 // ---------------------------------------------------------------------------
 //
-// The skill side of the per-turn pipeline (`selectSkillCandidates`,
-// `computeSkillActivation`, `selectSkillInjections`) has its own dedicated
-// Qdrant collection and embedding round-trips. Rather than threading staged
-// hits through that whole pipeline for every test, we mock the three skill
-// helpers and the synchronous `getSkillCapability` lookup at the module level
-// and let each test stage a `topNow` ordering and the matching `SkillEntry`
-// content directly.
+// The skill side of the per-turn pipeline (`computeSkillActivation`,
+// `selectSkillInjections`) has its own dedicated Qdrant collection and
+// embedding round-trips. Rather than threading staged hits through that whole
+// pipeline for every test, we mock the two activation helpers and the two
+// skill-store helpers (`getAllSkillIds` for the candidate pool,
+// `getSkillCapability` for content lookup) at the module level and let each
+// test stage a `topNow` ordering and the matching `SkillEntry` content
+// directly.
 
 const skillState = {
   /** Ordered ids `selectSkillInjections.topNow` returns this turn. */
   topSkillIds: [] as string[],
-  /** id → SkillEntry used by `getSkillCapability`. */
+  /** id → SkillEntry used by `getSkillCapability` and `getAllSkillIds`. */
   entries: new Map<string, SkillEntry>(),
 };
 
@@ -149,7 +150,6 @@ mock.module("../activation.js", () => ({
   // activation map are inputs to `selectSkillInjections`, not anything the
   // injection logic introspects. Stub them to empty so the test stays focused
   // on the wiring, not the pipeline internals (covered in activation.test.ts).
-  selectSkillCandidates: async () => new Set<string>(),
   computeSkillActivation: async () => ({
     activation: new Map<string, number>(),
     breakdown: new Map(),
@@ -160,6 +160,7 @@ mock.module("../activation.js", () => ({
 }));
 
 mock.module("../skill-store.js", () => ({
+  getAllSkillIds: () => [...skillState.entries.keys()],
   getSkillCapability: (id: string) => skillState.entries.get(id) ?? null,
 }));
 
@@ -331,6 +332,13 @@ function stageTurn(
   hits: Array<{ slug: string; denseScore?: number; sparseScore?: number }>,
   channels = 4,
 ): void {
+  // Clear any leftovers from a prior turn before staging this one so unused
+  // staged responses can't bleed into the next injection. The activation
+  // pipeline now skips the embedding round-trip for empty texts (turn 1's
+  // assistantMessage), so consumed-channel counts vary per turn — staging
+  // exclusively is the only way multi-turn tests stay aligned.
+  state.queryResponses.dense.length = 0;
+  state.queryResponses.sparse.length = 0;
   for (let i = 0; i < channels; i++) {
     state.queryResponses.dense.push({
       points: hits
@@ -399,11 +407,13 @@ describe("injectMemoryV2Block", () => {
 
     expect(result.toInject).toEqual(["alice-vscode"]);
     expect(result.block).not.toBeNull();
-    expect(result.block).toContain("<memory>");
+    // `block` is the unwrapped inner content; the caller adds the
+    // `<memory>...</memory>` wrapper exactly once at injection time.
+    expect(result.block).not.toContain("<memory>");
+    expect(result.block).not.toContain("</memory>");
     expect(result.block).not.toContain("## What I Remember Right Now");
     expect(result.block).toContain("### alice-vscode");
     expect(result.block).toContain("VS Code");
-    expect(result.block).toContain("</memory>");
 
     // State persisted: alice's activation is above epsilon and recorded;
     // everInjected captured the new slug + currentTurn.
@@ -652,13 +662,24 @@ describe("injectMemoryV2Block", () => {
     expect(persisted!.everInjected).toEqual([
       { slug: "phantom-slug", turn: 1 },
     ]);
+
+    // Activation log marks the slug `page_missing` (not `injected`) so a
+    // stale Qdrant / edge-index entry pointing at a vanished page is
+    // visible in telemetry instead of masquerading as a successful inject.
+    expect(telemetryState.recordCalls.length).toBe(1);
+    const row = telemetryState.recordCalls[0] as {
+      concepts: Array<{ slug: string; status: string }>;
+    };
+    const phantom = row.concepts.find((c) => c.slug === "phantom-slug");
+    expect(phantom).toBeDefined();
+    expect(phantom!.status).toBe("page_missing");
   });
 
   // ---------------------------------------------------------------------------
   // Skill subsection rendering
   // ---------------------------------------------------------------------------
 
-  test("renders a skill-only block in the same `<memory>` wrapper as concept-page-only blocks", async () => {
+  test("renders a skill-only block alongside concept-page-only blocks", async () => {
     // No concept-page candidates this turn — the candidate query and the three
     // simBatch queries all return empty. The skill pipeline is mocked to
     // surface a single skill.
@@ -687,10 +708,11 @@ describe("injectMemoryV2Block", () => {
 
     expect(result.toInject).toEqual([]);
     expect(result.block).not.toBeNull();
-    // Same outer wrapping as concept-page-only blocks.
-    expect(result.block).toContain("<memory>");
+    // `block` is the unwrapped inner content; the caller adds the
+    // `<memory>...</memory>` wrapper exactly once at injection time.
+    expect(result.block).not.toContain("<memory>");
+    expect(result.block).not.toContain("</memory>");
     expect(result.block).not.toContain("## What I Remember Right Now");
-    expect(result.block).toContain("</memory>");
     // No concept-page sections; skills subsection present with the right
     // bullet shape and the unconditional `→ use skill_load to activate` suffix.
     expect(result.block).not.toContain("### alice-vscode");