@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/plugins/defaults/memory/{graph → v1/graph}/bootstrap.ts

@@ -15,30 +15,35 @@ import { join } from "node:path";
 import { and, asc, ne, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getConfig } from "../../../../config/loader.js";
+import { getConfig } from "../../../../../config/loader.js";
+import { isMemoryV1Active } from "../../../../../config/memory-v3-gate.js";
 import {
   getMemoryCheckpoint,
   setMemoryCheckpoint,
-} from "../../../../persistence/checkpoints.js";
-import { getDb } from "../../../../persistence/db-connection.js";
-import { initQdrantClient } from "../../../../persistence/embeddings/qdrant-client.js";
+} from "../../../../../persistence/checkpoints.js";
+import { getDb } from "../../../../../persistence/db-connection.js";
+import { initQdrantClient } from "../../../../../persistence/embeddings/qdrant-client.js";
 import {
   enqueueMemoryJob,
   hasActiveJobOfType,
   isMemoryEnabled,
-} from "../../../../persistence/jobs-store.js";
-import { rawAll, rawGet, rawRun } from "../../../../persistence/raw-query.js";
+} from "../../../../../persistence/jobs-store.js";
+import {
+  rawAll,
+  rawGet,
+  rawRun,
+} from "../../../../../persistence/raw-query.js";
 import {
   conversations,
   memoryGraphNodes,
   memorySegments,
-} from "../../../../persistence/schema/index.js";
-import { resolveQdrantUrl } from "../embeddings.js";
-import { getLogger } from "../logging.js";
-import { memoryDbOrNull } from "../memory-db.js";
-import { getWorkspaceDir } from "../paths.js";
+} from "../../../../../persistence/schema/index.js";
+import { resolveQdrantUrl } from "../../embeddings.js";
+import { countNodes } from "../../graph/store.js";
+import { getLogger } from "../../logging.js";
+import { memoryDbOrNull } from "../../memory-db.js";
+import { getWorkspaceDir } from "../../paths.js";
 import { runGraphExtraction } from "./extraction.js";
-import { countNodes } from "./store.js";
 
 const log = getLogger("graph-bootstrap");
 
