@vellumai/assistant 0.6.0 → 0.6.2

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

@@ -43,6 +43,7 @@ export async function searchGraphNodes(
   limit: number,
   scopeIds?: string[],
   sparseVector?: QdrantSparseVector,
+  dateRange?: { afterMs?: number; beforeMs?: number },
 ): Promise<GraphSearchResult[]> {
   if (isQdrantBreakerOpen()) {
     log.warn("Qdrant circuit breaker open, skipping graph search");
@@ -54,13 +55,20 @@ export async function searchGraphNodes(
   // 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" } },
+      ...(scopeIds && scopeIds.length > 0
+        ? [{ key: "memory_scope_id", match: { any: scopeIds } }]
+        : []),
+    ];
+    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: [
-        { key: "target_type", match: { value: "graph_node" } },
-        ...(scopeIds && scopeIds.length > 0
-          ? [{ key: "memory_scope_id", match: { any: scopeIds } }]
-          : []),
-      ],
+      must,
       must_not: [{ key: "_meta", match: { value: true } }],
     };
 
@@ -82,21 +90,27 @@ export async function searchGraphNodes(
   }
 
   // Dense-only fallback
-  const filter: Record<string, unknown> = {
-    must: [
-      {
-        key: "target_type",
-        match: { value: "graph_node" },
-      },
-    ],
-  };
+  const denseMusts: Record<string, unknown>[] = [
+    {
+      key: "target_type",
+      match: { value: "graph_node" },
+    },
+  ];
 
   if (scopeIds && scopeIds.length > 0) {
-    (filter.must as unknown[]).push({
+    denseMusts.push({
       key: "memory_scope_id",
       match: { any: scopeIds },
     });
   }
+  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 };
 
   const results: QdrantSearchResult[] = await withQdrantBreaker(async () => {
     return client.search(queryVector, limit, filter);

package/src/memory/graph/injection.ts

@@ -13,8 +13,7 @@ import { isCapabilityNode } from "./types.js";
 // ---------------------------------------------------------------------------
 
 export const MAX_CONTEXT_LOAD_IMAGES = 3;
-export const MAX_PER_TURN_IMAGES = 1;
-export const MAX_REFRESH_IMAGES = 2;
+export const MAX_PER_TURN_IMAGES = 2;
 
 // ---------------------------------------------------------------------------
 // Types
@@ -30,11 +29,17 @@ export interface ResolvedImage {
 // InContextTracker — tracks which node IDs are visible to the LLM
 // ---------------------------------------------------------------------------
 
-interface InjectionLogEntry {
+export interface InjectionLogEntry {
   nodeId: string;
   turn: number;
 }
 
+export interface InContextTrackerSnapshot {
+  inContext: string[];
+  log: InjectionLogEntry[];
+  currentTurn: number;
+}
+
 /**
  * Tracks which memory graph nodes are currently in the LLM's context.
  * Handles:
@@ -107,6 +112,22 @@ export class InContextTracker {
   getTurn(): number {
     return this.currentTurn;
   }
+
+  /** Serialize tracker state for persistence across eviction. */
+  toJSON(): InContextTrackerSnapshot {
+    return {
+      inContext: [...this.inContext],
+      log: [...this.log],
+      currentTurn: this.currentTurn,
+    };
+  }
+
+  /** Restore tracker state from a persisted snapshot. Replaces current state. */
+  restoreFrom(snapshot: InContextTrackerSnapshot): void {
+    this.inContext = new Set(snapshot.inContext);
+    this.log = [...snapshot.log];
+    this.currentTurn = snapshot.currentTurn;
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -166,9 +187,12 @@ export function formatEventDate(epochMs: number): string {
   const monthName = monthNames[date.getMonth()];
   const dayOfMonth = date.getDate();
 
-  // Include time only when hours/minutes are non-zero (midnight = date-only event)
-  // Use UTC methods: date-only events are stored as midnight UTC, so local timezone
-  // methods would show non-zero hours in west-of-UTC timezones, defeating the check.
+  // Heuristic: date-only events are stored as midnight UTC, so we treat
+  // midnight-UTC epochs as "no time component".  This is lossy — a timed event
+  // genuinely scheduled at 00:00 UTC will have its time display silently dropped.
+  // Fixing this properly requires the event storage layer to carry an explicit
+  // `hasTime` flag; until then this is the best available approximation.
+  // Use UTC methods so west-of-UTC local offsets don't defeat the check.
   const hasTime = date.getUTCHours() !== 0 || date.getUTCMinutes() !== 0;
   let datePart = `${dayName} ${monthName} ${dayOfMonth}`;
   if (hasTime) {
@@ -315,7 +339,10 @@ export function assembleContextBlock(
   if (capabilities.length > 0) {
     const entries = capabilities.slice(0, 5).map((scored) => {
       const content = scored.node.content.replace(/^(?:skill|cli):\S+\n/, "");
-      return `- ${content} → use skill_load to activate`;
+      const suffix = /skill \(/.test(content)
+        ? " → use skill_load to activate"
+        : "";
+      return `- ${content}${suffix}`;
     });
     parts.push(`### Skills You Can Use\n${entries.join("\n")}`);
   }
@@ -371,7 +398,10 @@ export function assembleInjectionBlock(nodes: ScoredNode[]): string {
     .map((scored) => {
       if (isCapabilityNode(scored.node)) {
         const content = scored.node.content.replace(/^(?:skill|cli):\S+\n/, "");
-        return `- [skill] ${content} → use skill_load to activate`;
+        if (/skill \(/.test(content)) {
+          return `- [skill] ${content} → use skill_load to activate`;
+        }
+        return `- ${content}`;
       }
       if (scored.node.eventDate != null) {
         return formatUpcomingEntry(scored);

package/src/memory/graph/inspect.ts

@@ -267,10 +267,19 @@ async function showQuery(query: string) {
     const nodes = getNodesByIds(results.map((r) => r.nodeId));
     const nodeMap = new Map(nodes.map((n) => [n.id, n]));
 
-    console.log(`  Found ${results.length} results:\n`);
-    for (const r of results) {
+    const visible = results.filter((r) => {
       const node = nodeMap.get(r.nodeId);
-      if (!node) continue;
+      return node && node.fidelity !== "gone";
+    });
+
+    if (visible.length === 0) {
+      console.log("  No results found.");
+      return;
+    }
+
+    console.log(`  Found ${visible.length} results:\n`);
+    for (const r of visible) {
+      const node = nodeMap.get(r.nodeId)!;
       const preview =
         node.content.length > 120
           ? node.content.slice(0, 120) + "…"