@vellumai/assistant 0.8.0 → 0.8.1

package/src/memory/memory-retrospective-startup-cleanup.ts

@@ -0,0 +1,108 @@
+// ---------------------------------------------------------------------------
+// Memory retrospective — startup orphan cleanup.
+// ---------------------------------------------------------------------------
+//
+// When the daemon crashes mid-retrospective, the bootstrapped background
+// conversation lingers in the `conversations` table (and possibly the
+// `messages` table) as an orphan. The jobs-store recovery
+// (`resetRunningJobsToPending`) handles re-running the job, which bootstraps
+// a NEW background conversation — but the previous one is never deleted
+// because the original handler's cleanup path didn't get a chance to run.
+//
+// This module sweeps those orphans on daemon startup. Run AFTER
+// `resetRunningJobsToPending` so legitimate in-flight retries (which are
+// represented by their pending job row, not by a memory-retrospective
+// conversation directly) aren't swept.
+//
+// Sweep predicate:
+//   - `source = "memory-retrospective"`, AND
+//   - `last_message_at < now - 1 hour` (so a freshly-running job's
+//     conversation isn't swept on a startup that happens to race),
+//   - AND no pending OR running `memory_retrospective` job exists. (The
+//     orphan background conversation references the SOURCE conversation
+//     via the wake hint; if a job exists for that source, the background
+//     conversation might be the active one. We're conservative and only
+//     sweep when no job exists at all, since the worst-case false-positive
+//     is leaving a few extra orphans for the next sweep to catch.)
+
+import { and, eq, inArray, isNotNull, lt, notInArray, sql } from "drizzle-orm";
+
+import { getLogger } from "../util/logger.js";
+import { deleteConversation } from "./conversation-crud.js";
+import { getDb } from "./db-connection.js";
+import { MEMORY_RETROSPECTIVE_SOURCE } from "./memory-retrospective-constants.js";
+import { conversations, memoryJobs } from "./schema.js";
+
+const log = getLogger("memory-retrospective-startup-cleanup");
+
+const ORPHAN_AGE_MS = 60 * 60 * 1000;
+
+export interface CleanupResult {
+  swept: number;
+}
+
+/**
+ * Find and delete orphan memory-retrospective background conversations.
+ * Idempotent — safe to call repeatedly. Returns the number of conversations
+ * deleted. Best-effort: errors deleting individual rows are logged and the
+ * sweep continues.
+ */
+export function sweepOrphanMemoryRetrospectiveConversations(
+  now: number = Date.now(),
+): CleanupResult {
+  const cutoff = now - ORPHAN_AGE_MS;
+  const db = getDb();
+
+  const activeJobConversationIds = db
+    .select({
+      conversationId: sql<string>`json_extract(${memoryJobs.payload}, '$.conversationId')`,
+    })
+    .from(memoryJobs)
+    .where(
+      and(
+        eq(memoryJobs.type, "memory_retrospective"),
+        inArray(memoryJobs.status, ["pending", "running"]),
+      ),
+    )
+    .all()
+    .map((row) => row.conversationId)
+    .filter((id): id is string => typeof id === "string" && id.length > 0);
+
+  const orphans = db
+    .select({ id: conversations.id })
+    .from(conversations)
+    .where(
+      and(
+        eq(conversations.source, MEMORY_RETROSPECTIVE_SOURCE),
+        // Conservative: only sweep rows that have had at least one message
+        // AND haven't seen activity recently. Conversations without a
+        // last_message_at value are too fresh to assess.
+        isNotNull(conversations.lastMessageAt),
+        lt(conversations.lastMessageAt, cutoff),
+        activeJobConversationIds.length > 0
+          ? notInArray(conversations.id, activeJobConversationIds)
+          : sql`1=1`,
+      ),
+    )
+    .all();
+
+  let swept = 0;
+  for (const row of orphans) {
+    try {
+      deleteConversation(row.id);
+      swept++;
+    } catch (err) {
+      log.warn(
+        { err, conversationId: row.id },
+        "Failed to delete orphan memory-retrospective conversation; continuing",
+      );
+    }
+  }
+  if (swept > 0) {
+    log.info(
+      { swept, cutoff },
+      "Swept orphan memory-retrospective background conversations",
+    );
+  }
+  return { swept };
+}

package/src/memory/memory-retrospective-state.ts

