@vellumai/assistant 0.6.5 → 0.7.0

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

@@ -1,252 +1,25 @@
 // ---------------------------------------------------------------------------
-// Memory Graph — Tool handlers for recall and remember
+// Memory Tool handlers
 //
-// recall: search the living graph or raw archive
-// remember: save facts to the PKB (buffer.md + daily archive)
+// 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.
 // ---------------------------------------------------------------------------
 
 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";
-import { buildExcerpt, buildFtsMatchQuery } from "../conversation-queries.js";
-import { embedWithRetry } from "../embed.js";
-import { generateSparseEmbedding } from "../embedding-backend.js";
 import { enqueuePkbIndexJob } from "../jobs/embed-pkb-file.js";
 import { PKB_WORKSPACE_SCOPE } from "../pkb/types.js";
-import { searchGraphNodes } from "./graph-search.js";
-import { getNodesByIds } from "./store.js";
 
 const log = getLogger("graph-tool-handlers");
 
 // ---------------------------------------------------------------------------
-// recall handler
-// ---------------------------------------------------------------------------
-
-export interface RecallInput {
-  query: string;
-  mode?: "memory" | "archive";
-  num_results?: number;
-  filters?: {
-    types?: string[];
-    after?: string;
-    before?: string;
-  };
-}
-
-export interface RecallResult {
-  results: Array<{
-    id: string;
-    content: string;
-    type: string;
-    confidence: number;
-    significance: number;
-    score: number;
-    created: number;
-  }>;
-  mode: "memory" | "archive";
-  query: string;
-}
-
-export async function handleRecall(
-  input: RecallInput,
-  config: AssistantConfig,
-  scopeId: string,
-): Promise<RecallResult> {
-  const mode = input.mode ?? "memory";
-
-  if (mode === "archive") {
-    return handleArchiveRecall(input, scopeId);
-  }
-
-  return handleMemoryRecall(input, config, scopeId);
-}
-
-async function handleMemoryRecall(
-  input: RecallInput,
-  config: AssistantConfig,
-  scopeId: string,
-): Promise<RecallResult> {
-  // Embed the query
-  let queryVector: number[] | null = null;
-  try {
-    const result = await embedWithRetry(config, [input.query]);
-    queryVector = result.vectors[0] ?? null;
-  } catch (err) {
-    log.warn({ err }, "Failed to embed recall query");
-    return { results: [], mode: "memory", query: input.query };
-  }
-
-  if (!queryVector) {
-    return { results: [], mode: "memory", query: input.query };
-  }
-
-  // Generate sparse embedding for hybrid search (dense + sparse with RRF fusion)
-  const sparseVector = generateSparseEmbedding(input.query);
-
-  // Build date range filter for Qdrant-level filtering
-  const dateRange: { afterMs?: number; beforeMs?: number } = {};
-  if (input.filters?.after) {
-    const afterMs = new Date(input.filters.after).getTime();
-    if (!isNaN(afterMs)) dateRange.afterMs = afterMs;
-  }
-  if (input.filters?.before) {
-    const beforeMs = new Date(input.filters.before).getTime();
-    if (!isNaN(beforeMs)) dateRange.beforeMs = beforeMs;
-  }
-
-  // Search graph nodes
-  const limit = Math.max(1, Math.min(input.num_results ?? 20, 50));
-  const searchResults = await searchGraphNodes(
-    queryVector,
-    limit,
-    [scopeId],
-    sparseVector,
-    dateRange.afterMs != null || dateRange.beforeMs != null
-      ? dateRange
-      : undefined,
-  );
-  if (searchResults.length === 0) {
-    return { results: [], mode: "memory", query: input.query };
-  }
-
-  // Hydrate
-  const nodes = getNodesByIds(searchResults.map((r) => r.nodeId));
-  const nodeMap = new Map(nodes.map((n) => [n.id, n]));
-
-  // Apply filters
-  const results = searchResults.flatMap((r) => {
-    const node = nodeMap.get(r.nodeId);
-    if (!node || node.fidelity === "gone") return [];
-
-    // Type filter
-    if (input.filters?.types && input.filters.types.length > 0) {
-      if (!input.filters.types.includes(node.type)) return [];
-    }
-
-    return [
-      {
-        id: node.id,
-        content: node.content,
-        type: node.type,
-        confidence: node.confidence,
-        significance: node.significance,
-        score: r.score,
-        created: node.created,
-      },
-    ];
-  });
-
-  return { results, mode: "memory", query: input.query };
-}
-
-async function handleArchiveRecall(
-  input: RecallInput,
-  scopeId: string,
-): Promise<RecallResult> {
-  // Archive mode: search raw conversation transcripts via messages FTS
-  // This is a simple text search — no embedding needed
-  const { rawAll } = await import("../db.js");
-
-  try {
-    const limit = Math.max(1, Math.min(input.num_results ?? 20, 50));
-    const ftsMatch = buildFtsMatchQuery(input.query.trim(), {
-      allowFts5Syntax: true,
-    });
-
-    const afterMs = input.filters?.after
-      ? new Date(input.filters.after).getTime()
-      : NaN;
-    const beforeMs = input.filters?.before
-      ? new Date(input.filters.before).getTime()
-      : NaN;
-    const dateConditions: string[] = [];
-    const dateParams: number[] = [];
-    if (!isNaN(afterMs)) {
-      dateConditions.push("m.created_at >= ?");
-      dateParams.push(afterMs);
-    }
-    if (!isNaN(beforeMs)) {
-      dateConditions.push("m.created_at <= ?");
-      dateParams.push(beforeMs);
-    }
-    const dateClause =
-      dateConditions.length > 0 ? " AND " + dateConditions.join(" AND ") : "";
-
-    type ArchiveRow = {
-      id: string;
-      content: string;
-      role: string;
-      created_at: number;
-      conversation_id: string;
-    };
-
-    let rows: ArchiveRow[];
-
-    if (ftsMatch) {
-      // Use SQLite FTS on messages table, scoped to the active memory scope
-      rows = rawAll<ArchiveRow>(
-        `SELECT m.id, m.content, m.role, m.created_at, c.id as conversation_id
-         FROM messages_fts fts
-         JOIN messages m ON m.id = fts.message_id
-         JOIN conversations c ON c.id = m.conversation_id
-         WHERE messages_fts MATCH ?
-           AND c.memory_scope_id = ?${dateClause}
-         ORDER BY rank
-         LIMIT ?`,
-        ftsMatch,
-        scopeId,
-        ...dateParams,
-        limit,
-      );
-    } else if (!input.query.trim()) {
-      // Empty or whitespace-only query — return nothing rather than matching
-      // every message via a `%%` LIKE pattern.
-      rows = [];
-    } else {
-      // All FTS tokens dropped (non-ASCII, single-char, etc.) — fall back to
-      // LIKE-based search so queries like CJK characters still match.
-      const likePattern = `%${input.query
-        .replace(/\\/g, "\\\\")
-        .replace(/%/g, "\\%")
-        .replace(/_/g, "\\_")}%`;
-      rows = rawAll<ArchiveRow>(
-        `SELECT m.id, m.content, m.role, m.created_at, c.id as conversation_id
-         FROM messages m
-         JOIN conversations c ON c.id = m.conversation_id
-         WHERE m.content LIKE ? ESCAPE '\\' AND c.memory_scope_id = ?${dateClause}
-         ORDER BY m.created_at DESC
-         LIMIT ?`,
-        likePattern,
-        scopeId,
-        ...dateParams,
-        limit,
-      );
-    }
-
-    return {
-      results: rows.map((r) => ({
-        id: r.id,
-        content: buildExcerpt(r.content, input.query),
-        type: "archive",
-        confidence: 0,
-        significance: 0,
-        score: 0,
-        created: r.created_at,
-      })),
-      mode: "archive",
-      query: input.query,
-    };
-  } catch (err) {
-    log.warn({ err }, "Archive recall FTS failed");
-    return { results: [], mode: "archive", query: input.query };
-  }
-}
-
-// ---------------------------------------------------------------------------
-// remember handler — writes to PKB buffer + daily archive
+// remember handler — writes to PKB (v1) or memory/ (v2) buffer + daily archive
 // ---------------------------------------------------------------------------
 
 export interface RememberInput {
@@ -263,46 +36,99 @@ export function handleRemember(
   input: RememberInput,
   _conversationId: string,
   _scopeId: string,
+  config: AssistantConfig,
 ): RememberResult {
   if (!input.content || input.content.trim().length === 0) {
     return { success: false, message: "content is required" };
   }
 
   const workspaceDir = getWorkspaceDir();
+  const now = new Date();
+  const entry = formatRememberEntry(input.content.trim(), now);
+
+  if (isAssistantFeatureFlagEnabled("memory-v2-enabled", config)) {
+    appendBufferAndArchive({
+      rootDir: join(workspaceDir, "memory"),
+      entry,
+      now,
+    });
+    // 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." };
+  }
+
   const pkbDir = join(workspaceDir, "pkb");
-  const archiveDir = join(pkbDir, "archive");
+  const { bufferPath, archivePath } = appendBufferAndArchive({
+    rootDir: pkbDir,
+    entry,
+    now,
+  });
+  enqueuePkbReindex(pkbDir, bufferPath);
+  enqueuePkbReindex(pkbDir, archivePath);
 
-  // Ensure directories exist
-  mkdirSync(pkbDir, { recursive: true });
-  mkdirSync(archiveDir, { recursive: true });
+  return { success: true, message: "Saved to knowledge base." };
+}
 
-  // Build timestamped entry
-  const now = new Date();
+/**
+ * Build a timestamped bullet entry for `buffer.md` / `archive/<date>.md`.
+ *
+ * Format mirrors the long-standing v1 PKB layout so v2 buffers stay
+ * human-readable and downstream consumers (sweep, consolidation) can parse
+ * the same shape regardless of which path produced the entry.
+ *
+ * Exported so memory v2 sweep / extractor jobs format their auto-remembered
+ * entries identically to user-facing `remember()` calls.
+ */
+export function formatRememberEntry(content: string, now: Date): string {
   const month = now.toLocaleString("en-US", { month: "short" });
   const day = now.getDate();
   const hours = now.getHours();
   const minutes = String(now.getMinutes()).padStart(2, "0");
   const ampm = hours >= 12 ? "PM" : "AM";
   const displayHour = hours % 12 || 12;
-  const entry = `- [${month} ${day}, ${displayHour}:${minutes} ${ampm}] ${input.content.trim()}\n`;
+  return `- [${month} ${day}, ${displayHour}:${minutes} ${ampm}] ${content}\n`;
+}
 
-  // Append to buffer.md
-  const bufferPath = join(pkbDir, "buffer.md");
+/**
+ * Append `entry` to `<rootDir>/buffer.md` and `<rootDir>/archive/<today>.md`,
+ * creating the archive directory and seeding the archive header if missing.
+ *
+ * Returns the absolute paths of both files so callers can fan out follow-up
+ * work (e.g. PKB re-indexing in the v1 path).
+ *
+ * Exported so memory v2 background jobs (`sweep`, future LLM-driven
+ * extractors) can append to `memory/buffer.md` + `memory/archive/<today>.md`
+ * with exactly the same format `remember()` produces, keeping the two write
+ * paths byte-compatible for downstream consumers (consolidation, search).
+ */
+export function appendBufferAndArchive(args: {
+  rootDir: string;
+  entry: string;
+  now: Date;
+}): { bufferPath: string; archivePath: string } {
+  const { rootDir, entry, now } = args;
+  const archiveDir = join(rootDir, "archive");
+  mkdirSync(archiveDir, { recursive: true });
+
+  const bufferPath = join(rootDir, "buffer.md");
   appendFileSync(bufferPath, entry, "utf-8");
-  enqueuePkbReindex(pkbDir, bufferPath);
 
-  // Append to daily archive
   const yyyy = now.getFullYear();
   const mm = String(now.getMonth() + 1).padStart(2, "0");
   const dd = String(now.getDate()).padStart(2, "0");
   const archivePath = join(archiveDir, `${yyyy}-${mm}-${dd}.md`);
   if (!existsSync(archivePath)) {
-    appendFileSync(archivePath, `# ${month} ${day}, ${yyyy}\n\n`, "utf-8");
+    const month = now.toLocaleString("en-US", { month: "short" });
+    appendFileSync(
+      archivePath,
+      `# ${month} ${now.getDate()}, ${yyyy}\n\n`,
+      "utf-8",
+    );
   }
   appendFileSync(archivePath, entry, "utf-8");
-  enqueuePkbReindex(pkbDir, archivePath);
 
-  return { success: true, message: "Saved to knowledge base." };
+  return { bufferPath, archivePath };
 }
 
 /**

package/src/memory/graph/tools.ts

@@ -1,72 +1,52 @@
 // ---------------------------------------------------------------------------
-// Memory Graph — Tool definitions for recall and remember
-//
-// These replace memory_recall and memory_manage from the old system.
+// Memory Tool definitions for agentic recall and remember.
 // ---------------------------------------------------------------------------
 
 import type { ToolDefinition } from "../../providers/types.js";
+import {
+  ALL_RECALL_SOURCES,
+  MAX_RECALL_MAX_RESULTS,
+  MIN_RECALL_MAX_RESULTS,
+} from "../context-search/limits.js";
+
+const RECALL_DEPTHS = ["fast", "standard", "deep"] as const;
 
 /**
- * Explicit memory search across the living graph or raw archive.
- *
- * Auto-injected context covers common cases, but the assistant should
- * proactively recall when uncertain — search first, ask second.
+ * Explicit local information search across memory, PKB, conversations, and
+ * workspace files.
  */
 export const graphRecallDefinition: ToolDefinition = {
   name: "recall",
   description:
-    "Search your memory for specific information. Use this proactively — if you're uncertain about something, look it up before asking. Auto-injected context covers common cases, but actively recall when: you're about to ask a question that memory might answer, the user references something you should already know, you need details about a past conversation or event, or you want to search by a specific feeling, time period, or person. When in doubt, search first, ask second. Be specific in your query for best results.",
+    'Search local information the moment you feel uncertain. Use recall for memory, the personal knowledge base, past conversations, and workspace files — before you guess, before you ask, before you hedge. Auto-injection is incomplete by design; it surfaces patterns, not the specifics you need to answer well. If you catch yourself reaching for "I think", "I believe", "if I remember", "didn\'t we", "last time" — that\'s the signal. Recall. If the user references someone, a place, a decision, a document, or prior work you should be able to find locally — recall. Call it multiple times per conversation if the turn warrants it. Be specific in your query for best results.',
   input_schema: {
     type: "object",
     properties: {
       query: {
         type: "string",
         description:
-          "What you're looking for — be specific and descriptive. Can be a topic, feeling, time period, or person.",
+          "What you're looking for. Be specific and descriptive: include the topic, person, project, decision, time period, or file clues when known.",
       },
-      num_results: {
-        type: "integer",
+      sources: {
+        type: "array",
+        items: {
+          type: "string",
+          enum: [...ALL_RECALL_SOURCES],
+        },
         description:
-          "Maximum number of results to return (default 20, max 50).",
+          "Optional local sources to search. Omit to search memory, PKB, conversations, and workspace files.",
       },
-      mode: {
+      max_results: {
+        type: "integer",
+        minimum: MIN_RECALL_MAX_RESULTS,
+        maximum: MAX_RECALL_MAX_RESULTS,
+        description: "Maximum number of evidence items to return.",
+      },
+      depth: {
         type: "string",
-        enum: ["memory", "archive"],
+        enum: [...RECALL_DEPTHS],
         description:
-          '"memory" searches the living memory graph using semantic similarity (default). "archive" searches raw conversation transcripts using keyword matching. Supports FTS5 syntax: use "quoted phrases" for exact matching, AND/OR for boolean logic, NEAR(word1 word2, N) for proximity. Without operators, all keywords must appear (implicit AND). Short words like "I" and "a" are ignored. Prefer "memory" for conceptual/emotional queries, "archive" for finding specific wording.',
-      },
-      filters: {
-        type: "object",
-        description: "Optional filters to narrow results",
-        properties: {
-          types: {
-            type: "array",
-            items: {
-              type: "string",
-              enum: [
-                "episodic",
-                "semantic",
-                "procedural",
-                "emotional",
-                "prospective",
-                "behavioral",
-                "narrative",
-                "shared",
-              ],
-            },
-            description: "Only return memories of these types",
-          },
-          after: {
-            type: "string",
-            description:
-              "Only return memories created after this date (ISO 8601)",
-          },
-          before: {
-            type: "string",
-            description:
-              "Only return memories created before this date (ISO 8601)",
-          },
-        },
+          "Search effort. Use fast for quick lookups, standard by default, and deep when the answer may require multiple local searches.",
       },
     },
     required: ["query"],
@@ -74,15 +54,17 @@ export const graphRecallDefinition: ToolDefinition = {
 };
 
 /**
- * Save a fact to the personal knowledge base. The fact is appended to
- * buffer.md (immediately available in the next conversation) and the
- * daily archive (permanent date-indexed record). Filing into topic
- * files happens during the periodic filing job.
+ * 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.
  */
 export const graphRememberDefinition: ToolDefinition = {
   name: "remember",
   description:
-    "Save a fact to your knowledge base. Call this AGGRESSIVELY — capture anything concrete about their life: preferences, locations, names, dates, habits, opinions, health details, plans, relationship facts, routines, commitments. Default to remembering; only skip obvious noise (small talk, hypotheticals, things they're just musing about). Don't judge importance — filing decides that later. Examples: 'Prefers UberEats over DoorDash', 'Lives in NYC, from Texas', 'Takes daily medication, tapering dose', 'Partner Alex lives in Austin', 'Watches a weekly show on Saturday nights', 'Conference in May'. Call this multiple times per conversation — it's cheap (one line appended to a file). Don't wait until the end. Don't batch. Every new fact, immediately. Remembering too much is infinitely better than forgetting something that mattered. CORRECTIONS are the highest priority — when the user corrects a fact you had wrong, `remember` the correction immediately. The wrong version is already propagated in your prior turns and memory graph; skipping a correction means future-you keeps operating on the old value. Never skip a correction even if you'd skip the equivalent fresh fact.",
+    "Remember anything concrete: facts, preferences, corrections, plans, felt moments, names, dates, decisions. Default to remembering. Never wait until end of conversation. Corrections are highest priority — call remember the same turn the correction lands. **CRITICAL:** You should be calling remember on almost every turn. This should be your most frequently used tool.",
   input_schema: {
     type: "object",
     properties: {

package/src/memory/group-crud.ts

@@ -8,8 +8,7 @@
 import { v4 as uuid } from "uuid";
 
 import { ensureGroupMigration } from "./conversation-group-migration.js";
-import { rawAll, rawExec, rawGet, rawRun } from "./db.js";
-
+import { rawAll, rawExec, rawGet, rawRun } from "./raw-query.js";
 export interface ConversationGroupRow {
   id: string;
   name: string;

package/src/memory/guardian-action-store.ts

@@ -11,7 +11,8 @@ import { and, desc, eq, inArray, lt } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getLogger } from "../util/logger.js";
-import { getDb, rawChanges } from "./db.js";
+import { getDb } from "./db-connection.js";
+import { rawChanges } from "./raw-query.js";
 import { guardianActionDeliveries, guardianActionRequests } from "./schema.js";
 
 const log = getLogger("guardian-action-store");

package/src/memory/guardian-approvals.ts

@@ -9,7 +9,7 @@
 import { and, desc, eq, gt, lte } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getDb } from "./db.js";
+import { getDb } from "./db-connection.js";
 import { channelGuardianApprovalRequests } from "./schema.js";
 
 // ---------------------------------------------------------------------------

package/src/memory/guardian-rate-limits.ts

@@ -8,7 +8,7 @@
 import { and, eq } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getDb } from "./db.js";
+import { getDb } from "./db-connection.js";
 import { channelGuardianRateLimits } from "./schema.js";
 
 // ---------------------------------------------------------------------------

package/src/memory/indexer.ts

@@ -9,7 +9,7 @@ import { getLogger } from "../util/logger.js";
 import { enqueueAutoAnalysisIfEnabled } from "./auto-analysis-enqueue.js";
 import { isAutoAnalysisConversation } from "./auto-analysis-guard.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
-import { getDb } from "./db.js";
+import { getDb } from "./db-connection.js";
 import { selectedBackendSupportsMultimodal } from "./embedding-backend.js";
 import { enqueueMemoryJob, upsertDebouncedJob } from "./jobs-store.js";
 import {
@@ -193,15 +193,52 @@ export async function indexMessageNow(
       // 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",
         },
-        graphBatchFired ? Date.now() : Date.now() + idleTimeoutMs,
+        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.
+      let triggerConfig: ReturnType<typeof getConfig> | null = null;
+      try {
+        triggerConfig = getConfig();
+      } catch (err) {
+        log.debug(
+          { err, conversationId: input.conversationId },
+          "Skipping feature-gated extraction triggers: failed to load config",
+        );
+      }
+
+      // 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.
+      // `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
+      ) {
+        upsertDebouncedJob(
+          "memory_v2_sweep",
+          { conversationId: input.conversationId },
+          extractRunAfter,
+        );
+      }
+
       // ── Auto-analysis triggers ─────────────────────────────────────
       // Immediate triggers (batch, compaction) and debounced triggers
       // (idle, lifecycle) write to separate rows keyed by triggerGroup
@@ -218,23 +255,12 @@ export async function indexMessageNow(
       // Gated behind the `auto-analyze` feature flag so the counter
       // does not accumulate stale counts while the flag is off — if it
       // did, flipping the flag on would trigger an immediate batch from
-      // messages buffered during the disabled period. Reading config
-      // here is best-effort: if it fails we skip the batch trigger
-      // (the idle-debounced enqueue above still runs).
-      let analysisConfig: ReturnType<typeof getConfig> | null = null;
-      try {
-        analysisConfig = getConfig();
-      } catch (err) {
-        log.debug(
-          { err, conversationId: input.conversationId },
-          "Skipping auto-analysis batch trigger: failed to load config",
-        );
-      }
+      // messages buffered during the disabled period.
       if (
-        analysisConfig != null &&
-        isAssistantFeatureFlagEnabled("auto-analyze", analysisConfig)
+        triggerConfig != null &&
+        isAssistantFeatureFlagEnabled("auto-analyze", triggerConfig)
       ) {
-        const analysisBatchSize = analysisConfig.analysis.batchSize;
+        const analysisBatchSize = triggerConfig.analysis.batchSize;
         const analysisPendingKey = `conversation_analyze:${input.conversationId}:pending_count`;
         const analysisCurrentVal = getMemoryCheckpoint(analysisPendingKey);
         const analysisPendingCount =

package/src/memory/invite-store.ts

@@ -10,7 +10,7 @@ import { createHash, randomBytes, randomUUID } from "node:crypto";
 
 import { and, desc, eq, gt } from "drizzle-orm";
 
-import { getDb } from "./db.js";
+import { getDb } from "./db-connection.js";
 import { assistantIngressInvites } from "./schema.js";
 
 // ---------------------------------------------------------------------------

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

@@ -11,7 +11,7 @@ import {
   getConversationMemoryScopeId,
   messageMetadataSchema,
 } from "../conversation-crud.js";
-import { getDb } from "../db.js";
+import { getDb } from "../db-connection.js";
 import { indexMessageNow } from "../indexer.js";
 import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
 import { messages } from "../schema.js";

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

@@ -1,7 +1,8 @@
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
-import { getDb, rawAll, rawChanges, rawRun } from "../db.js";
+import { getDb } from "../db-connection.js";
 import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
+import { rawAll, rawChanges, rawRun } from "../raw-query.js";
 
 const log = getLogger("memory-jobs-worker");