@vellumai/assistant 0.6.0 → 0.6.2

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,32 @@ 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,
+  findLastInjectedPkbContent,
   inboundActorContextFromTrust,
   inboundActorContextFromTrustContext,
   readNowScratchpad,
-  stripInjectedContext,
+  readPkbContext,
+  stripInjectionsForCompaction,
 } from "./conversation-runtime-assembly.js";
 import type { SkillProjectionCache } from "./conversation-skill-tools.js";
+import { markSurfaceCompleted } from "./conversation-surfaces.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 +122,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");
@@ -440,6 +440,7 @@ export async function runAgentLoopImpl(
           surfaceId,
           summary: "Dismissed",
         });
+        markSurfaceCompleted(ctx, surfaceId, "Dismissed");
         ctx.pendingSurfaceActions.delete(surfaceId);
       }
     }
@@ -502,6 +503,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 +558,7 @@ export async function runAgentLoopImpl(
         compacted.summaryCacheReadInputTokens ?? 0,
         collapseRawResponses(compacted.summaryRawResponses),
       );
+      shouldInjectWorkspace = true;
     }
 
     const state = createEventHandlerState();
@@ -599,8 +602,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 +630,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 +720,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 +754,61 @@ 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;
+
+    // Only inject PKB 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.
+    // Note: injectPkbContext escapes </pkb> sequences before writing to history,
+    // so we must apply the same escaping before comparing to avoid false mismatches.
+    const currentPkbContent = readPkbContext();
+    const lastInjectedPkb = findLastInjectedPkbContent(ctx.messages);
+    const escapedCurrentPkb = currentPkbContent?.replace(/<\/pkb\s*>/gi, "&lt;/pkb&gt;") ?? null;
+    const pkbContext =
+      escapedCurrentPkb !== lastInjectedPkb ? currentPkbContent : null;
+
     // 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,
+      nowScratchpad,
       voiceCallControlPrompt: ctx.voiceCallControlPrompt ?? null,
       transportHints: ctx.transportHints ?? null,
       isNonInteractive: !isInteractiveResolved,
