@vellumai/assistant 0.10.4-dev.202607020106.aa66e63 → 0.10.4-dev.202607020525.d9ced46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.4-dev.202607020106.aa66e63",
+  "version": "0.10.4-dev.202607020525.d9ced46",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/attachments-store-heic-normalize.test.ts

@@ -0,0 +1,230 @@
+/**
+ * Wiring tests for HEIF/HEIC storage normalization: user-sourced ingress
+ * paths store a JPEG master (rewritten filename, mime, size, bytes) while
+ * register and assistant-outbound paths keep content verbatim.
+ *
+ * The converter module is mocked (keyed on the declared mime type) so these
+ * tests run identically with and without macOS sips; real conversion is
+ * covered in image-conversion.test.ts. mock.module is process-global — keep
+ * these cases in this file.
+ */
+
+import { beforeAll, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  loadConfig: () => ({}),
+  getConfig: () => ({}),
+  invalidateConfigCache: () => {},
+}));
+
+mock.module("../config/env.js", () => ({
+  isHttpAuthDisabled: () => true,
+  getAssistantDomain: () => "vellum.me",
+}));
+
+const FAKE_JPEG = Buffer.from("fake-jpeg-master-bytes");
+const FAKE_JPEG_B64 = FAKE_JPEG.toString("base64");
+
+mock.module("../util/image-conversion.js", () => ({
+  convertImageToJpeg: () => FAKE_JPEG,
+  isHeifImage: (bytes: Uint8Array) => bytes.length >= 12,
+  jpegFilenameFor: (filename: string) =>
+    `${filename.replace(/\.[^./\\]+$/, "")}.jpg`,
+  normalizeImageBytes: (mimeType: string, bytes: Uint8Array) =>
+    mimeType === "image/heic"
+      ? { mimeType: "image/jpeg", bytes: FAKE_JPEG, converted: true }
+      : { mimeType, bytes, converted: false },
+  normalizeImageBase64: (mimeType: string, dataBase64: string) =>
+    mimeType === "image/heic"
+      ? { mimeType: "image/jpeg", dataBase64: FAKE_JPEG_B64, converted: true }
+      : { mimeType, dataBase64, converted: false },
+}));
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  attachInlineAttachmentToMessage,
+  getAttachmentById,
+  getFilePathForAttachment,
+  uploadAttachment,
+  uploadAttachmentFromBytes,
+} from "../persistence/attachments-store.js";
+import {
+  addMessage,
+  createConversation,
+} from "../persistence/conversation-crud.js";
+import { initializeDb } from "../persistence/db-init.js";
+import {
+  attachmentMetadataSchema,
+  ROUTES,
+} from "../runtime/routes/attachment-routes.js";
+import type { RouteHandlerArgs } from "../runtime/routes/types.js";
+import { getWorkspaceDir } from "../util/platform.js";
+import { fakeHeifHeaderBytes } from "./heic-fixture.js";
+
+const uploadRoute = ROUTES.find((r) => r.operationId === "attachment_upload")!;
+const registerRoute = ROUTES.find(
+  (r) => r.operationId === "attachment_register",
+)!;
+
+const HEIC_BYTES = fakeHeifHeaderBytes();
+const HEIC_B64 = HEIC_BYTES.toString("base64");
+
+function jsonUploadArgs(body: Record<string, unknown>): RouteHandlerArgs {
+  return {
+    body,
+    rawBody: new TextEncoder().encode(JSON.stringify(body)),
+    headers: { "content-type": "application/json" },
+    queryParams: {},
+  };
+}
+
+describe("HEIC upload normalization wiring", () => {
+  beforeAll(async () => {
+    await initializeDb();
+  }, 30_000);
+
+  test("uploadAttachmentFromBytes stores a JPEG master for HEIC", () => {
+    const stored = uploadAttachmentFromBytes(
+      "IMG_5487.HEIC",
+      "image/heic",
+      HEIC_BYTES,
+    );
+
+    expect(stored.originalFilename).toBe("IMG_5487.jpg");
+    expect(stored.mimeType).toBe("image/jpeg");
+    expect(stored.sizeBytes).toBe(FAKE_JPEG.length);
+    const stagedPath = getFilePathForAttachment(stored.id);
+    expect(stagedPath).not.toBeNull();
+    expect(readFileSync(stagedPath!).equals(FAKE_JPEG)).toBe(true);
+  });
+
+  test("uploadAttachmentFromBytes leaves non-HEIC uploads verbatim", () => {
+    const stored = uploadAttachmentFromBytes(
+      "photo.png",
+      "image/png",
+      HEIC_BYTES,
+    );
+
+    expect(stored.originalFilename).toBe("photo.png");
+    expect(stored.mimeType).toBe("image/png");
+    expect(stored.sizeBytes).toBe(HEIC_BYTES.length);
+  });
+
+  test("uploadAttachment (base64) stores a JPEG master for HEIC", () => {
+    const stored = uploadAttachment("IMG_1.heic", "image/heic", HEIC_B64);
+
+    expect(stored.originalFilename).toBe("IMG_1.jpg");
+    expect(stored.mimeType).toBe("image/jpeg");
+    expect(stored.sizeBytes).toBe(FAKE_JPEG.length);
+    const row = getAttachmentById(stored.id);
+    expect(row?.dataBase64).toBe(FAKE_JPEG_B64);
+  });
+
+  test("uploadAttachment (base64) leaves non-HEIC uploads verbatim", () => {
+    const stored = uploadAttachment("photo.png", "image/png", HEIC_B64);
+
+    expect(stored.originalFilename).toBe("photo.png");
+    expect(stored.mimeType).toBe("image/png");
+    expect(stored.sizeBytes).toBe(HEIC_BYTES.length);
+  });
+
+  test("attachInlineAttachmentToMessage normalizes only when opted in", async () => {
+    const conv = createConversation();
+    const msg = await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "photos" }]),
+    );
+
+    const normalized = attachInlineAttachmentToMessage(
+      msg.id,
+      0,
+      "IMG_2.HEIC",
+      "image/heic",
+      HEIC_B64,
+      { normalizeImage: true },
+    );
+    expect(normalized.originalFilename).toBe("IMG_2.jpg");
+    expect(normalized.mimeType).toBe("image/jpeg");
+
+    // Assistant-outbound attachments are stored verbatim: no normalizeImage
+    // flag, no rewrite, even for HEIC content.
+    const verbatim = attachInlineAttachmentToMessage(
+      msg.id,
+      1,
+      "IMG_3.HEIC",
+      "image/heic",
+      HEIC_B64,
+    );
+    expect(verbatim.originalFilename).toBe("IMG_3.HEIC");
+    expect(verbatim.mimeType).toBe("image/heic");
+    expect(verbatim.sizeBytes).toBe(HEIC_BYTES.length);
+  });
+
+  test("JSON file-path upload converts the daemon-owned copy", async () => {
+    const sourceDir = mkdtempSync(join(tmpdir(), "vellum-heic-src-"));
+    const sourcePath = join(sourceDir, "IMG_4.HEIC");
+    writeFileSync(sourcePath, HEIC_BYTES);
+
+    const raw = await uploadRoute.handler(
+      jsonUploadArgs({
+        filename: "IMG_4.HEIC",
+        mimeType: "image/heic",
+        filePath: sourcePath,
+      }),
+    );
+    const result = attachmentMetadataSchema.parse(raw);
+
+    expect(result.filename).toBe("IMG_4.jpg");
+    expect(result.mimeType).toBe("image/jpeg");
+    expect(result.sizeBytes).toBe(FAKE_JPEG.length);
+    // The caller's source file is never mutated.
+    expect(readFileSync(sourcePath).equals(HEIC_BYTES)).toBe(true);
+    // The staged raw copy is replaced by the converted one.
+    const stagedPath = getFilePathForAttachment(result.id);
+    expect(stagedPath).not.toBeNull();
+    expect(stagedPath!.endsWith(".jpg")).toBe(true);
+    expect(readFileSync(stagedPath!).equals(FAKE_JPEG)).toBe(true);
+  });
+
+  test("attachment register keeps workspace files verbatim", async () => {
+    const registerDir = join(getWorkspaceDir(), "register-fixtures");
+    mkdirSync(registerDir, { recursive: true });
+    const registeredPath = join(registerDir, "IMG_5.HEIC");
+    writeFileSync(registeredPath, HEIC_BYTES);
+
+    const raw = await registerRoute.handler(
+      jsonUploadArgs({
+        path: registeredPath,
+        mimeType: "image/heic",
+        filename: "IMG_5.HEIC",
+      }),
+    );
+    const result = raw as {
+      originalFilename: string;
+      mimeType: string;
+    };
+
+    expect(result.originalFilename).toBe("IMG_5.HEIC");
+    expect(result.mimeType).toBe("image/heic");
+    // Registered files are referenced in place, never rewritten.
+    expect(existsSync(registeredPath)).toBe(true);
+    expect(readFileSync(registeredPath).equals(HEIC_BYTES)).toBe(true);
+  });
+});

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -195,6 +195,7 @@ mock.module("../persistence/jobs-store.js", () => ({
     automatic: "automatic",
     manual: "manual",
   },
+  MESSAGE_LEXICAL_JOB_TYPES: [],
   resetRunningJobsToPending: mock(() => 0),
   SLOW_LLM_JOB_TYPES: [],
   upsertAutoAnalysisJob: mock(() => "job-auto-analysis"),

package/src/__tests__/clear-all-lexical.test.ts

@@ -24,17 +24,14 @@ mock.module("../util/logger.js", () => ({
 // (`@qdrant/js-client-rest`, `uuid`, the local TF-IDF encoder) resolve in the
 // worktree.
 const actualLexical =
-  await import("../plugins/defaults/memory/job-handlers/index-message-lexical.js");
+  await import("../persistence/job-handlers/message-lexical.js");
 let clearCalls = 0;
-mock.module(
-  "../plugins/defaults/memory/job-handlers/index-message-lexical.js",
-  () => ({
-    ...actualLexical,
-    clearMessagesLexicalIndex: async () => {
-      clearCalls += 1;
-    },
-  }),
-);
+mock.module("../persistence/job-handlers/message-lexical.js", () => ({
+  ...actualLexical,
+  clearMessagesLexicalIndex: async () => {
+    clearCalls += 1;
+  },
+}));
 
 import { clearAll } from "../persistence/conversation-crud.js";
 import { initializeDb } from "../persistence/db-init.js";

package/src/__tests__/context-search-conversations-source.test.ts

@@ -35,22 +35,6 @@ mock.module("../persistence/conversation-search-lexical.js", () => ({
   },
 }));
 
-// Drives the real recall availability gate: when true the source yields no
-// evidence, because the lexical index write path is suppressed and the
-// collection is never populated. Defaults false so every other test exercises
-// the live path. Spread the real module so its other exports (job handlers,
-// enqueue helpers) stay intact for transitive importers.
-let suppressIndexing = false;
-const realLexicalModule =
-  await import("../plugins/defaults/memory/job-handlers/index-message-lexical.js");
-mock.module(
-  "../plugins/defaults/memory/job-handlers/index-message-lexical.js",
-  () => ({
-    ...realLexicalModule,
-    isMemoryIndexingSuppressed: () => suppressIndexing,
-  }),
-);
-
 import {
   deleteMemoryCheckpoint,
   LEXICAL_BACKFILL_COMPLETE_KEY,
@@ -70,15 +54,13 @@ describe("searchConversationSource (qdrant lexical index)", () => {
     getDb().run("DELETE FROM messages");
     getDb().run("DELETE FROM conversations");
     lexicalCalls = [];
-    suppressIndexing = false;
-    // Content evidence is available once the index is populated: not
-    // suppressed + backfill complete. Most tests exercise that path, so mark
-    // the backfill complete; the gates are covered by their own tests.
+    // Content evidence is available once the index is populated (backfill
+    // complete). Most tests exercise that path, so mark the backfill
+    // complete; the gate is covered by its own test.
     setMemoryCheckpoint(LEXICAL_BACKFILL_COMPLETE_KEY, "1");
   });
 
   afterEach(() => {
-    suppressIndexing = false;
     deleteMemoryCheckpoint(LEXICAL_BACKFILL_COMPLETE_KEY);
     lexicalMockImpl = () => {
       throw new Error(
@@ -143,29 +125,6 @@ describe("searchConversationSource (qdrant lexical index)", () => {
     expect(unicodeResult.evidence).toEqual([]);
   });
 
-  test("returns no evidence when memory indexing is suppressed", async () => {
-    await seedConversation({
-      title: "Suppressed indexing notes",
-      content: "The suppressedtoken decision is recorded here.",
-    });
-
-    // The lexical index is never populated while indexing is suppressed, so
-    // the source must yield no evidence without consulting Qdrant.
-    suppressIndexing = true;
-    lexicalMockImpl = async () => {
-      throw new Error("searchMessageIdsLexical must not run while suppressed");
-    };
-
-    const result = await searchConversationSource(
-      "suppressedtoken",
-      makeContext(),
-      5,
-    );
-
-    expect(lexicalCalls).toHaveLength(0);
-    expect(result.evidence).toEqual([]);
-  });
-
   test("returns no evidence until the backfill completion checkpoint is set", async () => {
     await seedConversation({
       title: "Pre-backfill notes",

package/src/__tests__/heic-fixture.ts

@@ -0,0 +1,55 @@
+/**
+ * HEIC fixture helpers for image-conversion tests.
+ *
+ * Real HEIC bytes can only be produced where `sips` exists (macOS), so
+ * consumers gate those tests with `describe.skipIf(process.platform !==
+ * "darwin")`. The fake-header helper works everywhere and exercises the
+ * conversion-failure fallback: the ftyp sniff accepts it, sips rejects it.
+ */
+
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const PNG_1PX_BASE64 =
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=";
+
+/**
+ * Create real HEIC bytes via macOS `sips` (1×1 PNG upscaled to 64×64, then
+ * HEIC-encoded). Returns null when sips is unavailable or fails.
+ */
+export function makeHeicFixtureBytes(): Buffer | null {
+  try {
+    const dir = mkdtempSync(join(tmpdir(), "vellum-heic-fixture-"));
+    const pngPath = join(dir, "src.png");
+    const bigPngPath = join(dir, "big.png");
+    const heicPath = join(dir, "out.heic");
+    writeFileSync(pngPath, Buffer.from(PNG_1PX_BASE64, "base64"));
+    execFileSync("sips", ["-z", "64", "64", pngPath, "--out", bigPngPath], {
+      stdio: "pipe",
+    });
+    execFileSync(
+      "sips",
+      ["-s", "format", "heic", bigPngPath, "--out", heicPath],
+      { stdio: "pipe" },
+    );
+    return readFileSync(heicPath) as Buffer;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * A syntactically valid HEIF ftyp header followed by nothing decodable.
+ * Sniffs as HEIF but fails conversion on every platform.
+ */
+export function fakeHeifHeaderBytes(brand = "heic"): Buffer {
+  const buf = Buffer.alloc(24);
+  buf.writeUInt32BE(24, 0);
+  buf.write("ftyp", 4, "ascii");
+  buf.write(brand, 8, "ascii");
+  return buf;
+}
+
+export const PNG_1PX_BYTES = Buffer.from(PNG_1PX_BASE64, "base64");

package/src/__tests__/image-conversion.test.ts

@@ -0,0 +1,170 @@
+/**
+ * Tests for the shared sips-backed image converter.
+ *
+ * Pure logic (ftyp sniffing, filename rewriting, passthrough behavior) runs
+ * everywhere; actual conversion requires macOS `sips`, so those cases are
+ * gated on darwin.
+ */
+
+import { beforeAll, describe, expect, test } from "bun:test";
+
+import {
+  convertImageToJpeg,
+  isHeifImage,
+  jpegFilenameFor,
+  normalizeImageBase64,
+  normalizeImageBytes,
+} from "../util/image-conversion.js";
+import {
+  fakeHeifHeaderBytes,
+  makeHeicFixtureBytes,
+  PNG_1PX_BYTES,
+} from "./heic-fixture.js";
+
+const JPEG_MAGIC = Buffer.from([0xff, 0xd8, 0xff]);
+
+function startsWithJpegMagic(bytes: Uint8Array): boolean {
+  return Buffer.from(bytes.slice(0, 3)).equals(JPEG_MAGIC);
+}
+
+describe("isHeifImage", () => {
+  test("accepts HEIF ftyp brands", () => {
+    for (const brand of ["heic", "heix", "heif", "mif1", "msf1", "hevc"]) {
+      expect(isHeifImage(fakeHeifHeaderBytes(brand))).toBe(true);
+    }
+  });
+
+  test("rejects AVIF brands (Chromium decodes AVIF natively)", () => {
+    expect(isHeifImage(fakeHeifHeaderBytes("avif"))).toBe(false);
+    expect(isHeifImage(fakeHeifHeaderBytes("avis"))).toBe(false);
+  });
+
+  test("rejects non-ISO-BMFF content", () => {
+    expect(isHeifImage(PNG_1PX_BYTES)).toBe(false);
+    expect(isHeifImage(Buffer.from("plain text content"))).toBe(false);
+  });
+
+  test("rejects buffers shorter than the sniff window", () => {
+    expect(isHeifImage(Buffer.alloc(0))).toBe(false);
+    expect(isHeifImage(Buffer.from("ftypheic"))).toBe(false);
+  });
+});
+
+describe("jpegFilenameFor", () => {
+  test("rewrites the extension to .jpg", () => {
+    expect(jpegFilenameFor("IMG_5487.HEIC")).toBe("IMG_5487.jpg");
+    expect(jpegFilenameFor("photo.heif")).toBe("photo.jpg");
+    expect(jpegFilenameFor("archive.tar.gz")).toBe("archive.tar.jpg");
+  });
+
+  test("keeps existing .jpg/.jpeg extensions", () => {
+    expect(jpegFilenameFor("photo.jpg")).toBe("photo.jpg");
+    expect(jpegFilenameFor("photo.JPEG")).toBe("photo.JPEG");
+  });
+
+  test("handles missing or empty names", () => {
+    expect(jpegFilenameFor("photo")).toBe("photo.jpg");
+    expect(jpegFilenameFor("")).toBe("attachment.jpg");
+    expect(jpegFilenameFor(".heic")).toBe("attachment.jpg");
+  });
+});
+
+describe("normalizeImageBytes passthrough", () => {
+  test("non-HEIF bytes pass through untouched", () => {
+    const result = normalizeImageBytes("image/png", PNG_1PX_BYTES);
+    expect(result.converted).toBe(false);
+    expect(result.mimeType).toBe("image/png");
+    expect(result.bytes).toBe(PNG_1PX_BYTES);
+  });
+
+  test("HEIF header with undecodable payload passes through", () => {
+    // sips fails (or is absent off-macOS) → the original bytes are kept.
+    const fake = fakeHeifHeaderBytes();
+    const result = normalizeImageBytes("image/heic", fake);
+    expect(result.converted).toBe(false);
+    expect(result.mimeType).toBe("image/heic");
+    expect(result.bytes).toBe(fake);
+  });
+});
+
+describe("normalizeImageBase64 passthrough", () => {
+  test("non-HEIF payloads skip conversion", () => {
+    const b64 = PNG_1PX_BYTES.toString("base64");
+    const result = normalizeImageBase64("image/png", b64);
+    expect(result.converted).toBe(false);
+    expect(result.dataBase64).toBe(b64);
+  });
+});
+
+describe.skipIf(process.platform !== "darwin")(
+  "real HEIC conversion (sips)",
+  () => {
+    let heicBytes: Buffer;
+
+    beforeAll(() => {
+      const fixture = makeHeicFixtureBytes();
+      if (!fixture) {
+        throw new Error("sips failed to produce a HEIC fixture on darwin");
+      }
+      heicBytes = fixture;
+    });
+
+    test("fixture sniffs as HEIF", () => {
+      expect(isHeifImage(heicBytes)).toBe(true);
+    });
+
+    test("convertImageToJpeg produces JPEG bytes", () => {
+      const converted = convertImageToJpeg(heicBytes);
+      expect(converted).not.toBeNull();
+      expect(startsWithJpegMagic(converted!)).toBe(true);
+    });
+
+    test("conversion options produce distinct outputs (cache key isolation)", () => {
+      // A hash-only cache key would make the second call return the first
+      // call's cached full-resolution output.
+      const fullRes = convertImageToJpeg(heicBytes, { quality: 90 });
+      const downscaled = convertImageToJpeg(heicBytes, {
+        maxDimensionPx: 16,
+        quality: 90,
+      });
+      expect(fullRes).not.toBeNull();
+      expect(downscaled).not.toBeNull();
+      expect(fullRes!.equals(downscaled!)).toBe(false);
+    });
+
+    test("repeated conversion is stable (cache round-trip)", () => {
+      const first = convertImageToJpeg(heicBytes, { quality: 90 });
+      const second = convertImageToJpeg(heicBytes, { quality: 90 });
+      expect(first).not.toBeNull();
+      expect(second).not.toBeNull();
+      expect(first!.equals(second!)).toBe(true);
+    });
+
+    test("normalizeImageBytes converts to a JPEG master", () => {
+      const result = normalizeImageBytes("image/heic", heicBytes);
+      expect(result.converted).toBe(true);
+      expect(result.mimeType).toBe("image/jpeg");
+      expect(startsWithJpegMagic(result.bytes)).toBe(true);
+    });
+
+    test("normalizeImageBytes converts even when the declared mime is wrong", () => {
+      // Chromium reports empty file.type for .heic; clients coerce it to
+      // application/octet-stream. Detection is content-based.
+      const result = normalizeImageBytes("application/octet-stream", heicBytes);
+      expect(result.converted).toBe(true);
+      expect(result.mimeType).toBe("image/jpeg");
+    });
+
+    test("normalizeImageBase64 converts and re-encodes", () => {
+      const result = normalizeImageBase64(
+        "image/heic",
+        heicBytes.toString("base64"),
+      );
+      expect(result.converted).toBe(true);
+      expect(result.mimeType).toBe("image/jpeg");
+      expect(
+        startsWithJpegMagic(Buffer.from(result.dataBase64, "base64")),
+      ).toBe(true);
+    });
+  },
+);

package/src/__tests__/job-handler-registry-guard.test.ts

@@ -43,21 +43,22 @@ const MEMORY_JOB_TYPES = [
   "memory_v2_activation_recompute",
   "memory_v3_maintain",
   "memory_retrospective",
-  "index_message_lexical",
-  "purge_conversation_lexical",
-  "delete_message_lexical",
-  "backfill_lexical_index",
 ].sort();
 
 /**
  * Job types wired directly by `registerMemoryJobHandlers` for domains that are
- * not plugins (persistence cleanup, conversations, media, home, runtime).
+ * not plugins (persistence cleanup, message-content lexical indexing,
+ * conversations, media, home, runtime).
  */
 const NON_PLUGIN_JOB_TYPES = [
   "prune_old_conversations",
   "prune_old_llm_request_logs",
   "prune_old_trace_events",
   "prune_old_tool_invocations",
+  "index_message_lexical",
+  "purge_conversation_lexical",
+  "delete_message_lexical",
+  "backfill_lexical_index",
   "build_conversation_summary",
   "media_processing",
   "conversation_analyze",

package/src/__tests__/lexical-index-dual-write.test.ts

@@ -1,9 +1,9 @@
-// Integration coverage for the messages lexical-index dual-write wiring:
-//   - a real persist (`addMessage` → `onMessagePersisted`) enqueues one
-//     `index_message_lexical` job for the message when memory is enabled, and
-//     none when memory is disabled;
+// Integration coverage for the messages lexical-index write wiring:
+//   - a real persist (`addMessage`) enqueues one `index_message_lexical` job
+//     for the message, regardless of whether memory is enabled or disabled
+//     (message-content search is host infrastructure);
 //   - forking a conversation copies message rows WITHOUT routing through
-//     `onMessagePersisted`, so a fork enqueues ZERO `index_message_lexical`
+//     the persist path, so a fork enqueues ZERO `index_message_lexical`
 //     jobs (the fork-exclusion regression);
 //   - wiping a conversation enqueues one `purge_conversation_lexical` job.
 //
@@ -31,7 +31,9 @@ let throwFromIndex = false;
 mock.module("../plugins/defaults/memory/indexer.js", () => ({
   MIN_SEGMENT_CHARS: 50,
   indexMessageNow: async () => {
-    if (throwFromIndex) throw new Error("simulated segment-indexing failure");
+    if (throwFromIndex) {
+      throw new Error("simulated segment-indexing failure");
+    }
     return { indexedSegments: 0, enqueuedJobs: 0 };
   },
   enqueueBackfillJob: () => "",
@@ -58,6 +60,7 @@ import {
 } from "../persistence/conversation-crud.js";
 import { getMemoryDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
+import { enqueueLexicalIndexForMessage } from "../persistence/job-handlers/message-lexical.js";
 import type { MemoryJobType } from "../persistence/jobs-store.js";
 import {
   getMemoryPersistenceHooks,
@@ -66,7 +69,6 @@ import {
 } from "../persistence/memory-lifecycle-hooks.js";
 import { memoryJobs } from "../persistence/schema/index.js";
 import { registerDefaultPluginPersistenceHooks } from "../plugins/defaults/index.js";
-import { enqueueLexicalIndexForMessage } from "../plugins/defaults/memory/job-handlers/index-message-lexical.js";
 
 await initializeDb();
 
@@ -76,7 +78,9 @@ function countJobs(type: MemoryJobType, conversationId?: string): number {
     .from(memoryJobs)
     .where(eq(memoryJobs.type, type))
     .all();
-  if (conversationId == null) return rows.length;
+  if (conversationId == null) {
+    return rows.length;
+  }
   return rows.filter((r) => {
     try {
       return (
@@ -157,12 +161,16 @@ describe("messages lexical-index dual-write", () => {
     expect(lexicalJobMessageIds()).toContain(message.id);
   });
 
-  test("addMessage enqueues NO index_message_lexical job when memory is disabled", async () => {
+  test("addMessage still enqueues an index_message_lexical job when memory is disabled", async () => {
     setMemoryEnabled(false);
     const conv = createConversation("Disabled memory thread");
-    await addMessage(conv.id, "user", "should not be lexically indexed");
+    const message = await addMessage(
+      conv.id,
+      "user",
+      "lexically indexed regardless of memory state",
+    );
 
-    expect(countJobs("index_message_lexical")).toBe(0);
+    expect(lexicalJobMessageIds()).toContain(message.id);
   });
 
   test("enqueueLexicalIndexForMessage no-ops on an empty message id", () => {