@vellumai/assistant 0.8.3 → 0.8.4

package/src/memory/db-init.ts

@@ -58,6 +58,7 @@ import {
   migrateCanonicalGuardianRequesterChatId,
   migrateCapabilityCardColumns,
   migrateChannelInboundDeliveredSegments,
+  migrateChannelInboundDeliveryAttempts,
   migrateChannelInteractionColumns,
   migrateContactChannelsAccessFields,
   migrateContactChannelsTypeChatIdIndex,
@@ -65,13 +66,16 @@ import {
   migrateContactsNotesColumn,
   migrateContactsRolePrincipal,
   migrateContactsUserFileColumn,
+  migrateConversationCleanedAt,
   migrateConversationForkLineage,
   migrateConversationHostAccess,
   migrateConversationInferenceProfileSession,
+  migrateConversationLastNotifiedProfile,
   migrateConversationsArchivedAt,
   migrateConversationsLastMessageAt,
   migrateConversationsThreadTypeIndex,
   migrateCreateConversationGraphMemoryState,
+  migrateCreateDocumentComments,
   migrateCreateDocumentConversations,
   migrateCreateMemoryGraphNodeEdits,
   migrateCreateMemoryGraphTables,
@@ -96,6 +100,7 @@ import {
   migrateDropSetupSkillIdColumn,
   migrateDropSimplifiedMemory,
   migrateDropUsageCompositeIndexes,
+  migrateExternalConversationBindingChatName,
   migrateExternalConversationBindingThreadId,
   migrateFkCascadeRebuilds,
   migrateGuardianActionFollowup,
@@ -122,6 +127,7 @@ import {
   migrateMemoryRecallLogsQueryContext,
   migrateMemoryRetrospectiveState,
   migrateMemoryV2ActivationLogs,
+  migrateMemoryV2InjectionEvents,
   migrateMessageBookmarks,
   migrateMessagesConversationCreatedAtIndex,
   migrateMessagesFtsBackfill,
@@ -144,6 +150,7 @@ import {
   migrateOAuthProvidersScopeSeparator,
   migrateOAuthProvidersTokenAuthMethodDefault,
   migrateOAuthProvidersTokenExchangeBodyFormat,
+  migrateOnboardingEventsPriorAssistants,
   migrateProviderConnectionBaseUrlAndModels,
   migrateProviderConnectionStatusLabel,
   migrateReminderRoutingIntent,
@@ -174,6 +181,7 @@ import {
   migrateSchemaIndexesAndColumns,
   migrateScrubCorruptedImageAttachments,
   migrateSlackCompactionWatermark,
+  migrateStripBaseUrlNonOpenaiCompatible,
   migrateStripIntegrationPrefixFromProviderKeys,
   migrateStripPlaceholderSentinelsFromMessages,
   migrateStripThinkingFromConsolidated,
@@ -436,6 +444,14 @@ export function initializeDb(): void {
     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.

package/src/memory/delivery-status.ts

@@ -6,7 +6,7 @@
  * retryable and dead-lettered events, and replaying dead letters.
  */
 
-import { and, eq, lte } from "drizzle-orm";
+import { and, eq, lte, or } from "drizzle-orm";
 
 import { getDb } from "./db-connection.js";
 import {
@@ -44,6 +44,7 @@ export function acknowledgeDelivery(
   db.update(channelInboundEvents)
     .set({
       deliveryStatus: "delivered",
+      retryAfter: null,
       updatedAt: now,
     })
     .where(eq(channelInboundEvents.id, existing.id))
@@ -61,6 +62,23 @@ export function markProcessed(eventId: string): void {
     .run();
 }
 
+/** Mark an event's outbound callback delivery as complete. */
+export function markDeliveryDelivered(eventId: string): void {
+  const db = getDb();
+  db.update(channelInboundEvents)
+    .set({
+      deliveryStatus: "delivered",
+      retryAfter: null,
+      updatedAt: Date.now(),
+    })
+    .where(eq(channelInboundEvents.id, eventId))
+    .run();
+}
+
+function errorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
 /**
  * Record a processing failure. Classifies the error to decide whether
  * the event should be retried (status='failed') or dead-lettered
@@ -79,7 +97,7 @@ export function recordProcessingFailure(eventId: string, err: unknown): void {
 
   const attempts = (row?.attempts ?? 0) + 1;
   const category = classifyError(err);
-  const errorMsg = err instanceof Error ? err.message : String(err);
+  const errorMsg = errorMessage(err);
 
   if (category === "fatal" || attempts >= RETRY_MAX_ATTEMPTS) {
     db.update(channelInboundEvents)
@@ -107,6 +125,51 @@ export function recordProcessingFailure(eventId: string, err: unknown): void {
   }
 }
 
+/**
+ * Record an outbound callback delivery failure without changing the processing
+ * status. Delivery uses its own retry budget so a turn that needed processing
+ * retries still gets a full delivery retry window.
+ */
+export function recordDeliveryFailure(eventId: string, err: unknown): void {
+  const db = getDb();
+  const now = Date.now();
+
+  const row = db
+    .select({ attempts: channelInboundEvents.deliveryAttempts })
+    .from(channelInboundEvents)
+    .where(eq(channelInboundEvents.id, eventId))
+    .get();
+
+  const attempts = (row?.attempts ?? 0) + 1;
+  const category = classifyError(err);
+  const errorMsg = errorMessage(err);
+
+  if (category === "fatal" || attempts >= RETRY_MAX_ATTEMPTS) {
+    db.update(channelInboundEvents)
+      .set({
+        deliveryStatus: "dead_letter",
+        deliveryAttempts: attempts,
+        lastProcessingError: errorMsg,
+        retryAfter: null,
+        updatedAt: now,
+      })
+      .where(eq(channelInboundEvents.id, eventId))
+      .run();
+  } else {
+    const delay = retryDelayForAttempt(attempts);
+    db.update(channelInboundEvents)
+      .set({
+        deliveryStatus: "failed",
+        deliveryAttempts: attempts,
+        lastProcessingError: errorMsg,
+        retryAfter: now + delay,
+        updatedAt: now,
+      })
+      .where(eq(channelInboundEvents.id, eventId))
+      .run();
+  }
+}
+
 /**
  * Mark an event as failed with a specific error message, bypassing error
  * classification. Use this when the failure reason is known and the event
@@ -180,6 +243,38 @@ export function getRetryableEvents(limit = 20): Array<{
     .all();
 }
 
+/** Fetch callback deliveries eligible for retry without rerunning processing. */
+export function getRetryableDeliveryEvents(limit = 20): Array<{
+  id: string;
+  conversationId: string;
+  messageId: string | null;
+  processingAttempts: number;
+  rawPayload: string | null;
+  deliveredSegmentCount: number;
+}> {
+  const db = getDb();
+  const now = Date.now();
+  return db
+    .select({
+      id: channelInboundEvents.id,
+      conversationId: channelInboundEvents.conversationId,
+      messageId: channelInboundEvents.messageId,
+      processingAttempts: channelInboundEvents.processingAttempts,
+      rawPayload: channelInboundEvents.rawPayload,
+      deliveredSegmentCount: channelInboundEvents.deliveredSegmentCount,
+    })
+    .from(channelInboundEvents)
+    .where(
+      and(
+        eq(channelInboundEvents.processingStatus, "processed"),
+        eq(channelInboundEvents.deliveryStatus, "failed"),
+        lte(channelInboundEvents.retryAfter, now),
+      ),
+    )
+    .limit(limit)
+    .all();
+}
+
 /** Fetch dead-lettered events. */
 export function getDeadLetterEvents(): Array<{
   id: string;
@@ -204,7 +299,15 @@ export function getDeadLetterEvents(): Array<{
       createdAt: channelInboundEvents.createdAt,
     })
     .from(channelInboundEvents)
-    .where(eq(channelInboundEvents.processingStatus, "dead_letter"))
+    .where(
+      or(
+        eq(channelInboundEvents.processingStatus, "dead_letter"),
+        and(
+          eq(channelInboundEvents.processingStatus, "processed"),
+          eq(channelInboundEvents.deliveryStatus, "dead_letter"),
+        ),
+      ),
+    )
     .all();
 }
 
@@ -218,27 +321,50 @@ export function replayDeadLetters(eventIds: string[]): number {
   let count = 0;
   for (const id of eventIds) {
     const existing = db
-      .select({ id: channelInboundEvents.id })
+      .select({
+        id: channelInboundEvents.id,
+        processingStatus: channelInboundEvents.processingStatus,
+        deliveryStatus: channelInboundEvents.deliveryStatus,
+      })
       .from(channelInboundEvents)
       .where(
         and(
           eq(channelInboundEvents.id, id),
-          eq(channelInboundEvents.processingStatus, "dead_letter"),
+          or(
+            eq(channelInboundEvents.processingStatus, "dead_letter"),
+            and(
+              eq(channelInboundEvents.processingStatus, "processed"),
+              eq(channelInboundEvents.deliveryStatus, "dead_letter"),
+            ),
+          ),
         ),
       )
       .get();
     if (!existing) continue;
 
-    db.update(channelInboundEvents)
-      .set({
-        processingStatus: "failed",
-        processingAttempts: 0,
-        lastProcessingError: null,
-        retryAfter: now,
-        updatedAt: now,
-      })
-      .where(eq(channelInboundEvents.id, id))
-      .run();
+    if (existing.processingStatus === "dead_letter") {
+      db.update(channelInboundEvents)
+        .set({
+          processingStatus: "failed",
+          processingAttempts: 0,
+          lastProcessingError: null,
+          retryAfter: now,
+          updatedAt: now,
+        })
+        .where(eq(channelInboundEvents.id, id))
+        .run();
+    } else {
+      db.update(channelInboundEvents)
+        .set({
+          deliveryStatus: "failed",
+          deliveryAttempts: 0,
+          lastProcessingError: null,
+          retryAfter: now,
+          updatedAt: now,
+        })
+        .where(eq(channelInboundEvents.id, id))
+        .run();
+    }
     count++;
   }
   return count;

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

@@ -7,7 +7,7 @@
  * list APIs.
  */
 
-import { and, eq, inArray, isNull } from "drizzle-orm";
+import { and, eq, inArray, isNull, sql } from "drizzle-orm";
 
 import { getDb } from "./db-connection.js";
 import { externalConversationBindings } from "./schema.js";
@@ -16,6 +16,7 @@ export interface ExternalConversationBinding {
   conversationId: string;
   sourceChannel: string;
   externalChatId: string;
+  externalChatName?: string | null;
   externalThreadId?: string | null;
   externalUserId?: string | null;
   displayName?: string | null;
@@ -30,6 +31,7 @@ export interface UpsertBindingInput {
   conversationId: string;
   sourceChannel: string;
   externalChatId: string;
+  externalChatName?: string | null;
   externalThreadId?: string | null;
   externalUserId?: string | null;
   displayName?: string | null;
@@ -43,6 +45,13 @@ function normalizeExternalThreadId(
   return trimmed ? trimmed : null;
 }
 
+function normalizeExternalChatName(
+  externalChatName?: string | null,
+): string | null {
+  const trimmed = externalChatName?.trim();
+  return trimmed ? trimmed : null;
+}
+
 /**
  * Insert or update an external conversation binding on conflict (conversationId).
  * On conflict, updates channel metadata and timestamps.
@@ -51,6 +60,7 @@ export function upsertBinding(input: UpsertBindingInput): void {
   const db = getDb();
   const now = Date.now();
   const externalThreadId = normalizeExternalThreadId(input.externalThreadId);
+  const externalChatName = normalizeExternalChatName(input.externalChatName);
 
   // If a stale binding exists for this channel/chat/thread tuple under a
   // different conversationId, remove it first so the unique index is not violated.
@@ -75,6 +85,7 @@ export function upsertBinding(input: UpsertBindingInput): void {
       conversationId: input.conversationId,
       sourceChannel: input.sourceChannel,
       externalChatId: input.externalChatId,
+      externalChatName,
       externalThreadId,
       externalUserId: input.externalUserId ?? null,
       displayName: input.displayName ?? null,
@@ -88,6 +99,9 @@ export function upsertBinding(input: UpsertBindingInput): void {
       set: {
         sourceChannel: input.sourceChannel,
         externalChatId: input.externalChatId,
+        externalChatName:
+          externalChatName ??
+          sql`${externalConversationBindings.externalChatName}`,
         externalThreadId,
         externalUserId: input.externalUserId ?? null,
         displayName: input.displayName ?? null,
@@ -158,6 +172,23 @@ export function upsertOutboundBinding(input: {
     .run();
 }
 
+export function updateExternalChatName(
+  conversationId: string,
+  externalChatName: string,
+): void {
+  const db = getDb();
+  const trimmedName = externalChatName.trim();
+  if (!trimmedName) return;
+
+  db.update(externalConversationBindings)
+    .set({
+      externalChatName: trimmedName,
+      updatedAt: Date.now(),
+    })
+    .where(eq(externalConversationBindings.conversationId, conversationId))
+    .run();
+}
+
 /**
  * Look up an external binding by conversation ID.
  */

package/src/memory/jobs-worker.ts

@@ -1,3 +1,5 @@
+import { join } from "node:path";
+
 import { getConfig } from "../config/loader.js";
 import type { AssistantConfig } from "../config/types.js";
 import {
@@ -6,6 +8,7 @@ import {
   shouldLogDiskPressureBackgroundSkip,
 } from "../daemon/disk-pressure-background-gate.js";
 import { getLogger } from "../util/logger.js";
+import { getWorkspaceDir } from "../util/platform.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
 import {
   getLastScheduledCleanupEnqueueMs,
@@ -75,7 +78,10 @@ import {
   memoryV2MigrateJob,
   memoryV2ReembedJob,
 } from "./v2/backfill-jobs.js";
-import { memoryV2ConsolidateJob } from "./v2/consolidation-job.js";
+import {
+  countBufferLines,
+  memoryV2ConsolidateJob,
+} from "./v2/consolidation-job.js";
 import { memoryV2SweepJob } from "./v2/sweep-job.js";
 
 const log = getLogger("memory-jobs-worker");
@@ -739,11 +745,25 @@ export function maybeEnqueueGraphMaintenanceJobs(
         },
       ];
 
+  let enqueuedV2 = false;
   for (const { key, intervalMs, jobType } of schedule) {
     const lastRun = parseInt(getMemoryCheckpoint(key) ?? "0", 10);
     if (nowMs - lastRun >= intervalMs) {
       enqueueMemoryJob(jobType, {});
       setMemoryCheckpoint(key, String(nowMs));
+      if (jobType === "memory_v2_consolidate") enqueuedV2 = true;
+    }
+  }
+
+  const maxLines = config.memory.v2.consolidation_max_buffer_lines;
+  if (v2Active && !enqueuedV2 && maxLines !== null) {
+    const bufferPath = join(getWorkspaceDir(), "memory", "buffer.md");
+    if (countBufferLines(bufferPath) >= maxLines) {
+      enqueueMemoryJob("memory_v2_consolidate", {});
+      setMemoryCheckpoint(
+        GRAPH_MAINTENANCE_CHECKPOINTS.memoryV2Consolidate,
+        String(nowMs),
+      );
     }
   }
 }

package/src/memory/memory-retrospective-constants.ts

@@ -5,9 +5,37 @@
  */
 export const MEMORY_RETROSPECTIVE_SOURCE = "memory-retrospective";
 
+/**
+ * Sentinel value for the `source` column of fork-based memory-retrospective
+ * conversations (the new `memory-retrospective-fork` flag path). Distinct
+ * from MEMORY_RETROSPECTIVE_SOURCE so dedup can scope its message scan to the
+ * post-fork tail — fork-kind rows carry the full source prefix and would
+ * otherwise pollute prior-remember dedup with source-inline `remember` calls.
+ */
+export const MEMORY_RETROSPECTIVE_FORK_SOURCE = "memory-retrospective-fork";
+
+/**
+ * Union of both retrospective source sentinels. Use when looking up the most
+ * recent retrospective for a source conversation (either kind is valid) or
+ * when filtering retrospective bg conversations out of recursion queries.
+ */
+export const MEMORY_RETROSPECTIVE_SOURCES: readonly string[] = [
+  MEMORY_RETROSPECTIVE_SOURCE,
+  MEMORY_RETROSPECTIVE_FORK_SOURCE,
+];
+
 /**
  * Dedicated `group_id` value for memory-retrospective background
  * conversations. Placed under `system:background` alongside auto-analysis,
  * heartbeat, and filing conversations.
  */
 export const MEMORY_RETROSPECTIVE_GROUP_ID = "system:background";
+
+/**
+ * `metadata.kind` value stamped on the user-role instruction message that
+ * fork-based retrospectives append to the forked conversation. Used purely
+ * for observability — operators inspecting a retrospective fork's history
+ * can tell the user-role message apart from a real user turn.
+ */
+export const MEMORY_RETROSPECTIVE_INSTRUCTION_KIND =
+  "memory_retrospective_instruction";

package/src/memory/memory-retrospective-enqueue.ts

@@ -20,7 +20,7 @@ import {
 import { getLogger } from "../util/logger.js";
 import { getConversationSource } from "./conversation-crud.js";
 import { upsertMemoryRetrospectiveJob } from "./jobs-store.js";
-import { MEMORY_RETROSPECTIVE_SOURCE } from "./memory-retrospective-constants.js";
+import { MEMORY_RETROSPECTIVE_SOURCES } from "./memory-retrospective-constants.js";
 
 const log = getLogger("memory-retrospective-enqueue");
 
@@ -67,7 +67,8 @@ export function enqueueMemoryRetrospectiveIfEnabled(args: {
 export function isMemoryRetrospectiveConversation(
   conversationId: string,
 ): boolean {
-  return getConversationSource(conversationId) === MEMORY_RETROSPECTIVE_SOURCE;
+  const source = getConversationSource(conversationId);
+  return source !== null && MEMORY_RETROSPECTIVE_SOURCES.includes(source);
 }
 
 /**