@vellumai/assistant 0.8.3 → 0.8.4

package/src/memory/migrations/254-external-conversation-binding-chat-name.ts

@@ -0,0 +1,43 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_external_conversation_binding_chat_name_v1";
+
+export function migrateExternalConversationBindingChatName(
+  database: DrizzleDb,
+): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    if (
+      tableHasColumn(
+        database,
+        "external_conversation_bindings",
+        "external_chat_name",
+      )
+    ) {
+      return;
+    }
+
+    database.run(
+      `ALTER TABLE external_conversation_bindings ADD COLUMN external_chat_name TEXT`,
+    );
+  });
+}
+
+export function downExternalConversationBindingChatName(
+  database: DrizzleDb,
+): void {
+  if (
+    !tableHasColumn(
+      database,
+      "external_conversation_bindings",
+      "external_chat_name",
+    )
+  ) {
+    return;
+  }
+
+  database.run(
+    `ALTER TABLE external_conversation_bindings DROP COLUMN external_chat_name`,
+  );
+}

package/src/memory/migrations/255-channel-inbound-delivery-attempts.ts

@@ -0,0 +1,24 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_channel_inbound_delivery_attempts_v1";
+
+/** Add a delivery-specific retry counter for channel inbound events. */
+export function migrateChannelInboundDeliveryAttempts(
+  database: DrizzleDb,
+): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    if (
+      tableHasColumn(database, "channel_inbound_events", "delivery_attempts")
+    ) {
+      return;
+    }
+    const raw = getSqliteFrom(database);
+    raw.exec(/*sql*/ `
+      ALTER TABLE channel_inbound_events
+        ADD COLUMN delivery_attempts INTEGER NOT NULL DEFAULT 0
+    `);
+  });
+}

package/src/memory/migrations/256-memory-v2-injection-events.ts

