@vellumai/assistant 0.6.5 → 0.7.0

package/src/memory/context-search/types.ts

@@ -0,0 +1,49 @@
+import type { AssistantConfig } from "../../config/schema.js";
+
+export type RecallSource = "memory" | "pkb" | "conversations" | "workspace";
+
+export type RecallDepth = "fast" | "standard" | "deep";
+
+export interface RecallInput {
+  query: string;
+  sources?: RecallSource[];
+  max_results?: number;
+  depth?: RecallDepth;
+}
+
+export interface RecallEvidence {
+  id: string;
+  source: RecallSource;
+  title: string;
+  locator: string;
+  excerpt: string;
+  timestampMs?: number;
+  score?: number;
+  metadata?: Record<string, unknown>;
+}
+
+export interface RecallSearchContext {
+  workingDir: string;
+  memoryScopeId: string;
+  conversationId: string;
+  config: AssistantConfig;
+  signal?: AbortSignal;
+}
+
+export interface RecallSearchResult {
+  evidence: RecallEvidence[];
+}
+
+export interface RecallAnswer {
+  answer: string;
+  evidence: RecallEvidence[];
+}
+
+export interface RecallSourceAdapter {
+  source: RecallSource;
+  search(
+    query: string,
+    context: RecallSearchContext,
+    limit: number,
+  ): Promise<RecallSearchResult>;
+}

package/src/memory/conversation-analyze-job.ts

@@ -2,9 +2,8 @@
 // Auto-analyze — conversation_analyze job handler
 //
 // Bridges the jobs worker to the shared analyzeConversation() service. The
-// deps bundle is stashed on a module singleton during daemon startup; if it
-// isn't set yet the handler throws BackendUnavailableError so the worker
-// defers with exponential backoff until deps become available.
+// service imports its dependencies (getOrCreateConversation, assistantEventHub)
+// directly — no DI singleton required.
 //
 // The service itself distinguishes manual vs. auto triggers: this handler
 // always invokes with `trigger: "auto"`, so the rolling analysis conversation
@@ -13,8 +12,6 @@
 
 import type { AssistantConfig } from "../config/types.js";
 import { analyzeConversation } from "../runtime/services/analyze-conversation.js";
