@vellumai/assistant 0.7.0 → 0.7.1

package/src/memory/migrations/__tests__/234-memory-v2-activation-logs.test.ts

@@ -0,0 +1,182 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../../db-connection.js";
+import * as schema from "../../schema.js";
+import {
+  downMemoryV2ActivationLogs,
+  migrateMemoryV2ActivationLogs,
+} from "../234-memory-v2-activation-logs.js";
+
+interface TableRow {
+  name: string;
+}
+
+interface IndexRow {
+  name: string;
+}
+
+interface ColumnRow {
+  name: string;
+  type: string;
+  notnull: number;
+  dflt_value: string | null;
+  pk: number;
+}
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+function bootstrapCheckpointsTable(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+}
+
+const EXPECTED_INDEXES = [
+  "idx_memory_v2_activation_logs_message_id",
+  "idx_memory_v2_activation_logs_conversation_id",
+  "idx_memory_v2_activation_logs_created_at",
+];
+
+describe("memory_v2_activation_logs migration", () => {
+  test("creates table with expected columns and indexes", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrateMemoryV2ActivationLogs(db);
+
+    const tableRow = raw
+      .query(
+        `SELECT name FROM sqlite_master WHERE type='table' AND name='memory_v2_activation_logs'`,
+      )
+      .get() as TableRow | null;
+    expect(tableRow?.name).toBe("memory_v2_activation_logs");
+
+    const columns = raw
+      .query(`PRAGMA table_info(memory_v2_activation_logs)`)
+      .all() as ColumnRow[];
+    const byName = new Map(columns.map((c) => [c.name, c]));
+
+    expect(byName.get("id")?.pk).toBe(1);
+    expect(byName.get("id")?.type).toBe("TEXT");
+    expect(byName.get("conversation_id")?.notnull).toBe(1);
+    expect(byName.get("conversation_id")?.type).toBe("TEXT");
+    expect(byName.get("message_id")?.notnull).toBe(0);
+    expect(byName.get("message_id")?.type).toBe("TEXT");
+    expect(byName.get("turn")?.notnull).toBe(1);
+    expect(byName.get("turn")?.type).toBe("INTEGER");
+    expect(byName.get("mode")?.notnull).toBe(1);
+    expect(byName.get("mode")?.type).toBe("TEXT");
+    expect(byName.get("concepts_json")?.notnull).toBe(1);
+    expect(byName.get("concepts_json")?.type).toBe("TEXT");
+    expect(byName.get("skills_json")?.notnull).toBe(1);
+    expect(byName.get("skills_json")?.type).toBe("TEXT");
+    expect(byName.get("config_json")?.notnull).toBe(1);
+    expect(byName.get("config_json")?.type).toBe("TEXT");
+    expect(byName.get("created_at")?.notnull).toBe(1);
+    expect(byName.get("created_at")?.type).toBe("INTEGER");
+
+    const indexes = raw
+      .query(
+        `SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='memory_v2_activation_logs'`,
+      )
+      .all() as IndexRow[];
+    const indexNames = new Set(indexes.map((r) => r.name));
+    for (const expected of EXPECTED_INDEXES) {
+      expect(indexNames.has(expected)).toBe(true);
+    }
+  });
+
+  test("re-running the migration is a no-op", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrateMemoryV2ActivationLogs(db);
+
+    raw
+      .query(
+        /*sql*/ `
+        INSERT INTO memory_v2_activation_logs (
+          id,
+          conversation_id,
+          message_id,
+          turn,
+          mode,
+          concepts_json,
+          skills_json,
+          config_json,
+          created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+      )
+      .run(
+        "log-1",
+        "conv-abc",
+        "msg-xyz",
+        3,
+        "per-turn",
+        "[]",
+        "[]",
+        "{}",
+        1000,
+      );
+
+    expect(() => migrateMemoryV2ActivationLogs(db)).not.toThrow();
+
+    const row = raw
+      .query(`SELECT id FROM memory_v2_activation_logs WHERE id = 'log-1'`)
+      .get() as { id: string } | null;
+    expect(row?.id).toBe("log-1");
+
+    const indexes = raw
+      .query(
+        `SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='memory_v2_activation_logs'`,
+      )
+      .all() as IndexRow[];
+    const indexNames = new Set(indexes.map((r) => r.name));
+    for (const expected of EXPECTED_INDEXES) {
+      expect(indexNames.has(expected)).toBe(true);
+    }
+  });
+
+  test("down() drops the table and is idempotent", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrateMemoryV2ActivationLogs(db);
+
+    expect(
+      raw
+        .query(
+          `SELECT name FROM sqlite_master WHERE type='table' AND name='memory_v2_activation_logs'`,
+        )
+        .get(),
+    ).toBeTruthy();
+
+    downMemoryV2ActivationLogs(db);
+
+    expect(
+      raw
+        .query(
+          `SELECT name FROM sqlite_master WHERE type='table' AND name='memory_v2_activation_logs'`,
+        )
+        .get(),
+    ).toBeNull();
+
+    expect(() => downMemoryV2ActivationLogs(db)).not.toThrow();
+  });
+});

package/src/memory/migrations/index.ts

@@ -181,6 +181,20 @@ export {
   downActivationState,
   migrateActivationState,
 } from "./232-activation-state.js";
+export { migrateCreateDocumentConversations } from "./233-document-conversations.js";
+export {
+  downMemoryV2ActivationLogs,
+  migrateMemoryV2ActivationLogs,
+} from "./234-memory-v2-activation-logs.js";
+export { migrateLlmUsageAttribution } from "./235-llm-usage-attribution.js";
+export {
+  downSlackCompactionWatermark,
+  migrateSlackCompactionWatermark,
+} from "./235-slack-compaction-watermark.js";
+export {
+  downToolInvocationsMatchedRuleId,
+  migrateToolInvocationsMatchedRuleId,
+} from "./236-tool-invocations-matched-rule-id.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/migrations/registry.ts

@@ -44,6 +44,9 @@ import { migrateScrubCorruptedImageAttachmentsDown } from "./206-scrub-corrupted
 import { downConversationHostAccess } from "./217-conversation-host-access.js";
 import { downNormalizeUserFileByPrincipal } from "./220-normalize-user-file-by-principal.js";
 import { downActivationState } from "./232-activation-state.js";
+import { downMemoryV2ActivationLogs } from "./234-memory-v2-activation-logs.js";
+import { downSlackCompactionWatermark } from "./235-slack-compaction-watermark.js";
+import { downToolInvocationsMatchedRuleId } from "./236-tool-invocations-matched-rule-id.js";
 
 export interface MigrationRegistryEntry {
   /** The checkpoint key written to memory_checkpoints on completion. */
@@ -380,6 +383,27 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
     description: "Create activation_state table for memory v2",
     down: downActivationState,
   },
+  {
+    key: "migration_memory_v2_activation_logs_v1",
+    version: 44,
+    description:
+      "Create memory_v2_activation_logs table for per-turn v2 activation telemetry consumed by the LLM Context Inspector",
+    down: downMemoryV2ActivationLogs,
+  },
+  {
+    key: "migration_slack_compaction_watermark_v1",
+    version: 45,
+    description:
+      "Add Slack-specific compaction watermark columns to conversations",
+    down: downSlackCompactionWatermark,
+  },
+  {
+    key: "migration_tool_invocations_matched_trust_rule_id_v1",
+    version: 46,
+    description:
+      "Add matched_trust_rule_id column to tool_invocations for trust rule audit and rule editor UI",
+    down: downToolInvocationsMatchedRuleId,
+  },
 ];
 
 export function getMaxMigrationVersion(): number {

package/src/memory/raw-query.ts

@@ -30,9 +30,9 @@
  * filtering, ordering, pagination — use Drizzle.
  */
 
-import type { Database, SQLQueryBindings } from "bun:sqlite";
+import type { SQLQueryBindings } from "bun:sqlite";
 
-import { type DrizzleDb, getSqlite, getSqliteFrom } from "./db-connection.js";
+import { getSqlite } from "./db-connection.js";
 
 type SqlParam = SQLQueryBindings;
 
@@ -82,72 +82,6 @@ export function rawChanges(): number {
   return (getSqlite().query("SELECT changes() AS c").get() as { c: number }).c;
 }
 
-// ---------------------------------------------------------------------------
-// Typed query helpers (explicit Drizzle instance)
-//
-// Used by migrations and tests that receive the Drizzle instance as a
-// parameter rather than using the global singleton.
-// ---------------------------------------------------------------------------
-
-/** Execute a raw SQL query against a specific Drizzle instance and return a single typed row. */
-export function rawGetFrom<T>(
-  db: DrizzleDb,
-  sql: string,
-  ...params: SqlParam[]
-): T | null {
-  return (
-    (getSqliteFrom(db)
-      .query(sql)
-      .get(...params) as T) ?? null
-  );
-}
-
-/** Execute a raw SQL query against a specific Drizzle instance and return all matching rows. */
-export function rawAllFrom<T>(
-  db: DrizzleDb,
-  sql: string,
-  ...params: SqlParam[]
-): T[] {
-  return getSqliteFrom(db)
-    .query(sql)
-    .all(...params) as T[];
-}
-
-/**
- * Execute a raw SQL statement against a specific Drizzle instance and return
- * affected row count.
- */
-export function rawRunFrom(
-  db: DrizzleDb,
-  sql: string,
-  ...params: SqlParam[]
-): number {
-  const sqlite = getSqliteFrom(db);
-  sqlite.query(sql).run(...params);
-  return (sqlite.query("SELECT changes() AS c").get() as { c: number }).c;
-}
-
-/** Execute batch SQL against a specific Drizzle instance. */
-export function rawExecFrom(db: DrizzleDb, sql: string): void {
-  getSqliteFrom(db).exec(sql);
-}
-
-/**
- * Create a prepared statement from the raw SQLite client.
- * Useful when you need to execute the same parameterized query in a loop.
- */
-export function rawPrepare(sql: string): ReturnType<Database["prepare"]> {
-  return getSqlite().prepare(sql);
-}
-
-/** Create a prepared statement from a specific Drizzle instance. */
-export function rawPrepareFrom(
-  db: DrizzleDb,
-  sql: string,
-): ReturnType<Database["prepare"]> {
-  return getSqliteFrom(db).prepare(sql);
-}
-
 /**
  * Delete all rows from the given tables in a single transaction.
  *

package/src/memory/schema/conversations.ts

@@ -21,6 +21,12 @@ export const conversations = sqliteTable(
       .notNull()
       .default(0),
     contextCompactedAt: integer("context_compacted_at"),
+    slackContextCompactionWatermarkTs: text(
+      "slack_context_compaction_watermark_ts",
+    ),
+    slackContextCompactionWatermarkAt: integer(
+      "slack_context_compaction_watermark_at",
+    ),
     conversationType: text("conversation_type").notNull().default("standard"),
     source: text("source").notNull().default("user"),
     memoryScopeId: text("memory_scope_id").notNull().default("default"),
@@ -72,6 +78,7 @@ export const toolInvocations = sqliteTable(
     result: text("result").notNull(),
     decision: text("decision").notNull(),
     riskLevel: text("risk_level").notNull(),
+    matchedTrustRuleId: text("matched_trust_rule_id"),
     durationMs: integer("duration_ms").notNull(),
     createdAt: integer("created_at").notNull(),
   },

package/src/memory/schema/infrastructure.ts

@@ -161,6 +161,28 @@ export const memoryRecallLogs = sqliteTable(
   ],
 );
 
+export const memoryV2ActivationLogs = sqliteTable(
+  "memory_v2_activation_logs",
+  {
+    id: text("id").primaryKey(),
+    conversationId: text("conversation_id").notNull(),
+    messageId: text("message_id"),
+    turn: integer("turn").notNull(),
+    mode: text("mode").notNull(), // "context-load" | "per-turn"
+    conceptsJson: text("concepts_json").notNull(),
+    skillsJson: text("skills_json").notNull(),
+    configJson: text("config_json").notNull(),
+    createdAt: integer("created_at").notNull(),
+  },
+  (table) => [
+    index("idx_memory_v2_activation_logs_message_id").on(table.messageId),
+    index("idx_memory_v2_activation_logs_conversation_id").on(
+      table.conversationId,
+    ),
+    index("idx_memory_v2_activation_logs_created_at").on(table.createdAt),
+  ],
+);
+
 export const llmUsageEvents = sqliteTable(
   "llm_usage_events",
   {
@@ -170,6 +192,9 @@ export const llmUsageEvents = sqliteTable(
     runId: text("run_id"),
     requestId: text("request_id"),
     actor: text("actor").notNull(),
+    callSite: text("call_site"),
+    inferenceProfile: text("inference_profile"),
+    inferenceProfileSource: text("inference_profile_source"),
     provider: text("provider").notNull(),
     model: text("model").notNull(),
     inputTokens: integer("input_tokens").notNull(),

package/src/memory/search/semantic.ts

@@ -1,6 +1,5 @@
 import { inArray } from "drizzle-orm";
 
-import { getLogger } from "../../util/logger.js";
 import { getDb } from "../db-connection.js";
 import { withQdrantBreaker } from "../qdrant-circuit-breaker.js";
 import type {
@@ -45,8 +44,6 @@ function computeRecencyScore(createdAt: number): number {
   return 1 / (1 + Math.log2(1 + ageDays));
 }
 
-const _log = getLogger("semantic-search");
-
 export async function semanticSearch(
   queryVector: number[],
   _provider: string,
@@ -54,7 +51,7 @@ export async function semanticSearch(
   limit: number,
   excludedMessageIds: string[] = [],
   scopeIds?: string[],
-  sparseVector?: QdrantSparseVector
+  sparseVector?: QdrantSparseVector,
 ): Promise<Candidate[]> {
   if (limit <= 0) return [];
 
@@ -79,7 +76,7 @@ export async function semanticSearch(
         filter,
         limit: fetchLimit,
         prefetchLimit: fetchLimit,
-      })
+      }),
     );
   } else {
     results = await withQdrantBreaker(() =>
@@ -88,8 +85,8 @@ export async function semanticSearch(
         fetchLimit,
         ["summary", "segment", "media"],
         excludedMessageIds,
-        scopeIds
-      )
+        scopeIds,
+      ),
     );
   }
 
@@ -145,7 +142,6 @@ export async function semanticSearch(
     for (const row of rows) mediaScopeMap.set(row.id, row.memoryScopeId);
   }
 
-
   const candidates: Candidate[] = [];
   for (const result of results) {
     const { payload, score } = result;
@@ -258,7 +254,7 @@ export async function semanticSearch(
  */
 function buildHybridFilter(
   excludeMessageIds: string[],
-  scopeIds?: string[]
+  scopeIds?: string[],
 ): Record<string, unknown> {
   const mustConditions: Array<Record<string, unknown>> = [
     {
@@ -298,10 +294,3 @@ function buildHybridFilter(
 function mapCosineToUnit(value: number): number {
   return Math.max(0, Math.min(1, (value + 1) / 2));
 }
-
-export function isQdrantConnectionError(err: unknown): boolean {
-  if (!(err instanceof Error)) return false;
-  return /ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENETUNREACH|fetch failed/i.test(
-    err.message
-  );
-}

package/src/memory/tool-usage-store.ts

@@ -12,6 +12,7 @@ export interface ToolInvocationRecord {
   result: string;
   decision: string;
   riskLevel: string;
+  matchedTrustRuleId?: string;
   durationMs: number;
 }
 
@@ -26,6 +27,7 @@ export function recordToolInvocation(record: ToolInvocationRecord): void {
       result: record.result,
       decision: record.decision,
       riskLevel: record.riskLevel,
+      matchedTrustRuleId: record.matchedTrustRuleId,
       durationMs: record.durationMs,
       createdAt: Date.now(),
     })

package/src/memory/usage-buckets.ts

@@ -215,7 +215,10 @@ function formatHourLabel(epochMillis: number, tz: string): string {
     hour12: true,
   });
   // "3 PM" → "3pm"
-  return formatter.format(new Date(epochMillis)).replace(/\s/g, "").toLowerCase();
+  return formatter
+    .format(new Date(epochMillis))
+    .replace(/\s/g, "")
+    .toLowerCase();
 }
 
 /** Format a short human-readable day label in `tz`, e.g. "Apr 11". */
@@ -282,6 +285,42 @@ function finalize(buckets: Map<string, MutableBucket>): UsageDayBucket[] {
     }));
 }
 
+const HOURLY_BUCKET_ID_RE = /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):00\|(-?\d+)$/;
+const DAILY_BUCKET_ID_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+
+function usageBucketSortKey(
+  bucket: Pick<UsageDayBucket, "bucketId">,
+): number | null {
+  const hourlyMatch = HOURLY_BUCKET_ID_RE.exec(bucket.bucketId);
+  if (hourlyMatch) {
+    const [, year, month, day, hour, offsetMinutes] = hourlyMatch;
+    return (
+      Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour)) -
+      Number(offsetMinutes) * 60_000
+    );
+  }
+
+  const dailyMatch = DAILY_BUCKET_ID_RE.exec(bucket.bucketId);
+  if (dailyMatch) {
+    const [, year, month, day] = dailyMatch;
+    return Date.UTC(Number(year), Number(month) - 1, Number(day));
+  }
+
+  return null;
+}
+
+export function compareUsageBuckets(
+  a: Pick<UsageDayBucket, "bucketId">,
+  b: Pick<UsageDayBucket, "bucketId">,
+): number {
+  const aSortKey = usageBucketSortKey(a);
+  const bSortKey = usageBucketSortKey(b);
+  if (aSortKey !== null && bSortKey !== null && aSortKey !== bSortKey) {
+    return aSortKey - bSortKey;
+  }
+  return a.bucketId.localeCompare(b.bucketId);
+}
+
 /** Options for bucketing behavior. */
 export interface BucketingOptions {
   /**

package/src/memory/usage-grouped-buckets.ts

@@ -0,0 +1,127 @@
+import { getLLMCallSiteLabel } from "../config/llm-callsite-catalog.js";
+import type {
+  GroupByDimension,
+  UsageBucketOptions,
+  UsageDayBucket,
+  UsageTimeRange,
+} from "./llm-usage-store.js";
+import {
+  bucketEventsByDay,
+  bucketEventsByHour,
+  compareUsageBuckets,
+  type UsageEventBucketRow,
+} from "./usage-buckets.js";
+
+export interface UsageSeriesGroupValue {
+  group: string;
+  groupKey: string | null;
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  totalEstimatedCostUsd: number;
+  eventCount: number;
+}
+
+export interface UsageGroupedSeriesBucket extends UsageDayBucket {
+  groups: Record<string, UsageSeriesGroupValue>;
+}
+
+export interface UsageGroupedBucketRow extends UsageEventBucketRow {
+  group_key: string | null;
+}
+
+const VALUE_GROUP_PREFIX = "value:";
+const NULL_GROUP_PREFIX = "null:";
+
+export function displayUsageGroup(
+  groupBy: GroupByDimension,
+  groupKey: string | null,
+): string {
+  if (groupBy === "call_site") {
+    return groupKey === null ? "Unknown Task" : getLLMCallSiteLabel(groupKey);
+  }
+  if (groupBy === "inference_profile") {
+    return groupKey === null ? "Default / Unset" : groupKey;
+  }
+  return groupKey ?? "Other";
+}
+
+export function stableUsageSeriesGroupKey(
+  groupBy: GroupByDimension,
+  groupKey: string | null,
+): string {
+  if (groupKey !== null) return `${VALUE_GROUP_PREFIX}${groupKey}`;
+  return `${NULL_GROUP_PREFIX}${groupBy}`;
+}
+
+function createEmptyGroupedBucket(
+  bucket: UsageDayBucket,
+): UsageGroupedSeriesBucket {
+  return {
+    bucketId: bucket.bucketId,
+    date: bucket.date,
+    displayLabel: bucket.displayLabel,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCostUsd: 0,
+    eventCount: 0,
+    groups: {},
+  };
+}
+
+export function bucketGroupedUsageEvents(
+  rows: UsageGroupedBucketRow[],
+  range: UsageTimeRange,
+  tz: string,
+  options: UsageBucketOptions & {
+    granularity: "daily" | "hourly";
+    groupBy: GroupByDimension;
+  },
+): UsageGroupedSeriesBucket[] {
+  const bucketEvents =
+    options.granularity === "hourly" ? bucketEventsByHour : bucketEventsByDay;
+  const baseBuckets = bucketEvents([], range, tz, {
+    fillEmpty: options.fillEmpty,
+  });
+  const buckets = new Map<string, UsageGroupedSeriesBucket>();
+
+  for (const bucket of baseBuckets) {
+    buckets.set(bucket.bucketId, createEmptyGroupedBucket(bucket));
+  }
+
+  for (const row of rows) {
+    const [bucket] = bucketEvents([row], range, tz);
+    if (!bucket) continue;
+
+    let groupedBucket = buckets.get(bucket.bucketId);
+    if (!groupedBucket) {
+      groupedBucket = createEmptyGroupedBucket(bucket);
+      buckets.set(bucket.bucketId, groupedBucket);
+    }
+
+    const seriesKey = stableUsageSeriesGroupKey(options.groupBy, row.group_key);
+    let group = groupedBucket.groups[seriesKey];
+    if (!group) {
+      group = {
+        group: displayUsageGroup(options.groupBy, row.group_key),
+        groupKey: row.group_key,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalEstimatedCostUsd: 0,
+        eventCount: 0,
+      };
+      groupedBucket.groups[seriesKey] = group;
+    }
+
+    group.totalInputTokens += row.input_tokens;
+    group.totalOutputTokens += row.output_tokens;
+    group.totalEstimatedCostUsd += row.estimated_cost_usd ?? 0;
+    group.eventCount += row.llm_call_count ?? 1;
+
+    groupedBucket.totalInputTokens += row.input_tokens;
+    groupedBucket.totalOutputTokens += row.output_tokens;
+    groupedBucket.totalEstimatedCostUsd += row.estimated_cost_usd ?? 0;
+    groupedBucket.eventCount += row.llm_call_count ?? 1;
+  }
+
+  return Array.from(buckets.values()).sort(compareUsageBuckets);
+}