@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/memory/graph/store.ts

@@ -450,7 +450,10 @@ export function getEdgesForNode(
       ? eq(memoryGraphEdges.sourceNodeId, nodeId)
       : direction === "incoming"
         ? eq(memoryGraphEdges.targetNodeId, nodeId)
-        : or(eq(memoryGraphEdges.sourceNodeId, nodeId), eq(memoryGraphEdges.targetNodeId, nodeId));
+        : or(
+            eq(memoryGraphEdges.sourceNodeId, nodeId),
+            eq(memoryGraphEdges.targetNodeId, nodeId),
+          );
 
   // Exclude edges where either endpoint has fidelity='gone' (soft-deleted)
   const condition = and(
@@ -577,12 +580,7 @@ export function getActiveTriggersByType(
       memoryGraphNodes,
       eq(memoryGraphTriggers.nodeId, memoryGraphNodes.id),
     )
-    .where(
-      and(
-        ...conditions,
-        sql`${memoryGraphNodes.fidelity} != 'gone'`,
-      ),
-    )
+    .where(and(...conditions, sql`${memoryGraphNodes.fidelity} != 'gone'`))
     .all();
   return rows.map((r) => rowToTrigger(r.trigger));
 }
@@ -680,19 +678,20 @@ export function applyDiff(
     createdNodeIds: [],
   };
 
+  // Qdrant-cleanup jobs target the dedicated memory connection (`memory_jobs`
+  // lives in its own file), so they can't share this main-DB transaction —
+  // collect the deleted node ids and enqueue them after the transaction commits.
+  const deletedNodeIds: string[] = [];
+
   db.transaction((tx) => {
-    // Soft-delete nodes (set fidelity='gone' and enqueue Qdrant cleanup)
+    // Soft-delete nodes (set fidelity='gone'); the Qdrant cleanup is enqueued
+    // after commit.
     for (const id of diff.deleteNodeIds) {
       tx.update(memoryGraphNodes)
         .set({ fidelity: "gone", lastAccessed: Date.now() })
         .where(eq(memoryGraphNodes.id, id))
         .run();
-      enqueueMemoryJob(
-        "delete_qdrant_vectors",
-        { targetType: "graph_node", targetId: id },
-        Date.now(),
-        tx,
-      );
+      deletedNodeIds.push(id);
       result.nodesDeleted++;
     }
 
@@ -862,6 +861,16 @@ export function applyDiff(
     }
   });
 
+  // Flush Qdrant-cleanup jobs onto the memory connection now the node soft-
+  // deletes have committed — enqueue only on success, mirroring the prior
+  // in-transaction behavior without spanning the two connections.
+  for (const id of deletedNodeIds) {
+    enqueueMemoryJob("delete_qdrant_vectors", {
+      targetType: "graph_node",
+      targetId: id,
+    });
+  }
+
   return result;
 }
 

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

@@ -22,7 +22,13 @@ const log = getLogger("graph-tool-handlers");
 // ---------------------------------------------------------------------------
 
 export interface RememberInput {
-  content: string;
+  /**
+   * The fact(s) to remember. A single string records one fact; an array
+   * records several independent facts in one call (each becomes its own
+   * timestamped entry), so a single turn can batch unrelated facts instead of
+   * calling `remember` once per fact.
+   */
+  content: string | string[];
   finish_turn?: boolean;
 }
 
@@ -31,13 +37,33 @@ export interface RememberResult {
   message: string;
 }
 