-import { getAnalysisDeps } from "../runtime/services/analyze-deps-singleton.js";
-import { BackendUnavailableError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import { enqueueAutoAnalysisIfEnabled } from "./auto-analysis-enqueue.js";
 import type { MemoryJob } from "./jobs-store.js";
@@ -31,25 +28,7 @@ export async function conversationAnalyzeJob(
     return;
   }
 
-  const deps = getAnalysisDeps();
-  if (!deps) {
-    // Daemon hasn't finished startup. Throw BackendUnavailableError so the
-    // worker defers the job with exponential backoff instead of completing
-    // it. Returning success here would permanently drop the job via
-    // completeMemoryJob — conversations with a pre-existing queued job
-    // during startup and no subsequent activity would never be analyzed.
-    // The deferral budget (50 × up to 5min backoff) is generous enough to
-    // outlast any realistic startup delay.
-    log.warn(
-      { jobId: job.id, conversationId },
-      "Deferring job: analysis deps not yet initialized",
-    );
-    throw new BackendUnavailableError(
-      "Analysis deps not yet initialized during daemon startup",
-    );
-  }
-
-  const result = await analyzeConversation(conversationId, deps, {
+  const result = await analyzeConversation(conversationId, {
     trigger: "auto",
   });
   if ("error" in result) {

package/src/memory/conversation-attention-store.ts

@@ -10,7 +10,7 @@ import { and, desc, eq, inArray, isNull, lt, or, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { UserError } from "../util/errors.js";
-import { getDb } from "./db.js";
+import { getDb } from "./db-connection.js";
 import {
   conversationAssistantAttentionState,
   conversationAttentionEvents,

package/src/memory/conversation-bootstrap.ts

@@ -6,7 +6,7 @@ import {
 } from "./conversation-title-service.js";
 
 export interface BootstrapConversationOptions {
-  conversationType?: "standard" | "private" | "background" | "scheduled";
+  conversationType?: "standard" | "background" | "scheduled";
   source?: string;
   origin: TitleOrigin;
   systemHint: string;

package/src/memory/conversation-crud.ts

@@ -20,9 +20,9 @@ import { z } from "zod";
 
 import type { ChannelId, InterfaceId } from "../channels/types.js";
 import { parseChannelId, parseInterfaceId } from "../channels/types.js";
-import { CHANNEL_IDS, INTERFACE_IDS, isChannelId } from "../channels/types.js";
+import { CHANNEL_IDS, isChannelId } from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
-import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
+import type { TrustContext } from "../daemon/trust-context.js";
 import { UserError } from "../util/errors.js";
 import { safeParseRecord } from "../util/json.js";
 import { getLogger } from "../util/logger.js";
@@ -45,12 +45,12 @@ import {
 } from "./conversation-disk-view.js";
 import { ensureDisplayOrderMigration } from "./conversation-display-order-migration.js";
 import { ensureGroupMigration } from "./conversation-group-migration.js";
-import { getDb, rawExec, rawGet, rawRun } from "./db.js";
+import { getDb } from "./db-connection.js";
 import { indexMessageNow } from "./indexer.js";
+import { rawExec, rawGet, rawRun } from "./raw-query.js";
 import {
   channelInboundEvents,
   conversations,
-  conversationStarters,
   llmRequestLogs,
   memoryEmbeddings,
   memorySegments,
@@ -68,7 +68,12 @@ const log = getLogger("conversation-store");
 // extra keys are allowed via passthrough so callers can attach ad-hoc data.
 
 const channelIdSchema = z.enum(CHANNEL_IDS);
-const interfaceIdSchema = z.enum(INTERFACE_IDS);
+// Accept both canonical INTERFACE_IDS and the legacy "vellum" alias,
+// normalizing to "web" on read so downstream code only handles canonical IDs.
+const interfaceIdSchema = z
+  .string()
+  .transform((v) => parseInterfaceId(v))
+  .refine((v): v is InterfaceId => v !== null);
 
 const subagentNotificationSchema = z.object({
   subagentId: z.string(),
@@ -78,9 +83,6 @@ const subagentNotificationSchema = z.object({
   conversationId: z.string().optional(),
 });
 
-export const PRIVATE_CONVERSATION_FORK_ERROR =
-  "Private conversations cannot be forked";
-
 export const messageMetadataSchema = z
   .object({
     userMessageChannel: channelIdSchema.optional(),
@@ -107,6 +109,9 @@ export const messageMetadataSchema = z
     memoryInjectedBlock: z.string().optional(),
     turnContextBlock: z.string().optional(),
     pkbSystemReminderBlock: z.string().optional(),
+    workspaceBlock: z.string().optional(),
+    nowScratchpadBlock: z.string().optional(),
+    pkbContextBlock: z.string().optional(),
   })
   .passthrough();
 
@@ -176,11 +181,11 @@ export interface ConversationRow {
   originInterface: string | null;
   forkParentConversationId: string | null;
   forkParentMessageId: string | null;
-  hostAccess: number;
   isAutoTitle: number;
   scheduleJobId: string | null;
   lastMessageAt: number | null;
   archivedAt: number | null;
+  inferenceProfile: string | null;
 }
 
 export const parseConversation = createRowMapper<
@@ -204,11 +209,11 @@ export const parseConversation = createRowMapper<
   originInterface: "originInterface",
   forkParentConversationId: "forkParentConversationId",
   forkParentMessageId: "forkParentMessageId",
-  hostAccess: "hostAccess",
   isAutoTitle: "isAutoTitle",
   scheduleJobId: "scheduleJobId",
   lastMessageAt: "lastMessageAt",
   archivedAt: "archivedAt",
+  inferenceProfile: "inferenceProfile",
 });
 
 export interface MessageRow {
@@ -220,7 +225,7 @@ export interface MessageRow {
   metadata: string | null;
 }
 
-export const parseMessage = createRowMapper<
+const parseMessage = createRowMapper<
   typeof messages.$inferSelect,
   MessageRow
 >({
@@ -232,6 +237,8 @@ export const parseMessage = createRowMapper<
   metadata: "metadata",
 });
 
+export type ConversationCreateType = "standard" | "background" | "scheduled";
+
 /**
  * Monotonic timestamp source for message ordering. Two messages saved within
  * the same millisecond (e.g., tool_results user message + assistant message in
@@ -251,11 +258,10 @@ export function createConversation(
     | string
     | {
         title?: string;
-        conversationType?: "standard" | "private" | "background" | "scheduled";
+        conversationType?: ConversationCreateType;
         source?: string;
         scheduleJobId?: string;
         groupId?: string;
-        hostAccess?: boolean;
         forkParentConversationId?: string;
       },
 ) {
@@ -265,12 +271,13 @@ export function createConversation(
     typeof titleOrOpts === "string"
       ? { title: titleOrOpts }
       : (titleOrOpts ?? {});
-  const conversationType = opts.conversationType ?? "standard";
+  const requestedConversationType = opts.conversationType;
+  const conversationType: ConversationCreateType =
+    requestedConversationType ?? "standard";
   const source = opts.source ?? "user";
   const groupId = opts.groupId;
   const id = uuid();
-  const memoryScopeId =
-    conversationType === "private" ? `private:${id}` : "default";
+  const memoryScopeId = "default";
 
   // Ensure group_id column exists for deterministic schema readiness,
   // even when this conversation has no groupId (a subsequent query or
@@ -288,7 +295,6 @@ export function createConversation(
     contextSummary: null as string | null,
     contextCompactedMessageCount: 0,
     contextCompactedAt: null as number | null,
-    hostAccess: opts.hostAccess ? 1 : 0,
     conversationType,
     source,
     memoryScopeId,
@@ -435,30 +441,17 @@ export function getConversationSource(conversationId: string): string | null {
   return row?.source ?? null;
 }
 
-export function getConversationType(
-  conversationId: string,
-): "standard" | "private" {
-  const conv = getConversation(conversationId);
-  const raw = conv?.conversationType;
-  return raw === "private" ? "private" : "standard";
-}
-
 export function getConversationMemoryScopeId(conversationId: string): string {
   const conv = getConversation(conversationId);
   return conv?.memoryScopeId ?? "default";
 }
 
-export function getConversationHostAccess(conversationId: string): boolean {
-  const conv = getConversation(conversationId);
-  return conv?.hostAccess === 1;
-}
-
 /**
  * Fetch group_id for a conversation via raw SQL. group_id is NOT in the
  * Drizzle schema (raw-query-only pattern), so ConversationRow doesn't
  * include it. This helper is used by forkConversation to inherit group_id.
  */
-export function getConversationGroupId(conversationId: string): string | null {
+function getConversationGroupId(conversationId: string): string | null {
   ensureGroupMigration();
   const row = rawGet<{ group_id: string | null }>(
     "SELECT group_id FROM conversations WHERE id = ?",
@@ -478,10 +471,6 @@ export function forkConversation(params: {
   if (!sourceConversation) {
     throw new UserError(`Conversation ${conversationId} not found`);
   }
-  if (sourceConversation.conversationType === "private") {
-    throw new UserError(PRIVATE_CONVERSATION_FORK_ERROR);
-  }
-
   const sourceMessages = getMessages(conversationId);
 
   if (sourceMessages.length === 0) {
@@ -553,6 +542,7 @@ export function forkConversation(params: {
         contextCompactedAt: preserveSourceCompactionState
           ? sourceConversation.contextCompactedAt
           : null,
+        inferenceProfile: sourceConversation.inferenceProfile,
       })
       .where(eq(conversations.id, fc.id))
       .run();
@@ -704,8 +694,6 @@ export function deleteConversation(id: string): DeletedMemoryIds {
   // resolve the conversation's disk-view directory path after deletion.
   const convBeforeDelete = getConversation(id);
   const createdAtForDiskCleanup = convBeforeDelete?.createdAt;
-  const memoryScopeId = convBeforeDelete?.memoryScopeId;
-  const isPrivateScope = memoryScopeId?.startsWith("private:") ?? false;
 
   db.transaction((tx) => {
     // Collect all message IDs for this conversation.
@@ -756,36 +744,6 @@ export function deleteConversation(id: string): DeletedMemoryIds {
         .run();
     }
 
-    if (isPrivateScope && memoryScopeId) {
-      // Sweep memory summaries with this private scopeId.
-      const scopeSummaries = tx
-        .select({ id: memorySummaries.id })
-        .from(memorySummaries)
-        .where(eq(memorySummaries.scopeId, memoryScopeId))
-        .all();
-      const scopeSummaryIds = scopeSummaries.map((r) => r.id);
-
-      if (scopeSummaryIds.length > 0) {
-        tx.delete(memoryEmbeddings)
-          .where(
-            and(
-              eq(memoryEmbeddings.targetType, "summary"),
-              inArray(memoryEmbeddings.targetId, scopeSummaryIds),
-            ),
-          )
-          .run();
-        tx.delete(memorySummaries)
-          .where(inArray(memorySummaries.id, scopeSummaryIds))
-          .run();
-        result.deletedSummaryIds.push(...scopeSummaryIds);
-      }
-
-      // Sweep conversation starters with this private scopeId.
-      tx.delete(conversationStarters)
-        .where(eq(conversationStarters.scopeId, memoryScopeId))
-        .run();
-    }
-
     tx.delete(conversations).where(eq(conversations.id, id)).run();
   });
 
@@ -855,50 +813,6 @@ export function wipeConversation(id: string): WipeConversationResult {
   };
 }
 
-/**
- * Delete all private (temporary) conversations and their associated data.
- * Called at daemon startup to clean up ephemeral conversations from previous sessions.
- * Returns the count and aggregated deleted memory IDs for Qdrant cleanup.
- */
-export function purgePrivateConversations(): {
-  count: number;
-  deletedMemory: DeletedMemoryIds;
-} {
-  const db = getDb();
-  const privateConvs = db
-    .select({ id: conversations.id })
-    .from(conversations)
-    .where(eq(conversations.conversationType, "private"))
-    .all();
-
-  if (privateConvs.length === 0) {
-    return {
-      count: 0,
-      deletedMemory: {
-        segmentIds: [],
-        deletedSummaryIds: [],
-      },
-    };
-  }
-
-  const allSegmentIds: string[] = [];
-  const allDeletedSummaryIds: string[] = [];
-
-  for (const conv of privateConvs) {
-    const deleted = deleteConversation(conv.id);
-    allSegmentIds.push(...deleted.segmentIds);
-    allDeletedSummaryIds.push(...deleted.deletedSummaryIds);
-  }
-
-  return {
-    count: privateConvs.length,
-    deletedMemory: {
-      segmentIds: allSegmentIds,
-      deletedSummaryIds: allDeletedSummaryIds,
-    },
-  };
-}
-
 export async function addMessage(
   conversationId: string,
   role: string,
@@ -1048,20 +962,26 @@ export function getMessages(conversationId: string): MessageRow[] {
 }
 
 /**
- * Count messages whose metadata JSON contains a `slackMeta` envelope, capped
- * at `limit`. Pushes the cap into SQL (`LIKE` + `LIMIT`) so warm Slack DM
- * conversations don't require a full-table scan + JSON parse on every
- * inbound message to confirm the cold-start threshold has been cleared.
- * Returns the number of matching rows up to `limit`; callers compare against
- * the cold-start threshold to decide whether to backfill.
+ * Return raw `metadata` strings for messages whose metadata contains the
+ * literal substring `"slackMeta"`, capped at `limit` and skipping the first
+ * `offset` matches. Pushes `LIKE` + `LIMIT`/`OFFSET` into SQL so warm Slack
+ * DM conversations don't require a full-table scan on the webhook critical
+ * path. The substring match is an indexable prefilter only — callers must
+ * parse and validate each returned string against the Slack metadata schema,
+ * because a malformed row (partial write, legacy format, unrelated key
+ * accidentally containing the literal) can still slip through the substring
+ * match. Callers that need a fixed number of *valid* rows should iterate
+ * with increasing offsets until the target is reached (capped at a
+ * reasonable maximum to bound scan cost).
  */
-export function countMessagesWithSlackMeta(
+export function selectSlackMetaCandidateMetadata(
   conversationId: string,
   limit: number,
-): number {
+  offset = 0,
+): string[] {
   const db = getDb();
   const rows = db
-    .select({ one: sql`1` })
+    .select({ metadata: messages.metadata })
     .from(messages)
     .where(
       and(
@@ -1069,9 +989,17 @@ export function countMessagesWithSlackMeta(
         like(messages.metadata, '%"slackMeta"%'),
       ),
     )
+    .orderBy(asc(messages.createdAt))
     .limit(limit)
+    .offset(offset)
     .all();
-  return rows.length;
+  const out: string[] = [];
+  for (const r of rows) {
+    if (typeof r.metadata === "string" && r.metadata.length > 0) {
+      out.push(r.metadata);
+    }
+  }
+  return out;
 }
 
 /**
@@ -1252,20 +1180,6 @@ export function updateConversationContextWindow(
     .run();
 }
 
-export function updateConversationHostAccess(
-  id: string,
-  hostAccess: boolean,
-): void {
-  const db = getDb();
-  db.update(conversations)
-    .set({
-      hostAccess: hostAccess ? 1 : 0,
-      updatedAt: Date.now(),
-    })
-    .where(eq(conversations.id, id))
-    .run();
-}
-
 export function archiveConversation(id: string): boolean {
   const conv = getConversation(id);
   if (!conv) return false;
@@ -1291,6 +1205,51 @@ export function unarchiveConversation(id: string): boolean {
   return true;
 }
 
+/**
+ * Set or clear the inference profile override for a conversation.
+ * Pass `null` to clear the override and fall back to the workspace
+ * `llm.activeProfile` resolution.
+ */
+export function setConversationInferenceProfile(
+  conversationId: string,
+  profile: string | null,
+): void {
+  const db = getDb();
+  db.update(conversations)
+    .set({ inferenceProfile: profile, updatedAt: Date.now() })
+    .where(eq(conversations.id, conversationId))
+    .run();
+}
+
+/**
+ * Resolve the per-turn inference-profile override from an already-loaded
+ * conversation row. Returns the row's `inferenceProfile` for non-background
+ * conversations, `undefined` otherwise — background turns (subagent fan-out,
+ * scheduled tasks, update bulletins) run on the workspace defaults rather
+ * than inheriting an interactive override.
+ *
+ * Prefer this row-based form when the caller already needs to read the
+ * conversation row for other reasons (e.g. the agent loop's title check).
+ */
+export function getConversationOverrideProfileFromRow(
+  conv: ConversationRow | null,
+): string | undefined {
+  if (conv?.conversationType === "background") return undefined;
+  return conv?.inferenceProfile ?? undefined;
+}
+
+/**
+ * Resolve the per-turn inference-profile override by conversation id.
+ * Convenience wrapper around `getConversationOverrideProfileFromRow` for
+ * standalone callers (e.g. subagent spawn, opportunity-wake) that don't
+ * already have the row in hand.
+ */
+export function getConversationOverrideProfile(
+  conversationId: string,
+): string | undefined {
+  return getConversationOverrideProfileFromRow(getConversation(conversationId));
+}
+
 /**
  * Delete all conversations, messages, and related data (tool invocations,
  * memory segments, etc.) from the daemon database.
@@ -1503,22 +1462,35 @@ export function updateMessageMetadata(
 }
 
 /**
- * Bulk-remove the `pkbSystemReminderBlock` field from every user-message
- * metadata row in a conversation. Called from compaction-strip sites so
- * post-restart rehydration stays consistent with the in-memory state
- * produced by `stripInjectionsForCompaction` (which removes
- * `<system_reminder>` from live messages but cannot touch the DB).
+ * Bulk-remove the metadata fields that back the blocks stripped by
+ * `stripInjectionsForCompaction` — currently `pkbSystemReminderBlock`
+ * (`<system_reminder>`), `nowScratchpadBlock` (`<NOW.md …>`), and
+ * `pkbContextBlock` (`<knowledge_base>`). Called from compaction-strip
+ * sites so post-restart rehydration stays consistent with the in-memory
+ * state produced by `stripInjectionsForCompaction` (which removes those
+ * tags from live messages but cannot touch the DB). Fields backing
+ * blocks that are intentionally NOT stripped (`turnContextBlock`,
+ * `workspaceBlock`, `memoryInjectedBlock`) are preserved.
  */
-export function clearPkbSystemReminderMetadataForConversation(
+export function clearStrippedInjectionMetadataForConversation(
   conversationId: string,
 ): void {
   rawRun(
     `UPDATE messages
-        SET metadata = json_remove(metadata, '$.pkbSystemReminderBlock')
+        SET metadata = json_remove(
+          metadata,
+          '$.pkbSystemReminderBlock',
+          '$.nowScratchpadBlock',
+          '$.pkbContextBlock'
+        )
       WHERE conversation_id = ?
         AND role = 'user'
         AND metadata IS NOT NULL
-        AND json_extract(metadata, '$.pkbSystemReminderBlock') IS NOT NULL`,
+        AND (
+          json_extract(metadata, '$.pkbSystemReminderBlock') IS NOT NULL
+          OR json_extract(metadata, '$.nowScratchpadBlock') IS NOT NULL
+          OR json_extract(metadata, '$.pkbContextBlock') IS NOT NULL
+        )`,
     conversationId,
   );
 }
@@ -1731,8 +1703,8 @@ export function getConversationOriginInterface(
  * in the given conversation, or `undefined` if none is found.
  *
  * Used by the pointer message trust resolver to detect conversations
- * whose audience is a guardian or trusted_contact (even if the
- * conversation itself isn't a desktop-origin private conversation).
+ * whose audience is a guardian or trusted_contact outside desktop-origin
+ * conversations.
  */
 export function getConversationRecentProvenanceTrustClass(
   conversationId: string,

package/src/memory/conversation-directories.ts

@@ -7,10 +7,7 @@ function getConversationDirTimestamp(createdAtMs: number): string {
   return new Date(createdAtMs).toISOString().replace(/:/g, "-");
 }
 
-export function getLegacyConversationDirName(
-  id: string,
-  createdAtMs: number,
-): string {
+function getLegacyConversationDirName(id: string, createdAtMs: number): string {
   return `${id}_${getConversationDirTimestamp(createdAtMs)}`;
 }
 
@@ -146,13 +143,6 @@ export function getResolvedConversationDirPath(
   return resolveConversationDirectoryPaths(id, createdAtMs).resolvedDirPath;
 }
 
-export function getResolvedConversationDirName(
-  id: string,
-  createdAtMs: number,
-): string {
-  return resolveConversationDirectoryPaths(id, createdAtMs).resolvedDirName;
-}
-
 export function getConversationAttachmentsDirPath(
   conversationId: string,
   createdAtMs: number,

package/src/memory/conversation-display-order-migration.ts

@@ -6,8 +6,7 @@
  */
 
 import { getLogger } from "../util/logger.js";
-import { rawRun } from "./db.js";
-
+import { rawRun } from "./raw-query.js";
 const log = getLogger("conversation-store");
 
 function isDuplicateColumnError(err: unknown): boolean {
@@ -41,3 +40,13 @@ export function ensureDisplayOrderMigration(): void {
     displayOrderColumnsEnsured = true;
   }
 }
+
+/**
+ * Reset the in-memory `displayOrderColumnsEnsured` guard so the next
+ * `ensureDisplayOrderMigration()` call re-runs. Intended ONLY for tests that
+ * recreate the SQLite database mid-process (e.g. `removeTestDbFiles()` in
+ * `db-conversation-inference-profile-migration.test.ts`).
+ */
+export function _resetDisplayOrderMigrationForTests(): void {
+  displayOrderColumnsEnsured = false;
+}

package/src/memory/conversation-group-migration.ts

@@ -10,8 +10,7 @@
 
 import { getLogger } from "../util/logger.js";
 import { ensureDisplayOrderMigration } from "./conversation-display-order-migration.js";
-import { rawExec, rawGet, rawRun } from "./db.js";
-
+import { rawExec, rawGet, rawRun } from "./raw-query.js";
 const log = getLogger("conversation-store");
 
 function isDuplicateColumnError(err: unknown): boolean {
@@ -20,6 +19,18 @@ function isDuplicateColumnError(err: unknown): boolean {
 
 let migrated = false;
 
+/**
+ * Reset the in-memory `migrated` guard so the next `ensureGroupMigration()`
+ * call re-runs the full migration. Intended ONLY for tests that recreate
+ * the SQLite database mid-process (e.g. `removeTestDbFiles()` in
+ * `db-conversation-inference-profile-migration.test.ts`) — without this,
+ * subsequent tests in the same `bun test` run hit
+ * `no such column: group_id` because the guard short-circuits the recreate.
+ */
+export function _resetGroupMigrationForTests(): void {
+  migrated = false;
+}
+
 /**
  * Uses raw BEGIN/COMMIT for the one-time backfill. Must NOT be called
  * for the first time inside a Drizzle db.transaction() block — SQLite
@@ -235,7 +246,10 @@ export function ensureGroupMigration(): void {
       rawExec("COMMIT");
     } catch (err) {
       rawExec("ROLLBACK");
-      log.error({ err }, "reflections-to-background migration failed, rolled back");
+      log.error(
+        { err },
+        "reflections-to-background migration failed, rolled back",
+      );
       throw err;
     }
   }
@@ -262,7 +276,9 @@ export function ensureGroupMigration(): void {
         WHERE group_id = 'system:reflections'
       `);
 
-      rawExec(`DELETE FROM conversation_groups WHERE id = 'system:reflections'`);
+      rawExec(
+        `DELETE FROM conversation_groups WHERE id = 'system:reflections'`,
+      );
 
       rawExec(`
         INSERT OR IGNORE INTO conversation_groups (id, name, sort_position, is_system_group)