@vellumai/assistant 0.7.2 → 0.8.0

package/src/memory/graph/tool-handlers.ts

@@ -2,14 +2,13 @@
 // Memory Tool handlers
 //
 // remember: save facts to the PKB (buffer.md + daily archive) under the v1
-// path, or to memory/buffer.md + memory/archive/<today>.md when the
-// `memory-v2-enabled` feature flag is on.
+// path, or to memory/buffer.md + memory/archive/<today>.md when memory v2 is
+// active.
 // ---------------------------------------------------------------------------
 
 import { appendFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
@@ -46,7 +45,7 @@ export function handleRemember(
   const now = new Date();
   const entry = formatRememberEntry(input.content.trim(), now);
 
-  if (isAssistantFeatureFlagEnabled("memory-v2-enabled", config)) {
+  if (config.memory.v2.enabled) {
     appendBufferAndArchive({
       rootDir: join(workspaceDir, "memory"),
       entry,

package/src/memory/graph/tools.ts

@@ -56,10 +56,10 @@ export const graphRecallDefinition: ToolDefinition = {
 /**
  * Save a fact to the assistant's knowledge base. The fact is appended to
  * `buffer.md` (immediately available in the next conversation) and the daily
- * archive (permanent date-indexed record). With the `memory-v2-enabled`
- * feature flag on, writes go under `memory/`; otherwise they go under
- * `pkb/`. Consolidation of the buffer into longer-form storage runs as a
- * separate periodic job in both modes.
+ * archive (permanent date-indexed record). When `memory.v2.enabled` is true,
+ * writes go under `memory/`; otherwise they go under `pkb/`. Consolidation
+ * of the buffer into longer-form storage runs as a separate periodic job in
+ * both modes.
  */
 export const graphRememberDefinition: ToolDefinition = {
   name: "remember",

package/src/memory/indexer.ts

@@ -175,39 +175,9 @@ export async function indexMessageNow(
     // Summaries still run — they feed the graph retrieval pipeline and
     // are not recursion-prone.
     if (!isAutoAnalysisSource) {
-      // ── Graph extraction ────────────────────────────────────────────
-      const graphPendingKey = `graph_extract:${input.conversationId}:pending_count`;
-      const graphCurrentVal = getMemoryCheckpoint(graphPendingKey);
-      const graphPendingCount =
-        (graphCurrentVal ? parseInt(graphCurrentVal, 10) : 0) + 1;
-      setMemoryCheckpoint(graphPendingKey, String(graphPendingCount));
-
-      const graphBatchFired = graphPendingCount >= batchSize;
-      if (graphBatchFired) {
-        setMemoryCheckpoint(graphPendingKey, "0");
-      }
-
-      // Single pending `graph_extract` row per conversation. If the
-      // batch threshold just fired, pull `runAfter` back to now so the
-      // job runs immediately; otherwise debounce by the idle timeout.
-      // Routing both paths through `upsertDebouncedJob` ensures the
-      // row's `runAfter` reflects whichever trigger ran last, so a
-      // batch crossing always takes effect immediately.
-      const extractRunAfter = graphBatchFired
-        ? Date.now()
-        : Date.now() + idleTimeoutMs;
-      upsertDebouncedJob(
-        "graph_extract",
-        {
-          conversationId: input.conversationId,
-          scopeId: input.scopeId ?? "default",
-        },
-        extractRunAfter,
-      );
-
-      // Reading config here is best-effort: feature-gated triggers below
-      // (memory v2 sweep, auto-analyze batch) skip when it fails — the
-      // idle-debounced enqueues above are unaffected.
+      // Reading config here is best-effort: when it fails we treat v2 as
+      // inactive (failing-open to v1) so a config error never silently
+      // drops both extraction paths.
       let triggerConfig: ReturnType<typeof getConfig> | null = null;
       try {
         triggerConfig = getConfig();
@@ -218,20 +188,58 @@ export async function indexMessageNow(
         );
       }
 
-      // Memory v2 sweep mirrors graph_extract's debounce: when the v2
-      // flag + config are on AND `sweep_enabled` is set, every extraction
-      // trigger also enqueues a sweep. The sweep itself reads recent
-      // messages globally, so the `conversationId` here is just the dedup
-      // key — one pending row per active conversation. All three gates
-      // (feature flag, v2 master toggle, sweep_enabled) must be true.
+      const v2Config =
+        triggerConfig != null && triggerConfig.memory.v2.enabled
+          ? triggerConfig
+          : null;
+
+      // ── Graph extraction (v1) ───────────────────────────────────────
+      // Suppressed when v2 is active — v2 reads memory from buffer.md
+      // and concept pages, so the v1 graph would be stale data nobody
+      // consumes. Pending-count tracking is suppressed too; otherwise a
+      // flag flip back to v1 would fire an immediate batch from counts
+      // accumulated during the v2 window.
+      let extractRunAfter: number;
+      if (v2Config == null) {
+        const graphPendingKey = `graph_extract:${input.conversationId}:pending_count`;
+        const graphCurrentVal = getMemoryCheckpoint(graphPendingKey);
+        const graphPendingCount =
+          (graphCurrentVal ? parseInt(graphCurrentVal, 10) : 0) + 1;
+        setMemoryCheckpoint(graphPendingKey, String(graphPendingCount));
+
+        const graphBatchFired = graphPendingCount >= batchSize;
+        if (graphBatchFired) {
+          setMemoryCheckpoint(graphPendingKey, "0");
+        }
+
+        // Single pending `graph_extract` row per conversation. If the
+        // batch threshold just fired, pull `runAfter` back to now so the
+        // job runs immediately; otherwise debounce by the idle timeout.
+        // Routing both paths through `upsertDebouncedJob` ensures the
+        // row's `runAfter` reflects whichever trigger ran last, so a
+        // batch crossing always takes effect immediately.
+        extractRunAfter = graphBatchFired
+          ? Date.now()
+          : Date.now() + idleTimeoutMs;
+        upsertDebouncedJob(
+          "graph_extract",
+          {
+            conversationId: input.conversationId,
+            scopeId: input.scopeId ?? "default",
+          },
+          extractRunAfter,
+        );
+      } else {
+        extractRunAfter = Date.now() + idleTimeoutMs;
+      }
+
+      // Memory v2 sweep: when v2 is on AND `sweep_enabled` is set, every
+      // extraction trigger also enqueues a sweep. The sweep itself reads
+      // recent messages globally, so the `conversationId` here is just
+      // the dedup key — one pending row per active conversation.
       // `sweep_enabled` defaults to false because `remember()` is the
       // primary capture path; the sweep is opt-in.
-      if (
-        triggerConfig != null &&
-        isAssistantFeatureFlagEnabled("memory-v2-enabled", triggerConfig) &&
-        triggerConfig.memory.v2.enabled &&
-        triggerConfig.memory.v2.sweep_enabled
-      ) {
+      if (v2Config != null && v2Config.memory.v2.sweep_enabled) {
         upsertDebouncedJob(
           "memory_v2_sweep",
           { conversationId: input.conversationId },

package/src/memory/job-handlers/backfill.ts

@@ -7,10 +7,7 @@ import {
   resetMessageCursorCheckpoint,
   writeMessageCursorCheckpoint,
 } from "../checkpoints.js";
-import {
-  getConversationMemoryScopeId,
-  messageMetadataSchema,
-} from "../conversation-crud.js";
+import { messageMetadataSchema } from "../conversation-crud.js";
 import { getDb } from "../db-connection.js";
 import { indexMessageNow } from "../indexer.js";
 import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
@@ -72,13 +69,7 @@ export async function backfillJob(
     .all();
 
   if (batch.length > 0) {
-    const scopeCache = new Map<string, string>();
     for (const message of batch) {
-      let scopeId = scopeCache.get(message.conversationId);
-      if (scopeId === undefined) {
-        scopeId = getConversationMemoryScopeId(message.conversationId);
-        scopeCache.set(message.conversationId, scopeId);
-      }
       const { provenanceTrustClass, automated } = parseMessageMetadata(
         message.metadata ?? null,
       );
@@ -89,7 +80,7 @@ export async function backfillJob(
           role: message.role,
           content: message.content,
           createdAt: message.createdAt,
-          scopeId,
+          scopeId: "default",
           provenanceTrustClass,
           automated,
         },

package/src/memory/job-handlers/cleanup.ts

@@ -54,6 +54,49 @@ export function pruneOldLlmRequestLogsJob(
   );
 }
 
+/**
+ * Delete trace events older than the configured retention period.
+ * Processes in batches to avoid long DB locks and excessive WAL growth.
+ * Re-enqueues itself if more rows remain.
+ */
+export function pruneOldTraceEventsJob(
+  job: MemoryJob,
+  config: AssistantConfig,
+): void {
+  const rawRetention = job.payload.retentionDays;
+  const retentionDays =
+    typeof rawRetention === "number" &&
+    Number.isFinite(rawRetention) &&
+    rawRetention >= 0
+      ? rawRetention
+      : config.memory.cleanup.traceEventRetentionDays;
+
+  // 0 means disabled
+  if (retentionDays === 0) return;
+
+  const cutoffMs = Date.now() - retentionDays * 86_400_000;
+
+  rawRun(
+    `DELETE FROM trace_events WHERE rowid IN (SELECT rowid FROM trace_events WHERE created_at < ? LIMIT ?)`,
+    cutoffMs,
+    PRUNE_LOG_BATCH_LIMIT,
+  );
+  const deleted = rawChanges();
+
+  if (deleted >= PRUNE_LOG_BATCH_LIMIT) {
+    enqueueMemoryJob("prune_old_trace_events", { retentionDays });
+  }
+
+  log.info(
+    {
+      deleted,
+      retentionDays,
+      cutoffMs,
+    },
+    "Pruned old trace events",
+  );
+}
+
 /**
  * Delete conversations that have had no activity (updatedAt) for longer than
  * the configured retention period. Processes in batches so a single job doesn't

package/src/memory/job-handlers/embedding.ts

@@ -3,7 +3,6 @@ import { readFile } from "node:fs/promises";
 import { eq } from "drizzle-orm";
 
 import type { AssistantConfig } from "../../config/types.js";
-import { getConversationMemoryScopeId } from "../conversation-crud.js";
 import { getDb } from "../db-connection.js";
 import type { EmbeddingInput } from "../embedding-types.js";
 import { asString, embedAndUpsert } from "../job-utils.js";
@@ -18,7 +17,7 @@ import {
 
 export async function embedSegmentJob(
   job: MemoryJob,
-  config: AssistantConfig
+  config: AssistantConfig,
 ): Promise<void> {
   const segmentId = asString(job.payload.segmentId);
   if (!segmentId) return;
@@ -39,7 +38,7 @@ export async function embedSegmentJob(
 
 export async function embedSummaryJob(
   job: MemoryJob,
-  config: AssistantConfig
+  config: AssistantConfig,
 ): Promise<void> {
   const summaryId = asString(job.payload.summaryId);
   if (!summaryId) return;
@@ -60,13 +59,13 @@ export async function embedSummaryJob(
       created_at: summary.startAt,
       last_seen_at: summary.endAt,
       memory_scope_id: summary.scopeId,
-    }
+    },
   );
 }
 
 export async function embedMediaJob(
   job: MemoryJob,
-  config: AssistantConfig
+  config: AssistantConfig,
 ): Promise<void> {
   const assetId = asString(job.payload.assetId);
   if (!assetId) return;
@@ -99,7 +98,7 @@ export async function embedMediaJob(
 
 export async function embedAttachmentJob(
   job: MemoryJob,
-  config: AssistantConfig
+  config: AssistantConfig,
 ): Promise<void> {
   const messageId = asString(job.payload.messageId);
   const blockIndex = job.payload.blockIndex as number;
@@ -125,11 +124,10 @@ export async function embedAttachmentJob(
 
   // Use messageId + blockIndex as targetId for uniqueness
   const targetId = `${messageId}:${blockIndex}`;
-  const memoryScopeId = getConversationMemoryScopeId(message.conversationId);
   await embedAndUpsert(config, "media", targetId, input, {
     created_at: message.createdAt,
     message_id: messageId,
     conversation_id: message.conversationId,
-    memory_scope_id: memoryScopeId,
+    memory_scope_id: "default",
   });
 }

package/src/memory/job-handlers/summarization.ts

@@ -10,7 +10,6 @@ import {
   userMessage,
 } from "../../providers/provider-send-message.js";
 import { getLogger } from "../../util/logger.js";
-import { getConversationMemoryScopeId } from "../conversation-crud.js";
 import { getDb } from "../db-connection.js";
 import { asString, truncate } from "../job-utils.js";
 import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
@@ -91,10 +90,6 @@ export async function buildConversationSummaryJob(
     "conversation",
   );
 
-  // Inherit the conversation's memory scope so summaries stay aligned with
-  // the retrieval scope used by the source conversation.
-  const scopeId = getConversationMemoryScopeId(conversationId);
-
   const now = Date.now();
   const summaryId = existing?.id ?? uuid();
   const nextVersion = (existing?.version ?? 0) + 1;
@@ -108,7 +103,7 @@ export async function buildConversationSummaryJob(
       id: summaryId,
       scope: "conversation",
       scopeKey: conversationId,
-      scopeId,
+      scopeId: "default",
       summary: summaryText,
       tokenEstimate: estimateTextTokens(summaryText),
       version: nextVersion,
@@ -123,7 +118,7 @@ export async function buildConversationSummaryJob(
         summary: summaryText,
         tokenEstimate: estimateTextTokens(summaryText),
         version: sql`${memorySummaries.version} + 1`,
-        scopeId,
+        scopeId: "default",
         startAt: earliestCovered,
         endAt: latestCovered,
         updatedAt: now,

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

@@ -86,6 +86,10 @@ const upsertCalls: Array<{
   slug: string;
   dense: number[];
   sparse: { indices: number[]; values: number[] };
+  summary?: {
+    dense: number[];
+    sparse: { indices: number[]; values: number[] };
+  };
   updatedAt: number;
 }> = [];
 
@@ -96,6 +100,10 @@ mock.module("../../v2/qdrant.js", () => ({
     slug: string;
     dense: number[];
     sparse: { indices: number[]; values: number[] };
+    summary?: {
+      dense: number[];
+      sparse: { indices: number[]; values: number[] };
+    };
     updatedAt: number;
   }) => {
     upsertCalls.push(params);
@@ -242,6 +250,114 @@ describe("embedConceptPageJob — happy path", () => {
   });
 });
 
+describe("embedConceptPageJob — summary embedding", () => {
+  test("embeds the summary when present and forwards summary vectors to upsert", async () => {
+    await writePage(tmpWorkspace, {
+      slug: "summarized-page",
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        summary: "A short prose summary that retrieval indexes separately.",
+      },
+      body: "Long-form body content.\n",
+    });
+
+    await embedConceptPageJob(
+      makeJob({ slug: "summarized-page" }),
+      TEST_CONFIG,
+    );
+
+    // Body and summary are batched into one backend call (saves a round-trip).
+    expect(embedWithBackendCalls).toHaveLength(1);
+    expect(embedWithBackendCalls[0].inputs).toHaveLength(2);
+    expect(upsertCalls).toHaveLength(1);
+    const call = upsertCalls[0];
+    expect(call.slug).toBe("summarized-page");
+    expect(call.dense).toEqual([0.1, 0.2, 0.3, 0.4]);
+    expect(call.sparse).toBeDefined();
+    expect(call.summary?.dense).toEqual([0.1, 0.2, 0.3, 0.4]);
+    expect(call.summary?.sparse).toBeDefined();
+  });
+
+  test("skips summary embedding when the page has no summary in frontmatter", async () => {
+    await writePage(tmpWorkspace, {
+      slug: "legacy-page",
+      frontmatter: { edges: [], ref_files: [] },
+      body: "Body only — no summary in frontmatter.\n",
+    });
+
+    await embedConceptPageJob(makeJob({ slug: "legacy-page" }), TEST_CONFIG);
+
+    // Only the body was embedded.
+    expect(embedWithBackendCalls).toHaveLength(1);
+    expect(upsertCalls).toHaveLength(1);
+    const call = upsertCalls[0];
+    expect(call.summary).toBeUndefined();
+  });
+
+  test("skips summary embedding when the summary is whitespace-only", async () => {
+    // Whitespace-only summaries (` `, `\n`) are equivalent to absent — the
+    // embedding backend would reject the empty input downstream anyway.
+    await writePage(tmpWorkspace, {
+      slug: "whitespace-summary",
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        summary: "   ",
+      },
+      body: "Body content.\n",
+    });
+
+    await embedConceptPageJob(
+      makeJob({ slug: "whitespace-summary" }),
+      TEST_CONFIG,
+    );
+
+    expect(embedWithBackendCalls).toHaveLength(1);
+    expect(upsertCalls[0].summary).toBeUndefined();
+  });
+
+  test("body and summary cache rows are independent (summary edit doesn't invalidate body)", async () => {
+    // Write a page with a summary, run the job to prime caches.
+    await writePage(tmpWorkspace, {
+      slug: "cached-summary",
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        summary: "First version of the summary.",
+      },
+      body: "Stable body that never changes.\n",
+    });
+    await embedConceptPageJob(
+      makeJob({ slug: "cached-summary" }),
+      TEST_CONFIG,
+    );
+    // Body + summary batched into a single backend call on first run.
+    expect(embedWithBackendCalls).toHaveLength(1);
+    expect(embedWithBackendCalls[0].inputs).toHaveLength(2);
+
+    // Edit only the summary — body stays identical, only the summary text
+    // changes. Re-running the job should hit the body cache (no re-embed)
+    // but recompute the summary embedding.
+    await writePage(tmpWorkspace, {
+      slug: "cached-summary",
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        summary: "Second version of the summary, different wording.",
+      },
+      body: "Stable body that never changes.\n",
+    });
+    await embedConceptPageJob(
+      makeJob({ slug: "cached-summary" }),
+      TEST_CONFIG,
+    );
+    // One additional backend call with only the summary text — body hit the cache.
+    expect(embedWithBackendCalls).toHaveLength(2);
+    expect(embedWithBackendCalls[1].inputs).toHaveLength(1);
+  });
+});
+
 describe("embedConceptPageJob — cache hit", () => {
   test("reuses the cached dense vector when content hash matches", async () => {
     await writePage(tmpWorkspace, {