@@ -0,0 +1,162 @@
+// ---------------------------------------------------------------------------
+// Memory retrospective — per-conversation state CRUD.
+// ---------------------------------------------------------------------------
+//
+// Two pointers move independently:
+//   - `lastProcessedMessageId` advances ONLY when a retrospective run
+//     completes successfully (correctness invariant — failures must
+//     re-process the same messages on the next attempt).
+//   - `lastRunAt` advances on EVERY job end (success or failure). Drives the
+//     per-conversation cooldown gate in the trigger-check helper so failing
+//     jobs can't loop in tight retries across trigger types.
+//
+// The schema enforces the foreign key with ON DELETE CASCADE, so deleting a
+// conversation collects its state row automatically.
+
+import { eq } from "drizzle-orm";
+
+import { type DrizzleDb, getDb } from "./db-connection.js";
+import { memoryRetrospectiveState } from "./schema.js";
+
+export interface MemoryRetrospectiveState {
+  conversationId: string;
+  lastProcessedMessageId: string;
+  lastRunAt: number;
+}
+
+/**
+ * Load the state row for a conversation, or `null` if no row exists.
+ */
+export function getRetrospectiveState(
+  conversationId: string,
+): MemoryRetrospectiveState | null {
+  const row = getDb()
+    .select()
+    .from(memoryRetrospectiveState)
+    .where(eq(memoryRetrospectiveState.conversationId, conversationId))
+    .get();
+  if (!row) return null;
+  return {
+    conversationId: row.conversationId,
+    lastProcessedMessageId: row.lastProcessedMessageId,
+    lastRunAt: row.lastRunAt,
+  };
+}
+
+/**
+ * Upsert both pointers atomically. Used on successful retrospective runs.
+ */
+export function upsertRetrospectiveState(args: MemoryRetrospectiveState): void {
+  const db = getDb();
+  db.insert(memoryRetrospectiveState)
+    .values({
+      conversationId: args.conversationId,
+      lastProcessedMessageId: args.lastProcessedMessageId,
+      lastRunAt: args.lastRunAt,
+    })
+    .onConflictDoUpdate({
+      target: memoryRetrospectiveState.conversationId,
+      set: {
+        lastProcessedMessageId: args.lastProcessedMessageId,
+        lastRunAt: args.lastRunAt,
+      },
+    })
+    .run();
+}
+
+/**
+ * Carry the source conversation's retrospective state into a forked child so
+ * the fork doesn't re-process content the parent already covered. Synchronous
+ * so it can run inside the bun:sqlite transaction wrapping `forkConversation`.
+ *
+ * Mapping for `lastProcessedMessageId`:
+ *
+ *   - source has no state row → no-op (child inherits "first run" semantics
+ *     and `findMostRecentRetrospectiveFor` walks the fork chain instead).
+ *   - source pointer is the `""` sentinel (failed-only attempts, never
+ *     succeeded) → child pointer is also `""`.
+ *   - source pointer is within the copied range (`forkedMessageIds` has it) →
+ *     child pointer is the mapped forked message ID.
+ *   - source pointer is past the fork boundary (not in `forkedMessageIds`) →
+ *     child pointer is the last copied message's mapped ID. All copied
+ *     messages have already been retro'd by the source, so the child should
+ *     wait for new post-fork messages before its first retro fires.
+ *
+ * `lastRunAt` is copied verbatim — the cooldown gate inherits from source.
+ */
+export function forkRetrospectiveState(args: {
+  database: DrizzleDb;
+  sourceConversationId: string;
+  forkedConversationId: string;
+  forkedMessageIds: Map<string, string>;
+  lastCopiedSourceMessageId: string | null;
+}): void {
+  const {
+    database,
+    sourceConversationId,
+    forkedConversationId,
+    forkedMessageIds,
+    lastCopiedSourceMessageId,
+  } = args;
+
+  const sourceRow = database
+    .select()
+    .from(memoryRetrospectiveState)
+    .where(eq(memoryRetrospectiveState.conversationId, sourceConversationId))
+    .get();
+  if (!sourceRow) return;
+
+  let forkedPointer = "";
+  if (sourceRow.lastProcessedMessageId !== "") {
+    const mapped = forkedMessageIds.get(sourceRow.lastProcessedMessageId);
+    if (mapped !== undefined) {
+      forkedPointer = mapped;
+    } else if (lastCopiedSourceMessageId !== null) {
+      // Source pointer is past the fork boundary — everything copied has
+      // already been processed by the source, so clamp to the last copied
+      // message so the fork waits for new post-fork messages.
+      forkedPointer = forkedMessageIds.get(lastCopiedSourceMessageId) ?? "";
+    }
+  }
+
+  database
+    .insert(memoryRetrospectiveState)
+    .values({
+      conversationId: forkedConversationId,
+      lastProcessedMessageId: forkedPointer,
+      lastRunAt: sourceRow.lastRunAt,
+    })
+    .onConflictDoUpdate({
+      target: memoryRetrospectiveState.conversationId,
+      set: {
+        lastProcessedMessageId: forkedPointer,
+        lastRunAt: sourceRow.lastRunAt,
+      },
+    })
+    .run();
+}
+
+/**
+ * Advance only `lastRunAt`. Used on every failure path so the cooldown gate
+ * applies to subsequent trigger-driven enqueues. If no row exists yet (first
+ * attempt failed), seed `lastProcessedMessageId` to the empty string — a
+ * sentinel meaning "nothing successfully processed yet" that subsequent
+ * `getMessagesSince(...)` queries treat the same as a missing row.
+ */
+export function bumpRetrospectiveLastRunAt(
+  conversationId: string,
+  lastRunAt: number,
+): void {
+  const db = getDb();
+  db.insert(memoryRetrospectiveState)
+    .values({
+      conversationId,
+      lastProcessedMessageId: "",
+      lastRunAt,
+    })
+    .onConflictDoUpdate({
+      target: memoryRetrospectiveState.conversationId,
+      set: { lastRunAt },
+    })
+    .run();
+}

