@vellumai/assistant 0.6.3 → 0.6.5

package/src/memory/auto-analysis-enqueue.ts

@@ -0,0 +1,127 @@
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import { getConfig } from "../config/loader.js";
+import {
+  isUntrustedTrustClass,
+  type TrustClass,
+} from "../runtime/actor-trust-resolver.js";
+import { getLogger } from "../util/logger.js";
+import { isAutoAnalysisConversation } from "./auto-analysis-guard.js";
+import { getConversationType } from "./conversation-crud.js";
+import { upsertAutoAnalysisJob } from "./jobs-store.js";
+
+const log = getLogger("auto-analysis-enqueue");
+
+/**
+ * Trigger reason for an auto-analysis enqueue.
+ *   - `"batch"`: source conversation crossed the batch threshold — enqueue
+ *     immediately (`runAfter = now`) but still upsert so a pending job
+ *     coalesces rapid threshold crossings into one.
+ *   - `"idle"`: source conversation has been idle long enough to warrant a
+ *     debounced analysis pass.
+ *   - `"lifecycle"`: a conversation lifecycle transition (e.g. resume,
+ *     close) should trigger a debounced analysis pass.
+ *   - `"compaction"`: context was just compacted — some recent turns are
+ *     now hidden behind a summary, so crystallize anything worth
+ *     remembering before the window narrows further. Fires immediately
+ *     (`runAfter = now`) like `"batch"`.
+ */
+export type AutoAnalysisTrigger =
+  | "batch"
+  | "idle"
+  | "lifecycle"
+  | "compaction";
+
+/**
+ * Conditionally enqueue a `conversation_analyze` job for the given
+ * conversation. Skips silently when:
+ *   - the `auto-analyze` feature flag is disabled, OR
+ *   - the source conversation is itself an auto-analysis conversation
+ *     (recursion guard — we never analyze our own analysis output), OR
+ *   - the source conversation is private (`analyzeConversation` rejects
+ *     private conversations, so enqueueing would guarantee a failed job).
+ *
+ * Immediate triggers (`"batch"`, `"compaction"`) and debounced triggers
+ * (`"idle"`, `"lifecycle"`) are written to separate rows keyed by a
+ * `triggerGroup` discriminator. This prevents an idle enqueue from
+ * pushing an already-scheduled batch row's `runAfter` into the future
+ * (and vice versa). Within each group, rapid enqueues still coalesce to
+ * a single pending row via `upsertAutoAnalysisJob`.
+ */
+export function enqueueAutoAnalysisIfEnabled(args: {
+  conversationId: string;
+  trigger: AutoAnalysisTrigger;
+}): void {
+  const { conversationId, trigger } = args;
+
+  let config;
+  try {
+    config = getConfig();
+  } catch (err) {
+    log.warn(
+      { err, conversationId },
+      "Skipping auto-analysis enqueue: failed to load config",
+    );
+    return;
+  }
+
+  if (!isAssistantFeatureFlagEnabled("auto-analyze", config)) {
+    return;
+  }
+
+  if (isAutoAnalysisConversation(conversationId)) {
+    log.debug(
+      { conversationId, trigger },
+      "Skipping auto-analysis enqueue: source is an auto-analysis conversation",
+    );
+    return;
+  }
+
+  if (getConversationType(conversationId) === "private") {
+    log.debug(
+      { conversationId, trigger },
+      "Skipping auto-analysis enqueue: source is a private conversation",
+    );
+    return;
+  }
+
+  const idleTimeoutMs = config.analysis?.idleTimeoutMs ?? 600_000;
+  const runImmediately = trigger === "batch" || trigger === "compaction";
+  const triggerGroup: "immediate" | "debounced" = runImmediately
+    ? "immediate"
+    : "debounced";
+  const runAfter = runImmediately ? Date.now() : Date.now() + idleTimeoutMs;
+
+  try {
+    upsertAutoAnalysisJob({ conversationId, triggerGroup }, runAfter);
+  } catch (err) {
+    log.warn(
+      { err, conversationId, trigger },
+      "Failed to enqueue auto-analysis job",
+    );
+  }
+}
+
+/**
+ * Fire an auto-analysis enqueue from a compaction site. Wraps
+ * `enqueueAutoAnalysisIfEnabled` with the trust-class gate and
+ * best-effort error handling used at every compaction call site, so
+ * the six compaction paths (forceCompact, preflight, overflow reducer,
+ * mid-loop, and two emergency paths) stay in sync.
+ *
+ * Trust gate mirrors the memory-extraction trust boundary applied in
+ * `disposeConversation` — we don't trigger analysis (which runs with
+ * guardian trust + full tools) for conversations with an untrusted actor.
+ */
+export function enqueueAutoAnalysisOnCompaction(
+  conversationId: string,
+  trustClass: TrustClass | undefined,
+): void {
+  if (isUntrustedTrustClass(trustClass)) {
+    return;
+  }
+  try {
+    enqueueAutoAnalysisIfEnabled({ conversationId, trigger: "compaction" });
+  } catch {
+    // Best-effort — never block compaction on enqueue failures.
+  }
+}

