@vellumai/assistant 0.5.16 → 0.6.1

package/src/memory/jobs-worker.ts

@@ -1,29 +1,36 @@
 import { getConfig } from "../config/loader.js";
 import type { AssistantConfig } from "../config/types.js";
 import { getLogger } from "../util/logger.js";
-import { rawAll, rawRun } from "./db.js";
+import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
+import { bootstrapFromHistory } from "./graph/bootstrap.js";
+import { runConsolidation } from "./graph/consolidation.js";
+import { runDecayTick } from "./graph/decay.js";
+import { graphExtractJob } from "./graph/extraction-job.js";
+import {
+  embedGraphNodeJob,
+  embedGraphTriggerJob,
+} from "./graph/graph-search.js";
+import { runNarrativeRefinement } from "./graph/narrative.js";
+import { runPatternScan } from "./graph/pattern-scan.js";
 import { backfillJob } from "./job-handlers/backfill.js";
-import { batchExtractJob } from "./job-handlers/batch-extraction.js";
 import {
-  cleanupStaleSupersededItemsJob,
   pruneOldConversationsJob,
+  pruneOldLlmRequestLogsJob,
 } from "./job-handlers/cleanup.js";
 import { generateConversationStartersJob } from "./job-handlers/conversation-starters.js";
 // ── Per-job-type handlers ──────────────────────────────────────────
 import {
   embedAttachmentJob,
-  embedItemJob,
   embedMediaJob,
   embedSegmentJob,
   embedSummaryJob,
 } from "./job-handlers/embedding.js";
-import { extractItemsJob } from "./job-handlers/extraction.js";
 import {
   deleteQdrantVectorsJob,
   rebuildIndexJob,
 } from "./job-handlers/index-maintenance.js";
-import { journalCarryForwardJob } from "./job-handlers/journal-carry-forward.js";
 import { mediaProcessingJob } from "./job-handlers/media-processing.js";
