@vellumai/assistant 0.5.16 → 0.6.1

package/src/__tests__/scheduler-reuse-conversation.test.ts

@@ -0,0 +1,368 @@
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+  truncateForLog: (value: string) => value,
+}));
+
+import { deleteConversation } from "../memory/conversation-crud.js";
+import { getDb, initializeDb } from "../memory/db.js";
+import { createSchedule, getScheduleRuns } from "../schedule/schedule-store.js";
+import { startScheduler } from "../schedule/scheduler.js";
+
+initializeDb();
+
+/** Access the underlying bun:sqlite Database for raw parameterized queries. */
+function getRawDb(): import("bun:sqlite").Database {
+  return (getDb() as unknown as { $client: import("bun:sqlite").Database })
+    .$client;
+}
+
+/** Force a schedule to be due by setting next_run_at in the past. */
+function forceScheduleDue(scheduleId: string): void {
+  getRawDb().run("UPDATE cron_jobs SET next_run_at = ? WHERE id = ?", [
+    Date.now() - 1000,
+    scheduleId,
+  ]);
+}
+
+// Build an RRULE expression anchored at the given start date, recurring every minute.
+function buildEveryMinuteRrule(dtstart: Date = new Date()): string {
+  const pad = (n: number) => String(n).padStart(2, "0");
+  const ds = `${dtstart.getUTCFullYear()}${pad(dtstart.getUTCMonth() + 1)}${pad(
+    dtstart.getUTCDate(),
+  )}T${pad(dtstart.getUTCHours())}${pad(dtstart.getUTCMinutes())}${pad(
+    dtstart.getUTCSeconds(),
+  )}Z`;
+  return `DTSTART:${ds}\nRRULE:FREQ=MINUTELY;INTERVAL=1`;
+}
+
+// Replace setTimeout with a zero-delay version so the 500ms scheduler
+// wait calls fire instantly instead of waiting real time.
+let origSetTimeout: typeof globalThis.setTimeout;
+
+describe("scheduler conversation reuse", () => {
+  beforeAll(() => {
+    origSetTimeout = globalThis.setTimeout;
+    globalThis.setTimeout = ((
+      fn: TimerHandler,
+      _ms?: number,
+      ...args: unknown[]
+    ) => {
+      return origSetTimeout(fn, 200, ...args);
+    }) as typeof setTimeout;
+  });
+
+  afterAll(() => {
+    globalThis.setTimeout = origSetTimeout;
+  });
+
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+    db.run("DELETE FROM task_runs");
+    db.run("DELETE FROM tasks");
+    db.run("DELETE FROM messages");
+    db.run("DELETE FROM conversations");
+  });
+
+  test("recurring schedule with reuseConversation=true reuses conversation across runs", async () => {
+    /**
+     * When a recurring schedule has reuseConversation enabled, the second run
+     * should reuse the conversation created by the first run.
+     */
+
+    // GIVEN a recurring schedule with reuseConversation enabled
+    const rruleExpr = buildEveryMinuteRrule();
+    const schedule = createSchedule({
+      name: "Reuse Test",
+      cronExpression: rruleExpr,
+      message: "Reuse conversation message",
+      syntax: "rrule",
+      expression: rruleExpr,
+      reuseConversation: true,
+    });
+
+    // WHEN the schedule fires for the first time
+    forceScheduleDue(schedule.id);
+
+    const processedMessages: { conversationId: string; message: string }[] = [];
+    const processMessage = async (conversationId: string, message: string) => {
+      processedMessages.push({ conversationId, message });
+    };
+
+    const scheduler1 = startScheduler(
+      processMessage,
+      () => {},
+      () => {},
+    );
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler1.stop();
+
+    // THEN a conversation is created and recorded
+    expect(processedMessages).toHaveLength(1);
+    const firstConversationId = processedMessages[0].conversationId;
+    expect(firstConversationId).toBeTruthy();
+
+    // AND a successful run is recorded
+    const runs1 = getScheduleRuns(schedule.id);
+    expect(runs1.length).toBe(1);
+    expect(runs1[0].status).toBe("ok");
+    expect(runs1[0].conversationId).toBe(firstConversationId);
+
+    // WHEN the schedule fires for the second time
+    forceScheduleDue(schedule.id);
+    processedMessages.length = 0;
+
+    const scheduler2 = startScheduler(
+      processMessage,
+      () => {},
+      () => {},
+    );
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler2.stop();
+
+    // THEN the same conversation is reused
+    expect(processedMessages).toHaveLength(1);
+    expect(processedMessages[0].conversationId).toBe(firstConversationId);
+
+    // AND the run references the reused conversation
+    const runs2 = getScheduleRuns(schedule.id);
+    expect(runs2.length).toBe(2);
+    expect(runs2[0].conversationId).toBe(firstConversationId);
+  });
+
+  test("recurring schedule with reuseConversation=false creates new conversation each run", async () => {
+    /**
+     * Default behavior: each run creates a brand-new conversation.
+     */
+
+    // GIVEN a recurring schedule with reuseConversation disabled (default)
+    const rruleExpr = buildEveryMinuteRrule();
+    const schedule = createSchedule({
+      name: "No Reuse Test",
+      cronExpression: rruleExpr,
+      message: "New conv each run",
+      syntax: "rrule",
+      expression: rruleExpr,
+      // reuseConversation defaults to false
+    });
+
+    // WHEN the schedule fires for the first time
+    forceScheduleDue(schedule.id);
+
+    const processedMessages: { conversationId: string; message: string }[] = [];
+    const processMessage = async (conversationId: string, message: string) => {
+      processedMessages.push({ conversationId, message });
+    };
+
+    const scheduler1 = startScheduler(
+      processMessage,
+      () => {},
+      () => {},
+    );
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler1.stop();
+
+    expect(processedMessages).toHaveLength(1);
+    const firstConversationId = processedMessages[0].conversationId;
+
+    // WHEN the schedule fires for the second time
+    forceScheduleDue(schedule.id);
+    processedMessages.length = 0;
+
+    const scheduler2 = startScheduler(
+      processMessage,
+      () => {},
+      () => {},
+    );
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler2.stop();
+
+    // THEN a different conversation is created
+    expect(processedMessages).toHaveLength(1);
+    expect(processedMessages[0].conversationId).not.toBe(firstConversationId);
+  });
+
+  test("reuseConversation creates a new conversation when prior one is deleted", async () => {
+    /**
+     * If the conversation from the last successful run has been deleted,
+     * a fresh conversation should be bootstrapped.
+     */
+
+    // GIVEN a recurring schedule with reuseConversation enabled that has already run once
+    const rruleExpr = buildEveryMinuteRrule();
+    const schedule = createSchedule({
+      name: "Deleted Conv Test",
+      cronExpression: rruleExpr,
+      message: "Handle deleted conv",
+      syntax: "rrule",
+      expression: rruleExpr,
+      reuseConversation: true,
+    });
+
+    forceScheduleDue(schedule.id);
+
+    const processedMessages: { conversationId: string; message: string }[] = [];
+    const processMessage = async (conversationId: string, message: string) => {
+      processedMessages.push({ conversationId, message });
+    };
+
+    const scheduler1 = startScheduler(
+      processMessage,
+      () => {},
+      () => {},
+    );
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler1.stop();
+
+    expect(processedMessages).toHaveLength(1);
+    const firstConversationId = processedMessages[0].conversationId;
+
+    // AND the conversation is deleted
+    deleteConversation(firstConversationId);
+
+    // WHEN the schedule fires again
+    forceScheduleDue(schedule.id);
+    processedMessages.length = 0;
+
+    const scheduler2 = startScheduler(
+      processMessage,
+      () => {},
+      () => {},
+    );
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler2.stop();
+
+    // THEN a new conversation is created (not the deleted one)
+    expect(processedMessages).toHaveLength(1);
+    expect(processedMessages[0].conversationId).not.toBe(firstConversationId);
+  });
+
+  test("one-shot schedule ignores reuseConversation flag", async () => {
+    /**
+     * One-shot schedules always create a new conversation regardless of the
+     * reuseConversation flag since they only fire once.
+     */
+
+    // GIVEN a one-shot schedule with reuseConversation enabled
+    const schedule = createSchedule({
+      name: "One-shot Reuse Ignored",
+      message: "One-shot with reuse flag",
+      mode: "execute",
+      nextRunAt: Date.now() - 1000,
+      reuseConversation: true,
+      // No expression = one-shot
+    });
+
+    // WHEN the schedule fires
+    const processedMessages: { conversationId: string; message: string }[] = [];
+    const processMessage = async (conversationId: string, message: string) => {
+      processedMessages.push({ conversationId, message });
+    };
+
+    const scheduler = startScheduler(
+      processMessage,
+      () => {},
+      () => {},
+    );
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler.stop();
+
+    // THEN the message is processed with a new conversation
+    expect(processedMessages).toHaveLength(1);
+    expect(processedMessages[0].conversationId).toBeTruthy();
+
+    // AND the schedule is marked as fired
+    const runs = getScheduleRuns(schedule.id);
+    expect(runs.length).toBeGreaterThanOrEqual(1);
+    expect(runs[0].status).toBe("ok");
+  });
+
+  test("reuseConversation uses the conversation from the most recent successful run", async () => {
+    /**
+     * When multiple runs exist, reuseConversation should pick the conversation
+     * from the most recent successful run (not a failed one).
+     */
+
+    // GIVEN a recurring schedule with reuseConversation enabled
+    const rruleExpr = buildEveryMinuteRrule();
+    const schedule = createSchedule({
+      name: "Most Recent Success Test",
+      cronExpression: rruleExpr,
+      message: "Pick latest success",
+      syntax: "rrule",
+      expression: rruleExpr,
+      reuseConversation: true,
+    });
+
+    // AND a first successful run
+    forceScheduleDue(schedule.id);
+
+    let shouldFail = false;
+    const processedMessages: { conversationId: string; message: string }[] = [];
+    const processMessage = async (conversationId: string, message: string) => {
+      processedMessages.push({ conversationId, message });
+      if (shouldFail) throw new Error("Simulated failure");
+    };
+
+    const scheduler1 = startScheduler(
+      processMessage,
+      () => {},
+      () => {},
+    );
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler1.stop();
+
+    expect(processedMessages).toHaveLength(1);
+    const successConversationId = processedMessages[0].conversationId;
+
+    // AND a second run that fails
+    forceScheduleDue(schedule.id);
+    processedMessages.length = 0;
+    shouldFail = true;
+
+    const scheduler2 = startScheduler(
+      processMessage,
+      () => {},
+      () => {},
+    );
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler2.stop();
+
+    // The failed run created a different conversation (since it failed
+    // before the run could reuse — actually it does reuse the same one
+    // because the lookup happens before the error). Let's verify the next
+    // successful run still uses the original successful conversation.
+
+    // AND a third run that succeeds
+    forceScheduleDue(schedule.id);
+    processedMessages.length = 0;
+    shouldFail = false;
+
+    const scheduler3 = startScheduler(
+      processMessage,
+      () => {},
+      () => {},
+    );
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler3.stop();
+
+    // THEN the third run reuses the conversation from the first successful run
+    // (the lookup queries for status="ok", so it picks the first run's conversation)
+    expect(processedMessages).toHaveLength(1);
+    expect(processedMessages[0].conversationId).toBe(successConversationId);
+  });
+});

