@vellumai/assistant 0.3.15 → 0.3.16

package/src/daemon/recording-intent.ts

@@ -7,8 +7,6 @@
 // Internal helpers (detect/strip/classify) are kept as private utilities
 // consumed only by `resolveRecordingIntent`.
 
-type RecordingIntentClass = 'start_only' | 'stop_only' | 'mixed' | 'none';
-
 export type RecordingIntentResult =
   | { kind: 'none' }
   | { kind: 'start_only' }
@@ -370,45 +368,6 @@ function isInterrogative(text: string, dynamicNames?: string[]): boolean {
   return false;
 }
 
-// ─── Unified classification ─────────────────────────────────────────────────
-
-/**
- * Classifies the recording intent of a user message into one of four categories:
- * - 'start_only': the prompt is purely about starting a recording
- * - 'stop_only': the prompt is purely about stopping a recording
- * - 'mixed': the prompt contains recording intent mixed with other tasks,
- *            or contains both start and stop recording patterns
- * - 'none': no recording intent detected
- *
- * If `dynamicNames` are provided, they are stripped from the beginning of the
- * text before classification (e.g., "Nova, record my screen" -> "record my screen").
- */
-function _classifyRecordingIntent(
-  taskText: string,
-  dynamicNames?: string[],
-): RecordingIntentClass {
-  const normalized =
-    dynamicNames && dynamicNames.length > 0
-      ? stripDynamicNames(taskText, dynamicNames)
-      : taskText;
-
-  const hasStart = detectRecordingIntent(normalized);
-  const hasStop = detectStopRecordingIntent(normalized);
-
-  // Both start and stop patterns present -> mixed
-  if (hasStart && hasStop) return 'mixed';
-
-  if (hasStop) {
-    return isStopRecordingOnly(normalized) ? 'stop_only' : 'mixed';
-  }
-
-  if (hasStart) {
-    return isRecordingOnly(normalized) ? 'start_only' : 'mixed';
-  }
-
-  return 'none';
-}
-
 // ─── Structured intent resolver ─────────────────────────────────────────────
 
 /**

package/src/daemon/response-tier.ts

@@ -226,12 +226,12 @@ export function tierMaxTokens(tier: ResponseTier, configuredMax: number): number
 
 /**
  * Map for Anthropic provider: tier → model.
- *   low    → haiku (fastest TTFT)
+ *   low    → sonnet (balanced)
  *   medium → sonnet (balanced)
  *   high   → undefined (use configured default, typically opus)
  */
 const ANTHROPIC_TIER_MODELS: Record<ResponseTier, string | undefined> = {
-  low: 'claude-haiku-4-5-20251001',
+  low: 'claude-sonnet-4-6',
   medium: 'claude-sonnet-4-6',
   high: undefined, // use configured default
 };

package/src/daemon/server.ts

@@ -188,7 +188,7 @@ export class DaemonServer {
       const children = getSubagentManager().getChildrenOf(sessionId);
       return children.some((c) => c.status === 'running' || c.status === 'pending');
     };