+import { buildConversationSummaryJob } from "./job-handlers/summarization.js";
 import {
   BackendUnavailableError,
   classifyError,
@@ -34,18 +41,37 @@ import {
   claimMemoryJobs,
   completeMemoryJob,
   deferMemoryJob,
-  enqueueCleanupStaleSupersededItemsJob,
   enqueueMemoryJob,
   enqueuePruneOldConversationsJob,
+  enqueuePruneOldLlmRequestLogsJob,
   failMemoryJob,
   failStalledJobs,
   type MemoryJob,
+  type MemoryJobType,
   resetRunningJobsToPending,
 } from "./jobs-store.js";
 import { QdrantCircuitOpenError } from "./qdrant-circuit-breaker.js";
 
 const log = getLogger("memory-jobs-worker");
 
+/**
+ * Job types whose handlers have been removed. Existing rows may still sit in
+ * the database — the worker completes them silently instead of throwing.
+ */
+const LEGACY_JOB_TYPES = new Set([
+  "embed_item",
+  "extract_items",
+  "batch_extract",
+  "extract_entities",
+  "cleanup_stale_superseded_items",
+  "backfill_entity_relations",
+  "refresh_weekly_summary",
+  "refresh_monthly_summary",
+  "journal_carry_forward",
+  "generate_capability_cards",
+  "generate_thread_starters",
+]);
+
 export const POLL_INTERVAL_MIN_MS = 1_500;
 export const POLL_INTERVAL_MAX_MS = 30_000;
 
@@ -60,31 +86,6 @@ export function startMemoryJobsWorker(): MemoryJobsWorker {
     log.info({ recovered }, "Recovered stale running memory jobs");
   }
 
-  // Startup recovery: enqueue batch_extract for conversations with pending
-  // unextracted messages (e.g. after a crash mid-conversation).
-  try {
-    const pendingRows = rawAll<{ key: string; value: string }>(
-      `SELECT key, value FROM memory_checkpoints WHERE key LIKE 'batch_extract:%:pending_count' AND CAST(value AS INTEGER) > 0`,
-    );
-    for (const row of pendingRows) {
-      // Extract conversationId from key: "batch_extract:<conversationId>:pending_count"
-      const parts = row.key.split(":");
-      if (parts.length >= 3) {
-        const conversationId = parts.slice(1, -1).join(":");
-        enqueueMemoryJob("batch_extract", { conversationId });
-        log.info(
-          { conversationId, pendingCount: row.value },
-          "Recovered pending batch extraction on startup",
-        );
-      }
-    }
-  } catch (err) {
-    log.warn(
-      { err: err instanceof Error ? err.message : String(err) },
-      "Failed to recover pending batch extractions on startup",
-    );
-  }
-
   let stopped = false;
   let tickRunning = false;
   let timer: ReturnType<typeof setTimeout>;
@@ -145,9 +146,6 @@ export async function runMemoryJobsOnce(
   if (!config.memory.enabled) return 0;
   const enableScheduledCleanup = options.enableScheduledCleanup === true;
 
-  // Periodic stale item sweep (throttled to at most once per hour)
-  sweepStaleItems(config);
-
   // Fail jobs that have been running longer than the configured timeout
   const timedOut = failStalledJobs(config.memory.jobs.stalledJobTimeoutMs);
   if (timedOut > 0) {
@@ -161,6 +159,7 @@ export async function runMemoryJobsOnce(
     if (enableScheduledCleanup) {
       maybeEnqueueScheduledCleanupJobs(config);
     }
+    maybeEnqueueGraphMaintenanceJobs();
     return 0;
   }
 
@@ -256,9 +255,67 @@ export async function runMemoryJobsOnce(
   if (enableScheduledCleanup) {
     maybeEnqueueScheduledCleanupJobs(config);
   }
+  maybeEnqueueGraphMaintenanceJobs();
   return processed;
 }
 
+// ── Graph lifecycle job handlers ──────────────────────────────────
+
+function graphDecayJob(job: MemoryJob): void {
+  const scopeId = (job.payload as { scopeId?: string })?.scopeId ?? "default";
+  const result = runDecayTick(scopeId);
+  log.info({ jobId: job.id, ...result }, "Graph decay tick complete");
+}
+
+async function graphConsolidateJob(
+  job: MemoryJob,
+  config: AssistantConfig,
+): Promise<void> {
+  const scopeId = (job.payload as { scopeId?: string })?.scopeId ?? "default";
+  const result = await runConsolidation(scopeId, config);
+  log.info(
+    {
+      jobId: job.id,
+      updated: result.totalUpdated,
+      deleted: result.totalDeleted,
+      mergeEdges: result.totalMergeEdges,
+    },
+    "Graph consolidation complete",
+  );
+}
+
+async function graphPatternScanJob(
+  job: MemoryJob,
+  config: AssistantConfig,
+): Promise<void> {
+  const scopeId = (job.payload as { scopeId?: string })?.scopeId ?? "default";
+  const result = await runPatternScan(scopeId, config);
+  log.info(
+    {
+      jobId: job.id,
+      patterns: result.patternsDetected,
+      edges: result.edgesCreated,
+    },
+    "Graph pattern scan complete",
+  );
+}
+
+async function graphNarrativeRefineJob(
+  job: MemoryJob,
+  config: AssistantConfig,
+): Promise<void> {
+  const scopeId = (job.payload as { scopeId?: string })?.scopeId ?? "default";
+  const result = await runNarrativeRefinement(scopeId, config);
+  log.info(
+    {
+      jobId: job.id,
+      updated: result.nodesUpdated,
+      arcs: result.arcsIdentified,
+    },
+    "Graph narrative refinement complete",
+  );
+}
+
 // ── Job error handling ─────────────────────────────────────────────
 
 function handleJobError(job: MemoryJob, err: unknown): void {
@@ -321,45 +378,21 @@ async function processJob(
     case "embed_segment":
       await embedSegmentJob(job, config);
       return;
-    case "embed_item":
-      await embedItemJob(job, config);
-      return;
     case "embed_summary":
       await embedSummaryJob(job, config);
       return;
-    case "extract_items":
-      await extractItemsJob(job);
-      return;
-    case "batch_extract":
-      await batchExtractJob(job);
-      return;
-    case "extract_entities":
-      // Entity extraction has been removed — silently drop legacy jobs
-      return;
-    case "cleanup_stale_superseded_items":
-      cleanupStaleSupersededItemsJob(job, config);
-      return;
     case "prune_old_conversations":
       pruneOldConversationsJob(job, config);
       return;
+    case "prune_old_llm_request_logs":
+      pruneOldLlmRequestLogsJob(job, config);
+      return;
     case "build_conversation_summary":
-      // Deprecated: conversation summaries are now produced as a side-effect
-      // of batch extraction. Silently skip legacy jobs.
-      log.debug(
-        { jobId: job.id },
-        "Skipping deprecated build_conversation_summary job — handled by batch extraction",
-      );
+      await buildConversationSummaryJob(job, config);
       return;
     case "backfill":
       await backfillJob(job, config);
       return;
-    case "backfill_entity_relations":
-      // Entity relation backfill has been removed — silently drop legacy jobs
-      return;
-    case "refresh_weekly_summary":
-    case "refresh_monthly_summary":
-      // Global summary rollups have been removed — silently drop legacy jobs
-      return;
     case "rebuild_index":
       await rebuildIndexJob();
       return;
@@ -375,22 +408,42 @@ async function processJob(
     case "embed_attachment":
       await embedAttachmentJob(job, config);
       return;
-    case "journal_carry_forward":
-      await journalCarryForwardJob(job);
+    case "embed_graph_node":
+      await embedGraphNodeJob(job, config);
+      return;
+    case "graph_trigger_embed":
+      await embedGraphTriggerJob(job, config);
+      return;
+    case "graph_extract":
+      await graphExtractJob(job, config);
+      return;
+    case "graph_decay":
+      graphDecayJob(job);
+      return;
+    case "graph_consolidate":
+      await graphConsolidateJob(job, config);
+      return;
+    case "graph_pattern_scan":
+      await graphPatternScanJob(job, config);
+      return;
+    case "graph_narrative_refine":
+      await graphNarrativeRefineJob(job, config);
       return;
     case "generate_conversation_starters":
       await generateConversationStartersJob(job);
       return;
-    case "generate_capability_cards":
-      // Capability cards were removed — silently drop legacy jobs.
-      return;
-    case "generate_thread_starters":
-      // Thread starters renamed to conversation starters — silently drop legacy jobs
+    case "graph_bootstrap":
+      await bootstrapFromHistory();
       return;
-    default:
-      throw new Error(
-        `Unknown memory job type: ${(job as { type: string }).type}`,
-      );
+
+    default: {
+      const rawType = (job as { type: string }).type;
+      if (LEGACY_JOB_TYPES.has(rawType)) {
+        log.debug({ jobId: job.id, type: rawType }, "Dropping legacy job");
+        return;
+      }
+      throw new Error(`Unknown memory job type: ${rawType}`);
+    }
   }
 }
 
@@ -416,82 +469,80 @@ export function maybeEnqueueScheduledCleanupJobs(
   if (nowMs - lastScheduledCleanupEnqueueMs < cleanup.enqueueIntervalMs)
     return false;
 
-  const staleSupersededItemsJobId = enqueueCleanupStaleSupersededItemsJob(
-    cleanup.supersededItemRetentionMs,
-  );
   const pruneConversationsJobId =
     cleanup.conversationRetentionDays > 0
       ? enqueuePruneOldConversationsJob(cleanup.conversationRetentionDays)
       : null;
+  const pruneLlmRequestLogsJobId =
+    cleanup.llmRequestLogRetentionMs > 0
+      ? enqueuePruneOldLlmRequestLogsJob(cleanup.llmRequestLogRetentionMs)
+      : null;
   lastScheduledCleanupEnqueueMs = nowMs;
   log.debug(
     {
-      staleSupersededItemsJobId,
       pruneConversationsJobId,
+      pruneLlmRequestLogsJobId,
       enqueueIntervalMs: cleanup.enqueueIntervalMs,
-      supersededItemRetentionMs: cleanup.supersededItemRetentionMs,
       conversationRetentionDays: cleanup.conversationRetentionDays,
+      llmRequestLogRetentionMs: cleanup.llmRequestLogRetentionMs,
     },
     "Enqueued scheduled memory cleanup jobs",
   );
   return true;
 }
 
-// ── Stale item sweep ───────────────────────────────────────────────
+// ── Graph maintenance scheduling ──────────────────────────────────
 
-const STALE_SWEEP_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
-let lastStaleSweepMs = 0;
+const GRAPH_DECAY_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+const GRAPH_CONSOLIDATE_INTERVAL_MS = 4 * 60 * 60 * 1000; // 4 hours
+const GRAPH_PATTERN_SCAN_INTERVAL_MS = 24 * 60 * 60 * 1000; // 1 day
+const GRAPH_NARRATIVE_INTERVAL_MS = 7 * 24 * 60 * 60 * 1000; // 1 week
 
-/** Reset the sweep throttle so tests can call sweepStaleItems back-to-back. */
-export function resetStaleSweepThrottle(): void {
-  lastStaleSweepMs = 0;
-}
+const GRAPH_MAINTENANCE_CHECKPOINTS = {
+  decay: "graph_maintenance:decay:last_run",
+  consolidate: "graph_maintenance:consolidate:last_run",
+  patternScan: "graph_maintenance:pattern_scan:last_run",
+  narrative: "graph_maintenance:narrative:last_run",
+} as const;
 
 /**
- * Mark deeply stale memory items as invalid. An item is considered deeply
- * stale when it has exceeded 2x its freshness window for its kind and has
- * not been recently accessed.
- *
- * This is non-destructive: items keep their data but get an `invalid_at`
- * timestamp that excludes them from retrieval queries.
+ * Enqueue periodic graph maintenance jobs (decay, consolidation, pattern scan, narrative).
+ * Uses durable checkpoints so intervals survive daemon restarts — jobs only fire
+ * when the actual elapsed time since last run exceeds the interval.
  */
-export function sweepStaleItems(config: AssistantConfig): number {
-  const freshness = config.memory.retrieval.freshness;
-  if (!freshness.enabled) return 0;
-
-  const now = Date.now();
-  // Throttle: at most once per hour
-  if (now - lastStaleSweepMs < STALE_SWEEP_INTERVAL_MS) return 0;
-  lastStaleSweepMs = now;
-
-  let totalMarked = 0;
-  for (const [kind, maxAgeDays] of Object.entries(freshness.maxAgeDays)) {
-    if (maxAgeDays <= 0) continue;
-    // Mark invalid if: past 2x window, no access in the shield period, and not already invalid
-    const cutoffMs = now - maxAgeDays * 2 * 86_400_000;
-    const shieldCutoffMs = now - freshness.reinforcementShieldDays * 86_400_000;
-    const changes = rawRun(
-      `
-      UPDATE memory_items
-      SET invalid_at = ?
-      WHERE kind = ?
-        AND status = 'active'
-        AND invalid_at IS NULL
-        AND last_seen_at < ?
-        AND (access_count = 0 OR COALESCE(last_used_at, 0) < ?)
-    `,
-      now,
-      kind,
-      cutoffMs,
-      shieldCutoffMs,
-    );
-    if (changes > 0) {
-      log.info(
-        { kind, marked: changes, cutoffMs },
-        "Marked stale memory items as invalid",
-      );
-      totalMarked += changes;
+function maybeEnqueueGraphMaintenanceJobs(nowMs = Date.now()): void {
+  const schedule: Array<{
+    key: string;
+    intervalMs: number;
+    jobType: MemoryJobType;
+  }> = [
+    {
+      key: GRAPH_MAINTENANCE_CHECKPOINTS.decay,
+      intervalMs: GRAPH_DECAY_INTERVAL_MS,
+      jobType: "graph_decay",
+    },
+    {
+      key: GRAPH_MAINTENANCE_CHECKPOINTS.consolidate,
+      intervalMs: GRAPH_CONSOLIDATE_INTERVAL_MS,
+      jobType: "graph_consolidate",
+    },
+    {
+      key: GRAPH_MAINTENANCE_CHECKPOINTS.patternScan,
+      intervalMs: GRAPH_PATTERN_SCAN_INTERVAL_MS,
+      jobType: "graph_pattern_scan",
+    },
+    {
+      key: GRAPH_MAINTENANCE_CHECKPOINTS.narrative,
+      intervalMs: GRAPH_NARRATIVE_INTERVAL_MS,
+      jobType: "graph_narrative_refine",
+    },
+  ];
+
+  for (const { key, intervalMs, jobType } of schedule) {
+    const lastRun = parseInt(getMemoryCheckpoint(key) ?? "0", 10);
+    if (nowMs - lastRun >= intervalMs) {
+      enqueueMemoryJob(jobType, {});
+      setMemoryCheckpoint(key, String(nowMs));
     }
   }
-  return totalMarked;
 }

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

@@ -91,10 +91,7 @@ export function backfillMessageIdOnLogs(
  * for a conversation), this targets only the given log rows — safe for
  * concurrent watch/assistant turns.
  */
-export function setMessageIdOnLogs(
-  logIds: string[],
-  messageId: string,
-): void {
+export function setMessageIdOnLogs(logIds: string[], messageId: string): void {
   if (logIds.length === 0) return;
   const db = getDb();
   db.update(llmRequestLogs)
@@ -185,18 +182,75 @@ function selectOrphanedLogsInRange(
     .all();
 }
 
+/**
+ * Find unlinked logs — logs with `message_id IS NULL` that haven't been
+ * backfilled yet. This covers the race where the client queries the inspector
+ * before `backfillMessageIdOnLogs` runs in `handleMessageComplete`, or when
+ * the backfill fails silently (try-catch in the agent loop).
+ *
+ * Scoped to a single conversation and a time range to avoid cross-turn bleed.
+ */
+function selectUnlinkedLogsInRange(
+  conversationId: string,
+  startTime: number,
+  endTime: number,
+): LogRow[] {
+  if (endTime <= startTime) return [];
+  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,
+    })
+    .from(llmRequestLogs)
+    .where(
+      and(
+        eq(llmRequestLogs.conversationId, conversationId),
+        gte(llmRequestLogs.createdAt, startTime),
+        lte(llmRequestLogs.createdAt, endTime),
+        isNull(llmRequestLogs.messageId),
+      ),
+    )
+    .orderBy(llmRequestLogs.createdAt)
+    .all();
+}
+
+export function getRequestLogById(logId: string): LogRow | null {
+  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,
+      })
+      .from(llmRequestLogs)
+      .where(eq(llmRequestLogs.id, logId))
+      .get() ?? null
+  );
+}
+
 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.
+  // Recovery: find logs in the turn's time window that the message-ID-based
+  // query missed. Two categories:
+  //  1. Orphaned — messageId references a deleted message (retry/deleteLastExchange).
+  //  2. Unlinked — messageId is still NULL because the backfill hasn't run yet
+  //     or failed silently. This covers the race where the client queries the
+  //     inspector before handleMessageComplete persists and backfills.
   const message = getMessageById(messageId);
   if (message) {
     const bounds = getTurnTimeBounds(message.conversationId, message.createdAt);
@@ -206,10 +260,16 @@ export function getRequestLogsByMessageId(messageId: string): LogRow[] {
         bounds.startTime,
         bounds.endTime,
       );
-      if (orphanedLogs.length > 0) {
+      const unlinkedLogs = selectUnlinkedLogsInRange(
+        message.conversationId,
+        bounds.startTime,
+        bounds.endTime,
+      );
+
+      if (orphanedLogs.length > 0 || unlinkedLogs.length > 0) {
         const seen = new Set(turnLogs.map((l) => l.id));
         const merged = [...turnLogs];
-        for (const log of orphanedLogs) {
+        for (const log of [...orphanedLogs, ...unlinkedLogs]) {
           if (!seen.has(log.id)) {
             merged.push(log);
             seen.add(log.id);
@@ -218,6 +278,30 @@ export function getRequestLogsByMessageId(messageId: string): LogRow[] {
         merged.sort(
           (a, b) => a.createdAt - b.createdAt || a.id.localeCompare(b.id),
         );
+
+        // Opportunistically backfill recovered unlinked logs so future queries
+        // hit the fast indexed-by-messageId path.  Guard with isNull so this
+        // recovery path never overwrites a messageId already set by an
+        // authoritative caller (e.g. watch-notifier).
+        if (unlinkedLogs.length > 0 && turnMessageIds.length > 0) {
+          try {
+            const db = getDb();
+            const ids = unlinkedLogs.map((l) => l.id);
+            const targetMessageId = turnMessageIds[turnMessageIds.length - 1]!;
+            db.update(llmRequestLogs)
+              .set({ messageId: targetMessageId })
+              .where(
+                and(
+                  inArray(llmRequestLogs.id, ids),
+                  isNull(llmRequestLogs.messageId),
+                ),
+              )
+              .run();
+          } catch {
+            // non-fatal — the recovery already returned the right data
+          }
+        }
+
         return merged;
       }
     }

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

@@ -23,9 +23,12 @@ export interface RecordMemoryRecallLogParams {
   topCandidatesJson: unknown;
   injectedText?: string;
   reason?: string;
+  queryContext?: string;
 }
 
-export function recordMemoryRecallLog(params: RecordMemoryRecallLogParams): void {
+export function recordMemoryRecallLog(
+  params: RecordMemoryRecallLogParams,
+): void {
   const db = getDb();
   db.insert(memoryRecallLogs)
     .values({
@@ -51,6 +54,7 @@ export function recordMemoryRecallLog(params: RecordMemoryRecallLogParams): void
       topCandidatesJson: JSON.stringify(params.topCandidatesJson),
       injectedText: params.injectedText ?? null,
       reason: params.reason ?? null,
+      queryContext: params.queryContext ?? null,
       createdAt: Date.now(),
     })
     .run();
@@ -90,6 +94,47 @@ export interface MemoryRecallLog {
   topCandidates: unknown;
   injectedText: string | null;
   reason: string | null;
+  queryContext: string | null;
+}
+
+/**
+ * Normalizes top-candidate entries from the stored SSE-event format
+ * (key/finalScore/semantic/recency/kind) to the inspector format expected
+ * by the Swift MemoryRecallCandidate struct (nodeId/score/semanticSimilarity/recencyBoost).
+ * Entries already in inspector format pass through unchanged.
+ */
+export function normalizeTopCandidates(raw: unknown): unknown {
+  if (!Array.isArray(raw)) return raw;
+  return raw.flatMap((entry: Record<string, unknown>) => {
+    if (!entry || typeof entry !== "object") return [];
+
+    // Start with a shallow copy, then apply field renames
+    const { key, finalScore, semantic, recency, kind: _kind, ...rest } = entry;
+
+    // nodeId: prefer existing nodeId, fall back to key
+    if (rest.nodeId === undefined && key !== undefined) {
+      rest.nodeId = key;
+    }
+
+    // score: prefer existing score, fall back to finalScore
+    if (rest.score === undefined && finalScore !== undefined) {
+      rest.score = finalScore;
+    }
+
+    // semanticSimilarity: prefer existing, fall back to semantic
+    if (rest.semanticSimilarity === undefined && semantic !== undefined) {
+      rest.semanticSimilarity = semantic;
+    }
+
+    // recencyBoost: prefer existing, fall back to recency
+    if (rest.recencyBoost === undefined && recency !== undefined) {
+      rest.recencyBoost = recency;
+    }
+
+    // kind is stripped (not in the Swift model) — already excluded via destructuring
+
+    return rest;
+  });
 }
 
 export function getMemoryRecallLogByMessageIds(
@@ -109,9 +154,7 @@ export function getMemoryRecallLogByMessageIds(
     degraded: !!row.degraded,
     provider: row.provider,
     model: row.model,
-    degradation: row.degradationJson
-      ? JSON.parse(row.degradationJson)
-      : null,
+    degradation: row.degradationJson ? JSON.parse(row.degradationJson) : null,
     semanticHits: row.semanticHits,
     mergedCount: row.mergedCount,
     selectedCount: row.selectedCount,
@@ -121,8 +164,9 @@ export function getMemoryRecallLogByMessageIds(
     sparseVectorUsed: !!row.sparseVectorUsed,
     injectedTokens: row.injectedTokens,
     latencyMs: row.latencyMs,
-    topCandidates: JSON.parse(row.topCandidatesJson),
+    topCandidates: normalizeTopCandidates(JSON.parse(row.topCandidatesJson)),
     injectedText: row.injectedText,
     reason: row.reason,
+    queryContext: row.queryContext,
   };
 }

package/src/memory/message-content.ts

@@ -121,6 +121,7 @@ export function extractMediaBlockMeta(
   }
 }
 
+
 function stableJson(value: unknown): string {
   try {
     return JSON.stringify(value);