@vellumai/assistant 0.7.2 → 0.7.3

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

@@ -0,0 +1,272 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+let listPagesImpl: (workspaceDir: string) => Promise<string[]> = async () => [];
+
+mock.module("../v2/page-store.js", () => ({
+  listPages: (workspaceDir: string) => listPagesImpl(workspaceDir),
+}));
+
+import { getDb } from "../db-connection.js";
+import { initializeDb } from "../db-init.js";
+import {
+  type MemoryV2ConceptRowRecord,
+  recordMemoryV2ActivationLog,
+} from "../memory-v2-activation-log-store.js";
+import { getConceptFrequencySummary } from "../memory-v2-concept-frequency.js";
+import { memoryV2ActivationLogs } from "../schema.js";
+import { sampleConfig } from "./fixtures/memory-v2-activation-fixtures.js";
+
+initializeDb();
+
+const WORKSPACE = "/tmp/memory-v2-concept-frequency-test";
+
+function makeConcept(
+  slug: string,
+  status: MemoryV2ConceptRowRecord["status"],
+): MemoryV2ConceptRowRecord {
+  return {
+    slug,
+    finalActivation: 0.5,
+    ownActivation: 0.4,
+    priorActivation: 0.1,
+    simUser: 0.3,
+    simAssistant: 0.2,
+    simNow: 0.1,
+    simUserRerankBoost: 0,
+    simAssistantRerankBoost: 0,
+    inRerankPool: false,
+    spreadContribution: 0.1,
+    source: "ann_top50",
+    status,
+  };
+}
+
+function resetTables(): void {
+  getDb().delete(memoryV2ActivationLogs).run();
+}
+
+describe("memory-v2-concept-frequency", () => {
+  beforeEach(() => {
+    resetTables();
+    listPagesImpl = async () => [];
+  });
+
+  test("aggregates per-status counts across multiple turns", async () => {
+    const conv = "conv-1";
+    recordMemoryV2ActivationLog({
+      conversationId: conv,
+      turn: 1,
+      mode: "context-load",
+      concepts: [
+        makeConcept("alice", "injected"),
+        makeConcept("bob", "not_injected"),
+      ],
+      config: sampleConfig,
+    });
+    recordMemoryV2ActivationLog({
+      conversationId: conv,
+      turn: 2,
+      mode: "per-turn",
+      concepts: [
+        makeConcept("alice", "in_context"),
+        makeConcept("bob", "injected"),
+      ],
+      config: sampleConfig,
+    });
+    recordMemoryV2ActivationLog({
+      conversationId: conv,
+      turn: 3,
+      mode: "per-turn",
+      concepts: [
+        makeConcept("alice", "injected"),
+        makeConcept("charlie", "page_missing"),
+      ],
+      config: sampleConfig,
+    });
+
+    listPagesImpl = async () => ["alice", "bob", "delta"];
+
+    const result = await getConceptFrequencySummary(WORKSPACE, {});
+
+    expect(result.totals.logCount).toBe(3);
+    expect(result.totals.conceptOccurrences).toBe(6);
+    expect(result.filters).toEqual({ conversationId: null, sinceMs: null });
+
+    const bySlug = new Map(result.concepts.map((c) => [c.slug, c]));
+
+    expect(bySlug.get("alice")!.counts).toEqual({
+      injected: 2,
+      in_context: 1,
+      not_injected: 0,
+      page_missing: 0,
+    });
+    expect(bySlug.get("alice")!.totalEvaluations).toBe(3);
+    expect(bySlug.get("alice")!.onDisk).toBe(true);
+    expect(bySlug.get("alice")!.lastInjectedAt).not.toBeNull();
+
+    expect(bySlug.get("bob")!.counts).toEqual({
+      injected: 1,
+      in_context: 0,
+      not_injected: 1,
+      page_missing: 0,
+    });
+    expect(bySlug.get("bob")!.totalEvaluations).toBe(2);
+    expect(bySlug.get("bob")!.onDisk).toBe(true);
+
+    expect(bySlug.get("charlie")!.counts).toEqual({
+      injected: 0,
+      in_context: 0,
+      not_injected: 0,
+      page_missing: 1,
+    });
+    expect(bySlug.get("charlie")!.onDisk).toBe(false);
+    expect(bySlug.get("charlie")!.lastInjectedAt).toBeNull();
+
+    // Sorted by totalEvaluations desc — alice (3) before bob (2) before charlie (1).
+    expect(result.concepts.map((c) => c.slug)).toEqual([
+      "alice",
+      "bob",
+      "charlie",
+    ]);
+
+    // delta is on disk but never appeared in any log row.
+    expect(result.neverEvaluatedSlugs).toEqual(["delta"]);
+  });
+
+  test("conversationId filter narrows aggregation", async () => {
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-a",
+      turn: 1,
+      mode: "per-turn",
+      concepts: [makeConcept("alice", "injected")],
+      config: sampleConfig,
+    });
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-b",
+      turn: 1,
+      mode: "per-turn",
+      concepts: [
+        makeConcept("alice", "injected"),
+        makeConcept("alice", "injected"),
+      ],
+      config: sampleConfig,
+    });
+
+    listPagesImpl = async () => ["alice"];
+
+    const all = await getConceptFrequencySummary(WORKSPACE, {});
+    expect(all.totals.logCount).toBe(2);
+    expect(all.concepts[0]!.counts.injected).toBe(3);
+    expect(all.filters.conversationId).toBeNull();
+
+    const onlyA = await getConceptFrequencySummary(WORKSPACE, {
+      conversationId: "conv-a",
+    });
+    expect(onlyA.totals.logCount).toBe(1);
+    expect(onlyA.concepts[0]!.counts.injected).toBe(1);
+    expect(onlyA.filters.conversationId).toBe("conv-a");
+
+    const onlyB = await getConceptFrequencySummary(WORKSPACE, {
+      conversationId: "conv-b",
+    });
+    expect(onlyB.totals.logCount).toBe(1);
+    expect(onlyB.concepts[0]!.counts.injected).toBe(2);
+  });
+
+  test("sinceMs filter excludes older log rows", async () => {
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-1",
+      turn: 1,
+      mode: "per-turn",
+      concepts: [makeConcept("alice", "injected")],
+      config: sampleConfig,
+    });
+    // Backdate the just-written row — recordMemoryV2ActivationLog uses Date.now().
+    getDb().update(memoryV2ActivationLogs).set({ createdAt: 1_000 }).run();
+
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-1",
+      turn: 2,
+      mode: "per-turn",
+      concepts: [makeConcept("alice", "injected")],
+      config: sampleConfig,
+    });
+
+    listPagesImpl = async () => ["alice"];
+
+    const all = await getConceptFrequencySummary(WORKSPACE, {});
+    expect(all.totals.logCount).toBe(2);
+    expect(all.concepts[0]!.counts.injected).toBe(2);
+
+    const recent = await getConceptFrequencySummary(WORKSPACE, {
+      sinceMs: 10_000,
+    });
+    expect(recent.totals.logCount).toBe(1);
+    expect(recent.concepts[0]!.counts.injected).toBe(1);
+    expect(recent.filters.sinceMs).toBe(10_000);
+  });
+
+  test("never-evaluated list excludes slugs that appeared in any status", async () => {
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-1",
+      turn: 1,
+      mode: "per-turn",
+      concepts: [
+        makeConcept("alice", "injected"),
+        makeConcept("bob", "not_injected"),
+        makeConcept("charlie", "page_missing"),
+      ],
+      config: sampleConfig,
+    });
+
+    listPagesImpl = async () => ["alice", "bob", "delta", "echo"];
+
+    const result = await getConceptFrequencySummary(WORKSPACE, {});
+    // bob was scored but rejected — still excluded from neverEvaluated.
+    expect(result.neverEvaluatedSlugs).toEqual(["delta", "echo"]);
+  });
+
+  test("returns empty result when no logs exist", async () => {
+    listPagesImpl = async () => ["alice", "bob"];
+
+    const result = await getConceptFrequencySummary(WORKSPACE, {});
+    expect(result.totals).toEqual({ logCount: 0, conceptOccurrences: 0 });
+    expect(result.concepts).toEqual([]);
+    expect(result.neverEvaluatedSlugs).toEqual(["alice", "bob"]);
+  });
+
+  test("flags slugs that appear in logs but no longer have a page on disk", async () => {
+    recordMemoryV2ActivationLog({
+      conversationId: "conv-1",
+      turn: 1,
+      mode: "per-turn",
+      concepts: [makeConcept("ghost", "injected")],
+      config: sampleConfig,
+    });
+
+    listPagesImpl = async () => ["alice"];
+
+    const result = await getConceptFrequencySummary(WORKSPACE, {});
+    const ghost = result.concepts.find((c) => c.slug === "ghost")!;
+    expect(ghost.onDisk).toBe(false);
+    expect(ghost.counts.injected).toBe(1);
+  });
+});