@@ -860,11 +924,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,
+          ...(step.compactionResult?.compacted && { pkbContext: currentPkbContent }),
+          ...(step.compactionResult?.compacted && { nowScratchpad: currentNowContent }),
+          workspaceTopLevelContext: shouldInjectWorkspace
+            ? ctx.workspaceTopLevelContext
+            : null,
           mode: currentInjectionMode,
         });
         if (isTrustedActor && currentInjectionMode !== "minimal") {
@@ -994,7 +1067,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 +1121,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") {
@@ -1133,8 +1213,16 @@ export async function runAgentLoopImpl(
     // limit), incorporate those new messages into ctx.messages so the
     // convergence loop operates on the full (larger) history.
     if (state.contextTooLargeDetected) {
+      // Track whether ctx.messages was actually stripped so we know if
+      // NOW.md (and other injections) need to be re-injected.  When the
+      // provider rejects before adding any messages, the strip is skipped
+      // and ctx.messages still contains the previous injection — blindly
+      // re-injecting would duplicate the NOW.md block.
+      let convergenceStripped = false;
+
       if (updatedHistory.length > preRunHistoryLength) {
-        ctx.messages = stripInjectedContext(updatedHistory);
+        ctx.messages = stripInjectionsForCompaction(updatedHistory);
+        convergenceStripped = true;
         preRepairMessages = updatedHistory;
         preRunHistoryLength = updatedHistory.length;
       }
@@ -1254,10 +1342,19 @@ export async function runAgentLoopImpl(
           ctx.graphMemory.onCompacted(
             step.compactionResult.compactedPersistedMessages,
           );
+          shouldInjectWorkspace = true;
         }
 
+        // Only re-inject NOW.md when ctx.messages was actually stripped;
+        // otherwise the existing NOW.md block is still present and
+        // re-injecting would duplicate it.
         runMessages = applyRuntimeInjections(ctx.messages, {
           ...injectionOpts,
+          pkbContext: currentPkbContent,
+          nowScratchpad: convergenceStripped ? currentNowContent : null,
+          workspaceTopLevelContext: shouldInjectWorkspace
+            ? ctx.workspaceTopLevelContext
+            : null,
           mode: currentInjectionMode,
         });
         if (isTrustedActor && currentInjectionMode !== "minimal") {
@@ -1295,7 +1392,8 @@ 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);
+            convergenceStripped = true;
             preRepairMessages = updatedHistory;
             preRunHistoryLength = updatedHistory.length;
           }
@@ -1368,14 +1466,23 @@ export async function runAgentLoopImpl(
               ctx.graphMemory.onCompacted(
                 emergencyCompact.compactedPersistedMessages,
               );
+              shouldInjectWorkspace = true;
             }
 
+            // Only re-inject NOW.md when ctx.messages was actually stripped;
+            // otherwise the existing block is still present.
             runMessages = applyRuntimeInjections(ctx.messages, {
               ...injectionOpts,
+              pkbContext: currentPkbContent,
+              nowScratchpad: convergenceStripped ? currentNowContent : null,
+              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 +1586,18 @@ export async function runAgentLoopImpl(
             ctx.graphMemory.onCompacted(
               emergencyCompact.compactedPersistedMessages,
             );
+            shouldInjectWorkspace = true;
           }
 
+          // Only re-inject NOW.md when ctx.messages was actually stripped;
+          // otherwise the existing block is still present.
           runMessages = applyRuntimeInjections(ctx.messages, {
             ...injectionOpts,
+            pkbContext: currentPkbContent,
+            nowScratchpad: convergenceStripped ? currentNowContent : null,
+            workspaceTopLevelContext: shouldInjectWorkspace
+              ? ctx.workspaceTopLevelContext
+              : null,
             mode: currentInjectionMode,
           });
           if (isTrustedActor && currentInjectionMode !== "minimal") {
@@ -1626,7 +1741,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 +1996,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-attachments.ts

@@ -71,7 +71,6 @@ export async function approveHostAttachmentRead(
     await generateAllowlistOptions(toolName, input),
     generateScopeOptions(workingDir, toolName),
     undefined,
-    undefined,
     conversationId,
     "host",
   );

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 },

package/src/daemon/conversation-lifecycle.ts

@@ -9,7 +9,6 @@ import type { EventBus } from "../events/bus.js";
 import type { AssistantDomainEvents } from "../events/domain-events.js";
 import type { ToolProfiler } from "../events/tool-profiling-listener.js";
 import { getHookManager } from "../hooks/manager.js";
-import { getMemoryCheckpoint } from "../memory/checkpoints.js";
 import {
   getConversation,
   getMessages,
@@ -151,6 +150,10 @@ export interface DisposeContext extends AbortContext {
   lastSurfaceAction: Map<string, unknown>;
   workspaceTopLevelContext: string | null;
   trustContext?: { trustClass: TrustClass };
+  /** Active memory node IDs snapshotted from the conversation's InContextTracker before disposal. */
+  activeContextNodeIds?: string[];
+  /** Memory scope for extraction — defaults to "default" if omitted. */
+  memoryScopeId?: string;
   abort(): void;
 }
 
@@ -289,19 +292,6 @@ export function disposeConversation(ctx: DisposeContext): void {
     conversationId: ctx.conversationId,
   });
 
-  // Trigger batch extraction for any remaining unextracted messages
-  try {
-    const pendingKey = `batch_extract:${ctx.conversationId}:pending_count`;
-    const pending = getMemoryCheckpoint(pendingKey);
-    if (pending && parseInt(pending, 10) > 0) {
-      enqueueMemoryJob("batch_extract", {
-        conversationId: ctx.conversationId,
-      });
-    }
-  } catch {
-    // Best-effort — don't block conversation disposal
-  }
-
   // Trigger graph extraction for end-of-conversation sweep.
   // Only extract from guardian conversations to preserve the memory trust
   // boundary — untrusted content must not influence future memory retrieval.
@@ -309,6 +299,10 @@ export function disposeConversation(ctx: DisposeContext): void {
     try {
       enqueueMemoryJob("graph_extract", {
         conversationId: ctx.conversationId,
+        scopeId: ctx.memoryScopeId ?? "default",
+        ...(ctx.activeContextNodeIds?.length
+          ? { activeContextNodeIds: ctx.activeContextNodeIds }
+          : {}),
       });
     } catch {
       // Best-effort — don't block conversation disposal

package/src/daemon/conversation-messaging.ts

@@ -41,6 +41,7 @@ import type {
   ServerMessage,
   UserMessageAttachment,
 } from "./message-protocol.js";
+import type { ConversationTransportMetadata } from "./message-types/conversations.js";
 
 const log = getLogger("conversation-messaging");
 
@@ -222,6 +223,7 @@ export function enqueueMessage(
   metadata?: Record<string, unknown>,
   options?: { isInteractive?: boolean },
   displayContent?: string,
+  transport?: ConversationTransportMetadata,
 ): { queued: boolean; requestId: string; rejected?: boolean } {
   if (!ctx.processing) {
     return { queued: false, requestId };
@@ -246,6 +248,7 @@ export function enqueueMessage(
     turnChannelContext,
     turnInterfaceContext,
     isInteractive: options?.isInteractive,
+    transport,
     displayContent,
     sentAt: Date.now(),
   });