package/src/__tests__/scoped-approval-grants.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -8,7 +8,7 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (value: string) => value,
 }));
 
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import { scopedApprovalGrants } from "../memory/schema.js";
 import {
   _internal,
@@ -34,10 +34,6 @@ function clearTables(): void {
   db.delete(scopedApprovalGrants).run();
 }
 
-afterAll(() => {
-  resetDb();
-});
-
 // ---------------------------------------------------------------------------
 // Helper to build grant params with sensible defaults
 // ---------------------------------------------------------------------------

package/src/__tests__/scoped-grant-security-matrix.test.ts

@@ -23,7 +23,7 @@
  *  11. Guardian identity mismatch cannot mint grant — guardian-grant-minting.test.ts
  */
 
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -33,7 +33,7 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (value: string) => value,
 }));
 
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import { scopedApprovalGrants } from "../memory/schema.js";
 import {
   _internal,
@@ -51,10 +51,6 @@ function clearTables(): void {
   db.delete(scopedApprovalGrants).run();
 }
 
-afterAll(() => {
-  resetDb();
-});
-
 // ---------------------------------------------------------------------------
 // Helper to build grant params with sensible defaults
 // ---------------------------------------------------------------------------

package/src/__tests__/scrub-corrupted-image-attachments.test.ts

@@ -0,0 +1,278 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { migrateScrubCorruptedImageAttachments } from "../memory/migrations/206-scrub-corrupted-image-attachments.js";
+import * as schema from "../memory/schema.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = OFF");
+  return drizzle(sqlite, { schema });
+}
+
+type TestDb = ReturnType<typeof createTestDb>;
+
+function getRawSqlite(db: TestDb): Database {
+  return (db as unknown as { $client: Database }).$client;
+}
+
+function createRequiredTables(raw: Database) {
+  raw.exec(/*sql*/ `
+    CREATE TABLE memory_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE TABLE attachments (
+      id TEXT PRIMARY KEY,
+      original_filename TEXT NOT NULL,
+      mime_type TEXT NOT NULL,
+      size_bytes INTEGER NOT NULL,
+      kind TEXT NOT NULL,
+      data_base64 TEXT NOT NULL DEFAULT '',
+      content_hash TEXT,
+      thumbnail_base64 TEXT,
+      file_path TEXT,
+      created_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE TABLE message_attachments (
+      id TEXT PRIMARY KEY,
+      message_id TEXT NOT NULL,
+      attachment_id TEXT NOT NULL,
+      position INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL
+    )
+  `);
+}
+
+// A minimal valid PNG header (8 bytes)
+const VALID_PNG_BASE64 = Buffer.from(
+  Uint8Array.from([137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 0]),
+).toString("base64");
+
+// HTML error page encoded as base64 (simulating Slack CDN auth failure)
+const HTML_ERROR_BASE64 = Buffer.from(
+  "<!DOCTYPE html><html><head><title>Sign in</title></head><body>Please sign in</body></html>",
+).toString("base64");
+
+// HTML with leading whitespace/BOM
+const HTML_WITH_BOM_BASE64 = Buffer.from(
+  "\uFEFF  <!DOCTYPE html><html><body>Error</body></html>",
+).toString("base64");
+
+const HTML_UPPERCASE_BASE64 = Buffer.from(
+  "<HTML><BODY>Error page</BODY></HTML>",
+).toString("base64");
+
+describe("migrateScrubCorruptedImageAttachments", () => {
+  test("removes corrupted image attachment with HTML data_base64", () => {
+    const db = createTestDb();
+    const raw = getRawSqlite(db);
+    const now = Date.now();
+
+    createRequiredTables(raw);
+
+    // Insert corrupted attachment (HTML stored as image/png)
+    raw.exec(/*sql*/ `
+      INSERT INTO attachments (id, original_filename, mime_type, size_bytes, kind, data_base64, created_at)
+      VALUES ('corrupt-1', 'image.png', 'image/png', 100, 'image', '${HTML_ERROR_BASE64}', ${now})
+    `);
+
+    // Insert message_attachments link
+    raw.exec(/*sql*/ `
+      INSERT INTO message_attachments (id, message_id, attachment_id, position, created_at)
+      VALUES ('ma-1', 'msg-1', 'corrupt-1', 0, ${now})
+    `);
+
+    migrateScrubCorruptedImageAttachments(db);
+
+    const attachmentCount = raw
+      .query(`SELECT COUNT(*) AS count FROM attachments`)
+      .get() as { count: number };
+    expect(attachmentCount.count).toBe(0);
+
+    const linkCount = raw
+      .query(`SELECT COUNT(*) AS count FROM message_attachments`)
+      .get() as { count: number };
+    expect(linkCount.count).toBe(0);
+  });
+
+  test("does NOT remove valid PNG attachment", () => {
+    const db = createTestDb();
+    const raw = getRawSqlite(db);
+    const now = Date.now();
+
+    createRequiredTables(raw);
+
+    // Insert valid PNG attachment
+    raw.exec(/*sql*/ `
+      INSERT INTO attachments (id, original_filename, mime_type, size_bytes, kind, data_base64, created_at)
+      VALUES ('valid-1', 'photo.png', 'image/png', 200, 'image', '${VALID_PNG_BASE64}', ${now})
+    `);
+
+    raw.exec(/*sql*/ `
+      INSERT INTO message_attachments (id, message_id, attachment_id, position, created_at)
+      VALUES ('ma-valid', 'msg-2', 'valid-1', 0, ${now})
+    `);
+
+    migrateScrubCorruptedImageAttachments(db);
+
+    const attachmentCount = raw
+      .query(`SELECT COUNT(*) AS count FROM attachments`)
+      .get() as { count: number };
+    expect(attachmentCount.count).toBe(1);
+
+    const linkCount = raw
+      .query(`SELECT COUNT(*) AS count FROM message_attachments`)
+      .get() as { count: number };
+    expect(linkCount.count).toBe(1);
+  });
+
+  test("removes corrupted and preserves valid attachments together", () => {
+    const db = createTestDb();
+    const raw = getRawSqlite(db);
+    const now = Date.now();
+
+    createRequiredTables(raw);
+
+    // Corrupted attachment
+    raw.exec(/*sql*/ `
+      INSERT INTO attachments (id, original_filename, mime_type, size_bytes, kind, data_base64, created_at)
+      VALUES ('corrupt-1', 'slack-img.png', 'image/png', 100, 'image', '${HTML_ERROR_BASE64}', ${now})
+    `);
+    raw.exec(/*sql*/ `
+      INSERT INTO message_attachments (id, message_id, attachment_id, position, created_at)
+      VALUES ('ma-corrupt', 'msg-1', 'corrupt-1', 0, ${now})
+    `);
+
+    // Valid attachment
+    raw.exec(/*sql*/ `
+      INSERT INTO attachments (id, original_filename, mime_type, size_bytes, kind, data_base64, created_at)
+      VALUES ('valid-1', 'photo.png', 'image/png', 200, 'image', '${VALID_PNG_BASE64}', ${now})
+    `);
+    raw.exec(/*sql*/ `
+      INSERT INTO message_attachments (id, message_id, attachment_id, position, created_at)
+      VALUES ('ma-valid', 'msg-2', 'valid-1', 0, ${now})
+    `);
+
+    migrateScrubCorruptedImageAttachments(db);
+
+    const remaining = raw.query(`SELECT id FROM attachments`).all() as Array<{
+      id: string;
+    }>;
+    expect(remaining).toEqual([{ id: "valid-1" }]);
+
+    const links = raw
+      .query(`SELECT attachment_id FROM message_attachments`)
+      .all() as Array<{ attachment_id: string }>;
+    expect(links).toEqual([{ attachment_id: "valid-1" }]);
+  });
+
+  test("detects HTML with leading BOM and whitespace", () => {
+    const db = createTestDb();
+    const raw = getRawSqlite(db);
+    const now = Date.now();
+
+    createRequiredTables(raw);
+
+    raw.exec(/*sql*/ `
+      INSERT INTO attachments (id, original_filename, mime_type, size_bytes, kind, data_base64, created_at)
+      VALUES ('bom-1', 'img.jpg', 'image/jpeg', 50, 'image', '${HTML_WITH_BOM_BASE64}', ${now})
+    `);
+
+    migrateScrubCorruptedImageAttachments(db);
+
+    const count = raw
+      .query(`SELECT COUNT(*) AS count FROM attachments`)
+      .get() as { count: number };
+    expect(count.count).toBe(0);
+  });
+
+  test("detects uppercase <HTML> tag", () => {
+    const db = createTestDb();
+    const raw = getRawSqlite(db);
+    const now = Date.now();
+
+    createRequiredTables(raw);
+
+    raw.exec(/*sql*/ `
+      INSERT INTO attachments (id, original_filename, mime_type, size_bytes, kind, data_base64, created_at)
+      VALUES ('upper-1', 'img.gif', 'image/gif', 50, 'image', '${HTML_UPPERCASE_BASE64}', ${now})
+    `);
+
+    migrateScrubCorruptedImageAttachments(db);
+
+    const count = raw
+      .query(`SELECT COUNT(*) AS count FROM attachments`)
+      .get() as { count: number };
+    expect(count.count).toBe(0);
+  });
+
+  test("is idempotent — running twice does not error", () => {
+    const db = createTestDb();
+    const raw = getRawSqlite(db);
+    const now = Date.now();
+
+    createRequiredTables(raw);
+
+    raw.exec(/*sql*/ `
+      INSERT INTO attachments (id, original_filename, mime_type, size_bytes, kind, data_base64, created_at)
+      VALUES ('corrupt-1', 'image.png', 'image/png', 100, 'image', '${HTML_ERROR_BASE64}', ${now})
+    `);
+    raw.exec(/*sql*/ `
+      INSERT INTO message_attachments (id, message_id, attachment_id, position, created_at)
+      VALUES ('ma-1', 'msg-1', 'corrupt-1', 0, ${now})
+    `);
+
+    migrateScrubCorruptedImageAttachments(db);
+    migrateScrubCorruptedImageAttachments(db);
+
+    const attachmentCount = raw
+      .query(`SELECT COUNT(*) AS count FROM attachments`)
+      .get() as { count: number };
+    expect(attachmentCount.count).toBe(0);
+
+    const linkCount = raw
+      .query(`SELECT COUNT(*) AS count FROM message_attachments`)
+      .get() as { count: number };
+    expect(linkCount.count).toBe(0);
+
+    // The checkpoint should be set to '1' (completed)
+    const checkpoint = raw
+      .query(
+        `SELECT value FROM memory_checkpoints WHERE key = 'migration_scrub_corrupted_image_attachments_v1'`,
+      )
+      .get() as { value: string } | null;
+    expect(checkpoint?.value).toBe("1");
+  });
+
+  test("skips non-image MIME types", () => {
+    const db = createTestDb();
+    const raw = getRawSqlite(db);
+    const now = Date.now();
+
+    createRequiredTables(raw);
+
+    // HTML content with text/html MIME type — should NOT be touched
+    raw.exec(/*sql*/ `
+      INSERT INTO attachments (id, original_filename, mime_type, size_bytes, kind, data_base64, created_at)
+      VALUES ('html-1', 'page.html', 'text/html', 100, 'document', '${HTML_ERROR_BASE64}', ${now})
+    `);
+
+    migrateScrubCorruptedImageAttachments(db);
+
+    const count = raw
+      .query(`SELECT COUNT(*) AS count FROM attachments`)
+      .get() as { count: number };
+    expect(count.count).toBe(1);
+  });
+});