+/**
+ * Normalize the `remember` content input to a list of non-empty facts.
+ * Accepts the single-string form or the batch array form, trims each fact, and
+ * drops blanks so an empty or whitespace-only input yields no facts.
+ */
+function normalizeFacts(content: string | string[]): string[] {
+  const raw = Array.isArray(content) ? content : [content];
+  return raw
+    .filter((fact): fact is string => typeof fact === "string")
+    .map((fact) => fact.trim())
+    .filter((fact) => fact.length > 0);
+}
+
+function rememberSuccessMessage(count: number): string {
+  return count === 1
+    ? "Saved to knowledge base."
+    : `Saved ${count} facts to knowledge base.`;
+}
+
 export function handleRemember(
   input: RememberInput,
   _conversationId: string,
   _scopeId: string,
   config: AssistantConfig,
 ): RememberResult {
-  if (!input.content || input.content.trim().length === 0) {
+  const facts = normalizeFacts(input.content);
+  if (facts.length === 0) {
     return { success: false, message: "content is required" };
   }
   if (config.memory.enabled === false) {
@@ -46,7 +72,10 @@ export function handleRemember(
 
   const workspaceDir = getWorkspaceDir();
   const now = new Date();
-  const entry = formatRememberEntry(input.content.trim(), now);
+  // Each fact becomes its own timestamped bullet; a batched call writes them
+  // all in a single append so one turn can record several independent facts.
+  const entry = facts.map((fact) => formatRememberEntry(fact, now)).join("");
+  const message = rememberSuccessMessage(facts.length);
 
   if (config.memory.v2.enabled) {
     appendBufferAndArchive({
@@ -57,7 +86,7 @@ export function handleRemember(
     // v2 path skips the PKB re-index queue — embedding for memory v2 happens
     // via the dedicated `embed_concept_page` job after consolidation, not on
     // every remember() write.
-    return { success: true, message: "Saved to knowledge base." };
+    return { success: true, message };
   }
 
   const pkbDir = join(workspaceDir, "pkb");
@@ -69,7 +98,7 @@ export function handleRemember(
   enqueuePkbReindex(pkbDir, bufferPath);
   enqueuePkbReindex(pkbDir, archivePath);
 
-  return { success: true, message: "Saved to knowledge base." };
+  return { success: true, message };
 }
 
 /**

package/src/memory/graph/tools.ts

@@ -77,9 +77,12 @@ export const graphRememberDefinition = {
     type: "object",
     properties: {
       content: {
-        type: "string",
+        anyOf: [
+          { type: "string" },
+          { type: "array", items: { type: "string" }, minItems: 1 },
+        ],
         description:
-          "The fact to remember. Write naturally — a preference, a detail, a commitment, a plan. No need to categorize.",
+          "The fact(s) to remember. Pass a single string for one fact, or an array of strings to record several independent facts in one call. When a turn surfaces multiple unrelated facts, pass them all as an array in one call rather than calling `remember` once per fact. Write naturally — a preference, a detail, a commitment, a plan. No need to categorize.",
       },
       finish_turn: {
         type: "boolean",

package/src/memory/indexer.ts

@@ -95,10 +95,17 @@ export async function indexMessageNow(
       ? candidateMediaMeta
       : [];
 
-  // Wrap all segment inserts and job enqueues in a single transaction so they
-  // either all succeed or all roll back, preventing partial/orphaned state.
+  // Wrap all segment inserts in a single transaction so they either all
+  // succeed or all roll back, preventing partial/orphaned state. The job
+  // enqueues target the dedicated memory connection (`memory_jobs` lives in
+  // its own file), so they can't share this main-DB transaction — collect them
+  // here and flush them after the transaction commits.
   let skippedEmbedJobs = 0;
   let skippedShortSegments = 0;
+  const pendingJobs: Array<{
+    type: "embed_segment" | "embed_attachment";
+    payload: Record<string, unknown>;
+  }> = [];
   db.transaction((tx) => {
     for (const segment of segments) {
       if (segment.text.length < MIN_SEGMENT_CHARS) {
@@ -144,7 +151,7 @@ export async function indexMessageNow(
       if (existing?.contentHash === hash) {
         skippedEmbedJobs++;
       } else if (isMemoryEnabled()) {
-        enqueueMemoryJob("embed_segment", { segmentId }, Date.now(), tx);
+        pendingJobs.push({ type: "embed_segment", payload: { segmentId } });
       }
     }
 
@@ -152,16 +159,21 @@ export async function indexMessageNow(
     // embedding provider supports multimodal (Gemini only).
     if (isMemoryEnabled()) {
       for (const block of mediaBlocks) {
-        enqueueMemoryJob(
-          "embed_attachment",
-          { messageId: input.messageId, blockIndex: block.index },
-          Date.now(),
-          tx,
-        );
+        pendingJobs.push({
+          type: "embed_attachment",
+          payload: { messageId: input.messageId, blockIndex: block.index },
+        });
       }
     }
   });
 
+  // Flush queued jobs onto the memory connection now the segment writes have
+  // committed — enqueue only on success, mirroring the prior in-transaction
+  // behavior without spanning the two connections.
+  for (const job of pendingJobs) {
+    enqueueMemoryJob(job.type, job.payload);
+  }
+
   // ── Batch extraction tracking ──────────────────────────────────────
   // Instead of per-message extraction, track pending unextracted messages
   // and trigger batch extraction when the threshold is reached or after idle.

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

@@ -1,9 +1,10 @@
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
+import { getLogsDbPath } from "../../util/logs-db-path.js";
 import { runAsyncSqlite } from "../db-async-query.js";
 import { getDb } from "../db-connection.js";
 import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
-import { rawAll, rawRun } from "../raw-query.js";
+import { rawAll, rawLogsRun, rawRun } from "../raw-query.js";
 
 const log = getLogger("memory-jobs-worker");
 
@@ -49,9 +50,14 @@ export async function pruneOldLlmRequestLogsJob(
   // fallback backend in `db-async-query.ts` synthesizes the same shape
   // by capturing `changes()` atomically after `exec()`. Both backends
   // end up on the parser path below.
+  // llm_request_logs lives in the dedicated logs database. Point the prune at
+  // that file directly via `dbPath` — both backends open it as their own
+  // database (the subprocess directly, the in-process fallback via a transient
+  // connection), so the DELETE hits the right file.
   const result = await runAsyncSqlite(
     `DELETE FROM llm_request_logs WHERE rowid IN (SELECT rowid FROM llm_request_logs WHERE created_at < ${cutoffMs} LIMIT ${PRUNE_LOG_BATCH_LIMIT});
 SELECT changes();`,
+    { dbPath: getLogsDbPath() },
   );
   if (!result.ok) {
     log.warn(
@@ -203,8 +209,9 @@ export function pruneOldConversationsJob(
       );
       if (still.length === 0) return;
 
-      // Non-cascading tables
-      rawRun(`DELETE FROM llm_request_logs WHERE conversation_id = ?`, id);
+      // Non-cascading tables. llm_request_logs lives in the dedicated logs
+      // connection, so it is deleted there (outside this main-DB transaction).
+      rawLogsRun(`DELETE FROM llm_request_logs WHERE conversation_id = ?`, id);
       rawRun(`DELETE FROM tool_invocations WHERE conversation_id = ?`, id);
       rawRun(`DELETE FROM messages WHERE conversation_id = ?`, id);
       rawRun(`DELETE FROM skill_loaded_events WHERE conversation_id = ?`, id);

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

@@ -61,14 +61,14 @@ const TEST_CONFIG: AssistantConfig = {
 };
 
 describe("embedMediaJob", () => {
-  beforeAll(() => {
-    initializeDb();
+  beforeAll(async () => {
+    await initializeDb();
   });
 
-  beforeEach(() => {
+  beforeEach(async () => {
     embedAndUpsertCalls.length = 0;
     resetDbForTesting();
-    initializeDb();
+    await initializeDb();
   });
 
   function makeJob(payload: Record<string, unknown>): MemoryJob {

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

@@ -142,7 +142,7 @@ afterAll(() => {
 // Imports are deferred to after the env var is set so any internal use of
 // `getWorkspaceDir()` resolves to the tmpdir.
 const { DEFAULT_CONFIG } = await import("../../../config/defaults.js");
-const { getDb } = await import("../../db-connection.js");
+const { getDb, getMemoryDb } = await import("../../db-connection.js");
 const { resetDbForTesting } =
   await import("../../../__tests__/db-test-helpers.js");
 const { initializeDb } = await import("../../db-init.js");
@@ -184,11 +184,11 @@ function makeJob(payload: Record<string, unknown>): MemoryJob {
   };
 }
 
-beforeEach(() => {
+beforeEach(async () => {
   resetDbForTesting();
   // The first run pays the full cold-start migration chain; bump the hook
   // timeout above bun's 5s default so the leading test doesn't flake in CI.
-  initializeDb();
+  await initializeDb();
   embedWithBackendCalls.length = 0;
   upsertCalls.length = 0;
   deleteCalls.length = 0;
@@ -547,7 +547,7 @@ describe("enqueueEmbedConceptPageJob", () => {
   test("inserted job row carries the right type and slug payload", () => {
     const id = enqueueEmbedConceptPageJob({ slug: "row-check" });
 
-    const row = getDb()
+    const row = getMemoryDb()!
       .select()
       .from(memoryJobs)
       .all()

package/src/memory/jobs/embed-pkb-file.test.ts

@@ -33,7 +33,7 @@ mock.module("../../config/loader.js", () => ({
 
 import { DEFAULT_CONFIG } from "../../config/defaults.js";
 import type { AssistantConfig } from "../../config/types.js";
-import { getDb } from "../db-connection.js";
+import { getMemoryDb } from "../db-connection.js";
 import { initializeDb } from "../db-init.js";
 import {
   claimMemoryJobs,
@@ -62,13 +62,13 @@ function makeJob(payload: Record<string, unknown>): MemoryJob {
 }
 
 describe("embedPkbFileJob", () => {
-  beforeAll(() => {
-    initializeDb();
+  beforeAll(async () => {
+    await initializeDb();
   });
 
   beforeEach(() => {
     indexPkbFileCalls.length = 0;
-    const db = getDb();
+    const db = getMemoryDb()!;
     db.delete(memoryJobs).run();
   });
 
@@ -116,13 +116,13 @@ describe("embedPkbFileJob", () => {
 });
 
 describe("enqueuePkbIndexJob", () => {
-  beforeAll(() => {
-    initializeDb();
+  beforeAll(async () => {
+    await initializeDb();
   });
 
   beforeEach(() => {
     indexPkbFileCalls.length = 0;
-    const db = getDb();
+    const db = getMemoryDb()!;
     db.delete(memoryJobs).run();
   });
 

package/src/memory/jobs-store.ts

@@ -4,7 +4,7 @@ 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";
+import { type DrizzleDb, getMemoryDb } from "./db-connection.js";
 import {
   isEmbeddingBillingBreakerOpen,
   shouldAllowBillingProbe,
@@ -13,11 +13,23 @@ import {
   isQdrantBreakerOpen,
   shouldAllowQdrantProbe,
 } from "./qdrant-circuit-breaker.js";
-import { rawAll, rawChanges } from "./raw-query.js";
+import { rawMemoryAll, rawMemoryChanges } from "./raw-query.js";
 import { memoryJobs } from "./schema.js";
 
 const log = getLogger("memory-jobs-store");
 
+/**
+ * The memory connection (`assistant-memory.db`), where `memory_jobs` lives.
+ * Throws if the file cannot be opened — the work queue has no fallback.
+ */
+function memoryDb(): DrizzleDb {
+  const db = getMemoryDb();
+  if (!db) {
+    throw new Error("memory database unavailable");
+  }
+  return db;
+}
+
 export type MemoryJobType =
   | "embed_segment"
   | "embed_summary"
@@ -115,13 +127,13 @@ export function enqueueMemoryJob(
   type: MemoryJobType,
   payload: Record<string, unknown>,
   runAfter = Date.now(),
-  dbOverride?: Parameters<ReturnType<typeof getDb>["transaction"]>[0] extends (
+  dbOverride?: Parameters<DrizzleDb["transaction"]>[0] extends (
     tx: infer T,
   ) => unknown
     ? T
     : never,
 ): string {
-  const db = dbOverride ?? getDb();
+  const db = dbOverride ?? memoryDb();
   const id = uuid();
   const now = Date.now();
   db.insert(memoryJobs)
@@ -157,13 +169,13 @@ export function upsertDebouncedJob(
   type: MemoryJobType,
   payload: { conversationId: string } & Record<string, unknown>,
   runAfter: number,
-  dbOverride?: Parameters<ReturnType<typeof getDb>["transaction"]>[0] extends (
+  dbOverride?: Parameters<DrizzleDb["transaction"]>[0] extends (
     tx: infer T,
   ) => unknown
     ? T
     : never,
 ): void {
-  const db = dbOverride ?? getDb();
+  const db = dbOverride ?? memoryDb();
   const existing = db
     .select()
     .from(memoryJobs)
@@ -211,13 +223,13 @@ export function upsertAutoAnalysisJob(
     triggerGroup: "immediate" | "debounced";
   },
   runAfter: number,
-  dbOverride?: Parameters<ReturnType<typeof getDb>["transaction"]>[0] extends (
+  dbOverride?: Parameters<DrizzleDb["transaction"]>[0] extends (
     tx: infer T,
   ) => unknown
     ? T
     : never,
 ): void {
-  const db = dbOverride ?? getDb();
+  const db = dbOverride ?? memoryDb();
   // Match rows with the same triggerGroup OR legacy rows without triggerGroup
   // (from older builds that used upsertDebouncedJob before triggerGroup was
   // introduced). Without the IS NULL fallback, the next enqueue would insert
@@ -293,13 +305,13 @@ export function upsertAutoAnalysisJob(
 export function upsertMemoryRetrospectiveJob(
   payload: { conversationId: string },
   runAfter: number = Date.now(),
-  dbOverride?: Parameters<ReturnType<typeof getDb>["transaction"]>[0] extends (
+  dbOverride?: Parameters<DrizzleDb["transaction"]>[0] extends (
     tx: infer T,
   ) => unknown
     ? T
     : never,
 ): void {
-  const db = dbOverride ?? getDb();
+  const db = dbOverride ?? memoryDb();
   const existing = db
     .select()
     .from(memoryJobs)
@@ -331,7 +343,7 @@ export function upsertMemoryRetrospectiveJob(
  * Used to prevent duplicate enqueues for long-running maintenance jobs.
  */
 export function hasActiveJobOfType(type: MemoryJobType): boolean {
-  const db = getDb();
+  const db = memoryDb();
   return (
     db
       .select({ id: memoryJobs.id })
@@ -347,7 +359,7 @@ export function hasActiveJobOfType(type: MemoryJobType): boolean {
 }
 
 export function enqueuePruneOldLlmRequestLogsJob(retentionMs?: number): string {
-  const db = getDb();
+  const db = memoryDb();
   const existing = db
     .select()
     .from(memoryJobs)
@@ -396,7 +408,7 @@ export function enqueuePruneOldLlmRequestLogsJob(retentionMs?: number): string {
 export function enqueuePruneOldConversationsJob(
   retentionDays?: number,
 ): string {
-  const db = getDb();
+  const db = memoryDb();
   const existing = db
     .select()
     .from(memoryJobs)
@@ -443,7 +455,7 @@ export function enqueuePruneOldConversationsJob(
 }
 
 export function enqueuePruneOldTraceEventsJob(retentionDays?: number): string {
-  const db = getDb();
+  const db = memoryDb();
   const existing = db
     .select()
     .from(memoryJobs)
@@ -498,7 +510,7 @@ export interface LaneBudgets {
 export function claimMemoryJobs(limits: LaneBudgets): MemoryJob[] {
   if (limits.slowLlm <= 0 && limits.fast <= 0 && limits.embed <= 0) return [];
 
-  const db = getDb();
+  const db = memoryDb();
   const now = Date.now();
   const pendingFilter = and(
     eq(memoryJobs.status, "pending"),
@@ -584,7 +596,7 @@ export function claimMemoryJobs(limits: LaneBudgets): MemoryJob[] {
       .set({ status: "running", startedAt: now, updatedAt: now })
       .where(and(eq(memoryJobs.id, row.id), eq(memoryJobs.status, "pending")))
       .run();
-    if (rawChanges() === 0) continue;
+    if (rawMemoryChanges() === 0) continue;
     claimed.push(
       parseRow({
         ...row,
@@ -598,7 +610,7 @@ export function claimMemoryJobs(limits: LaneBudgets): MemoryJob[] {
 }
 
 export function completeMemoryJob(id: string): void {
-  const db = getDb();
+  const db = memoryDb();
   db.update(memoryJobs)
     .set({ status: "completed", updatedAt: Date.now(), lastError: null })
     .where(eq(memoryJobs.id, id))
@@ -626,7 +638,7 @@ const DEFER_MAX_DELAY_MS = 5 * 60 * 1000;
  * were exceeded and the job was marked as failed.
  */
 export function deferMemoryJob(id: string): "deferred" | "failed" {
-  const db = getDb();
+  const db = memoryDb();
   const row = db.select().from(memoryJobs).where(eq(memoryJobs.id, id)).get();
   if (!row) return "failed";
 
@@ -683,7 +695,7 @@ export function failMemoryJob(
 ): void {
   const retryDelayMs = options?.retryDelayMs ?? 30_000;
   const maxAttempts = options?.maxAttempts ?? 5;
-  const db = getDb();
+  const db = memoryDb();
   const row = db.select().from(memoryJobs).where(eq(memoryJobs.id, id)).get();
   if (!row) return;
   const attempts = row.attempts + 1;
@@ -713,12 +725,12 @@ export function failMemoryJob(
 }
 
 export function resetRunningJobsToPending(): number {
-  const db = getDb();
+  const db = memoryDb();
   db.update(memoryJobs)
     .set({ status: "pending", updatedAt: Date.now() })
     .where(eq(memoryJobs.status, "running"))
     .run();
-  return rawChanges();
+  return rawMemoryChanges();
 }
 
 /**
@@ -728,7 +740,7 @@ export function resetRunningJobsToPending(): number {
 export function failStalledJobs(timeoutMs: number): number {
   const now = Date.now();
   const cutoff = now - timeoutMs;
-  const stalled = rawAll<{ id: string; type: string }>(
+  const stalled = rawMemoryAll<{ id: string; type: string }>(
     `
     SELECT id, type
     FROM memory_jobs
@@ -740,7 +752,7 @@ export function failStalledJobs(timeoutMs: number): number {
   );
   if (stalled.length === 0) return 0;
 
-  const db = getDb();
+  const db = memoryDb();
   for (const row of stalled) {
     db.update(memoryJobs)
       .set({
@@ -761,7 +773,7 @@ export function failStalledJobs(timeoutMs: number): number {
 }
 
 export function getMemoryJobCounts(): Record<string, number> {
-  const rows = rawAll<{ status: string; c: number }>(`
+  const rows = rawMemoryAll<{ status: string; c: number }>(`
     SELECT status, COUNT(*) AS c
     FROM memory_jobs
     GROUP BY status