package/src/memory/auto-analysis-guard.ts

@@ -0,0 +1,27 @@
+import { getConversationSource } from "./conversation-crud.js";
+
+/**
+ * The `source` value used for conversations created by the auto-analysis
+ * loop. Single source of truth — downstream code (enqueue helper,
+ * service auto-branch) imports this constant rather than hardcoding the
+ * string.
+ */
+export const AUTO_ANALYSIS_SOURCE = "auto-analysis";
+
+/**
+ * Dedicated `group_id` value for auto-analysis rolling conversations.
+ * Placed in the `system:background` group alongside heartbeat and filing
+ * conversations, rendered as a "Reflections" sub-group in the sidebar.
+ */
+export const AUTO_ANALYSIS_GROUP_ID = "system:background";
+
+/**
+ * Returns true if the conversation's `source` column is `"auto-analysis"`,
+ * meaning it was produced by the auto-analysis loop. Callers use this to
+ * skip both `graph_extract` and `conversation_analyze` enqueues so we
+ * never (a) analyze our own analysis output or (b) extract memory from
+ * reflective musings (the analysis agent writes memory directly via tools).
+ */
+export function isAutoAnalysisConversation(conversationId: string): boolean {
+  return getConversationSource(conversationId) === AUTO_ANALYSIS_SOURCE;
+}

package/src/memory/cleanup-schedule-state.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared state for the cleanup-scheduler throttle.
+ *
+ * `maybeEnqueueScheduledCleanupJobs` in jobs-worker.ts gates cleanup-job
+ * enqueueing behind a 6-hour window (configurable via
+ * memory.cleanup.enqueueIntervalMs). This module owns the "last enqueue"
+ * timestamp so that code paths outside jobs-worker — notably
+ * ConfigWatcher.refreshConfigFromSources — can reset the throttle without
+ * pulling in jobs-worker's large transitive import graph.
+ *
+ * The ConfigWatcher uses resetCleanupScheduleThrottle() to ensure that
+ * retention changes made via the UI (which flow through config.json →
+ * invalidateConfigCache → refreshConfigFromSources) take effect on the
+ * very next scheduler tick instead of waiting out the remaining window.
+ */
+
+let lastScheduledCleanupEnqueueMs = 0;
+
+/** Read the timestamp of the most recent enqueue (0 if never/reset). */
+export function getLastScheduledCleanupEnqueueMs(): number {
+  return lastScheduledCleanupEnqueueMs;
+}
+
+/** Record that an enqueue just happened at `nowMs`. */
+export function markScheduledCleanupEnqueued(nowMs: number): void {
+  lastScheduledCleanupEnqueueMs = nowMs;
+}
+
+/**
+ * Clear the throttle so the next `maybeEnqueueScheduledCleanupJobs` call
+ * bypasses the `enqueueIntervalMs` window. Used by ConfigWatcher when
+ * retention settings change, and by tests that need deterministic
+ * scheduling.
+ */
+export function resetCleanupScheduleThrottle(): void {
+  lastScheduledCleanupEnqueueMs = 0;
+}

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

