@vellumai/assistant 0.4.49 → 0.4.51

package/src/memory/jobs-worker.ts

@@ -2,20 +2,11 @@ import { getConfig } from "../config/loader.js";
 import type { AssistantConfig } from "../config/types.js";
 import { getLogger } from "../util/logger.js";
 import { rawRun } from "./db.js";
-import { reconcileFtsIndexes } from "./fts-reconciler.js";
+import { backfillJob } from "./job-handlers/backfill.js";
 import {
-  backfillEntityRelationsJob,
-  backfillJob,
-} from "./job-handlers/backfill.js";
-import {
-  checkContradictionsJob,
   cleanupStaleSupersededItemsJob,
   pruneOldConversationsJob,
 } from "./job-handlers/cleanup.js";
-import {
-  cleanupResolvedConflictsJob,
-  resolvePendingConflictsForMessageJob,
-} from "./job-handlers/conflict.js";
 // ── Per-job-type handlers ──────────────────────────────────────────
 import {
   embedAttachmentJob,
@@ -24,19 +15,13 @@ import {
   embedSegmentJob,
   embedSummaryJob,
 } from "./job-handlers/embedding.js";
-import {
-  extractEntitiesJob,
-  extractItemsJob,
-} from "./job-handlers/extraction.js";
+import { extractItemsJob } from "./job-handlers/extraction.js";
 import {
   deleteQdrantVectorsJob,
   rebuildIndexJob,
 } from "./job-handlers/index-maintenance.js";
 import { mediaProcessingJob } from "./job-handlers/media-processing.js";
-import {
-  buildConversationSummaryJob,
-  buildGlobalSummaryJob,
-} from "./job-handlers/summarization.js";
+import { buildConversationSummaryJob } from "./job-handlers/summarization.js";
 import {
   BackendUnavailableError,
   classifyError,
@@ -47,20 +32,14 @@ import {
   claimMemoryJobs,
   completeMemoryJob,
   deferMemoryJob,
-  enqueueCleanupResolvedConflictsJob,
   enqueueCleanupStaleSupersededItemsJob,
   enqueuePruneOldConversationsJob,
-  enqueueReconcileFtsJob,
   failMemoryJob,
   failStalledJobs,
   type MemoryJob,
   resetRunningJobsToPending,
 } from "./jobs-store.js";
 import { QdrantCircuitOpenError } from "./qdrant-circuit-breaker.js";
-import { bumpMemoryVersion } from "./recall-cache.js";
-
-// Re-export public utilities consumed by tests and other modules
-export { currentWeekWindow } from "./job-utils.js";
 
 const log = getLogger("memory-jobs-worker");
 
@@ -157,7 +136,6 @@ export async function runMemoryJobsOnce(
       try {
         await processJob(job, config);
         completeMemoryJob(job.id);
-        bumpMemoryVersion();
         groupProcessed += 1;
       } catch (err) {
         try {
@@ -292,13 +270,7 @@ async function processJob(
       await extractItemsJob(job);
       return;
     case "extract_entities":
-      await extractEntitiesJob(job, config);
-      return;
-    case "resolve_pending_conflicts_for_message":
-      await resolvePendingConflictsForMessageJob(job, config);
-      return;
-    case "cleanup_resolved_conflicts":
-      cleanupResolvedConflictsJob(job, config);
+      // Entity extraction has been removed — silently drop legacy jobs
       return;
     case "cleanup_stale_superseded_items":
       cleanupStaleSupersededItemsJob(job, config);
@@ -306,30 +278,22 @@ async function processJob(
     case "prune_old_conversations":
       pruneOldConversationsJob(job, config);
       return;
-    case "check_contradictions":
-      await checkContradictionsJob(job);
-      return;
     case "build_conversation_summary":
       await buildConversationSummaryJob(job, config);
       return;
-    case "refresh_weekly_summary":
-      await buildGlobalSummaryJob("weekly_global", config);
-      return;
-    case "refresh_monthly_summary":
-      await buildGlobalSummaryJob("monthly_global", config);
-      return;
     case "backfill":
       backfillJob(job, config);
       return;
     case "backfill_entity_relations":
-      backfillEntityRelationsJob(job, config);
+      // Entity relation backfill has been removed — silently drop legacy jobs
+      return;
+    case "refresh_weekly_summary":
+    case "refresh_monthly_summary":
+      // Global summary rollups have been removed — silently drop legacy jobs
       return;
     case "rebuild_index":
       rebuildIndexJob();
       return;
-    case "reconcile_fts":
-      reconcileFtsIndexes();
-      return;
     case "delete_qdrant_vectors":
       await deleteQdrantVectorsJob(job);
       return;
@@ -371,9 +335,6 @@ export function maybeEnqueueScheduledCleanupJobs(
   if (nowMs - lastScheduledCleanupEnqueueMs < cleanup.enqueueIntervalMs)
     return false;
 
-  const resolvedConflictsJobId = enqueueCleanupResolvedConflictsJob(
-    cleanup.resolvedConflictRetentionMs,
-  );
   const staleSupersededItemsJobId = enqueueCleanupStaleSupersededItemsJob(
     cleanup.supersededItemRetentionMs,
   );
@@ -381,16 +342,12 @@ export function maybeEnqueueScheduledCleanupJobs(
     cleanup.conversationRetentionDays > 0
       ? enqueuePruneOldConversationsJob(cleanup.conversationRetentionDays)
       : null;
-  const reconcileFtsJobId = enqueueReconcileFtsJob();
   lastScheduledCleanupEnqueueMs = nowMs;
   log.debug(
     {
-      resolvedConflictsJobId,
       staleSupersededItemsJobId,
       pruneConversationsJobId,
-      reconcileFtsJobId,
       enqueueIntervalMs: cleanup.enqueueIntervalMs,
-      resolvedConflictRetentionMs: cleanup.resolvedConflictRetentionMs,
       supersededItemRetentionMs: cleanup.supersededItemRetentionMs,
       conversationRetentionDays: cleanup.conversationRetentionDays,
     },

package/src/memory/migrations/104-core-indexes.ts

@@ -69,9 +69,9 @@ export function createCoreIndexes(database: DrizzleDb): void {
   database.run(
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_memory_items_last_seen_at ON memory_items(last_seen_at)`,
   );
-  // Partial covering index for directItemSearch: the LIKE '%term%' pattern can't
-  // seek a B-tree, but this index lets SQLite scan only active non-invalidated rows
-  // and evaluate LIKE + return columns without touching the main table.
+  // Partial covering index for active memory item queries: this index lets SQLite
+  // scan only active non-invalidated rows and return columns without touching
+  // the main table.
   migrateDropActiveSearchIndex(database);
   database.run(/*sql*/ `
     CREATE INDEX IF NOT EXISTS idx_memory_items_active_search

package/src/memory/migrations/149-oauth-tables.ts

@@ -18,6 +18,7 @@ export function createOAuthTables(database: DrizzleDb): void {
       extra_params TEXT,
       callback_transport TEXT,
       loopback_port INTEGER,
+      ping_url TEXT,
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL
     )
@@ -28,6 +29,7 @@ export function createOAuthTables(database: DrizzleDb): void {
       id TEXT PRIMARY KEY,
       provider_key TEXT NOT NULL REFERENCES oauth_providers(provider_key),
       client_id TEXT NOT NULL,
+      client_secret_credential_path TEXT NOT NULL,
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL
     )

package/src/memory/migrations/150-oauth-apps-client-secret-path.ts

@@ -0,0 +1,98 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * Add client_secret_credential_path column to oauth_apps.
+ *
+ * Makes explicit what was previously implicit: the credential path pattern
+ * `oauth_app/${id}/client_secret`. Steps:
+ *
+ * 1. ALTER TABLE to add the column (nullable initially).
+ * 2. Backfill existing rows with `oauth_app/${id}/client_secret`.
+ * 3. Rebuild the table to enforce NOT NULL (SQLite doesn't support ALTER COLUMN).
+ *
+ * Idempotent — skips if the column already exists with NOT NULL.
+ */
+export function migrateOAuthAppsClientSecretPath(database: DrizzleDb): void {
+  withCrashRecovery(
+    database,
+    "migration_oauth_apps_client_secret_path_v1",
+    () => {
+      const raw = getSqliteFrom(database);
+
+      // Guard: table must exist
+      const tableExists = raw
+        .query(
+          `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'oauth_apps'`,
+        )
+        .get();
+      if (!tableExists) return;
+
+      // Guard: check if column already exists with NOT NULL
+      const colInfo = raw
+        .query(
+          `SELECT "notnull" FROM pragma_table_info('oauth_apps') WHERE name = 'client_secret_credential_path'`,
+        )
+        .get() as { notnull: number } | null;
+      if (colInfo && colInfo.notnull === 1) return;
+
+      // Step 1: Add the column (nullable) — wrapped in try/catch for idempotency
+      if (!colInfo) {
+        try {
+          raw.exec(
+            /*sql*/ `ALTER TABLE oauth_apps ADD COLUMN client_secret_credential_path TEXT`,
+          );
+        } catch {
+          // Column may already exist from a previous partial run
+        }
+      }
+
+      // Step 2: Backfill existing rows
+      raw.exec(
+        /*sql*/ `UPDATE oauth_apps SET client_secret_credential_path = 'oauth_app/' || id || '/client_secret' WHERE client_secret_credential_path IS NULL`,
+      );
+
+      // Step 3: Rebuild the table to enforce NOT NULL
+      raw.exec("PRAGMA foreign_keys = OFF");
+      try {
+        raw.exec("BEGIN");
+
+        raw.exec(/*sql*/ `
+          CREATE TABLE oauth_apps_new (
+            id TEXT PRIMARY KEY,
+            provider_key TEXT NOT NULL REFERENCES oauth_providers(provider_key),
+            client_id TEXT NOT NULL,
+            client_secret_credential_path TEXT NOT NULL DEFAULT '',
+            created_at INTEGER NOT NULL,
+            updated_at INTEGER NOT NULL
+          )
+        `);
+
+        raw.exec(/*sql*/ `
+          INSERT INTO oauth_apps_new
+          SELECT id, provider_key, client_id, client_secret_credential_path, created_at, updated_at
+          FROM oauth_apps
+        `);
+
+        raw.exec(/*sql*/ `DROP TABLE oauth_apps`);
+        raw.exec(/*sql*/ `ALTER TABLE oauth_apps_new RENAME TO oauth_apps`);
+
+        // Recreate the unique index
+        raw.exec(
+          /*sql*/ `CREATE UNIQUE INDEX IF NOT EXISTS idx_oauth_apps_provider_client ON oauth_apps(provider_key, client_id)`,
+        );
+
+        raw.exec("COMMIT");
+      } catch (e) {
+        try {
+          raw.exec("ROLLBACK");
+        } catch {
+          /* no active transaction */
+        }
+        throw e;
+      } finally {
+        raw.exec("PRAGMA foreign_keys = ON");
+      }
+    },
+  );
+}

package/src/memory/migrations/151-oauth-providers-ping-url.ts

@@ -0,0 +1,11 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateOAuthProvidersPingUrl(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(/*sql*/ `ALTER TABLE oauth_providers ADD COLUMN ping_url TEXT`);
+  } catch {
+    // Column already exists — nothing to do.
+  }
+}

package/src/memory/migrations/152-memory-item-supersession.ts

@@ -0,0 +1,44 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Add supersession tracking columns and override confidence to memory_items.
+ *
+ * - `supersedes` — references the ID of the item this one replaces
+ * - `superseded_by` — references the ID of the item that replaced this one
+ * - `override_confidence` — enum: "explicit", "tentative", "inferred" (default "inferred")
+ * - Index on (status, superseded_by) for filtering active non-superseded items
+ *
+ * All columns are added via ALTER TABLE with try/catch for idempotency.
+ */
+export function migrateMemoryItemSupersession(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  try {
+    raw.exec(
+      /*sql*/ `ALTER TABLE memory_items ADD COLUMN supersedes TEXT DEFAULT NULL`,
+    );
+  } catch {
+    // Column already exists
+  }
+
+  try {
+    raw.exec(
+      /*sql*/ `ALTER TABLE memory_items ADD COLUMN superseded_by TEXT DEFAULT NULL`,
+    );
+  } catch {
+    // Column already exists
+  }
+
+  try {
+    raw.exec(
+      /*sql*/ `ALTER TABLE memory_items ADD COLUMN override_confidence TEXT DEFAULT 'inferred'`,
+    );
+  } catch {
+    // Column already exists
+  }
+
+  raw.exec(
+    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_memory_items_status_superseded_by ON memory_items(status, superseded_by)`,
+  );
+}

package/src/memory/migrations/153-drop-entity-tables.ts

@@ -0,0 +1,15 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Drop entity-related tables that are no longer used.
+ *
+ * Entity search has been replaced by hybrid search on entity-rich text
+ * in item statements, so these tables are now dead weight.
+ */
+export function migrateDropEntityTables(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS memory_item_entities`);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS memory_entity_relations`);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS memory_entities`);
+}

package/src/memory/migrations/154-drop-fts.ts

@@ -0,0 +1,20 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Drop the memory_segment_fts virtual table and its associated triggers.
+ *
+ * The FTS-based lexical search pipeline has been replaced by Qdrant hybrid
+ * search. Keeping the FTS table around wastes disk space and adds write
+ * overhead on every segment insert/update/delete.
+ */
+export function migrateDropMemorySegmentFts(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  // Drop triggers first — they reference the FTS table.
+  raw.exec(/*sql*/ `DROP TRIGGER IF EXISTS memory_segments_ai`);
+  raw.exec(/*sql*/ `DROP TRIGGER IF EXISTS memory_segments_ad`);
+  raw.exec(/*sql*/ `DROP TRIGGER IF EXISTS memory_segments_au`);
+
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS memory_segment_fts`);
+}

package/src/memory/migrations/155-drop-conflicts.ts

@@ -0,0 +1,7 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateDropConflicts(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS memory_item_conflicts`);
+}

package/src/memory/migrations/156-call-session-invite-metadata.ts

@@ -0,0 +1,24 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+/**
+ * Add invite metadata columns to call_sessions so outbound invite calls
+ * can persist friend/guardian names for deterministic routing in the
+ * relay setup router (mirroring how verification_session_id works for
+ * guardian verification calls).
+ */
+export function migrateCallSessionInviteMetadata(database: DrizzleDb): void {
+  try {
+    database.run(
+      /*sql*/ `ALTER TABLE call_sessions ADD COLUMN invite_friend_name TEXT`,
+    );
+  } catch {
+    /* already exists */
+  }
+  try {
+    database.run(
+      /*sql*/ `ALTER TABLE call_sessions ADD COLUMN invite_guardian_name TEXT`,
+    );
+  } catch {
+    /* already exists */
+  }
+}

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

@@ -0,0 +1,104 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * Add a required contact_id column to assistant_ingress_invites.
+ * Invites must be bound to the contact they were created for.
+ * Legacy rows without a contact_id are deleted since they cannot
+ * be redeemed correctly.
+ *
+ * Steps:
+ *  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).
+ */
+export function migrateInviteContactId(database: DrizzleDb): void {
+  withCrashRecovery(database, "migration_invite_contact_id_v1", () => {
+    const raw = getSqliteFrom(database);
+
+    const cols = (
+      raw.query(`PRAGMA table_info(assistant_ingress_invites)`).all() as Array<{
+        name: string;
+        notnull: number;
+      }>
+    ).map((c) => ({ name: c.name, notnull: c.notnull }));
+
+    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
+
+    raw.exec("PRAGMA foreign_keys = OFF");
+    try {
+      raw.exec(/*sql*/ `
+          BEGIN;
+
+          CREATE TABLE assistant_ingress_invites_new (
+            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 CHECK (max_uses > 0),
+            use_count INTEGER NOT NULL DEFAULT 0 CHECK (use_count >= 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,
+            contact_id TEXT NOT NULL,
+            created_at INTEGER NOT NULL,
+            updated_at INTEGER NOT NULL
+          );
+
+          INSERT INTO assistant_ingress_invites_new
+          SELECT id, source_channel, token_hash, created_by_session_id, 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,
+                 voice_code_digits, invite_code_hash, friend_name, guardian_name,
+                 contact_id, created_at, updated_at
+          FROM assistant_ingress_invites;
+
+          DROP TABLE assistant_ingress_invites;
+          ALTER TABLE assistant_ingress_invites_new RENAME TO assistant_ingress_invites;
+
+          CREATE UNIQUE INDEX IF NOT EXISTS idx_ingress_invites_token_hash
+            ON assistant_ingress_invites(token_hash);
+          CREATE INDEX IF NOT EXISTS idx_ingress_invites_channel_status
+            ON assistant_ingress_invites(source_channel, status, expires_at);
+          CREATE INDEX IF NOT EXISTS idx_ingress_invites_channel_created
+            ON assistant_ingress_invites(source_channel, created_at);
+
+          COMMIT;
+        `);
+    } catch (e) {
+      try {
+        raw.exec("ROLLBACK");
+      } catch {
+        /* no active transaction */
+      }
+      throw e;
+    } finally {
+      raw.exec("PRAGMA foreign_keys = ON");
+    }
+  });
+}

package/src/memory/migrations/index.ts

@@ -91,6 +91,14 @@ export { migrateScheduleOneShotRouting } from "./146-schedule-oneshot-routing.js
 export { migrateRemindersToSchedules } from "./147-migrate-reminders-to-schedules.js";
 export { migrateDropRemindersTable } from "./148-drop-reminders-table.js";
 export { createOAuthTables } from "./149-oauth-tables.js";
+export { migrateOAuthAppsClientSecretPath } from "./150-oauth-apps-client-secret-path.js";
+export { migrateOAuthProvidersPingUrl } from "./151-oauth-providers-ping-url.js";
+export { migrateMemoryItemSupersession } from "./152-memory-item-supersession.js";
+export { migrateDropEntityTables } from "./153-drop-entity-tables.js";
+export { migrateDropMemorySegmentFts } from "./154-drop-fts.js";
+export { migrateDropConflicts } from "./155-drop-conflicts.js";
+export { migrateCallSessionInviteMetadata } from "./156-call-session-invite-metadata.js";
+export { migrateInviteContactId } from "./157-invite-contact-id.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/migrations/registry.ts

@@ -190,6 +190,12 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
     description:
       "Drop the legacy reminders table and its index after data migration to cron_jobs",
   },
+  {
+    key: "migration_oauth_apps_client_secret_path_v1",
+    version: 28,
+    description:
+      "Add client_secret_credential_path column to oauth_apps and backfill existing rows with convention-based paths",
+  },
 ];
 
 export interface MigrationValidationResult {