package/src/memory/admin.ts

@@ -6,7 +6,6 @@ import { getWorkspaceDir } from "../util/platform.js";
 import { deleteMemoryCheckpoint } from "./checkpoints.js";
 import { runDeterministicRecallSearch } from "./context-search/search.js";
 import type { RecallEvidence } from "./context-search/types.js";
-import { getConversationMemoryScopeId } from "./conversation-crud.js";
 import { getDb } from "./db-connection.js";
 import { getMemoryBackendStatus } from "./embedding-backend.js";
 import {
@@ -32,7 +31,7 @@ import {
 
 const log = getLogger("memory-admin");
 
-export interface MemorySystemStatus {
+interface MemorySystemStatus {
   enabled: boolean;
   degraded: boolean;
   reason: string | null;
@@ -47,7 +46,7 @@ export interface MemorySystemStatus {
   jobs: Record<string, number>;
 }
 
-export interface AdminMemoryQueryResult {
+interface AdminMemoryQueryResult {
   results: Array<{
     id: string;
     content: string;
@@ -106,7 +105,6 @@ export async function queryMemory(
     { query, sources: ["memory", "conversations", "pkb"] },
     {
       workingDir: getWorkspaceDir(),
-      memoryScopeId: getConversationMemoryScopeId(conversationId) ?? "default",
       conversationId,
       config,
     },
@@ -148,7 +146,7 @@ function readNumericMetadata(
 
 // ── Short segment cleanup ─────────────────────────────────────────────
 
-export interface CleanupShortSegmentsResult {
+interface CleanupShortSegmentsResult {
   removed: number;
   failed: number;
   dryRunCount?: number;
@@ -216,7 +214,7 @@ export async function compactLongMemoryNodes(
 
 // ── Re-extraction ──────────────────────────────────────────────────────
 
-export interface ReextractTarget {
+interface ReextractTarget {
   conversationId: string;
   title: string | null;
   messageCount: number;
@@ -312,11 +310,9 @@ export function requestReextract(targets: ReextractTarget[]): {
       )
       .run();
 
-    // Resolve scope and enqueue re-extraction
-    const scopeId = getConversationMemoryScopeId(conversationId);
     const jobId = enqueueMemoryJob("graph_extract", {
       conversationId,
-      scopeId,
+      scopeId: "default",
     });
     jobIds.push(jobId);
 

package/src/memory/context-search/agent-runner.ts

@@ -306,7 +306,17 @@ export async function runAgenticRecall(
         [...RECALL_AGENT_TOOL_DEFINITIONS],
         undefined,
         {
-          config: { callSite: "recall", temperature: 0 },
+          // `thinking: disabled` is required because we set `temperature: 0`
+          // explicitly. Anthropic 400s on `temperature` ≠ 1 whenever thinking
+          // is enabled or in adaptive mode; without this, profiles that
+          // resolve thinking-enabled (Opus 4.x at `effort: high|xhigh`, etc.)
+          // would fail. Recall is tool-call-heavy reasoning where determinism
+          // matters more than extended chain-of-thought.
+          config: {
+            callSite: "recall",
+            temperature: 0,
+            thinking: { type: "disabled" },
+          },
           signal: context.signal,
         },
       );
@@ -597,7 +607,14 @@ async function tryFinalFinishRecall(options: {
       [FINISH_RECALL_TOOL_DEFINITION],
       undefined,
       {
-        config: { callSite: "recall", temperature: 0 },
+        // `thinking: disabled` required for the same reason as the agent
+        // round above — Anthropic 400s on `temperature` ≠ 1 whenever
+        // thinking is enabled or in adaptive mode.
+        config: {
+          callSite: "recall",
+          temperature: 0,
+          thinking: { type: "disabled" },
+        },
         signal: options.context.signal,
       },
     );

package/src/memory/context-search/sources/conversations.ts

@@ -88,10 +88,7 @@ export async function searchConversationSource(
 
   for (const ftsMatch of ftsMatches) {
     try {
-      rows = mergeConversationRows(
-        rows,
-        searchWithFts(ftsMatch, context.memoryScopeId, queryLimit),
-      );
+      rows = mergeConversationRows(rows, searchWithFts(ftsMatch, queryLimit));
     } catch {
       // Try the next, broader query shape.
     }
@@ -100,7 +97,7 @@ export async function searchConversationSource(
   }
 
   if (rows.length === 0) {
-    rows = searchWithLike(trimmedQuery, context.memoryScopeId, queryLimit);
+    rows = searchWithLike(trimmedQuery, queryLimit);
   }
 
   const sortedRows = rows
@@ -130,7 +127,6 @@ export async function searchConversationSource(
 
 function searchWithFts(
   ftsMatch: string,
-  memoryScopeId: string,
   limit: number,
 ): ConversationEvidenceRow[] {
   return rawAll<ConversationEvidenceRow>(
@@ -146,14 +142,12 @@ function searchWithFts(
     JOIN messages m ON m.id = messages_fts.message_id
     JOIN conversations c ON c.id = m.conversation_id
     WHERE messages_fts MATCH ?
-      AND c.memory_scope_id = ?
       AND (c.conversation_type IS NULL OR c.conversation_type != 'private')
       AND (c.source IS NULL OR c.source NOT IN (?, ?))
     ORDER BY bm25(messages_fts), m.created_at DESC
     LIMIT ?
     `,
     ftsMatch,
-    memoryScopeId,
     SUBAGENT_SOURCE,
     AUTO_ANALYSIS_SOURCE,
     limit,
@@ -162,7 +156,6 @@ function searchWithFts(
 
 function searchWithLike(
   query: string,
-  memoryScopeId: string,
   limit: number,
 ): ConversationEvidenceRow[] {
   return rawAll<ConversationEvidenceRow>(
@@ -177,14 +170,12 @@ function searchWithLike(
     FROM messages m
     JOIN conversations c ON c.id = m.conversation_id
     WHERE m.content LIKE ? ESCAPE '\\'
-      AND c.memory_scope_id = ?
       AND (c.conversation_type IS NULL OR c.conversation_type != 'private')
       AND (c.source IS NULL OR c.source NOT IN (?, ?))
     ORDER BY m.created_at DESC
     LIMIT ?
     `,
     buildLikePattern(query),
-    memoryScopeId,
     SUBAGENT_SOURCE,
     AUTO_ANALYSIS_SOURCE,
     limit,

package/src/memory/context-search/sources/memory-v2.ts

@@ -47,10 +47,11 @@ import type {
 } from "../types.js";
 
 /**
- * True when both v2 gates are on. Single source of truth shared by the recall
- * `memory` source (which delegates to v2), the `pkb` source (which
- * short-circuits because v2 absorbs PKB as a read source), and the per-turn
- * PKB injectors (which go silent so v2 owns the read path end-to-end).
+ * True when both v2 gates are on. Single source of truth for whether v2 is
+ * the active memory subsystem — used by recall sources (`memory`, `pkb`),
+ * per-turn injectors, the indexer's v1 graph_extract suppression, and the
+ * v1/v2 maintenance scheduler. The historical name retains "Read" but the
+ * predicate now gates both read and write paths.
  */
 export function isMemoryV2ReadActive(config: AssistantConfig): boolean {
   return (

package/src/memory/context-search/sources/memory.ts

@@ -47,7 +47,6 @@ export async function searchMemorySource(
     const searchResults = await searchGraphNodes(
       queryVector,
       normalizedLimit,
-      [context.memoryScopeId],
       sparseVector,
     );
 

package/src/memory/context-search/types.ts

@@ -24,7 +24,6 @@ export interface RecallEvidence {
 
 export interface RecallSearchContext {
   workingDir: string;
-  memoryScopeId: string;
   conversationId: string;
   config: AssistantConfig;
   signal?: AbortSignal;

package/src/memory/conversation-crud.ts

@@ -115,8 +115,6 @@ export const messageMetadataSchema = z
   })
   .passthrough();
 
-export type MessageMetadata = z.infer<typeof messageMetadataSchema>;
-
 function cloneForkMessageMetadata(
   metadata: string | null,
   sourceMessageId: string,
@@ -444,11 +442,6 @@ export function getConversationSource(conversationId: string): string | null {
   return row?.source ?? null;
 }
 
-export function getConversationMemoryScopeId(conversationId: string): string {
-  const conv = getConversation(conversationId);
-  return conv?.memoryScopeId ?? "default";
-}
-
 /**
  * Fetch group_id for a conversation via raw SQL. group_id is NOT in the
  * Drizzle schema (raw-query-only pattern), so ConversationRow doesn't
@@ -912,7 +905,6 @@ export async function addMessage(
   if (!opts?.skipIndexing) {
     try {
       const config = getConfig();
-      const scopeId = getConversationMemoryScopeId(conversationId);
       const parsed = metadata
         ? messageMetadataSchema.safeParse(metadata)
         : null;
@@ -927,7 +919,7 @@ export async function addMessage(
           role: message.role,
           content: message.content,
           createdAt: message.createdAt,
-          scopeId,
+          scopeId: "default",
           provenanceTrustClass,
           automated,
         },
@@ -1027,7 +1019,7 @@ export function hasMessages(conversationId: string): boolean {
   return row !== undefined;
 }
 
-export interface PaginatedMessagesResult {
+interface PaginatedMessagesResult {
   messages: MessageRow[];
   hasMore: boolean;
 }
@@ -1441,12 +1433,12 @@ export function deleteLastExchange(conversationId: string): number {
  * Callers must delete these from the Qdrant collection after the
  * SQLite transaction commits.
  */
-export interface DeletedMemoryIds {
+interface DeletedMemoryIds {
   segmentIds: string[];
   deletedSummaryIds: string[];
 }
 
-export interface WipeConversationResult extends DeletedMemoryIds {
+interface WipeConversationResult extends DeletedMemoryIds {
   cancelledJobCount: number;
 }
 

package/src/memory/db-init.ts

@@ -165,6 +165,7 @@ import {
   migrateStripPlaceholderSentinelsFromMessages,
   migrateStripThinkingFromConsolidated,
   migrateToolInvocationsMatchedRuleId,
+  migrateTraceEventsCreatedAtIndex,
   migrateUsageDashboardIndexes,
   migrateUsageLlmCallCount,
   migrateVoiceInviteColumns,
@@ -408,6 +409,7 @@ export function initializeDb(): void {
       backfillAppConversationIds();
     },
     migrateScheduleRetryPolicy,
+    migrateTraceEventsCreatedAtIndex,
   ];
 
   // Run each migration step, catching and logging individual failures so one