@vellumai/assistant 0.8.1 → 0.8.2

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

@@ -15,6 +15,8 @@ type ConvRow = {
   id: string;
   source: string | null;
   last_message_at: number | null;
+  fork_parent_conversation_id: string | null;
+  created_at: number;
 };
 type JobRow = {
   type: string;
@@ -58,11 +60,26 @@ mock.module("../db-connection.js", () => ({
                   return { conversationId: convId };
                 });
             }
-            // Otherwise, this is the conversation query.
-            // The test harness applies its OWN filter logic below since the
-            // production code uses drizzle's combinator. We expose all rows
-            // tagged with the right source/last_message_at, and the test
-            // post-filters them to mirror the production query.
+            // The "all retros" query (used to compute most-recent-per-source
+            // preservation) requests id + forkParentConversationId + createdAt
+            // with only the source + isNotNull(forkParent) predicate.
+            if (
+              colKeys.includes("forkParentConversationId") &&
+              colKeys.includes("createdAt")
+            ) {
+              return mockConversations
+                .filter((c) => c.source === "memory-retrospective")
+                .filter((c) => c.fork_parent_conversation_id !== null)
+                .map((c) => ({
+                  id: c.id,
+                  forkParentConversationId: c.fork_parent_conversation_id,
+                  createdAt: c.created_at,
+                }));
+            }
+            // Otherwise, this is the orphan-candidate query. The production
+            // predicate compares `forkParentConversationId` (the source ID
+            // encoded on the background conversation row) against the set
+            // of source IDs extracted from active jobs.
             return mockConversations
               .filter((c) => c.source === "memory-retrospective")
               .filter(
@@ -70,7 +87,11 @@ mock.module("../db-connection.js", () => ({
                   c.last_message_at !== null &&
                   c.last_message_at < injectedNowMinusOrphanAgeMs,
               )
-              .filter((c) => !activeJobConvIds.has(c.id))
+              .filter(
+                (c) =>
+                  c.fork_parent_conversation_id === null ||
+                  !activeJobSourceConvIds.has(c.fork_parent_conversation_id),
+              )
               .map((c) => ({ id: c.id }));
           },
         }),
@@ -79,7 +100,7 @@ mock.module("../db-connection.js", () => ({
   }),
 }));
 
