@vellumai/assistant 0.7.2 → 0.8.0

package/src/memory/memory-v2-activation-log-store.ts

@@ -12,20 +12,37 @@ export interface MemoryV2ConceptRowRecord {
   simUser: number;
   simAssistant: number;
   simNow: number;
+  /**
+   * Cross-encoder rerank delta in raw rerank space (`alpha · r_norm_u`)
+   * for the user channel. Zero when rerank is disabled or the slug fell
+   * outside the unified top-K-by-pre-rerank-A_o window. Applied
+   * additively to A_o weighted by `c_user` — `simUser` itself is the
+   * raw fused score and never carries the boost. Stored as a JSON field,
+   * so older log rows pre-date this addition and decode with `undefined`;
+   * readers should fall back to 0.
+   */
+  simUserRerankBoost: number;
+  /**
+   * Cross-encoder rerank delta for the assistant channel. Same semantics
+   * as `simUserRerankBoost`, weighted by `c_assistant` when applied to
+   * A_o. The NOW channel intentionally bypasses rerank, so there is no
+   * `simNowRerankBoost`.
+   */
+  simAssistantRerankBoost: number;
+  /**
+   * True when rerank ran and this slug landed in the unified
+   * top-K-by-pre-rerank-A_o pool. Distinguishes "cross-encoder evaluated
+   * this and chose 0" from "rerank skipped this slug" so the inspector
+   * can keep the rerank rows visible at `+0.000` instead of silently
+   * dropping them. Older log rows pre-date this field and decode with
+   * `undefined`; readers should fall back to `false`.
+   */
+  inRerankPool: boolean;
   spreadContribution: number;
   source: "prior_state" | "ann_top50" | "both";
   status: "in_context" | "injected" | "not_injected" | "page_missing";
 }
 
