@vellumai/assistant 0.5.13 → 0.5.15

package/src/context/window-manager.ts

@@ -1,8 +1,16 @@
-import { createUserMessage } from "../agent/message-types.js";
 import type { ContextWindowConfig } from "../config/types.js";
-import type { ContentBlock, Message, Provider } from "../providers/types.js";
+import type {
+  ContentBlock,
+  ImageContent,
+  Message,
+  Provider,
+} from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
-import { estimatePromptTokens, estimateTextTokens } from "./token-estimator.js";
+import {
+  estimateContentBlockTokens,
+  estimatePromptTokens,
+  estimateTextTokens,
+} from "./token-estimator.js";
 import { truncateToolResultsAcrossHistory } from "./tool-result-truncation.js";
 
 const log = getLogger("context-window");
@@ -399,13 +407,13 @@ export class ContextWindowManager {
       };
     }
 
-    const transcript = this.capTranscriptToTokenBudget(
-      serializeMessages(compactableMessages),
+    const transcriptBlocks = this.capTranscriptBlocksToTokenBudget(
+      serializeMessagesToContentBlocks(compactableMessages),
       existingSummary ?? "No previous summary.",
     );
     const summaryUpdate = await this.updateSummary(
       existingSummary ?? "No previous summary.",
-      transcript,
+      transcriptBlocks,
       signal,
     );
     const summary = summaryUpdate.summary;
@@ -426,7 +434,8 @@ export class ContextWindowManager {
     // Media (images, files) in kept turns is preserved naturally — those
     // turns are carried forward as-is and their token cost is already
     // accounted for by pickKeepBoundary's estimatePromptTokens call.
-    // Media in compacted turns is described textually in the summary transcript.
+    // Images in compacted turns are passed to the summarizer so it can
+    // describe their visual content in the summary text.
     const summaryMessage = createContextSummaryMessage(summary);
 
     const { messages: truncatedKeptMessages } =
@@ -555,18 +564,20 @@ export class ContextWindowManager {
   }
 
   /**
-   * Trim the serialized transcript so that the summary prompt (system prompt +
-   * existing summary + transcript + scaffolding) fits within the provider's
-   * input token limit, minus the output budget reserved for the summary itself.
-   * This prevents the summarizer LLM call from exceeding its context window
-   * during forced compaction of very large histories.
+   * Trim the serialized transcript content blocks so that the summary prompt
+   * (system prompt + existing summary + transcript + scaffolding) fits within
+   * the provider's input token limit, minus the output budget reserved for the
+   * summary itself.
+   *
+   * When the transcript exceeds the budget, blocks are dropped from the
+   * beginning (oldest messages first) to preserve recent context. Image blocks
+   * are dropped before text blocks within each pass since they are expensive
+   * and their surrounding text context already captures the conversation flow.
    */
-  private capTranscriptToTokenBudget(
-    transcript: string,
+  private capTranscriptBlocksToTokenBudget(
+    blocks: ContentBlock[],
     currentSummary: string,
-  ): string {
-    // Reserve tokens for: system prompt, summary prompt scaffolding, existing
-    // summary, message overhead, and the output (summaryMaxTokens).
+  ): ContentBlock[] {
     const overheadTokens =
       estimateTextTokens(SUMMARY_SYSTEM_PROMPT) +
       estimateTextTokens(currentSummary) +
@@ -580,26 +591,59 @@ export class ContextWindowManager {
       this.config.maxInputTokens - overheadTokens,
     );
 
-    const transcriptTokens = estimateTextTokens(transcript);
-    if (transcriptTokens <= maxTranscriptTokens) return transcript;
+    const estimateBlockTokens = (b: ContentBlock): number =>
+      estimateContentBlockTokens(b, { providerName: this.provider.name });
+
+    let totalTokens = 0;
+    for (const block of blocks) {
+      totalTokens += estimateBlockTokens(block);
+    }
+    if (totalTokens <= maxTranscriptTokens) return blocks;
+
+    // First pass: drop images from the beginning until we fit or run out of
+    // images to drop. Images are high-cost and their text context (message
+    // headers, surrounding tool_use/tool_result serializations) is preserved.
+    const result = [...blocks];
+    for (let i = 0; i < result.length && totalTokens > maxTranscriptTokens; i++) {
+      if (result[i].type === "image") {
+        totalTokens -= estimateBlockTokens(result[i]);
+        const stub: ContentBlock = {
+          type: "text",
+          text: `[image omitted from summary context]`,
+        };
+        totalTokens += estimateBlockTokens(stub);
+        result[i] = stub;
+      }
+    }
+    if (totalTokens <= maxTranscriptTokens) return result;
+
+    // Second pass: drop text blocks from the beginning (oldest) until we fit.
+    let dropUntil = 0;
+    let droppedTokens = 0;
+    for (let i = 0; i < result.length && totalTokens > maxTranscriptTokens; i++) {
+      droppedTokens += estimateBlockTokens(result[i]);
+      totalTokens -= estimateBlockTokens(result[i]);
+      dropUntil = i + 1;
+    }
 
-    // Truncate from the beginning (older messages) to preserve recent context.
-    const maxChars = maxTranscriptTokens * 4; // inverse of estimateTextTokens
-    const truncated = transcript.slice(transcript.length - maxChars);
     log.info(
       {
-        originalTokens: transcriptTokens,
+        originalTokens: totalTokens + droppedTokens,
         cappedTokens: maxTranscriptTokens,
-        droppedTokens: transcriptTokens - maxTranscriptTokens,
+        droppedTokens,
       },
-      "Capped summary transcript to fit provider input limit",
+      "Capped summary transcript blocks to fit provider input limit",
     );
-    return `[earlier messages truncated]\n${truncated}`;
+
+    return [
+      { type: "text", text: "[earlier messages truncated]" } as ContentBlock,
+      ...result.slice(dropUntil),
+    ];
   }
 
   private async updateSummary(
     currentSummary: string,
-    transcript: string,
+    transcriptBlocks: ContentBlock[],
     signal?: AbortSignal,
   ): Promise<{
     summary: string;
@@ -610,10 +654,14 @@ export class ContextWindowManager {
     cacheReadInputTokens: number;
     rawResponse?: unknown;
   }> {
-    const prompt = buildSummaryPrompt(currentSummary, transcript);
+    const contentBlocks = buildSummaryContentBlocks(
+      currentSummary,
+      transcriptBlocks,
+    );
+    const summaryMessage: Message = { role: "user", content: contentBlocks };
     try {
       const response = await this.provider.sendMessage(
-        [createUserMessage(prompt)],
+        [summaryMessage],
         undefined,
         SUMMARY_SYSTEM_PROMPT,
         {
@@ -639,8 +687,14 @@ export class ContextWindowManager {
       log.warn({ err }, "Summary generation failed, using local fallback");
     }
 
+    // Fallback: extract text-only transcript for local summary generation.
+    const textTranscript = transcriptBlocks
+      .filter((b): b is Extract<ContentBlock, { type: "text" }> => b.type === "text")
+      .map((b) => b.text)
+      .join("\n\n");
+
     return {
-      summary: fallbackSummary(currentSummary, transcript),
+      summary: fallbackSummary(currentSummary, textTranscript),
       inputTokens: 0,
       outputTokens: 0,
       model: "",
@@ -789,35 +843,102 @@ export function createContextSummaryMessage(summary: string): Message {
   return message;
 }
 
-function buildSummaryPrompt(
+/**
+ * Build content blocks for the summary prompt. Returns a mix of text blocks
+ * (for the scaffolding, existing summary, and serialized non-image content)
+ * and image blocks (preserved from the original messages so the summarizer
+ * can describe what was in them).
+ */
+function buildSummaryContentBlocks(
   currentSummary: string,
-  transcript: string,
-): string {
+  transcriptBlocks: ContentBlock[],
+): ContentBlock[] {
   return [
-    "Update the summary with new transcript data.",
-    "If new information conflicts with older notes, keep the most recent and explicit detail.",
-    "Keep all unresolved asks and next steps.",
-    "",
-    "### Existing Summary",
-    currentSummary.trim().length > 0 ? currentSummary.trim() : "None.",
-    "",
-    "### Transcript",
-    transcript,
-  ].join("\n");
+    {
+      type: "text",
+      text: [
+        "Update the summary with new transcript data.",
+        "If new information conflicts with older notes, keep the most recent and explicit detail.",
+        "Keep all unresolved asks and next steps.",
+        "For any images included below, describe their visual content in the summary so the information is preserved after compaction.",
+        "",
+        "### Existing Summary",
+        currentSummary.trim().length > 0 ? currentSummary.trim() : "None.",
+        "",
+        "### Transcript",
+      ].join("\n"),
+    } as ContentBlock,
+    ...transcriptBlocks,
+  ];
 }
 
-function serializeMessages(messages: Message[]): string {
-  return messages.map((m, i) => serializeForSummary(m, i)).join("\n\n");
-}
+/**
+ * Serialize messages into a sequence of content blocks. Text-based content
+ * (tool calls, tool results, thinking, etc.) is serialized into text blocks.
+ * Image blocks — both top-level and nested inside tool_result contentBlocks —
+ * are preserved as-is so the summarizer LLM can see them.
+ */
+function serializeMessagesToContentBlocks(messages: Message[]): ContentBlock[] {
+  const blocks: ContentBlock[] = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    const textLines: string[] = [`Message #${i + 1} (${msg.role})`];
 
-function serializeForSummary(message: Message, index: number): string {
-  const lines = [`Message #${index + 1} (${message.role})`];
+    for (const block of msg.content) {
+      if (block.type === "image") {
+        // Flush accumulated text lines before the image.
+        if (textLines.length > 0) {
+          blocks.push({ type: "text", text: textLines.join("\n") });
+          textLines.length = 0;
+        }
+        blocks.push(block);
+      } else if (block.type === "web_search_tool_result") {
+        textLines.push(
+          `web_search_tool_result ${block.tool_use_id}: [opaque]`,
+        );
+      } else if (block.type === "tool_result") {
+        // Extract images from tool_result contentBlocks before serializing.
+        const collectedImages: ImageContent[] = [];
+        textLines.push(serializeToolResultBlock(block, collectedImages));
+        if (collectedImages.length > 0) {
+          // Flush text, emit collected images, then continue.
+          if (textLines.length > 0) {
+            blocks.push({ type: "text", text: textLines.join("\n") });
+            textLines.length = 0;
+          }
+          blocks.push(...collectedImages);
+        }
+      } else {
+        textLines.push(serializeBlock(block));
+      }
+    }
 
-  for (const block of message.content) {
-    lines.push(serializeBlock(block));
+    // Flush remaining text lines for this message.
+    if (textLines.length > 0) {
+      blocks.push({ type: "text", text: textLines.join("\n") });
+    }
   }
+  return blocks;
+}
 
-  return lines.join("\n");
+/**
+ * Serialize images nested inside tool_result contentBlocks, returning them
+ * as separate content blocks to preserve for the summarizer.
+ */
+function serializeToolResultBlock(
+  block: Extract<ContentBlock, { type: "tool_result" }>,
+  collectedImages: ImageContent[],
+): string {
+  if (block.contentBlocks) {
+    for (const cb of block.contentBlocks) {
+      if (cb.type === "image") {
+        collectedImages.push(cb);
+      }
+    }
+  }
+  return `tool_result ${block.tool_use_id}${
+    block.is_error ? " (error)" : ""
+  }: ${clampText(block.content)}`;
 }
 
 function serializeBlock(block: ContentBlock): string {
@@ -831,6 +952,8 @@ function serializeBlock(block: ContentBlock): string {
         block.is_error ? " (error)" : ""
       }: ${clampText(block.content)}`;
     case "image":
+      // Top-level images are handled by serializeMessagesToContentBlocks.
+      // This path is only hit for images in unexpected positions.
       return `image: ${block.source.media_type}, ${
         Math.ceil(block.source.data.length / 4) * 3
       } bytes(base64)`;

package/src/credential-execution/executable-discovery.ts

@@ -21,7 +21,7 @@ import { join } from "node:path";
 
 import { getIsContainerized } from "../config/env-registry.js";
 import { getLogger } from "../util/logger.js";
-import { getRootDir } from "../util/platform.js";
+import { getBinDir } from "../util/platform.js";
 
 const log = getLogger("ces-discovery");
 
@@ -67,7 +67,7 @@ function getManagedBootstrapSocketPath(): string {
  * a malicious binary there. Removed to close the sandbox-escape vector.
  */
 function getLocalBinarySearchPaths(): string[] {
-  return [join(getRootDir(), "bin", "credential-executor")];
+  return [join(getBinDir(), "credential-executor")];
 }
 
 // ---------------------------------------------------------------------------

package/src/daemon/approved-devices-store.ts

@@ -17,7 +17,7 @@ import {
 import { dirname, join } from "node:path";
 
 import { getLogger } from "../util/logger.js";
-import { getRootDir } from "../util/platform.js";
+import { getProtectedDir } from "../util/platform.js";
 
 const log = getLogger("approved-devices-store");
 
@@ -33,7 +33,7 @@ interface ApprovedDevicesFile {
 }
 
 function getStorePath(): string {
-  return join(getRootDir(), "protected", "approved-devices.json");
+  return join(getProtectedDir(), "approved-devices.json");
 }
 
 /** Hash a raw deviceId for storage. */

package/src/daemon/assistant-attachments.ts

@@ -63,6 +63,8 @@ const EXTENSION_MIME_MAP: Record<string, string> = {
   svg: "image/svg+xml",
   ico: "image/x-icon",
   bmp: "image/bmp",
+  heic: "image/heic",
+  heif: "image/heif",
 
   // Documents
   pdf: "application/pdf",

package/src/daemon/config-watcher.ts

@@ -1,7 +1,7 @@
 /**
  * File watchers and config reload logic extracted from DaemonServer.
- * Watches workspace files (config, prompts), protected directory
- * (trust rules, secret allowlist), and skills directories for changes.
+ * Watches workspace files (config, prompts) and skills directories
+ * for changes.
  */
 import {
   existsSync,
@@ -12,27 +12,20 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 
-import { clearFeatureFlagOverridesCache } from "../config/assistant-feature-flags.js";
 import { getConfig, invalidateConfigCache } from "../config/loader.js";
 import { clearEmbeddingBackendCache } from "../memory/embedding-backend.js";
 import { clearCache as clearTrustCache } from "../permissions/trust-store.js";
 import { initializeProviders } from "../providers/registry.js";
-import {
-  resetAllowlist,
-  validateAllowlistFile,
-} from "../security/secret-allowlist.js";
 import { handleBashSignal } from "../signals/bash.js";
 import { handleCancelSignal } from "../signals/cancel.js";
-import { handleConfirmationSignal } from "../signals/confirm.js";
 import { handleConversationUndoSignal } from "../signals/conversation-undo.js";
+import { handleEmitEventSignal } from "../signals/emit-event.js";
 import { handleMcpReloadSignal } from "../signals/mcp-reload.js";
 import { handleShotgunSignal } from "../signals/shotgun.js";
-import { handleTrustRuleSignal } from "../signals/trust-rule.js";
 import { handleUserMessageSignal } from "../signals/user-message.js";
 import { DebouncerMap } from "../util/debounce.js";
 import { getLogger } from "../util/logger.js";
 import {
-  getRootDir,
   getSignalsDir,
   getWorkspaceDir,
   getWorkspaceSkillsDir,
@@ -117,7 +110,6 @@ export class ConfigWatcher {
    */
   start(onConversationEvict: () => void, onIdentityChanged?: () => void): void {
     const workspaceDir = getWorkspaceDir();
-    const protectedDir = join(getRootDir(), "protected");
 
     const workspaceHandlers: Record<string, () => void> = {
       "config.json": async () => {
@@ -150,36 +142,6 @@ export class ConfigWatcher {
       "UPDATES.md": () => onConversationEvict(),
     };
 
-    const protectedHandlers: Record<string, () => void> = {
-      "trust.json": () => {
-        clearTrustCache();
-      },
-      "feature-flags.json": () => {
-        clearFeatureFlagOverridesCache();
-        onConversationEvict();
-      },
-      "feature-flags-remote.json": () => {
-        clearFeatureFlagOverridesCache();
-        onConversationEvict();
-      },
-      "secret-allowlist.json": () => {
-        resetAllowlist();
-        try {
-          const errors = validateAllowlistFile();
-          if (errors && errors.length > 0) {
-            for (const e of errors) {
-              log.warn(
-                { index: e.index, pattern: e.pattern },
-                `Invalid regex in secret-allowlist.json: ${e.message}`,
-              );
-            }
-          }
-        } catch (err) {
-          log.warn({ err }, "Failed to validate secret-allowlist.json");
-        }
-      },
-    };
-
     const watchDir = (
       dir: string,
       handlers: Record<string, () => void>,
@@ -210,13 +172,6 @@ export class ConfigWatcher {
       workspaceHandlers,
       "workspace directory for config/prompt changes",
     );
-    if (existsSync(protectedDir)) {
-      watchDir(
-        protectedDir,
-        protectedHandlers,
-        "protected directory for trust/allowlist changes",
-      );
-    }
 
     this.startSignalsWatcher();
     this.startSkillsWatchers(onConversationEvict);
@@ -242,10 +197,9 @@ export class ConfigWatcher {
 
     const exactSignalHandlers: Record<string, () => void | Promise<void>> = {
       cancel: handleCancelSignal,
-      confirm: handleConfirmationSignal,
       "mcp-reload": handleMcpReloadSignal,
-      "trust-rule": handleTrustRuleSignal,
       "conversation-undo": handleConversationUndoSignal,
+      "emit-event": handleEmitEventSignal,
     };
 
     const prefixSignalHandlers: Record<

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

@@ -60,6 +60,8 @@ export interface EventHandlerState {
   exchangeCacheCreationInputTokens: number;
   exchangeCacheReadInputTokens: number;
   exchangeOutputTokens: number;
+  /** Number of actual LLM API calls within this exchange. */
+  exchangeLlmCallCount: number;
   readonly exchangeRawResponses: unknown[];
   model: string;
   orderingErrorDetected: boolean;
@@ -100,6 +102,8 @@ export interface EventHandlerState {
   >;
   /** tool_use_ids emitted in the current turn (populated in handleToolUse, cleared after annotation). */
   currentTurnToolUseIds: string[];
+  /** Wall-clock time (ms since epoch) when the agent loop turn started, used as the display timestamp for assistant messages. */
+  turnStartedAt: number;
 }
 
 /** Immutable context shared across event handlers within a single agent loop run. */
@@ -127,6 +131,7 @@ export function createEventHandlerState(): EventHandlerState {
     exchangeCacheCreationInputTokens: 0,
     exchangeCacheReadInputTokens: 0,
     exchangeOutputTokens: 0,
+    exchangeLlmCallCount: 0,
     exchangeRawResponses: [],
     model: "",
     orderingErrorDetected: false,
@@ -151,6 +156,7 @@ export function createEventHandlerState(): EventHandlerState {
     requestIdToToolUseId: new Map(),
     toolConfirmationOutcomes: new Map(),
     currentTurnToolUseIds: [],
+    turnStartedAt: Date.now(),
   };
 }
 
@@ -267,7 +273,7 @@ export function handleThinkingDelta(
   }
   if (!deps.ctx.streamThinking) return;
   emitLlmCallStartedIfNeeded(state, deps);
-  deps.onEvent({ type: "assistant_thinking_delta", thinking: event.thinking });
+  deps.onEvent({ type: "assistant_thinking_delta", thinking: event.thinking, conversationId: deps.ctx.conversationId });
 }
 
 export function handleToolUse(
@@ -719,6 +725,7 @@ export async function handleMessageComplete(
     userMessageInterface: deps.turnInterfaceContext.userMessageInterface,
     assistantMessageInterface:
       deps.turnInterfaceContext.assistantMessageInterface,
+    sentAt: state.turnStartedAt,
   };
   const assistantMsg = await addMessage(
     deps.ctx.conversationId,
@@ -778,6 +785,7 @@ export function handleUsage(
 ): void {
   const providerName = event.actualProvider ?? deps.ctx.provider.name;
   state.exchangeProviderName = providerName;
+  state.exchangeLlmCallCount += 1;
   state.exchangeInputTokens += event.inputTokens;
   state.exchangeCacheCreationInputTokens += event.cacheCreationInputTokens ?? 0;
   state.exchangeCacheReadInputTokens += event.cacheReadInputTokens ?? 0;

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

@@ -1589,6 +1589,12 @@ export async function runAgentLoopImpl(
     const restoredHistory = [...preRepairMessages, ...newMessages];
     ctx.messages = stripInjectedContext(restoredHistory);
 
+    const postLoopContextEstimate = estimatePromptTokens(
+      ctx.messages,
+      ctx.systemPrompt,
+      { providerName: ctx.provider.name, toolTokenBudget },
+    );
+
     emitUsage(
       ctx,
       state.exchangeInputTokens,
@@ -1601,6 +1607,8 @@ export async function runAgentLoopImpl(
       state.exchangeCacheReadInputTokens,
       collapseRawResponses(state.exchangeRawResponses),
       state.exchangeProviderName,
+      state.exchangeLlmCallCount,
+      { tokens: postLoopContextEstimate, maxTokens: config.contextWindow.maxInputTokens },
     );
 
     void getHookManager().trigger("post-message", {
@@ -1868,6 +1876,8 @@ function emitUsage(
   cacheReadInputTokens = 0,
   rawResponse?: unknown,
   providerName?: string,
+  llmCallCount = 1,
+  contextWindow?: { tokens: number; maxTokens: number },
 ): void {
   recordUsage(
     {
@@ -1884,6 +1894,8 @@ function emitUsage(
     cacheCreationInputTokens,
     cacheReadInputTokens,
     rawResponse,
+    llmCallCount,
+    contextWindow,
   );
 }
 

package/src/daemon/conversation-error.ts

@@ -458,15 +458,13 @@ function classifyByMessage(
       .split("\n")
       .map((l) => l.trim())
       .find((l) => l.length > 0) ?? "";
-  const summary =
-    firstLine.length > 150 ? firstLine.slice(0, 150) + "..." : firstLine;
-  const userMessage = summary
-    ? `Processing failed: ${summary}`
+  const userMessage = firstLine
+    ? `Processing failed: ${firstLine}`
     : "Something went wrong processing your message. Please try again.";
   return {
     code: "CONVERSATION_PROCESSING_FAILED",
     userMessage,
-    retryable: false,
+    retryable: true,
     errorCategory: "processing_failed",
   };
 }

package/src/daemon/conversation-history.ts

@@ -10,6 +10,7 @@ import {
 } from "../memory/conversation-crud.js";
 import { isLastUserMessageToolResult } from "../memory/conversation-queries.js";
 import { enqueueMemoryJob } from "../memory/jobs-store.js";
+import { relinkLlmRequestLogs } from "../memory/llm-request-log-store.js";
 import { withQdrantBreaker } from "../memory/qdrant-circuit-breaker.js";
 import { getQdrantClient } from "../memory/qdrant-client.js";
 import type { ContentBlock, Message } from "../providers/types.js";
@@ -295,9 +296,10 @@ export function consolidateAssistantMessages(
     JSON.stringify(consolidatedContent),
   );
 
-  // Re-link attachments from messages about to be deleted to the consolidated
-  // message. Without this, ON DELETE CASCADE on message_attachments destroys
-  // the attachment links, and deleteOrphanAttachments removes the data.
+  // Re-link attachments and LLM request logs from messages about to be
+  // deleted to the consolidated message. Without this, ON DELETE CASCADE on
+  // message_attachments destroys the attachment links, and LLM call logs
+  // become orphaned (invisible in the context inspector).
   const messageIdsToDelete = [
     ...messagesToConsolidate.slice(1).map((m) => m.id),
     ...messagesToDelete,
@@ -313,6 +315,8 @@ export function consolidateAssistantMessages(
         "Re-linked attachments to consolidated message",
       );
     }
+
+    relinkLlmRequestLogs(messageIdsToDelete, firstAssistantMsg.id);
   }
 
   // Delete the other assistant messages and internal tool_result messages,

package/src/daemon/conversation-lifecycle.ts

@@ -9,11 +9,13 @@ 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,
   type MessageRow,
 } from "../memory/conversation-crud.js";
+import { enqueueMemoryJob } from "../memory/jobs-store.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { ContentBlock, Message } from "../providers/types.js";
@@ -266,6 +268,20 @@ export function disposeConversation(ctx: DisposeContext): void {
   void getHookManager().trigger("conversation-end", {
     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
+  }
+
   ctx.abort();
   unregisterCallNotifiers(ctx.conversationId);
   unregisterConversationSender(ctx.conversationId);

package/src/daemon/conversation-messaging.ts

@@ -247,6 +247,7 @@ export function enqueueMessage(
     turnInterfaceContext,
     isInteractive: options?.isInteractive,
     displayContent,
+    sentAt: Date.now(),
   });
   if (!accepted) {
     onEvent({