-let activeJobConvIds = new Set<string>();
+let activeJobSourceConvIds = new Set<string>();
 let injectedNowMinusOrphanAgeMs = 0;
 
 mock.module("../conversation-crud.js", () => ({
@@ -94,7 +115,7 @@ import { sweepOrphanMemoryRetrospectiveConversations } from "../memory-retrospec
 const ORPHAN_AGE_MS = 60 * 60 * 1000;
 
 function rebuildActiveJobSet(): void {
-  activeJobConvIds = new Set();
+  activeJobSourceConvIds = new Set();
   for (const j of mockJobs) {
     if (
       j.type !== "memory_retrospective" ||
@@ -105,7 +126,7 @@ function rebuildActiveJobSet(): void {
     try {
       const parsed = JSON.parse(j.payload) as { conversationId?: unknown };
       if (typeof parsed.conversationId === "string") {
-        activeJobConvIds.add(parsed.conversationId);
+        activeJobSourceConvIds.add(parsed.conversationId);
       }
     } catch {
       // ignore
@@ -118,7 +139,7 @@ describe("sweepOrphanMemoryRetrospectiveConversations", () => {
     mockConversations = [];
     mockJobs = [];
     deletedIds = [];
-    activeJobConvIds = new Set();
+    activeJobSourceConvIds = new Set();
     injectedNowMinusOrphanAgeMs = 0;
   });
 
@@ -127,7 +148,7 @@ describe("sweepOrphanMemoryRetrospectiveConversations", () => {
     mockJobs = [];
   });
 
-  test("sweeps an old memory-retrospective conversation with no active job", () => {
+  test("sweeps an old memory-retrospective orphan that has been superseded by a newer retro for the same source", () => {
     const now = Date.now();
     injectedNowMinusOrphanAgeMs = now - ORPHAN_AGE_MS;
     mockConversations = [
@@ -135,6 +156,16 @@ describe("sweepOrphanMemoryRetrospectiveConversations", () => {
         id: "old-orphan",
         source: "memory-retrospective",
         last_message_at: now - 2 * ORPHAN_AGE_MS,
+        fork_parent_conversation_id: "source-A",
+        created_at: now - 3 * ORPHAN_AGE_MS,
+      },
+      // Newer successful retro for the same source — this one is preserved.
+      {
+        id: "newer-retro",
+        source: "memory-retrospective",
+        last_message_at: now - 90 * 60 * 1000,
+        fork_parent_conversation_id: "source-A",
+        created_at: now - 2 * ORPHAN_AGE_MS,
       },
     ];
     rebuildActiveJobSet();
@@ -153,6 +184,8 @@ describe("sweepOrphanMemoryRetrospectiveConversations", () => {
         id: "fresh-bg",
         source: "memory-retrospective",
         last_message_at: now - 60_000,
+        fork_parent_conversation_id: "source-A",
+        created_at: now - 60_000,
       },
     ];
     rebuildActiveJobSet();
@@ -171,6 +204,8 @@ describe("sweepOrphanMemoryRetrospectiveConversations", () => {
         id: "auto-analysis-old",
         source: "auto-analysis",
         last_message_at: now - 2 * ORPHAN_AGE_MS,
+        fork_parent_conversation_id: "source-A",
+        created_at: now - 2 * ORPHAN_AGE_MS,
       },
     ];
     rebuildActiveJobSet();
@@ -180,21 +215,91 @@ describe("sweepOrphanMemoryRetrospectiveConversations", () => {
     expect(result.swept).toBe(0);
   });
 
-  test("does NOT sweep an orphan whose source conversation has an active job", () => {
+  // Regression test for the previously-broken active-job guard. Before the
+  // fix, the predicate compared `conversations.id` (the BACKGROUND-conv id)
+  // to source-conv ids extracted from job payloads — two different identifier
+  // spaces — so the guard never matched and in-flight retros were swept.
+  test("does NOT sweep a background conversation whose SOURCE has an active job (different identifier spaces)", () => {
     const now = Date.now();
     injectedNowMinusOrphanAgeMs = now - ORPHAN_AGE_MS;
+    // The background conv has its own id, distinct from the source it forks
+    // from. The active job's payload references the SOURCE, not the
+    // background.
     mockConversations = [
       {
-        id: "orphan-but-protected",
+        id: "background-conv-id",
         source: "memory-retrospective",
         last_message_at: now - 2 * ORPHAN_AGE_MS,
+        fork_parent_conversation_id: "source-conv-id",
+        created_at: now - 2 * ORPHAN_AGE_MS,
       },
     ];
     mockJobs = [
       {
         type: "memory_retrospective",
         status: "pending",
-        payload: JSON.stringify({ conversationId: "orphan-but-protected" }),
+        payload: JSON.stringify({ conversationId: "source-conv-id" }),
+      },
+    ];
+    rebuildActiveJobSet();
+
+    const result = sweepOrphanMemoryRetrospectiveConversations(now);
+
+    expect(result.swept).toBe(0);
+    expect(deletedIds).toEqual([]);
+  });
+
+  test("sweeps a superseded background conversation whose source has NO active job, even when another unrelated job is pending", () => {
+    const now = Date.now();
+    injectedNowMinusOrphanAgeMs = now - ORPHAN_AGE_MS;
+    mockConversations = [
+      {
+        id: "background-A",
+        source: "memory-retrospective",
+        last_message_at: now - 2 * ORPHAN_AGE_MS,
+        fork_parent_conversation_id: "source-A",
+        created_at: now - 3 * ORPHAN_AGE_MS,
+      },
+      {
+        id: "newer-A",
+        source: "memory-retrospective",
+        last_message_at: now - 90 * 60 * 1000,
+        fork_parent_conversation_id: "source-A",
+        created_at: now - 2 * ORPHAN_AGE_MS,
+      },
+    ];
+    // Active job references a DIFFERENT source — neither retro above is
+    // protected by the active-job guard.
+    mockJobs = [
+      {
+        type: "memory_retrospective",
+        status: "pending",
+        payload: JSON.stringify({ conversationId: "source-B" }),
+      },
+    ];
+    rebuildActiveJobSet();
+
+    const result = sweepOrphanMemoryRetrospectiveConversations(now);
+
+    expect(result.swept).toBe(1);
+    expect(deletedIds).toEqual(["background-A"]);
+  });
+
+  // Regression test for Devin's concern on PR #30331: the sweep used to
+  // delete every memory-retrospective conversation older than 1h, including
+  // the most-recent successful one per source. That broke
+  // `findMostRecentRetrospectiveFor` on the next run — the next retro had
+  // no dedup context and could re-save facts the prior pass already captured.
+  test("PRESERVES the most-recent retro per source even when older than the orphan cutoff", () => {
+    const now = Date.now();
+    injectedNowMinusOrphanAgeMs = now - ORPHAN_AGE_MS;
+    mockConversations = [
+      {
+        id: "successful-retro",
+        source: "memory-retrospective",
+        last_message_at: now - 2 * ORPHAN_AGE_MS,
+        fork_parent_conversation_id: "source-A",
+        created_at: now - 2 * ORPHAN_AGE_MS,
       },
     ];
     rebuildActiveJobSet();

package/src/memory/__tests__/message-content.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test";
+
+import { stringifyMessageContent } from "../message-content.js";
+
+describe("stringifyMessageContent", () => {
+  test("returns trimmed raw text for legacy plain-string rows", () => {
+    expect(stringifyMessageContent("  hello world  ")).toBe("hello world");
+  });
+
+  test("returns trimmed inner string when JSON parses to a string", () => {
+    expect(stringifyMessageContent(JSON.stringify("  inner  "))).toBe("inner");
+  });
+
+  test("concatenates text blocks from a ContentBlock[] payload", () => {
+    const raw = JSON.stringify([
+      { type: "text", text: "alpha" },
+      { type: "tool_use", id: "x", name: "noop", input: {} },
+      { type: "text", text: "beta" },
+    ]);
+    expect(stringifyMessageContent(raw)).toBe("alpha\nbeta");
+  });
+
+  test("falls back to raw trimmed text when JSON parses to a non-array object", () => {
+    const raw = '  {"type":"text","text":"hi"}  ';
+    expect(stringifyMessageContent(raw)).toBe('{"type":"text","text":"hi"}');
+  });
+
+  test("falls back to raw trimmed text when JSON parses to a number", () => {
+    expect(stringifyMessageContent("  42  ")).toBe("42");
+  });
+
+  test("returns trimmed raw text when JSON parsing fails", () => {
+    expect(stringifyMessageContent("  not json  ")).toBe("not json");
+  });
+});

package/src/memory/bookmark-crud.ts

@@ -106,22 +106,51 @@ export function listBookmarks(db: DrizzleDb): BookmarkSummary[] {
 }
 
 /**
- * Create a bookmark for the given message and return its JOIN-shaped
- * {@link BookmarkSummary}. Idempotent on the unique `message_id` index —
- * if a bookmark already exists for `messageId`, the existing summary is
- * returned and no new row is inserted.
+ * Discriminated result returned by {@link createBookmark}. `inserted`
+ * distinguishes a brand-new row from an idempotent return of an existing
+ * one, so callers can suppress side effects (e.g. `bookmark.created` SSE
+ * publishes) on duplicate POSTs.
+ */
+export type CreateBookmarkResult =
+  | { inserted: true; bookmark: BookmarkSummary }
+  | { inserted: false; bookmark: BookmarkSummary };
+
+/**
+ * Create a bookmark for the given message and return a discriminated
+ * result indicating whether a new row was actually inserted. Idempotent
+ * on the unique `message_id` index — if a bookmark already exists for
+ * `messageId`, the existing summary is returned with `inserted: false`.
+ *
+ * `conversationId` is derived from the message row rather than trusted from
+ * the caller, so a buggy or malicious caller cannot persist a bookmark
+ * whose `conversationId` disagrees with the message's actual conversation.
  */
 export function createBookmark(
   db: DrizzleDb,
-  params: { messageId: string; conversationId: string },
-): BookmarkSummary {
-  const { messageId, conversationId } = params;
+  params: { messageId: string },
+): CreateBookmarkResult {
+  const { messageId } = params;
+  const message = db
+    .select({ conversationId: messages.conversationId })
+    .from(messages)
+    .where(eq(messages.id, messageId))
+    .get();
+  if (!message) {
+    throw new Error(`Message ${messageId} not found`);
+  }
+  const conversationId = message.conversationId;
+
   const existing = db
     .select({ id: messageBookmarks.id })
     .from(messageBookmarks)
     .where(eq(messageBookmarks.messageId, messageId))
     .get();
-  if (existing) return readBookmarkSummaryOrThrow(db, existing.id);
+  if (existing) {
+    return {
+      inserted: false,
+      bookmark: readBookmarkSummaryOrThrow(db, existing.id),
+    };
+  }
 
   const id = uuid();
   try {
@@ -137,9 +166,12 @@ export function createBookmark(
       .where(eq(messageBookmarks.messageId, messageId))
       .get();
     if (!winner) throw err;
-    return readBookmarkSummaryOrThrow(db, winner.id);
+    return {
+      inserted: false,
+      bookmark: readBookmarkSummaryOrThrow(db, winner.id),
+    };
   }
-  return readBookmarkSummaryOrThrow(db, id);
+  return { inserted: true, bookmark: readBookmarkSummaryOrThrow(db, id) };
 }
 
 function readBookmarkSummaryOrThrow(

package/src/memory/context-search/sources/conversations.ts

@@ -1,7 +1,12 @@
+import { readSlackMetadata } from "../../../messaging/providers/slack/message-metadata.js";
+import {
+  parseExternalContentEnvelope,
+  wrapUntrustedContent,
+} from "../../../security/untrusted-content.js";
 import { AUTO_ANALYSIS_SOURCE } from "../../auto-analysis-guard.js";
 import {
-  buildExcerpt,
   buildFtsMatchQuery,
+  buildRecallEvidenceExcerpt,
 } from "../../conversation-queries.js";
 import { rawAll } from "../../raw-query.js";
 import type { RecallSearchContext, RecallSearchResult } from "../types.js";
@@ -15,6 +20,7 @@ interface ConversationEvidenceRow {
   role: string;
   content: string;
   created_at: number;
+  metadata: string | null;
   title: string | null;
 }
 
@@ -118,7 +124,7 @@ export async function searchConversationSource(
       source: "conversations",
       title: row.title?.trim() || "Untitled conversation",
       locator: `${row.conversation_id}#${row.message_id}`,
-      excerpt: buildExcerpt(row.content, trimmedQuery),
+      excerpt: buildRecallExcerpt(row, trimmedQuery),
       timestampMs: row.created_at,
       score,
       metadata: {
@@ -142,6 +148,7 @@ function searchWithFts(
       m.role,
       m.content,
       m.created_at,
+      m.metadata,
       c.title
     FROM messages_fts
     JOIN messages m ON m.id = messages_fts.message_id
@@ -175,6 +182,7 @@ function searchWithLike(
       m.role,
       m.content,
       m.created_at,
+      m.metadata,
       c.title
     FROM messages m
     JOIN conversations c ON c.id = m.conversation_id
@@ -194,6 +202,58 @@ function searchWithLike(
   );
 }
 
+function buildRecallExcerpt(
+  row: ConversationEvidenceRow,
+  query: string,
+): string {
+  const excerpt = buildRecallEvidenceExcerpt(row.content, query);
+  const slackMeta = parseSlackRecallMetadata(row.metadata);
+  if (
+    row.role !== "user" ||
+    !slackMeta ||
+    slackMeta.provenanceTrustClass === "guardian" ||
+    excerpt.length === 0 ||
+    parseExternalContentEnvelope(excerpt)
+  ) {
+    return excerpt;
+  }
+
+  return wrapUntrustedContent(excerpt, {
+    source: "slack",
+    ...(slackMeta.displayName ? { sourceDetail: slackMeta.displayName } : {}),
+  });
+}
+
+function parseSlackRecallMetadata(rawMetadata: string | null): {
+  displayName?: string;
+  provenanceTrustClass?: string;
+} | null {
+  if (!rawMetadata) return null;
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(rawMetadata);
+  } catch {
+    return null;
+  }
+
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null;
+  }
+
+  const metadata = parsed as Record<string, unknown>;
+  if (typeof metadata.slackMeta !== "string") return null;
+  const slackMeta = readSlackMetadata(metadata.slackMeta);
+  if (!slackMeta) return null;
+
+  return {
+    ...(slackMeta.displayName ? { displayName: slackMeta.displayName } : {}),
+    ...(typeof metadata.provenanceTrustClass === "string"
+      ? { provenanceTrustClass: metadata.provenanceTrustClass }
+      : {}),
+  };
+}
+
 function buildRecallFtsMatchQueries(query: string): string[] {
   const queries: string[] = [];
   const exact = buildFtsMatchQuery(query);

package/src/memory/context-search/sources/workspace.ts

@@ -68,6 +68,9 @@ const SECRET_SEGMENT_NAMES = new Set([
 const SECRET_TOKEN_PATTERN =
   /(?:^|[-_.])(?:keys?|secrets?|tokens?)(?:[-_.]|$)/i;
 
+const SECRET_TOKEN_CAMEL_CASE_PATTERN =
+  /(?<=[a-z0-9])(?:Keys?|Secrets?|Tokens?)(?=[A-Z]|[-_.]|$)/;
+
 const QUERY_STOP_WORDS = new Set([
   "a",
   "about",
@@ -1185,6 +1188,7 @@ function shouldSkipSegmentName(name: string): boolean {
     GENERATED_OR_DEPENDENCY_DIR_NAMES.has(lowerName) ||
     lowerName.startsWith(".env") ||
     SECRET_TOKEN_PATTERN.test(lowerName) ||
+    SECRET_TOKEN_CAMEL_CASE_PATTERN.test(name) ||
     lowerName.startsWith("credentials") ||
     SECRET_SEGMENT_NAMES.has(lowerName)
   );

package/src/memory/conversation-crud.ts

@@ -14,6 +14,7 @@ import {
   like,
   lt,
   lte,
+  or,
   sql,
 } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
@@ -86,6 +87,7 @@ const subagentNotificationSchema = z.object({
   status: z.enum(["running", "completed", "failed", "aborted"]),
   error: z.string().optional(),
   conversationId: z.string().optional(),
+  objective: z.string().optional(),
 });
 
 export const messageMetadataSchema = z
@@ -94,6 +96,16 @@ export const messageMetadataSchema = z
     assistantMessageChannel: channelIdSchema.optional(),
     userMessageInterface: interfaceIdSchema.optional(),
     assistantMessageInterface: interfaceIdSchema.optional(),
+    /**
+     * Optional client-side metadata bag attached to user messages by HTTP
+     * header middleware (reads `x-vellum-browser-family`,
+     * `x-vellum-browser-version`, `x-vellum-client-os`,
+     * `x-vellum-interface-version`). Forwarded verbatim onto
+     * `TurnTelemetryEvent.client` for downstream analytics. Kept as a
+     * permissive `record` so adding a new client field doesn't require a
+     * migration -- dbt can unpack later via JSON_VALUE.
+     */
+    client: z.record(z.string(), z.unknown()).optional(),
     subagentNotification: subagentNotificationSchema.optional(),
     /**
      * Trust class of the actor at the time this message was persisted.
@@ -727,9 +739,14 @@ export function forkConversation(params: {
 
     // Carry the parent's per-conversation memory state into the child so the
     // forked thread resumes with the same activation/injection log and
-    // in-context tracker the parent had at fork time.
-    forkActivationState(db, sourceConversation.id, fc.id);
-    forkGraphMemoryState(sourceConversation.id, fc.id);
+    // in-context tracker the parent had at fork time. Only valid for
+    // full-history forks: a truncated fork would inherit activation/tracker
+    // entries for turns the child does not actually contain.
+    const isFullHistoryFork = copyBoundaryIndex === sourceMessages.length - 1;
+    if (isFullHistoryFork) {
+      forkActivationState(db, sourceConversation.id, fc.id);
+      forkGraphMemoryState(sourceConversation.id, fc.id);
+    }
     forkRetrospectiveState({
       database: db,
       sourceConversationId: sourceConversation.id,
@@ -1040,22 +1057,23 @@ export function getMessages(conversationId: string): MessageRow[] {
 }
 
 /**
- * Return raw `metadata` strings for messages whose metadata contains the
- * literal substring `"slackMeta"`, capped at `limit` and skipping the first
- * `offset` matches. Pushes `LIKE` + `LIMIT`/`OFFSET` into SQL so warm Slack
- * DM conversations don't require a full-table scan on the webhook critical
- * path. The substring match is an indexable prefilter only — callers must
- * parse and validate each returned string against the Slack metadata schema,
- * because a malformed row (partial write, legacy format, unrelated key
- * accidentally containing the literal) can still slip through the substring
- * match. Callers that need a fixed number of *valid* rows should iterate
- * with increasing offsets until the target is reached (capped at a
- * reasonable maximum to bound scan cost).
+ * Return raw `metadata` strings for messages whose metadata looks like it may
+ * contain Slack metadata, capped at `limit` and skipping the first `offset`
+ * matches. Pushes `LIKE` + `LIMIT`/`OFFSET` into SQL so warm Slack DM
+ * conversations don't require a full-table scan on the webhook critical path.
+ * The substring match is an indexable prefilter only — callers must parse and
+ * validate each returned string against the Slack metadata schema, because a
+ * malformed row (partial write, legacy format, unrelated key accidentally
+ * containing the literal) can still slip through the substring match. Callers
+ * that need a fixed number of *valid* rows should iterate with increasing
+ * offsets until the target is reached (capped at a reasonable maximum to bound
+ * scan cost).
  */
 export function selectSlackMetaCandidateMetadata(
   conversationId: string,
   limit: number,
   offset = 0,
+  opts?: { includeFlatLegacy?: boolean },
 ): string[] {
   const db = getDb();
   const rows = db
@@ -1064,7 +1082,12 @@ export function selectSlackMetaCandidateMetadata(
     .where(
       and(
         eq(messages.conversationId, conversationId),
-        like(messages.metadata, '%"slackMeta"%'),
+        opts?.includeFlatLegacy
+          ? or(
+              like(messages.metadata, '%"slackMeta"%'),
+              like(messages.metadata, '%"source":"slack"%'),
+            )
+          : like(messages.metadata, '%"slackMeta"%'),
       ),
     )
     .orderBy(asc(messages.createdAt))
@@ -1110,13 +1133,23 @@ export function countMessagesAfter(
     .where(eq(messages.id, afterMessageId))
     .get();
   if (!ref) return 0;
+  // Tie-breaker on `messages.id` so rows that share a millisecond timestamp
+  // with the reference are not permanently skipped. Mirrors the
+  // `(createdAt, id)` cursor pattern used by the backfill job-handler and
+  // turn-events-store.
   const row = db
     .select({ c: count() })
     .from(messages)
     .where(
       and(
         eq(messages.conversationId, conversationId),
-        gt(messages.createdAt, ref.createdAt),
+        or(
+          gt(messages.createdAt, ref.createdAt),
+          and(
+            eq(messages.createdAt, ref.createdAt),
+            gt(messages.id, afterMessageId),
+          ),
+        ),
       ),
     )
     .get();
@@ -1136,11 +1169,14 @@ export function getMessagesAfter(
 ): MessageRow[] {
   const db = getDb();
   if (afterMessageId === null || afterMessageId === "") {
+    // Secondary `asc(messages.id)` matches the non-null path's cursor
+    // ordering, so callers tracking `cutoffMessageId` across runs see a
+    // consistent ordering when multiple rows share a millisecond timestamp.
     return db
       .select()
       .from(messages)
       .where(eq(messages.conversationId, conversationId))
-      .orderBy(asc(messages.createdAt))
+      .orderBy(asc(messages.createdAt), asc(messages.id))
       .all()
       .map(parseMessage);
   }
@@ -1150,16 +1186,24 @@ export function getMessagesAfter(
     .where(eq(messages.id, afterMessageId))
     .get();
   if (!ref) return [];
+  // Same `(createdAt, id)` cursor as `countMessagesAfter` — rows sharing
+  // the reference's millisecond timestamp would otherwise be skipped.
   return db
     .select()
     .from(messages)
     .where(
       and(
         eq(messages.conversationId, conversationId),
-        gt(messages.createdAt, ref.createdAt),
+        or(
+          gt(messages.createdAt, ref.createdAt),
+          and(
+            eq(messages.createdAt, ref.createdAt),
+            gt(messages.id, afterMessageId),
+          ),
+        ),
       ),
     )
-    .orderBy(asc(messages.createdAt))
+    .orderBy(asc(messages.createdAt), asc(messages.id))
     .all()
     .map(parseMessage);
 }