@@ -0,0 +1,113 @@
+import { getLogger } from "../../util/logger.js";
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_memory_v2_injection_events_v1";
+const log = getLogger("memory-v2-injection-events-migration");
+
+/**
+ * Create the memory_v2_injection_events table — an append-only event log of
+ * (slug, injected_at) tuples capturing every router selection.
+ *
+ * This is the data source for the time-decayed injection frequency score
+ * that drives tier 2 assignment in memory router v4. Score is computed on
+ * read as `Σ exp(-λ × (now - tᵢ))` with `λ = ln(2) / 3 days`, so the table
+ * just accumulates raw events; the formula or half-life can change later
+ * without losing signal.
+ *
+ * Backfill: walks existing `memory_v2_activation_logs` and replays each
+ * row's router-sourced slugs as historical events. Without backfill the
+ * scores would take ~3 half-lives (≈9 days) to reach steady state; with
+ * backfill tier 2 assignment has signal from day one.
+ *
+ * Indexes:
+ * - `(slug, injected_at)` for per-slug score reads (the hot path).
+ * - `(injected_at)` for time-range pruning later.
+ */
+export function migrateMemoryV2InjectionEvents(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+    raw.exec(/*sql*/ `
+      CREATE TABLE IF NOT EXISTS memory_v2_injection_events (
+        id INTEGER PRIMARY KEY,
+        slug TEXT NOT NULL,
+        injected_at INTEGER NOT NULL
+      )
+    `);
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_memory_v2_injection_events_slug_time
+        ON memory_v2_injection_events (slug, injected_at)
+    `);
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_memory_v2_injection_events_time
+        ON memory_v2_injection_events (injected_at)
+    `);
+
+    // Bail before backfill on databases that predate memory_v2_activation_logs
+    // (migration 234) — there's no historical signal to replay.
+    const logsTable = raw
+      .query(
+        `SELECT name FROM sqlite_master WHERE type='table' AND name='memory_v2_activation_logs'`,
+      )
+      .get();
+    if (!logsTable) return;
+
+    // Re-run safety net independent of the checkpoint: if events already
+    // exist, do not append duplicates. The checkpoint normally short-circuits
+    // re-runs in withCrashRecovery; this guards the manual-clear path.
+    const existing = raw
+      .query(`SELECT COUNT(*) as n FROM memory_v2_injection_events`)
+      .get() as { n: number };
+    if (existing.n > 0) return;
+
+    const rows = raw
+      .query(
+        `SELECT concepts_json, created_at FROM memory_v2_activation_logs ORDER BY created_at ASC`,
+      )
+      .all() as Array<{ concepts_json: string; created_at: number }>;
+    if (rows.length === 0) return;
+
+    const insert = raw.prepare(
+      `INSERT INTO memory_v2_injection_events (slug, injected_at) VALUES (?, ?)`,
+    );
+    const replay = raw.transaction(
+      (events: ReadonlyArray<{ slug: string; t: number }>) => {
+        for (const e of events) insert.run(e.slug, e.t);
+      },
+    );
+
+    const buffer: Array<{ slug: string; t: number }> = [];
+    let parseFailures = 0;
+    for (const row of rows) {
+      let concepts: Array<{ slug?: unknown; source?: unknown }>;
+      try {
+        concepts = JSON.parse(row.concepts_json) as Array<{
+          slug?: unknown;
+          source?: unknown;
+        }>;
+      } catch {
+        parseFailures += 1;
+        continue;
+      }
+      if (!Array.isArray(concepts)) continue;
+      for (const c of concepts) {
+        if (typeof c.slug !== "string") continue;
+        // Carry-over entries were not router-selected this turn — exclude.
+        if (c.source !== "router") continue;
+        buffer.push({ slug: c.slug, t: row.created_at });
+      }
+    }
+
+    if (buffer.length > 0) replay(buffer);
+    log.info(
+      { inserted: buffer.length, rowsScanned: rows.length, parseFailures },
+      `Backfilled ${buffer.length} injection events from ${rows.length} activation log rows`,
+    );
+  });
+}
+
+export function downMemoryV2InjectionEvents(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS memory_v2_injection_events`);
+}

package/src/memory/migrations/257-strip-base-url-non-openai-compatible.ts

@@ -0,0 +1,22 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Strip `base_url` from provider connections whose provider is NOT
+ * `openai-compatible`. These values should never have been accepted — the
+ * route layer now rejects them, but existing rows may still carry one from
+ * before the validation was added. Setting it to NULL prevents
+ * API-key exfiltration via a redirected base URL.
+ *
+ * Idempotent — re-running is a no-op once all non-openai-compatible rows
+ * already have NULL base_url.
+ */
+export function migrateStripBaseUrlNonOpenaiCompatible(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+
+  // Only clear base_url on rows where provider is NOT openai-compatible.
+  raw.exec(
+    `UPDATE provider_connections SET base_url = NULL WHERE provider != 'openai-compatible' AND base_url IS NOT NULL`,
+  );
+}

package/src/memory/migrations/258-onboarding-events-prior-assistants.ts

@@ -0,0 +1,13 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+export function migrateOnboardingEventsPriorAssistants(
+  database: DrizzleDb,
+): void {
+  try {
+    database.run(
+      /*sql*/ `ALTER TABLE onboarding_events ADD COLUMN prior_assistants_json TEXT`,
+    );
+  } catch {
+    /* already exists */
+  }
+}

package/src/memory/migrations/259-conversation-cleaned-at.ts

@@ -0,0 +1,33 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_conversation_cleaned_at_v1";
+
+const COLUMN_NAME = "cleaned_at";
+const COLUMN_DEFINITION = "cleaned_at INTEGER";
+
+/**
+ * Add a `cleaned_at` timestamp to conversations.
+ *
+ * Records the moment `/clean` ran. The load path uses it to skip metadata
+ * reinjection (and strip injection prefixes from message content) for
+ * messages whose `created_at < cleaned_at`, so the clean survives daemon
+ * restart and conversation eviction. `forkConversation` copies the marker
+ * to the child only when the fork point is at-or-after the clean.
+ */
+export function migrateConversationCleanedAt(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    if (tableHasColumn(database, "conversations", COLUMN_NAME)) {
+      return;
+    }
+    database.run(`ALTER TABLE conversations ADD COLUMN ${COLUMN_DEFINITION}`);
+  });
+}
+
+export function downConversationCleanedAt(database: DrizzleDb): void {
+  if (!tableHasColumn(database, "conversations", COLUMN_NAME)) {
+    return;
+  }
+  database.run(`ALTER TABLE conversations DROP COLUMN ${COLUMN_NAME}`);
+}

package/src/memory/migrations/index.ts

@@ -217,6 +217,23 @@ export {
 export { migrateProviderConnectionBaseUrlAndModels } from "./250-provider-connection-base-url-and-models.js";
 export { downA2ATasks, migrateA2ATasks } from "./251-a2a-tasks.js";
 export { migrateLlmRequestLogAgentLoopExitReason } from "./252-llm-request-log-agent-loop-exit-reason.js";
+export { migrateConversationLastNotifiedProfile } from "./253-conversation-last-notified-profile.js";
+export { migrateCreateDocumentComments } from "./253-document-comments.js";
+export {
+  downExternalConversationBindingChatName,
+  migrateExternalConversationBindingChatName,
+} from "./254-external-conversation-binding-chat-name.js";
+export { migrateChannelInboundDeliveryAttempts } from "./255-channel-inbound-delivery-attempts.js";
+export {
+  downMemoryV2InjectionEvents,
+  migrateMemoryV2InjectionEvents,
+} from "./256-memory-v2-injection-events.js";
+export { migrateStripBaseUrlNonOpenaiCompatible } from "./257-strip-base-url-non-openai-compatible.js";
+export { migrateOnboardingEventsPriorAssistants } from "./258-onboarding-events-prior-assistants.js";
+export {
+  downConversationCleanedAt,
+  migrateConversationCleanedAt,
+} from "./259-conversation-cleaned-at.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/migrations/registry.ts

@@ -50,6 +50,9 @@ import { downToolInvocationsMatchedRuleId } from "./236-tool-invocations-matched
 import { downHeartbeatRuns } from "./237-heartbeat-runs.js";
 import { downNormalizeSlackExternalContent } from "./249-normalize-slack-external-content.js";
 import { downA2ATasks } from "./251-a2a-tasks.js";
+import { downExternalConversationBindingChatName } from "./254-external-conversation-binding-chat-name.js";
+import { downMemoryV2InjectionEvents } from "./256-memory-v2-injection-events.js";
+import { downConversationCleanedAt } from "./259-conversation-cleaned-at.js";
 
 export interface MigrationRegistryEntry {
   /** The checkpoint key written to memory_checkpoints on completion. */
@@ -428,6 +431,28 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
       "Create a2a_tasks table for tracking A2A request/response lifecycle",
     down: downA2ATasks,
   },
+  {
+    key: "migration_external_conversation_binding_chat_name_v1",
+    version: 50,
+    description:
+      "Add external_chat_name to external conversation bindings for channel footer metadata",
+    down: downExternalConversationBindingChatName,
+  },
+  {
+    key: "migration_memory_v2_injection_events_v1",
+    version: 51,
+    dependsOn: ["migration_memory_v2_activation_logs_v1"],
+    description:
+      "Create memory_v2_injection_events table and backfill from activation logs for EMA-based tier 2 routing",
+    down: downMemoryV2InjectionEvents,
+  },
+  {
+    key: "migration_conversation_cleaned_at_v1",
+    version: 52,
+    description:
+      "Add cleaned_at timestamp to conversations so /clean survives reload and forks inherit conditionally on fork point",
+    down: downConversationCleanedAt,
+  },
 ];
 
 export function getMaxMigrationVersion(): number {

package/src/memory/onboarding-events-store.ts

@@ -14,6 +14,7 @@ export interface OnboardingEvent {
   tone: string | null;
   googleConnected: boolean | null;
   googleScopesJson: string | null;
+  priorAssistantsJson: string | null;
   abVariant: string | null;
 }
 
@@ -24,6 +25,7 @@ export interface RecordOnboardingEventParams {
   tone?: string;
   googleConnected?: boolean;
   googleScopes?: string[];
+  priorAssistants?: string[];
   abVariant?: string;
 }
 
@@ -47,6 +49,9 @@ export function recordOnboardingEvent(
     googleScopesJson: params.googleScopes
       ? JSON.stringify(params.googleScopes)
       : null,
+    priorAssistantsJson: params.priorAssistants
+      ? JSON.stringify(params.priorAssistants)
+      : null,
     abVariant: params.abVariant ?? null,
   };
   db.insert(onboardingEvents)
@@ -59,6 +64,7 @@ export function recordOnboardingEvent(
       tone: event.tone,
       googleConnected: event.googleConnected,
       googleScopesJson: event.googleScopesJson,
+      priorAssistantsJson: event.priorAssistantsJson,
       abVariant: event.abVariant,
     })
     .run();
@@ -85,6 +91,7 @@ export function queryUnreportedOnboardingEvents(
       tone: onboardingEvents.tone,
       googleConnected: onboardingEvents.googleConnected,
       googleScopesJson: onboardingEvents.googleScopesJson,
+      priorAssistantsJson: onboardingEvents.priorAssistantsJson,
       abVariant: onboardingEvents.abVariant,
     })
     .from(onboardingEvents)

package/src/memory/schema/calls.ts

@@ -78,6 +78,7 @@ export const externalConversationBindings = sqliteTable(
       .references(() => conversations.id, { onDelete: "cascade" }),
     sourceChannel: text("source_channel").notNull(),
     externalChatId: text("external_chat_id").notNull(),
+    externalChatName: text("external_chat_name"),
     externalThreadId: text("external_thread_id"),
     externalUserId: text("external_user_id"),
     displayName: text("display_name"),

package/src/memory/schema/conversations.ts

@@ -21,6 +21,7 @@ export const conversations = sqliteTable(
       .notNull()
       .default(0),
     contextCompactedAt: integer("context_compacted_at"),
+    cleanedAt: integer("cleaned_at"),
     slackContextCompactionWatermarkTs: text(
       "slack_context_compaction_watermark_ts",
     ),
@@ -41,6 +42,7 @@ export const conversations = sqliteTable(
     inferenceProfile: text("inference_profile"),
     inferenceProfileSessionId: text("inference_profile_session_id"),
     inferenceProfileExpiresAt: integer("inference_profile_expires_at"),
+    lastNotifiedInferenceProfile: text("last_notified_inference_profile"),
   },
   (table) => [
     index("idx_conversations_updated_at").on(table.updatedAt),
@@ -150,6 +152,7 @@ export const channelInboundEvents = sqliteTable("channel_inbound_events", {
   deliveryStatus: text("delivery_status").notNull().default("pending"),
   processingStatus: text("processing_status").notNull().default("pending"),
   processingAttempts: integer("processing_attempts").notNull().default(0),
+  deliveryAttempts: integer("delivery_attempts").notNull().default(0),
   lastProcessingError: text("last_processing_error"),
   retryAfter: integer("retry_after"),
   rawPayload: text("raw_payload"),

package/src/memory/schema/infrastructure.ts

@@ -242,6 +242,7 @@ export const onboardingEvents = sqliteTable("onboarding_events", {
   tone: text("tone"),
   googleConnected: integer("google_connected", { mode: "boolean" }),
   googleScopesJson: text("google_scopes_json"),
+  priorAssistantsJson: text("prior_assistants_json"),
   abVariant: text("ab_variant"),
 });