-    getSubagentManager().onSubagentFinished = (parentSessionId, message, sendToClient, notification) => {
+    getSubagentManager().onSubagentFinished = async (parentSessionId, message, sendToClient, notification) => {
       const parentSession = this.sessions.get(parentSessionId);
       if (!parentSession) {
         log.warn({ parentSessionId }, 'Subagent finished but parent session not found');
@@ -202,7 +202,7 @@ export class DaemonServer {
         return;
       }
       if (!enqueueResult.queued) {
-        const messageId = parentSession.persistUserMessage(message, [], undefined, metadata);
+        const messageId = await parentSession.persistUserMessage(message, [], undefined, metadata);
         parentSession.runAgentLoop(message, messageId, sendToClient).catch((err) => {
           log.error({ parentSessionId, err }, 'Failed to process subagent notification in parent');
         });
@@ -809,7 +809,7 @@ export class DaemonServer {
     );
 
     const requestId = crypto.randomUUID();
-    const messageId = session.persistUserMessage(content, attachments, requestId);
+    const messageId = await session.persistUserMessage(content, attachments, requestId);
 
     // Register pending interactions so channel approval interception can
     // find the session by requestId when confirmation/secret events fire.
@@ -865,7 +865,7 @@ export class DaemonServer {
           : {}),
       };
       const userMsg = createUserMessage(content, attachments);
-      const persisted = conversationStore.addMessage(
+      const persisted = await conversationStore.addMessage(
         conversationId,
         'user',
         JSON.stringify(userMsg.content),
@@ -889,7 +889,7 @@ export class DaemonServer {
       }
 
       const assistantMsg = createAssistantMessage(slashResult.message);
-      conversationStore.addMessage(
+      await conversationStore.addMessage(
         conversationId,
         'assistant',
         JSON.stringify(assistantMsg.content),
@@ -908,7 +908,7 @@ export class DaemonServer {
     const requestId = crypto.randomUUID();
     let messageId: string;
     try {
-      messageId = session.persistUserMessage(resolvedContent, attachments, requestId);
+      messageId = await session.persistUserMessage(resolvedContent, attachments, requestId);
     } catch (err) {
       session.setPreactivatedSkillIds(undefined);
       throw err;

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

@@ -104,6 +104,26 @@ export function emitLlmCallStartedIfNeeded(
   });
 }
 
+// ── IPC Size Caps ────────────────────────────────────────────────────
+// The client truncates tool results anyway (2 000 chars in ChatViewModel),
+// but the full string can be megabytes (file_read, bash output). Capping
+// here avoids sending oversized payloads over IPC which get decoded on
+// the client's main thread.
+
+const TOOL_RESULT_MAX_CHARS = 2_000;
+const TOOL_RESULT_TRUNCATION_SUFFIX = '...[truncated]';
+
+// tool_input_delta streams accumulated JSON as tools run. For non-app
+// tools the client discards it (extractCodePreview only handles app tools),
+// so we cap it aggressively to avoid excessive IPC traffic.
+const TOOL_INPUT_DELTA_MAX_CHARS = 50_000;
+const APP_TOOL_NAMES = new Set(['app_create', 'app_update']);
+
+function truncateForIpc(value: string, maxChars: number, suffix: string): string {
+  if (value.length <= maxChars) return value;
+  return value.slice(0, maxChars - suffix.length) + suffix;
+}
+
 // ── Individual Handlers ──────────────────────────────────────────────
 
 export function handleTextDelta(
@@ -194,7 +214,12 @@ export function handleInputJsonDelta(
   deps: EventHandlerDeps,
   event: Extract<AgentEvent, { type: 'input_json_delta' }>,
 ): void {
-  deps.onEvent({ type: 'tool_input_delta', toolName: event.toolName, content: event.accumulatedJson, sessionId: deps.ctx.conversationId });
+  // Cap non-app tool input deltas — the client only uses this data for
+  // app_create/app_update code previews; all other tools discard it.
+  const content = APP_TOOL_NAMES.has(event.toolName)
+    ? event.accumulatedJson
+    : truncateForIpc(event.accumulatedJson, TOOL_INPUT_DELTA_MAX_CHARS, TOOL_RESULT_TRUNCATION_SUFFIX);
+  deps.onEvent({ type: 'tool_input_delta', toolName: event.toolName, content, sessionId: deps.ctx.conversationId });
 }
 
 export function handleToolResult(
@@ -206,7 +231,7 @@ export function handleToolResult(
   deps.onEvent({
     type: 'tool_result',
     toolName: '',
-    result: event.content,
+    result: truncateForIpc(event.content, TOOL_RESULT_MAX_CHARS, TOOL_RESULT_TRUNCATION_SUFFIX),
     isError: event.isError,
     diff: event.diff,
     status: event.status,
@@ -256,11 +281,11 @@ export function handleError(
   }
 }
 
-export function handleMessageComplete(
+export async function handleMessageComplete(
   state: EventHandlerState,
   deps: EventHandlerDeps,
   event: Extract<AgentEvent, { type: 'message_complete' }>,
-): void {
+): Promise<void> {
   // Flush any remaining directive display buffer
   if (state.pendingDirectiveDisplayBuffer.length > 0) {
     deps.onEvent({
@@ -290,7 +315,7 @@ export function handleMessageComplete(
       userMessageInterface: deps.turnInterfaceContext.userMessageInterface,
       assistantMessageInterface: deps.turnInterfaceContext.assistantMessageInterface,
     };
-    conversationStore.addMessage(
+    await conversationStore.addMessage(
       deps.ctx.conversationId,
       'user',
       JSON.stringify(toolResultBlocks),
@@ -335,7 +360,7 @@ export function handleMessageComplete(
     userMessageInterface: deps.turnInterfaceContext.userMessageInterface,
     assistantMessageInterface: deps.turnInterfaceContext.assistantMessageInterface,
   };
-  const assistantMsg = conversationStore.addMessage(
+  const assistantMsg = await conversationStore.addMessage(
     deps.ctx.conversationId,
     'assistant',
     JSON.stringify(contentWithSurfaces),
@@ -399,11 +424,11 @@ export function handleUsage(
 // ── Dispatcher ───────────────────────────────────────────────────────
 
 /** Routes an AgentEvent to the appropriate handler. */
-export function dispatchAgentEvent(
+export async function dispatchAgentEvent(
   state: EventHandlerState,
   deps: EventHandlerDeps,
   event: AgentEvent,
-): void {
+): Promise<void> {
   switch (event.type) {
     case 'text_delta':
       handleTextDelta(state, deps, event);
@@ -427,7 +452,7 @@ export function dispatchAgentEvent(
       handleError(state, deps, event);
       break;
     case 'message_complete':
-      handleMessageComplete(state, deps, event);
+      await handleMessageComplete(state, deps, event);
       break;
     case 'usage':
       handleUsage(state, deps, event);

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

@@ -34,7 +34,7 @@ import {
   type AssistantAttachmentDraft,
   cleanAssistantContent,
 } from './assistant-attachments.js';
-import { buildTemporalContext } from './date-context.js';
+import { buildTemporalContext, extractUserTimeZoneFromDynamicProfile } from './date-context.js';
 import { deepRepairHistory,repairHistory } from './history-repair.js';
 import type { DynamicPageSurfaceData,ServerMessage, SurfaceData, SurfaceType, UsageStats } from './ipc-protocol.js';
 import {
@@ -132,7 +132,7 @@ export interface AgentLoopSessionContext {
   getQueueDepth(): number;
   hasQueuedMessages(): boolean;
   canHandoffAtCheckpoint(): boolean;
-  drainQueue(reason: QueueDrainReason): void;
+  drainQueue(reason: QueueDrainReason): Promise<void>;
   getTurnChannelContext(): TurnChannelContext | null;
   getTurnInterfaceContext(): TurnInterfaceContext | null;
 }
@@ -144,7 +144,7 @@ export async function runAgentLoopImpl(
   content: string,
   userMessageId: string,
   onEvent: (msg: ServerMessage) => void,
-  options?: { skipPreMessageRollback?: boolean; isInteractive?: boolean },
+  options?: { skipPreMessageRollback?: boolean; isInteractive?: boolean; titleText?: string },
 ): Promise<void> {
   if (!ctx.abortController) {
     throw new Error('runAgentLoop called without prior persistUserMessage');
@@ -272,7 +272,7 @@ export async function runAgentLoopImpl(
         assistantMessageInterface: capturedTurnInterfaceContext.assistantMessageInterface,
       };
       const assistantMessage = createAssistantMessage(memoryResult.conflictClarification);
-      conversationStore.addMessage(
+      await conversationStore.addMessage(
         ctx.conversationId,
         'assistant',
         JSON.stringify(assistantMessage.content),
@@ -325,8 +325,15 @@ export async function runAgentLoopImpl(
     ctx.refreshWorkspaceTopLevelContextIfNeeded();
 
     // Compute fresh temporal context each turn for date grounding.
+    // Absolute "now" is always anchored to assistant host clock, while local
+    // date semantics prefer configured user timezone, then profile memory.
+    const hostTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const userTimeZone = extractUserTimeZoneFromDynamicProfile(dynamicProfile.text);
+    const configuredUserTimeZone = getConfig().ui.userTimezone ?? null;
     const temporalContext = buildTemporalContext({
-      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      hostTimeZone,
+      configuredUserTimeZone,
+      userTimeZone,
     });
 
     // Use the channel/interface context captured at the top of this function
@@ -584,7 +591,7 @@ export async function runAgentLoopImpl(
         userMessageInterface: capturedTurnInterfaceContext.userMessageInterface,
         assistantMessageInterface: capturedTurnInterfaceContext.assistantMessageInterface,
       };
-      conversationStore.addMessage(
+      await conversationStore.addMessage(
         ctx.conversationId,
         'user',
         JSON.stringify(toolResultBlocks),
@@ -610,7 +617,7 @@ export async function runAgentLoopImpl(
         assistantMessageInterface: capturedTurnInterfaceContext.assistantMessageInterface,
       };
       const errorAssistantMessage = createAssistantMessage(state.providerErrorUserMessage);
-      conversationStore.addMessage(
+      await conversationStore.addMessage(
         ctx.conversationId,
         'assistant',
         JSON.stringify(errorAssistantMessage.content),
@@ -695,7 +702,7 @@ export async function runAgentLoopImpl(
       queueGenerateConversationTitle({
         conversationId: ctx.conversationId,
         provider: ctx.provider,
-        userMessage: content,
+        userMessage: options?.titleText ?? content,
         assistantResponse: state.firstAssistantText || undefined,
         onTitleUpdated: (title) => {
           onEvent({

package/src/daemon/session-history.ts

@@ -3,6 +3,7 @@ import { v4 as uuid } from 'uuid';
 import { getSummaryFromContextMessage } from '../context/window-manager.js';
 import * as conversationStore from '../memory/conversation-store.js';
 import { enqueueMemoryJob } from '../memory/jobs-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';
 import { getLogger } from '../util/logger.js';
@@ -67,7 +68,7 @@ export async function cleanupQdrantVectors(
   }
 
   const results = await Promise.allSettled(
-    targets.map((t) => qdrant.deleteByTarget(t.targetType, t.targetId)),
+    targets.map((t) => withQdrantBreaker(() => qdrant.deleteByTarget(t.targetType, t.targetId))),
   );
 
   let succeeded = 0;
@@ -263,7 +264,7 @@ export interface HistorySessionContext {
     content: string,
     userMessageId: string,
     onEvent: (msg: ServerMessage) => void,
-    options?: { skipPreMessageRollback?: boolean },
+    options?: { skipPreMessageRollback?: boolean; titleText?: string },
   ): Promise<void>;
 }
 

package/src/daemon/session-media-retry.ts

@@ -30,6 +30,9 @@ export function stripMediaPayloadsForRetry(messages: Message[]): { messages: Mes
   const nextMessages = messages.map((msg, msgIndex) => {
     const nextContent: ContentBlock[] = [];
     for (const block of msg.content) {
+      // Top-level image blocks are user-uploaded attachments. Keep the latest
+      // few (in the most recent user message) and strip older ones so the
+      // retry can actually reduce context size when images are the cause.
       if (block.type === 'image') {
         const keep = latestUserIndex === msgIndex && keptLatestMediaBlocks < RETRY_KEEP_LATEST_MEDIA_BLOCKS;
         if (keep) {

package/src/daemon/session-messaging.ts

@@ -10,6 +10,7 @@ import { v4 as uuid } from 'uuid';
 import { createUserMessage } from '../agent/message-types.js';
 import type { TurnChannelContext, TurnInterfaceContext } from '../channels/types.js';
 import { parseChannelId, parseInterfaceId } from '../channels/types.js';
+import { AttachmentUploadError, linkAttachmentToMessage, uploadAttachment, validateAttachmentUpload } from '../memory/attachments-store.js';
 import * as conversationStore from '../memory/conversation-store.js';
 import { provenanceFromGuardianContext } from '../memory/conversation-store.js';
 import type { SecretPrompter } from '../permissions/secret-prompter.js';
@@ -124,6 +125,7 @@ export function enqueueMessage(
   currentPage?: string,
   metadata?: Record<string, unknown>,
   options?: { isInteractive?: boolean },
+  displayContent?: string,
 ): { queued: boolean; rejected?: boolean; requestId: string } {
   if (!ctx.processing) {
     return { queued: false, requestId };
@@ -143,6 +145,7 @@ export function enqueueMessage(
     turnInterfaceContext,
     isInteractive: options?.isInteractive,
     queuedAt: Date.now(),
+    displayContent,
   });
   if (!pushed) {
     return { queued: false, rejected: true, requestId };
@@ -152,13 +155,14 @@ export function enqueueMessage(
 
 // ── persistUserMessage ───────────────────────────────────────────────
 
-export function persistUserMessage(
+export async function persistUserMessage(
   ctx: MessagingSessionContext,
   content: string,
   attachments: UserMessageAttachment[],
   requestId?: string,
   metadata?: Record<string, unknown>,
-): string {
+  displayContent?: string,
+): Promise<string> {
   if (ctx.processing) {
     throw new Error('Session is already processing a message');
   }
@@ -202,10 +206,19 @@ export function persistUserMessage(
         : {}),
     };
 
-    const persistedUserMessage = conversationStore.addMessage(
+    // When displayContent is provided (e.g. original text before recording
+    // intent stripping), persist that to DB so users see the full message
+    // after restart. The in-memory userMessage (sent to the LLM) still uses
+    // the stripped content.
+    const contentToPersist = displayContent
+      ? JSON.stringify(createUserMessage(displayContent, attachments.map((a) => ({
+          id: a.id, filename: a.filename, mimeType: a.mimeType, data: a.data, extractedText: a.extractedText,
+        }))).content)
+      : JSON.stringify(userMessage.content);
+    const persistedUserMessage = await conversationStore.addMessage(
       ctx.conversationId,
       'user',
-      JSON.stringify(userMessage.content),
+      contentToPersist,
       mergedMetadata,
     );
 
@@ -220,6 +233,27 @@ export function persistUserMessage(
       throw new Error('Failed to persist user message');
     }
 
+    // Index user attachments in the attachments table so asset_search can find them.
+    for (let i = 0; i < attachments.length; i++) {
+      const a = attachments[i];
+      if (!a.data) continue;
+      try {
+        const validation = validateAttachmentUpload(a.filename, a.mimeType);
+        if (!validation.ok) {
+          log.warn({ filename: a.filename, error: validation.error }, 'Skipping user attachment indexing: validation failed');
+          continue;
+        }
+        const stored = uploadAttachment(a.filename, a.mimeType, a.data);
+        linkAttachmentToMessage(persistedUserMessage.id, stored.id, i);
+      } catch (err) {
+        if (err instanceof AttachmentUploadError) {
+          log.warn({ filename: a.filename, error: err.message }, 'Skipping user attachment indexing');
+        } else {
+          log.error({ filename: a.filename, err }, 'Failed to index user attachment');
+        }
+      }
+    }
+
     return persistedUserMessage.id;
   } catch (err) {
     ctx.messages.pop();

package/src/daemon/session-notifiers.ts

@@ -96,12 +96,12 @@ export function registerSessionNotifiers(
     }
   });
 
-  registerCallQuestionNotifier(conversationId, (callSessionId: string, question: string) => {
+  registerCallQuestionNotifier(conversationId, async (callSessionId: string, question: string) => {
     const callSession = getCallSession(callSessionId);
     const callee = callSession?.toNumber ?? 'the caller';
     const questionText = `**Live call question** (to ${callee}):\n\n${question}\n\n_Use the call answer API to respond._`;
 
-    conversationStore.addMessage(
+    await conversationStore.addMessage(
       conversationId,
       'assistant',
       JSON.stringify([{ type: 'text', text: questionText }]),