@vellumai/assistant 0.4.48 → 0.4.50

package/src/instrument.ts

@@ -1,4 +1,4 @@
-import { arch, platform, release } from "node:os";
+import { arch, hostname, platform, release } from "node:os";
 
 import * as Sentry from "@sentry/node";
 
@@ -47,12 +47,14 @@ export function initSentry(): void {
     dist: COMMIT_SHA,
     environment: APP_VERSION === "0.0.0-dev" ? "development" : "production",
     sendDefaultPii: false,
+    serverName: hostname(),
     initialScope: {
       tags: {
         commit: COMMIT_SHA,
         os_platform: platform(),
         os_release: release(),
         os_arch: arch(),
+        server_name: hostname(),
         runtime: "bun",
         runtime_version:
           typeof Bun !== "undefined" ? Bun.version : process.version,
@@ -90,3 +92,61 @@ export function initSentry(): void {
 export async function closeSentry(): Promise<void> {
   await Sentry.close();
 }
+
+// ── Dynamic session-scoped Sentry tags ──────────────────────────────
+//
+// These tags change per conversation turn and are set on the current
+// Sentry scope before the agent loop runs. Any `Sentry.captureException`
+// call within that async execution chain (e.g. inside agent/loop.ts)
+// will inherit these tags, enabling filtering by conversation, session,
+// user, or assistant in the Sentry dashboard.
+
+/** Tag keys set by {@link setSentrySessionContext}. */
+const SESSION_TAG_KEYS = [
+  "assistant_id",
+  "conversation_id",
+  "session_id",
+  "message_count",
+  "user_identifier",
+] as const;
+
+export interface SentrySessionContext {
+  /** Internal assistant ID (daemon uses 'self'). */
+  assistantId: string;
+  /** Conversation/session identifier. */
+  conversationId: string;
+  /** Number of messages in the conversation at time of the turn. */
+  messageCount: number;
+  /** Stable per-user identifier (guardian principal ID or similar). */
+  userIdentifier?: string;
+}
+
+/**
+ * Set session-scoped tags on the current Sentry scope.
+ *
+ * Call at the start of each agent loop turn so that any exceptions
+ * captured within the turn include conversation/session context.
+ */
+export function setSentrySessionContext(ctx: SentrySessionContext): void {
+  Sentry.setTag("assistant_id", ctx.assistantId);
+  Sentry.setTag("conversation_id", ctx.conversationId);
+  // session_id mirrors conversation_id — in this codebase they are the
+  // same value, but downstream Sentry users may search by either name.
+  Sentry.setTag("session_id", ctx.conversationId);
+  Sentry.setTag("message_count", String(ctx.messageCount));
+  if (ctx.userIdentifier) {
+    Sentry.setTag("user_identifier", ctx.userIdentifier);
+  }
+}
+
+/**
+ * Clear session-scoped tags from the current Sentry scope.
+ *
+ * Call in the finally block after the agent loop completes so tags
+ * from one conversation do not leak into unrelated error captures.
+ */
+export function clearSentrySessionContext(): void {
+  for (const key of SESSION_TAG_KEYS) {
+    Sentry.setTag(key, undefined);
+  }
+}

package/src/logfire.ts

@@ -1,4 +1,4 @@
-import { getLogfireToken, isMonitoringEnabled } from "./config/env.js";
+import { getLogfireToken } from "./config/env.js";
 import type {
   Message,
   Provider,
@@ -13,7 +13,7 @@ const log = getLogger("logfire");
 
 type LogfireModule = typeof import("@pydantic/logfire-node");
 
-const LOGFIRE_ENABLED: boolean = !!getLogfireToken() && isMonitoringEnabled();
+let logfireEnabled: boolean = !!getLogfireToken();
 
 let logfireInstance: LogfireModule | null = null;
 
@@ -23,7 +23,7 @@ let logfireInstance: LogfireModule | null = null;
  * Non-fatal on failure (logs warning and continues).
  */
 export async function initLogfire(): Promise<void> {
-  if (!LOGFIRE_ENABLED) return;
+  if (!logfireEnabled) return;
 
   try {
     const logfire = await import("@pydantic/logfire-node");
@@ -42,12 +42,23 @@ export async function initLogfire(): Promise<void> {
   }
 }
 
+/**
+ * Disable Logfire after early initialization. Called when the user has opted
+ * out via the feature flag. Nulls out the instance so future wrapWithLogfire
+ * calls become no-ops.
+ */
+export function disableLogfire(): void {
+  logfireEnabled = false;
+  logfireInstance = null;
+  log.info("Logfire disabled by feature flag");
+}
+
 /**
  * Wraps a provider with Logfire tracing spans.
- * When LOGFIRE_ENABLED is false, returns the provider as-is (no wrapper allocated).
+ * When logfireEnabled is false, returns the provider as-is (no wrapper allocated).
  */
 export function wrapWithLogfire(provider: Provider): Provider {
-  if (!LOGFIRE_ENABLED) return provider;
+  if (!logfireEnabled) return provider;
   return new LogfireProvider(provider);
 }
 

package/src/memory/admin.ts

@@ -1,14 +1,9 @@
 import { getConfig } from "../config/loader.js";
 import { getLogger } from "../util/logger.js";
-import {
-  listPendingConflictDetails,
-  resolveConflict,
-} from "./conflict-store.js";
 import { rawGet } from "./db.js";
 import { getMemoryBackendStatus } from "./embedding-backend.js";
 import { enqueueBackfillJob, enqueueRebuildIndexJob } from "./indexer.js";
 import {
-  enqueueCleanupResolvedConflictsJob,
   enqueueCleanupStaleSupersededItemsJob,
   getMemoryJobCounts,
 } from "./jobs-store.js";
@@ -28,94 +23,18 @@ export interface MemorySystemStatus {
     summaries: number;
     embeddings: number;
   };
-  conflicts: {
-    pending: number;
-    resolved: number;
-    oldestPendingAgeMs: number | null;
-  };
   cleanup: {
-    resolvedBacklog: number;
     supersededBacklog: number;
-    resolvedCompleted24h: number;
     supersededCompleted24h: number;
   };
   jobs: Record<string, number>;
 }
 
-export interface MemoryConflictAndCleanupStats {
-  conflicts: MemorySystemStatus["conflicts"];
-  cleanup: MemorySystemStatus["cleanup"];
-}
-
-interface ConflictStatsRow {
-  pending_count: number | null;
-  resolved_count: number | null;
-  oldest_pending_created_at: number | null;
-}
-
 interface CleanupStatsRow {
-  resolved_backlog: number | null;
   superseded_backlog: number | null;
-  resolved_completed_24h: number | null;
   superseded_completed_24h: number | null;
 }
 
-/** Lightweight query for conflict/cleanup metrics only — no table counts or job totals. */
-export function getMemoryConflictAndCleanupStats(): MemoryConflictAndCleanupStats {
-  const conflictStats = rawGet<ConflictStatsRow>(`
-    SELECT
-      SUM(CASE WHEN status = 'pending_clarification' THEN 1 ELSE 0 END) AS pending_count,
-      SUM(CASE WHEN status != 'pending_clarification' THEN 1 ELSE 0 END) AS resolved_count,
-      MIN(CASE WHEN status = 'pending_clarification' THEN created_at END) AS oldest_pending_created_at
-    FROM memory_item_conflicts
-  `);
-  const pending = conflictStats?.pending_count ?? 0;
-  const oldestPendingCreatedAt =
-    conflictStats?.oldest_pending_created_at ?? null;
-  const oldestPendingAgeMs =
-    oldestPendingCreatedAt == null
-      ? null
-      : Math.max(0, Date.now() - oldestPendingCreatedAt);
-  const throughputWindowStartMs = Date.now() - 24 * 60 * 60 * 1000;
-  const cleanupStats = rawGet<CleanupStatsRow>(
-    `
-    SELECT
-      SUM(CASE
-        WHEN type = 'cleanup_resolved_conflicts' AND status IN ('pending', 'running')
-        THEN 1 ELSE 0 END
-      ) AS resolved_backlog,
-      SUM(CASE
-        WHEN type = 'cleanup_stale_superseded_items' AND status IN ('pending', 'running')
-        THEN 1 ELSE 0 END
-      ) AS superseded_backlog,
-      SUM(CASE
-        WHEN type = 'cleanup_resolved_conflicts' AND status = 'completed' AND updated_at >= ?
-        THEN 1 ELSE 0 END
-      ) AS resolved_completed_24h,
-      SUM(CASE
-        WHEN type = 'cleanup_stale_superseded_items' AND status = 'completed' AND updated_at >= ?
-        THEN 1 ELSE 0 END
-      ) AS superseded_completed_24h
-    FROM memory_jobs
-  `,
-    throughputWindowStartMs,
-    throughputWindowStartMs,
-  );
-  return {
-    conflicts: {
-      pending,
-      resolved: conflictStats?.resolved_count ?? 0,
-      oldestPendingAgeMs,
-    },
-    cleanup: {
-      resolvedBacklog: cleanupStats?.resolved_backlog ?? 0,
-      supersededBacklog: cleanupStats?.superseded_backlog ?? 0,
-      resolvedCompleted24h: cleanupStats?.resolved_completed_24h ?? 0,
-      supersededCompleted24h: cleanupStats?.superseded_completed_24h ?? 0,
-    },
-  };
-}
-
 export function getMemorySystemStatus(): MemorySystemStatus {
   const config = getConfig();
   const backend = getMemoryBackendStatus(config);
@@ -125,36 +44,14 @@ export function getMemorySystemStatus(): MemorySystemStatus {
     summaries: countTable("memory_summaries"),
     embeddings: countTable("memory_embeddings"),
   };
-  const conflictStats = rawGet<ConflictStatsRow>(`
-    SELECT
-      SUM(CASE WHEN status = 'pending_clarification' THEN 1 ELSE 0 END) AS pending_count,
-      SUM(CASE WHEN status != 'pending_clarification' THEN 1 ELSE 0 END) AS resolved_count,
-      MIN(CASE WHEN status = 'pending_clarification' THEN created_at END) AS oldest_pending_created_at
-    FROM memory_item_conflicts
-  `);
-  const pending = conflictStats?.pending_count ?? 0;
-  const oldestPendingCreatedAt =
-    conflictStats?.oldest_pending_created_at ?? null;
-  const oldestPendingAgeMs =
-    oldestPendingCreatedAt == null
-      ? null
-      : Math.max(0, Date.now() - oldestPendingCreatedAt);
   const throughputWindowStartMs = Date.now() - 24 * 60 * 60 * 1000;
   const cleanupStats = rawGet<CleanupStatsRow>(
     `
     SELECT
-      SUM(CASE
-        WHEN type = 'cleanup_resolved_conflicts' AND status IN ('pending', 'running')
-        THEN 1 ELSE 0 END
-      ) AS resolved_backlog,
       SUM(CASE
         WHEN type = 'cleanup_stale_superseded_items' AND status IN ('pending', 'running')
         THEN 1 ELSE 0 END
       ) AS superseded_backlog,
-      SUM(CASE
-        WHEN type = 'cleanup_resolved_conflicts' AND status = 'completed' AND updated_at >= ?
-        THEN 1 ELSE 0 END
-      ) AS resolved_completed_24h,
       SUM(CASE
         WHEN type = 'cleanup_stale_superseded_items' AND status = 'completed' AND updated_at >= ?
         THEN 1 ELSE 0 END
@@ -162,7 +59,6 @@ export function getMemorySystemStatus(): MemorySystemStatus {
     FROM memory_jobs
   `,
     throughputWindowStartMs,
-    throughputWindowStartMs,
   );
   return {
     enabled: backend.enabled,
@@ -171,15 +67,8 @@ export function getMemorySystemStatus(): MemorySystemStatus {
     provider: backend.provider,
     model: backend.model,
     counts,
-    conflicts: {
-      pending,
-      resolved: conflictStats?.resolved_count ?? 0,
-      oldestPendingAgeMs,
-    },
     cleanup: {
-      resolvedBacklog: cleanupStats?.resolved_backlog ?? 0,
       supersededBacklog: cleanupStats?.superseded_backlog ?? 0,
-      resolvedCompleted24h: cleanupStats?.resolved_completed_24h ?? 0,
       supersededCompleted24h: cleanupStats?.superseded_completed_24h ?? 0,
     },
     jobs: getMemoryJobCounts(),
@@ -203,95 +92,17 @@ export function requestMemoryRebuildIndex(): string {
 }
 
 export function requestMemoryCleanup(retentionMs?: number): {
-  resolvedConflictsJobId: string;
   staleSupersededItemsJobId: string;
 } {
-  const resolvedConflictsJobId =
-    enqueueCleanupResolvedConflictsJob(retentionMs);
   const staleSupersededItemsJobId =
     enqueueCleanupStaleSupersededItemsJob(retentionMs);
   log.info(
-    { resolvedConflictsJobId, staleSupersededItemsJobId, retentionMs },
+    { staleSupersededItemsJobId, retentionMs },
     "Queued memory cleanup jobs",
   );
-  return { resolvedConflictsJobId, staleSupersededItemsJobId };
+  return { staleSupersededItemsJobId };
 }
 
 export async function queryMemory(query: string, conversationId: string) {
   return queryMemoryForCli(query, conversationId, getConfig());
 }
-
-export interface DismissConflictsResult {
-  dismissed: number;
-  remaining: number;
-  details: Array<{
-    id: string;
-    existingStatement: string;
-    candidateStatement: string;
-  }>;
-}
-
-/**
- * Dismiss pending memory conflicts. With `all: true`, dismisses every
- * pending conflict. Otherwise, dismisses only conflicts matching the
- * given `pattern` regex against either statement.
- */
-export function dismissPendingConflicts(options: {
-  all?: boolean;
-  pattern?: RegExp;
-  scopeId?: string;
-}): DismissConflictsResult {
-  const scopeId = options.scopeId ?? "default";
-  const dismissed: DismissConflictsResult["details"] = [];
-  const BATCH_SIZE = 1000;
-
-  // Cursor-based pagination: track last seen (createdAt, id) to advance past
-  // previously inspected rows. This ensures pattern mode scans all pending
-  // conflicts even when non-matching rows outnumber the batch size.
-  let cursor: { createdAt: number; id: string } | undefined;
-  let batch = listPendingConflictDetails(scopeId, BATCH_SIZE);
-  while (batch.length > 0) {
-    for (const conflict of batch) {
-      const matches =
-        options.all ||
-        (options.pattern &&
-          (options.pattern.test(conflict.existingStatement) ||
-            options.pattern.test(conflict.candidateStatement)));
-      if (!matches) continue;
-
-      resolveConflict(conflict.id, {
-        status: "dismissed",
-        resolutionNote: options.all
-          ? "Bulk dismissed via CLI (dismiss-conflicts --all)."
-          : `Dismissed via CLI (pattern: ${options.pattern?.source}).`,
-      });
-      dismissed.push({
-        id: conflict.id,
-        existingStatement: conflict.existingStatement,
-        candidateStatement: conflict.candidateStatement,
-      });
-    }
-    // No more rows to inspect
-    if (batch.length < BATCH_SIZE) break;
-    const lastRow = batch[batch.length - 1];
-    cursor = { createdAt: lastRow.createdAt, id: lastRow.id };
-    batch = listPendingConflictDetails(scopeId, BATCH_SIZE, cursor);
-  }
-
-  // Get true remaining count via SQL to avoid batch-size truncation
-  const remaining =
-    rawGet<{ c: number }>(
-      `SELECT COUNT(*) AS c FROM memory_item_conflicts WHERE scope_id = ? AND status = 'pending_clarification'`,
-      scopeId,
-    )?.c ?? 0;
-
-  log.info(
-    { dismissed: dismissed.length, remaining, scopeId },
-    "Dismissed pending conflicts",
-  );
-  return {
-    dismissed: dismissed.length,
-    remaining,
-    details: dismissed,
-  };
-}

package/src/memory/canonical-guardian-store.ts

@@ -17,6 +17,21 @@ import {
   canonicalGuardianRequests,
 } from "./schema.js";
 
+// ---------------------------------------------------------------------------
+// Expiry helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns true when a canonical request has passed its `expiresAt` deadline.
+ * Requests without an `expiresAt` are never considered expired by this check.
+ */
+export function isRequestExpired(
+  request: Pick<CanonicalGuardianRequest, "expiresAt">,
+): boolean {
+  if (!request.expiresAt) return false;
+  return new Date(request.expiresAt).getTime() < Date.now();
+}
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -444,6 +459,27 @@ export function resolveCanonicalGuardianRequest(
   return getCanonicalGuardianRequest(id);
 }
 
+/**
+ * Expire all pending canonical guardian requests in a single bulk update.
+ *
+ * Called at daemon startup to clean up requests that can never be completed
+ * because the in-memory pending-interactions Map (which holds session
+ * references needed by resolvers) was wiped on restart.
+ *
+ * Returns the number of requests transitioned from pending → expired.
+ */
+export function expireAllPendingCanonicalRequests(): number {
+  const db = getDb();
+  const now = new Date().toISOString();
+
+  db.update(canonicalGuardianRequests)
+    .set({ status: "expired", updatedAt: now })
+    .where(eq(canonicalGuardianRequests.status, "pending"))
+    .run();
+
+  return rawChanges();
+}
+
 // ---------------------------------------------------------------------------
 // Canonical Guardian Deliveries
 // ---------------------------------------------------------------------------
@@ -624,14 +660,14 @@ export function listPendingRequestsByConversationScope(
   const result: CanonicalGuardianRequest[] = [];
 
   for (const req of bySource) {
-    if (!seen.has(req.id)) {
+    if (!seen.has(req.id) && !isRequestExpired(req)) {
       seen.add(req.id);
       result.push(req);
     }
   }
 
   for (const req of byDestination) {
-    if (!seen.has(req.id)) {
+    if (!seen.has(req.id) && !isRequestExpired(req)) {
       seen.add(req.id);
       result.push(req);
     }

package/src/memory/conversation-crud.ts

@@ -19,7 +19,6 @@ import {
   conversations,
   llmRequestLogs,
   memoryEmbeddings,
-  memoryItemEntities,
   memoryItems,
   memoryItemSources,
   memorySegments,
@@ -503,19 +502,6 @@ export function clearAll(): { conversations: number; messages: number } {
   // triggers so that the subsequent base-table DELETEs don't also fail
   // (SQLite triggers are atomic with the triggering statement, so a
   // corrupted FTS table would roll back every base-table DELETE).
-  let segmentFtsCorrupted = false;
-  try {
-    rawExec("DELETE FROM memory_segment_fts");
-  } catch (err) {
-    log.warn(
-      { err },
-      "clearAll: failed to clear memory_segment_fts — dropping triggers so base-table cleanup can proceed",
-    );
-    rawExec("DROP TRIGGER IF EXISTS memory_segments_ai");
-    rawExec("DROP TRIGGER IF EXISTS memory_segments_ad");
-    rawExec("DROP TRIGGER IF EXISTS memory_segments_au");
-    segmentFtsCorrupted = true;
-  }
   rawExec("DELETE FROM memory_item_sources");
   rawExec("DELETE FROM memory_segments");
   rawExec("DELETE FROM memory_items");
@@ -548,21 +534,6 @@ export function clearAll(): { conversations: number; messages: number } {
   // DELETEs have completed. Dropping the virtual table clears the corruption,
   // and recreating it + triggers means subsequent writes maintain FTS
   // consistency without requiring a daemon restart.
-  if (segmentFtsCorrupted) {
-    rawExec("DROP TABLE IF EXISTS memory_segment_fts");
-    rawExec(
-      `CREATE VIRTUAL TABLE IF NOT EXISTS memory_segment_fts USING fts5(segment_id UNINDEXED, text)`,
-    );
-    rawExec(
-      `CREATE TRIGGER IF NOT EXISTS memory_segments_ai AFTER INSERT ON memory_segments BEGIN INSERT INTO memory_segment_fts(segment_id, text) VALUES (new.id, new.text); END`,
-    );
-    rawExec(
-      `CREATE TRIGGER IF NOT EXISTS memory_segments_ad AFTER DELETE ON memory_segments BEGIN DELETE FROM memory_segment_fts WHERE segment_id = old.id; END`,
-    );
-    rawExec(
-      `CREATE TRIGGER IF NOT EXISTS memory_segments_au AFTER UPDATE ON memory_segments BEGIN DELETE FROM memory_segment_fts WHERE segment_id = old.id; INSERT INTO memory_segment_fts(segment_id, text) VALUES (new.id, new.text); END`,
-    );
-  }
   if (messagesFtsCorrupted) {
     rawExec("DROP TABLE IF EXISTS messages_fts");
     rawExec(
@@ -787,10 +758,6 @@ export function deleteMessageById(messageId: string): DeletedMemoryIds {
       result.orphanedItemIds = orphanedIds;
 
       if (orphanedIds.length > 0) {
-        // Delete memory_item_entities (no FK cascade on this table).
-        tx.delete(memoryItemEntities)
-          .where(inArray(memoryItemEntities.memoryItemId, orphanedIds))
-          .run();
         // Delete embeddings referencing these items.
         tx.delete(memoryEmbeddings)
           .where(

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

@@ -117,6 +117,27 @@ export function getOrCreateConversation(conversationKey: string): {
       return { conversationId: existing.conversationId, created: false };
     }
 
+    // Check if the conversationKey itself is an existing conversation ID.
+    // This happens when the client loads a thread from the conversations list
+    // and uses the server's conversationId as its local sessionId / conversationKey.
+    const existingConversation = tx
+      .select({ id: conversations.id })
+      .from(conversations)
+      .where(eq(conversations.id, conversationKey))
+      .get();
+
+    if (existingConversation) {
+      tx.insert(conversationKeys)
+        .values({
+          id: uuid(),
+          conversationKey,
+          conversationId: existingConversation.id,
+          createdAt: Date.now(),
+        })
+        .run();
+      return { conversationId: existingConversation.id, created: false };
+    }
+
     const now = Date.now();
     const conversationId = uuid();
 

package/src/memory/conversation-queries.ts

@@ -6,10 +6,24 @@ import { parseConversation, parseMessage } from "./conversation-crud.js";
 import { ensureDisplayOrderMigration } from "./conversation-display-order-migration.js";
 import { getDb, rawAll } from "./db.js";
 import { conversations, messages } from "./schema.js";
-import { buildFtsMatchQuery } from "./search/lexical.js";
 
 const log = getLogger("conversation-store");
 
+/**
+ * Build an FTS5 MATCH query string from natural text by extracting tokens.
+ * Used for messages_fts full-text search over conversation content.
+ */
+function buildFtsMatchQuery(text: string): string | null {
+  const tokens = text
+    .toLowerCase()
+    .split(/[^a-z0-9_]+/g)
+    .map((token) => token.trim())
+    .filter((token) => token.length >= 2);
+  if (tokens.length === 0) return null;
+  const unique = [...new Set(tokens)].slice(0, 24);
+  return unique.map((token) => `"${token.replace(/"/g, '""')}"`).join(" OR ");
+}
+
 export function listConversations(
   limit?: number,
   includeBackground = false,
@@ -160,7 +174,9 @@ export function isLastUserMessageToolResult(conversationId: string): boolean {
       Array.isArray(parsed) &&
       parsed.length > 0 &&
       parsed.every(
-        (block: Record<string, unknown>) => block.type === "tool_result",
+        (block: Record<string, unknown>) =>
+          block.type === "tool_result" ||
+          block.type === "web_search_tool_result",
       )
     ) {
       return true;
@@ -375,7 +391,10 @@ function buildExcerpt(rawContent: string, query: string): string {
         if (typeof block === "object" && block != null) {
           if (block.type === "text" && typeof block.text === "string") {
             parts.push(block.text);
-          } else if (block.type === "tool_result") {
+          } else if (
+            block.type === "tool_result" ||
+            block.type === "web_search_tool_result"
+          ) {
             const inner = Array.isArray(block.content) ? block.content : [];
             for (const ib of inner) {
               if (ib?.type === "text" && typeof ib.text === "string")

package/src/memory/db-init.ts

@@ -28,6 +28,7 @@ import {
   createMediaAssetsTables,
   createMessagesFts,
   createNotificationTables,
+  createOAuthTables,
   createScopedApprovalGrantsTable,
   createSequenceTables,
   createTasksAndWorkItemsTables,
@@ -36,6 +37,7 @@ import {
   migrateBackfillContactInteractionStats,
   migrateBackfillGuardianPrincipalId,
   migrateBackfillUsageCacheAccounting,
+  migrateCallSessionInviteMetadata,
   migrateCallSessionMode,
   migrateCanonicalGuardianDeliveriesDestinationIndex,
   migrateCanonicalGuardianRequesterChatId,
@@ -48,7 +50,10 @@ import {
   migrateConversationsThreadTypeIndex,
   migrateDropAccountsTable,
   migrateDropAssistantIdColumns,
+  migrateDropConflicts,
+  migrateDropEntityTables,
   migrateDropLegacyMemberGuardianTables,
+  migrateDropMemorySegmentFts,
   migrateDropRemindersTable,
   migrateDropUsageCompositeIndexes,
   migrateFkCascadeRebuilds,
@@ -62,9 +67,12 @@ import {
   migrateGuardianVerificationPurpose,
   migrateGuardianVerificationSessions,
   migrateInviteCodeHashColumn,
+  migrateMemoryItemSupersession,
   migrateMessagesFtsBackfill,
   migrateNormalizePhoneIdentities,
   migrateNotificationDeliveryThreadDecision,
+  migrateOAuthAppsClientSecretPath,
+  migrateOAuthProvidersPingUrl,
   migrateReminderRoutingIntent,
   migrateRemindersToSchedules,
   migrateRenameGuardianVerificationValues,
@@ -340,6 +348,30 @@ export function initializeDb(): void {
   // 52. Drop the legacy reminders table after data migration
   migrateDropRemindersTable(database);
 
+  // 53. OAuth provider/app/connection tables
+  createOAuthTables(database);
+
+  // 54. Add explicit client_secret_credential_path to oauth_apps
+  migrateOAuthAppsClientSecretPath(database);
+
+  // 55. Add ping_url column to oauth_providers
+  migrateOAuthProvidersPingUrl(database);
+
+  // 56. Add supersession tracking columns and override confidence to memory_items
+  migrateMemoryItemSupersession(database);
+
+  // 56b. Drop unused entity tables (entity search replaced by hybrid search on item statements)
+  migrateDropEntityTables(database);
+
+  // 57. Drop memory_segment_fts virtual table and triggers (replaced by Qdrant hybrid search)
+  migrateDropMemorySegmentFts(database);
+
+  // 58. Drop memory_item_conflicts table (conflict resolution system removed)
+  migrateDropConflicts(database);
+
+  // 59. Add invite metadata columns to call_sessions for outbound invite call routing
+  migrateCallSessionInviteMetadata(database);
+
   validateMigrationState(database);
 
   if (process.env.BUN_TEST === "1") {