@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

package/src/persistence/conversation-disk-view.ts

@@ -143,7 +143,9 @@ interface FlattenedContent {
  * Parse the message `content` JSON string (ContentBlock[]) and extract
  * text, tool_use, and tool_result blocks into flat fields.
  */
-export function flattenContentBlocks(rawContent: string): FlattenedContent {
+export function flattenContentBlocks(
+  rawContent: string | ContentBlock[],
+): FlattenedContent {
   const result: FlattenedContent = {
     content: "",
     toolCalls: [],
@@ -151,16 +153,20 @@ export function flattenContentBlocks(rawContent: string): FlattenedContent {
   };
 
   let blocks: ContentBlock[];
-  try {
-    const parsed = JSON.parse(rawContent);
-    if (!Array.isArray(parsed)) {
-      // Plain text content (not block array)
+  if (Array.isArray(rawContent)) {
+    blocks = rawContent;
+  } else {
+    try {
+      const parsed = JSON.parse(rawContent);
+      if (!Array.isArray(parsed)) {
+        // Plain text content (not block array)
+        return { ...result, content: rawContent };
+      }
+      blocks = parsed;
+    } catch {
+      // Not valid JSON — treat as plain text
       return { ...result, content: rawContent };
     }
-    blocks = parsed;
-  } catch {
-    // Not valid JSON — treat as plain text
-    return { ...result, content: rawContent };
   }
 
   const textParts: string[] = [];
@@ -198,7 +204,9 @@ export function flattenContentBlocks(rawContent: string): FlattenedContent {
  */
 export function resolveUniqueFilename(dir: string, filename: string): string {
   const sanitized = basename(filename);
-  if (!existsSync(join(dir, sanitized))) return sanitized;
+  if (!existsSync(join(dir, sanitized))) {
+    return sanitized;
+  }
 
   const ext = extname(sanitized);
   const base = basename(sanitized, ext);
@@ -235,7 +243,9 @@ function writeAttachmentFile(
     }
 
     const content = getAttachmentContent(attachmentId);
-    if (!content) return null;
+    if (!content) {
+      return null;
+    }
 
     const resolvedName = resolveUniqueFilename(attachDir, originalFilename);
     writeFileSync(join(attachDir, resolvedName), content);
@@ -301,11 +311,18 @@ export function syncMessageToDisk(
       ts: new Date(message.createdAt).toISOString(),
     };
 
-    if (content) record.content = content;
-    if (toolCalls.length > 0) record.toolCalls = toolCalls;
-    if (toolResults.length > 0) record.toolResults = toolResults;
-    if (attachmentFilenames.length > 0)
+    if (content) {
+      record.content = content;
+    }
+    if (toolCalls.length > 0) {
+      record.toolCalls = toolCalls;
+    }
+    if (toolResults.length > 0) {
+      record.toolResults = toolResults;
+    }
+    if (attachmentFilenames.length > 0) {
       record.attachments = attachmentFilenames;
+    }
     if (message.metadata) {
       try {
         record.metadata = JSON.parse(message.metadata);

package/src/persistence/conversation-group-migration.test.ts

@@ -1,11 +1,4 @@
-import { beforeAll, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
+import { beforeAll, describe, expect, test } from "bun:test";
 
 import { ensureGroupMigration } from "./conversation-group-migration.js";
 import { initializeDb } from "./db-init.js";

package/src/persistence/conversation-key-store.ts

@@ -217,7 +217,6 @@ export function getOrCreateConversation(
     const conversationId = uuid();
     const customTitle = opts?.title?.trim();
     const title = customTitle || GENERATING_TITLE;
-    const memoryScopeId = "default";
     // Snapshot↔stream alignment baseline, captured at the creation instant
     // (same seed as `createConversation`; 0 is stored as NULL).
     const initialSeq = getCurrentSeq();
@@ -241,7 +240,6 @@ export function getOrCreateConversation(
         contextCompactedMessageCount: 0,
         contextCompactedAt: null,
         conversationType,
-        memoryScopeId,
       })
       .run();
 

package/src/persistence/conversation-plugin-facade.ts

@@ -0,0 +1,190 @@
+import type {
+  AddMessageOptions,
+  ConversationRow,
+  MessageRole,
+  MessageRow,
+} from "./conversation-crud.js";
+import type { ArchiveStatusFilter } from "./conversation-queries.js";
+import type { ConversationType } from "./conversation-types.js";
+
+/**
+ * Plugin-facing facade over the host conversation store: reads and writes on
+ * conversations and their message history, plus the lexical message-search
+ * surface. Every operation takes explicit parameters and resolves nothing
+ * from config, so the wrappers are pure pass-throughs.
+ *
+ * The store modules are loaded via dynamic `import()` inside each wrapper —
+ * they carry the DB/drizzle import graph and are among the most
+ * partial-mocked modules in the test suite, so importing this module (which
+ * every `@vellumai/plugin-api` consumer does transitively) must not force
+ * their named exports to resolve at instantiation. All type imports above are
+ * erased at compile time. Async for that reason, including the wrappers whose
+ * underlying functions are synchronous.
+ */
+
+type MessageMetadata = ReturnType<
+  typeof import("./conversation-crud.js").parseMessageMetadata
+>;
+
+type MessageLexicalSearchResult = Awaited<
+  ReturnType<
+    typeof import("./conversation-search-lexical.js").searchMessageIdsLexical
+  >
+>[number];
+
+type AddMessageResult = Awaited<
+  ReturnType<typeof import("./conversation-crud.js").addMessage>
+>;
+
+/** Look up a conversation row by id. */
+export async function getConversation(
+  id: string,
+): Promise<ConversationRow | null> {
+  const { getConversation: fn } = await import("./conversation-crud.js");
+  return fn(id);
+}
+
+/** All messages of a conversation in insertion order. */
+export async function getMessages(
+  conversationId: string,
+): Promise<MessageRow[]> {
+  const { getMessages: fn } = await import("./conversation-crud.js");
+  return fn(conversationId);
+}
+
+/** Whether the conversation currently has a turn in flight. */
+export async function isConversationProcessing(id: string): Promise<boolean> {
+  const { isConversationProcessing: fn } =
+    await import("./conversation-crud.js");
+  return fn(id);
+}
+
+/** Parse a stored message-metadata JSON string; undefined when absent/invalid. */
+export async function parseMessageMetadata(
+  metadataJson: string | null,
+): Promise<MessageMetadata> {
+  const { parseMessageMetadata: fn } = await import("./conversation-crud.js");
+  return fn(metadataJson);
+}
+
+/** Merge the given keys into a message's metadata JSON. */
+export async function updateMessageMetadata(
+  messageId: string,
+  updates: Record<string, unknown>,
+): Promise<void> {
+  const { updateMessageMetadata: fn } = await import("./conversation-crud.js");
+  return fn(messageId, updates);
+}
+
+/**
+ * Append a message to a conversation. This is the low-level insert: it
+ * persists and indexes the row only — it does not project the message into
+ * the conversation's disk view and does not notify connected clients, so
+ * background/internal writes stay silent. A user-visible append pairs this
+ * with `syncMessageToDisk` and a client notification, as the host's own
+ * out-of-pipeline writers do.
+ */
+export async function addMessage(
+  conversationId: string,
+  role: MessageRole,
+  content: string,
+  options?: AddMessageOptions,
+): Promise<AddMessageResult> {
+  const { addMessage: fn } = await import("./conversation-crud.js");
+  return fn(conversationId, role, content, options);
+}
+
+/**
+ * Delete a conversation, yielding the event loop between row batches, and
+ * enqueue vector-store cleanup for the memory segments and summaries the
+ * delete cascaded away — the same vector-cleanup pairing the host's delete
+ * route performs, so facade callers never leave semantic vectors behind. The lexical-index
+ * purge runs inside the delete itself via the persistence hook.
+ */
+export async function deleteConversation(id: string): Promise<void> {
+  const [{ deleteConversationGently: fn }, { enqueueMemoryJob }] =
+    await Promise.all([
+      import("./conversation-crud.js"),
+      import("./jobs-store.js"),
+    ]);
+  const deleted = await fn(id);
+  for (const segId of deleted.segmentIds) {
+    enqueueMemoryJob("delete_qdrant_vectors", {
+      targetType: "segment",
+      targetId: segId,
+    });
+  }
+  for (const summaryId of deleted.deletedSummaryIds) {
+    enqueueMemoryJob("delete_qdrant_vectors", {
+      targetType: "summary",
+      targetId: summaryId,
+    });
+  }
+}
+
+/** List conversation rows, newest first. */
+export async function listConversations(
+  limit?: number,
+  conversationType?: ConversationType,
+  offset?: number,
+  archiveStatus?: ArchiveStatusFilter,
+  originChannel?: string,
+): Promise<ConversationRow[]> {
+  const { listConversations: fn } = await import("./conversation-queries.js");
+  // Explicit `undefined` arguments fall through to the underlying defaults.
+  return fn(limit, conversationType, offset, archiveStatus, originChannel);
+}
+
+/** Sparse lexical search over stored message text; ranked message-id hits. */
+export async function searchMessageIdsLexical(
+  query: string,
+  limit: number,
+  opts?: { conversationId?: string },
+): Promise<MessageLexicalSearchResult[]> {
+  const { searchMessageIdsLexical: fn } =
+    await import("./conversation-search-lexical.js");
+  return fn(query, limit, opts);
+}
+
+/** Whether the text tokenizes to at least one lexical search token. */
+export async function hasLexicalTokens(text: string): Promise<boolean> {
+  const { hasLexicalTokens: fn } = await import("./conversation-queries.js");
+  return fn(text);
+}
+
+/**
+ * Build a model-facing excerpt of stored message content around a query,
+ * preserving external-content envelopes so third-party boundaries stay
+ * visible.
+ */
+export async function buildMessageExcerpt(
+  rawContent: string,
+  query: string,
+): Promise<string> {
+  const { buildRecallEvidenceExcerpt: fn } =
+    await import("./conversation-queries.js");
+  return fn(rawContent, query);
+}
+
+/**
+ * Absolute path of a conversation's disk-view directory under the workspace
+ * naming scheme (timestamp-first, derived from id + creation time).
+ */
+export async function getConversationDirPath(
+  id: string,
+  createdAtMs: number,
+): Promise<string> {
+  const { getConversationDirPath: fn } =
+    await import("./conversation-directories.js");
+  return fn(id, createdAtMs);
+}
+
+/** Re-sync one persisted message into the conversation's disk view. */
+export async function syncMessageToDisk(
+  conversationId: string,
+  messageId: string,
+  createdAtMs: number,
+): Promise<void> {
+  const { syncMessageToDisk: fn } = await import("./conversation-disk-view.js");
+  return fn(conversationId, messageId, createdAtMs);
+}

package/src/persistence/conversation-row-batch-delete.ts

@@ -34,6 +34,7 @@
 
 import { setTimeout as sleep } from "node:timers/promises";
 
+import { BULK_BATCH_TIMEOUT_MS, withBulkWriteGate } from "./bulk-write-gate.js";
 import {
   type AsyncSqliteBackend,
   type AsyncSqliteResult,
@@ -170,9 +171,23 @@ export async function deleteConversationRowsInBatches(
     runOptions.forceBackend = "in-process-blocking";
   }
   if (options.dbPath !== undefined) {
+    // A dedicated file (e.g. the logs DB) has its own write lock, so its
+    // drain must not queue behind — or hold up — main-DB bulk streams.
     runOptions.dbPath = options.dbPath;
+    return await drainBatches(options, batchSize, runOptions);
   }
 
+  return await withBulkWriteGate(
+    `conversation-row-delete:${options.table}:${options.conversationId}`,
+    () => drainBatches(options, batchSize, runOptions),
+  );
+}
+
+async function drainBatches(
+  options: DeleteConversationRowsOptions,
+  batchSize: number,
+  runOptions: RunAsyncSqliteOptions,
+): Promise<AsyncSqliteResult> {
   let totalElapsedMs = 0;
   let backend: AsyncSqliteBackend = "in-process-blocking";
 
@@ -190,7 +205,7 @@ export async function deleteConversationRowsInBatches(
     const result = await runAsyncSqlite(
       sql,
       `conversation-row-delete:${options.table}:${options.conversationId}`,
-      runOptions,
+      { ...runOptions, timeoutMs: BULK_BATCH_TIMEOUT_MS },
     );
     totalElapsedMs += result.elapsedMs;
     backend = result.backend;

package/src/persistence/conversation-title-service.ts

@@ -98,7 +98,9 @@ const REPLACEABLE_PATTERNS = [
  * user-provided custom titles.
  */
 export function isReplaceableTitle(title: string | null): boolean {
-  if (title == null || title.trim() === "") return true;
+  if (title == null || title.trim() === "") {
+    return true;
+  }
   return REPLACEABLE_PATTERNS.some((pattern) => pattern.test(title));
 }
 
@@ -467,12 +469,21 @@ function buildTitlePrompt(
 
   if (context) {
     const hints: string[] = [];
-    if (context.sourceChannel) hints.push(`Channel: ${context.sourceChannel}`);
-    if (context.displayName) hints.push(`User: ${context.displayName}`);
-    if (context.systemHint) hints.push(`Context: ${context.systemHint}`);
-    if (context.uxBrief) hints.push(`Brief: ${context.uxBrief}`);
-    if (context.metadataHints?.length)
+    if (context.sourceChannel) {
+      hints.push(`Channel: ${context.sourceChannel}`);
+    }
+    if (context.displayName) {
+      hints.push(`User: ${context.displayName}`);
+    }
+    if (context.systemHint) {
+      hints.push(`Context: ${context.systemHint}`);
+    }
+    if (context.uxBrief) {
+      hints.push(`Brief: ${context.uxBrief}`);
+    }
+    if (context.metadataHints?.length) {
       hints.push(`Hints: ${context.metadataHints.join(", ")}`);
+    }
     if (hints.length > 0) {
       parts.push("Metadata:", ...hints, "");
     }
@@ -513,7 +524,9 @@ function retryableFallbackLogFields(
     reason,
     fallbackSource: params.context ? "context" : "untitled",
   };
-  if (err) fields.err = err;
+  if (err) {
+    fields.err = err;
+  }
   return fields;
 }
 
@@ -546,14 +559,18 @@ const MAX_TITLE_LENGTH = 40;
 const MAX_TITLE_WORDS = 7;
 
 function truncateTitle(title: string): string {
-  if (title.length <= MAX_TITLE_LENGTH) return title;
+  if (title.length <= MAX_TITLE_LENGTH) {
+    return title;
+  }
   const words = title.split(/\s+/);
   if (words.length <= MAX_TITLE_WORDS) {
     // Long words but few of them — truncate to char limit at word boundary
     let result = "";
     for (const word of words) {
       const candidate = result ? result + " " + word : word;
-      if (candidate.length > MAX_TITLE_LENGTH) break;
+      if (candidate.length > MAX_TITLE_LENGTH) {
+        break;
+      }
       result = candidate;
     }
     return result || title.slice(0, MAX_TITLE_LENGTH);
@@ -566,7 +583,9 @@ function normalizeTitle(raw: string): string {
   let title = raw.trim().replace(/^["']|["']$/g, "");
   title = stripMarkdown(title);
   title = stripThinkingTags(title).trim();
-  if (!title) return "";
+  if (!title) {
+    return "";
+  }
   // Reject outputs that are the model reasoning aloud or continuing the
   // conversation instead of naming it (e.g. "I need to generate a…", "I'll
   // work through these files…"). Callers fall back to a deterministic title.
@@ -646,8 +665,12 @@ const LEAKED_PROSE_PREFIXES = [
  * fallback title, while a false accept persists a broken one.
  */
 function looksLikeLeakedProse(title: string): boolean {
-  if (/\n/.test(title)) return true;
-  if (/\b(?:user|assistant)\s*:/i.test(title)) return true;
+  if (/\n/.test(title)) {
+    return true;
+  }
+  if (/\b(?:user|assistant)\s*:/i.test(title)) {
+    return true;
+  }
   const lower = title.toLowerCase();
   if (LEAKED_PROSE_PREFIXES.some((prefix) => lower.startsWith(prefix))) {
     return true;
@@ -688,9 +711,15 @@ function stripMarkdown(text: string): string {
 }
 
 function deriveFallbackTitle(context?: TitleContext): string | null {
-  if (!context) return null;
-  if (context.systemHint) return context.systemHint;
-  if (context.uxBrief) return context.uxBrief;
+  if (!context) {
+    return null;
+  }
+  if (context.systemHint) {
+    return context.systemHint;
+  }
+  if (context.uxBrief) {
+    return context.uxBrief;
+  }
   return null;
 }
 
@@ -705,14 +734,20 @@ function deriveFallbackTitle(context?: TitleContext): string | null {
  * Returns empty string for content-block arrays with no extractable text,
  * preventing raw JSON from polluting the title prompt.
  */
-function extractTextForTitle(raw: string): string {
+function extractTextForTitle(raw: string | Array<{ type: string }>): string {
   try {
-    const parsed = JSON.parse(raw);
-    if (typeof parsed === "string") return parsed;
-    if (!Array.isArray(parsed)) return raw;
+    const parsed = Array.isArray(raw) ? raw : JSON.parse(raw);
+    if (typeof parsed === "string") {
+      return parsed;
+    }
+    if (!Array.isArray(parsed)) {
+      return raw as string;
+    }
     const texts: string[] = [];
     for (const block of parsed) {
-      if (!block || typeof block !== "object") continue;
+      if (!block || typeof block !== "object") {
+        continue;
+      }
       if (block.type === "text" && typeof block.text === "string") {
         texts.push(block.text);
         // guard:allow-tool-result-only — web_search_tool_result has structured
@@ -737,7 +772,7 @@ function extractTextForTitle(raw: string): string {
     }
     return texts.join("\n");
   } catch {
-    return raw;
+    return Array.isArray(raw) ? "" : raw;
   }
 }
 
@@ -746,7 +781,9 @@ function buildRegenerationPrompt(recentMessages: MessageRow[]): string {
 
   for (const msg of recentMessages) {
     const text = extractTextForTitle(msg.content);
-    if (!text) continue;
+    if (!text) {
+      continue;
+    }
     const role = msg.role === "user" ? "User" : "Assistant";
     parts.push(`${role}: ${stripThinkingTags(text)}`);
   }

package/src/persistence/conversation-types.ts

@@ -1,16 +1,31 @@
-// Re-exports the canonical conversation-type union (defined alongside the
-// create path in `conversation-crud.ts`) under a read-side name and provides
+// The canonical conversation-type union — how a conversation was created / what
+// execution mode it runs in. Defined here (a leaf) so the create path in
+// `conversation-crud.ts`, the notification pipeline, and read-side filters
+// share one declaration without importing the heavy CRUD module. Also provides
 // the shared "is this a non-interactive / background conversation?" predicate
 // used by notification-feed and memory filters.
 
-import type { ConversationCreateType } from "./conversation-crud.js";
+/** How a conversation was created / its execution mode. */
+export type ConversationCreateType = "standard" | "background" | "scheduled";
 
+/** Read-side alias of {@link ConversationCreateType}. */
 export type ConversationType = ConversationCreateType;
 
+/**
+ * Conversation types created by background machinery (heartbeat runs,
+ * scheduled runs, retrospective forks) rather than by a person. Exported as a
+ * list so SQL filters (e.g. `notInArray`) share the same set as the predicate
+ * below.
+ */
+export const BACKGROUND_CONVERSATION_TYPES = [
+  "background",
+  "scheduled",
+] as const satisfies readonly ConversationType[];
+
 // Tolerant of null/undefined/unknown strings so it can be called directly on
 // raw DB column values without pre-validation.
 export function isBackgroundConversationType(
   t: ConversationType | string | null | undefined,
 ): boolean {
-  return t === "background" || t === "scheduled";
+  return (BACKGROUND_CONVERSATION_TYPES as readonly string[]).includes(t ?? "");
 }

package/src/persistence/db-async-query.ts

@@ -193,11 +193,18 @@ async function runViaCli(
     stderr: "pipe",
   });
 
-  // Match the busy_timeout the daemon connection uses so this subprocess
-  // waits for — rather than instantly failing against — a lock held by the
-  // still-running in-process connection (and vice versa). Prepended to the
-  // piped SQL so it takes effect before the statement runs.
-  const sqlWithPragma = `PRAGMA busy_timeout=${SQLITE_BUSY_TIMEOUT_MS};\n${sql}`;
+  // Match the daemon connection's pragmas (`applyConnectionPragmas`) so this
+  // subprocess writes like every other connection. `busy_timeout` makes it
+  // wait for — rather than instantly fail against — a lock held by the
+  // still-running in-process connection (and vice versa).
+  // `synchronous=NORMAL` overrides the CLI default (FULL), which would fsync
+  // the WAL inside every commit's write-lock window and stretch bulk-batch
+  // lock holds under I/O pressure: in WAL mode, NORMAL commits become durable
+  // at checkpoint (an OS/power crash can lose the last commits, never
+  // corrupt) — the durability posture every daemon write already has, so
+  // FULL here buys no end-to-end guarantee. Prepended to the piped SQL so
+  // both take effect before the statement runs.
+  const sqlWithPragma = `PRAGMA busy_timeout=${SQLITE_BUSY_TIMEOUT_MS};\nPRAGMA synchronous=NORMAL;\n${sql}`;
 
   // Write the SQL and close stdin so sqlite3 sees EOF and exits.
   proc.stdin.write(sqlWithPragma + "\n");
@@ -280,11 +287,13 @@ async function runInProcessBlocking(
     let sqlite: Database;
     if (usesDedicatedFile) {
       transient = new Database(options.dbPath ?? getDbPath());
-      // Match the daemon connection's busy_timeout so this transient
-      // connection waits for a lock held by another writer rather than
-      // failing immediately with SQLITE_BUSY. (The daemon connection reused
-      // in the else branch already has it set via applyConnectionPragmas.)
+      // Match the daemon connection's busy_timeout and synchronous pragmas so
+      // this transient connection waits for locks and commits like every
+      // other writer (see the runViaCli prelude for the synchronous=NORMAL
+      // rationale). (The daemon connection reused in the else branch already
+      // has both set via applyConnectionPragmas.)
       transient.exec(`PRAGMA busy_timeout=${SQLITE_BUSY_TIMEOUT_MS}`);
+      transient.exec("PRAGMA synchronous=NORMAL");
       for (const a of options.attach ?? []) {
         transient.exec(
           `ATTACH DATABASE '${a.path.replace(/'/g, "''")}' AS ${a.alias}`,

package/src/persistence/db-connection.ts

@@ -104,11 +104,21 @@ function applyConnectionPragmas(sqlite: Database): void {
   sqlite.exec("PRAGMA foreign_keys = ON");
   sqlite.exec("PRAGMA cache_size=-256000");
   sqlite.exec("PRAGMA temp_store=MEMORY");
+  // Checkpointing alone never shrinks the WAL file — a fully-backfilled WAL
+  // is reused from offset 0 at its high-water size, so a single write burst
+  // otherwise leaves a permanently huge file (disk cost, plus a long recovery
+  // scan on the first open after a hard crash). With a size limit, any WAL
+  // reset also truncates the file to at most this many bytes. 64 MB
+  // comfortably exceeds the WAL's steady-state hover (the ~4 MB autocheckpoint
+  // threshold), so normal writes never pay file re-extension.
+  sqlite.exec("PRAGMA journal_size_limit=67108864");
 }
 
 export function getDb(): DrizzleDb {
   const existing = getStoredDb<DrizzleDb>("main");
-  if (existing) return existing;
+  if (existing) {
+    return existing;
+  }
 
   assertTestDbIsIsolated();
   ensureDataDir();
@@ -193,7 +203,9 @@ function openDedicatedDb(
  */
 export function getLogsDb(): DrizzleDb | null {
   const existing = getStoredDb<DrizzleDb>("logs");
-  if (existing) return existing;
+  if (existing) {
+    return existing;
+  }
   return openDedicatedDb("logs", getLogsDbPath());
 }
 
@@ -210,7 +222,9 @@ export function getLogsSqlite(): Database | null {
  */
 export function getMemoryDb(): DrizzleDb | null {
   const existing = getStoredDb<DrizzleDb>("memory");
-  if (existing) return existing;
+  if (existing) {
+    return existing;
+  }
   return openDedicatedDb("memory", getMemoryDbPath());
 }
 
@@ -227,7 +241,9 @@ export function getMemorySqlite(): Database | null {
  */
 export function getTelemetryDb(): DrizzleDb | null {
   const existing = getStoredDb<DrizzleDb>("telemetry");
-  if (existing) return existing;
+  if (existing) {
+    return existing;
+  }
   return openDedicatedDb("telemetry", getTelemetryDbPath());
 }