@vellumai/assistant 0.7.0 → 0.7.2

package/src/memory/graph/conversation-graph-memory.ts

@@ -235,7 +235,7 @@ export class ConversationGraphMemory {
     }
     // Re-track node IDs since onCompacted evicted them
     this.tracker.add(this.lastInjectedNodeIds);
-    // Strip any existing <memory __injected> blocks from the last user message
+    // Strip any existing <memory> blocks from the last user message
     // before re-injecting, so compaction sites don't end up with duplicates.
     const cleaned = stripExistingMemoryInjections(messages);
 
@@ -264,7 +264,7 @@ export class ConversationGraphMemory {
    * Re-register cached node IDs with the InContextTracker after compaction
    * WITHOUT modifying messages. Use this at post-agent-loop compaction sites
    * where the memory block already survives on the original user message
-   * (since `<memory __injected>` is not stripped by stripInjectionsForCompaction).
+   * (since `<memory>` is not stripped by stripInjectionsForCompaction).
    *
    * Calling reinjectCachedMemory at these sites would inject a duplicate
    * onto the last user message — which after tool calls is a tool_result,
@@ -403,11 +403,17 @@ export class ConversationGraphMemory {
     // assistantMessage is empty: context-load fires on turn 1 / post-
     // compaction, so there is no immediately-prior assistant turn to
     // weight the activation against.
+    //
+    // Use the raw user text (no >10-char filter) so even short greetings
+    // ("hi") get a fresh top-K activation dump on the first user message.
+    // The activation pipeline is robust to weak ANN signal — it still falls
+    // back to spreading + nowText to surface candidates.
+    const rawUserText = readRawUserText(messages[messages.length - 1]);
     const v2 = await this.maybeRouteV2Injection(
       messages,
       config,
       "context-load",
-      userQuery ?? "",
+      rawUserText ?? userQuery ?? "",
       "",
     );
     if (v2.routed) {
@@ -685,7 +691,7 @@ export class ConversationGraphMemory {
 
     return {
       routed: true,
-      runMessages: prependMemoryV2Block(messages, result.block),
+      runMessages: injectTextBlock(messages, result.block),
       injectedBlockText: result.block,
     };
   }
@@ -699,7 +705,7 @@ export class ConversationGraphMemory {
  * Count the leading content blocks on a user message that were added by
  * `injectMemoryBlock`. Memory-injected images use a 3-block pattern
  * (opening `<memory_image>` text + image + closing `</memory_image>` text),
- * followed by a `<memory __injected>…</memory>` text block. A legacy
+ * followed by a `<memory>…</memory>` text block (legacy `<memory __injected>` is also accepted). A legacy
  * 2-block image pattern (no closing tag) is also accepted for backward
  * compatibility. The injection prefix is always contiguous at the start,
  * so we stop at the first non-memory block.
@@ -712,7 +718,8 @@ export function countMemoryPrefixBlocks(content: ContentBlock[]): number {
     const block = content[firstNonMemory];
     if (
       block.type === "text" &&
-      block.text.startsWith("<memory __injected>\n")
+      (block.text.startsWith("<memory>\n") ||
+        block.text.startsWith("<memory __injected>\n"))
     ) {
       firstNonMemory++;
       prevWasMemoryImageMarker = false;
@@ -747,7 +754,7 @@ export function countMemoryPrefixBlocks(content: ContentBlock[]): number {
  *
  * `injectMemoryBlock` always prepends blocks in this order:
  *   1. For each image: `<memory_image __injected>…` text + `image` + `</memory_image>` text (3-block group)
- *   2. `<memory __injected>…</memory>` text block
+ *   2. `<memory>…</memory>` text block
  *
  * We strip all leading blocks that match this pattern so that
  * `reinjectCachedMemory` is idempotent — no duplicate images after compaction.
@@ -795,7 +802,7 @@ function injectTextBlock(messages: Message[], text: string): Message[] {
       content: [
         {
           type: "text" as const,
-          text: `<memory __injected>\n${text}\n</memory>`,
+          text: `<memory>\n${text}\n</memory>`,
         },
         ...userTail.content,
       ],
@@ -839,7 +846,7 @@ function injectMemoryBlock(
 
   blocks.push({
     type: "text" as const,
-    text: `<memory __injected>\n${text}\n</memory>`,
+    text: `<memory>\n${text}\n</memory>`,
   });
 
   return [
@@ -848,37 +855,29 @@ function injectMemoryBlock(
   ];
 }
 
-/** Extract text content from a user message. */
+/**
+ * Extract text content from a user message for v1's `loadContextMemory`,
+ * skipping very short messages because v1's path embeds a single dense
+ * vector and short queries produce vague results.
+ */
 function extractUserText(message: Message): string | null {
-  const texts = message.content
-    .filter((b): b is Extract<typeof b, { type: "text" }> => b.type === "text")
-    .map((b) => b.text.trim())
-    .filter((t) => t.length > 0);
-  if (texts.length === 0) return null;
-  const joined = texts.join(" ");
-  // Skip very short messages ("hi", "yes") — they produce vague embeddings
+  const joined = readRawUserText(message);
+  if (!joined) return null;
   return joined.length > 10 ? joined : null;
 }
 
 /**
- * Prepend a pre-rendered `<memory __injected>` block (produced by
- * `injectMemoryV2Block`) to the last user message. Unlike v1's
- * {@link injectMemoryBlock}, the input here is already wrapped — we
- * just need to attach it as a leading text block. We still strip any
- * pre-existing memory injections first so the layer is idempotent
- * across compaction-driven re-injection.
+ * Raw user-text reader (no length filter). The v2 activation pipeline can
+ * use even short queries because it spreads activation through the edge
+ * graph and combines user/assistant/now signals, so the ≤10-char guard
+ * v1 needs would unnecessarily starve v2 on short greetings.
  */
-function prependMemoryV2Block(messages: Message[], block: string): Message[] {
-  if (block.trim().length === 0) return messages;
-  if (messages.length === 0) return messages;
-  const cleaned = stripExistingMemoryInjections(messages);
-  const userTail = cleaned[cleaned.length - 1];
-  if (!userTail || userTail.role !== "user") return messages;
-  return [
-    ...cleaned.slice(0, -1),
-    {
-      ...userTail,
-      content: [{ type: "text" as const, text: block }, ...userTail.content],
-    },
-  ];
+function readRawUserText(message: Message | undefined): string | null {
+  if (!message) return null;
+  const texts = message.content
+    .filter((b): b is Extract<typeof b, { type: "text" }> => b.type === "text")
+    .map((b) => b.text.trim())
+    .filter((t) => t.length > 0);
+  if (texts.length === 0) return null;
+  return texts.join(" ");
 }

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

@@ -2,8 +2,10 @@
 // Memory Graph — Qdrant vector search for graph nodes
 // ---------------------------------------------------------------------------
 
+import { getConfig } from "../../config/loader.js";
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
+import { isMemoryV2ReadActive } from "../context-search/sources/memory-v2.js";
 import { selectedBackendSupportsMultimodal } from "../embedding-backend.js";
 import type { EmbeddingInput } from "../embedding-types.js";
 import { embedAndUpsert } from "../job-utils.js";
@@ -48,6 +50,12 @@ export async function searchGraphNodes(
   dateRange?: { afterMs?: number; beforeMs?: number },
   excludeScopeIds?: string[],
 ): Promise<GraphSearchResult[]> {
+  // v2 owns the read path when both gates are on. 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 v2 down with them.
+  if (isMemoryV2ReadActive(getConfig())) return [];
+
   if (isQdrantBreakerOpen()) {
     log.warn("Qdrant circuit breaker open, skipping graph search");
     return [];

package/src/memory/graph/injection.test.ts

@@ -192,9 +192,9 @@ describe("assembleContextBlock", () => {
     expect(assembleContextBlock([])).toBe("");
   });
 
-  test("includes the main heading", () => {
+  test("omits the legacy `What I Remember Right Now` heading", () => {
     const result = assembleContextBlock([makeScored()]);
-    expect(result).toContain("## What I Remember Right Now");
+    expect(result).not.toContain("## What I Remember Right Now");
   });
 
   test("puts prospective nodes under Active Threads", () => {

package/src/memory/graph/injection.ts

@@ -381,7 +381,7 @@ export function assembleContextBlock(
   }
 
   if (parts.length === 0) return "";
-  return `## What I Remember Right Now\n\n${parts.join("\n\n")}`;
+  return parts.join("\n\n");
 }
 
 function buildSection(nodes: ScoredNode[], maxItems: number): string[] {

package/src/memory/graph/retriever.ts

@@ -14,6 +14,7 @@ import {
 } from "../../providers/provider-send-message.js";
 import type { ContentBlock, ImageContent } from "../../providers/types.js";
 import { getLogger } from "../../util/logger.js";
+import { isMemoryV2ReadActive } from "../context-search/sources/memory-v2.js";
 import { embedWithRetry } from "../embed.js";
 import {
   generateSparseEmbedding,
@@ -425,6 +426,33 @@ export interface ContextLoadResult {
 export async function loadContextMemory(
   opts: ContextLoadOpts,
 ): Promise<ContextLoadResult> {
+  // v2 owns the read path when both gates are on. The v1 collection is in
+  // active retirement and querying it can OOM-crash Qdrant via a corrupted
+  // sparse segment, so we skip the embedding work and downstream searches
+  // entirely. Caller (`runContextLoad`) sees zero nodes and routes to the
+  // v2 activation pipeline.
+  if (isMemoryV2ReadActive(opts.config)) {
+    return {
+      nodes: [],
+      serendipityNodes: [],
+      triggeredNodes: [],
+      latencyMs: 0,
+      metrics: {
+        semanticHits: 0,
+        mergedCount: 0,
+        selectedCount: 0,
+        tier1Count: 0,
+        tier2Count: 0,
+        hybridSearchLatencyMs: 0,
+        sparseVectorUsed: false,
+        embeddingProvider: null,
+        embeddingModel: null,
+        queryContext: null,
+        topCandidates: [],
+      },
+    };
+  }
+
   const start = Date.now();
   const ctxLoadCfg = opts.config.memory.retrieval.injection.contextLoad;
   const maxNodes = opts.maxNodes ?? ctxLoadCfg.maxNodes;

package/src/memory/graph/tools.ts

@@ -76,7 +76,7 @@ export const graphRememberDefinition: ToolDefinition = {
       finish_turn: {
         type: "boolean",
         description:
-          "Set to true ONLY on the final `remember` call when you have nothing else to say and want to hand control back to the user. When true, the assistant turn ends after this tool call and no further LLM call is made. Do NOT set true on intermediate `remember` calls. Default: false.",
+          "When you have nothing else to say and want to hand control back to the user you MUST set this to true. When true, your turn ends after this tool call. It's critical that you do this in order to avoid unnecessary LLM calls.",
       },
     },
     required: ["content"],

package/src/memory/guardian-action-store.ts

@@ -222,18 +222,6 @@ export function getGuardianActionRequest(
   return row ? rowToRequest(row) : null;
 }
 
-export function getByPendingQuestionId(
-  questionId: string,
-): GuardianActionRequest | null {
-  const db = getDb();
-  const row = db
-    .select()
-    .from(guardianActionRequests)
-    .where(eq(guardianActionRequests.pendingQuestionId, questionId))
-    .get();
-  return row ? rowToRequest(row) : null;
-}
-
 /**
  * Find the most recent pending guardian action request for a given call session.
  * Used by the consultation timeout handler to mark the linked request as timed out.
@@ -382,37 +370,6 @@ export function supersedeGuardianActionRequest(
   return getGuardianActionRequest(id);
 }
 
-/**
- * Backfill supersession metadata on an already-expired request.
- * Used when the superseding request ID is not known at the time the
- * original request is expired (e.g., the new request is created
- * asynchronously via dispatchGuardianQuestion).
- *
- * Only updates requests that are already in 'expired' status with
- * expired_reason='superseded'.
- */
-export function backfillSupersessionMetadata(
-  id: string,
-  supersededByRequestId: string,
-): void {
-  const db = getDb();
-  const now = Date.now();
-
-  db.update(guardianActionRequests)
-    .set({
-      supersededByRequestId,
-      supersededAt: now,
-      updatedAt: now,
-    })
-    .where(
-      and(
-        eq(guardianActionRequests.id, id),
-        eq(guardianActionRequests.status, "expired"),
-      ),
-    )
-    .run();
-}
-
 /**
  * Get all pending guardian action requests that have expired.
  */
@@ -683,46 +640,6 @@ export function createGuardianActionDelivery(params: {
   return rowToDelivery(row);
 }
 
-/**
- * Look up sent deliveries for a specific destination.
- * Used by inbound message routing to match incoming answers to deliveries.
- */
-export function getPendingDeliveriesByDestination(
-  channel: string,
-  chatId: string,
-): GuardianActionDelivery[] {
-  try {
-    const db = getDb();
-
-    const rows = db
-      .select({
-        delivery: guardianActionDeliveries,
-      })
-      .from(guardianActionDeliveries)
-      .innerJoin(
-        guardianActionRequests,
-        eq(guardianActionDeliveries.requestId, guardianActionRequests.id),
-      )
-      .where(
-        and(
-          eq(guardianActionRequests.status, "pending"),
-          eq(guardianActionDeliveries.destinationChannel, channel),
-          eq(guardianActionDeliveries.destinationChatId, chatId),
-          eq(guardianActionDeliveries.status, "sent"),
-        ),
-      )
-      .all();
-
-    return rows.map((r) => rowToDelivery(r.delivery));
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("no such table")) {
-      log.warn({ err }, "guardian tables not yet created");
-      return [];
-    }
-    throw err;
-  }
-}
-
 /**
  * Look up all pending deliveries by destination conversation ID.
  * Used for disambiguation when a reused vellum conversation has multiple active

package/src/memory/guardian-approvals.ts

@@ -292,54 +292,6 @@ export function updateApprovalDecision(
     .run();
 }
 
-// ---------------------------------------------------------------------------
-// Escalation Query Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * List approval requests optionally filtered by channel, conversation, and
- * status. Returns a paginated list of escalations.
- */
-export function listPendingApprovalRequests(params: {
-  channel?: string;
-  conversationId?: string;
-  status?: ApprovalRequestStatus;
-  limit?: number;
-  offset?: number;
-}): GuardianApprovalRequest[] {
-  const db = getDb();
-
-  const conditions: ReturnType<typeof eq>[] = [];
-  if (params.channel) {
-    conditions.push(
-      eq(channelGuardianApprovalRequests.channel, params.channel),
-    );
-  }
-  if (params.conversationId) {
-    conditions.push(
-      eq(channelGuardianApprovalRequests.conversationId, params.conversationId),
-    );
-  }
-  conditions.push(
-    eq(channelGuardianApprovalRequests.status, params.status ?? "pending"),
-  );
-
-  let query = db
-    .select()
-    .from(channelGuardianApprovalRequests)
-    .where(and(...conditions))
-    .orderBy(desc(channelGuardianApprovalRequests.createdAt));
-
-  if (params.limit !== undefined) {
-    query = query.limit(params.limit) as typeof query;
-  }
-  if (params.offset !== undefined) {
-    query = query.offset(params.offset) as typeof query;
-  }
-
-  return query.all().map(rowToApprovalRequest);
-}
-
 /**
  * Fetch a single approval request by its primary key.
  */

package/src/memory/indexer.ts

@@ -1,5 +1,5 @@
 import { createHash } from "crypto";
-import { desc, eq } from "drizzle-orm";
+import { eq } from "drizzle-orm";
 
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
@@ -349,20 +349,6 @@ export function enqueueRebuildIndexJob(): string {
   return enqueueMemoryJob("rebuild_index", {});
 }
 
-export function getRecentSegmentsForConversation(
-  conversationId: string,
-  limit: number,
-): Array<typeof memorySegments.$inferSelect> {
-  const db = getDb();
-  return db
-    .select()
-    .from(memorySegments)
-    .where(eq(memorySegments.conversationId, conversationId))
-    .orderBy(desc(memorySegments.createdAt))
-    .limit(limit)
-    .all();
-}
-
 function buildSegmentId(messageId: string, segmentIndex: number): string {
   return `${messageId}:${segmentIndex}`;
 }

package/src/memory/job-handlers/conversation-starters.ts

@@ -19,6 +19,16 @@ import {
 } from "../../providers/provider-send-message.js";
 import { getLogger } from "../../util/logger.js";
 import { truncate } from "../../util/truncate.js";
+import {
+  checkpointKey,
+  CK_BATCH,
+  CK_ITEM_COUNT,
+  CK_LAST_GEN_AT,
+  countActiveMemoryNodes,
+  getCheckpointValue,
+  parseCheckpointInt,
+  upsertCheckpoint,
+} from "../conversation-starter-checkpoints.js";
 import {
   buildConversationStarterValidationContext,
   isValidConversationStarterText,
@@ -26,23 +36,11 @@ import {
 import { getDb } from "../db-connection.js";
 import { asString } from "../job-utils.js";
 import type { MemoryJob } from "../jobs-store.js";
-import { rawAll, rawGet } from "../raw-query.js";
-import {
-  conversationStarters,
-  memoryCheckpoints,
-  memoryGraphNodes,
-} from "../schema.js";
+import { rawAll } from "../raw-query.js";
+import { conversationStarters, memoryGraphNodes } from "../schema.js";
 
 const log = getLogger("conversation-starters-gen");
 
-function checkpointKey(base: string, scopeId: string): string {
-  return `${base}:${scopeId}`;
-}
-
-const CK_ITEM_COUNT = "conversation_starters:item_count_at_last_gen";
-const CK_BATCH = "conversation_starters:generation_batch";
-const CK_LAST_GEN_AT = "conversation_starters:last_gen_at";
-
 // ── Rollup construction ───────────────────────────────────────────
 
 function buildMemoryRollup(scopeId: string): string {
@@ -97,13 +95,10 @@ function buildMemoryRollup(scopeId: string): string {
 }
 
 function buildNewItemsDiff(scopeId: string): string {
-  const db = getDb();
-  const checkpoint = db
-    .select({ value: memoryCheckpoints.value })
-    .from(memoryCheckpoints)
-    .where(eq(memoryCheckpoints.key, checkpointKey(CK_LAST_GEN_AT, scopeId)))
-    .get();
-  const lastGenAt = checkpoint ? parseInt(checkpoint.value, 10) : 0;
+  const lastGenAt =
+    parseCheckpointInt(
+      getCheckpointValue(checkpointKey(CK_LAST_GEN_AT, scopeId)),
+    ) ?? 0;
 
   if (lastGenAt === 0) return ""; // No previous generation — skip diff
 
@@ -400,25 +395,27 @@ export async function generateConversationStartersJob(
   job: MemoryJob,
 ): Promise<void> {
   const scopeId = asString(job.payload.scopeId) ?? "default";
+  const db = getDb();
+  const now = Date.now();
 
   const starters = await generateStarters(scopeId);
   if (starters.length === 0) {
     log.info({ scopeId }, "No conversation starters generated");
+
+    // Sync checkpoints so both `staleByAge` and `checkpointAhead` clear.
+    const totalActive = countActiveMemoryNodes(scopeId);
+    upsertCheckpoint(
+      checkpointKey(CK_ITEM_COUNT, scopeId),
+      String(totalActive),
+      now,
+    );
+    upsertCheckpoint(checkpointKey(CK_LAST_GEN_AT, scopeId), String(now), now);
     return;
   }
 
-  const db = getDb();
-  const now = Date.now();
-
   // Determine next batch number
-  const batchCheckpoint = db
-    .select({ value: memoryCheckpoints.value })
-    .from(memoryCheckpoints)
-    .where(eq(memoryCheckpoints.key, checkpointKey(CK_BATCH, scopeId)))
-    .get();
-  const nextBatch = batchCheckpoint
-    ? parseInt(batchCheckpoint.value, 10) + 1
-    : 1;
+  const prevBatch = getCheckpointValue(checkpointKey(CK_BATCH, scopeId));
+  const nextBatch = prevBatch ? parseInt(prevBatch, 10) + 1 : 1;
 
   // Collect the memory types that informed this batch
   let sourceKinds = "";
@@ -444,7 +441,6 @@ export async function generateConversationStartersJob(
     .where(eq(conversationStarters.scopeId, scopeId))
     .run();
 
-  // Insert starters — all are chips
   for (const starter of starters) {
     db.insert(conversationStarters)
       .values({
@@ -461,27 +457,14 @@ export async function generateConversationStartersJob(
       .run();
   }
 
-  // Count active items for checkpoint
-  const countRow = rawGet<{ c: number }>(
-    `SELECT COUNT(*) AS c FROM memory_graph_nodes WHERE fidelity != 'gone' AND scope_id = ?`,
-    scopeId,
+  const totalActive = countActiveMemoryNodes(scopeId);
+  upsertCheckpoint(
+    checkpointKey(CK_ITEM_COUNT, scopeId),
+    String(totalActive),
+    now,
   );
-  const totalActive = countRow?.c ?? 0;
-
-  // Update all three checkpoints
-  const upsertCheckpoint = (key: string, value: string) => {
-    db.insert(memoryCheckpoints)
-      .values({ key, value, updatedAt: now })
-      .onConflictDoUpdate({
-        target: memoryCheckpoints.key,
-        set: { value, updatedAt: now },
-      })
-      .run();
-  };
-
-  upsertCheckpoint(checkpointKey(CK_ITEM_COUNT, scopeId), String(totalActive));
-  upsertCheckpoint(checkpointKey(CK_BATCH, scopeId), String(nextBatch));
-  upsertCheckpoint(checkpointKey(CK_LAST_GEN_AT, scopeId), String(now));
+  upsertCheckpoint(checkpointKey(CK_BATCH, scopeId), String(nextBatch), now);
+  upsertCheckpoint(checkpointKey(CK_LAST_GEN_AT, scopeId), String(now), now);
 
   log.info(
     { scopeId, batch: nextBatch, count: starters.length },

package/src/memory/job-utils.ts

@@ -132,12 +132,6 @@ export function asString(value: unknown): string | null {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
 
-export function asPositiveMs(value: unknown): number | null {
-  if (typeof value !== "number") return null;
-  if (!Number.isFinite(value) || value <= 0) return null;
-  return Math.floor(value);
-}
-
 export function truncate(text: string, max: number): string {
   if (text.length <= max) return text;
   return `${text.slice(0, max - 3)}...`;

package/src/memory/jobs/__tests__/embed-concept-page.test.ts

@@ -103,6 +103,12 @@ mock.module("../../v2/qdrant.js", () => ({
   deleteConceptPageEmbedding: async (slug: string) => {
     deleteCalls.push(slug);
   },
+  // Other exports from the real module — stubbed so transitive imports
+  // don't crash on missing names when the mock replaces the module wholesale.
+  hybridQueryConceptPages: async () => [],
+  _resetMemoryV2QdrantForTests: () => {},
+  ensureConceptPageCollection: async () => {},
+  MEMORY_V2_COLLECTION: "memory_v2_concept_pages",
 }));
 
 // ── Workspace setup ────────────────────────────────────────────────
@@ -321,7 +327,7 @@ describe("enqueueEmbedConceptPageJob", () => {
     const id = enqueueEmbedConceptPageJob({ slug: "alice-prefers-vs-code" });
     expect(id).toBeTruthy();
 
-    const claimed = claimMemoryJobs(10);
+    const claimed = claimMemoryJobs({ slowLlm: 10, fast: 10, embed: 10 });
     expect(claimed).toHaveLength(1);
     const [job] = claimed;
     expect(job.type).toBe("embed_concept_page");
@@ -337,7 +343,7 @@ describe("enqueueEmbedConceptPageJob", () => {
 
     enqueueEmbedConceptPageJob({ slug: "round-trip-slug" });
 
-    const claimed = claimMemoryJobs(10);
+    const claimed = claimMemoryJobs({ slowLlm: 10, fast: 10, embed: 10 });
     expect(claimed).toHaveLength(1);
     const [job] = claimed;
     expect(job.type).toBe("embed_concept_page");