@vellumai/assistant 0.6.0 → 0.6.1

package/src/daemon/config-watcher.ts

@@ -28,7 +28,10 @@ import { handleUserMessageSignal } from "../signals/user-message.js";
 import { DebouncerMap } from "../util/debounce.js";
 import { getLogger } from "../util/logger.js";
 import {
+  AVATAR_IMAGE_FILENAME,
+  getAvatarDir,
   getSignalsDir,
+  getSoundsDir,
   getWorkspaceDir,
   getWorkspaceSkillsDir,
 } from "../util/platform.js";
@@ -110,7 +113,12 @@ export class ConfigWatcher {
    * files change and conversations need to be evicted for reload.
    * `onIdentityChanged` is called when IDENTITY.md changes on disk.
    */
-  start(onConversationEvict: () => void, onIdentityChanged?: () => void): void {
+  start(
+    onConversationEvict: () => void,
+    onIdentityChanged?: () => void,
+    onSoundsConfigChanged?: () => void,
+    onAvatarChanged?: () => void,
+  ): void {
     const workspaceDir = getWorkspaceDir();
 
     const workspaceHandlers: Record<string, () => void> = {
@@ -175,6 +183,13 @@ export class ConfigWatcher {
       "workspace directory for config/prompt changes",
     );
 
+    if (onSoundsConfigChanged) {
+      this.startSoundsWatcher(onSoundsConfigChanged);
+    }
+    if (onAvatarChanged) {
+      this.startAvatarWatcher(onAvatarChanged);
+    }
+
     this.startFeatureFlagsWatcher();
     this.startSignalsWatcher();
     this.startSkillsWatchers(onConversationEvict);
@@ -188,6 +203,69 @@ export class ConfigWatcher {
     this.watchers = [];
   }
 
+  private startSoundsWatcher(onSoundsConfigChanged: () => void): void {
+    const soundsDir = getSoundsDir();
+    try {
+      if (!existsSync(soundsDir)) {
+        mkdirSync(soundsDir, { recursive: true });
+      }
+    } catch {
+      // If we can't create it, watching will also fail — handled below.
+    }
+
+    try {
+      const watcher = watch(soundsDir, (_eventType, filename) => {
+        if (!filename) return;
+        this.debounceTimers.schedule("file:sounds", () => {
+          log.info(
+            { file: String(filename) },
+            "Sounds directory changed, notifying clients",
+          );
+          onSoundsConfigChanged();
+        });
+      });
+      this.watchers.push(watcher);
+      log.info({ dir: soundsDir }, "Watching sounds directory for changes");
+    } catch (err) {
+      log.warn(
+        { err, dir: soundsDir },
+        "Failed to watch sounds directory. Sound config changes will require a restart.",
+      );
+    }
+  }
+
+  private startAvatarWatcher(onAvatarChanged: () => void): void {
+    const avatarDir = getAvatarDir();
+    try {
+      if (!existsSync(avatarDir)) {
+        mkdirSync(avatarDir, { recursive: true });
+      }
+    } catch {
+      // If we can't create it, watching will also fail — handled below.
+    }
+
+    try {
+      const watcher = watch(avatarDir, (_eventType, filename) => {
+        if (!filename) return;
+        if (String(filename) !== AVATAR_IMAGE_FILENAME) return;
+        this.debounceTimers.schedule("file:avatar", () => {
+          log.info(
+            { file: String(filename) },
+            "Avatar image changed, notifying clients",
+          );
+          onAvatarChanged();
+        });
+      });
+      this.watchers.push(watcher);
+      log.info({ dir: avatarDir }, "Watching avatar directory for changes");
+    } catch (err) {
+      log.warn(
+        { err, dir: avatarDir },
+        "Failed to watch avatar directory. Avatar changes will require a restart.",
+      );
+    }
+  }
+
   private startFeatureFlagsWatcher(): void {
     const protectedDir = process.env.GATEWAY_SECURITY_DIR
       ? process.env.GATEWAY_SECURITY_DIR

package/src/daemon/conversation-agent-loop-handlers.ts

@@ -27,6 +27,7 @@ import {
 } from "../memory/llm-request-log-store.js";
 import { backfillMemoryRecallLogMessageId } from "../memory/memory-recall-log-store.js";
 import type { ContentBlock, ImageContent } from "../providers/types.js";
+import { ProviderError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import type { DirectiveRequest } from "./assistant-attachments.js";
 import {
@@ -630,6 +631,25 @@ export function handleError(
       state.orderingErrorDetected = true;
       state.deferredOrderingError = event.error.message;
     } else {
+      if (classified.errorCategory === "provider_api_error") {
+        log.error(
+          {
+            conversationId: deps.ctx.conversationId,
+            errorCode: classified.code,
+            errorCategory: classified.errorCategory,
+            statusCode:
+              event.error instanceof ProviderError
+                ? event.error.statusCode
+                : undefined,
+            provider:
+              event.error instanceof ProviderError
+                ? event.error.provider
+                : undefined,
+            errorMessage: event.error.message,
+          },
+          "Provider rejected request with unclassified 4xx error",
+        );
+      }
       deps.onEvent(
         buildConversationErrorMessage(deps.ctx.conversationId, classified),
       );

package/src/daemon/conversation-agent-loop.ts

@@ -44,10 +44,7 @@ import {
   updateConversationTitle,
   updateMessageMetadata,
 } from "../memory/conversation-crud.js";
-import {
-  rebuildConversationDiskViewFromDbState,
-  syncMessageToDisk,
-} from "../memory/conversation-disk-view.js";
+import { syncMessageToDisk } from "../memory/conversation-disk-view.js";
 import {
   isReplaceableTitle,
   queueGenerateConversationTitle,
@@ -91,30 +88,30 @@ import {
   classifyConversationError,
   isUserCancellation,
 } from "./conversation-error.js";
-import { consolidateAssistantMessages } from "./conversation-history.js";
 import { raceWithTimeout } from "./conversation-media-retry.js";
 import type { MessageQueue } from "./conversation-queue-manager.js";
 import type { QueueDrainReason } from "./conversation-queue-manager.js";
 import type {
   ActiveSurfaceContext,
   ChannelCapabilities,
-  ChannelTurnContextParams,
   InboundActorContext,
   InjectionMode,
-  InterfaceTurnContextParams,
   TrustContext,
 } from "./conversation-runtime-assembly.js";
 import {
   applyRuntimeInjections,
+  buildUnifiedTurnContextBlock,
+  findLastInjectedNowContent,
   inboundActorContextFromTrust,
   inboundActorContextFromTrustContext,
   readNowScratchpad,
-  stripInjectedContext,
+  readPkbContext,
+  stripInjectionsForCompaction,
 } from "./conversation-runtime-assembly.js";
 import type { SkillProjectionCache } from "./conversation-skill-tools.js";
 import { resolveTrustClass } from "./conversation-tool-setup.js";
 import { recordUsage } from "./conversation-usage.js";
-import { buildTemporalContext } from "./date-context.js";
+import { formatTurnTimestamp } from "./date-context.js";
 import { deepRepairHistory, repairHistory } from "./history-repair.js";
 import type {
   DynamicPageSurfaceData,
@@ -123,6 +120,7 @@ import type {
   SurfaceType,
   UsageStats,
 } from "./message-protocol.js";
+import type { MemoryRecalled } from "./message-types/memory.js";
 import type { TraceEmitter } from "./trace-emitter.js";
 
 const log = getLogger("conversation-agent-loop");
@@ -502,6 +500,7 @@ export async function runAgentLoopImpl(
     }
 
     const isFirstMessage = ctx.messages.length === 1;
+    let shouldInjectWorkspace = isFirstMessage;
 
     const compactCheck = ctx.contextWindowManager.shouldCompact(ctx.messages);
     if (compactCheck.needed) {
@@ -556,6 +555,7 @@ export async function runAgentLoopImpl(
         compacted.summaryCacheReadInputTokens ?? 0,
         collapseRawResponses(compacted.summaryRawResponses),
       );
+      shouldInjectWorkspace = true;
     }
 
     const state = createEventHandlerState();
@@ -599,8 +599,8 @@ export async function runAgentLoopImpl(
 
     let runMessages = ctx.messages;
 
-    // Memory graph retrieval — dispatches to context-load / per-turn / refresh
-    // based on conversation state.
+    // Memory graph retrieval — dispatches to context-load / per-turn based on
+    // conversation state.
     const isTrustedActor = resolveTrustClass(ctx.trustContext) === "guardian";
     if (isTrustedActor) {
       const graphResult = await ctx.graphMemory.prepareMemory(
@@ -627,26 +627,65 @@ export async function runAgentLoopImpl(
         }
       }
 
+      const m = graphResult.metrics;
+
       try {
         recordMemoryRecallLog({
           conversationId: ctx.conversationId,
           enabled: true,
           degraded: false,
-          semanticHits: 0,
-          mergedCount: 0,
-          selectedCount: 0,
-          tier1Count: 0,
-          tier2Count: 0,
-          hybridSearchLatencyMs: 0,
-          sparseVectorUsed: false,
+          provider: m?.embeddingProvider ?? undefined,
+          model: m?.embeddingModel ?? undefined,
+          semanticHits: m?.semanticHits ?? 0,
+          mergedCount: m?.mergedCount ?? 0,
+          selectedCount: m?.selectedCount ?? 0,
+          tier1Count: m?.tier1Count ?? 0,
+          tier2Count: m?.tier2Count ?? 0,
+          hybridSearchLatencyMs: m?.hybridSearchLatencyMs ?? 0,
+          sparseVectorUsed: m?.sparseVectorUsed ?? false,
           injectedTokens: graphResult.injectedTokens,
           latencyMs: graphResult.latencyMs,
-          topCandidatesJson: [],
+          topCandidatesJson: (m?.topCandidates ?? []).map((c) => ({
+            key: c.nodeId,
+            type: c.type,
+            kind: "graph",
+            finalScore: c.score,
+            semantic: c.semanticSimilarity,
+            recency: c.recencyBoost,
+          })),
+          injectedText: graphResult.injectedBlockText ?? undefined,
           reason: `graph:${graphResult.mode}`,
+          queryContext: m?.queryContext ?? undefined,
         });
       } catch (err) {
         log.warn({ err }, "Failed to persist memory recall log (non-fatal)");
       }
+
+      if (m) {
+        const memoryRecalledEvent: MemoryRecalled = {
+          type: "memory_recalled",
+          provider: m.embeddingProvider ?? "unknown",
+          model: m.embeddingModel ?? "unknown",
+          semanticHits: m.semanticHits,
+          mergedCount: m.mergedCount,
+          selectedCount: m.selectedCount,
+          tier1Count: m.tier1Count,
+          tier2Count: m.tier2Count,
+          hybridSearchLatencyMs: m.hybridSearchLatencyMs,
+          sparseVectorUsed: m.sparseVectorUsed,
+          injectedTokens: graphResult.injectedTokens,
+          latencyMs: graphResult.latencyMs,
+          topCandidates: m.topCandidates.map((c) => ({
+            key: c.nodeId,
+            type: c.type,
+            kind: "graph",
+            finalScore: c.score,
+            semantic: c.semanticSimilarity,
+            recency: c.recencyBoost,
+          })),
+        };
+        onEvent(memoryRecalledEvent);
+      }
     }
 
     // Build active surface context
@@ -678,37 +717,20 @@ export async function runAgentLoopImpl(
 
     ctx.refreshWorkspaceTopLevelContextIfNeeded();
 
-    // Compute fresh temporal context each turn for date grounding.
+    // Compute fresh turn timestamp for date grounding.
     // Absolute "now" is always anchored to assistant host clock, while local
     // date semantics prefer configured user timezone, then recalled memory.
     const hostTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
     const configuredUserTimeZone = getConfig().ui.userTimezone ?? null;
     const recalledUserTimeZone = null;
-    const temporalContext = buildTemporalContext({
+    const timestamp = formatTurnTimestamp({
       hostTimeZone,
       configuredUserTimeZone,
       userTimeZone: recalledUserTimeZone,
     });
 
-    // Use the channel/interface context captured at the top of this function
-    // so it reflects the channel/interface that originally sent *this* turn's
-    // message, even if a newer message from a different channel arrived since.
-    const channelTurnContext: ChannelTurnContextParams = {
-      turnContext: capturedTurnChannelContext,
-      conversationOriginChannel: getConversationOriginChannel(
-        ctx.conversationId,
-      ),
-    };
-
-    const interfaceTurnContext: InterfaceTurnContextParams = {
-      turnContext: capturedTurnInterfaceContext,
-      conversationOriginInterface: getConversationOriginInterface(
-        ctx.conversationId,
-      ),
-    };
-
-    // Resolve the inbound actor context for the model's <inbound_actor_context>
-    // block. When the conversation carries enough identity info, use the unified
+    // Resolve the inbound actor context for the unified <turn_context> block.
+    // When the conversation carries enough identity info, use the unified
     // actor trust resolver so member status/policy and guardian binding details
     // are fresh for this turn. The conversation runtime context remains the source
     // for policy gating; this block is model-facing grounding metadata.
@@ -729,22 +751,53 @@ export async function runAgentLoopImpl(
       }
     }
 
+    // Build unified turn context block that replaces the separate temporal,
+    // channel, interface, and actor context blocks.
+    const interfaceName =
+      capturedTurnInterfaceContext.userMessageInterface ?? undefined;
+    const channelName =
+      capturedTurnChannelContext?.userMessageChannel ?? undefined;
+    const isGuardian =
+      resolvedInboundActorContext?.trustClass === "guardian" ||
+      !resolvedInboundActorContext;
+    const unifiedTurnContextStr = buildUnifiedTurnContextBlock(
+      isGuardian
+        ? { timestamp, interfaceName, channelName }
+        : {
+            timestamp,
+            interfaceName,
+            channelName,
+            actorContext: resolvedInboundActorContext,
+          },
+    );
+
     // The `remember` tool handles scratchpad-style memory writes directly to the graph.
 
     const isInteractiveResolved =
       options?.isInteractive ?? (!ctx.hasNoClient && !ctx.headlessLock);
 
+    // Only inject NOW.md if it changed since the last injection in the
+    // conversation.  Keeping the previous injection in place avoids mutating
+    // historical user messages and preserves the cached prefix.
+    const currentNowContent = readNowScratchpad();
+    const lastInjectedNow = findLastInjectedNowContent(ctx.messages);
+    const nowScratchpad =
+      currentNowContent !== lastInjectedNow ? currentNowContent : null;
+
+    // Read PKB always-loaded files (INDEX, essentials, threads, buffer)
+    const currentPkbContent = readPkbContext();
+
     // Shared injection options — reused whenever we need to re-inject after reduction.
     const injectionOpts = {
       activeSurface,
-      workspaceTopLevelContext: ctx.workspaceTopLevelContext,
+      workspaceTopLevelContext: shouldInjectWorkspace
+        ? ctx.workspaceTopLevelContext
+        : null,
       channelCapabilities: ctx.channelCapabilities ?? null,
       channelCommandContext: ctx.commandIntent ?? null,
-      channelTurnContext,
-      interfaceTurnContext,
-      inboundActorContext: resolvedInboundActorContext,
-      temporalContext,
-      nowScratchpad: readNowScratchpad(),
+      unifiedTurnContext: unifiedTurnContextStr,
+      pkbContext: currentPkbContent,
+      nowScratchpad,
       voiceCallControlPrompt: ctx.voiceCallControlPrompt ?? null,
       transportHints: ctx.transportHints ?? null,
       isNonInteractive: !isInteractiveResolved,
@@ -860,11 +913,20 @@ export async function runAgentLoopImpl(
           ctx.graphMemory.onCompacted(
             step.compactionResult.compactedPersistedMessages,
           );
+          shouldInjectWorkspace = true;
         }
 
-        // Re-inject with potentially downgraded injection mode
+        // Re-inject with potentially downgraded injection mode.
+        // When compaction ran it strips existing NOW.md / PKB blocks, so we
+        // must re-inject the current content. Otherwise rely on the deduplicated
+        // value from injectionOpts to avoid duplicate injection.
         runMessages = applyRuntimeInjections(ctx.messages, {
           ...injectionOpts,
+          pkbContext: currentPkbContent,
+          ...(step.compactionResult?.compacted && { nowScratchpad: currentNowContent }),
+          workspaceTopLevelContext: shouldInjectWorkspace
+            ? ctx.workspaceTopLevelContext
+            : null,
           mode: currentInjectionMode,
         });
         if (isTrustedActor && currentInjectionMode !== "minimal") {
@@ -994,7 +1056,7 @@ export async function runAgentLoopImpl(
 
       // Strip injected context from updated history before compacting,
       // so we compact the "raw" persistent messages.
-      const rawHistory = stripInjectedContext(updatedHistory);
+      const rawHistory = stripInjectionsForCompaction(updatedHistory);
       ctx.messages = rawHistory;
 
       ctx.emitActivityState(
@@ -1048,14 +1110,21 @@ export async function runAgentLoopImpl(
           midLoopCompact.summaryCacheReadInputTokens ?? 0,
           collapseRawResponses(midLoopCompact.summaryRawResponses),
         );
-        ctx.graphMemory.onCompacted(
-          midLoopCompact.compactedPersistedMessages,
-        );
+        ctx.graphMemory.onCompacted(midLoopCompact.compactedPersistedMessages);
+        shouldInjectWorkspace = true;
       }
 
-      // Re-inject runtime context and re-enter the agent loop
+      // Re-inject runtime context and re-enter the agent loop.
+      // stripInjectionsForCompaction() unconditionally removed the existing
+      // NOW.md block from ctx.messages above, so we must always re-inject
+      // the current content regardless of whether compaction actually ran.
       runMessages = applyRuntimeInjections(ctx.messages, {
         ...injectionOpts,
+        pkbContext: currentPkbContent,
+        nowScratchpad: currentNowContent,
+        workspaceTopLevelContext: shouldInjectWorkspace
+          ? ctx.workspaceTopLevelContext
+          : null,
         mode: currentInjectionMode,
       });
       if (isTrustedActor && currentInjectionMode !== "minimal") {
@@ -1134,7 +1203,7 @@ export async function runAgentLoopImpl(
     // convergence loop operates on the full (larger) history.
     if (state.contextTooLargeDetected) {
       if (updatedHistory.length > preRunHistoryLength) {
-        ctx.messages = stripInjectedContext(updatedHistory);
+        ctx.messages = stripInjectionsForCompaction(updatedHistory);
         preRepairMessages = updatedHistory;
         preRunHistoryLength = updatedHistory.length;
       }
@@ -1254,10 +1323,18 @@ export async function runAgentLoopImpl(
           ctx.graphMemory.onCompacted(
             step.compactionResult.compactedPersistedMessages,
           );
+          shouldInjectWorkspace = true;
         }
 
+        // ctx.messages has been stripped (line 1206/1373) so NOW.md must
+        // always be re-injected regardless of whether compaction ran.
         runMessages = applyRuntimeInjections(ctx.messages, {
           ...injectionOpts,
+          pkbContext: currentPkbContent,
+          nowScratchpad: currentNowContent,
+          workspaceTopLevelContext: shouldInjectWorkspace
+            ? ctx.workspaceTopLevelContext
+            : null,
           mode: currentInjectionMode,
         });
         if (isTrustedActor && currentInjectionMode !== "minimal") {
@@ -1295,7 +1372,7 @@ export async function runAgentLoopImpl(
           // tier operates on up-to-date history instead of stale
           // pre-rerun messages.
           if (updatedHistory.length > preRunHistoryLength) {
-            ctx.messages = stripInjectedContext(updatedHistory);
+            ctx.messages = stripInjectionsForCompaction(updatedHistory);
             preRepairMessages = updatedHistory;
             preRunHistoryLength = updatedHistory.length;
           }
@@ -1368,14 +1445,23 @@ export async function runAgentLoopImpl(
               ctx.graphMemory.onCompacted(
                 emergencyCompact.compactedPersistedMessages,
               );
+              shouldInjectWorkspace = true;
             }
 
+            // ctx.messages was already stripped before the convergence
+            // loop, so NOW.md must always be re-injected here.
             runMessages = applyRuntimeInjections(ctx.messages, {
               ...injectionOpts,
+              pkbContext: currentPkbContent,
+              nowScratchpad: currentNowContent,
+              workspaceTopLevelContext: shouldInjectWorkspace
+                ? ctx.workspaceTopLevelContext
+                : null,
               mode: currentInjectionMode,
             });
             if (isTrustedActor && currentInjectionMode !== "minimal") {
-              const memResult = ctx.graphMemory.reinjectCachedMemory(runMessages);
+              const memResult =
+                ctx.graphMemory.reinjectCachedMemory(runMessages);
               runMessages = memResult.runMessages;
             }
             preRepairMessages = runMessages;
@@ -1479,10 +1565,18 @@ export async function runAgentLoopImpl(
             ctx.graphMemory.onCompacted(
               emergencyCompact.compactedPersistedMessages,
             );
+            shouldInjectWorkspace = true;
           }
 
+          // ctx.messages was already stripped before the convergence
+          // loop, so NOW.md must always be re-injected here.
           runMessages = applyRuntimeInjections(ctx.messages, {
             ...injectionOpts,
+            pkbContext: currentPkbContent,
+            nowScratchpad: currentNowContent,
+            workspaceTopLevelContext: shouldInjectWorkspace
+              ? ctx.workspaceTopLevelContext
+              : null,
             mode: currentInjectionMode,
           });
           if (isTrustedActor && currentInjectionMode !== "minimal") {
@@ -1626,7 +1720,11 @@ export async function runAgentLoopImpl(
       { providerName: ctx.provider.name, toolTokenBudget },
     );
 
-    ctx.messages = stripInjectedContext(restoredHistory);
+    // Persist injections in history: runtime-injected context stays on
+    // historical user messages so the conversation prefix is stable for
+    // Anthropic's prefix caching.  Stripping only happens during
+    // compaction/overflow recovery (where a cache miss is expected).
+    ctx.messages = restoredHistory;
 
     emitUsage(
       ctx,
@@ -1877,15 +1975,10 @@ export async function runAgentLoopImpl(
     // Clear at turn end so they never leak into subsequent unrelated messages.
     ctx.commandIntent = undefined;
 
-    if (userMessageId) {
-      const didMutateHistory = consolidateAssistantMessages(
-        ctx.conversationId,
-        userMessageId,
-      );
-      if (didMutateHistory) {
-        rebuildConversationDiskViewFromDbState(ctx.conversationId);
-      }
-    }
+    // Consolidation deferred to compaction: keeping assistant + tool_result
+    // messages unconsolidated preserves the exact message structure sent to
+    // the API, enabling stable prefix caching across turns.  Compaction
+    // consolidates when it summarizes old messages (cache miss is expected).
 
     ctx.drainQueue(yieldedForHandoff ? "checkpoint_handoff" : "loop_complete");
 

package/src/daemon/conversation-history.ts

@@ -68,14 +68,13 @@ export function findLastUndoableUserMessageIndex(messages: Message[]): number {
 // ── Qdrant Vector Cleanup ────────────────────────────────────────────
 
 /**
- * Delete Qdrant vector entries for the given segment and item IDs.
+ * Delete Qdrant vector entries for the given segment IDs.
  * Individual deletion failures are logged and enqueued as retry jobs
  * to prevent silently orphaned vectors.
  */
 export async function cleanupQdrantVectors(
   conversationId: string,
   segmentIds: string[],
-  orphanedItemIds: string[],
 ): Promise<void> {
   let qdrant: ReturnType<typeof getQdrantClient>;
   try {
@@ -84,15 +83,12 @@ export async function cleanupQdrantVectors(
     return; // Qdrant not initialized — nothing to clean up.
   }
 
-  if (segmentIds.length === 0 && orphanedItemIds.length === 0) return;
+  if (segmentIds.length === 0) return;
 
   const targets: Array<{ targetType: string; targetId: string }> = [];
   for (const segId of segmentIds) {
     targets.push({ targetType: "segment", targetId: segId });
   }
-  for (const itemId of orphanedItemIds) {
-    targets.push({ targetType: "item", targetId: itemId });
-  }
 
   const results = await Promise.allSettled(
     targets.map((t) =>
@@ -124,7 +120,6 @@ export async function cleanupQdrantVectors(
         succeeded,
         failed,
         segments: segmentIds.length,
-        items: orphanedItemIds.length,
       },
       "Cleaned up Qdrant vectors after regenerate",
     );
@@ -187,20 +182,17 @@ export function consolidateAssistantMessages(
     // Still delete internal tool_result messages even if only one assistant message,
     // and collect IDs for vector cleanup
     const allSegmentIds: string[] = [];
-    const allOrphanedItemIds: string[] = [];
     for (const id of messagesToDelete) {
       const deleted = deleteMessageById(id);
       didMutate = true;
       allSegmentIds.push(...deleted.segmentIds);
-      allOrphanedItemIds.push(...deleted.orphanedItemIds);
     }
 
     // Clean up Qdrant vectors (fire-and-forget)
-    if (allSegmentIds.length > 0 || allOrphanedItemIds.length > 0) {
+    if (allSegmentIds.length > 0) {
       cleanupQdrantVectors(
         conversationId,
         allSegmentIds,
-        allOrphanedItemIds,
       ).catch((err) => {
         log.warn(
           { err, conversationId },
@@ -322,24 +314,20 @@ export function consolidateAssistantMessages(
   // Delete the other assistant messages and internal tool_result messages,
   // and collect IDs for vector cleanup
   const allSegmentIds: string[] = [];
-  const allOrphanedItemIds: string[] = [];
   for (let i = 1; i < messagesToConsolidate.length; i++) {
     const deleted = deleteMessageById(messagesToConsolidate[i].id);
     allSegmentIds.push(...deleted.segmentIds);
-    allOrphanedItemIds.push(...deleted.orphanedItemIds);
   }
   for (const id of messagesToDelete) {
     const deleted = deleteMessageById(id);
     allSegmentIds.push(...deleted.segmentIds);
-    allOrphanedItemIds.push(...deleted.orphanedItemIds);
   }
 
   // Clean up Qdrant vectors (fire-and-forget)
-  if (allSegmentIds.length > 0 || allOrphanedItemIds.length > 0) {
+  if (allSegmentIds.length > 0) {
     cleanupQdrantVectors(
       conversationId,
       allSegmentIds,
-      allOrphanedItemIds,
     ).catch((err) => {
       log.warn(
         { err, conversationId },
@@ -539,18 +527,15 @@ export async function regenerate(
 
   // Delete each message via deleteMessageById and collect IDs for Qdrant cleanup.
   const allSegmentIds: string[] = [];
-  const allOrphanedItemIds: string[] = [];
   for (const msg of messagesToDelete) {
     const deleted = deleteMessageById(msg.id);
     allSegmentIds.push(...deleted.segmentIds);
-    allOrphanedItemIds.push(...deleted.orphanedItemIds);
   }
 
   // Clean up Qdrant vectors (fire-and-forget).
   cleanupQdrantVectors(
     conversation.conversationId,
     allSegmentIds,
-    allOrphanedItemIds,
   ).catch((err) => {
     log.warn(
       { err, conversationId: conversation.conversationId },