@vellumai/assistant 0.8.3 → 0.8.4

package/src/memory/__tests__/memory-retrospective-job.test.ts

@@ -33,11 +33,52 @@ let priorRetroMessages: Array<{ role: string; content: string }> = [];
 
 let mockWakeResult: { invoked: boolean; reason?: string } = { invoked: true };
 let mockWakeThrows: Error | null = null;
-let wakeCalls: Array<{ conversationId: string; hint: string }> = [];
+let wakeCalls: Array<{
+  conversationId: string;
+  hint: string;
+  opts: Record<string, unknown>;
+}> = [];
 let bootstrappedConversationId = "bg-conv-new";
 let bootstrapCalls: Array<{ forkParentConversationId?: string }> = [];
 let deletedConversationIds: string[] = [];
 
+// Fork-path mocks. Flag off by default so legacy-path tests stay untouched.
+let forkFlagEnabled = false;
+let forkedConversationId = "fork-conv-1";
+let forkCalls: Array<{
+  conversationId: string;
+  throughMessageId?: string;
+  source: string;
+  title: string;
+  conversationType?: string;
+  groupId?: string;
+}> = [];
+let addMessageCalls: Array<{
+  conversationId: string;
+  role: string;
+  content: string;
+  metadata: unknown;
+}> = [];
+
+// Per-conversation overrides for getConversation. Lets fork-path tests stage
+// a fork-kind prior retrospective row alongside the default legacy stub.
+type ConversationStub = {
+  source: string;
+  forkParentMessageId: string | null;
+  title?: string;
+};
+let conversationOverrides: Record<string, ConversationStub> = {};
+
+// Per-conversation overrides for getMessages so fork-path tests can return
+// fork-shaped message rows (with metadata stamps + createdAt boundaries).
+type StubMessage = {
+  role: string;
+  content: string;
+  createdAt: number;
+  metadata: string | null;
+};
+let messagesByConversationId: Record<string, StubMessage[]> = {};
+
 mock.module("../memory-retrospective-state.js", () => ({
   getRetrospectiveState: (_id: string) => mockState,
   upsertRetrospectiveState: (args: {
@@ -55,16 +96,61 @@ mock.module("../memory-retrospective-state.js", () => ({
 mock.module("../conversation-crud.js", () => ({
   getMessagesAfter: (_id: string, _afterId: string | null) => newMessages,
   getMessages: (id: string) => {
+    if (messagesByConversationId[id]) return messagesByConversationId[id];
     if (id === priorRetroId) return priorRetroMessages;
     return [];
   },
   findMostRecentRetrospectiveFor: (_id: string) =>
     priorRetroId ? { id: priorRetroId } : null,
+  // The fork path calls `getConversation(sourceConversationId)` to read the
+  // source's title for the fork title. `collectPriorRetrospectiveRemembers`
+  // also calls it with the prior retro id to discriminate legacy vs fork
+  // sources — for that id return a legacy-shaped row by default so existing
+  // tests exercise the unchanged extract-everything code path.
+  // `conversationOverrides` lets per-test setup stage fork-kind priors.
+  getConversation: (id: string) => {
+    if (conversationOverrides[id]) return conversationOverrides[id];
+    if (id === priorRetroId) {
+      return {
+        source: "memory-retrospective",
+        forkParentMessageId: null,
+      };
+    }
+    return {
+      source: "user",
+      forkParentMessageId: null,
+      title: "Source conversation",
+    };
+  },
+  forkConversation: (params: {
+    conversationId: string;
+    throughMessageId?: string;
+    source: string;
+    title: string;
+    conversationType?: string;
+    groupId?: string;
+  }) => {
+    forkCalls.push(params);
+    return { id: forkedConversationId };
+  },
+  addMessage: async (
+    conversationId: string,
+    role: string,
+    content: string,
+    metadata: unknown,
+  ) => {
+    addMessageCalls.push({ conversationId, role, content, metadata });
+  },
   deleteConversation: (id: string) => {
     deletedConversationIds.push(id);
   },
 }));
 
+mock.module("../../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (flag: string) =>
+    flag === "memory-retrospective-fork" && forkFlagEnabled,
+}));
+
 let transcriptFormatterCalls: Array<{
   messageIds: string[];
   timeZone?: string;
@@ -117,11 +203,14 @@ mock.module("../../daemon/trust-context.js", () => ({
 }));
 
 mock.module("../../runtime/agent-wake.js", () => ({
-  wakeAgentForOpportunity: async (opts: {
-    conversationId: string;
-    hint: string;
-  }) => {
-    wakeCalls.push({ conversationId: opts.conversationId, hint: opts.hint });
+  wakeAgentForOpportunity: async (
+    opts: { conversationId: string; hint: string } & Record<string, unknown>,
+  ) => {
+    wakeCalls.push({
+      conversationId: opts.conversationId,
+      hint: opts.hint,
+      opts,
+    });
     if (mockWakeThrows) throw mockWakeThrows;
     return mockWakeResult;
   },
@@ -200,6 +289,12 @@ describe("memoryRetrospectiveJob", () => {
     transcriptFormatterCalls = [];
     mockAssistantName = "Bob";
     mockUserName = "Alice";
+    forkFlagEnabled = false;
+    forkedConversationId = "fork-conv-1";
+    forkCalls = [];
+    addMessageCalls = [];
+    conversationOverrides = {};
+    messagesByConversationId = {};
   });
 
   test("first-run happy path: no state row, no prior retrospective, both pointer fields set on success", async () => {
@@ -408,4 +503,223 @@ describe("memoryRetrospectiveJob", () => {
     const hint = wakeCalls[0]!.hint;
     expect(hint).toContain("<\u200B/already_remembered>");
   });
+
+  test("fork path: persisted instruction is stamped with hidden: true so the UI list serializer drops it", async () => {
+    forkFlagEnabled = true;
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(addMessageCalls).toHaveLength(1);
+    expect(addMessageCalls[0]!.conversationId).toBe("fork-conv-1");
+    expect(addMessageCalls[0]!.role).toBe("user");
+    expect(addMessageCalls[0]!.metadata).toEqual({
+      kind: "memory_retrospective_instruction",
+      hidden: true,
+    });
+  });
+
+  test("fork path: forked retrospective is bucketed as background under the retrospective group", async () => {
+    forkFlagEnabled = true;
+    const outcome = await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(outcome.kind).toBe("invoked");
+    expect(forkCalls).toHaveLength(1);
+    expect(forkCalls[0]!.conversationType).toBe("background");
+    expect(forkCalls[0]!.groupId).toBe("system:background");
+  });
+
+  test("fork path: wake opts include suppressWakeSurface so clients don't render an empty wake card on top of the '(Retrospective)' fork", async () => {
+    forkFlagEnabled = true;
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(forkCalls).toHaveLength(1);
+    expect(wakeCalls).toHaveLength(1);
+    expect(wakeCalls[0]!.conversationId).toBe("fork-conv-1");
+    const opts = wakeCalls[0]!.opts;
+    expect(opts.suppressWakeSurface).toBe(true);
+    // Sanity: the other fork-specific opts the handler relies on are still set.
+    expect(opts.skipHintInjection).toBe(true);
+    expect(opts.suppressAutoCompaction).toBe(true);
+    expect(opts.hintRole).toBe("user");
+  });
+
+  test("fork path: fork is pinned to the computed cutoffMessageId so late-arriving messages don't sneak into this run", async () => {
+    // Without `throughMessageId`, the fork snapshots the latest source
+    // message at fork time. If a new user/assistant turn lands between the
+    // slice read and the fork, this run would process the late turn while
+    // state advances only to `cutoffMessageId`, causing the next
+    // retrospective to reprocess it.
+    forkFlagEnabled = true;
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(forkCalls).toHaveLength(1);
+    expect(forkCalls[0]!.throughMessageId).toBe("m3");
+  });
+
+  test("fork path: prior fork-kind retrospective with nested-fork ancestry still surfaces its post-fork remembers in <already_remembered>", async () => {
+    // The source conversation was itself a fork. Its assistant messages
+    // therefore carry `forkSourceMessageId` values pointing at the
+    // ANCESTOR's message ids — not at the new fork's `forkParentMessageId`.
+    // The boundary detector must locate the boundary by scanning for the
+    // last metadata stamp regardless of value, not by equality against
+    // `forkParentMessageId` (which would miss every copied row and lose
+    // dedup context).
+    forkFlagEnabled = true;
+    priorRetroId = "prior-fork-retro-1";
+
+    // The fork's `forkParentMessageId` is the source conv's tip ("m-src-2"),
+    // but the cloned messages preserve ancestor stamps ("m-ancestor-*").
+    conversationOverrides[priorRetroId] = {
+      source: "memory-retrospective-fork",
+      forkParentMessageId: "m-src-2",
+    };
+    messagesByConversationId[priorRetroId] = [
+      // Copied prefix — note metadata stamps point at the ANCESTOR, not
+      // `forkParentMessageId`. The old detector would return null here.
+      {
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "hi" }]),
+        createdAt: 1000,
+        metadata: JSON.stringify({ forkSourceMessageId: "m-ancestor-1" }),
+      },
+      {
+        role: "assistant",
+        // An inline `remember` from the source conv (should NOT leak into
+        // dedup baseline — it's part of the copied prefix, not the post-fork
+        // retrospective tail).
+        content: JSON.stringify([
+          {
+            type: "tool_use",
+            name: "remember",
+            input: { content: "source-inline save — must be excluded" },
+          },
+        ]),
+        createdAt: 2000,
+        metadata: JSON.stringify({ forkSourceMessageId: "m-ancestor-2" }),
+      },
+      // Post-fork instruction (no forkSourceMessageId) + the wake's tail
+      // assistant turn with the retrospective's own remember call.
+      {
+        role: "user",
+        content: JSON.stringify([
+          { type: "text", text: "Retrospective instruction" },
+        ]),
+        createdAt: 3000,
+        metadata: JSON.stringify({
+          kind: "memory_retrospective_instruction",
+          hidden: true,
+        }),
+      },
+      {
+        role: "assistant",
+        content: JSON.stringify([
+          {
+            type: "tool_use",
+            name: "remember",
+            input: { content: "retrospective save — must be included" },
+          },
+        ]),
+        createdAt: 4000,
+        metadata: null,
+      },
+    ];
+
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    // The fork path persists the prompt as a user-role message, not via the
+    // wake's hint. Pull the rendered text block out of the persisted JSON.
+    expect(addMessageCalls).toHaveLength(1);
+    const blocks = JSON.parse(addMessageCalls[0]!.content) as Array<{
+      type: string;
+      text: string;
+    }>;
+    const instructionText = blocks[0]!.text;
+    expect(instructionText).toContain(
+      "- retrospective save — must be included",
+    );
+    expect(instructionText).not.toContain("source-inline save");
+    // Sanity: the "first retrospective" sentinel should not appear — we
+    // located dedup context.
+    expect(instructionText).not.toContain(
+      "(none — this is your first retrospective over this conversation)",
+    );
+  });
+
+  test("fork path: prior fork-kind retrospective with no copied messages degrades to empty dedup", async () => {
+    // Corrupted/empty fork-kind prior: no message carries
+    // `forkSourceMessageId`. The detector should return null and the
+    // handler should treat dedup as empty rather than dumping everything
+    // (which would leak any pre-fork content into the baseline).
+    forkFlagEnabled = true;
+    priorRetroId = "prior-fork-retro-2";
+
+    conversationOverrides[priorRetroId] = {
+      source: "memory-retrospective-fork",
+      forkParentMessageId: "m-src-2",
+    };
+    messagesByConversationId[priorRetroId] = [
+      {
+        role: "assistant",
+        content: JSON.stringify([
+          {
+            type: "tool_use",
+            name: "remember",
+            input: { content: "would-be-leaked save" },
+          },
+        ]),
+        createdAt: 1000,
+        metadata: null,
+      },
+    ];
+
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(addMessageCalls).toHaveLength(1);
+    const blocks = JSON.parse(addMessageCalls[0]!.content) as Array<{
+      type: string;
+      text: string;
+    }>;
+    const instructionText = blocks[0]!.text;
+    expect(instructionText).not.toContain("- would-be-leaked save");
+    expect(instructionText).toContain(
+      "(none — this is your first retrospective over this conversation)",
+    );
+  });
+
+  test("fork path: prompt anchors review window at first turn_context current_time and disambiguates first-pass vs incremental", async () => {
+    forkFlagEnabled = true;
+    // Stage a user turn whose content carries a turn_context current_time
+    // block — the handler should anchor the prompt at that timestamp.
+    newMessages = [
+      {
+        id: "m1",
+        createdAt: Date.parse("2026-05-11T10:00:00Z"),
+        role: "user",
+        content: JSON.stringify([
+          {
+            type: "text",
+            text: "<turn_context>\ncurrent_time: 2026-05-11T10:00:00-07:00\n</turn_context>\n\nhi",
+          },
+        ]),
+      },
+      // Wake's response — no turn_context, not used as anchor.
+      {
+        id: "m2",
+        createdAt: Date.parse("2026-05-11T10:05:00Z"),
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "hello" }]),
+      },
+    ] as Array<{ id: string; createdAt: number } & Record<string, unknown>>;
+
+    // Incremental run — `lastProcessedMessageId` already set.
+    mockState = {
+      conversationId: "src-conv-1",
+      lastProcessedMessageId: "prev-msg",
+      lastRunAt: Date.now() - 60 * 60 * 1000,
+    };
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(addMessageCalls).toHaveLength(1);
+    expect(forkCalls).toHaveLength(1);
+    expect(forkCalls[0]!.throughMessageId).toBe("m2");
+  });
 });

package/src/memory/conversation-crud.ts

@@ -50,7 +50,7 @@ import { ensureGroupMigration } from "./conversation-group-migration.js";
 import { getDb, getSqliteFrom } from "./db-connection.js";
 import { forkGraphMemoryState } from "./graph/graph-memory-state-store.js";
 import { indexMessageNow } from "./indexer.js";
-import { MEMORY_RETROSPECTIVE_SOURCE } from "./memory-retrospective-constants.js";
+import { MEMORY_RETROSPECTIVE_SOURCES } from "./memory-retrospective-constants.js";
 import { forkRetrospectiveState } from "./memory-retrospective-state.js";
 import { rawExec, rawGet, rawRun } from "./raw-query.js";
 import {
@@ -190,6 +190,7 @@ export interface ConversationRow {
   contextSummary: string | null;
   contextCompactedMessageCount: number;
   contextCompactedAt: number | null;
+  cleanedAt: number | null;
   slackContextCompactionWatermarkTs: string | null;
   slackContextCompactionWatermarkAt: number | null;
   conversationType: string;
@@ -206,6 +207,7 @@ export interface ConversationRow {
   inferenceProfile: string | null;
   inferenceProfileSessionId: string | null;
   inferenceProfileExpiresAt: number | null;
+  lastNotifiedInferenceProfile: string | null;
 }
 
 export const parseConversation = createRowMapper<
@@ -222,6 +224,7 @@ export const parseConversation = createRowMapper<
   contextSummary: "contextSummary",
   contextCompactedMessageCount: "contextCompactedMessageCount",
   contextCompactedAt: "contextCompactedAt",
+  cleanedAt: "cleanedAt",
   slackContextCompactionWatermarkTs: "slackContextCompactionWatermarkTs",
   slackContextCompactionWatermarkAt: "slackContextCompactionWatermarkAt",
   conversationType: "conversationType",
@@ -238,6 +241,7 @@ export const parseConversation = createRowMapper<
   inferenceProfile: "inferenceProfile",
   inferenceProfileSessionId: "inferenceProfileSessionId",
   inferenceProfileExpiresAt: "inferenceProfileExpiresAt",
+  lastNotifiedInferenceProfile: "lastNotifiedInferenceProfile",
 });
 
 export interface MessageRow {
@@ -482,7 +486,7 @@ export function findMostRecentRetrospectiveFor(
       .from(conversations)
       .where(
         and(
-          eq(conversations.source, MEMORY_RETROSPECTIVE_SOURCE),
+          inArray(conversations.source, MEMORY_RETROSPECTIVE_SOURCES),
           eq(conversations.forkParentConversationId, currentId),
         ),
       )
@@ -535,6 +539,32 @@ function getConversationGroupId(conversationId: string): string | null {
 export function forkConversation(params: {
   conversationId: string;
   throughMessageId?: string;
+  /**
+   * Override the fork's `source` column. Defaults to the standard
+   * `createConversation` default (`"user"`). Used by fork-based memory
+   * retrospectives to mark the fork as a retrospective artifact distinct
+   * from a user-initiated fork, so dedup and cleanup queries can scope
+   * correctly.
+   */
+  source?: string;
+  /**
+   * Optional title for the fork. Defaults to `<parent title> (Fork)`.
+   */
+  title?: string;
+  /**
+   * Override the fork's `conversationType` column. Defaults to `"standard"`.
+   * Used by fork-based memory retrospectives to bucket the fork as a
+   * `"background"` conversation so it doesn't surface in the user's
+   * conversation list.
+   */
+  conversationType?: ConversationCreateType;
+  /**
+   * Override the fork's `groupId`. Defaults to the parent conversation's
+   * group (or `"system:all"` when the parent has none). Used by fork-based
+   * memory retrospectives to route the fork into a dedicated background
+   * group.
+   */
+  groupId?: string;
 }): ConversationRow {
   const { conversationId, throughMessageId } = params;
   const db = getDb();
@@ -576,8 +606,19 @@ export function forkConversation(params: {
     copyBoundaryIndex >= 0
       ? sourceMessages.slice(0, copyBoundaryIndex + 1)
       : ([] as MessageRow[]);
+
+  // Inherit /clean state only when the fork boundary is at-or-after the
+  // clean event. Pre-clean forks branch from history that pre-dates the
+  // clean, so the marker would be a no-op and is misleading to copy.
+  const sourceCleanedAt = sourceConversation.cleanedAt ?? null;
+  const boundaryMessageCreatedAt = messagesToCopy.at(-1)?.createdAt ?? null;
+  const inheritsCleanedAt =
+    sourceCleanedAt != null &&
+    boundaryMessageCreatedAt != null &&
+    boundaryMessageCreatedAt >= sourceCleanedAt;
   const forkParentMessageId = messagesToCopy.at(-1)?.id ?? null;
-  const forkTitle = `${sourceConversation.title ?? "Untitled"} (Fork)`;
+  const forkTitle =
+    params.title ?? `${sourceConversation.title ?? "Untitled"} (Fork)`;
 
   // Collect disk-sync work to run after the transaction commits.
   const diskSyncQueue: Array<{
@@ -597,8 +638,9 @@ export function forkConversation(params: {
   const forkedConversation = db.transaction(() => {
     const fc = createConversation({
       title: forkTitle,
-      conversationType: "standard",
-      groupId: parentGroupId ?? "system:all",
+      conversationType: params.conversationType ?? "standard",
+      groupId: params.groupId ?? parentGroupId ?? "system:all",
+      ...(params.source != null ? { source: params.source } : {}),
     });
 
     db.update(conversations)
@@ -620,6 +662,7 @@ export function forkConversation(params: {
         slackContextCompactionWatermarkAt: preserveSourceCompactionState
           ? sourceConversation.slackContextCompactionWatermarkAt
           : null,
+        cleanedAt: inheritsCleanedAt ? sourceCleanedAt : null,
         inferenceProfile: sourceConversation.inferenceProfile,
       })
       .where(eq(conversations.id, fc.id))
@@ -1229,10 +1272,14 @@ interface PaginatedMessagesResult {
   hasMore: boolean;
 }
 
+const PAGINATION_CHUNK_MIN = 50;
+const PAGINATION_SCAN_CAP = 10_000;
+
 export function getMessagesPaginated(
   conversationId: string,
   limit: number | undefined,
   beforeTimestamp?: number,
+  filter?: (row: MessageRow) => boolean,
 ): PaginatedMessagesResult {
   const db = getDb();
 
@@ -1248,51 +1295,69 @@ export function getMessagesPaginated(
       .orderBy(asc(messages.createdAt))
       .all()
       .map(parseMessage);
-    return { messages: rows, hasMore: false };
+    return {
+      messages: filter ? rows.filter(filter) : rows,
+      hasMore: false,
+    };
   }
 
-  const conditions = [eq(messages.conversationId, conversationId)];
-  if (beforeTimestamp !== undefined) {
-    conditions.push(lt(messages.createdAt, beforeTimestamp));
-  }
+  // Walk pages newest→oldest, applying `filter` in TS (metadata parsing is
+  // JSON, not a structured column). Keep fetching until we have `limit + 1`
+  // visible rows or the DB is exhausted, so `hasMore` and the cursor reflect
+  // the visible page rather than the unfiltered row count. Without this loop,
+  // a fully-hidden page returns `{ messages: [], hasMore: true }` with no
+  // cursor, which stalls the web client's older-page fetch.
+  let cursorCreatedAt = beforeTimestamp;
+  let cursorMessageId: string | undefined;
+  const visible: MessageRow[] = [];
+  const chunkSize = Math.max(limit + 1, PAGINATION_CHUNK_MIN);
+  // Bound the work a single request can do when `filter` rejects nearly every
+  // row — otherwise a pathological filter against a huge conversation would
+  // tie up a connection for thousands of roundtrips.
+  let rowsScanned = 0;
+
+  while (visible.length < limit + 1 && rowsScanned < PAGINATION_SCAN_CAP) {
+    const cursorPredicate =
+      cursorCreatedAt === undefined
+        ? undefined
+        : cursorMessageId === undefined
+          ? lt(messages.createdAt, cursorCreatedAt)
+          : or(
+              lt(messages.createdAt, cursorCreatedAt),
+              and(
+                eq(messages.createdAt, cursorCreatedAt),
+                lt(messages.id, cursorMessageId),
+              ),
+            );
 
-  const rows = db
-    .select()
-    .from(messages)
-    .where(and(...conditions))
-    .orderBy(desc(messages.createdAt))
-    .limit(limit + 1)
-    .all()
-    .map(parseMessage);
+    const chunk = db
+      .select()
+      .from(messages)
+      .where(and(eq(messages.conversationId, conversationId), cursorPredicate))
+      .orderBy(desc(messages.createdAt), desc(messages.id))
+      .limit(chunkSize)
+      .all()
+      .map(parseMessage);
 
-  const hasMore = rows.length > limit;
-  if (hasMore) {
-    rows.splice(limit);
+    if (chunk.length === 0) break;
+    rowsScanned += chunk.length;
+
+    for (const row of chunk) {
+      if (!filter || filter(row)) visible.push(row);
+      if (visible.length >= limit + 1) break;
+    }
+
+    if (chunk.length < chunkSize) break;
+    const lastRow = chunk[chunk.length - 1];
+    cursorCreatedAt = lastRow.createdAt;
+    cursorMessageId = lastRow.id;
   }
-  rows.reverse();
 
-  return { messages: rows, hasMore };
-}
+  const hasMore = visible.length > limit;
+  if (hasMore) visible.splice(limit);
+  visible.reverse();
 
-export function getLastAssistantTimestampBefore(
-  conversationId: string,
-  beforeTimestamp: number,
-): number {
-  const db = getDb();
-  const row = db
-    .select({ createdAt: messages.createdAt })
-    .from(messages)
-    .where(
-      and(
-        eq(messages.conversationId, conversationId),
-        eq(messages.role, "assistant"),
-        lt(messages.createdAt, beforeTimestamp),
-      ),
-    )
-    .orderBy(desc(messages.createdAt))
-    .limit(1)
-    .get();
-  return row?.createdAt ?? 0;
+  return { messages: visible, hasMore };
 }
 
 export function getLastUserTimestampBefore(
@@ -1386,6 +1451,20 @@ export function updateConversationContextWindow(
     .run();
 }
 
+export function setConversationCleanedAt(
+  id: string,
+  cleanedAt: number | null,
+): void {
+  const db = getDb();
+  db.update(conversations)
+    .set({
+      cleanedAt,
+      updatedAt: Date.now(),
+    })
+    .where(eq(conversations.id, id))
+    .run();
+}
+
 export function updateConversationSlackContextWatermark(
   id: string,
   watermarkTs: string,
@@ -1609,6 +1688,17 @@ export function getConversationOverrideProfile(
   return getConversationOverrideProfileFromRow(getConversation(conversationId));
 }
 
+export function setLastNotifiedInferenceProfile(
+  conversationId: string,
+  profileKey: string | null,
+): void {
+  rawRun(
+    "UPDATE conversations SET last_notified_inference_profile = ? WHERE id = ?",
+    profileKey,
+    conversationId,
+  );
+}
+
 /**
  * Delete all conversations, messages, and related data (tool invocations,
  * memory segments, etc.) from the daemon database.