package/src/memory/memory-retrospective-trigger-check.ts

@@ -0,0 +1,91 @@
+// ---------------------------------------------------------------------------
+// Memory retrospective — periodic trigger check.
+// ---------------------------------------------------------------------------
+//
+// Called from post-turn hooks (after each agent turn completes). Decides
+// whether to enqueue a retrospective for this conversation based on:
+//
+//   1. Cooldown gate: never within `minCooldownMs` of the last attempt
+//      (success or failure). Prevents tight retry loops across trigger
+//      types.
+//   2. Interval threshold: time since last attempt >= `timeThresholdMs`.
+//   3. Message count threshold: new messages since `lastProcessedMessageId`
+//      >= `messageThreshold`.
+//
+// First-run case (no state row) skips the cooldown — `lastRunAt = 0` so the
+// gap is effectively `Infinity`. The interval threshold trips immediately;
+// the message-count threshold trips once enough messages accumulate.
+
+import type { AssistantConfig } from "../config/types.js";
+import { getLogger } from "../util/logger.js";
+import { countMessagesAfter } from "./conversation-crud.js";
+import { enqueueMemoryRetrospectiveIfEnabled } from "./memory-retrospective-enqueue.js";
+import { getRetrospectiveState } from "./memory-retrospective-state.js";
+
+const log = getLogger("memory-retrospective-trigger-check");
+
+export type RetrospectiveTrigger = "interval" | "message_count";
+
+/**
+ * Returns the trigger kind that fired, or `null` if no threshold tripped.
+ * Exported separately from `maybeEnqueueRetrospective` so tests can assert on
+ * the decision without observing side effects.
+ */
+export function shouldEnqueueRetrospective(args: {
+  state: { lastProcessedMessageId: string; lastRunAt: number } | null;
+  newMessageCount: number;
+  now: number;
+  timeThresholdMs: number;
+  messageThreshold: number;
+  minCooldownMs: number;
+}): RetrospectiveTrigger | null {
+  const {
+    state,
+    newMessageCount,
+    now,
+    timeThresholdMs,
+    messageThreshold,
+    minCooldownMs,
+  } = args;
+
+  if (state && now - state.lastRunAt < minCooldownMs) return null;
+
+  if (state && now - state.lastRunAt >= timeThresholdMs) return "interval";
+  if (!state) return "interval";
+
+  if (newMessageCount >= messageThreshold) return "message_count";
+  return null;
+}
+
+/**
+ * Post-turn hook entry point. Looks up state, counts new messages, evaluates
+ * thresholds, and enqueues if appropriate. Best-effort — any thrown error is
+ * caught and logged so the agent turn cleanup path doesn't fail.
+ */
+export function maybeEnqueueRetrospective(
+  conversationId: string,
+  config: AssistantConfig,
+): void {
+  try {
+    const state = getRetrospectiveState(conversationId);
+    const newMessageCount = countMessagesAfter(
+      conversationId,
+      state?.lastProcessedMessageId ?? null,
+    );
+    if (newMessageCount === 0) return;
+
+    const trigger = shouldEnqueueRetrospective({
+      state,
+      newMessageCount,
+      now: Date.now(),
+      timeThresholdMs: config.memory.retrospective.timeThresholdMs,
+      messageThreshold: config.memory.retrospective.messageThreshold,
+      minCooldownMs: config.memory.retrospective.minCooldownMs,
+    });
+    if (!trigger) return;
+
+    enqueueMemoryRetrospectiveIfEnabled({ conversationId, trigger });
+  } catch (err) {
+    log.warn({ err, conversationId }, "trigger-check failed; skipping enqueue");
+  }
+}

