@vellumai/assistant 0.5.1 → 0.5.3

package/src/memory/migrations/181-rename-thread-starters-checkpoints.ts

@@ -0,0 +1,46 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * Rename checkpoint keys from the old `thread_starters:` prefix to
+ * `conversation_starters:` so that the renamed code paths in
+ * `conversation-starters-cadence.ts` and `conversation-starters.ts`
+ * find existing generation state and avoid unnecessary re-generation.
+ *
+ * This was originally appended to migration 174, but that migration
+ * had already shipped with its own checkpoint key
+ * (`migration_rename_thread_starters_table_v1`), so `withCrashRecovery`
+ * would skip the entire body for users who had already run it. Moving
+ * the checkpoint-key rewrite into its own migration with an independent
+ * checkpoint key ensures it runs for all users.
+ *
+ * The rename is collision-safe: if a database already has both old
+ * `thread_starters:*` keys and new `conversation_starters:*` keys
+ * (written by updated code after the table rename), we drop the stale
+ * old rows first to avoid UNIQUE constraint violations on the primary key.
+ */
+export function migrateRenameThreadStartersCheckpoints(
+  database: DrizzleDb,
+): void {
+  withCrashRecovery(
+    database,
+    "migration_rename_thread_starters_checkpoints_v1",
+    () => {
+      const raw = getSqliteFrom(database);
+
+      // 1. Delete old thread_starters: keys where a corresponding
+      //    conversation_starters: key already exists (the newer key
+      //    written by updated code takes precedence).
+      raw.exec(/*sql*/ `DELETE FROM memory_checkpoints
+         WHERE key LIKE 'thread_starters:%'
+           AND replace(key, 'thread_starters:', 'conversation_starters:') IN (
+             SELECT key FROM memory_checkpoints WHERE key LIKE 'conversation_starters:%'
+           )`);
+
+      // 2. Rename remaining old keys that have no collision.
+      raw.exec(
+        /*sql*/ `UPDATE memory_checkpoints SET key = replace(key, 'thread_starters:', 'conversation_starters:') WHERE key LIKE 'thread_starters:%'`,
+      );
+    },
+  );
+}

package/src/memory/migrations/182-oauth-providers-display-metadata.ts

@@ -0,0 +1,20 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateOAuthProvidersDisplayMetadata(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  const columns = [
+    "display_name TEXT",
+    "description TEXT",
+    "dashboard_url TEXT",
+    "client_id_placeholder TEXT",
+    "requires_client_secret INTEGER NOT NULL DEFAULT 1",
+  ];
+  for (const col of columns) {
+    try {
+      raw.exec(`ALTER TABLE oauth_providers ADD COLUMN ${col}`);
+    } catch {
+      // Column already exists — nothing to do.
+    }
+  }
+}

package/src/memory/migrations/183-add-conversation-fork-lineage.ts