@@ -0,0 +1,74 @@
+// ---------------------------------------------------------------------------
+// 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.
+//
+// The service itself distinguishes manual vs. auto triggers: this handler
+// always invokes with `trigger: "auto"`, so the rolling analysis conversation
+// logic and recursion guard apply.
+// ---------------------------------------------------------------------------
+
+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";
+
+const log = getLogger("conversation-analyze-job");
+
+export async function conversationAnalyzeJob(
+  job: MemoryJob<{ conversationId?: string }>,
+  _config: AssistantConfig,
+): Promise<void> {
+  const { conversationId } = job.payload;
+  if (!conversationId) {
+    log.warn({ jobId: job.id }, "Skipping job: missing conversationId");
+    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, {
+    trigger: "auto",
+  });
+  if ("error" in result) {
+    log.warn(
+      { jobId: job.id, conversationId, error: result.error },
+      "Auto-analysis service rejected source conversation",
+    );
+    return;
+  }
+  if (result.skipped) {
+    // The rolling analysis conversation was still processing a prior run, so
+    // this invocation was a no-op. Schedule a debounced follow-up ourselves
+    // — otherwise, if no later batch/idle/lifecycle trigger arrives (e.g.
+    // the conversation goes quiet after a long in-flight analysis), new
+    // source messages would stay un-analyzed indefinitely.
+    enqueueAutoAnalysisIfEnabled({ conversationId, trigger: "idle" });
+    log.debug(
+      { jobId: job.id, conversationId },
+      "Auto-analysis skipped (rolling conversation busy); requeued follow-up",
+    );
+  }
+}

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