package/src/memory/memory-v2-activation-log-store.ts

@@ -39,8 +39,43 @@ export interface MemoryV2ConceptRowRecord {
    */
   inRerankPool: boolean;
   spreadContribution: number;
-  source: "prior_state" | "ann_top50" | "both";
-  status: "in_context" | "injected" | "not_injected" | "page_missing";
+  /**
+   * Provenance of this concept row.
+   *   - `prior_state` — carried over from prior turn's activation state.
+   *   - `ann_top50`   — entered via ANN top-K candidate pool.
+   *   - `both`        — present in both prior state and ANN pool.
+   *   - `router`      — selected by the Sonnet router (memory-v2 router
+   *     mode). Router-mode rows zero out all activation values
+   *     (`finalActivation`, `ownActivation`, `priorActivation`, channel
+   *     similarities, rerank boosts, `spreadContribution`) because the
+   *     router does not compute spreading-activation scores.
+   *   - `carry_over`  — router-mode row representing a slug carried over
+   *     from `priorEverInjected` that the router did NOT re-pick on this
+   *     turn. The cached attachment from a prior turn is still present
+   *     on a prior user message; emitting `source: "router"` for these
+   *     rows would overcount router selections in inspector queries.
+   *     Same zeroed activation values as `router`.
+   */
+  source: "prior_state" | "ann_top50" | "both" | "router" | "carry_over";
+  /**
+   * Per-turn outcome for this slug:
+   *   - `in_context`  — already injected on a prior turn; cached attachment
+   *     remains visible without re-rendering.
+   *   - `injected`    — freshly rendered into this turn's user message.
+   *   - `not_injected`— a candidate that didn't make `slugsToRender`.
+   *   - `page_missing`— would-have-been-injected, but `readPage` returned
+   *     null (file vanished between selection and render — stale Qdrant
+   *     or edge-index entry).
+   *   - `corrupt`     — would-have-been-injected, but `readPage` threw
+   *     (e.g. malformed frontmatter). Other slugs in the same batch
+   *     rendered normally.
+   */
+  status:
+    | "in_context"
+    | "injected"
+    | "not_injected"
+    | "page_missing"
+    | "corrupt";
 }
 
 export interface MemoryV2ConfigSnapshot {
@@ -57,7 +92,16 @@ export interface MemoryV2ConfigSnapshot {
 export interface RecordMemoryV2ActivationLogParams {
   conversationId: string;
   turn: number;
-  mode: "context-load" | "per-turn";
+  /**
+   * Call-site mode: `context-load` for fresh / post-compaction loads,
+   * `per-turn` for normal append injections, `errored` when `injectMemoryV2Block`
+   * threw before completing — telemetry is still written so silent failures
+   * are observable in the database, with whatever `concepts` rows had been
+   * built so far (possibly empty). `router` indicates the Sonnet
+   * router selected the per-turn page set; router-mode rows carry zeroed
+   * activation values and `source: "router"` on every concept row.
+   */
+  mode: "context-load" | "per-turn" | "errored" | "router";
   concepts: MemoryV2ConceptRowRecord[];
   config: MemoryV2ConfigSnapshot;
 }
@@ -105,7 +149,7 @@ export function backfillMemoryV2ActivationMessageId(
 export interface MemoryV2ActivationLog {
   conversationId: string;
   turn: number;
-  mode: "context-load" | "per-turn";
+  mode: "context-load" | "per-turn" | "errored" | "router";
   concepts: MemoryV2ConceptRowRecord[];
   config: MemoryV2ConfigSnapshot;
 }
@@ -126,7 +170,7 @@ export function getMemoryV2ActivationLogByMessageIds(
   return {
     conversationId: row.conversationId,
     turn: row.turn,
-    mode: row.mode as "context-load" | "per-turn",
+    mode: row.mode as "context-load" | "per-turn" | "errored" | "router",
     concepts: JSON.parse(row.conceptsJson) as MemoryV2ConceptRowRecord[],
     config: JSON.parse(row.configJson) as MemoryV2ConfigSnapshot,
   };

package/src/memory/memory-v2-concept-frequency.ts

@@ -52,6 +52,7 @@ const ZERO_COUNTS: ConceptFrequencyCounts = {
   in_context: 0,
   not_injected: 0,
   page_missing: 0,
+  corrupt: 0,
 };
 
 interface CountRow {
@@ -130,6 +131,9 @@ export async function getConceptFrequencySummary(
       case "page_missing":
         entry.counts.page_missing += row.count;
         break;
+      case "corrupt":
+        entry.counts.corrupt += row.count;
+        break;
       default:
         // Forward-compat: unknown status values are ignored, not summed into
         // totalEvaluations. The activation pipeline produces a closed enum.

package/src/memory/message-content.ts

@@ -121,7 +121,6 @@ export function extractMediaBlockMeta(
   }
 }
 
-
 function stableJson(value: unknown): string {
   try {
     return JSON.stringify(value);
@@ -129,3 +128,41 @@ function stableJson(value: unknown): string {
     return "<unserializable />";
   }
 }
+
+/**
+ * Coerce stored message content into a single human-readable text string,
+ * dropping non-text blocks (images, tool calls, tool results, thinking,
+ * …). Used by call sites that want only the spoken text — sweep-model
+ * context, RAG backfill, bookmark previews. For richer renderings that
+ * include tool metadata, use {@link extractTextFromStoredMessageContent}
+ * instead.
+ *
+ * Handles the two on-disk shapes:
+ *   - Modern rows: JSON-serialized `ContentBlock[]`
+ *   - Legacy rows: plain string
+ *
+ * Parse failures fall back to returning the raw input trimmed (the
+ * legacy-string path).
+ */
+export function stringifyMessageContent(stored: string): string {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(stored);
+  } catch {
+    return stored.trim();
+  }
+  if (typeof parsed === "string") return parsed.trim();
+  if (!Array.isArray(parsed)) return "";
+  const parts: string[] = [];
+  for (const block of parsed) {
+    if (
+      block &&
+      typeof block === "object" &&
+      (block as { type?: string }).type === "text" &&
+      typeof (block as { text?: unknown }).text === "string"
+    ) {
+      parts.push((block as { text: string }).text);
+    }
+  }
+  return parts.join("\n").trim();
+}

package/src/memory/migrations/227-add-conversation-inference-profile.ts

@@ -8,8 +8,13 @@ export function migrateAddConversationInferenceProfile(
   const columns = raw.query(`PRAGMA table_info(conversations)`).all() as Array<{
     name: string;
   }>;
+  // Skip if either the original camelCase column or the renamed snake_case
+  // column from migration 228 is already present. Without the snake_case
+  // check, this migration would re-add the camelCase column on every boot
+  // after 228 runs, leaving both columns permanently.
   const hasColumn = columns.some(
-    (column) => column.name === "inferenceProfile",
+    (column) =>
+      column.name === "inferenceProfile" || column.name === "inference_profile",
   );
   if (hasColumn) {
     return;

package/src/memory/migrations/228-rename-inference-profile-snake-case.ts

@@ -6,19 +6,32 @@ import { tableHasColumn } from "./schema-introspection.js";
  * by migration 227) to `inference_profile` so it matches the snake_case
  * convention used by every other column on the table.
  *
- * Idempotent:
- * - camelCase column present, snake_case absent → renames it.
- * - snake_case column already present → no-op.
- * - neither column present → no-op (shouldn't happen since 227 ran first,
- *   but we guard for completeness).
+ * Idempotent and self-healing:
+ * - both columns present → drop the camelCase one (heals instances that
+ *   already booted twice with the original buggy migration 227, where 227
+ *   re-added the camelCase column after this migration renamed it).
+ * - camelCase column present, snake_case absent → rename it.
+ * - snake_case column present, camelCase absent → no-op.
+ * - neither column present → no-op.
  */
 export function migrateRenameInferenceProfileSnakeCase(
   database: DrizzleDb,
 ): void {
-  if (tableHasColumn(database, "conversations", "inference_profile")) {
+  const hasSnake = tableHasColumn(
+    database,
+    "conversations",
+    "inference_profile",
+  );
+  const hasCamel = tableHasColumn(
+    database,
+    "conversations",
+    "inferenceProfile",
+  );
+  if (hasSnake && hasCamel) {
+    database.run(`ALTER TABLE conversations DROP COLUMN inferenceProfile`);
     return;
   }
-  if (!tableHasColumn(database, "conversations", "inferenceProfile")) {
+  if (!hasCamel) {
     return;
   }
   database.run(

package/src/memory/migrations/229-delete-private-conversations.test.ts

@@ -615,7 +615,8 @@ function seedGuardianAndApprovalRows(raw: Database, now: number): void {
       created_at,
       updated_at
     ) VALUES
-      ('call-standard-guardian', 'conv-standard', 'test-provider', '+15550100', '+15550101', 'initiated', ${now}, ${now});
+      ('call-standard-guardian', 'conv-standard', 'test-provider', '+15550100', '+15550101', 'initiated', ${now}, ${now}),
+      ('call-private-guardian', 'conv-private', 'test-provider', '+15550102', '+15550103', 'initiated', ${now}, ${now});
 
     INSERT INTO call_pending_questions (
       id,
@@ -708,6 +709,23 @@ function seedGuardianAndApprovalRows(raw: Database, now: number): void {
       ('scoped-grant-standard', 'request_id', 'canonical-request-standard', NULL, NULL, 'vellum', 'vellum', 'conv-standard', 'active', ${now + 60000}, ${now}, ${now}),
       ('scoped-grant-unscoped', 'tool_signature', NULL, 'test_tool', 'digest-123', 'vellum', 'vellum', NULL, 'active', ${now + 60000}, ${now}, ${now});
 
+    INSERT INTO scoped_approval_grants (
+      id,
+      scope_mode,
+      request_id,
+      tool_name,
+      input_digest,
+      request_channel,
+      decision_channel,
+      conversation_id,
+      call_session_id,
+      status,
+      expires_at,
+      created_at,
+      updated_at
+    ) VALUES
+      ('scoped-grant-private-call-only', 'tool_signature', NULL, 'test_tool', 'digest-456', 'vellum', 'vellum', NULL, 'call-private-guardian', 'active', ${now + 60000}, ${now}, ${now});
+
     INSERT INTO channel_guardian_approval_requests (
       id,
       run_id,
@@ -1034,6 +1052,13 @@ describe("migrateDeletePrivateConversations", () => {
     expect(
       countWhere(raw, "scoped_approval_grants", `id = 'scoped-grant-unscoped'`),
     ).toBe(1);
+    expect(
+      countWhere(
+        raw,
+        "scoped_approval_grants",
+        `id = 'scoped-grant-private-call-only'`,
+      ),
+    ).toBe(0);
     expect(
       countWhere(
         raw,
@@ -1084,4 +1109,48 @@ describe("migrateDeletePrivateConversations", () => {
       ),
     ).toBe(1);
   });
+
+  test("removes orphan attachments left by prior runs that deleted private messages", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    const now = Date.now();
+
+    bootstrapTables(raw);
+    seedConversation(raw, "conv-standard", "standard");
+    raw.exec(/*sql*/ `
+      INSERT INTO attachments (
+        id,
+        original_filename,
+        mime_type,
+        size_bytes,
+        kind,
+        data_base64,
+        created_at
+      ) VALUES (
+        'orphan-private-attachment',
+        'leaked.txt',
+        'text/plain',
+        1,
+        'text',
+        'eA==',
+        ${now}
+      );
+    `);
+
+    expect(
+      countWhere(raw, "attachments", `id = 'orphan-private-attachment'`),
+    ).toBe(1);
+    expect(
+      countWhere(raw, "attachments", `id = 'conv-standard-attachment'`),
+    ).toBe(1);
+
+    migrateDeletePrivateConversations(db);
+
+    expect(
+      countWhere(raw, "attachments", `id = 'orphan-private-attachment'`),
+    ).toBe(0);
+    expect(
+      countWhere(raw, "attachments", `id = 'conv-standard-attachment'`),
+    ).toBe(1);
+  });
 });