@vellumai/assistant 0.5.3 → 0.5.4

package/src/daemon/conversation-memory.ts

@@ -1,5 +1,8 @@
 import { getConfig } from "../config/loader.js";
 import { estimatePromptTokens } from "../context/token-estimator.js";
+import { buildArchiveRecall } from "../memory/archive-recall.js";
+import { compileMemoryBrief } from "../memory/brief.js";
+import { getDb } from "../memory/db.js";
 import { buildMemoryQuery } from "../memory/query-builder.js";
 import { computeRecallBudget } from "../memory/retrieval-budget.js";
 import {
@@ -9,8 +12,11 @@ import {
 import type { ScopePolicyOverride } from "../memory/search/types.js";
 import type { Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
+import { getLogger } from "../util/logger.js";
 import type { ServerMessage } from "./message-protocol.js";
 
+const log = getLogger("conversation-memory");
+
 export interface MemoryRecallResult {
   runMessages: Message[];
   recall: Awaited<ReturnType<typeof buildMemoryRecall>>;
@@ -115,6 +121,14 @@ export async function prepareMemoryContext(
 
   const runtimeConfig = getConfig();
 
+  // ── Simplified memory path ──────────────────────────────────────────
+  // When `memory.simplified.enabled` is true, inject the brief and
+  // optional archive recall instead of the legacy hybrid pipeline.
+  if (runtimeConfig.memory?.simplified?.enabled) {
+    return prepareSimplifiedMemoryContext(ctx, content, userMessageId, onEvent);
+  }
+
+  // ── Legacy memory path (fallback) ──────────────────────────────────
   // Memory recall via the V2 hybrid pipeline
   const recallQuery = buildMemoryQuery(content, ctx.messages);
   const dynamicBudgetConfig = runtimeConfig.memory?.retrieval?.dynamicBudget;
@@ -207,3 +221,106 @@ export async function prepareMemoryContext(
     recall,
   };
 }
+
+// ── Simplified memory injection ─────────────────────────────────────────
+
+/**
+ * Build simplified memory context for a turn: compiles the `<memory_brief>`
+ * block and conditionally appends `<supporting_recall>` from the archive.
+ *
+ * Non-empty blocks are injected as text content blocks prepended to the
+ * last user message, following the same injection pattern as the legacy
+ * pipeline. Stripping is handled by `RUNTIME_INJECTION_PREFIXES` which
+ * already includes `<memory_brief>`.
+ */
+function prepareSimplifiedMemoryContext(
+  ctx: MemoryPrepareContext,
+  content: string,
+  userMessageId: string,
+  onEvent: (msg: ServerMessage) => void,
+): MemoryRecallResult {
+  const start = Date.now();
+
+  // Build a no-op recall result matching the legacy shape.
+  const noopRecall = (): Awaited<ReturnType<typeof buildMemoryRecall>> =>
+    ({
+      enabled: true,
+      degraded: false,
+      injectedText: "",
+      semanticHits: 0,
+      recencyHits: 0,
+      mergedCount: 0,
+      selectedCount: 0,
+      injectedTokens: 0,
+      latencyMs: 0,
+      topCandidates: [],
+      tier1Count: 0,
+      tier2Count: 0,
+    }) as Awaited<ReturnType<typeof buildMemoryRecall>>;
+
+  try {
+    const db = getDb();
+
+    // Step 1: Build the memory brief
+    const briefResult = compileMemoryBrief(db, ctx.scopeId, userMessageId);
+
+    // Step 2: Conditionally build supporting recall from the archive
+    const archiveResult = buildArchiveRecall(ctx.scopeId, content);
+
+    // Step 3: Assemble the injection blocks (non-empty only)
+    const blocks: string[] = [];
+    if (briefResult.text.length > 0) {
+      blocks.push(briefResult.text);
+    }
+    if (archiveResult.text.length > 0) {
+      blocks.push(archiveResult.text);
+    }
+
+    const latencyMs = Date.now() - start;
+
+    // Emit memory status for the simplified path
+    onEvent({
+      type: "memory_status",
+      enabled: true,
+      degraded: false,
+    });
+
+    // Inject non-empty blocks into the last user message
+    let runMessages = ctx.messages;
+    if (blocks.length > 0) {
+      const injectedText = blocks.join("\n\n");
+      const userTail = ctx.messages[ctx.messages.length - 1];
+      if (userTail && userTail.role === "user") {
+        runMessages = injectMemoryRecallAsUserBlock(ctx.messages, injectedText);
+      }
+
+      log.debug(
+        {
+          briefLength: briefResult.text.length,
+          recallTrigger: archiveResult.trigger,
+          recallBullets: archiveResult.bullets.length,
+          latencyMs,
+        },
+        "Simplified memory injection completed",
+      );
+    }
+
+    return {
+      runMessages,
+      recall: {
+        ...noopRecall(),
+        injectedText: blocks.length > 0 ? blocks.join("\n\n") : "",
+        latencyMs,
+      },
+    };
+  } catch (err) {
+    log.warn({ err }, "Simplified memory injection failed, returning no-op");
+    return {
+      runMessages: ctx.messages,
+      recall: {
+        ...noopRecall(),
+        latencyMs: Date.now() - start,
+      },
+    };
+  }
+}

package/src/daemon/conversation-runtime-assembly.ts

@@ -962,6 +962,7 @@ const RUNTIME_INJECTION_PREFIXES = [
   "<interface_turn_context>",
   "<turn_context>",
   "<memory_brief>",
+  "<supporting_recall>",
   "<memory_context __injected>",
   "<memory_context>", // backward-compat: strip legacy blocks from pre-__injected history
   "<voice_call_control>",

package/src/daemon/handlers/conversations.ts

@@ -23,6 +23,7 @@ import {
   queueGenerateConversationTitle,
   UNTITLED_FALLBACK,
 } from "../../memory/conversation-title-service.js";
+import { reduceBeforeSwitch } from "../../memory/reducer-scheduler.js";
 import * as pendingInteractions from "../../runtime/pending-interactions.js";
 import { getSubagentManager } from "../../subagent/index.js";
 import { truncate } from "../../util/truncate.js";
@@ -233,6 +234,12 @@ export async function handleConversationCreate(
     conversationType: normalizeConversationType(conversation.conversationType),
   });
 
+  // Reduce the previous dirty conversation before processing the initial
+  // message so its memory is fresh for the next read.
+  if (msg.initialMessage) {
+    await reduceBeforeSwitch(conversation.id);
+  }
+
   // Auto-send the initial message if provided, kick-starting the skill.
   if (msg.initialMessage) {
     // Queue title generation eagerly — some processMessage paths (guardian
@@ -343,6 +350,10 @@ export async function switchConversation(
     return null;
   }
 
+  // Reduce the previous dirty conversation before switching so its memory
+  // is fresh for the next read.
+  await reduceBeforeSwitch(conversationId);
+
   // If the target conversation is headless-locked (actively executing a task run),
   // skip rebinding so tool confirmations stay suppressed.
   const existingConversation = ctx.conversations.get(conversationId);

package/src/daemon/lifecycle.ts

@@ -30,6 +30,7 @@ import {
   getConversationType,
   getMessages,
   purgePrivateConversations,
+  sweepStaleReducerJobs,
 } from "../memory/conversation-crud.js";
 import { resolveConversationId } from "../memory/conversation-key-store.js";
 import { initializeDb } from "../memory/db.js";
@@ -206,16 +207,40 @@ export async function runDaemon(): Promise<void> {
           targetId: summaryId,
         });
       }
+      for (const obsId of deletedMemory.deletedObservationIds) {
+        enqueueMemoryJob("delete_qdrant_vectors", {
+          targetType: "observation",
+          targetId: obsId,
+        });
+      }
+      for (const chunkId of deletedMemory.deletedChunkIds) {
+        enqueueMemoryJob("delete_qdrant_vectors", {
+          targetType: "chunk",
+          targetId: chunkId,
+        });
+      }
+      for (const episodeId of deletedMemory.deletedEpisodeIds) {
+        enqueueMemoryJob("delete_qdrant_vectors", {
+          targetType: "episode",
+          targetId: episodeId,
+        });
+      }
       if (
         deletedMemory.segmentIds.length > 0 ||
         deletedMemory.orphanedItemIds.length > 0 ||
-        deletedMemory.deletedSummaryIds.length > 0
+        deletedMemory.deletedSummaryIds.length > 0 ||
+        deletedMemory.deletedObservationIds.length > 0 ||
+        deletedMemory.deletedChunkIds.length > 0 ||
+        deletedMemory.deletedEpisodeIds.length > 0
       ) {
         log.info(
           {
             segments: deletedMemory.segmentIds.length,
             orphanedItems: deletedMemory.orphanedItemIds.length,
             deletedSummaries: deletedMemory.deletedSummaryIds.length,
+            deletedObservations: deletedMemory.deletedObservationIds.length,
+            deletedChunks: deletedMemory.deletedChunkIds.length,
+            deletedEpisodes: deletedMemory.deletedEpisodeIds.length,
           },
           "Enqueued Qdrant vector cleanup jobs for purged private conversations",
         );
@@ -240,6 +265,24 @@ export async function runDaemon(): Promise<void> {
       );
     }
 
+    // Sweep dirty conversations whose tail messages are already past the
+    // idle delay — they should have been reduced while the daemon was down.
+    // Enqueue immediate reducer jobs so the memory worker picks them up.
+    try {
+      const sweepCount = sweepStaleReducerJobs();
+      if (sweepCount > 0) {
+        log.info(
+          { sweepCount },
+          `Enqueued reducer jobs for ${sweepCount} stale dirty conversation(s)`,
+        );
+      }
+    } catch (err) {
+      log.warn(
+        { err },
+        "Startup sweep for stale reducer jobs failed — continuing startup",
+      );
+    }
+
     // Ensure a vellum guardian binding exists so the identity system works
     // without requiring a manual bootstrap step.
     try {