-export interface MemoryV2SkillRowRecord {
-  id: string;
-  activation: number;
-  simUser: number;
-  simAssistant: number;
-  simNow: number;
-  status: "injected" | "not_injected";
-}
-
 export interface MemoryV2ConfigSnapshot {
   d: number;
   c_user: number;
@@ -34,7 +51,6 @@ export interface MemoryV2ConfigSnapshot {
   k: number;
   hops: number;
   top_k: number;
-  top_k_skills: number;
   epsilon: number;
 }
 
@@ -43,7 +59,6 @@ export interface RecordMemoryV2ActivationLogParams {
   turn: number;
   mode: "context-load" | "per-turn";
   concepts: MemoryV2ConceptRowRecord[];
-  skills: MemoryV2SkillRowRecord[];
   config: MemoryV2ConfigSnapshot;
 }
 
@@ -51,6 +66,11 @@ export function recordMemoryV2ActivationLog(
   params: RecordMemoryV2ActivationLogParams,
 ): void {
   const db = getDb();
+  // Skills now live as concept rows under `slug: "skills/<id>"`, so the
+  // separate `skills_json` column is always written empty. The column itself
+  // remains in the schema for backwards-compat with prior log rows; the
+  // reader drops it. A future migration can DROP the column once those rows
+  // age out of relevance.
   db.insert(memoryV2ActivationLogs)
     .values({
       id: uuid(),
@@ -59,7 +79,7 @@ export function recordMemoryV2ActivationLog(
       turn: params.turn,
       mode: params.mode,
       conceptsJson: JSON.stringify(params.concepts),
-      skillsJson: JSON.stringify(params.skills),
+      skillsJson: "[]",
       configJson: JSON.stringify(params.config),
       createdAt: Date.now(),
     })
@@ -87,7 +107,6 @@ export interface MemoryV2ActivationLog {
   turn: number;
   mode: "context-load" | "per-turn";
   concepts: MemoryV2ConceptRowRecord[];
-  skills: MemoryV2SkillRowRecord[];
   config: MemoryV2ConfigSnapshot;
 }
 
@@ -109,7 +128,6 @@ export function getMemoryV2ActivationLogByMessageIds(
     turn: row.turn,
     mode: row.mode as "context-load" | "per-turn",
     concepts: JSON.parse(row.conceptsJson) as MemoryV2ConceptRowRecord[],
-    skills: JSON.parse(row.skillsJson) as MemoryV2SkillRowRecord[],
     config: JSON.parse(row.configJson) as MemoryV2ConfigSnapshot,
   };
 }

package/src/memory/memory-v2-concept-frequency.ts

@@ -0,0 +1,169 @@
+import type { MemoryV2ConceptRowRecord } from "./memory-v2-activation-log-store.js";
+import { rawAll, rawGet } from "./raw-query.js";
+import { listPages } from "./v2/page-store.js";
+
+type ConceptStatus = MemoryV2ConceptRowRecord["status"];
+
+export type ConceptFrequencyCounts = Record<ConceptStatus, number>;
+
+export interface ConceptFrequencyRow {
+  slug: string;
+  counts: ConceptFrequencyCounts;
+  totalEvaluations: number;
+  lastInjectedAt: number | null;
+  /** Whether the slug currently has a markdown page on disk. */
+  onDisk: boolean;
+}
+
+export interface ConceptFrequencyResponse {
+  filters: {
+    conversationId: string | null;
+    sinceMs: number | null;
+  };
+  totals: {
+    /** Activation log rows scanned (turns of evaluation in the window). */
+    logCount: number;
+    /** Sum of per-row concept evaluations across all log rows in the window. */
+    conceptOccurrences: number;
+  };
+  /** Per-slug aggregates, sorted by `totalEvaluations` desc, then slug asc. */
+  concepts: ConceptFrequencyRow[];
+  /**
+   * Slugs present on disk that never appeared in any activation log row in
+   * the window — i.e. retrieval never even scored them as a candidate.
+   */
+  neverEvaluatedSlugs: string[];
+}
+
+export interface GetConceptFrequencyFilters {
+  conversationId?: string;
+  sinceMs?: number;
+}
+
+interface AggRow {
+  slug: string | null;
+  status: ConceptStatus | string | null;
+  count: number;
+  last_seen: number;
+}
+
+const ZERO_COUNTS: ConceptFrequencyCounts = {
+  injected: 0,
+  in_context: 0,
+  not_injected: 0,
+  page_missing: 0,
+};
+
+interface CountRow {
+  count: number;
+}
+
+export async function getConceptFrequencySummary(
+  workspaceDir: string,
+  filters: GetConceptFrequencyFilters = {},
+): Promise<ConceptFrequencyResponse> {
+  const conversationId = filters.conversationId ?? null;
+  const sinceMs = filters.sinceMs ?? null;
+
+  // Kick off the on-disk page walk in parallel with the (synchronous) SQL
+  // queries below — listPages does fs.readdir, rawAll/rawGet are sync.
+  const onDiskSlugsPromise = listPages(workspaceDir);
+
+  const aggRows = rawAll<AggRow>(
+    `SELECT
+       json_extract(c.value, '$.slug')   AS slug,
+       json_extract(c.value, '$.status') AS status,
+       COUNT(*)                          AS count,
+       MAX(l.created_at)                 AS last_seen
+     FROM memory_v2_activation_logs l, json_each(l.concepts_json) c
+     WHERE (? IS NULL OR l.conversation_id = ?)
+       AND (? IS NULL OR l.created_at >= ?)
+     GROUP BY slug, status`,
+    conversationId,
+    conversationId,
+    sinceMs,
+    sinceMs,
+  );
+
+  const logCountRow = rawGet<CountRow>(
+    `SELECT COUNT(*) AS count
+       FROM memory_v2_activation_logs
+       WHERE (? IS NULL OR conversation_id = ?)
+         AND (? IS NULL OR created_at >= ?)`,
+    conversationId,
+    conversationId,
+    sinceMs,
+    sinceMs,
+  );
+
+  const bySlug = new Map<string, ConceptFrequencyRow>();
+  let conceptOccurrences = 0;
+
+  for (const row of aggRows) {
+    if (!row.slug) continue;
+    let entry = bySlug.get(row.slug);
+    if (!entry) {
+      entry = {
+        slug: row.slug,
+        counts: { ...ZERO_COUNTS },
+        totalEvaluations: 0,
+        lastInjectedAt: null,
+        onDisk: false,
+      };
+      bySlug.set(row.slug, entry);
+    }
+
+    switch (row.status) {
+      case "injected":
+        entry.counts.injected += row.count;
+        entry.lastInjectedAt =
+          entry.lastInjectedAt === null
+            ? row.last_seen
+            : Math.max(entry.lastInjectedAt, row.last_seen);
+        break;
+      case "in_context":
+        entry.counts.in_context += row.count;
+        break;
+      case "not_injected":
+        entry.counts.not_injected += row.count;
+        break;
+      case "page_missing":
+        entry.counts.page_missing += row.count;
+        break;
+      default:
+        // Forward-compat: unknown status values are ignored, not summed into
+        // totalEvaluations. The activation pipeline produces a closed enum.
+        continue;
+    }
+    entry.totalEvaluations += row.count;
+    conceptOccurrences += row.count;
+  }
+
+  const onDiskSlugs = new Set(await onDiskSlugsPromise);
+  for (const entry of bySlug.values()) {
+    entry.onDisk = onDiskSlugs.has(entry.slug);
+  }
+
+  const neverEvaluatedSlugs: string[] = [];
+  for (const slug of onDiskSlugs) {
+    if (!bySlug.has(slug)) neverEvaluatedSlugs.push(slug);
+  }
+  neverEvaluatedSlugs.sort();
+
+  const concepts = [...bySlug.values()].sort((a, b) => {
+    if (b.totalEvaluations !== a.totalEvaluations) {
+      return b.totalEvaluations - a.totalEvaluations;
+    }
+    return a.slug.localeCompare(b.slug);
+  });
+
+  return {
+    filters: { conversationId, sinceMs },
+    totals: {
+      logCount: logCountRow?.count ?? 0,
+      conceptOccurrences,
+    },
+    concepts,
+    neverEvaluatedSlugs,
+  };
+}

package/src/memory/migrations/239-trace-events-created-at-index.ts

@@ -0,0 +1,18 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_trace_events_created_at_index_v1";
+
+/**
+ * Add an index on `trace_events.created_at` so the periodic prune job
+ * can locate expired rows without a full table scan.
+ */
+export function migrateTraceEventsCreatedAtIndex(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+    raw.exec(
+      `CREATE INDEX IF NOT EXISTS idx_trace_events_created_at ON trace_events(created_at)`,
+    );
+  });
+}

