@vellumai/assistant 0.8.4 → 0.8.6

package/src/daemon/conversation-lifecycle.ts

@@ -16,7 +16,7 @@ import {
   getMessages,
   type MessageRow,
 } from "../memory/conversation-crud.js";
-import { enqueueMemoryJob } from "../memory/jobs-store.js";
+import { enqueueMemoryJob, isMemoryEnabled } from "../memory/jobs-store.js";
 import { enqueueMemoryRetrospectiveIfEnabled } from "../memory/memory-retrospective-enqueue.js";
 import { shouldExposePersonalMemory } from "../memory/v2/static-context.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
@@ -189,17 +189,18 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
     ctx.contextCompactedAt = conv?.contextCompactedAt ?? null;
   }
 
-  // `/clean` persists a timestamp; messages older than this should skip
-  // metadata rehydration and have any injection prefixes still embedded in
-  // their content stripped, so the cleaned state survives reload and forks.
-  const cleanedAt = conv?.cleanedAt ?? null;
+  // Every injection-strip event (`/clean` or compaction) updates
+  // `historyStrippedAt`. Messages older than this should skip metadata
+  // rehydration and have any injection prefixes still embedded in their
+  // content stripped, so the post-strip view survives reload and forks.
+  const historyStrippedAt = conv?.historyStrippedAt ?? null;
   const slicedDbMessages = dbMessages.slice(ctx.contextCompactedMessageCount);
