@vellumai/assistant 0.8.2 → 0.8.4

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.

package/src/memory/conversation-queries.ts

@@ -1,4 +1,4 @@
-import { and, count, desc, eq, sql } from "drizzle-orm";
+import { and, count, desc, eq, inArray, isNull, sql } from "drizzle-orm";
 
 import {
   parseExternalContentEnvelope,
@@ -86,6 +86,92 @@ export function listConversations(
   return query.all().map(parseConversation);
 }
 
+/**
+ * List conversations matching an exact `source` value, ordered by `createdAt`
+ * descending. The surgical filter for "find every background run produced by
+ * job X" — heartbeat, memory_v2_consolidation, watcher-engine, etc. — since
+ * `source` is the canonical job-class distinguisher across the background
+ * bucket. `conversationType` + `group_id` only narrow to "background vs
+ * scheduled vs standard"; neither identifies which job produced the row.
+ *
+ * Filter is exact (no `LIKE`, no implicit exclusions): the route layer is
+ * responsible for knowing which source constants exist and passing one. The
+ * defensive `source != 'subagent'` carve-out applied by `listConversations`
+ * is deliberately NOT replicated here — a caller asking for an exact source
+ * gets exactly that source.
+ *
+ * @param source        Exact match against `conversations.source`. Pass the
+ *                      canonical constant (e.g. `MEMORY_V2_CONSOLIDATION_SOURCE`).
+ * @param limit         Maximum rows to return (default 20).
+ * @param opts.includeArchived  Include rows with non-null `archivedAt`.
+ *                              Defaults to `true` so callers that want a full
+ *                              run history get one; pass `false` for views
+ *                              that hide archived rows.
+ */
+export function listConversationsBySource(
+  source: string,
+  limit = 20,
+  opts?: { includeArchived?: boolean },
+): ConversationRow[] {
+  const db = getDb();
+  const includeArchived = opts?.includeArchived ?? true;
+  const where = includeArchived
+    ? eq(conversations.source, source)
+    : and(eq(conversations.source, source), isNull(conversations.archivedAt));
+  const rows = db
+    .select()
+    .from(conversations)
+    .where(where)
+    .orderBy(desc(conversations.createdAt))
+    .limit(limit)
+    .all();
+  return rows.map(parseConversation);
+}
+
+/**
+ * Per-conversation aggregate of messages with a specific role. Powers
+ * heartbeat-shaped run endpoints (e.g. `consolidation/runs`) that need a
+ * "did the agent emit any output?" signal stronger than
+ * `conversations.lastMessageAt` — which is bumped by the kickoff user
+ * prompt and so cannot distinguish "agent ran" from "agent dispatched but
+ * crashed before responding".
+ *
+ * Single batched aggregate query (no N+1). Conversations with zero matching
+ * messages are NOT present in the returned map — callers should treat a
+ * missing key as `{ count: 0, lastAt: null }`.
+ *
+ * @param conversationIds  Conversation ids to look up (empty → empty map).
+ * @param role             Message role to count (default `"assistant"`).
+ */
+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) },
+    ]),
+  );
+}
+
 export function listPinnedConversations(): ConversationRow[] {
   ensureDisplayOrderMigration();
   ensureGroupMigration();

package/src/memory/conversation-title-service.ts

@@ -298,9 +298,11 @@ function buildTitleSystemPrompt(): string {
     "You generate ultra-concise conversation titles. Output ONLY the title text — no explanation, no quotes, no markdown, no preamble.",
     "",
     "Rules:",
-    "- 2–6 words. Titles longer than 6 words are unacceptable — ruthlessly compress",
-    "- Summarize the TOPIC, not the request or instructions",
-    "- Noun phrases are ideal (e.g. 'Auth Middleware Rewrite', 'Docker Volume Mounts')",
+    "- 2–5 words maximum. Titles longer than 5 words are unacceptable — ruthlessly compress to a short noun phrase",
+    "- 40 characters absolute maximum — if your title exceeds 40 characters it will be truncated and look broken",
+    "- Summarize only the TOPIC, not the request or instructions",
+    "- Noun phrases are ideal (e.g. 'Auth Middleware Rewrite', 'Docker Volume Mounts', 'Onboarding Flow')",
+    "- Think: what would make a scannable sidebar label?",
     "- Do NOT echo back what the user asked you to do",
     "- Do NOT respond to the conversation content",
     "- Do NOT assess feasibility or comment on capabilities",
@@ -353,13 +355,33 @@ const META_FAILURE_TITLES = new Set([
   "no content",
 ]);
 
+const MAX_TITLE_LENGTH = 40;
+const MAX_TITLE_WORDS = 7;
+
+function truncateTitle(title: string): string {
+  if (title.length <= MAX_TITLE_LENGTH) return title;
+  const words = title.split(/\s+/);
+  if (words.length <= MAX_TITLE_WORDS) {
+    // Long words but few of them — truncate to char limit at word boundary
+    let result = "";
+    for (const word of words) {
+      const candidate = result ? result + " " + word : word;
+      if (candidate.length > MAX_TITLE_LENGTH) break;
+      result = candidate;
+    }
+    return result || title.slice(0, MAX_TITLE_LENGTH);
+  }
+  // Too many words — trim to 5 words
+  return words.slice(0, 5).join(" ");
+}
+
 function normalizeTitle(raw: string): string {
   let title = raw.trim().replace(/^["']|["']$/g, "");
   title = stripMarkdown(title);
   if (META_FAILURE_TITLES.has(title.toLowerCase())) {
     return "";
   }
-  return title;
+  return truncateTitle(title);
 }
 
 /** Strip common markdown formatting so titles render as plain text. */

package/src/memory/db-init.ts

@@ -39,6 +39,7 @@ import {
   createWatchersAndLogsTables,
   migrate230AcpSessionHistory,
   migrate231RepairMemoryGraphEventDates,
+  migrateA2ATasks,
   migrateActivationState,
   migrateActivationStateFkCascade,
   migrateAddConversationInferenceProfile,
@@ -57,6 +58,7 @@ import {
   migrateCanonicalGuardianRequesterChatId,
   migrateCapabilityCardColumns,
   migrateChannelInboundDeliveredSegments,
+  migrateChannelInboundDeliveryAttempts,
   migrateChannelInteractionColumns,
   migrateContactChannelsAccessFields,
   migrateContactChannelsTypeChatIdIndex,
@@ -64,13 +66,16 @@ import {
   migrateContactsNotesColumn,
   migrateContactsRolePrincipal,
   migrateContactsUserFileColumn,
+  migrateConversationCleanedAt,
   migrateConversationForkLineage,
   migrateConversationHostAccess,
   migrateConversationInferenceProfileSession,
+  migrateConversationLastNotifiedProfile,
   migrateConversationsArchivedAt,
   migrateConversationsLastMessageAt,
   migrateConversationsThreadTypeIndex,
   migrateCreateConversationGraphMemoryState,
+  migrateCreateDocumentComments,
   migrateCreateDocumentConversations,
   migrateCreateMemoryGraphNodeEdits,
   migrateCreateMemoryGraphTables,
@@ -95,6 +100,7 @@ import {
   migrateDropSetupSkillIdColumn,
   migrateDropSimplifiedMemory,
   migrateDropUsageCompositeIndexes,
+  migrateExternalConversationBindingChatName,
   migrateExternalConversationBindingThreadId,
   migrateFkCascadeRebuilds,
   migrateGuardianActionFollowup,
@@ -111,6 +117,7 @@ import {
   migrateHeartbeatRuns,
   migrateInviteCodeHashColumn,
   migrateInviteContactId,
+  migrateLlmRequestLogAgentLoopExitReason,
   migrateLlmRequestLogMessageId,
   migrateLlmRequestLogProvider,
   migrateLlmRequestLogsCreatedAtIndex,
@@ -120,6 +127,7 @@ import {
   migrateMemoryRecallLogsQueryContext,
   migrateMemoryRetrospectiveState,
   migrateMemoryV2ActivationLogs,
+  migrateMemoryV2InjectionEvents,
   migrateMessageBookmarks,
   migrateMessagesConversationCreatedAtIndex,
   migrateMessagesFtsBackfill,
@@ -142,6 +150,8 @@ import {
   migrateOAuthProvidersScopeSeparator,
   migrateOAuthProvidersTokenAuthMethodDefault,
   migrateOAuthProvidersTokenExchangeBodyFormat,
+  migrateOnboardingEventsPriorAssistants,
+  migrateProviderConnectionBaseUrlAndModels,
   migrateProviderConnectionStatusLabel,
   migrateReminderRoutingIntent,
   migrateRemindersToSchedules,
@@ -171,6 +181,7 @@ import {
   migrateSchemaIndexesAndColumns,
   migrateScrubCorruptedImageAttachments,
   migrateSlackCompactionWatermark,
+  migrateStripBaseUrlNonOpenaiCompatible,
   migrateStripIntegrationPrefixFromProviderKeys,
   migrateStripPlaceholderSentinelsFromMessages,
   migrateStripThinkingFromConsolidated,
@@ -430,6 +441,17 @@ export function initializeDb(): void {
     migrateExternalConversationBindingThreadId,
     createOnboardingEventsTable,
     migrateNormalizeSlackExternalContent,
+    migrateProviderConnectionBaseUrlAndModels,
+    migrateA2ATasks,
+    migrateLlmRequestLogAgentLoopExitReason,
+    migrateCreateDocumentComments,
+    migrateExternalConversationBindingChatName,
+    migrateChannelInboundDeliveryAttempts,
+    migrateMemoryV2InjectionEvents,
+    migrateConversationLastNotifiedProfile,
+    migrateStripBaseUrlNonOpenaiCompatible,
+    migrateOnboardingEventsPriorAssistants,
+    migrateConversationCleanedAt,
   ];
 
   // Run each migration step, catching and logging individual failures so one

package/src/memory/delivery-crud.ts

@@ -313,6 +313,47 @@ export function storePayload(
     .run();
 }
 
+/**
+ * Persist the assistant reply row generated for an inbound event so callback
+ * delivery retries target that exact response instead of the latest message in
+ * the conversation.
+ */
+export function storeReplyMessageId(
+  eventId: string,
+  replyMessageId: string,
+): void {
+  const db = getDb();
+  const row = db
+    .select({ rawPayload: channelInboundEvents.rawPayload })
+    .from(channelInboundEvents)
+    .where(eq(channelInboundEvents.id, eventId))
+    .get();
+  if (!row?.rawPayload) return;
+
+  let payload: Record<string, unknown>;
+  try {
+    const parsed = JSON.parse(row.rawPayload) as unknown;
+    if (
+      parsed === null ||
+      typeof parsed !== "object" ||
+      Array.isArray(parsed)
+    ) {
+      return;
+    }
+    payload = parsed as Record<string, unknown>;
+  } catch {
+    return;
+  }
+
+  db.update(channelInboundEvents)
+    .set({
+      rawPayload: JSON.stringify({ ...payload, replyMessageId }),
+      updatedAt: Date.now(),
+    })
+    .where(eq(channelInboundEvents.id, eventId))
+    .run();
+}
+
 /**
  * Clear a previously stored payload. Used when the ingress check
  * detects secret-bearing content — the payload must not remain on disk.