package/src/memory/migrations/index.ts

@@ -200,6 +200,7 @@ export {
   migrateHeartbeatRuns,
 } from "./237-heartbeat-runs.js";
 export { migrateScheduleRetryPolicy } from "./238-schedule-retry-policy.js";
+export { migrateTraceEventsCreatedAtIndex } from "./239-trace-events-created-at-index.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/pkb/pkb-search.test.ts

@@ -2,6 +2,13 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { makeMockLogger } from "../../__tests__/helpers/mock-logger.js";
 
+// This test exercises the v1 PKB search path. `config.memory.v2.enabled`
+// (default `true`) makes pkb-search short-circuit to keep traffic off the
+// legacy collection — force it off so the v1 path stays under test.
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({ memory: { v2: { enabled: false } } }),
+}));
+
 mock.module("../../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),
 }));

package/src/memory/pkb/pkb-search.ts

@@ -4,7 +4,6 @@
 
 import { getConfig } from "../../config/loader.js";
 import { getLogger } from "../../util/logger.js";
-import { isMemoryV2ReadActive } from "../context-search/sources/memory-v2.js";
 import {
   isQdrantBreakerOpen,
   withQdrantBreaker,
@@ -42,10 +41,10 @@ export async function searchPkbFiles(
   limit: number,
   scopeIds?: string[],
 ): Promise<PkbSearchResult[]> {
-  // v2 owns the read path when both gates are on; v2 absorbs PKB as a read
-  // source, so PKB hint search short-circuits to keep traffic off the v1
-  // collection (avoiding OOM-crash risk from a corrupted sparse segment).
-  if (isMemoryV2ReadActive(getConfig())) return [];
+  // v2 owns the read path when enabled; v2 absorbs PKB as a read source,
+  // so PKB hint search short-circuits to keep traffic off the v1 collection
+  // (avoiding OOM-crash risk from a corrupted sparse segment).
+  if (getConfig().memory.v2.enabled) return [];
 
   if (isQdrantBreakerOpen()) {
     log.warn("Qdrant circuit breaker open, skipping PKB search");

package/src/memory/qdrant-client.ts

@@ -248,6 +248,9 @@ export class VellumQdrantClient {
           m: 16,
           ef_construct: 100,
         },
+        optimizers_config: {
+          default_segment_number: 2,
+        },
         quantization_config:
           this.quantization === "scalar"
             ? {
@@ -388,7 +391,6 @@ export class VellumQdrantClient {
     limit: number,
     targetTypes: Array<"segment" | "item" | "summary" | "media">,
     excludeMessageIds?: string[],
-    scopeIds?: string[],
   ): Promise<QdrantSearchResult[]> {
     const mustConditions: Array<Record<string, unknown>> = [
       {
@@ -415,18 +417,6 @@ export class VellumQdrantClient {
       });
     }
 
-    // Scope filtering: accept points whose memory_scope_id matches one of the
-    // allowed scopes, OR points that lack the field entirely (legacy data).
-    // Post-query DB filtering remains as defense-in-depth for legacy points.
-    if (scopeIds && scopeIds.length > 0) {
-      mustConditions.push({
-        should: [
-          { key: "memory_scope_id", match: { any: scopeIds } },
-          { is_empty: { key: "memory_scope_id" } },
-        ],
-      });
-    }
-
     const mustNotConditions: Array<Record<string, unknown>> = [
       { key: "_meta", match: { value: true } },
     ];