@@ -0,0 +1,22 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateConversationForkLineage(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  const columns = [
+    "fork_parent_conversation_id TEXT",
+    "fork_parent_message_id TEXT",
+  ];
+
+  for (const column of columns) {
+    try {
+      raw.exec(`ALTER TABLE conversations ADD COLUMN ${column}`);
+    } catch {
+      // Column already exists — nothing to do.
+    }
+  }
+
+  raw.exec(
+    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_conversations_fork_parent_conversation_id ON conversations(fork_parent_conversation_id)`,
+  );
+}

package/src/memory/migrations/184-llm-request-log-provider.ts

@@ -0,0 +1,12 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateLlmRequestLogProvider(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  try {
+    raw.exec(/*sql*/ `ALTER TABLE llm_request_logs ADD COLUMN provider TEXT`);
+  } catch {
+    // Column already exists — nothing to do.
+  }
+}

package/src/memory/migrations/185-memory-brief-state.ts

@@ -0,0 +1,52 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Create the memory brief state tables: time_contexts and open_loops.
+ *
+ * Both tables use CREATE TABLE IF NOT EXISTS and CREATE INDEX IF NOT EXISTS,
+ * making this migration inherently idempotent — safe to re-run on every startup
+ * without a checkpoint guard.
+ */
+export function migrateMemoryBriefState(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  // -- time_contexts: bounded temporal windows for the brief --
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS time_contexts (
+      id TEXT PRIMARY KEY,
+      scope_id TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      source TEXT NOT NULL,
+      active_from INTEGER NOT NULL,
+      active_until INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_time_contexts_scope_active_until
+    ON time_contexts (scope_id, active_until)
+  `);
+
+  // -- open_loops: unresolved items the brief should surface --
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS open_loops (
+      id TEXT PRIMARY KEY,
+      scope_id TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'open',
+      source TEXT NOT NULL,
+      due_at INTEGER,
+      surfaced_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_open_loops_scope_status_due
+    ON open_loops (scope_id, status, due_at)
+  `);
+}

package/src/memory/migrations/186-memory-archive.ts

@@ -0,0 +1,109 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Create the memory archive tables (memory_observations, memory_chunks,
+ * memory_episodes) with prefetch indexes on scopeId, conversationId, and
+ * createdAt.
+ *
+ * All statements use IF NOT EXISTS / IF NOT EXISTS guards so the migration
+ * is safe to re-run on every startup.
+ */
+export function migrateMemoryArchiveTables(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  // -- memory_observations --------------------------------------------------
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_observations (
+      id TEXT PRIMARY KEY,
+      scope_id TEXT NOT NULL DEFAULT 'default',
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      message_id TEXT REFERENCES messages(id) ON DELETE SET NULL,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      modality TEXT NOT NULL DEFAULT 'text',
+      source TEXT,
+      created_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_observations_scope_id
+    ON memory_observations (scope_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_observations_conversation_id
+    ON memory_observations (conversation_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_observations_created_at
+    ON memory_observations (created_at)
+  `);
+
+  // -- memory_chunks --------------------------------------------------------
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_chunks (
+      id TEXT PRIMARY KEY,
+      scope_id TEXT NOT NULL DEFAULT 'default',
+      observation_id TEXT NOT NULL REFERENCES memory_observations(id) ON DELETE CASCADE,
+      content TEXT NOT NULL,
+      token_estimate INTEGER NOT NULL,
+      content_hash TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_chunks_scope_id
+    ON memory_chunks (scope_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_chunks_observation_id
+    ON memory_chunks (observation_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_memory_chunks_content_hash
+    ON memory_chunks (scope_id, content_hash)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_chunks_created_at
+    ON memory_chunks (created_at)
+  `);
+
+  // -- memory_episodes ------------------------------------------------------
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_episodes (
+      id TEXT PRIMARY KEY,
+      scope_id TEXT NOT NULL DEFAULT 'default',
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      title TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      token_estimate INTEGER NOT NULL,
+      source TEXT,
+      start_at INTEGER NOT NULL,
+      end_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_episodes_scope_id
+    ON memory_episodes (scope_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_episodes_conversation_id
+    ON memory_episodes (conversation_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_episodes_created_at
+    ON memory_episodes (created_at)
+  `);
+}

package/src/memory/migrations/187-memory-reducer-checkpoints.ts

@@ -0,0 +1,19 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateMemoryReducerCheckpoints(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  const columns = [
+    "memory_reduced_through_message_id TEXT",
+    "memory_dirty_tail_since_message_id TEXT",
+    "memory_last_reduced_at INTEGER",
+  ];
+
+  for (const column of columns) {
+    try {
+      raw.exec(`ALTER TABLE conversations ADD COLUMN ${column}`);
+    } catch {
+      // Column already exists — nothing to do.
+    }
+  }
+}

package/src/memory/migrations/index.ts

@@ -119,6 +119,16 @@ export { migrateRenameThreadStartersTable } from "./174-rename-thread-starters-t
 export { createLifecycleEventsTable } from "./175-create-lifecycle-events.js";
 export { migrateDropCapabilityCardState } from "./176-drop-capability-card-state.js";
 export { migrateCreateTraceEventsTable } from "./177-create-trace-events-table.js";
+export { migrateOAuthProvidersManagedServiceConfigKey } from "./178-oauth-providers-managed-service-config-key.js";
+export { migrateLlmRequestLogMessageId } from "./179-llm-request-log-message-id.js";
+export { migrateBackfillInlineAttachmentsToDisk } from "./180-backfill-inline-attachments-to-disk.js";
+export { migrateRenameThreadStartersCheckpoints } from "./181-rename-thread-starters-checkpoints.js";
+export { migrateOAuthProvidersDisplayMetadata } from "./182-oauth-providers-display-metadata.js";
+export { migrateConversationForkLineage } from "./183-add-conversation-fork-lineage.js";
+export { migrateLlmRequestLogProvider } from "./184-llm-request-log-provider.js";
+export { migrateMemoryBriefState } from "./185-memory-brief-state.js";
+export { migrateMemoryArchiveTables } from "./186-memory-archive.js";
+export { migrateMemoryReducerCheckpoints } from "./187-memory-reducer-checkpoints.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/migrations/registry.ts

@@ -228,6 +228,19 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
     description:
       "Remove deleted capability-card rows, jobs, checkpoints, and category state",
   },
+  {
+    key: "migration_backfill_inline_attachments_v1",
+    version: 34,
+    description:
+      "Backfill existing inline base64 attachments to on-disk storage and clear dataBase64",
+  },
+  {
+    key: "migration_rename_thread_starters_checkpoints_v1",
+    version: 35,
+    dependsOn: ["migration_rename_thread_starters_table_v1"],
+    description:
+      "Rename checkpoint keys from thread_starters: to conversation_starters: prefix so renamed code paths find existing generation state",
+  },
 ];
 
 export interface MigrationValidationResult {

package/src/memory/qdrant-client.ts

@@ -20,7 +20,7 @@ export interface QdrantClientConfig {
 }
 
 export interface QdrantPointPayload {
-  target_type: "segment" | "item" | "summary" | "media";
+  target_type: "segment" | "item" | "summary" | "observation" | "chunk" | "episode" | "media";
   target_id: string;
   text: string;
   kind?: string;
@@ -230,7 +230,7 @@ export class VellumQdrantClient {
   }
 
   async upsert(
-    targetType: "segment" | "item" | "summary" | "media",
+    targetType: "segment" | "item" | "summary" | "observation" | "chunk" | "episode" | "media",
     targetId: string,
     vector: number[],
     payload: Omit<QdrantPointPayload, "target_type" | "target_id">,
@@ -324,8 +324,11 @@ export class VellumQdrantClient {
   async searchWithFilter(
     vector: number[],
     limit: number,
-    targetTypes: Array<"segment" | "item" | "summary" | "media">,
+    targetTypes: Array<
+      "segment" | "item" | "summary" | "media" | "chunk" | "episode"
+    >,
     excludeMessageIds?: string[],
+    scopeIds?: string[],
   ): Promise<QdrantSearchResult[]> {
     const mustConditions: Array<Record<string, unknown>> = [
       {
@@ -346,12 +349,24 @@ export class VellumQdrantClient {
           },
           {
             key: "target_type",
-            match: { any: ["segment", "summary", "media"] },
+            match: { any: ["segment", "summary", "media", "chunk"] },
           },
         ],
       });
     }
 
+    // Scope filtering: accept points whose memory_scope_id matches one of the
+    // allowed scopes, OR points that lack the field entirely (legacy data).
+    // Post-query DB filtering remains as defense-in-depth for legacy points.
+    if (scopeIds && scopeIds.length > 0) {
+      mustConditions.push({
+        should: [
+          { key: "memory_scope_id", match: { any: scopeIds } },
+          { is_empty: { key: "memory_scope_id" } },
+        ],
+      });
+    }
+
     const mustNotConditions: Array<Record<string, unknown>> = [
       { key: "_meta", match: { value: true } },
     ];
@@ -561,6 +576,10 @@ export class VellumQdrantClient {
         field_name: "modality",
         field_schema: "keyword",
       }),
+      this.client.createPayloadIndex(this.collection, {
+        field_name: "memory_scope_id",
+        field_schema: "keyword",
+      }),
     ]);
   }
 

