@vellumai/assistant 0.11.3 → 0.11.4-staging.1

package/src/persistence/bookmark-crud.ts

@@ -3,6 +3,7 @@ import { v4 as uuid } from "uuid";
 
 import type { DrizzleDb } from "./db-connection.js";
 import { stringifyMessageContent } from "./message-content.js";
+import { messageConversationId } from "./message-reads.js";
 import { conversations, messageBookmarks, messages } from "./schema.js";
 
 /**
@@ -138,15 +139,10 @@ export function createBookmark(
   params: { messageId: string },
 ): CreateBookmarkResult {
   const { messageId } = params;
-  const message = db
-    .select({ conversationId: messages.conversationId })
-    .from(messages)
-    .where(eq(messages.id, messageId))
-    .get();
-  if (!message) {
+  const conversationId = messageConversationId(messageId, { db });
+  if (conversationId === null) {
     throw new Error(`Message ${messageId} not found`);
   }
-  const conversationId = message.conversationId;
 
   const existing = db
     .select({ id: messageBookmarks.id })

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

@@ -21,11 +21,14 @@ import { v4 as uuid } from "uuid";
 
 import { UserError } from "../util/errors.js";
 import { getDb } from "./db-connection.js";
+import {
+  latestAssistantMessage,
+  latestAssistantMessageBefore,
+} from "./message-reads.js";
 import {
   conversationAssistantAttentionState,
   conversationAttentionEvents,
   conversations,
-  messages,
 } from "./schema/index.js";
 
 // ── Types ────────────────────────────────────────────────────────────
@@ -361,19 +364,11 @@ export function recordConversationSeenSignal(params: {
     if (!state) {
       // No state row yet — look up the conversation's latest assistant message so
       // upgraded databases (with existing messages but no attention row) correctly
-      // initialize the full state on the first seen signal.
-      const latestMsg = tx
-        .select({ id: messages.id, createdAt: messages.createdAt })
-        .from(messages)
-        .where(
-          and(
-            eq(messages.conversationId, conversationId),
-            eq(messages.role, "assistant"),
-          ),
-        )
-        .orderBy(desc(messages.createdAt))
-        .limit(1)
-        .get();
+      // initialize the full state on the first seen signal. Finalized-only via
+      // the accessor: a still-streaming reply is not a reply the user has seen,
+      // and anchoring the watermark on it would classify the finished reply as
+      // seen the moment it completes.
+      const latestMsg = latestAssistantMessage(conversationId, { db: tx });
 
       const latestMsgId = latestMsg?.id ?? null;
       const latestMsgAt = latestMsg?.createdAt ?? null;
@@ -461,26 +456,11 @@ function resolveAssistantCursor(params: {
     latestAssistantMessageAt,
   } = params;
 
-  // Unread classification compares timestamps strictly, so rewinding to a
-  // same-timestamp sibling would leave the latest reply classified as seen.
-  const previousAssistantMessageBefore = (before: number) =>
-    db
-      .select({ id: messages.id, createdAt: messages.createdAt })
-      .from(messages)
-      .where(
-        and(
-          eq(messages.conversationId, conversationId),
-          eq(messages.role, "assistant"),
-          lt(messages.createdAt, before),
-        ),
-      )
-      .orderBy(desc(messages.createdAt), desc(messages.id))
-      .limit(1)
-      .get();
-
   if (latestAssistantMessageId && latestAssistantMessageAt != null) {
-    const previousMessage = previousAssistantMessageBefore(
+    const previousMessage = latestAssistantMessageBefore(
+      conversationId,
       latestAssistantMessageAt,
+      { db },
     );
 
     return {
@@ -491,25 +471,16 @@ function resolveAssistantCursor(params: {
     };
   }
 
-  const latestMessage = db
-    .select({ id: messages.id, createdAt: messages.createdAt })
-    .from(messages)
-    .where(
-      and(
-        eq(messages.conversationId, conversationId),
-        eq(messages.role, "assistant"),
-      ),
-    )
-    .orderBy(desc(messages.createdAt), desc(messages.id))
-    .limit(1)
-    .get();
+  const latestMessage = latestAssistantMessage(conversationId, { db });
 
   if (!latestMessage) {
     return null;
   }
 
-  const previousMessage = previousAssistantMessageBefore(
+  const previousMessage = latestAssistantMessageBefore(
+    conversationId,
     latestMessage.createdAt,
+    { db },
   );
   return {
     latestAssistantMessageId: latestMessage.id,

package/src/persistence/conversation-crud.ts

@@ -498,6 +498,25 @@ export function parseMessageMetadata(
   }
 }
 
+/**
+ * Rows a fork may copy: finalized ones. A `finalized = 0` row is mid-write,
+ * its content a `{ ref }` into the source turn's in-flight delta file, which
+ * the source deletes when the turn completes. A copied row would point at a
+ * file another conversation is about to delete, leaving a permanently empty
+ * message that reads as final and is invisible to crash recovery (which scans
+ * `finalized = 0` only). Unfinalized is not "unsent": the message was sent
+ * and is still being written, so there is no completed content to copy. A
+ * fork reflects the conversation at a completed point.
+ *
+ * Callers apply this to `messagesToCopy` itself, upstream of the boundary
+ * timestamp, compaction inheritance, `forkParentMessageId`, and the id map,
+ * so every derivation describes the rows actually copied and the lineage
+ * anchor can never reference a row the fork does not hold.
+ */
+function dropUnfinalizedRows(rows: MessageRow[]): MessageRow[] {
+  return rows.filter((message) => message.finalized === 1);
+}
+
 function cloneForkMessageMetadata(
   metadata: string | null,
   sourceMessageId: string,
@@ -1336,7 +1355,7 @@ export function forkConversation(params: {
 
   const messagesToCopy =
     copyBoundaryIndex >= 0
-      ? sourceMessages.slice(0, copyBoundaryIndex + 1)
+      ? dropUnfinalizedRows(sourceMessages.slice(0, copyBoundaryIndex + 1))
       : ([] as MessageRow[]);
 
   // Inherit the history-strip marker only when the fork boundary is at-or-
@@ -1461,7 +1480,13 @@ export function forkConversation(params: {
       messagesToCopy,
       forkedMessageIds,
       latestForkedAssistant,
-      isFullHistoryFork: copyBoundaryIndex === sourceMessages.length - 1,
+      // The wholesale memory-state carry requires the fork's window to equal
+      // the source's rendered window; a boundary at the tip no longer
+      // guarantees that when the unfinalized filter dropped rows from the
+      // slice, so both conditions gate it.
+      isFullHistoryFork:
+        copyBoundaryIndex === sourceMessages.length - 1 &&
+        messagesToCopy.length === copyBoundaryIndex + 1,
       inheritedCompactedMessageCount:
         inheritedCompaction?.compactedMessageCount ?? 0,
       diskSyncQueue,
@@ -1772,7 +1797,7 @@ export async function forkConversationForRetrospective(params: {
   );
   const messagesToCopy =
     copyBoundaryIndex >= 0
-      ? sourceMessages.slice(0, copyBoundaryIndex + 1)
+      ? dropUnfinalizedRows(sourceMessages.slice(0, copyBoundaryIndex + 1))
       : ([] as MessageRow[]);
 
   const sourceHistoryStrippedAt = sourceConversation.historyStrippedAt ?? null;
@@ -1936,8 +1961,12 @@ export async function forkConversationForRetrospective(params: {
               messagesToCopy: rowsToCopy,
               forkedMessageIds,
               latestForkedAssistant,
+              // Both conditions, for the same reason as `forkConversation`:
+              // a tip boundary no longer implies an equal window once the
+              // unfinalized filter dropped rows from the slice.
               isFullHistoryFork:
-                copyBoundaryIndex === sourceMessages.length - 1,
+                copyBoundaryIndex === sourceMessages.length - 1 &&
+                messagesToCopy.length === copyBoundaryIndex + 1,
               // The copied range already starts at the visible window.
               inheritedCompactedMessageCount: forkCompactedMessageCount,
               skipCompactionLedgerCopy: inheritedCompaction != null,

package/src/persistence/conversation-lineage.ts

@@ -184,6 +184,14 @@ export function isSingleSegmentLineage(segments: LineageSegment[]): boolean {
  * strictly-earlier `createdAt`, or an equal `createdAt` with an id that does
  * not sort after the bound. The fork message itself is included, because a
  * fork is taken THROUGH that message.
+ *
+ * Ancestor segments additionally exclude unfinalized rows. An ancestor's
+ * `finalized = 0` row is a message its own live turn is still writing; a
+ * descendant reading it would see partial content that the ancestor rewrites
+ * inline when the turn completes. The row enters the window on its own once
+ * it finalizes. A segment with no bound is the conversation's own tail and
+ * keeps its unfinalized rows: a conversation always sees its own in-flight
+ * message.
  */
 export function lineageMessageFilter(segments: LineageSegment[]): SQL {
   const clauses = segments.map((segment) => {
@@ -194,6 +202,7 @@ export function lineageMessageFilter(segments: LineageSegment[]): SQL {
     const { createdAt, id } = segment.through;
     return and(
       owner,
+      eq(messages.finalized, 1),
       or(
         lt(messages.createdAt, createdAt),
         and(

package/src/persistence/conversation-queries.ts

@@ -1,4 +1,4 @@
-import { and, count, desc, eq, inArray, isNull, lt, sql } from "drizzle-orm";
+import { and, count, desc, eq, isNull, lt, sql } from "drizzle-orm";
 
 import {
   parseExternalContentEnvelope,
@@ -26,11 +26,14 @@ import {
   parseContentRef,
   resolveMessageContentBlocks,
 } from "./message-content-file.js";
+import {
+  countMessagesByRoleForConversations,
+  latestUserMessageRawContent,
+} from "./message-reads.js";
 import { rawAll } from "./raw-query.js";
 import {
   conversationAssistantAttentionState,
   conversations,
-  messages,
 } from "./schema/index.js";
 
 const log = getLogger("conversation-store");
@@ -438,31 +441,7 @@ export function getMessageRoleStatsByConversation(
   conversationIds: string[],
   role: string = "assistant",
 ): Map<string, { count: number; lastAt: number }> {
-  if (conversationIds.length === 0) {
-    return new Map();
-  }
-  const db = getDb();
-  const rows = db
-    .select({
-      conversationId: messages.conversationId,
-      count: sql<number>`COUNT(*)`.as("count"),
-      lastAt: sql<number>`MAX(${messages.createdAt})`.as("last_at"),
-    })
-    .from(messages)
-    .where(
-      and(
-        inArray(messages.conversationId, conversationIds),
-        eq(messages.role, role),
-      ),
-    )
-    .groupBy(messages.conversationId)
-    .all();
-  return new Map(
-    rows.map((r) => [
-      r.conversationId,
-      { count: Number(r.count), lastAt: Number(r.lastAt) },
-    ]),
-  );
+  return countMessagesByRoleForConversations(conversationIds, role);
 }
 
 export function listPinnedConversations(
@@ -535,6 +514,8 @@ export function listConversationsByTitlePrefix(
   const rows = rawAll<Row>(
     "conversation:listByTitlePrefix",
     `SELECT c.id, c.title,
+            -- Any-state count (streaming rows included): a list-surface size
+            -- hint where a transient +1 during a live turn is immaterial.
             (SELECT COUNT(*) FROM messages WHERE conversation_id = c.id) AS message_count,
             c.created_at
      FROM conversations c
@@ -617,32 +598,114 @@ export function countUnreadConversations(): number {
   return total;
 }
 
+/** Totals for one sidebar section: every member, and the unread among them. */
+export interface ConversationSectionCount {
+  total: number;
+  unread: number;
+}
+
 /**
- * Check whether the last user message in a conversation is a tool_result-only
- * message (i.e., not a real user-typed message). This is used by undo() to
- * determine if additional exchanges need to be deleted from the DB.
+ * Row counts for every non-empty sidebar section, with no rows fetched.
+ *
+ * Two axes, disjoint by construction because `group_id` is single-valued:
+ *
+ * - `groups`: rows filed somewhere, bucketed by `group_id`. Contains
+ *   `'system:pinned'` and custom-group ids; the background/scheduled system
+ *   buckets are excluded because no section renders them.
+ * - `channels`: rows filed nowhere, bucketed by effective origin channel,
+ *   where NULL reads as {@link NATIVE_ORIGIN_CHANNEL} exactly as
+ *   {@link originChannelClause} reads it. The native bucket is the Chats
+ *   section; each other bucket is that channel's section.
+ *
+ * Only buckets with at least one row appear: GROUP BY cannot emit an empty
+ * bucket, and an empty section renders no card.
+ *
+ * `total` follows the standard-listing visibility
+ * ({@link conversationTypeClause}), active rows only, so it counts exactly
+ * the rows `GET /v1/conversations` would return for that section's filter.
+ * `unread` applies the same rules as {@link countUnreadConversations} on top
+ * (not an unsurfaced background/scheduled row, unseen per the attention
+ * projection), composed from the same predicates rather than restated, so
+ * the per-section numbers always sum against the global count.
  */
-export function isLastUserMessageToolResult(conversationId: string): boolean {
+export interface ConversationSectionCounts {
+  groups: Array<{ groupId: string } & ConversationSectionCount>;
+  channels: Array<{ channel: string } & ConversationSectionCount>;
+}
+
+export function countConversationSections(): ConversationSectionCounts {
+  ensureGroupMigration();
   const db = getDb();
-  const lastUserMsg = db
-    .select({ content: messages.content })
-    .from(messages)
+
+  /* `countUnreadConversations` gets the same effect with an INNER JOIN and
+     the unseen conditions in its WHERE; here every row must be counted and
+     only unread rows summed, so the join is LEFT and the conditions move
+     into the CASE. A row with no attention projection has NULL columns,
+     fails the conditions, and sums 0: identical membership. */
+  const unread = sql<number>`SUM(CASE WHEN ${and(
+    sql.raw(notBackgroundVisibilitySql()),
+    ...unseenAttentionStateConditions(),
+  )} THEN 1 ELSE 0 END)`;
+
+  const attentionJoin = eq(
+    conversationAssistantAttentionState.conversationId,
+    conversations.id,
+  );
+
+  const groups = db
+    .select({
+      groupId: sql<string>`group_id`,
+      total: count(),
+      unread,
+    })
+    .from(conversations)
+    .leftJoin(conversationAssistantAttentionState, attentionJoin)
     .where(
       and(
-        eq(messages.conversationId, conversationId),
-        eq(messages.role, "user"),
+        conversationTypeClause("standard"),
+        isNull(conversations.archivedAt),
+        sql`(group_id = ${PINNED_GROUP_ID} OR (group_id IS NOT NULL AND group_id NOT LIKE 'system:%'))`,
       ),
     )
-    .orderBy(sql`rowid DESC`)
-    .limit(1)
-    .get();
+    .groupBy(sql`group_id`)
+    .all();
+
+  const effectiveChannel = sql<string>`COALESCE(${conversations.originChannel}, ${NATIVE_ORIGIN_CHANNEL})`;
+  const channels = db
+    .select({
+      channel: effectiveChannel,
+      total: count(),
+      unread,
+    })
+    .from(conversations)
+    .leftJoin(conversationAssistantAttentionState, attentionJoin)
+    .where(
+      and(
+        conversationTypeClause("standard"),
+        isNull(conversations.archivedAt),
+        groupIdClause(UNGROUPED_GROUP_ID),
+      ),
+    )
+    .groupBy(effectiveChannel)
+    .all();
+
+  return { groups, channels };
+}
+
+/**
+ * Check whether the last user message in a conversation is a tool_result-only
+ * message (i.e., not a real user-typed message). This is used by undo() to
+ * determine if additional exchanges need to be deleted from the DB.
+ */
+export function isLastUserMessageToolResult(conversationId: string): boolean {
+  const lastUserContent = latestUserMessageRawContent(conversationId);
 
-  if (!lastUserMsg) {
+  if (lastUserContent === null) {
     return false;
   }
 
   try {
-    const parsed = JSON.parse(lastUserMsg.content);
+    const parsed = JSON.parse(lastUserContent);
     if (
       Array.isArray(parsed) &&
       parsed.length > 0 &&
@@ -816,6 +879,10 @@ export async function searchConversations(
       if (!opts?.includeArchived) {
         whereClauses.push(`c.archived_at IS NULL`);
       }
+      // No completeness predicate: candidate ids come from the lexical
+      // index, which filters finalized = 1 at index time, so an unfinalized
+      // row cannot be a candidate. Do not copy this shape for id sets with
+      // different provenance.
       const visibleRows = rawAll<CandidateRow>(
         "conversation:searchConversations:visibleCandidates",
         `

package/src/persistence/delivery-crud.ts

@@ -8,8 +8,8 @@
 import { and, desc, eq, isNotNull, ne, or, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import type { ChannelId } from "../channels/types.js";
 import { readSlackMetadataFromMessageMetadata } from "../messaging/providers/slack/message-metadata.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import type { SlackInboundMessageMetadata } from "../runtime/http-types.js";
 import { parseJsonSafe } from "../util/json.js";
 import { isPlainObject } from "../util/object.js";
@@ -19,6 +19,7 @@ import {
   getOrCreateConversation,
   setConversationKeyIfAbsent,
 } from "./conversation-key-store.js";
+import type { NonScheduledConversationType } from "./conversation-types.js";
 import { getDb } from "./db-connection.js";
 import { channelInboundEvents, conversations } from "./schema.js";
 
@@ -31,7 +32,6 @@ export interface InboundResult {
 
 export interface RecordInboundOptions {
   sourceMessageId?: string;
-  assistantId?: string;
   sourceThreadId?: string;
 }
 
@@ -45,30 +45,25 @@ const SLACK_LEGACY_THREAD_EVIDENCE_MAX_SCAN = 500;
  */
 const THREAD_SCOPED_CHANNELS = new Set(["slack", "telegram"]);
 
-function buildScopedConversationKeyForAssistant(
-  assistantId: string,
+/**
+ * Scope prefix on every conversation key.
+ *
+ * Part of the stored key format, so it is fixed: rows are written under
+ * `asst:self:` and stop resolving if it changes. The daemon is single-tenant
+ * and scopes all its storage to `self` (`DAEMON_INTERNAL_ASSISTANT_ID`).
+ */
+const CONVERSATION_KEY_SCOPE = "asst:self";
+
+export function buildScopedConversationKey(
   sourceChannel: string,
   externalChatId: string,
   sourceThreadId?: string | null,
 ): string {
   const threadId = sourceThreadId?.trim();
   if (THREAD_SCOPED_CHANNELS.has(sourceChannel) && threadId) {
-    return `asst:${assistantId}:${sourceChannel}:${externalChatId}:thread:${threadId}`;
+    return `${CONVERSATION_KEY_SCOPE}:${sourceChannel}:${externalChatId}:thread:${threadId}`;
   }
-  return `asst:${assistantId}:${sourceChannel}:${externalChatId}`;
-}
-
-export function buildScopedConversationKey(
-  sourceChannel: string,
-  externalChatId: string,
-  sourceThreadId?: string | null,
-): string {
-  return buildScopedConversationKeyForAssistant(
-    DAEMON_INTERNAL_ASSISTANT_ID,
-    sourceChannel,
-    externalChatId,
-    sourceThreadId,
-  );
+  return `${CONVERSATION_KEY_SCOPE}:${sourceChannel}:${externalChatId}`;
 }
 
 function legacySlackConversationHasThreadEvidence(
@@ -135,14 +130,24 @@ function legacySlackConversationHasThreadEvidence(
   return false;
 }
 
-function resolveInboundConversation(
-  assistantId: string,
+/**
+ * Applied only where this call is what creates the conversation. An address
+ * that already resolves is an existing conversation, and neither its type nor
+ * where it came from is the current message's to restate.
+ */
+export interface ResolveInboundConversationOptions {
+  conversationType?: NonScheduledConversationType;
+  /** Channel this conversation originates on, for first-message attribution. */
+  origin?: ChannelId;
+}
+
+export function resolveInboundConversation(
   sourceChannel: string,
   externalChatId: string,
   sourceThreadId?: string | null,
+  opts?: ResolveInboundConversationOptions,
 ): { conversationId: string } {
-  const threadedKey = buildScopedConversationKeyForAssistant(
-    assistantId,
+  const threadedKey = buildScopedConversationKey(
     sourceChannel,
     externalChatId,
     sourceThreadId,
@@ -155,7 +160,7 @@ function resolveInboundConversation(
   // other thread-scoped channel (Telegram topics) has no flat-key aliasing —
   // a thread id always resolves the threaded key directly.
   if (sourceChannel !== "slack" || !threadId) {
-    return getOrCreateConversation(threadedKey);
+    return getOrCreateConversation(threadedKey, opts);
   }
 
   const threadedMapping = getConversationByKey(threadedKey);
@@ -163,8 +168,7 @@ function resolveInboundConversation(
     return { conversationId: threadedMapping.conversationId };
   }
 
-  const legacyKey = buildScopedConversationKeyForAssistant(
-    assistantId,
+  const legacyKey = buildScopedConversationKey(
     sourceChannel,
     externalChatId,
     null,
@@ -185,7 +189,7 @@ function resolveInboundConversation(
     }
   }
 
-  return getOrCreateConversation(threadedKey);
+  return getOrCreateConversation(threadedKey, opts);
 }
 
 /**
@@ -236,6 +240,13 @@ export function findInboundConversationId(
 /**
  * Record an inbound channel event. Returns `duplicate: true` if this
  * exact (channel, chat, message) combination was already seen.
+ *
+ * The dedup half of this is also implemented gateway-side, on the same
+ * triple, in `gateway/src/db/inbound-dedup-store.ts`. Deliberately, not by
+ * accident: the gateway claims a delivery before handing it over, so a
+ * vendor's retry costs no crossing, and this stays as the record that binds
+ * the conversation and tracks the reply. Both must key on the same three
+ * fields for either to mean anything.
  */
 export function recordInbound(
   sourceChannel: string,
@@ -269,9 +280,7 @@ export function recordInbound(
     };
   }
 
-  const assistantId = options?.assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID;
   const mapping = resolveInboundConversation(
-    assistantId,
     sourceChannel,
     externalChatId,
     options?.sourceThreadId,

package/src/persistence/external-conversation-store.ts

@@ -7,7 +7,8 @@
  * list APIs.
  */
 
-import { and, eq, inArray, isNull, sql } from "drizzle-orm";
+import { and, eq, inArray, isNull, type SQL, sql } from "drizzle-orm";
+import type { AnySQLiteColumn } from "drizzle-orm/sqlite-core";
 
 import { getDb } from "./db-connection.js";
 import { externalConversationBindings } from "./schema/index.js";
@@ -45,6 +46,19 @@ function normalizeExternalThreadId(
   return trimmed ? trimmed : null;
 }
 
+/**
+ * An upsert value that leaves the stored column alone when the caller said
+ * nothing about it, distinguishing "I do not know" from "there is none".
+ */
+function keepStoredIfAbsent<T extends string | null | undefined>(
+  value: T,
+  column: AnySQLiteColumn,
+): Exclude<T, undefined> | SQL {
+  return value === undefined
+    ? sql`${column}`
+    : (value as Exclude<T, undefined>);
+}
+
 function normalizeExternalChatName(
   externalChatName?: string | null,
 ): string | null {
@@ -103,9 +117,23 @@ export function upsertBinding(input: UpsertBindingInput): void {
           externalChatName ??
           sql`${externalConversationBindings.externalChatName}`,
         externalThreadId,
-        externalUserId: input.externalUserId ?? null,
-        displayName: input.displayName ?? null,
-        username: input.username ?? null,
+        // An omitted sender field keeps what is stored; an explicit value,
+        // including null, replaces it. A caller that knows only the chat
+        // coordinates on a message is silent about the sender rather than
+        // asserting there is none, and erasing a known name on that silence
+        // drops it from the conversation and session APIs.
+        externalUserId: keepStoredIfAbsent(
+          input.externalUserId,
+          externalConversationBindings.externalUserId,
+        ),
+        displayName: keepStoredIfAbsent(
+          input.displayName,
+          externalConversationBindings.displayName,
+        ),
+        username: keepStoredIfAbsent(
+          input.username,
+          externalConversationBindings.username,
+        ),
         updatedAt: now,
         lastInboundAt: now,
       },

package/src/persistence/llm-request-log-store.ts

@@ -28,13 +28,14 @@ import {
   getTurnTimeBounds,
   messageMetadataSchema,
 } from "./conversation-crud.js";
-import { type DrizzleDb, getDb, getLogsDb } from "./db-connection.js";
+import { type DrizzleDb, getLogsDb } from "./db-connection.js";
 import { getClickHouseLlmRequestLogSink } from "./llm-request-log-sink-clickhouse.js";
 import type {
   LlmRequestLogWriter,
   LlmRequestLogWriteRow,
 } from "./llm-request-log-writer-types.js";
-import { llmRequestLogs, messages } from "./schema/index.js";
+import { existingMessageIds } from "./message-reads.js";
+import { llmRequestLogs } from "./schema/index.js";
 import { timeSyncSection } from "./slow-sync-log.js";
 
 /**
@@ -593,14 +594,7 @@ function selectOrphanedLogsInRange(
   const candidateMessageIds = [
     ...new Set(candidates.map((c) => c.messageId as string)),
   ];
-  const existing = new Set(
-    getDb()
-      .select({ id: messages.id })
-      .from(messages)
-      .where(inArray(messages.id, candidateMessageIds))
-      .all()
-      .map((r) => r.id),
-  );
+  const existing = existingMessageIds(candidateMessageIds);
 
   // Orphaned = the referenced message no longer exists.
   return candidates.filter((c) => !existing.has(c.messageId as string));