@vellumai/assistant 0.8.3 → 0.8.5

package/src/memory/jobs-store.ts

@@ -1,6 +1,7 @@
 import { and, asc, eq, inArray, lte, notInArray, or, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import { getConfig } from "../config/loader.js";
 import { getLogger } from "../util/logger.js";
 import { truncate } from "../util/truncate.js";
 import { getDb } from "./db-connection.js";
@@ -43,6 +44,9 @@ export type MemoryJobType =
   | "memory_v2_migrate"
   | "memory_v2_reembed"
   | "memory_v2_activation_recompute"
+  | "memory_v3_consolidate"
+  | "memory_v3_index_maintenance"
+  | "memory_v3_edge_learning"
   | "memory_retrospective";
 
 export const EMBED_JOB_TYPES: MemoryJobType[] = [
@@ -66,12 +70,22 @@ export const SLOW_LLM_JOB_TYPES: MemoryJobType[] = [
   "generate_conversation_starters",
   "memory_v2_sweep",
   "memory_v2_consolidate",
+  "memory_v3_consolidate",
   "memory_v2_migrate",
   "memory_retrospective",
   "backfill",
   "graph_bootstrap",
 ];
 
+/** Returns `false` only when `config.memory.enabled` is explicitly `false`; defaults to `true` on missing config or load errors. */
+export function isMemoryEnabled(): boolean {
+  try {
+    return getConfig().memory?.enabled !== false;
+  } catch {
+    return true;
+  }
+}
+
 export interface MemoryJob<T = Record<string, unknown>> {
   id: string;
   type: MemoryJobType;

package/src/memory/jobs-worker.ts

@@ -1,3 +1,5 @@
+import { join } from "node:path";
+
 import { getConfig } from "../config/loader.js";
 import type { AssistantConfig } from "../config/types.js";
 import {
@@ -6,6 +8,7 @@ import {
   shouldLogDiskPressureBackgroundSkip,
 } from "../daemon/disk-pressure-background-gate.js";
 import { getLogger } from "../util/logger.js";
+import { getWorkspaceDir } from "../util/platform.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
 import {
   getLastScheduledCleanupEnqueueMs,
@@ -75,8 +78,14 @@ import {
   memoryV2MigrateJob,
   memoryV2ReembedJob,
 } from "./v2/backfill-jobs.js";
-import { memoryV2ConsolidateJob } from "./v2/consolidation-job.js";
+import {
+  countBufferLines,
+  memoryV2ConsolidateJob,
+} from "./v2/consolidation-job.js";
 import { memoryV2SweepJob } from "./v2/sweep-job.js";
+import { memoryV3ConsolidateJob } from "./v3/consolidation-job.js";
+import { memoryV3EdgeLearningJob } from "./v3/edge-learning-job.js";
+import { memoryV3IndexMaintenanceJob } from "./v3/maintenance.js";
 
 const log = getLogger("memory-jobs-worker");
 
@@ -253,7 +262,7 @@ export async function runMemoryJobsOnce(
       maybeEnqueueScheduledCleanupJobs(config);
     }
     maybeEnqueueGraphMaintenanceJobs(config);
-    maybeRunDbMaintenance();
+    await maybeRunDbMaintenance();
     return 0;
   }
 
@@ -307,7 +316,7 @@ export async function runMemoryJobsOnce(
     maybeEnqueueScheduledCleanupJobs(config);
   }
   maybeEnqueueGraphMaintenanceJobs(config);
-  maybeRunDbMaintenance();
+  await maybeRunDbMaintenance();
   return slowProcessed + fastProcessed + embedProcessed;
 }
 
@@ -518,10 +527,10 @@ async function processJob(
       pruneOldConversationsJob(job, config);
       return;
     case "prune_old_llm_request_logs":
-      pruneOldLlmRequestLogsJob(job, config);
+      await pruneOldLlmRequestLogsJob(job, config);
       return;
     case "prune_old_trace_events":
-      pruneOldTraceEventsJob(job, config);
+      await pruneOldTraceEventsJob(job, config);
       return;
     case "build_conversation_summary":
       // Stale rows enqueued before v2 was enabled must not consume the
@@ -597,6 +606,16 @@ async function processJob(
     case "memory_v2_consolidate":
       await memoryV2ConsolidateJob(job, config);
       return;
+    case "memory_v3_consolidate":
+      await memoryV3ConsolidateJob(job, config);
+      return;
+    case "memory_v3_index_maintenance":
+      await memoryV3IndexMaintenanceJob(job);
+      return;
+    case "memory_v3_edge_learning":
+      // Fast lane: bounded DB work (decay + reinforce + read), no LLM.
+      memoryV3EdgeLearningJob(job);
+      return;
     case "memory_v2_migrate":
       await memoryV2MigrateJob(job, config);
       return;
@@ -675,17 +694,28 @@ export const GRAPH_MAINTENANCE_CHECKPOINTS = {
   patternScan: "graph_maintenance:pattern_scan:last_run",
   narrative: "graph_maintenance:narrative:last_run",
   memoryV2Consolidate: "memory_v2_consolidate_last_run",
+  memoryV3Consolidate: "memory_v3_consolidate_last_run",
 } as const;
 
 /**
  * Enqueue periodic graph maintenance jobs.
  *
  * Mutually exclusive between v1 and v2:
- *   - v2 active (`memory.v2.enabled` on) → only `memory_v2_consolidate` is
- *     scheduled.
+ *   - v2 active (`memory.v2.enabled` on) → only one buffer-drainer is
+ *     scheduled (see below).
  *   - v2 inactive → the four v1 entries (decay, consolidate, pattern_scan,
  *     narrative) are scheduled instead.
  *
+ * **Buffer-drainer retarget (v2 vs v3).** The `memory/buffer.md` is shared, so
+ * exactly one consolidator may own the drain at a time. When
+ * `memory.v3.write.enabled` is on, the v3 consolidator (`memory_v3_consolidate`)
+ * is scheduled INSTEAD of `memory_v2_consolidate` — same shared buffer +
+ * standing-context files, additionally authored into the v3 tree. When the v3
+ * write flag is off (default) the v2 consolidator stays the sole drainer,
+ * unchanged. The retarget is a clean conditional, fully reversible via the flag.
+ * Concept pages stay the shared canonical store, so the v2 router keeps working
+ * off pages v3 writes regardless of which consolidator ran.
+ *
  * Read/write paths route to v2 when the flag is on, so v1 graph data goes
  * unread; running v1 maintenance alongside v2 is wasted compute and LLM
  * spend. The v1 code path remains live so flipping the flag back to off
@@ -702,20 +732,29 @@ export function maybeEnqueueGraphMaintenanceJobs(
   nowMs = Date.now(),
 ): void {
   const v2Active = config.memory.v2.enabled;
+  const v3WriteActive = config.memory.v3.write.enabled;
+
+  // The single buffer-drainer entry for the v2-active branch: v3 when the v3
+  // write flag owns the drain, v2 otherwise. Same shared buffer either way.
+  const consolidateEntry = v3WriteActive
+    ? {
+        key: GRAPH_MAINTENANCE_CHECKPOINTS.memoryV3Consolidate,
+        intervalMs: config.memory.v3.write.consolidateIntervalMs,
+        jobType: "memory_v3_consolidate" as MemoryJobType,
+      }
+    : {
+        key: GRAPH_MAINTENANCE_CHECKPOINTS.memoryV2Consolidate,
+        intervalMs:
+          config.memory.v2.consolidation_interval_hours * 60 * 60 * 1000,
+        jobType: "memory_v2_consolidate" as MemoryJobType,
+      };
 
   const schedule: Array<{
     key: string;
     intervalMs: number;
     jobType: MemoryJobType;
   }> = v2Active
-    ? [
-        {
-          key: GRAPH_MAINTENANCE_CHECKPOINTS.memoryV2Consolidate,
-          intervalMs:
-            config.memory.v2.consolidation_interval_hours * 60 * 60 * 1000,
-          jobType: "memory_v2_consolidate",
-        },
-      ]
+    ? [consolidateEntry]
     : [
         {
           key: GRAPH_MAINTENANCE_CHECKPOINTS.decay,
@@ -739,11 +778,25 @@ export function maybeEnqueueGraphMaintenanceJobs(
         },
       ];
 
+  let enqueuedConsolidate = false;
   for (const { key, intervalMs, jobType } of schedule) {
     const lastRun = parseInt(getMemoryCheckpoint(key) ?? "0", 10);
     if (nowMs - lastRun >= intervalMs) {
       enqueueMemoryJob(jobType, {});
       setMemoryCheckpoint(key, String(nowMs));
+      if (jobType === consolidateEntry.jobType) enqueuedConsolidate = true;
+    }
+  }
+
+  // Size-based trigger: when the shared buffer crosses the configured line
+  // count, drain it now rather than waiting out the interval. Retargets to the
+  // same consolidator the interval branch above selected.
+  const maxLines = config.memory.v2.consolidation_max_buffer_lines;
+  if (v2Active && !enqueuedConsolidate && maxLines !== null) {
+    const bufferPath = join(getWorkspaceDir(), "memory", "buffer.md");
+    if (countBufferLines(bufferPath) >= maxLines) {
+      enqueueMemoryJob(consolidateEntry.jobType, {});
+      setMemoryCheckpoint(consolidateEntry.key, String(nowMs));
     }
   }
 }

package/src/memory/llm-request-log-source-clickhouse.ts

@@ -58,6 +58,16 @@ interface ClickHouseRow {
   response_payload: string;
   created_at: string;
   agent_loop_exit_reason: string;
+  /**
+   * Mirrors `llm_request_logs.call_site` from the SQLite source. Added
+   * to the CH `default.llm_request_logs` table via ALTER TABLE (matching
+   * the `agent_loop_exit_reason` precedent — see
+   * `memory/concepts/objects/clickhouse-mirror.md`).
+   *
+   * CH columns are `DEFAULT ''` rather than Nullable, so empty-string
+   * means "not set" — `toLogRow` maps that back to NULL on the JS side.
+   */
+  call_site: string;
 }
 
 /** Injectable fetch override for tests. Defaults to globalThis.fetch. */
@@ -125,7 +135,8 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
         request_payload,
         response_payload,
         toUnixTimestamp64Milli(created_at) AS created_at,
-        agent_loop_exit_reason
+        agent_loop_exit_reason,
+        call_site
       FROM ${this.tableRef()}
       WHERE assistant_id = {assistant_id:String}
         AND id = {log_id:String}
@@ -171,6 +182,33 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
     );
   }
 
+  async getRequestLogsByConversationId(
+    conversationId: string,
+  ): Promise<LogRow[]> {
+    const aid = await this.assistantId();
+    const sql = `SELECT
+        id,
+        conversation_id,
+        message_id,
+        provider,
+        request_payload,
+        response_payload,
+        toUnixTimestamp64Milli(created_at) AS created_at,
+        agent_loop_exit_reason,
+        call_site
+      FROM ${this.tableRef()}
+      WHERE assistant_id = {assistant_id:String}
+        AND conversation_id = {conversation_id:String}
+      ORDER BY created_at ASC, id ASC
+      LIMIT 1 BY id
+      FORMAT JSONEachRow`;
+    const rows = await this.exec(sql, {
+      assistant_id: aid,
+      conversation_id: conversationId,
+    });
+    return rows.map((r) => this.toLogRow(r));
+  }
+
   private async selectByMessageIds(ids: string[]): Promise<LogRow[]> {
     if (ids.length === 0) return [];
     const aid = await this.assistantId();
@@ -197,7 +235,8 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
         request_payload,
         response_payload,
         toUnixTimestamp64Milli(created_at) AS created_at,
-        agent_loop_exit_reason
+        agent_loop_exit_reason,
+        call_site
       FROM ${this.tableRef()}
       WHERE assistant_id = {assistant_id:String}
         AND message_id IN (${placeholders.join(",")})
@@ -288,6 +327,7 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
       createdAt: Number(row.created_at),
       agentLoopExitReason:
         row.agent_loop_exit_reason === "" ? null : row.agent_loop_exit_reason,
+      callSite: row.call_site === "" ? null : row.call_site,
     };
   }
 

package/src/memory/llm-request-log-source-local.ts

@@ -11,6 +11,7 @@
 import type { LlmRequestLogSource } from "./llm-request-log-source.js";
 import {
   getRequestLogById,
+  getRequestLogsByConversationId,
   getRequestLogsByMessageId,
   type LogRow,
 } from "./llm-request-log-store.js";
@@ -23,4 +24,10 @@ export class LocalLlmRequestLogSource implements LlmRequestLogSource {
   async getRequestLogsByMessageId(messageId: string): Promise<LogRow[]> {
     return getRequestLogsByMessageId(messageId);
   }
+
+  async getRequestLogsByConversationId(
+    conversationId: string,
+  ): Promise<LogRow[]> {
+    return getRequestLogsByConversationId(conversationId);
+  }
 }

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

@@ -1,8 +1,8 @@
 /**
  * Pluggable read source for LLM request logs.
  *
- * The Inspector view at `GET /v1/messages/:id/llm-context` (and the
- * single-log payload route) historically read directly from the local
+ * The Inspector views at `GET /v1/messages/:id/llm-context` and
+ * `GET /v1/conversations/llm-context` (plus the single-log payload route) historically read directly from the local
  * SQLite `llm_request_logs` table via `llm-request-log-store.ts`. The
  * source-of-truth remains local, but the *read path* is now configurable
  * via `llmRequestLogs.readSource` in workspace config.
@@ -31,6 +31,13 @@ export interface LlmRequestLogSource {
    * INSERT-only against the source-of-truth).
    */
   getRequestLogsByMessageId(messageId: string): Promise<LogRow[]>;
+
+  /**
+   * Fetch every LLM request log associated with the given conversation.
+   * This is the conversation-wide inspector read path: linked, unlinked,
+   * and orphaned logs are all included because they share conversation_id.
+   */
+  getRequestLogsByConversationId(conversationId: string): Promise<LogRow[]>;
 }
 
 /**

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

@@ -1,6 +1,7 @@
-import { and, desc, eq, gte, inArray, isNull, lte, sql } from "drizzle-orm";
+import { and, asc, desc, eq, gte, inArray, isNull, lte, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import type { LLMCallSite } from "../config/schemas/llm.js";
 import { AssistantError, ProviderError } from "../util/errors.js";
 import {
   getAssistantMessageIdsInTurn,
@@ -26,6 +27,12 @@ export type LogRow = {
    * `AgentLoopExitReason` in `agent/loop.ts`.
    */
   agentLoopExitReason: string | null;
