@vellumai/assistant 0.5.10 → 0.5.12

package/src/memory/llm-request-log-store.ts

@@ -1,13 +1,24 @@
-import { and, eq, gte, inArray, isNull, lte } from "drizzle-orm";
+import { and, eq, gte, inArray, isNull, lte, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import {
   getAssistantMessageIdsInTurn,
   getMessageById,
+  getTurnTimeBounds,
   messageMetadataSchema,
 } from "./conversation-crud.js";
 import { getDb } from "./db.js";
-import { llmRequestLogs } from "./schema.js";
+import { llmRequestLogs, messages } from "./schema.js";
+
+type LogRow = {
+  id: string;
+  conversationId: string;
+  messageId: string | null;
+  provider: string | null;
+  requestPayload: string;
+  responsePayload: string;
+  createdAt: number;
+};
 
 export function recordRequestLog(
   conversationId: string,
@@ -77,15 +88,7 @@ export function backfillMessageIdOnLogs(
  * given message IDs, ordered by `createdAt ASC`. Uses the existing
  * `idx_llm_request_logs_message_id` index via `inArray`.
  */
-function selectLogsByMessageIds(messageIds: string[]): Array<{
-  id: string;
-  conversationId: string;
-  messageId: string | null;
-  provider: string | null;
-  requestPayload: string;
-  responsePayload: string;
-  createdAt: number;
-}> {
+function selectLogsByMessageIds(messageIds: string[]): LogRow[] {
   if (messageIds.length === 0) return [];
   const db = getDb();
   return db
@@ -104,26 +107,90 @@ function selectLogsByMessageIds(messageIds: string[]): Array<{
     .all();
 }
 
-export function getRequestLogsByMessageId(messageId: string): Array<{
-  id: string;
-  conversationId: string;
-  messageId: string | null;
-  provider: string | null;
-  requestPayload: string;
-  responsePayload: string;
-  createdAt: number;
-}> {
+/**
+ * Find orphaned logs — logs whose `message_id` references a message that no
+ * longer exists in the DB. These are left behind when intermediate assistant
+ * messages are deleted (e.g. by retry/deleteLastExchange).
+ *
+ * Scoped to a single conversation and a time range to avoid cross-turn bleed.
+ */
+function selectOrphanedLogsInRange(
+  conversationId: string,
+  startTime: number,
+  endTime: number,
+): LogRow[] {
+  if (endTime <= startTime) return [];
+  const db = getDb();
+  // LEFT JOIN messages → filter where message row IS NULL (orphaned).
+  return db
+    .select({
+      id: llmRequestLogs.id,
+      conversationId: llmRequestLogs.conversationId,
+      messageId: llmRequestLogs.messageId,
+      provider: llmRequestLogs.provider,
+      requestPayload: llmRequestLogs.requestPayload,
+      responsePayload: llmRequestLogs.responsePayload,
+      createdAt: llmRequestLogs.createdAt,
+    })
+    .from(llmRequestLogs)
+    .leftJoin(messages, eq(llmRequestLogs.messageId, messages.id))
+    .where(
+      and(
+        eq(llmRequestLogs.conversationId, conversationId),
+        gte(llmRequestLogs.createdAt, startTime),
+        lte(llmRequestLogs.createdAt, endTime),
+        sql`${messages.id} IS NULL`,
+        sql`${llmRequestLogs.messageId} IS NOT NULL`,
+      ),
+    )
+    .orderBy(llmRequestLogs.createdAt)
+    .all();
+}
+
+export function getRequestLogsByMessageId(messageId: string): LogRow[] {
   // Resolve all assistant message IDs in the same turn so the inspector
   // shows every LLM call from the entire agent turn, not just the queried message.
   const turnMessageIds = getAssistantMessageIdsInTurn(messageId);
   const turnLogs = selectLogsByMessageIds(turnMessageIds);
+
+  // Orphaned-log recovery: intermediate assistant messages within a turn can
+  // be deleted (e.g. by retry / deleteLastExchange) while their
+  // llm_request_logs rows survive. When that happens the message-ID-based
+  // query misses those logs. We detect orphaned logs (logs whose message_id
+  // references a deleted message) within the turn's time window and merge
+  // them with the message-ID-based results.
+  const message = getMessageById(messageId);
+  if (message) {
+    const bounds = getTurnTimeBounds(message.conversationId, message.createdAt);
+    if (bounds) {
+      const orphanedLogs = selectOrphanedLogsInRange(
+        message.conversationId,
+        bounds.startTime,
+        bounds.endTime,
+      );
+      if (orphanedLogs.length > 0) {
+        const seen = new Set(turnLogs.map((l) => l.id));
+        const merged = [...turnLogs];
+        for (const log of orphanedLogs) {
+          if (!seen.has(log.id)) {
+            merged.push(log);
+            seen.add(log.id);
+          }
+        }
+        merged.sort(
+          (a, b) => a.createdAt - b.createdAt || a.id.localeCompare(b.id),
+        );
+        return merged;
+      }
+    }
+  }
+
   if (turnLogs.length > 0) {
     return turnLogs;
   }
 
   // Fork-source fallback: if no logs found for the turn, check whether
   // the queried message was forked from a source and resolve that source's turn.
-  const message = getMessageById(messageId);
   if (!message?.metadata) {
     return [];
   }

package/src/memory/memory-recall-log-store.ts

@@ -0,0 +1,128 @@
+import { and, eq, inArray, isNull } from "drizzle-orm";
+import { v4 as uuid } from "uuid";
+
+import { getDb } from "./db.js";
+import { memoryRecallLogs } from "./schema.js";
+
+export interface RecordMemoryRecallLogParams {
+  conversationId: string;
+  enabled: boolean;
+  degraded: boolean;
+  provider?: string;
+  model?: string;
+  degradationJson?: unknown;
+  semanticHits: number;
+  mergedCount: number;
+  selectedCount: number;
+  tier1Count: number;
+  tier2Count: number;
+  hybridSearchLatencyMs: number;
+  sparseVectorUsed: boolean;
+  injectedTokens: number;
+  latencyMs: number;
+  topCandidatesJson: unknown;
+  injectedText?: string;
+  reason?: string;
+}
+
+export function recordMemoryRecallLog(params: RecordMemoryRecallLogParams): void {
+  const db = getDb();
+  db.insert(memoryRecallLogs)
+    .values({
+      id: uuid(),
+      conversationId: params.conversationId,
+      messageId: null,
+      enabled: params.enabled ? 1 : 0,
+      degraded: params.degraded ? 1 : 0,
+      provider: params.provider ?? null,
+      model: params.model ?? null,
+      degradationJson: params.degradationJson
+        ? JSON.stringify(params.degradationJson)
+        : null,
+      semanticHits: params.semanticHits,
+      mergedCount: params.mergedCount,
+      selectedCount: params.selectedCount,
+      tier1Count: params.tier1Count,
+      tier2Count: params.tier2Count,
+      hybridSearchLatencyMs: params.hybridSearchLatencyMs,
+      sparseVectorUsed: params.sparseVectorUsed ? 1 : 0,
+      injectedTokens: params.injectedTokens,
+      latencyMs: params.latencyMs,
+      topCandidatesJson: JSON.stringify(params.topCandidatesJson),
+      injectedText: params.injectedText ?? null,
+      reason: params.reason ?? null,
+      createdAt: Date.now(),
+    })
+    .run();
+}
+
+export function backfillMemoryRecallLogMessageId(
+  conversationId: string,
+  messageId: string,
+): void {
+  const db = getDb();
+  db.update(memoryRecallLogs)
+    .set({ messageId })
+    .where(
+      and(
+        eq(memoryRecallLogs.conversationId, conversationId),
+        isNull(memoryRecallLogs.messageId),
+      ),
+    )
+    .run();
+}
+
+export interface MemoryRecallLog {
+  enabled: boolean;
+  degraded: boolean;
+  provider: string | null;
+  model: string | null;
+  degradation: unknown | null;
+  semanticHits: number;
+  mergedCount: number;
+  selectedCount: number;
+  tier1Count: number;
+  tier2Count: number;
+  hybridSearchLatencyMs: number;
+  sparseVectorUsed: boolean;
+  injectedTokens: number;
+  latencyMs: number;
+  topCandidates: unknown;
+  injectedText: string | null;
+  reason: string | null;
+}
+
+export function getMemoryRecallLogByMessageIds(
+  messageIds: string[],
+): MemoryRecallLog | null {
+  if (messageIds.length === 0) return null;
+  const db = getDb();
+  const rows = db
+    .select()
+    .from(memoryRecallLogs)
+    .where(inArray(memoryRecallLogs.messageId, messageIds))
+    .all();
+  if (rows.length === 0) return null;
+  const row = rows[0]!;
+  return {
+    enabled: !!row.enabled,
+    degraded: !!row.degraded,
+    provider: row.provider,
+    model: row.model,
+    degradation: row.degradationJson
+      ? JSON.parse(row.degradationJson)
+      : null,
+    semanticHits: row.semanticHits,
+    mergedCount: row.mergedCount,
+    selectedCount: row.selectedCount,
+    tier1Count: row.tier1Count,
+    tier2Count: row.tier2Count,
+    hybridSearchLatencyMs: row.hybridSearchLatencyMs,
+    sparseVectorUsed: !!row.sparseVectorUsed,
+    injectedTokens: row.injectedTokens,
+    latencyMs: row.latencyMs,
+    topCandidates: JSON.parse(row.topCandidatesJson),
+    injectedText: row.injectedText,
+    reason: row.reason,
+  };
+}

package/src/memory/migrations/194-memory-recall-logs.ts

@@ -0,0 +1,50 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_create_memory_recall_logs_v1";
+
+/**
+ * Create the memory_recall_logs table for the inspector memory tab.
+ */
+export function migrateCreateMemoryRecallLogs(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+
+    raw.exec(/*sql*/ `
+      CREATE TABLE IF NOT EXISTS memory_recall_logs (
+        id TEXT PRIMARY KEY,
+        conversation_id TEXT NOT NULL,
+        message_id TEXT,
+        enabled INTEGER NOT NULL,
+        degraded INTEGER NOT NULL,
+        provider TEXT,
+        model TEXT,
+        degradation_json TEXT,
+        semantic_hits INTEGER NOT NULL,
+        merged_count INTEGER NOT NULL,
+        selected_count INTEGER NOT NULL,
+        tier1_count INTEGER NOT NULL,
+        tier2_count INTEGER NOT NULL,
+        hybrid_search_latency_ms INTEGER NOT NULL,
+        sparse_vector_used INTEGER NOT NULL,
+        injected_tokens INTEGER NOT NULL,
+        latency_ms INTEGER NOT NULL,
+        top_candidates_json TEXT NOT NULL,
+        injected_text TEXT,
+        reason TEXT,
+        created_at INTEGER NOT NULL
+      )
+    `);
+
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_memory_recall_logs_message_id
+      ON memory_recall_logs (message_id)
+    `);
+
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_memory_recall_logs_conversation_id
+      ON memory_recall_logs (conversation_id)
+    `);
+  });
+}

package/src/memory/migrations/195-oauth-providers-ping-config.ts

@@ -0,0 +1,23 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateOAuthProvidersPingConfig(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(/*sql*/ `ALTER TABLE oauth_providers ADD COLUMN ping_method TEXT`);
+  } catch {
+    // Column already exists — nothing to do.
+  }
+  try {
+    raw.exec(
+      /*sql*/ `ALTER TABLE oauth_providers ADD COLUMN ping_headers TEXT`,
+    );
+  } catch {
+    // Column already exists — nothing to do.
+  }
+  try {
+    raw.exec(/*sql*/ `ALTER TABLE oauth_providers ADD COLUMN ping_body TEXT`);
+  } catch {
+    // Column already exists — nothing to do.
+  }
+}

package/src/memory/migrations/196-messages-conversation-created-at-index.ts

@@ -0,0 +1,9 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+export function migrateMessagesConversationCreatedAtIndex(
+  database: DrizzleDb,
+): void {
+  database.run(
+    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_messages_conversation_created_at ON messages(conversation_id, created_at)`,
+  );
+}

package/src/memory/migrations/196-strip-integration-prefix-from-provider-keys.ts

@@ -0,0 +1,186 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * One-shot migration: strip the `integration:` prefix from provider_key
+ * values across all three OAuth tables (oauth_providers, oauth_apps,
+ * oauth_connections).
+ *
+ * Historically provider keys were stored as `integration:google`,
+ * `integration:slack`, etc.  The codebase is moving to bare-name keys
+ * (`google`, `slack`) for simplicity.  Providers that were already stored
+ * with bare names (e.g. `slack_channel`, `telegram`) are unaffected.
+ *
+ * If a bare-name key already exists (runtime seed data created it), the
+ * old `integration:` rows are orphaned — we delete them instead of
+ * renaming to avoid UNIQUE constraint violations.
+ *
+ * FK constraints require us to update child tables (oauth_apps,
+ * oauth_connections) before the parent (oauth_providers), or disable FKs.
+ * We disable FKs for safety and update all three tables atomically.
+ */
+export function migrateStripIntegrationPrefixFromProviderKeys(
+  database: DrizzleDb,
+): void {
+  withCrashRecovery(
+    database,
+    "migration_strip_integration_prefix_from_provider_keys_v1",
+    () => {
+      const raw = getSqliteFrom(database);
+
+      raw.exec("PRAGMA foreign_keys = OFF");
+      try {
+        // Find all provider keys with the integration: prefix.
+        const rows = raw
+          .prepare(
+            /*sql*/ `SELECT provider_key FROM oauth_providers WHERE provider_key LIKE 'integration:%'`,
+          )
+          .all() as Array<{ provider_key: string }>;
+
+        for (const { provider_key: oldKey } of rows) {
+          const newKey = oldKey.replace(/^integration:/, "");
+
+          // Check if the bare-name key already exists (seed data may have created it).
+          const bareExists = raw
+            .prepare(
+              /*sql*/ `SELECT 1 FROM oauth_providers WHERE provider_key = ?`,
+            )
+            .get(newKey);
+
+          if (bareExists) {
+            // Bare-name provider already exists — delete the old prefixed rows
+            // to avoid UNIQUE constraint violations.
+            raw
+              .prepare(
+                /*sql*/ `DELETE FROM oauth_connections WHERE provider_key = ?`,
+              )
+              .run(oldKey);
+            raw
+              .prepare(/*sql*/ `DELETE FROM oauth_apps WHERE provider_key = ?`)
+              .run(oldKey);
+            raw
+              .prepare(
+                /*sql*/ `DELETE FROM oauth_providers WHERE provider_key = ?`,
+              )
+              .run(oldKey);
+          } else {
+            // Rename: update child tables first, then parent.
+            raw
+              .prepare(
+                /*sql*/ `UPDATE oauth_connections SET provider_key = ? WHERE provider_key = ?`,
+              )
+              .run(newKey, oldKey);
+            raw
+              .prepare(
+                /*sql*/ `UPDATE oauth_apps SET provider_key = ? WHERE provider_key = ?`,
+              )
+              .run(newKey, oldKey);
+            raw
+              .prepare(
+                /*sql*/ `UPDATE oauth_providers SET provider_key = ? WHERE provider_key = ?`,
+              )
+              .run(newKey, oldKey);
+          }
+        }
+
+        // Also update the watchers table — credential_service stores provider
+        // keys like "integration:google" that feed into resolveOAuthConnection().
+        raw
+          .prepare(
+            /*sql*/ `UPDATE watchers SET credential_service = REPLACE(credential_service, 'integration:', '') WHERE credential_service LIKE 'integration:%'`,
+          )
+          .run();
+      } finally {
+        raw.exec("PRAGMA foreign_keys = ON");
+      }
+    },
+  );
+}
+
+/**
+ * Reverse: re-add the `integration:` prefix to provider keys that don't
+ * already have one and aren't known bare-name providers.
+ *
+ * This is a best-effort rollback — we prefix all keys that look like they
+ * were originally `integration:` prefixed.  Known bare-name keys
+ * (`slack_channel`, `telegram`) are left as-is because they never had the
+ * prefix.
+ */
+export function migrateStripIntegrationPrefixFromProviderKeysDown(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+
+  // Keys that were always bare — never had an integration: prefix.
+  const ALWAYS_BARE = new Set(["slack_channel", "telegram"]);
+
+  raw.exec("PRAGMA foreign_keys = OFF");
+  try {
+    const rows = raw
+      .prepare(
+        /*sql*/ `SELECT provider_key FROM oauth_providers WHERE provider_key NOT LIKE 'integration:%'`,
+      )
+      .all() as Array<{ provider_key: string }>;
+
+    for (const { provider_key: bareKey } of rows) {
+      if (ALWAYS_BARE.has(bareKey)) continue;
+
+      const prefixedKey = `integration:${bareKey}`;
+
+      // If the prefixed key already exists, delete the bare rows.
+      const prefixedExists = raw
+        .prepare(/*sql*/ `SELECT 1 FROM oauth_providers WHERE provider_key = ?`)
+        .get(prefixedKey);
+
+      if (prefixedExists) {
+        raw
+          .prepare(
+            /*sql*/ `DELETE FROM oauth_connections WHERE provider_key = ?`,
+          )
+          .run(bareKey);
+        raw
+          .prepare(/*sql*/ `DELETE FROM oauth_apps WHERE provider_key = ?`)
+          .run(bareKey);
+        raw
+          .prepare(/*sql*/ `DELETE FROM oauth_providers WHERE provider_key = ?`)
+          .run(bareKey);
+      } else {
+        raw
+          .prepare(
+            /*sql*/ `UPDATE oauth_connections SET provider_key = ? WHERE provider_key = ?`,
+          )
+          .run(prefixedKey, bareKey);
+        raw
+          .prepare(
+            /*sql*/ `UPDATE oauth_apps SET provider_key = ? WHERE provider_key = ?`,
+          )
+          .run(prefixedKey, bareKey);
+        raw
+          .prepare(
+            /*sql*/ `UPDATE oauth_providers SET provider_key = ? WHERE provider_key = ?`,
+          )
+          .run(prefixedKey, bareKey);
+      }
+    }
+
+    // Reverse the watchers table update — re-add the prefix for keys that
+    // aren't known bare-name providers.
+    const watcherRows = raw
+      .prepare(
+        /*sql*/ `SELECT DISTINCT credential_service FROM watchers WHERE credential_service NOT LIKE 'integration:%'`,
+      )
+      .all() as Array<{ credential_service: string }>;
+
+    for (const { credential_service: bareKey } of watcherRows) {
+      if (ALWAYS_BARE.has(bareKey)) continue;
+      raw
+        .prepare(
+          /*sql*/ `UPDATE watchers SET credential_service = ? WHERE credential_service = ?`,
+        )
+        .run(`integration:${bareKey}`, bareKey);
+    }
+  } finally {
+    raw.exec("PRAGMA foreign_keys = ON");
+  }
+}

package/src/memory/migrations/197-oauth-providers-behavior-columns.ts

@@ -0,0 +1,29 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateOAuthProvidersBehaviorColumns(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+  const columns = [
+    "loopback_port INTEGER",
+    "injection_templates TEXT",
+    "setup_skill_id TEXT",
+    "app_type TEXT",
+    "setup_notes TEXT",
+    "identity_url TEXT",
+    "identity_method TEXT",
+    "identity_headers TEXT",
+    "identity_body TEXT",
+    "identity_response_paths TEXT",
+    "identity_format TEXT",
+    "identity_ok_field TEXT",
+  ];
+  for (const col of columns) {
+    try {
+      raw.exec(`ALTER TABLE oauth_providers ADD COLUMN ${col}`);
+    } catch {
+      // Column already exists — nothing to do.
+    }
+  }
+}

package/src/memory/migrations/198-drop-setup-skill-id-column.ts

@@ -0,0 +1,11 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateDropSetupSkillIdColumn(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(/*sql*/ `ALTER TABLE oauth_providers DROP COLUMN setup_skill_id`);
+  } catch {
+    // Column already dropped or doesn't exist — nothing to do.
+  }
+}

package/src/memory/migrations/index.ts

@@ -132,6 +132,12 @@ export { migrateCallSessionSkipDisclosure } from "./190-call-session-skip-disclo
 export { migrateBackfillAudioAttachmentMimeTypes } from "./191-backfill-audio-attachment-mime-types.js";
 export { migrateContactsUserFileColumn } from "./192-contacts-user-file-column.js";
 export { migrateAddSourceTypeColumns } from "./193-add-source-type-columns.js";
+export { migrateCreateMemoryRecallLogs } from "./194-memory-recall-logs.js";
+export { migrateOAuthProvidersPingConfig } from "./195-oauth-providers-ping-config.js";
+export { migrateMessagesConversationCreatedAtIndex } from "./196-messages-conversation-created-at-index.js";
+export { migrateStripIntegrationPrefixFromProviderKeys } from "./196-strip-integration-prefix-from-provider-keys.js";
+export { migrateOAuthProvidersBehaviorColumns } from "./197-oauth-providers-behavior-columns.js";
+export { migrateDropSetupSkillIdColumn } from "./198-drop-setup-skill-id-column.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/migrations/registry.ts

@@ -38,6 +38,7 @@ import { migrateBackfillInlineAttachmentsToDiskDown } from "./180-backfill-inlin
 import { migrateRenameThreadStartersCheckpointsDown } from "./181-rename-thread-starters-checkpoints.js";
 import { migrateBackfillAudioAttachmentMimeTypesDown } from "./191-backfill-audio-attachment-mime-types.js";
 import { migrateAddSourceTypeColumnsDown } from "./193-add-source-type-columns.js";
+import { migrateStripIntegrationPrefixFromProviderKeysDown } from "./196-strip-integration-prefix-from-provider-keys.js";
 
 export interface MigrationRegistryEntry {
   /** The checkpoint key written to memory_checkpoints on completion. */
@@ -333,6 +334,13 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
       "Add source_type and source_message_role columns to memory_items with backfill from verification_state and source messages",
     down: migrateAddSourceTypeColumnsDown,
   },
+  {
+    key: "migration_strip_integration_prefix_from_provider_keys_v1",
+    version: 38,
+    description:
+      "Strip integration: prefix from provider_key across oauth_providers, oauth_apps, and oauth_connections",
+    down: migrateStripIntegrationPrefixFromProviderKeysDown,
+  },
 ];
 
 export function getMaxMigrationVersion(): number {

package/src/memory/retriever.test.ts

@@ -331,8 +331,7 @@ describe("Memory Retriever Pipeline", () => {
     expect(result.enabled).toBe(true);
     expect(result.degraded).toBe(false);
     expect(result.degradation).toBeUndefined();
-    // With mock Qdrant returning empty results and recency-only candidates
-    // scoring below tier thresholds, no candidates are selected.
+    // With Qdrant mocked empty, no candidates are found.
     // The pipeline still completes successfully with tier metadata.
     expect(result.tier1Count).toBeDefined();
     expect(result.tier2Count).toBeDefined();
@@ -345,7 +344,7 @@ describe("Memory Retriever Pipeline", () => {
   // Current-conversation segment filtering
   // -----------------------------------------------------------------------
 
-  test("current-conversation segments are filtered from recency results", async () => {
+  test("current-conversation segments are filtered from search results", async () => {
     const db = getDb();
     const now = Date.now();
     const activeConv = "conv-active";
@@ -613,7 +612,7 @@ describe("Memory Retriever Pipeline", () => {
 
     insertConversation(db, convId, now - MS_PER_DAY * 200);
 
-    // Create a message from 200 days ago to serve as recency source
+    // Create a message from 200 days ago (staleness test anchor)
     insertMessage(
       db,
       "msg-old",
@@ -679,7 +678,7 @@ describe("Memory Retriever Pipeline", () => {
   // Degradation: Qdrant circuit breaker open
   // -----------------------------------------------------------------------
 
-  test("Qdrant unavailable: pipeline completes with recency fallback", async () => {
+  test("Qdrant unavailable: pipeline completes with empty results", async () => {
     seedMemory();
 
     // Force the Qdrant circuit breaker open