@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/persistence/llm-request-log-sink-clickhouse.ts

@@ -30,6 +30,7 @@
  * can never abort a turn.
  */
 import { getConfigReadOnly } from "../config/loader.js";
+import { resolvePlatformAssistantIdOrNull } from "../config/platform-identity.js";
 import type { LlmRequestLogsClickHouseConfig } from "../config/schemas/llm-request-logs.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
@@ -71,7 +72,7 @@ export interface ClickHouseLlmRequestLogSinkDeps {
   resolveUrl?: () => Promise<string | null>;
   /** Override the credential read for `clickhouse:password`. */
   resolvePassword?: () => Promise<string | null>;
-  /** Override the credential read for `vellum:platform_assistant_id`. */
+  /** Override the in-memory platform assistant id. */
   resolveAssistantId?: () => Promise<string | null>;
   /** Override fetch for testing. */
   fetchImpl?: ClickHouseSinkFetch;
@@ -98,8 +99,7 @@ export class ClickHouseLlmRequestLogSink implements LlmRequestLogWriter {
       deps.resolvePassword ??
       (() => readCredentialOrNull("clickhouse", "password"));
     this.resolveAssistantId =
-      deps.resolveAssistantId ??
-      (() => readCredentialOrNull("vellum", "platform_assistant_id"));
+      deps.resolveAssistantId ?? resolvePlatformAssistantIdOrNull;
     this.fetchImpl = deps.fetchImpl ?? globalThis.fetch.bind(globalThis);
   }
 

package/src/persistence/llm-request-log-source-clickhouse.ts

@@ -15,6 +15,7 @@
  * than the local source. Acceptable for the "internal use while we
  * finetune prompts" use case; revisit when mirror updates are added.
  */
+import { resolvePlatformAssistantIdOrNull } from "../config/platform-identity.js";
 import type { LlmRequestLogsClickHouseConfig } from "../config/schemas/llm-request-logs.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
@@ -104,7 +105,7 @@ export interface ClickHouseLlmRequestLogSourceDeps {
   resolveUrl?: () => Promise<string | null>;
   /** Override the credential read for `clickhouse:password`. */
   resolvePassword?: () => Promise<string | null>;
-  /** Override the credential read for `vellum:platform_assistant_id`. */
+  /** Override the in-memory platform assistant id. */
   resolveAssistantId?: () => Promise<string | null>;
   /** Override the turn-id resolver (default: `getAssistantMessageIdsInTurn`). */
   resolveTurnMessageIds?: (messageId: string) => string[];
@@ -138,8 +139,7 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
       deps.resolvePassword ??
       (() => readCredentialOrNull("clickhouse", "password"));
     this.resolveAssistantId =
-      deps.resolveAssistantId ??
-      (() => readCredentialOrNull("vellum", "platform_assistant_id"));
+      deps.resolveAssistantId ?? resolvePlatformAssistantIdOrNull;
     this.resolveTurnMessageIds =
       deps.resolveTurnMessageIds ?? getAssistantMessageIdsInTurn;
     this.resolveMessage = deps.resolveMessage ?? getMessageById;

package/src/persistence/message-cursor.ts

@@ -0,0 +1,78 @@
+// ---------------------------------------------------------------------------
+// Message cursors: the "(createdAt, id) after which" reference behind the
+// messages-after reads, resilient to the referenced row being deleted.
+// ---------------------------------------------------------------------------
+//
+// A bare message id bounds a read only while its row exists. A regenerated
+// reply (the conversation retry route discards the latest assistant turn) or a
+// retried turn deletes the row, and a caller holding just the id can no longer
+// say where it sat. A `MessageCursor` carries the row's `createdAt` alongside
+// its id, so the `(createdAt, id)` bound is reconstructible from the cursor
+// alone. The live row stays authoritative whenever it exists.
+
+import { eq } from "drizzle-orm";
+
+import type { LineageBound } from "./conversation-lineage.js";
+import { getDb } from "./db-connection.js";
+import { messages } from "./schema/index.js";
+
+export { messagesAfterBoundFilter } from "./conversation-lineage.js";
+
+/**
+ * A `(createdAt, id)` message reference. `createdAt` is null when the holder
+ * never recorded it; such a cursor bounds a read only while its row exists.
+ */
+export interface MessageCursor {
+  readonly id: string;
+  readonly createdAt: number | null;
+}
+
+/**
+ * Accepted "after" references: a message id, a {@link MessageCursor}, or
+ * null. `null`, `""`, and a cursor whose id is `""` all mean "no lower bound".
+ */
+export type MessagesAfterRef = string | MessageCursor | null;
+
+/** Where a messages-after read starts. */
+export type MessagesAfterBound =
+  /** No lower bound: every row the conversation owns. */
+  | { kind: "all" }
+  /** Rows strictly after `bound` in `(createdAt, id)` order. */
+  | { kind: "after"; bound: LineageBound }
+  /**
+   * The referenced row is gone and the reference carried no timestamp, so
+   * the read has no defensible starting point. Readers return nothing.
+   */
+  | { kind: "vanished" };
+
+/** The `(createdAt, id)` bound of a single message, or null when it is gone. */
+export function loadMessageBound(messageId: string): LineageBound | null {
+  const row = getDb()
+    .select({ createdAt: messages.createdAt, id: messages.id })
+    .from(messages)
+    .where(eq(messages.id, messageId))
+    .get();
+  return row ?? null;
+}
+
+/**
+ * Resolve an "after" reference to the bound a read filters on. A live row
+ * wins; a cursor whose row is gone falls back to the `createdAt` it carries,
+ * paired with its id so same-millisecond neighbours keep their order.
+ */
+export function resolveMessagesAfterBound(
+  after: MessagesAfterRef,
+): MessagesAfterBound {
+  const id = typeof after === "string" ? after : (after?.id ?? "");
+  if (id === "") {
+    return { kind: "all" };
+  }
+  const live = loadMessageBound(id);
+  if (live) {
+    return { kind: "after", bound: live };
+  }
+  if (typeof after === "object" && after !== null && after.createdAt !== null) {
+    return { kind: "after", bound: { createdAt: after.createdAt, id } };
+  }
+  return { kind: "vanished" };
+}

package/src/persistence/message-reads.ts

@@ -190,6 +190,36 @@ export function existingMessageIds(
   );
 }
 
+/**
+ * `createdAt` of each of `messageIds` that exists as a row, keyed by id, in
+ * any state.
+ *
+ * Any-state deliberately: a row's `createdAt` is fixed at insert, so its
+ * completeness does not change the answer, and the callers (retrospective
+ * cursor bookkeeping) hold ids taken from rows they have already reviewed.
+ * An empty input returns an empty map without querying.
+ */
+export function messageCreatedAtByIds(
+  messageIds: readonly string[],
+  opts?: { db?: MessageReadHandle },
+): Map<string, number> {
+  const db = opts?.db ?? getDb();
+  const result = new Map<string, number>();
+  // Chunked so a whole-conversation id list stays under SQLite's bound
+  // parameter limit.
+  for (let offset = 0; offset < messageIds.length; offset += 500) {
+    const rows = db
+      .select({ id: messages.id, createdAt: messages.createdAt })
+      .from(messages)
+      .where(inArray(messages.id, messageIds.slice(offset, offset + 500)))
+      .all();
+    for (const row of rows) {
+      result.set(row.id, row.createdAt);
+    }
+  }
+  return result;
+}
+
 /**
  * The conversation that owns `messageId`, in any state, or null when the
  * message does not exist.

package/src/persistence/migrations/157-invite-contact-id.ts

@@ -1,4 +1,5 @@
 import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { tableExists } from "./schema-introspection.js";
 
 /**
  * Add a required contact_id column to assistant_ingress_invites.
@@ -10,8 +11,16 @@ import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
  *  1. Add the column as nullable.
  *  2. Delete legacy rows that have no contact binding (NULL).
  *  3. Rebuild the table to enforce NOT NULL (SQLite cannot ALTER COLUMN).
+ *
+ * The rebuild copies whichever session-id column is live:
+ * `source_conversation_id` (after migrateRenameCreatedBySessionIdColumns)
+ * or `created_by_session_id`.
  */
 export function migrateInviteContactId(database: DrizzleDb): void {
+  if (!tableExists(database, "assistant_ingress_invites")) {
+    return;
+  }
+
   const raw = getSqliteFrom(database);
 
   const cols = (
@@ -20,25 +29,28 @@ export function migrateInviteContactId(database: DrizzleDb): void {
       notnull: number;
     }>
   ).map((c) => ({ name: c.name, notnull: c.notnull }));
+  const colNames = new Set(cols.map((c) => c.name));
 
   const col = cols.find((c) => c.name === "contact_id");
 
-  // Step 1: Add the column as nullable
   if (!col) {
     raw.exec(
       /*sql*/ `ALTER TABLE assistant_ingress_invites ADD COLUMN contact_id TEXT`,
     );
   }
 
-  // Step 2: Delete legacy rows with no contact binding
   raw.exec(
     /*sql*/ `DELETE FROM assistant_ingress_invites WHERE contact_id IS NULL OR contact_id = ''`,
   );
 
-  // Step 3: Rebuild the table with NOT NULL on contact_id
   if (col && col.notnull === 1) {
     return;
-  } // already NOT NULL
+  }
+
+  const sessionCol = colNames.has("source_conversation_id")
+    ? "source_conversation_id"
+    : "created_by_session_id";
+  const sessionSelect = colNames.has(sessionCol) ? sessionCol : "NULL";
 
   raw.exec("PRAGMA foreign_keys = OFF");
   try {
@@ -49,7 +61,7 @@ export function migrateInviteContactId(database: DrizzleDb): void {
           id TEXT PRIMARY KEY,
           source_channel TEXT NOT NULL,
           token_hash TEXT NOT NULL,
-          created_by_session_id TEXT,
+          ${sessionCol} TEXT,
           note TEXT,
           max_uses INTEGER NOT NULL DEFAULT 1 CHECK (max_uses > 0),
           use_count INTEGER NOT NULL DEFAULT 0 CHECK (use_count >= 0),
@@ -70,7 +82,7 @@ export function migrateInviteContactId(database: DrizzleDb): void {
         );
 
         INSERT INTO assistant_ingress_invites_new
-        SELECT id, source_channel, token_hash, created_by_session_id, note,
+        SELECT id, source_channel, token_hash, ${sessionSelect}, note,
                max_uses, use_count, expires_at, status,
                redeemed_by_external_user_id, redeemed_by_external_chat_id,
                redeemed_at, expected_external_user_id, voice_code_hash,

package/src/persistence/migrations/__tests__/157-invite-contact-id.test.ts

@@ -0,0 +1,149 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../../db-connection.js";
+import * as schema from "../../schema.js";
+import { migrateInviteContactId } from "../157-invite-contact-id.js";
+import { tableExists, tableHasColumn } from "../schema-introspection.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  return drizzle(sqlite, { schema });
+}
+
+function columnNotNull(raw: Database, name: string): boolean {
+  const cols = raw.query(`PRAGMA table_info(assistant_ingress_invites)`).all() as Array<{
+    name: string;
+    notnull: number;
+  }>;
+  return cols.some((c) => c.name === name && c.notnull === 1);
+}
+
+describe("migrateInviteContactId", () => {
+  test("rebuilds a legacy created_by_session_id table with NOT NULL contact_id", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    raw.exec(/*sql*/ `
+      CREATE TABLE assistant_ingress_invites (
+        id TEXT PRIMARY KEY,
+        source_channel TEXT NOT NULL,
+        token_hash TEXT NOT NULL,
+        created_by_session_id TEXT,
+        note TEXT,
+        max_uses INTEGER NOT NULL DEFAULT 1,
+        use_count INTEGER NOT NULL DEFAULT 0,
+        expires_at INTEGER NOT NULL,
+        status TEXT NOT NULL DEFAULT 'active',
+        redeemed_by_external_user_id TEXT,
+        redeemed_by_external_chat_id TEXT,
+        redeemed_at INTEGER,
+        expected_external_user_id TEXT,
+        voice_code_hash TEXT,
+        voice_code_digits INTEGER,
+        invite_code_hash TEXT,
+        friend_name TEXT,
+        guardian_name TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+    raw.run(
+      `INSERT INTO assistant_ingress_invites
+         (id, source_channel, token_hash, created_by_session_id, max_uses, use_count,
+          expires_at, status, created_at, updated_at)
+       VALUES ('inv-keep', 'slack', 'hash-keep', 'conv-1', 1, 0, 9, 'active', 1, 1)`,
+    );
+    raw.exec(
+      `ALTER TABLE assistant_ingress_invites ADD COLUMN contact_id TEXT`,
+    );
+    raw.run(
+      `UPDATE assistant_ingress_invites SET contact_id = 'contact-keep' WHERE id = 'inv-keep'`,
+    );
+    raw.run(
+      `INSERT INTO assistant_ingress_invites
+         (id, source_channel, token_hash, max_uses, use_count, expires_at, status,
+          created_at, updated_at)
+       VALUES ('inv-drop', 'slack', 'hash-drop', 1, 0, 9, 'active', 1, 1)`,
+    );
+
+    migrateInviteContactId(db);
+
+    expect(tableHasColumn(db, "assistant_ingress_invites", "contact_id")).toBe(
+      true,
+    );
+    expect(columnNotNull(raw, "contact_id")).toBe(true);
+    expect(
+      tableHasColumn(db, "assistant_ingress_invites", "created_by_session_id"),
+    ).toBe(true);
+    const rows = raw
+      .query(`SELECT id, contact_id FROM assistant_ingress_invites ORDER BY id`)
+      .all() as Array<{ id: string; contact_id: string }>;
+    expect(rows).toEqual([{ id: "inv-keep", contact_id: "contact-keep" }]);
+  });
+
+  test("rebuilds after created_by_session_id was renamed to source_conversation_id", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    raw.exec(/*sql*/ `
+      CREATE TABLE assistant_ingress_invites (
+        id TEXT PRIMARY KEY,
+        source_channel TEXT NOT NULL,
+        token_hash TEXT NOT NULL,
+        source_conversation_id TEXT,
+        note TEXT,
+        max_uses INTEGER NOT NULL DEFAULT 1,
+        use_count INTEGER NOT NULL DEFAULT 0,
+        expires_at INTEGER NOT NULL,
+        status TEXT NOT NULL DEFAULT 'active',
+        redeemed_by_external_user_id TEXT,
+        redeemed_by_external_chat_id TEXT,
+        redeemed_at INTEGER,
+        expected_external_user_id TEXT,
+        voice_code_hash TEXT,
+        voice_code_digits INTEGER,
+        invite_code_hash TEXT,
+        friend_name TEXT,
+        guardian_name TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+    raw.exec(
+      `ALTER TABLE assistant_ingress_invites ADD COLUMN contact_id TEXT`,
+    );
+    raw.run(
+      `INSERT INTO assistant_ingress_invites
+         (id, source_channel, token_hash, source_conversation_id, contact_id,
+          max_uses, use_count, expires_at, status, created_at, updated_at)
+       VALUES ('inv-1', 'slack', 'hash-1', 'conv-9', 'contact-1', 1, 0, 9, 'active', 1, 1)`,
+    );
+
+    migrateInviteContactId(db);
+
+    expect(columnNotNull(raw, "contact_id")).toBe(true);
+    expect(
+      tableHasColumn(db, "assistant_ingress_invites", "source_conversation_id"),
+    ).toBe(true);
+    expect(
+      tableHasColumn(db, "assistant_ingress_invites", "created_by_session_id"),
+    ).toBe(false);
+    const row = raw
+      .query(
+        `SELECT source_conversation_id, contact_id FROM assistant_ingress_invites WHERE id = 'inv-1'`,
+      )
+      .get() as { source_conversation_id: string; contact_id: string };
+    expect(row).toEqual({
+      source_conversation_id: "conv-9",
+      contact_id: "contact-1",
+    });
+  });
+
+  test("is a no-op when the table does not exist", () => {
+    const db = createTestDb();
+    migrateInviteContactId(db);
+    expect(tableExists(db, "assistant_ingress_invites")).toBe(false);
+  });
+});

package/src/persistence/schema/memory-core.ts

@@ -104,6 +104,11 @@ export const memoryRetrospectiveState = sqliteTable(
     conversationId: text("conversation_id").primaryKey(),
     lastProcessedMessageId: text("last_processed_message_id").notNull(),
     lastRunAt: integer("last_run_at").notNull(),
+    // `createdAt` of the `last_processed_message_id` row when the pointer was
+    // written, so the cursor still bounds reads after that row is deleted.
+    // NULL when unknown. Added lazily by `ensureRetrospectiveCursorColumn`
+    // (memory-retrospective-state.ts), not by the migration chain.
+    lastProcessedCreatedAt: integer("last_processed_created_at"),
     // JSON array of strings — cumulative `remember` contents from prior
     // retrospective passes (capped; see memory-retrospective-state.ts).
     // NULL for rows that predate migration 281 or have no saves yet.

package/src/platform/client.test.ts

@@ -24,7 +24,9 @@ mock.module("../providers/platform-proxy/context.js", () => ({
   resolveManagedProxyContext: () => mockResolveManagedProxyContext(),
 }));
 
+const actualEnv = await import("../config/env.js");
 mock.module("../config/env.js", () => ({
+  ...actualEnv,
   getPlatformAssistantId: () => mockAssistantId,
 }));
 
@@ -113,11 +115,11 @@ describe("VellumPlatformClient", () => {
         platformBaseUrl: "",
         assistantApiKey: "",
       };
-      mockAssistantId = "";
+      mockAssistantId = "stored-assistant-id";
       mockSecureKeys = {
         "vellum:platform_base_url": "https://stored-platform.example.com/",
         "vellum:assistant_api_key": "stored-api-key",
-        "vellum:platform_assistant_id": " stored-assistant-id ",
+        "vellum:platform_assistant_id": " vault-assistant-id ",
       };
 
       const client = await VellumPlatformClient.create();

package/src/platform/client.ts

@@ -7,7 +7,7 @@
 
 import type { PlatformCredentialVerificationStatus } from "@vellumai/service-contracts/platform-credential";
 
-import { getPlatformAssistantId } from "../config/env.js";
+import { resolvePlatformAssistantId } from "../config/platform-identity.js";
 import { resolveManagedProxyContext } from "../providers/platform-proxy/context.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
@@ -63,7 +63,7 @@ async function resolvePlatformClientConfig(): Promise<PlatformClientConfig | nul
 
   let baseUrl = ctx.enabled ? ctx.platformBaseUrl : "";
   let apiKey = ctx.enabled ? ctx.assistantApiKey : "";
-  let assistantId = getPlatformAssistantId();
+  const assistantId = await resolvePlatformAssistantId();
 
   // Fall back to credential store for values not yet rehydrated (standalone CLI).
   if (!baseUrl) {
@@ -76,14 +76,6 @@ async function resolvePlatformClientConfig(): Promise<PlatformClientConfig | nul
       (await getSecureKeyAsync(credentialKey("vellum", "assistant_api_key"))) ??
       "";
   }
-  if (!assistantId) {
-    assistantId =
-      (
-        await getSecureKeyAsync(
-          credentialKey("vellum", "platform_assistant_id"),
-        )
-      )?.trim() ?? "";
-  }
 
   if (!baseUrl || !apiKey) {
     const level = _missingPrereqsWarned ? "debug" : "warn";

package/src/plugin-api/constants.ts

@@ -34,6 +34,8 @@ export const HOOKS = {
   CONVERSATION_DELETED: "conversation-deleted",
   /** Fires once when every conversation is wiped at once (the clear-all reset), after the main tables are cleared. Carries no `conversationId`; cleanup hooks wipe their own per-conversation state wholesale. */
   CONVERSATIONS_CLEARED: "conversations-cleared",
+  /** Fires once per deleted message row, after the row is removed, carrying the row's `(createdAt, id)` so a hook can settle state that pointed at it. Fire-and-forget cleanup signal, like `conversation-deleted`; whole-conversation deletes dispatch that hook instead. */
+  MESSAGE_DELETED: "message-deleted",
 } as const;
 
 /** Union of every hook name declared in {@link HOOKS}. */

package/src/plugin-api/index.ts

@@ -110,6 +110,7 @@ export type {
   HookBroadcast,
   HookFunction,
   InitContext,
+  MessageDeletedContext,
   ModelProfileInfo,
   PluginLogger,
   PostCompactContext,

package/src/plugin-api/types.ts

@@ -16,6 +16,7 @@ export type {
   ConversationDeletedContext,
   ConversationsClearedContext,
   HookBroadcast,
+  MessageDeletedContext,
   PluginLogger,
   PostCompactContext,
   PostModelCallContext,
@@ -60,6 +61,7 @@ export type {
  *   - `post-model-call` — {@link PostModelCallContext}
  *   - `conversation-deleted` — {@link ConversationDeletedContext}
  *   - `conversations-cleared` — {@link ConversationsClearedContext}
+ *   - `message-deleted`: {@link MessageDeletedContext}
  */
 export type HookFunction<TCtx = unknown> = (
   ctx: TCtx,

package/src/plugins/defaults/index.ts

@@ -65,6 +65,7 @@ import maxTokensContinuePkg from "./max-tokens-continue/package.json" with { typ
 import memoryConversationDeleted from "./memory/hooks/conversation-deleted.js";
 import memoryConversationsCleared from "./memory/hooks/conversations-cleared.js";
 import memoryInit from "./memory/hooks/init.js";
+import memoryMessageDeleted from "./memory/hooks/message-deleted.js";
 import memoryPostCompact from "./memory/hooks/post-compact.js";
 import memoryShutdown from "./memory/hooks/shutdown.js";
 import memoryUserPromptSubmit from "./memory/hooks/user-prompt-submit.js";
@@ -199,6 +200,7 @@ export const defaultMemoryPlugin: Plugin = {
     "post-compact": memoryPostCompact,
     "conversation-deleted": memoryConversationDeleted,
     "conversations-cleared": memoryConversationsCleared,
+    "message-deleted": memoryMessageDeleted,
   },
   injectors: memoryInjectors,
 };

package/src/plugins/defaults/memory/__tests__/memory-retrospective-accounting.test.ts

@@ -434,3 +434,49 @@ describe("ambient camera frames are not retrospective work", () => {
     expect(hasQualifyingUserMessageAfter(CONV, null)).toBe(true);
   });
 });
+
+describe("retrospective accounting: a cursor survives its row's deletion", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run(`DELETE FROM messages`);
+    db.run(`DELETE FROM conversations`);
+    createConversation({ id: CONV });
+  });
+
+  test("a deleted cursor row with a stored timestamp still bounds the count, the slice, and the user-activity probe", () => {
+    insertRaw({ role: "user", content: TEXT, createdAt: 1_000 });
+    const reply = insertRaw({
+      role: "assistant",
+      content: TEXT,
+      createdAt: 2_000,
+    });
+    // Regenerate: the reply the cursor sits on is discarded and replaced.
+    getDb().delete(messages).where(eq(messages.id, reply)).run();
+    const regenerated = insertRaw({
+      role: "assistant",
+      content: TEXT,
+      createdAt: 3_000,
+    });
+    const followUp = insertRaw({
+      role: "user",
+      content: TEXT,
+      createdAt: 4_000,
+    });
+
+    const cursor = { id: reply, createdAt: 2_000 };
+    expect(countRetrospectiveMessagesAfter(CONV, cursor)).toBe(2);
+    expect(
+      getRetrospectiveMessagesAfter(CONV, cursor).map((r) => r.id),
+    ).toEqual([regenerated, followUp]);
+    expect(hasQualifyingUserMessageAfter(CONV, cursor)).toBe(true);
+  });
+
+  test("a deleted cursor row without a timestamp still reads as no new work", () => {
+    insertRaw({ role: "user", content: TEXT, createdAt: 1_000 });
+
+    const cursor = { id: "gone", createdAt: null };
+    expect(countRetrospectiveMessagesAfter(CONV, cursor)).toBe(0);
+    expect(getRetrospectiveMessagesAfter(CONV, cursor)).toEqual([]);
+    expect(hasQualifyingUserMessageAfter(CONV, cursor)).toBe(false);
+  });
+});