-  let preCleanCount = 0;
-  if (cleanedAt != null) {
+  let preStrippedCount = 0;
+  if (historyStrippedAt != null) {
     const boundary = slicedDbMessages.findIndex(
-      (m) => m.createdAt >= cleanedAt,
+      (m) => m.createdAt >= historyStrippedAt,
     );
-    preCleanCount = boundary === -1 ? slicedDbMessages.length : boundary;
+    preStrippedCount = boundary === -1 ? slicedDbMessages.length : boundary;
   }
 
   // Mirror the injection-time gate (`shouldExposePersonalMemory` in
@@ -213,7 +214,7 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
     isTrustedActor: resolveTrustClass(ctx.trustContext) === "guardian",
   });
   const parsedMessages: Message[] = slicedDbMessages.map((m, index, arr) => {
-    const isPreClean = index < preCleanCount;
+    const isPreStripped = index < preStrippedCount;
     const role = m.role as "user" | "assistant";
     let content: ContentBlock[];
     try {
@@ -233,7 +234,7 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
 
     // Re-inject persisted injection blocks from metadata so it survives
     // conversation reloads (eviction, restart, fork).
-    if (role === "user" && m.metadata && !isPreClean) {
+    if (role === "user" && m.metadata && !isPreStripped) {
       try {
         const meta = JSON.parse(m.metadata);
         const isTail = index === arr.length - 1;
@@ -244,9 +245,12 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
         // (pkb-context 30, pkb-reminder 35, memory-v2-static 38,
         // now-md 40 — the v2 static block lands inside the memory
         // prefix, so now-md splices *after* it):
-        //   [<workspace>, <turn_context>, <memory __injected>,
-        //    <memory>\n…</memory>, <NOW.md>, <system_reminder>,
+        //   [<workspace>, <turn_context>, <memory>dynamic</memory>,
+        //    <info>v2static</info>, <NOW.md>, <system_reminder>,
         //    <knowledge_base>, ...original]
+        // The v2 static block is replayed verbatim from stored metadata,
+        // so rows may carry either `<info>…</info>` or `<memory>…</memory>`
+        // depending on when they were persisted.
         // Required so Anthropic's prefix cache keeps matching msg[0]
         // across daemon restart and conversation eviction. The tail
         // row only rehydrates `memoryInjectedBlock` — the next turn
@@ -273,11 +277,12 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
         }
 
         // The v2 static memory block (essentials/threads/recent/buffer
-        // wrapped in `<memory>…</memory>`) carries personal user memory.
-        // Trust-gated to mirror `shouldExposePersonalMemory` at injection
-        // time — untrusted-actor views must not read persisted personal
-        // memory back through metadata. Skipped on the tail row because
-        // the next turn re-injects fresh content on full-mode turns.
+        // wrapped in either `<info>…</info>` or `<memory>…</memory>`)
+        // carries personal user memory. Trust-gated to mirror
+        // `shouldExposePersonalMemory` at injection time — untrusted-actor
+        // views must not read persisted personal memory back through
+        // metadata. Skipped on the tail row because the next turn
+        // re-injects fresh content on full-mode turns.
         if (
           !isTail &&
           personalMemoryAllowed &&
@@ -336,13 +341,13 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
   // Strip pre-clean messages only; post-clean messages keep the fresh
   // injections they were generated with.
   const messagesBeforeRepair =
-    preCleanCount === 0
+    preStrippedCount === 0
       ? parsedMessages
       : [
           ...stripInjectionsForCompaction(
-            parsedMessages.slice(0, preCleanCount),
+            parsedMessages.slice(0, preStrippedCount),
           ),
-          ...parsedMessages.slice(preCleanCount),
+          ...parsedMessages.slice(preStrippedCount),
         ];
 
   const { messages: repairedMessages, stats } =
@@ -448,7 +453,7 @@ export function disposeConversation(ctx: DisposeContext): void {
       } catch {
         // Best-effort — fall through to legacy v1 enqueue
       }
-      if (!v2Enabled) {
+      if (!v2Enabled && isMemoryEnabled()) {
         try {
           enqueueMemoryJob("graph_extract", {
             conversationId: ctx.conversationId,

package/src/daemon/conversation-messaging.ts

@@ -26,6 +26,7 @@ import {
 } from "../memory/attachments-store.js";
 import {
   addMessage,
+  extractImageSourcePaths,
   getConversation,
   provenanceFromTrustContext,
   setConversationOriginChannelIfUnset,
@@ -284,22 +285,44 @@ export function buildSlackMetaForPersistence(params: {
   return writeSlackMetadata(slackMeta);
 }
 
+// ── EnqueueMessageOptions ────────────────────────────────────────────
+
+/** Options for `enqueueMessage`. Only `content` is required; everything
+ *  else has a sensible default or is genuinely optional. */
+export interface EnqueueMessageOptions {
+  content: string;
+  attachments?: UserMessageAttachment[];
+  onEvent?: (msg: ServerMessage) => void;
+  requestId?: string;
+  activeSurfaceId?: string;
+  currentPage?: string;
+  metadata?: Record<string, unknown>;
+  isInteractive?: boolean;
+  displayContent?: string;
+  transport?: ConversationTransportMetadata;
+  clientMessageId?: string;
+}
+
 // ── enqueueMessage ───────────────────────────────────────────────────
 
 export function enqueueMessage(
   ctx: MessagingConversationContext,
-  content: string,
-  attachments: UserMessageAttachment[],
-  onEvent: (msg: ServerMessage) => void,
-  requestId: string,
-  activeSurfaceId?: string,
-  currentPage?: string,
-  metadata?: Record<string, unknown>,
-  options?: { isInteractive?: boolean },
-  displayContent?: string,
-  transport?: ConversationTransportMetadata,
-  clientMessageId?: string,
+  options: EnqueueMessageOptions,
 ): { queued: boolean; requestId: string; rejected?: boolean } {
+  const {
+    content,
+    attachments = [],
+    onEvent,
+    requestId = crypto.randomUUID(),
+    activeSurfaceId,
+    currentPage,
+    metadata,
+    isInteractive,
+    displayContent,
+    transport,
+    clientMessageId,
+  } = options;
+
   if (!ctx.processing) {
     return { queued: false, requestId };
   }
@@ -316,20 +339,20 @@ export function enqueueMessage(
     content,
     attachments,
     requestId,
-    onEvent,
+    onEvent: onEvent ?? (() => {}),
     activeSurfaceId,
     currentPage,
     metadata,
     turnChannelContext,
     turnInterfaceContext,
-    isInteractive: options?.isInteractive,
+    isInteractive,
     transport,
     displayContent,
     sentAt: Date.now(),
     clientMessageId,
   });
   if (!accepted) {
-    onEvent({
+    onEvent?.({
       type: "error",
       conversationId: ctx.conversationId,
       message:
@@ -341,16 +364,26 @@ export function enqueueMessage(
   return { queued: true, requestId };
 }
 
+// ── PersistMessageOptions ────────────────────────────────────────────
+
+/** Shared options for `persistUserMessage` and `persistQueuedMessageBody`. */
+export interface PersistMessageOptions {
+  content: string;
+  attachments?: UserMessageAttachment[];
+  requestId?: string;
+  metadata?: Record<string, unknown>;
+  displayContent?: string;
+  clientMessageId?: string;
+}
+
 // ── persistUserMessage ───────────────────────────────────────────────
 
 export async function persistUserMessage(
   ctx: MessagingConversationContext,
-  content: string,
-  attachments: UserMessageAttachment[],
-  requestId?: string,
-  metadata?: Record<string, unknown>,
-  displayContent?: string,
-): Promise<string> {
+  options: PersistMessageOptions,
+): Promise<{ id: string; deduplicated: boolean }> {
+  const { content, attachments = [] } = options;
+
   if (ctx.processing) {
     throw new Error("Conversation is already processing a message");
   }
@@ -359,20 +392,23 @@ export async function persistUserMessage(
     throw new Error("Message content or attachments are required");
   }
 
-  const reqId = requestId ?? uuid();
+  const reqId = options.requestId ?? uuid();
   ctx.currentRequestId = reqId;
   ctx.processing = true;
   ctx.abortController = new AbortController();
 
   try {
-    return await persistQueuedMessageBody(
-      ctx,
-      content,
+    const result = await persistQueuedMessageBody(ctx, {
+      ...options,
       attachments,
-      reqId,
-      metadata,
-      displayContent,
-    );
+      requestId: reqId,
+    });
+    if (result.deduplicated) {
+      ctx.processing = false;
+      ctx.abortController = null;
+      ctx.currentRequestId = undefined;
+    }
+    return result;
   } catch (err) {
     ctx.processing = false;
     ctx.abortController = null;
@@ -394,12 +430,16 @@ export async function persistUserMessage(
  */
 export async function persistQueuedMessageBody(
   ctx: MessagingConversationContext,
-  content: string,
-  attachments: UserMessageAttachment[],
-  requestId: string,
-  metadata: Record<string, unknown> | undefined,
-  displayContent: string | undefined,
-): Promise<string> {
+  options: PersistMessageOptions,
+): Promise<{ id: string; deduplicated: boolean }> {
+  const {
+    content,
+    attachments = [],
+    requestId = uuid(),
+    metadata,
+    displayContent,
+    clientMessageId,
+  } = options;
   const attachmentInputs = attachments.map((attachment) => ({
     id: attachment.id,
     filename: attachment.filename,
@@ -431,13 +471,7 @@ export async function persistQueuedMessageBody(
     const turnIfCtx =
       extractTurnInterfaceContext(metadata) ?? ctx.getTurnInterfaceContext();
     const provenance = provenanceFromTrustContext(ctx.trustContext);
-    const imageSourcePaths: Record<string, string> = {};
-    for (let i = 0; i < attachments.length; i++) {
-      const a = attachments[i];
-      if (a.filePath && a.mimeType.toLowerCase().startsWith("image/")) {
-        imageSourcePaths[`${i}:${a.filename}`] = a.filePath;
-      }
-    }
+    const imageSourcePaths = extractImageSourcePaths(attachments);
 
     // Strip the transient `slackInbound` carrier key from the persisted
     // metadata — it's an in-memory plumbing field, not a stored column value.
@@ -468,7 +502,7 @@ export async function persistQueuedMessageBody(
             assistantMessageInterface: turnIfCtx.assistantMessageInterface,
           }
         : {}),
-      ...(Object.keys(imageSourcePaths).length > 0 ? { imageSourcePaths } : {}),
+      ...(imageSourcePaths ? { imageSourcePaths } : {}),
       ...(slackMeta ? { slackMeta } : {}),
     };
 
@@ -486,8 +520,15 @@ export async function persistQueuedMessageBody(
       "user",
       contentToPersist,
       mergedMetadata,
+      undefined,
+      clientMessageId,
     );
 
+    if (persistedUserMessage.deduplicated) {
+      ctx.messages.pop();
+      return { id: persistedUserMessage.id, deduplicated: true };
+    }
+
     if (turnCtx) {
       setConversationOriginChannelIfUnset(
         ctx.conversationId,
@@ -569,7 +610,7 @@ export async function persistQueuedMessageBody(
       );
     }
 
-    return persistedUserMessage.id;
+    return { id: persistedUserMessage.id, deduplicated: false };
   } catch (err) {
     ctx.messages.pop();
     throw err;

package/src/daemon/conversation-process.ts

@@ -34,6 +34,7 @@ import { routeGuardianReply } from "../runtime/guardian-reply-router.js";
 import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../util/logger.js";
 import type { CleanResult } from "./conversation.js";
+import type { PersistMessageOptions } from "./conversation-messaging.js";
 import {
   persistQueuedMessageBody,
   serializePersistedUserMessageContent,
@@ -158,12 +159,8 @@ export interface ProcessConversationContext {
   currentTurnChannelCapabilities?: ChannelCapabilities;
   ensureActorScopedHistory(): Promise<void>;
   persistUserMessage(
-    content: string,
-    attachments: UserMessageAttachment[],
-    requestId?: string,
-    metadata?: Record<string, unknown>,
-    displayContent?: string,
-  ): Promise<string>;
+    options: PersistMessageOptions,
+  ): Promise<{ id: string; deduplicated: boolean }>;
   runAgentLoop(
     content: string,
     userMessageId: string,
@@ -921,15 +918,16 @@ async function drainSingleMessage(
   // succeeds, runAgentLoop is called and its finally block will drain
   // the next message. If persistUserMessage fails, processMessage
   // resolves early (no runAgentLoop call), so we must continue draining.
-  let userMessageId: string;
+  let persistResult: { id: string; deduplicated: boolean };
   try {
-    userMessageId = await conversation.persistUserMessage(
-      resolvedContent,
-      next.attachments,
-      next.requestId,
-      { ...next.metadata, sentAt: next.sentAt },
-      next.displayContent,
-    );
+    persistResult = await conversation.persistUserMessage({
+      content: resolvedContent,
+      attachments: next.attachments,
+      requestId: next.requestId,
+      metadata: { ...next.metadata, sentAt: next.sentAt },
+      displayContent: next.displayContent,
+      clientMessageId: next.clientMessageId,
+    });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     log.error(
@@ -961,6 +959,18 @@ async function drainSingleMessage(
     return;
   }
 
+  const userMessageId = persistResult.id;
+
+  if (persistResult.deduplicated) {
+    log.info(
+      { conversationId: conversation.conversationId, userMessageId },
+      "Skipping agent loop for deduplicated queued message",
+    );
+    conversation.preactivatedSkillIds = undefined;
+    await drainQueue(conversation);
+    return;
+  }
+
   // Broadcast the user message to all hub subscribers so passive devices
   // see the user turn before the assistant reply starts streaming.
   next.onEvent({
@@ -1217,24 +1227,43 @@ async function drainBatch(
     const qmContent = qmSlash.content;
 
     try {
+      let batchPersistResult: { id: string; deduplicated: boolean };
+      const persistOptions = {
+        content: qmContent,
+        attachments: qm.attachments,
+        requestId: qm.requestId,
+        metadata: { ...qm.metadata, sentAt: qm.sentAt },
+        displayContent: qm.displayContent,
+        clientMessageId: qm.clientMessageId,
+      };
       if (i === 0) {
-        lastUserMessageId = await conversation.persistUserMessage(
-          qmContent,
-          qm.attachments,
-          qm.requestId,
-          { ...qm.metadata, sentAt: qm.sentAt },
-          qm.displayContent,
-        );
+        batchPersistResult =
+          await conversation.persistUserMessage(persistOptions);
       } else {
-        lastUserMessageId = await persistQueuedMessageBody(
+        batchPersistResult = await persistQueuedMessageBody(
           conversation,
-          qmContent,
-          qm.attachments,
-          qm.requestId,
-          { ...qm.metadata, sentAt: qm.sentAt },
-          qm.displayContent,
+          persistOptions,
         );
       }
+      if (batchPersistResult.deduplicated) {
+        if (i === 0) {
+          // Head was deduplicated — persistUserMessage cleared the
+          // processing flag. Recursively drain remaining items so the
+          // first non-duplicate becomes the new batch head and sets
+          // processing via persistUserMessage.
+          const remaining = batch.slice(1);
+          if (remaining.length >= 2) {
+            await drainBatch(conversation, remaining, reason);
+          } else if (remaining.length === 1) {
+            await drainSingleMessage(conversation, remaining[0], reason);
+          } else {
+            await drainQueue(conversation);
+          }
+          return;
+        }
+        continue;
+      }
+      lastUserMessageId = batchPersistResult.id;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       log.error(
@@ -1377,12 +1406,19 @@ async function drainBatch(
   conversation.currentActiveSurfaceId = lastSuccessfulActiveSurfaceId;
   conversation.currentPage = lastSuccessfulCurrentPage;
 
-  // Broadcast agent-loop events only to members whose persist succeeded.
-  // Members whose persist failed already received an error event in the
-  // catch block above; sending them the assistant's streaming response
-  // would surface a reply for a user message that isn't in their DB.
+  // Broadcast agent-loop events only to unique sinks whose persist succeeded.
+  // Multiple web-queued messages share the same broadcastMessage callback; if
+  // we call it once per queued message, every text delta is published N times
+  // to the same SSE stream and the client renders duplicated text.
+  //
+  // Members whose persist failed already received an error event in the catch
+  // block above; sending them the assistant's streaming response would surface
+  // a reply for a user message that isn't in their DB.
+  const successfulEventSinks = Array.from(
+    new Set(successfulBatch.map((qm) => qm.onEvent)),
+  );
   const fanOutOnEvent = (msg: ServerMessage) => {
-    for (const qm of successfulBatch) qm.onEvent(msg);
+    for (const onEvent of successfulEventSinks) onEvent(msg);
   };
 
   const drainLoopOptions: {
@@ -1857,15 +1893,14 @@ export async function processMessage(
     }
   }
 
-  let userMessageId: string;
+  let pmResult: { id: string; deduplicated: boolean };
   try {
-    userMessageId = await conversation.persistUserMessage(
-      resolvedContent,
+    pmResult = await conversation.persistUserMessage({
+      content: resolvedContent,
       attachments,
       requestId,
-      undefined,
       displayContent,
-    );
+    });
     publishConversationMessagesChanged(conversation.conversationId);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1879,6 +1914,8 @@ export async function processMessage(
     return "";
   }
 
+  const userMessageId = pmResult.id;
+
   // Fire-and-forget: detect notification preferences in the user message
   // and persist any that are found. Runs in the background so it doesn't
   // block the main conversation flow.

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

@@ -997,23 +997,38 @@ export function buildUnifiedTurnContextBlock(
 // ---------------------------------------------------------------------------
 
 /**
- * Remove text blocks from user messages whose text starts with any of the
- * given prefixes.  If stripping removes all content blocks from a message,
- * the message itself is dropped.
+ * A matcher for an injected text block. A plain string matches by prefix
+ * (`startsWith`). A `{ prefix, suffix }` wrapper requires BOTH the opening
+ * prefix and the closing suffix, so user-authored content that merely begins
+ * with an injection-like opening tag (e.g. a message discussing `<info>`
+ * markup) is not mistaken for an injected block and dropped. This mirrors
+ * `countMemoryPrefixBlocks`, which only treats `<memory>…</memory>` /
+ * `<info>…</info>` blocks as injected when the full wrapper is present.
+ */
+type InjectionMatcher = string | { prefix: string; suffix: string };
+
+/**
+ * Remove text blocks from user messages that match any of the given matchers.
+ * If stripping removes all content blocks from a message, the message itself
+ * is dropped.
  *
  * This is the shared primitive behind the individual strip* functions and
  * the `stripInjectionsForCompaction` pipeline.
  */
 function stripUserTextBlocksByPrefix(
   messages: Message[],
-  prefixes: string[],
+  matchers: InjectionMatcher[],
 ): Message[] {
   return messages
     .map((message) => {
       if (message.role !== "user") return message;
       const nextContent = message.content.filter((block) => {
         if (block.type !== "text") return true;
-        return !prefixes.some((p) => block.text.startsWith(p));
+        return !matchers.some((m) =>
+          typeof m === "string"
+            ? block.text.startsWith(m)
+            : block.text.startsWith(m.prefix) && block.text.endsWith(m.suffix),
+        );
       });
       if (nextContent.length === message.content.length) return message;
       if (nextContent.length === 0) return null;
@@ -1720,8 +1735,8 @@ export function loadSlackActiveThreadFocusBlock(
   return assembleSlackActiveThreadFocusBlock(rows, capabilities);
 }
 
-/** Prefixes stripped by the pipeline (order doesn't matter — single pass). */
-const RUNTIME_INJECTION_PREFIXES = [
+/** Matchers stripped by the pipeline (order doesn't matter — single pass). */
+const RUNTIME_INJECTION_PREFIXES: InjectionMatcher[] = [
   "<channel_capabilities>",
   "<channel_command_context>",
   "<disk_pressure_warning>",
@@ -1734,15 +1749,21 @@ const RUNTIME_INJECTION_PREFIXES = [
   "<background_turn>",
   "<memory_context __injected>",
   "<memory_context>", // backward-compat: strip legacy blocks from pre-__injected history
-  // The static `memory-v2-static` block (opens `<memory>\n…`) IS stripped
-  // so each compaction re-injects the freshest essentials/threads/recent/
-  // buffer view, matching the `<knowledge_base>` cadence. The dynamic
-  // activation block (opens `<memory __injected>…`) is intentionally NOT
-  // stripped — `startsWith("<memory>\n")` does not match it — so per-turn
-  // memory activations persist in history. The activation pipeline dedupes
-  // via `everInjected`, and compaction handles aggregate growth, so
-  // accumulation does not cause unbounded context growth.
-  "<memory>\n",
+  // The static `memory-v2-static` block (`<info>\n…</info>`) and the
+  // dynamic activation block (`<memory>\n…</memory>`, plus legacy
+  // `<memory __injected>…`) are both stripped so each compaction
+  // re-injects the freshest essentials/threads/recent/buffer view and
+  // re-runs the activation pipeline, matching the `<knowledge_base>`
+  // cadence. The activation pipeline dedupes via `everInjected`, and
+  // compaction handles aggregate growth, so accumulation does not cause
+  // unbounded context growth. Both wrappers may appear in persisted rows.
+  //
+  // These two use the full `{ prefix, suffix }` wrapper shape (not a bare
+  // prefix) so that user-authored text merely starting with `<memory>\n` or
+  // `<info>\n` is never silently dropped during compaction/`/clean`. This
+  // matches the full-wrapper requirement in `countMemoryPrefixBlocks`.
+  { prefix: "<memory>\n", suffix: "\n</memory>" },
+  { prefix: "<info>\n", suffix: "\n</info>" },
   "<voice_call_control>",
   "<workspace_top_level>", // backward-compat: strip legacy workspace blocks
   // NOTE: <workspace> is intentionally NOT stripped — workspace context
@@ -2037,7 +2058,7 @@ export interface RuntimeInjectionOptions {
   /**
    * Pre-rendered v2 static memory content (essentials/threads/recent/buffer
    * concatenated, header-wrapped). When non-null on full-mode turns the
-   * `memory-v2-static` injector wraps it in `<memory>` and splices it onto
+   * `memory-v2-static` injector wraps it in `<info>` and splices it onto
    * the user message; subsequent turns leave the prior block cached on its
    * original user message.
    */