+  /**
+   * Logical call site that produced this row — `mainAgent`,
+   * `compactionAgent`, etc. NULL on pre-migration-264 rows (no backfill).
+   * In practice values come from `LLMCallSite` (`config/schemas/llm.ts`).
+   */
+  callSite: string | null;
 };
 
 /**
@@ -73,6 +80,7 @@ export function recordRequestLog(
   responsePayload: string,
   messageId?: string,
   provider?: string,
+  callSite?: LLMCallSite,
 ): string {
   const db = getDb();
   const id = uuid();
@@ -88,6 +96,10 @@ export function recordRequestLog(
       // Stamped later via setAgentLoopExitReasonOnLatestLog, once the
       // agent loop body actually exits. Intermediate rows stay NULL.
       agentLoopExitReason: null,
+      // Logical call site (`mainAgent`, `compactionAgent`, …). NULL when
+      // a caller hasn't been updated yet — preserves backward compat
+      // while we plumb call sites through one site at a time.
+      callSite: callSite ?? null,
     })
     .run();
   return id;
@@ -182,6 +194,7 @@ function selectLogsByMessageIds(messageIds: string[]): LogRow[] {
       responsePayload: llmRequestLogs.responsePayload,
       createdAt: llmRequestLogs.createdAt,
       agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
+      callSite: llmRequestLogs.callSite,
     })
     .from(llmRequestLogs)
     .where(inArray(llmRequestLogs.messageId, messageIds))
@@ -189,6 +202,32 @@ function selectLogsByMessageIds(messageIds: string[]): LogRow[] {
     .all();
 }
 
+/**
+ * Query every LLM request log recorded for a conversation, ordered by
+ * creation time. Conversation-scoped inspector views intentionally do
+ * not apply turn recovery: the `conversation_id` column already includes
+ * linked, unlinked, and orphaned rows for the full conversation.
+ */
+export function getRequestLogsByConversationId(conversationId: string): LogRow[] {
+  const db = getDb();
+  return db
+    .select({
+      id: llmRequestLogs.id,
+      conversationId: llmRequestLogs.conversationId,
+      messageId: llmRequestLogs.messageId,
+      provider: llmRequestLogs.provider,
+      requestPayload: llmRequestLogs.requestPayload,
+      responsePayload: llmRequestLogs.responsePayload,
+      createdAt: llmRequestLogs.createdAt,
+      agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
+      callSite: llmRequestLogs.callSite,
+    })
+    .from(llmRequestLogs)
+    .where(eq(llmRequestLogs.conversationId, conversationId))
+    .orderBy(asc(llmRequestLogs.createdAt), asc(llmRequestLogs.id))
+    .all();
+}
+
 /**
  * Find orphaned logs — logs whose `message_id` references a message that no
  * longer exists in the DB. These are left behind when intermediate assistant
@@ -214,6 +253,7 @@ function selectOrphanedLogsInRange(
       responsePayload: llmRequestLogs.responsePayload,
       createdAt: llmRequestLogs.createdAt,
       agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
+      callSite: llmRequestLogs.callSite,
     })
     .from(llmRequestLogs)
     .leftJoin(messages, eq(llmRequestLogs.messageId, messages.id))
@@ -255,6 +295,7 @@ function selectUnlinkedLogsInRange(
       responsePayload: llmRequestLogs.responsePayload,
       createdAt: llmRequestLogs.createdAt,
       agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
+      callSite: llmRequestLogs.callSite,
     })
     .from(llmRequestLogs)
     .where(
@@ -282,6 +323,7 @@ export function getRequestLogById(logId: string): LogRow | null {
         responsePayload: llmRequestLogs.responsePayload,
         createdAt: llmRequestLogs.createdAt,
         agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
+      callSite: llmRequestLogs.callSite,
       })
       .from(llmRequestLogs)
       .where(eq(llmRequestLogs.id, logId))

package/src/memory/llm-usage-store.ts

@@ -57,6 +57,7 @@ export function recordUsageEvent(
       outputTokens: event.outputTokens,
       cacheCreationInputTokens: event.cacheCreationInputTokens,
       cacheReadInputTokens: event.cacheReadInputTokens,
+      rawUsage: event.rawUsage === null ? null : JSON.stringify(event.rawUsage),
       estimatedCostUsd: event.estimatedCostUsd,
       pricingStatus: event.pricingStatus,
       llmCallCount: event.llmCallCount ?? 1,
@@ -87,6 +88,7 @@ function rowToUsageEvent(row: {
   outputTokens: number;
   cacheCreationInputTokens: number | null;
   cacheReadInputTokens: number | null;
+  rawUsage: string | null;
   estimatedCostUsd: number | null;
   pricingStatus: string;
 }): UsageEvent {
@@ -107,11 +109,32 @@ function rowToUsageEvent(row: {
     outputTokens: row.outputTokens,
     cacheCreationInputTokens: row.cacheCreationInputTokens,
     cacheReadInputTokens: row.cacheReadInputTokens,
+    rawUsage: parseRawUsage(row.rawUsage),
     estimatedCostUsd: row.estimatedCostUsd,
     pricingStatus: row.pricingStatus as "priced" | "unpriced",
   };
 }
 
+/**
+ * Parse the JSON-serialized provider usage payload stored in `raw_usage`.
+ * Returns `null` for missing or malformed values; malformed JSON is logged
+ * and discarded rather than failing the read, because callers (admin
+ * dashboards, telemetry forwarders) treat `raw_usage` as opaque diagnostic
+ * data and shouldn't be blocked by a single corrupt row.
+ */
+function parseRawUsage(value: string | null): Record<string, unknown> | null {
+  if (value === null) return null;
+  try {
+    const parsed = JSON.parse(value);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 export function listUsageEvents(options?: { limit?: number }): UsageEvent[] {
   const db = getDb();
   const rows = db
@@ -187,6 +210,7 @@ export function queryUnreportedUsageEvents(
       outputTokens: llmUsageEvents.outputTokens,
       cacheCreationInputTokens: llmUsageEvents.cacheCreationInputTokens,
       cacheReadInputTokens: llmUsageEvents.cacheReadInputTokens,
+      rawUsage: llmUsageEvents.rawUsage,
       estimatedCostUsd: llmUsageEvents.estimatedCostUsd,
       pricingStatus: llmUsageEvents.pricingStatus,
       conversationType: conversations.conversationType,

package/src/memory/memory-retrospective-constants.ts

@@ -5,9 +5,37 @@
  */
 export const MEMORY_RETROSPECTIVE_SOURCE = "memory-retrospective";
 
+/**
+ * Sentinel value for the `source` column of fork-based memory-retrospective
+ * conversations (the new `memory-retrospective-fork` flag path). Distinct
+ * from MEMORY_RETROSPECTIVE_SOURCE so dedup can scope its message scan to the
+ * post-fork tail — fork-kind rows carry the full source prefix and would
+ * otherwise pollute prior-remember dedup with source-inline `remember` calls.
+ */
+export const MEMORY_RETROSPECTIVE_FORK_SOURCE = "memory-retrospective-fork";
+
+/**
+ * Union of both retrospective source sentinels. Use when looking up the most
+ * recent retrospective for a source conversation (either kind is valid) or
+ * when filtering retrospective bg conversations out of recursion queries.
+ */
+export const MEMORY_RETROSPECTIVE_SOURCES: readonly string[] = [
+  MEMORY_RETROSPECTIVE_SOURCE,
+  MEMORY_RETROSPECTIVE_FORK_SOURCE,
+];
+
 /**
  * Dedicated `group_id` value for memory-retrospective background
  * conversations. Placed under `system:background` alongside auto-analysis,
  * heartbeat, and filing conversations.
  */
 export const MEMORY_RETROSPECTIVE_GROUP_ID = "system:background";
+
+/**
+ * `metadata.kind` value stamped on the user-role instruction message that
+ * fork-based retrospectives append to the forked conversation. Used purely
+ * for observability — operators inspecting a retrospective fork's history
+ * can tell the user-role message apart from a real user turn.
+ */
+export const MEMORY_RETROSPECTIVE_INSTRUCTION_KIND =
+  "memory_retrospective_instruction";

package/src/memory/memory-retrospective-enqueue.ts

@@ -19,8 +19,11 @@ import {
 } from "../runtime/actor-trust-resolver.js";
 import { getLogger } from "../util/logger.js";
 import { getConversationSource } from "./conversation-crud.js";
-import { upsertMemoryRetrospectiveJob } from "./jobs-store.js";
-import { MEMORY_RETROSPECTIVE_SOURCE } from "./memory-retrospective-constants.js";
+import {
+  isMemoryEnabled,
+  upsertMemoryRetrospectiveJob,
+} from "./jobs-store.js";
+import { MEMORY_RETROSPECTIVE_SOURCES } from "./memory-retrospective-constants.js";
 
 const log = getLogger("memory-retrospective-enqueue");
 
@@ -38,6 +41,10 @@ export function enqueueMemoryRetrospectiveIfEnabled(args: {
 }): void {
   const { conversationId, trigger } = args;
 
+  if (!isMemoryEnabled()) {
+    return;
+  }
+
   if (isMemoryRetrospectiveConversation(conversationId)) {
     log.debug(
       { conversationId, trigger },
@@ -67,7 +74,8 @@ export function enqueueMemoryRetrospectiveIfEnabled(args: {
 export function isMemoryRetrospectiveConversation(
   conversationId: string,
 ): boolean {
-  return getConversationSource(conversationId) === MEMORY_RETROSPECTIVE_SOURCE;
+  const source = getConversationSource(conversationId);
+  return source !== null && MEMORY_RETROSPECTIVE_SOURCES.includes(source);
 }
 
 /**