@vellumai/assistant 0.4.56 → 0.4.57

package/src/memory/retriever.ts

@@ -1,7 +1,8 @@
-import { inArray, sql } from "drizzle-orm";
+import { asc, eq, inArray, sql } from "drizzle-orm";
 
 import type { AssistantConfig } from "../config/types.js";
 import { estimateTextTokens } from "../context/token-estimator.js";
+import type { Message } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
 import {
   abortableSleep,
@@ -24,8 +25,8 @@ import {
 } from "./schema.js";
 import {
   buildTwoLayerInjection,
+  CAPABILITY_KINDS,
   IDENTITY_KINDS,
-  MEMORY_CONTEXT_ACK,
   PREFERENCE_KINDS,
 } from "./search/formatting.js";
 import { recencySearch } from "./search/lexical.js";
@@ -354,6 +355,44 @@ export async function buildMemoryRecall(
     if (c.text.length > existing.text.length) {
       existing.text = c.text;
     }
+    // Propagate metadata that the first source may lack (e.g. legacy
+    // Qdrant points missing conversation_id / message_id). The recency
+    // source always has these from the DB, so merging fills the gap.
+    if (c.conversationId && !existing.conversationId) {
+      existing.conversationId = c.conversationId;
+    }
+    if (c.messageId && !existing.messageId) {
+      existing.messageId = c.messageId;
+    }
+  }
+
+  // ── Step 5b: Filter out current-conversation segments still in context ──
+  // Segments whose source message is still in the conversation's context
+  // window are redundant (already visible to the model). However, segments
+  // from messages that were removed by context compaction should be kept —
+  // those messages are no longer in the conversation history and memory is
+  // the only way they can influence the response.
+  if (conversationId) {
+    const inContextMessageIds = getInContextMessageIds(conversationId);
+    if (inContextMessageIds) {
+      for (const [key, c] of candidateMap) {
+        if (c.type === "segment") {
+          if (c.messageId) {
+            // Segment has a known source message — filter only if that
+            // message is still in the context window.
+            if (inContextMessageIds.has(c.messageId)) {
+              candidateMap.delete(key);
+            }
+          } else if (c.conversationId === conversationId) {
+            // Segment from the current conversation but missing messageId
+            // (e.g. legacy Qdrant points without message_id payload).
+            // We can't determine whether it's compacted, so err on the
+            // side of filtering to avoid token bloat from redundant segments.
+            candidateMap.delete(key);
+          }
+        }
+      }
+    }
   }
 
   // Compute RRF-style final scores for the merged candidates
@@ -427,11 +466,15 @@ export async function buildMemoryRecall(
   const preferences = afterDemotion.filter(
     (c) => c.tier === 1 && PREFERENCE_KINDS.has(c.kind),
   );
+  const capabilities = afterDemotion.filter(
+    (c) => c.tier === 1 && CAPABILITY_KINDS.has(c.kind),
+  );
   const tier1Candidates = afterDemotion.filter(
     (c) =>
       c.tier === 1 &&
       !IDENTITY_KINDS.has(c.kind) &&
-      !PREFERENCE_KINDS.has(c.kind),
+      !PREFERENCE_KINDS.has(c.kind) &&
+      !CAPABILITY_KINDS.has(c.kind),
   );
   const tier2Candidates = afterDemotion.filter((c) => c.tier === 2);
 
@@ -440,6 +483,7 @@ export async function buildMemoryRecall(
     tier1Candidates,
     tier2Candidates,
     preferences,
+    capabilities,
     totalBudgetTokens: maxInjectTokens,
   });
 
@@ -448,7 +492,8 @@ export async function buildMemoryRecall(
     identityItems.length +
     tier1Candidates.length +
     tier2Candidates.length +
-    preferences.length;
+    preferences.length +
+    capabilities.length;
 
   const tier1Count = afterDemotion.filter((c) => c.tier === 1).length;
   const tier2Count = afterDemotion.filter((c) => c.tier === 2).length;
@@ -528,6 +573,52 @@ export async function buildMemoryRecall(
   return result;
 }
 
+/**
+ * Get the set of message IDs that are still in the conversation's context
+ * window (i.e., not compacted away). Uses `contextCompactedMessageCount` to
+ * determine the offset: messages ordered by createdAt after that count are
+ * still visible to the model.
+ *
+ * Returns `null` if the conversation is not found (deleted, or no DB row).
+ */
+function getInContextMessageIds(conversationId: string): Set<string> | null {
+  try {
+    const db = getDb();
+
+    // Look up the conversation's compacted message count
+    const conv = db
+      .select({
+        contextCompactedMessageCount:
+          conversations.contextCompactedMessageCount,
+      })
+      .from(conversations)
+      .where(eq(conversations.id, conversationId))
+      .get();
+
+    if (!conv) return null;
+
+    const offset = conv.contextCompactedMessageCount;
+
+    // Fetch message IDs ordered by creation time, skipping compacted ones
+    const rows = db
+      .select({ id: messages.id })
+      .from(messages)
+      .where(eq(messages.conversationId, conversationId))
+      .orderBy(asc(messages.createdAt))
+      .all();
+
+    // Messages up to `offset` have been compacted out of context
+    const inContextRows = rows.slice(offset);
+    return new Set(inContextRows.map((r) => r.id));
+  } catch (err) {
+    log.warn(
+      { err },
+      "Failed to fetch in-context message IDs; skipping segment filter",
+    );
+    return null;
+  }
+}
+
 /**
  * Enrich item candidates with metadata needed for staleness computation:
  * - firstSeenAt: when the item was first extracted
@@ -671,146 +762,32 @@ function enrichSourceLabels(candidates: TieredCandidate[]): void {
 }
 
 /**
- * Strip memory recall messages from the conversation history.
+ * Inject memory recall as a text content block prepended to the last user
+ * message. This follows the same pattern as workspace, temporal, and other
+ * runtime injections — the memory context is a text block in the user
+ * message rather than a separate synthetic message pair.
  *
- * Handles both exact text matching and `<memory_context>` XML wrapper
- * detection: when the recall text starts with `<memory_context>`, we
- * also match user messages whose sole text block starts with the same
- * tag (covering cases where the exact text differs slightly due to
- * dynamic content).
+ * Stripping is handled by `stripUserTextBlocksByPrefix` matching the
+ * `<memory_context __injected>` prefix in `RUNTIME_INJECTION_PREFIXES`, so no
+ * dedicated strip function is needed.
  */
-export function stripMemoryRecallMessages<
-  T extends {
-    role: "user" | "assistant";
-    content: Array<{ type: string; text?: string }>;
-  },
->(
-  messages: T[],
-  memoryRecallText?: string,
-  injectionStrategy?: "prepend_user_block" | "separate_context_message",
-): T[] {
-  const recallText = memoryRecallText ?? "";
-  if (recallText.trim().length === 0) return messages;
-
-  const isAck = (msg: T) =>
-    msg.role === "assistant" &&
-    msg.content.length === 1 &&
-    msg.content[0].type === "text" &&
-    msg.content[0].text === MEMORY_CONTEXT_ACK;
-
-  // Check if the recall text uses the <memory_context> XML format
-  const isMemoryContextFormat = recallText
-    .trimStart()
-    .startsWith("<memory_context>");
-
-  // Helper: does a text block match the recall text?
-  const textMatches = (text: string | undefined): boolean => {
-    if (!text) return false;
-    if (text === recallText) return true;
-    // For <memory_context> format, match any block that starts with the tag
-    if (
-      isMemoryContextFormat &&
-      text.trimStart().startsWith("<memory_context>")
-    ) {
-      return true;
-    }
-    return false;
-  };
-
-  // Prefer the canonical separate_context_message pair: a user message whose
-  // sole text block is the recall text, followed by an assistant ack. This
-  // must be checked first so that a real user message that happens to contain
-  // the same text is not incorrectly removed instead of the synthetic one.
-  if (injectionStrategy !== "prepend_user_block") {
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const msg = messages[i];
-      if (msg.role !== "user") continue;
-      if (msg.content.length !== 1) continue;
-      const block = msg.content[0];
-      if (block.type !== "text" || !textMatches(block.text)) continue;
-      const next = messages[i + 1];
-      if (next && isAck(next)) {
-        return [...messages.slice(0, i), ...messages.slice(i + 2)];
-      }
-    }
-  }
-
-  // Fall back to generic text-match removal: find the last user message
-  // containing the recall text block.
-  let targetIndex = -1;
-  let blockIndex = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.role !== "user" || msg.content.length === 0) continue;
-    for (let bi = msg.content.length - 1; bi >= 0; bi--) {
-      const block = msg.content[bi];
-      if (block.type === "text" && textMatches(block.text)) {
-        targetIndex = i;
-        blockIndex = bi;
-        break;
-      }
-    }
-    if (targetIndex !== -1) break;
-  }
-  if (targetIndex === -1) return messages;
-
-  // Strip the adjacent assistant ack when the injection strategy used a
-  // separate context message (or is unknown). This mirrors the canonical
-  // pair removal above but covers repair-merged cases where the user
-  // message has multiple content blocks.
-  const ackIndex =
-    injectionStrategy !== "prepend_user_block" &&
-    targetIndex + 1 < messages.length &&
-    isAck(messages[targetIndex + 1])
-      ? targetIndex + 1
-      : -1;
-
-  const cleaned: T[] = [];
-  for (let i = 0; i < messages.length; i++) {
-    if (i === ackIndex) continue;
-    if (i !== targetIndex) {
-      cleaned.push(messages[i]);
-      continue;
-    }
-    const filteredContent = [
-      ...messages[i].content.slice(0, blockIndex),
-      ...messages[i].content.slice(blockIndex + 1),
-    ];
-    if (filteredContent.length === 0) continue;
-    cleaned.push({ ...messages[i], content: filteredContent } as T);
-  }
-  return cleaned;
-}
-
-/**
- * Inject memory recall as a separate user+assistant message pair before the
- * last user message. This separates memory context from the user's actual
- * query, making it clearer to the model that the memory is background context.
- */
-export function injectMemoryRecallAsSeparateMessage<
-  T extends {
-    role: "user" | "assistant";
-    content: Array<{ type: string; text?: string }>;
-  },
->(messages: T[], memoryRecallText: string): T[] {
+export function injectMemoryRecallAsUserBlock(
+  messages: Message[],
+  memoryRecallText: string,
+): Message[] {
   if (memoryRecallText.trim().length === 0) return messages;
   if (messages.length === 0) return messages;
-  // These synthetic messages satisfy the structural constraint T extends { role; content }
-  // but may lack extra fields present on T. In practice T is always Message which has
-  // only role and content, so the cast is safe.
-  const contextMessage = {
-    role: "user" as const,
-    content: [{ type: "text" as const, text: memoryRecallText }],
-  } as T;
-  const ackMessage = {
-    role: "assistant" as const,
-    content: [{ type: "text" as const, text: MEMORY_CONTEXT_ACK }],
-  } as T;
+  const userTail = messages[messages.length - 1];
+  if (!userTail || userTail.role !== "user") return messages;
   return [
     ...messages.slice(0, -1),
-    contextMessage,
-    ackMessage,
-    messages[messages.length - 1],
+    {
+      ...userTail,
+      content: [
+        { type: "text" as const, text: memoryRecallText },
+        ...userTail.content,
+      ],
+    },
   ];
 }
 

package/src/memory/schema/calls.ts

@@ -95,7 +95,7 @@ export const channelVerificationSessions = sqliteTable(
     challengeHash: text("challenge_hash").notNull(),
     expiresAt: integer("expires_at").notNull(),
     status: text("status").notNull().default("pending"),
-    createdByConversationId: text("created_by_session_id"),
+    sourceConversationId: text("source_conversation_id"),
     consumedByExternalUserId: text("consumed_by_external_user_id"),
     consumedByChatId: text("consumed_by_chat_id"),
     // Outbound session: expected-identity binding

package/src/memory/schema/contacts.ts

@@ -69,7 +69,7 @@ export const assistantIngressInvites = sqliteTable(
     id: text("id").primaryKey(),
     sourceChannel: text("source_channel").notNull(),
     tokenHash: text("token_hash").notNull(),
-    createdByConversationId: text("created_by_session_id"),
+    sourceConversationId: text("source_conversation_id"),
     note: text("note"),
     maxUses: integer("max_uses").notNull().default(1),
     useCount: integer("use_count").notNull().default(0),

package/src/memory/schema/infrastructure.ts

@@ -138,6 +138,12 @@ export const llmUsageEvents = sqliteTable(
   ],
 );
 
+export const lifecycleEvents = sqliteTable("lifecycle_events", {
+  id: text("id").primaryKey(),
+  eventName: text("event_name").notNull(), // 'app_open' | 'hatch'
+  createdAt: integer("created_at").notNull(),
+});
+
 export const actorTokenRecords = sqliteTable("actor_token_records", {
   id: text("id").primaryKey(),
   tokenHash: text("token_hash").notNull(),
@@ -151,6 +157,29 @@ export const actorTokenRecords = sqliteTable("actor_token_records", {
   updatedAt: integer("updated_at").notNull(),
 });
 
+export const traceEvents = sqliteTable(
+  "trace_events",
+  {
+    eventId: text("event_id").primaryKey(),
+    conversationId: text("conversation_id").notNull(),
+    requestId: text("request_id"),
+    timestampMs: integer("timestamp_ms").notNull(),
+    sequence: integer("sequence").notNull(),
+    kind: text("kind").notNull(),
+    status: text("status"),
+    summary: text("summary").notNull(),
+    attributesJson: text("attributes_json"), // JSON-serialized attributes
+    createdAt: integer("created_at").notNull(),
+  },
+  (table) => [
+    index("idx_trace_events_conversation_id").on(table.conversationId),
+    index("idx_trace_events_conversation_timestamp").on(
+      table.conversationId,
+      table.timestampMs,
+    ),
+  ],
+);
+
 export const actorRefreshTokenRecords = sqliteTable(
   "actor_refresh_token_records",
   {

package/src/memory/schema/memory-core.ts

@@ -2,7 +2,6 @@ import {
   blob,
   index,
   integer,
-  primaryKey,
   real,
   sqliteTable,
   text,
@@ -150,8 +149,8 @@ export const memoryCheckpoints = sqliteTable("memory_checkpoints", {
   updatedAt: integer("updated_at").notNull(),
 });
 
-export const threadStarters = sqliteTable(
-  "thread_starters",
+export const conversationStarters = sqliteTable(
+  "conversation_starters",
   {
     id: text("id").primaryKey(),
     label: text("label").notNull(),
@@ -167,22 +166,13 @@ export const threadStarters = sqliteTable(
     createdAt: integer("created_at").notNull(),
   },
   (table) => [
-    index("idx_thread_starters_batch").on(
+    index("idx_conversation_starters_batch").on(
       table.generationBatch,
       table.createdAt,
     ),
-    index("idx_thread_starters_card_type").on(table.cardType, table.scopeId),
+    index("idx_conversation_starters_card_type").on(
+      table.cardType,
+      table.scopeId,
+    ),
   ],
 );
-
-export const capabilityCardCategories = sqliteTable(
-  "capability_card_categories",
-  {
-    scopeId: text("scope_id").notNull(),
-    category: text("category").notNull(),
-    relevance: real("relevance").notNull(),
-    generationBatch: integer("generation_batch").notNull(),
-    createdAt: integer("created_at").notNull(),
-  },
-  (table) => [primaryKey({ columns: [table.scopeId, table.category] })],
-);

package/src/memory/schema/notifications.ts

@@ -13,7 +13,7 @@ export const notificationEvents = sqliteTable("notification_events", {
   id: text("id").primaryKey(),
   sourceEventName: text("source_event_name").notNull(),
   sourceChannel: text("source_channel").notNull(),
-  sourceSessionId: text("source_session_id").notNull(),
+  sourceContextId: text("source_context_id").notNull(),
   attentionHintsJson: text("attention_hints_json").notNull().default("{}"),
   payloadJson: text("payload_json").notNull().default("{}"),
   dedupeKey: text("dedupe_key"),

package/src/memory/search/formatting.ts

@@ -1,9 +1,6 @@
 import { estimateTextTokens } from "../../context/token-estimator.js";
 import type { TieredCandidate } from "./tier-classifier.js";
 
-/** Marker text used in the assistant acknowledgment of a separate context message. */
-export const MEMORY_CONTEXT_ACK = "[Memory context loaded.]";
-
 /**
  * Escape XML-like tag sequences in recalled text to prevent delimiter injection.
  * Recalled content is interpolated verbatim inside `<memory>` wrapper tags,
@@ -80,6 +77,9 @@ export const IDENTITY_KINDS = new Set(["identity"]);
 /** Kinds classified as preferences for the <applicable_preferences> section. */
 export const PREFERENCE_KINDS = new Set(["preference", "constraint"]);
 
+/** Kinds classified as capabilities for the <available_capabilities> section. */
+export const CAPABILITY_KINDS = new Set(["capability"]);
+
 /** Per-item token budget for tier 1 items. */
 const TIER1_PER_ITEM_TOKENS = 150;
 
@@ -105,6 +105,7 @@ export function buildTwoLayerInjection(params: {
   tier1Candidates: TieredCandidate[];
   tier2Candidates: TieredCandidate[];
   preferences: TieredCandidate[];
+  capabilities: TieredCandidate[];
   totalBudgetTokens?: number;
 }): string {
   const {
@@ -112,6 +113,7 @@ export function buildTwoLayerInjection(params: {
     tier1Candidates,
     tier2Candidates,
     preferences,
+    capabilities,
     totalBudgetTokens,
   } = params;
 
@@ -120,7 +122,8 @@ export function buildTwoLayerInjection(params: {
     identityItems.length === 0 &&
     tier1Candidates.length === 0 &&
     tier2Candidates.length === 0 &&
-    preferences.length === 0
+    preferences.length === 0 &&
+    capabilities.length === 0
   ) {
     return "";
   }
@@ -129,7 +132,7 @@ export function buildTwoLayerInjection(params: {
   // Reserve tokens for XML wrapper overhead (<memory_context>, section tags,
   // newlines between sections) so the final assembled text stays within budget.
   const WRAPPER_OVERHEAD_TOKENS = estimateTextTokens(
-    "<memory_context>\n\n\n\n</memory_context>",
+    "<memory_context __injected>\n\n\n\n</memory_context>",
   );
   const SECTION_TAG_TOKENS = estimateTextTokens(
     "<possibly_relevant>\n\n</possibly_relevant>",
@@ -139,6 +142,7 @@ export function buildTwoLayerInjection(params: {
     tier1Candidates.length,
     tier2Candidates.length,
     preferences.length,
+    capabilities.length,
   ].filter((n) => n > 0).length;
   const structuralOverhead =
     WRAPPER_OVERHEAD_TOKENS + sectionCount * SECTION_TAG_TOKENS;
@@ -168,6 +172,13 @@ export function buildTwoLayerInjection(params: {
   );
   remainingTokens -= estimateTextTokens(preferenceLines.join("\n"));
 
+  const capabilityLines = renderPlainStatements(
+    capabilities,
+    TIER1_PER_ITEM_TOKENS,
+    remainingTokens,
+  );
+  remainingTokens -= estimateTextTokens(capabilityLines.join("\n"));
+
   // Tier 2 uses remaining budget
   const possiblyRelevantEpisodes = renderEpisodesWithStaleness(
     tier2Candidates,
@@ -196,6 +207,12 @@ export function buildTwoLayerInjection(params: {
     );
   }
 
+  if (capabilityLines.length > 0) {
+    sections.push(
+      `<available_capabilities>\n${capabilityLines.join("\n")}\n</available_capabilities>`,
+    );
+  }
+
   if (possiblyRelevantEpisodes.length > 0) {
     sections.push(
       `<possibly_relevant>\n${possiblyRelevantEpisodes.join("\n")}\n</possibly_relevant>`,
@@ -204,7 +221,7 @@ export function buildTwoLayerInjection(params: {
 
   if (sections.length === 0) return "";
 
-  return `<memory_context>\n\n${sections.join("\n\n")}\n\n</memory_context>`;
+  return `<memory_context __injected>\n\n${sections.join("\n\n")}\n\n</memory_context>`;
 }
 
 /**

package/src/memory/search/lexical.ts

@@ -36,6 +36,8 @@ export function recencySearch(
     source: "recency",
     text: row.text,
     kind: "segment",
+    conversationId: row.conversationId,
+    messageId: row.messageId,
     confidence: 0.55,
     importance: 0.5,
     createdAt: row.createdAt,

package/src/memory/search/semantic.ts

@@ -245,6 +245,8 @@ export async function semanticSearch(
         source: "semantic",
         text: payload.text,
         kind: "segment",
+        conversationId: payload.conversation_id,
+        messageId: payload.message_id,
         confidence: 0.55,
         importance: 0.5,
         createdAt,

package/src/memory/search/staleness.ts

@@ -8,6 +8,7 @@ const BASE_LIFETIME_MS: Record<string, number> = {
   project: 14 * 86_400_000, // 2 weeks
   decision: 14 * 86_400_000, // 2 weeks
   event: 3 * 86_400_000, // 3 days
+  capability: Infinity,
 };
 
 const DEFAULT_LIFETIME_MS = 30 * 86_400_000;

package/src/memory/search/types.ts

@@ -11,6 +11,10 @@ export interface Candidate {
   text: string;
   kind: string;
   modality?: "text" | "image" | "audio" | "video";
+  /** The conversation this candidate originated from (segments only). */
+  conversationId?: string;
+  /** The source message ID this candidate was extracted from (segments only). */
+  messageId?: string;
   confidence: number;
   importance: number;
   createdAt: number;