@@ -312,16 +317,26 @@ export function resetBootstrapCheckpoint(): void {
 
 /**
  * Enqueue a graph_bootstrap job if the graph is empty (no non-procedural nodes)
- * but historical data exists (segments or journal files). Called on daemon startup
- * to auto-populate the graph for users upgrading from the old extraction system.
+ * but historical data exists (segments or journal files). Called on daemon
+ * startup to auto-populate the graph for users upgrading from the old
+ * extraction system, and again from the v1 branch of the periodic maintenance
+ * scheduler so a config hot-reload onto v1 bootstraps without a restart.
  *
  * Idempotent: does nothing if graph nodes already exist or a bootstrap job is
  * already pending/running.
  */
 export function maybeEnqueueGraphBootstrap(): void {
+  // The bootstrap LLM-extracts history into the legacy v1 graph, which only
+  // the v1 tier reads — so enqueue only when v1 is the active memory tier.
+  if (!isMemoryV1Active(getConfig())) {
+    return;
+  }
+
   // Graph nodes live on the memory connection; segments still live on main.
   const memoryDb = memoryDbOrNull("maybeEnqueueGraphBootstrap");
-  if (!memoryDb) return;
+  if (!memoryDb) {
+    return;
+  }
 
   // Check for non-procedural graph nodes (procedural = capability seeds, not real memories)
   const nonProceduralCount =
@@ -336,7 +351,9 @@ export function maybeEnqueueGraphBootstrap(): void {
       )
       .get()?.count ?? 0;
 
-  if (nonProceduralCount > 0) return; // Graph already populated
+  if (nonProceduralCount > 0) {
+    return; // Graph already populated
+  }
 
   // Check for historical data to bootstrap from
   const segmentCount =
@@ -347,12 +364,14 @@ export function maybeEnqueueGraphBootstrap(): void {
 
   const hasJournalFiles = existsSync(join(getWorkspaceDir(), "journal"));
 
-  if (segmentCount === 0 && !hasJournalFiles) return; // Nothing to bootstrap from
+  if (segmentCount === 0 && !hasJournalFiles) {
+    return; // Nothing to bootstrap from
+  }
 
   // Don't enqueue if already in progress
-  if (hasActiveJobOfType("graph_bootstrap")) return;
-
-  if (!isMemoryEnabled()) return;
+  if (hasActiveJobOfType("graph_bootstrap")) {
+    return;
+  }
 
   log.info(
     { segmentCount, hasJournalFiles },
@@ -523,7 +542,7 @@ export async function cleanupStaleItemVectors(): Promise<void> {
   let qdrant;
   try {
     qdrant = (
-      await import("../../../../persistence/embeddings/qdrant-client.js")
+      await import("../../../../../persistence/embeddings/qdrant-client.js")
     ).getQdrantClient();
   } catch {
     // Qdrant not initialized yet — skip; will run on next startup.

package/src/plugins/defaults/memory/{graph → v1/graph}/consolidation.ts

@@ -12,16 +12,8 @@
 
 import { getConfiguredProvider } from "@vellumai/plugin-api";
 
-import type { AssistantConfig } from "../../../../config/types.js";
-import { getMemoryDb } from "../../../../persistence/db-connection.js";
-import { BackendUnavailableError } from "../host-utils.js";
-import { extractToolUse, userMessage } from "../llm-helpers.js";
-import { getLogger } from "../logging.js";
-import {
-  EVENT_DATE_PROMPT_RULES,
-  formatAuthoritativeConversationTimestamp,
-  parseEpochMs,
-} from "./extraction.js";
+import type { AssistantConfig } from "../../../../../config/types.js";
+import { getMemoryDb } from "../../../../../persistence/db-connection.js";
 import {
   createTrigger,
   deduplicateParagraphs,
@@ -31,9 +23,17 @@ import {
   queryNodes,
   recordNodeEdit,
   updateNode,
-} from "./store.js";
-import type { MemoryNode } from "./types.js";
-import { isCapabilityNode } from "./types.js";
+} from "../../graph/store.js";
+import type { MemoryNode } from "../../graph/types.js";
+import { isCapabilityNode } from "../../graph/types.js";
+import { BackendUnavailableError } from "../../host-utils.js";
+import { extractToolUse, userMessage } from "../../llm-helpers.js";
+import { getLogger } from "../../logging.js";
+import {
+  EVENT_DATE_PROMPT_RULES,
+  formatAuthoritativeConversationTimestamp,
+  parseEpochMs,
+} from "./extraction.js";
 
 const log = getLogger("graph-consolidation");
 
@@ -536,7 +536,7 @@ async function consolidateChunk(
   }
 
   // Apply merge edges (before deletion so the edge can reference the node)
-  const { createEdge } = await import("./store.js");
+  const { createEdge } = await import("../../graph/store.js");
   for (const merge of input.merge_edges ?? []) {
     if (!nodeIds.has(merge.survivor_id) || !nodeIds.has(merge.deleted_id))
       continue;

package/src/plugins/defaults/memory/{graph → v1/graph}/decay.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
+import type { EmotionalCharge } from "../../graph/types.js";
 import { computeDecayedIntensity, computeFidelityLevel } from "./decay.js";
-import type { EmotionalCharge } from "./types.js";
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/plugins/defaults/memory/{graph → v1/graph}/decay.ts

@@ -9,9 +9,9 @@
 
 import { eq, sql } from "drizzle-orm";
 
-import { memoryGraphNodes } from "../../../../persistence/schema/index.js";
-import { memoryDbOrNull } from "../memory-db.js";
-import type { EmotionalCharge, Fidelity } from "./types.js";
+import { memoryGraphNodes } from "../../../../../persistence/schema/index.js";
+import type { EmotionalCharge, Fidelity } from "../../graph/types.js";
+import { memoryDbOrNull } from "../../memory-db.js";
 
 // ---------------------------------------------------------------------------
 // Emotional intensity decay

package/src/plugins/defaults/memory/{graph → v1/graph}/extraction-job.ts

@@ -6,14 +6,14 @@
 // - End-of-conversation extraction (full transcript)
 // ---------------------------------------------------------------------------
 
-import type { AssistantConfig } from "../../../../config/types.js";
+import type { AssistantConfig } from "../../../../../config/types.js";
 import {
   getMemoryCheckpoint,
   setMemoryCheckpoint,
-} from "../../../../persistence/checkpoints.js";
-import { asString } from "../../../../persistence/job-utils.js";
-import type { MemoryJob } from "../../../../persistence/jobs-store.js";
-import { getLogger } from "../logging.js";
+} from "../../../../../persistence/checkpoints.js";
+import { asString } from "../../../../../persistence/job-utils.js";
+import type { MemoryJob } from "../../../../../persistence/jobs-store.js";
+import { getLogger } from "../../logging.js";
 import { runGraphExtraction } from "./extraction.js";
 
 const log = getLogger("graph-extraction-job");

package/src/plugins/defaults/memory/{graph → v1/graph}/extraction.test.ts

@@ -1,11 +1,11 @@
 import { describe, expect, test } from "bun:test";
 
+import type { MemoryDiff, MemoryNode, NewNode } from "../../graph/types.js";
 import type { DeferredEdge } from "./extraction.js";
 import {
   applySupersessionDurability,
   parseExtractionResponse,
 } from "./extraction.js";
-import type { MemoryDiff, MemoryNode, NewNode } from "./types.js";
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/plugins/defaults/memory/{graph → v1/graph}/extraction.ts

@@ -16,22 +16,22 @@ import {
 } from "@vellumai/plugin-api";
 import { and, asc, desc, eq, gt } from "drizzle-orm";
 
-import type { AssistantConfig } from "../../../../config/types.js";
-import { getDb } from "../../../../persistence/db-connection.js";
+import type { AssistantConfig } from "../../../../../config/types.js";
+import { getDb } from "../../../../../persistence/db-connection.js";
 import {
   conversations,
   messages,
-} from "../../../../persistence/schema/index.js";
-import { BackendUnavailableError } from "../host-utils.js";
-import { buildIdentityContext } from "../identity-context.js";
-import { extractToolUse, userMessage } from "../llm-helpers.js";
-import { getLogger } from "../logging.js";
+} from "../../../../../persistence/schema/index.js";
 import {
   enqueueGraphNodeEmbed,
   enqueueGraphTriggerEmbed,
-  searchGraphNodes,
-} from "./graph-search.js";
-import { applyDiff, createEdge, getNodesByIds, queryNodes } from "./store.js";
+} from "../../graph/graph-search.js";
+import {
+  applyDiff,
+  createEdge,
+  getNodesByIds,
+  queryNodes,
+} from "../../graph/store.js";
 import type {
   DecayCurve,
   EmotionalCharge,
@@ -45,7 +45,12 @@ import type {
   NewTrigger,
   SourceType,
   TriggerType,
-} from "./types.js";
+} from "../../graph/types.js";
+import { BackendUnavailableError } from "../../host-utils.js";
+import { extractToolUse, userMessage } from "../../llm-helpers.js";
+import { getLogger } from "../../logging.js";
+import { buildIdentityContext } from "../identity-context.js";
+import { searchGraphNodes } from "./graph-search.js";
 
 const log = getLogger("graph-extraction");
 
@@ -1288,7 +1293,7 @@ export async function runGraphExtraction(
     edgesCreated++;
   }
 
-  const { createTrigger } = await import("./store.js");
+  const { createTrigger } = await import("../../graph/store.js");
 
   for (const dt of deferredTriggers) {
     const newNodeId = createdNodeIds[dt.newNodeIndex];
@@ -1310,7 +1315,8 @@ export async function runGraphExtraction(
   // 10. Embed new nodes — inline for bootstrap, async for live conversations
   const createdNodes = getNodesByIds(createdNodeIds);
   if (opts?.embedInline) {
-    const { embedGraphNodeDirect } = await import("./graph-search.js");
+    const { embedGraphNodeDirect } =
+      await import("../../graph/graph-search.js");
     for (const node of createdNodes) {
       try {
         await embedGraphNodeDirect(node);
@@ -1606,7 +1612,7 @@ async function findCandidateNodes(
   } else {
     // Live mode: semantic search via Qdrant
     const { embedWithRetry } =
-      await import("../../../../persistence/embeddings/embed.js");
+      await import("../../../../../persistence/embeddings/embed.js");
     const searchText =
       transcript.length > 3000
         ? transcript.slice(0, 1500) + "\n...\n" + transcript.slice(-1500)

package/src/plugins/defaults/memory/{graph → v1/graph}/graph-search.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { setConfig } from "../../../../__tests__/helpers/set-config.js";
+import { setConfig } from "../../../../../__tests__/helpers/set-config.js";
 
 // This test exercises the v1 graph search path. `config.memory.v2.enabled`
 // (default `true`) makes graph-search short-circuit to keep traffic off
@@ -22,7 +22,7 @@ const searchCalls: Array<{
 }> = [];
 
 mock.module(
-  "../../../../persistence/embeddings/qdrant-circuit-breaker.js",
+  "../../../../../persistence/embeddings/qdrant-circuit-breaker.js",
   () => ({
     isQdrantBreakerOpen: () => breakerOpen,
     withQdrantBreaker: async <T>(fn: () => Promise<T>): Promise<T> => fn(),
@@ -32,7 +32,7 @@ mock.module(
   }),
 );
 
-mock.module("../../../../persistence/embeddings/qdrant-client.js", () => ({
+mock.module("../../../../../persistence/embeddings/qdrant-client.js", () => ({
   getQdrantClient: () => ({
     hybridSearch: async (params: {
       denseVector: number[];

package/src/plugins/defaults/memory/v1/graph/graph-search.ts

@@ -0,0 +1,123 @@
+// ---------------------------------------------------------------------------
+// Memory Graph — v1 hybrid Qdrant search over graph nodes
+// ---------------------------------------------------------------------------
+
+import { getConfig } from "../../../../../config/loader.js";
+import { usesConceptPageMemory } from "../../../../../config/memory-v3-gate.js";
+import { isQdrantBreakerOpen } from "../../../../../persistence/embeddings/qdrant-circuit-breaker.js";
+import { withQdrantBreaker } from "../../../../../persistence/embeddings/qdrant-circuit-breaker.js";
+import {
+  getQdrantClient,
+  type QdrantSearchResult,
+  type QdrantSparseVector,
+} from "../../../../../persistence/embeddings/qdrant-client.js";
+import { getLogger } from "../../logging.js";
+
+// Distinct from the all-tier `graph/graph-search.ts` module, which owns the
+// bare `graph-search` scope. The tier split left both emitting under one name;
+// log scopes are observable, so the v1 half takes its own.
+const log = getLogger("v1-graph-search");
+
+export interface GraphSearchResult {
+  nodeId: string;
+  score: number;
+  text: string;
+}
+
+/**
+ * Semantic search across graph nodes in Qdrant. Returns scored node IDs
+ * that the caller can hydrate from the graph store.
+ *
+ * Filters to `target_type: "graph_node"`.
+ */
+export async function searchGraphNodes(
+  queryVector: number[],
+  limit: number,
+  sparseVector?: QdrantSparseVector,
+  dateRange?: { afterMs?: number; beforeMs?: number },
+): Promise<GraphSearchResult[]> {
+  // Concept-page memory owns the read path when active. The v1 `memory`
+  // collection is in active retirement and a corrupted sparse segment can
+  // OOM-crash the shared Qdrant process — short-circuiting here keeps v1
+  // background work and stale callers from taking it down.
+  if (usesConceptPageMemory(getConfig().memory)) {
+    return [];
+  }
+
+  if (isQdrantBreakerOpen()) {
+    log.warn("Qdrant circuit breaker open, skipping graph search");
+    return [];
+  }
+
+  const client = getQdrantClient();
+
+  const mustNot: Record<string, unknown>[] = [
+    { key: "_meta", match: { value: true } },
+  ];
+
+  // Use hybrid search (dense + sparse with RRF fusion) when a non-empty
+  // sparse vector is available; otherwise fall back to dense-only search.
+  if (sparseVector && sparseVector.indices.length > 0) {
+    const must: Record<string, unknown>[] = [
+      { key: "target_type", match: { value: "graph_node" } },
+    ];
+    if (dateRange?.afterMs != null) {
+      must.push({ key: "created_at", range: { gte: dateRange.afterMs } });
+    }
+    if (dateRange?.beforeMs != null) {
+      must.push({ key: "created_at", range: { lte: dateRange.beforeMs } });
+    }
+    const filter = { must, must_not: mustNot };
+
+    // RRF fuses per-modality top-N. A small prefetch (e.g. limit*3) silently
+    // truncates good matches when the query is wordy or low-similarity, so
+    // give RRF a meaningful candidate window with a generous floor.
+    const prefetchLimit = Math.max(limit * 10, 200);
+
+    const results: QdrantSearchResult[] = await withQdrantBreaker(() =>
+      client.hybridSearch({
+        denseVector: queryVector,
+        sparseVector,
+        filter,
+        limit,
+        prefetchLimit,
+      }),
+    );
+
+    return results.map((r) => ({
+      nodeId: r.payload.target_id,
+      score: r.score,
+      text: r.payload.text,
+    }));
+  }
+
+  // Dense-only fallback
+  const denseMusts: Record<string, unknown>[] = [
+    {
+      key: "target_type",
+      match: { value: "graph_node" },
+    },
+  ];
+
+  if (dateRange?.afterMs != null) {
+    denseMusts.push({ key: "created_at", range: { gte: dateRange.afterMs } });
+  }
+  if (dateRange?.beforeMs != null) {
+    denseMusts.push({ key: "created_at", range: { lte: dateRange.beforeMs } });
+  }
+
+  const filter: Record<string, unknown> = {
+    must: denseMusts,
+    must_not: mustNot,
+  };
+
+  const results: QdrantSearchResult[] = await withQdrantBreaker(async () => {
+    return client.search(queryVector, limit, filter);
+  });
+
+  return results.map((r) => ({
+    nodeId: r.payload.target_id,
+    score: r.score,
+    text: r.payload.text,
+  }));
+}

package/src/plugins/defaults/memory/{graph → v1/graph}/injection.test.ts

@@ -1,12 +1,11 @@
 import { describe, expect, test } from "bun:test";
 
+import type { MemoryNode, ScoredNode } from "../../graph/types.js";
 import {
   assembleContextBlock,
   assembleInjectionBlock,
   formatEventDate,
-  InContextTracker,
 } from "./injection.js";
-import type { MemoryNode, ScoredNode } from "./types.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -66,122 +65,6 @@ function makeScored(
   };
 }
 
-// ---------------------------------------------------------------------------
-// InContextTracker
-// ---------------------------------------------------------------------------
-
-describe("InContextTracker", () => {
-  test("tracks added node IDs", () => {
-    const tracker = new InContextTracker();
-    tracker.add(["a", "b"]);
-    expect(tracker.isInContext("a")).toBe(true);
-    expect(tracker.isInContext("b")).toBe(true);
-    expect(tracker.isInContext("c")).toBe(false);
-  });
-
-  test("filters out nodes already in context", () => {
-    const tracker = new InContextTracker();
-    tracker.add(["a"]);
-
-    const candidates: ScoredNode[] = [
-      makeScored({ id: "a" }),
-      makeScored({ id: "b" }),
-      makeScored({ id: "c" }),
-    ];
-    const filtered = tracker.filterNew(candidates);
-    expect(filtered).toHaveLength(2);
-    expect(filtered.map((c) => c.node.id)).toEqual(["b", "c"]);
-  });
-
-  test("advances turn counter", () => {
-    const tracker = new InContextTracker();
-    expect(tracker.getTurn()).toBe(0);
-    tracker.advanceTurn();
-    expect(tracker.getTurn()).toBe(1);
-    tracker.advanceTurn();
-    expect(tracker.getTurn()).toBe(2);
-  });
-
-  test("records injection log with turn numbers", () => {
-    const tracker = new InContextTracker();
-    tracker.add(["a"]);
-    tracker.advanceTurn();
-    tracker.add(["b"]);
-
-    const log = tracker.getLog();
-    expect(log).toHaveLength(2);
-    expect(log[0]).toEqual({ nodeId: "a", turn: 0 });
-    expect(log[1]).toEqual({ nodeId: "b", turn: 1 });
-  });
-
-  test("returns all active node IDs", () => {
-    const tracker = new InContextTracker();
-    tracker.add(["a", "b"]);
-    tracker.advanceTurn();
-    tracker.add(["c"]);
-
-    const active = tracker.getActiveNodeIds();
-    expect(active.sort()).toEqual(["a", "b", "c"]);
-  });
-
-  test("evicts compacted turns", () => {
-    const tracker = new InContextTracker();
-    tracker.add(["a"]);
-    tracker.advanceTurn();
-    tracker.add(["b"]);
-    tracker.advanceTurn();
-    tracker.add(["c"]);
-
-    // Evict turns 0 and 1
-    tracker.evictCompactedTurns(1);
-
-    expect(tracker.isInContext("a")).toBe(false);
-    expect(tracker.isInContext("b")).toBe(false);
-    expect(tracker.isInContext("c")).toBe(true);
-  });
-
-  test("keeps nodes that appear in both compacted and non-compacted turns", () => {
-    const tracker = new InContextTracker();
-    tracker.add(["a"]);
-    tracker.advanceTurn();
-    tracker.add(["a"]); // same node re-injected in turn 1
-
-    // Evict turn 0 only
-    tracker.evictCompactedTurns(0);
-
-    // "a" should still be in context because it was also injected in turn 1
-    expect(tracker.isInContext("a")).toBe(true);
-  });
-
-  test("eviction cleans up log entries", () => {
-    const tracker = new InContextTracker();
-    tracker.add(["a"]);
-    tracker.advanceTurn();
-    tracker.add(["b"]);
-
-    tracker.evictCompactedTurns(0);
-
-    const log = tracker.getLog();
-    expect(log).toHaveLength(1);
-    expect(log[0].nodeId).toBe("b");
-  });
-
-  test("evicting with upToTurn=0 only evicts turn 0", () => {
-    const tracker = new InContextTracker();
-    tracker.add(["a"]);
-    tracker.advanceTurn();
-    tracker.add(["b"]);
-    tracker.advanceTurn();
-    tracker.add(["c"]);
-
-    tracker.evictCompactedTurns(0);
-
-    expect(tracker.isInContext("a")).toBe(false);
-    expect(tracker.isInContext("b")).toBe(true);
-    expect(tracker.isInContext("c")).toBe(true);
-  });
-});
-
 // ---------------------------------------------------------------------------
 // assembleContextBlock
 // ---------------------------------------------------------------------------