@@ -172,11 +172,8 @@ export function seedForkedConversationAttention(params: {
   latestAssistantMessageId: string | null;
   latestAssistantMessageAt: number | null;
 }): void {
-  const {
-    conversationId,
-    latestAssistantMessageId,
-    latestAssistantMessageAt,
-  } = params;
+  const { conversationId, latestAssistantMessageId, latestAssistantMessageAt } =
+    params;
 
   if (!latestAssistantMessageId || latestAssistantMessageAt == null) {
     return;
@@ -458,9 +455,15 @@ function resolveAssistantCursor(params: {
  * This uses the existing attention projection instead of adding a separate
  * manual-unread state machine.
  */
-export function markConversationUnread(conversationId: string): void {
+/**
+ * Returns `true` when the seen cursor was actually rewound (state changed),
+ * `false` when the conversation was already unread (no-op).
+ * Throws `UserError` when there is no assistant message to mark unread.
+ */
+export function markConversationUnread(conversationId: string): boolean {
   const db = getDb();
   const now = Date.now();
+  let changed = false;
 
   db.transaction((tx) => {
     const state = tx
@@ -511,6 +514,7 @@ export function markConversationUnread(conversationId: string): void {
           updatedAt: now,
         })
         .run();
+      changed = true;
       return;
     }
 
@@ -524,7 +528,10 @@ export function markConversationUnread(conversationId: string): void {
         eq(conversationAssistantAttentionState.conversationId, conversationId),
       )
       .run();
+    changed = true;
   });
+
+  return changed;
 }
 
 // ── getAttentionStateByConversationIds ───────────────────────────────

package/src/memory/conversation-crud.ts

@@ -10,6 +10,7 @@ import {
   gte,
   inArray,
   isNull,
+  like,
   lt,
   lte,
   sql,
@@ -23,6 +24,7 @@ import { CHANNEL_IDS, INTERFACE_IDS, isChannelId } from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
 import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
 import { UserError } from "../util/errors.js";
+import { safeParseRecord } from "../util/json.js";
 import { getLogger } from "../util/logger.js";
 import { getConversationsDir } from "../util/platform.js";
 import { createRowMapper } from "../util/row-mapper.js";
@@ -30,6 +32,7 @@ import {
   deleteOrphanAttachments,
   linkAttachmentToMessage,
 } from "./attachments-store.js";
+import { AUTO_ANALYSIS_SOURCE } from "./auto-analysis-guard.js";
 import {
   projectAssistantMessage,
   seedForkedConversationAttention,
@@ -101,6 +104,9 @@ export const messageMetadataSchema = z
     forkSourceMessageId: z.string().optional(),
     /** Image source paths from desktop attachments, keyed by filename. */
     imageSourcePaths: z.record(z.string(), z.string()).optional(),
+    memoryInjectedBlock: z.string().optional(),
+    turnContextBlock: z.string().optional(),
+    pkbSystemReminderBlock: z.string().optional(),
   })
   .passthrough();
 
@@ -174,6 +180,7 @@ export interface ConversationRow {
   isAutoTitle: number;
   scheduleJobId: string | null;
   lastMessageAt: number | null;
+  archivedAt: number | null;
 }
 
 export const parseConversation = createRowMapper<
@@ -201,6 +208,7 @@ export const parseConversation = createRowMapper<
   isAutoTitle: "isAutoTitle",
   scheduleJobId: "scheduleJobId",
   lastMessageAt: "lastMessageAt",
+  archivedAt: "archivedAt",
 });
 
 export interface MessageRow {
@@ -248,6 +256,7 @@ export function createConversation(
         scheduleJobId?: string;
         groupId?: string;
         hostAccess?: boolean;
+        forkParentConversationId?: string;
       },
 ) {
   const db = getDb();
@@ -284,6 +293,7 @@ export function createConversation(
     source,
     memoryScopeId,
     scheduleJobId: opts.scheduleJobId ?? null,
+    forkParentConversationId: opts.forkParentConversationId ?? null,
   };
 
   // Retry on SQLITE_BUSY and SQLITE_IOERR — transient disk I/O errors or WAL
@@ -379,6 +389,52 @@ export function countConversationsByScheduleJobId(
   );
 }
 
+/**
+ * Find the rolling analysis conversation for a given source conversation,
+ * or null if none exists yet. Used by the auto-analyze loop to append
+ * to an existing analysis conversation rather than creating a new one
+ * each time the analyze job fires.
+ *
+ * Returns the most recently updated match if multiple exist (defensive —
+ * shouldn't happen in normal operation but the contract is well-defined).
+ *
+ * Hits `idx_conversations_fork_parent_conversation_id` for the
+ * `forkParentConversationId` lookup.
+ */
+export function findAnalysisConversationFor(
+  parentConversationId: string,
+): { id: string } | null {
+  const db = getDb();
+  const row = db
+    .select({ id: conversations.id })
+    .from(conversations)
+    .where(
+      and(
+        eq(conversations.source, AUTO_ANALYSIS_SOURCE),
+        eq(conversations.forkParentConversationId, parentConversationId),
+      ),
+    )
+    .orderBy(desc(conversations.updatedAt))
+    .limit(1)
+    .get();
+  return row ? { id: row.id } : null;
+}
+
+/**
+ * Returns the `source` column for the given conversation, or null if
+ * not found. Tiny convenience used by the recursion guard in the
+ * auto-analyze loop.
+ */
+export function getConversationSource(conversationId: string): string | null {
+  const db = getDb();
+  const row = db
+    .select({ source: conversations.source })
+    .from(conversations)
+    .where(eq(conversations.id, conversationId))
+    .get();
+  return row?.source ?? null;
+}
+
 export function getConversationType(
   conversationId: string,
 ): "standard" | "private" {
@@ -991,6 +1047,49 @@ export function getMessages(conversationId: string): MessageRow[] {
     .map(parseMessage);
 }
 
+/**
+ * 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.
+ */
+export function countMessagesWithSlackMeta(
+  conversationId: string,
+  limit: number,
+): number {
+  const db = getDb();
+  const rows = db
+    .select({ one: sql`1` })
+    .from(messages)
+    .where(
+      and(
+        eq(messages.conversationId, conversationId),
+        like(messages.metadata, '%"slackMeta"%'),
+      ),
+    )
+    .limit(limit)
+    .all();
+  return rows.length;
+}
+
+/**
+ * Efficient existence check — returns true if the conversation has at least
+ * one message row. Uses `LIMIT 1` + `select({ 1 })` to avoid loading and
+ * parsing any message content.
+ */
+export function hasMessages(conversationId: string): boolean {
+  const db = getDb();
+  const row = db
+    .select({ one: sql`1` })
+    .from(messages)
+    .where(eq(messages.conversationId, conversationId))
+    .limit(1)
+    .get();
+  return row !== undefined;
+}
+
 export interface PaginatedMessagesResult {
   messages: MessageRow[];
   hasMore: boolean;
@@ -1062,6 +1161,27 @@ export function getLastAssistantTimestampBefore(
   return row?.createdAt ?? 0;
 }
 
+export function getLastUserTimestampBefore(
+  conversationId: string,
+  beforeTimestamp: number,
+): number {
+  const db = getDb();
+  const row = db
+    .select({ createdAt: messages.createdAt })
+    .from(messages)
+    .where(
+      and(
+        eq(messages.conversationId, conversationId),
+        eq(messages.role, "user"),
+        lt(messages.createdAt, beforeTimestamp),
+      ),
+    )
+    .orderBy(desc(messages.createdAt))
+    .limit(1)
+    .get();
+  return row?.createdAt ?? 0;
+}
+
 /** Fetch a single message by ID, optionally scoped to a specific conversation. */
 export function getMessageById(
   messageId: string,
@@ -1146,6 +1266,31 @@ export function updateConversationHostAccess(
     .run();
 }
 
+export function archiveConversation(id: string): boolean {
+  const conv = getConversation(id);
+  if (!conv) return false;
+  const now = Date.now();
+  rawRun(
+    "UPDATE conversations SET archived_at = ?, updated_at = ? WHERE id = ?",
+    now,
+    now,
+    id,
+  );
+  return true;
+}
+
+export function unarchiveConversation(id: string): boolean {
+  const conv = getConversation(id);
+  if (!conv) return false;
+  const now = Date.now();
+  rawRun(
+    "UPDATE conversations SET archived_at = NULL, updated_at = ? WHERE id = ?",
+    now,
+    id,
+  );
+  return true;
+}
+
 /**
  * Delete all conversations, messages, and related data (tool invocations,
  * memory segments, etc.) from the daemon database.
@@ -1357,6 +1502,60 @@ export function updateMessageMetadata(
     .run();
 }
 
+/**
+ * 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).
+ */
+export function clearPkbSystemReminderMetadataForConversation(
+  conversationId: string,
+): void {
+  rawRun(
+    `UPDATE messages
+        SET metadata = json_remove(metadata, '$.pkbSystemReminderBlock')
+      WHERE conversation_id = ?
+        AND role = 'user'
+        AND metadata IS NOT NULL
+        AND json_extract(metadata, '$.pkbSystemReminderBlock') IS NOT NULL`,
+    conversationId,
+  );
+}
+
+/**
+ * Atomically update both `content` and (shallow-merged) `metadata` for a
+ * message. Used by edit-propagation paths that need to update the message
+ * body and stamp metadata (e.g. `slackMeta.editedAt`) in a single
+ * transaction so a partial write cannot leak.
+ *
+ * `metadataUpdates` is shallow-merged into the existing top-level metadata
+ * object. To merge into a nested sub-key (e.g. `slackMeta`), the caller
+ * must compute the merged sub-value first and pass `{ slackMeta: merged }`.
+ */
+export function updateMessageContentAndMetadata(
+  messageId: string,
+  newContent: string,
+  metadataUpdates: Record<string, unknown>,
+): void {
+  const db = getDb();
+  db.transaction((tx) => {
+    const row = tx
+      .select({ metadata: messages.metadata })
+      .from(messages)
+      .where(eq(messages.id, messageId))
+      .get();
+    const existing = row?.metadata ? safeParseRecord(row.metadata) : {};
+    tx.update(messages)
+      .set({
+        content: newContent,
+        metadata: JSON.stringify({ ...existing, ...metadataUpdates }),
+      })
+      .where(eq(messages.id, messageId))
+      .run();
+  });
+}
+
 /**
  * Re-link all attachments from a set of source messages to a target message.
  * Used during message consolidation so that attachments linked to deleted

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

@@ -310,6 +310,13 @@ export function syncMessageToDisk(
     if (toolResults.length > 0) record.toolResults = toolResults;
     if (attachmentFilenames.length > 0)
       record.attachments = attachmentFilenames;
+    if (message.metadata) {
+      try {
+        record.metadata = JSON.parse(message.metadata);
+      } catch {
+        // Invalid JSON — omit metadata from disk record
+      }
+    }
 
     appendFileSync(
       join(dirPath, "messages.jsonl"),

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

@@ -57,7 +57,7 @@ export function ensureGroupMigration(): void {
     }
   }
 
-  // 3. Seed system groups (four: pinned, scheduled, background, all)
+  // 3. Seed system groups.
   const now = Math.floor(Date.now() / 1000);
   rawExec(`
     INSERT OR IGNORE INTO conversation_groups (id, name, sort_position, is_system_group, created_at, updated_at)
@@ -213,5 +213,69 @@ export function ensureGroupMigration(): void {
     }
   }
 
+  // 6. One-time migration: move auto-analysis conversations from system:reflections to system:background
+  const reflectionsMigrateDone = rawGet<{ id: string }>(
+    "SELECT id FROM conversation_groups WHERE id = '_reflections_to_background_complete'",
+  );
+
+  if (!reflectionsMigrateDone) {
+    try {
+      rawExec("BEGIN");
+
+      rawExec(`
+        UPDATE conversations SET group_id = 'system:background'
+        WHERE group_id = 'system:reflections'
+      `);
+
+      rawExec(`
+        INSERT OR IGNORE INTO conversation_groups (id, name, sort_position, is_system_group)
+        VALUES ('_reflections_to_background_complete', '_reflections_to_background_complete', -1, TRUE)
+      `);
+
+      rawExec("COMMIT");
+    } catch (err) {
+      rawExec("ROLLBACK");
+      log.error({ err }, "reflections-to-background migration failed, rolled back");
+      throw err;
+    }
+  }
+
+  // 7. One-time cleanup: delete the orphaned system:reflections group row.
+  //
+  // Reflections render as a sub-group under Background via the client's
+  // sub-group label provider; the standalone system:reflections group is no
+  // longer referenced by any conversation after step 6. Leaving the row in
+  // place causes the macOS sidebar to render an empty duplicate "Reflections"
+  // entry with a fallback folder icon alongside the Background sub-group.
+  const reflectionsGroupDeleted = rawGet<{ id: string }>(
+    "SELECT id FROM conversation_groups WHERE id = '_reflections_group_deleted_complete'",
+  );
+
+  if (!reflectionsGroupDeleted) {
+    try {
+      rawExec("BEGIN");
+
+      // Belt-and-suspenders: re-run the conversation move in case a straggler
+      // crept in between step 6's sentinel being set and this step shipping.
+      rawExec(`
+        UPDATE conversations SET group_id = 'system:background'
+        WHERE group_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)
+        VALUES ('_reflections_group_deleted_complete', '_reflections_group_deleted_complete', -1, TRUE)
+      `);
+
+      rawExec("COMMIT");
+    } catch (err) {
+      rawExec("ROLLBACK");
+      log.error({ err }, "reflections-group deletion failed, rolled back");
+      throw err;
+    }
+  }
+
   migrated = true;
 }