package/src/memory/reducer-store.ts

@@ -0,0 +1,271 @@
+/**
+ * Reducer store — transactional application of reducer results to brief-state
+ * tables (time_contexts, open_loops) and conversation reducer checkpoints.
+ *
+ * The `applyReducerResult` helper is the single entry point for persisting
+ * reducer output. It runs all upserts, resolves, and checkpoint advances
+ * inside a single SQLite transaction so the DB is never left in a
+ * partially-applied state.
+ *
+ * Archive writes are intentionally out of scope — they have their own
+ * lifecycle and can be tested independently.
+ */
+
+import { and, eq, gt } from "drizzle-orm";
+import { v4 as uuid } from "uuid";
+
+import { getLogger } from "../util/logger.js";
+import { getDb } from "./db.js";
+import type { ReducerResult } from "./reducer-types.js";
+import { conversations, messages, openLoops, timeContexts } from "./schema.js";
+
+const log = getLogger("reducer-store");
+
+// ── Read helpers ─────────────────────────────────────────────────────
+
+/**
+ * Return all active (non-expired) time contexts for a memory scope.
+ * "Active" means `activeUntil` is in the future relative to `now`.
+ */
+export function getActiveTimeContexts(
+  scopeId: string,
+  now: number = Date.now(),
+): Array<{
+  id: string;
+  summary: string;
+  activeFrom: number;
+  activeUntil: number;
+}> {
+  const db = getDb();
+  return db
+    .select({
+      id: timeContexts.id,
+      summary: timeContexts.summary,
+      activeFrom: timeContexts.activeFrom,
+      activeUntil: timeContexts.activeUntil,
+    })
+    .from(timeContexts)
+    .where(
+      and(eq(timeContexts.scopeId, scopeId), gt(timeContexts.activeUntil, now)),
+    )
+    .all();
+}
+
+/**
+ * Return all open loops for a memory scope.
+ */
+export function getActiveOpenLoops(
+  scopeId: string,
+): Array<{ id: string; summary: string; status: string }> {
+  const db = getDb();
+  return db
+    .select({
+      id: openLoops.id,
+      summary: openLoops.summary,
+      status: openLoops.status,
+    })
+    .from(openLoops)
+    .where(and(eq(openLoops.scopeId, scopeId), eq(openLoops.status, "open")))
+    .all();
+}
+
+// ── Brief-compiler helper ────────────────────────────────────────────
+
+/**
+ * Update the `surfaced_at` timestamp on a single open loop.
+ *
+ * Called by the brief compiler after resurfacing a low-salience loop
+ * so it is not immediately resurfaced again on the next turn.
+ */
+export function updateLastSurfacedAt(loopId: string, surfacedAt: number): void {
+  const db = getDb();
+  db.update(openLoops)
+    .set({ surfacedAt, updatedAt: surfacedAt })
+    .where(eq(openLoops.id, loopId))
+    .run();
+}
+
+// ── Transactional apply ──────────────────────────────────────────────
+
+export interface ApplyReducerResultParams {
+  /** The validated reducer result to persist. */
+  result: ReducerResult;
+  /** Conversation that was reduced. */
+  conversationId: string;
+  /** Memory scope for new rows (e.g. assistant instance ID). */
+  scopeId: string;
+  /** ID of the last message that was included in this reducer run. */
+  reducedThroughMessageId: string;
+  /** Current timestamp in epoch ms (injectable for testing). */
+  now?: number;
+}
+
+/**
+ * Atomically apply a reducer result to the database.
+ *
+ * Within a single transaction this function:
+ *   1. Upserts time_contexts (create / update / resolve)
+ *   2. Upserts open_loops (create / update / resolve)
+ *   3. Advances the conversation's reducer checkpoint columns
+ *   4. Clears `memoryDirtyTailSinceMessageId` when the conversation is
+ *      fully caught up (no messages exist after `reducedThroughMessageId`)
+ *
+ * Archive candidates in the result are intentionally ignored — they are
+ * handled by a separate pipeline.
+ *
+ * The function is idempotent: applying the same result twice leaves the
+ * database in the same state. Create operations use deterministic IDs
+ * derived from the reducer output position so re-application produces
+ * the same rows.
+ */
+export function applyReducerResult(params: ApplyReducerResultParams): void {
+  const {
+    result,
+    conversationId,
+    scopeId,
+    reducedThroughMessageId,
+    now = Date.now(),
+  } = params;
+
+  const db = getDb();
+
+  db.transaction((tx) => {
+    // ── 1. Time contexts ───────────────────────────────────────────
+    for (let i = 0; i < result.timeContexts.length; i++) {
+      const op = result.timeContexts[i];
+
+      if (op.action === "create") {
+        const id = uuid();
+        tx.insert(timeContexts)
+          .values({
+            id,
+            scopeId,
+            summary: op.summary,
+            source: op.source,
+            activeFrom: op.activeFrom,
+            activeUntil: op.activeUntil,
+            createdAt: now,
+            updatedAt: now,
+          })
+          .run();
+      } else if (op.action === "update") {
+        const setFields: Record<string, unknown> = { updatedAt: now };
+        if (op.summary !== undefined) setFields.summary = op.summary;
+        if (op.activeFrom !== undefined) setFields.activeFrom = op.activeFrom;
+        if (op.activeUntil !== undefined)
+          setFields.activeUntil = op.activeUntil;
+
+        tx.update(timeContexts)
+          .set(setFields)
+          .where(eq(timeContexts.id, op.id))
+          .run();
+      } else {
+        // resolve — delete the row (resolved time contexts are no longer relevant)
+        tx.delete(timeContexts).where(eq(timeContexts.id, op.id)).run();
+      }
+    }
+
+    // ── 2. Open loops ──────────────────────────────────────────────
+    for (let i = 0; i < result.openLoops.length; i++) {
+      const op = result.openLoops[i];
+
+      if (op.action === "create") {
+        const id = uuid();
+        tx.insert(openLoops)
+          .values({
+            id,
+            scopeId,
+            summary: op.summary,
+            source: op.source,
+            status: "open",
+            dueAt: op.dueAt ?? null,
+            createdAt: now,
+            updatedAt: now,
+          })
+          .run();
+      } else if (op.action === "update") {
+        const setFields: Record<string, unknown> = { updatedAt: now };
+        if (op.summary !== undefined) setFields.summary = op.summary;
+        if (op.dueAt !== undefined) setFields.dueAt = op.dueAt;
+
+        tx.update(openLoops)
+          .set(setFields)
+          .where(eq(openLoops.id, op.id))
+          .run();
+      } else {
+        // resolve — mark status (resolved | expired)
+        tx.update(openLoops)
+          .set({ status: op.status, updatedAt: now })
+          .where(eq(openLoops.id, op.id))
+          .run();
+      }
+    }
+
+    // ── 3. Advance reducer checkpoint ──────────────────────────────
+    //
+    // Check whether the conversation is fully caught up: no messages
+    // exist after the one we just reduced through. If caught up, clear
+    // the dirty tail marker so the reducer knows there's nothing left
+    // to process.
+    const laterMessage = tx
+      .select({ id: messages.id })
+      .from(messages)
+      .where(
+        and(
+          eq(messages.conversationId, conversationId),
+          gt(
+            messages.createdAt,
+            getMessageCreatedAt(tx, reducedThroughMessageId),
+          ),
+        ),
+      )
+      .limit(1)
+      .get();
+
+    const isCaughtUp = !laterMessage;
+
+    const checkpointUpdate: Record<string, unknown> = {
+      memoryReducedThroughMessageId: reducedThroughMessageId,
+      memoryLastReducedAt: now,
+    };
+
+    if (isCaughtUp) {
+      checkpointUpdate.memoryDirtyTailSinceMessageId = null;
+    }
+
+    tx.update(conversations)
+      .set(checkpointUpdate)
+      .where(eq(conversations.id, conversationId))
+      .run();
+
+    log.debug(
+      {
+        conversationId,
+        reducedThroughMessageId,
+        timeContextOps: result.timeContexts.length,
+        openLoopOps: result.openLoops.length,
+        isCaughtUp,
+      },
+      "Applied reducer result",
+    );
+  });
+}
+
+// ── Internal helpers ─────────────────────────────────────────────────
+
+/**
+ * Get the createdAt timestamp for a message by ID.
+ * Returns 0 if the message doesn't exist (which means the gt() comparison
+ * will match all messages — safe fallback that prevents clearing dirty tail).
+ */
+function getMessageCreatedAt(
+  tx: Parameters<Parameters<ReturnType<typeof getDb>["transaction"]>[0]>[0],
+  messageId: string,
+): number {
+  const row = tx
+    .select({ createdAt: messages.createdAt })
+    .from(messages)
+    .where(eq(messages.id, messageId))
+    .get();
+  return row?.createdAt ?? 0;
+}