@vellumai/assistant 0.4.49 → 0.4.50

package/src/daemon/history-repair.ts

@@ -1,6 +1,7 @@
 import type {
   ContentBlock,
   Message,
+  ServerToolUseContent,
   ToolResultContent,
   ToolUseContent,
 } from "../providers/types.js";
@@ -20,6 +21,11 @@ export interface RepairResult {
 const SYNTHETIC_RESULT =
   "<synthesized_result>tool result missing from history</synthesized_result>";
 
+const SYNTHETIC_WEB_SEARCH_ERROR = {
+  type: "web_search_tool_result_error",
+  error_code: "unavailable",
+};
+
 export function repairHistory(messages: Message[]): RepairResult {
   const stats: RepairStats = {
     assistantToolResultsMigrated: 0,
@@ -45,12 +51,15 @@ export function repairHistory(messages: Message[]): RepairResult {
         recoveredResults = new Map();
       }
 
-      // Strip tool_result blocks from assistant messages, preserving them
-      // so they can be migrated to the correct user message position
+      // Strip client-side tool_result blocks from assistant messages,
+      // preserving them so they can be migrated to the correct user message.
+      // Server-side tools (server_tool_use / web_search_tool_result) are
+      // self-paired within the assistant message and must NOT be separated.
       const cleanedContent: ContentBlock[] = [];
       const newRecovered = new Map<string, ToolResultContent>();
       for (const block of msg.content) {
         if (block.type === "tool_result") {
+          // guard:allow-tool-result-only — only client-side tool_result belongs in recovered; web_search_tool_result stays in the assistant message
           const tr = block as ToolResultContent;
           newRecovered.set(tr.tool_use_id, tr);
           stats.assistantToolResultsMigrated++;
@@ -59,9 +68,34 @@ export function repairHistory(messages: Message[]): RepairResult {
         }
       }
 
+      // Ensure every server_tool_use has a paired web_search_tool_result
+      // in the same assistant message (handles interrupted streams)
+      const serverToolIds = new Set(
+        cleanedContent
+          .filter(
+            (b): b is ServerToolUseContent => b.type === "server_tool_use",
+          )
+          .map((b) => b.id),
+      );
+      const matchedServerIds = new Set(
+        cleanedContent
+          .filter((b) => b.type === "web_search_tool_result")
+          .map((b) => (b as { tool_use_id: string }).tool_use_id),
+      );
+      for (const id of serverToolIds) {
+        if (!matchedServerIds.has(id)) {
+          cleanedContent.push({
+            type: "web_search_tool_result",
+            tool_use_id: id,
+            content: SYNTHETIC_WEB_SEARCH_ERROR,
+          });
+          stats.missingToolResultsInserted++;
+        }
+      }
+
       result.push({ role: "assistant", content: cleanedContent });
 
-      // Collect tool_use IDs from this assistant message
+      // Only track client-side tool_use IDs as pending (not server_tool_use)
       pendingToolUseIds = new Set(
         cleanedContent
           .filter((b): b is ToolUseContent => b.type === "tool_use")
@@ -76,14 +110,28 @@ export function repairHistory(messages: Message[]): RepairResult {
 
         for (const block of msg.content) {
           if (block.type === "tool_result") {
+            // guard:allow-tool-result-only — matches client-side tool_use; web_search_tool_result is handled separately below
             const tr = block as ToolResultContent;
             if (pendingToolUseIds.has(tr.tool_use_id)) {
               matchedIds.add(tr.tool_use_id);
               newContent.push(block);
             } else {
               stats.orphanToolResultsDowngraded++;
-              newContent.push(downgradeToolResult(tr));
+              newContent.push(downgradeResult(tr));
             }
+          } else if (block.type === "web_search_tool_result") {
+            // web_search_tool_result in a user message is orphaned — server-side
+            // results belong in the assistant message, not here
+            stats.orphanToolResultsDowngraded++;
+            newContent.push(
+              downgradeResult(
+                block as {
+                  type: "web_search_tool_result";
+                  tool_use_id: string;
+                  content: unknown;
+                },
+              ),
+            );
           } else {
             newContent.push(block);
           }
@@ -112,11 +160,21 @@ export function repairHistory(messages: Message[]): RepairResult {
         pendingToolUseIds = new Set();
         recoveredResults = new Map();
       } else {
-        // No pending tool_use — any tool_result here is orphaned
+        // No pending tool_use — any tool_result/web_search_tool_result here is orphaned
         const newContent: ContentBlock[] = msg.content.map((block) => {
           if (block.type === "tool_result") {
             stats.orphanToolResultsDowngraded++;
-            return downgradeToolResult(block as ToolResultContent);
+            return downgradeResult(block as ToolResultContent);
+          }
+          if (block.type === "web_search_tool_result") {
+            stats.orphanToolResultsDowngraded++;
+            return downgradeResult(
+              block as {
+                type: "web_search_tool_result";
+                tool_use_id: string;
+                content: unknown;
+              },
+            );
           }
           return block;
         });
@@ -207,9 +265,15 @@ export function deepRepairHistory(messages: Message[]): RepairResult {
   return repairHistory(merged);
 }
 
-function downgradeToolResult(tr: ToolResultContent): ContentBlock {
+function downgradeResult(tr: {
+  type: string;
+  tool_use_id: string;
+  content?: unknown;
+}): ContentBlock {
+  const content =
+    tr.type === "tool_result" ? tr.content : "[web search result]"; // guard:allow-tool-result-only — distinguishes content format between the two types
   return {
     type: "text",
-    text: `[orphaned tool_result for ${tr.tool_use_id}]: ${tr.content}`,
+    text: `[orphaned ${tr.type} for ${tr.tool_use_id}]: ${content}`,
   };
 }

package/src/daemon/host-cu-proxy.ts

@@ -9,6 +9,7 @@
 
 import { v4 as uuid } from "uuid";
 
+import { escapeAxTreeContent } from "../agent/loop.js";
 import type { ContentBlock } from "../providers/types.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
@@ -65,6 +66,7 @@ interface PendingRequest {
 export class HostCuProxy {
   private pending = new Map<string, PendingRequest>();
   private sendToClient: (msg: ServerMessage) => void;
+  private onInternalResolve?: (requestId: string) => void;
   private clientConnected = false;
 
   // CU state tracking (per-conversation)
@@ -76,9 +78,11 @@ export class HostCuProxy {
 
   constructor(
     sendToClient: (msg: ServerMessage) => void,
+    onInternalResolve?: (requestId: string) => void,
     maxSteps = MAX_STEPS,
   ) {
     this.sendToClient = sendToClient;
+    this.onInternalResolve = onInternalResolve;
     this._maxSteps = maxSteps;
   }
 
@@ -150,6 +154,7 @@ export class HostCuProxy {
     return new Promise<ToolExecutionResult>((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(requestId);
+        this.onInternalResolve?.(requestId);
         log.warn({ requestId, toolName }, "Host CU proxy request timed out");
         resolve({
           content: "Host CU proxy timed out waiting for client response",
@@ -164,6 +169,7 @@ export class HostCuProxy {
           if (this.pending.has(requestId)) {
             clearTimeout(timer);
             this.pending.delete(requestId);
+            this.onInternalResolve?.(requestId);
             resolve({ content: "Aborted", isError: true });
           }
         };
@@ -191,10 +197,13 @@ export class HostCuProxy {
     clearTimeout(entry.timer);
     this.pending.delete(requestId);
 
+    // Capture pre-update state so formatObservation sees the correct previous AX tree
+    const prevAXTree = this._previousAXTree;
+
     // Update CU state from observation
     this.updateStateFromObservation(observation);
 
-    const result = this.formatObservation(observation);
+    const result = this.formatObservation(observation, prevAXTree);
     entry.resolve(result);
   }
 
@@ -202,6 +211,10 @@ export class HostCuProxy {
     return this.pending.has(requestId);
   }
 
+  isAvailable(): boolean {
+    return this.clientConnected;
+  }
+
   // ---------------------------------------------------------------------------
   // CU state management
   // ---------------------------------------------------------------------------
@@ -245,7 +258,11 @@ export class HostCuProxy {
    * (AX tree wrapped in markers, diff, warnings) and optional screenshot
    * as an image content block.
    */
-  formatObservation(obs: CuObservationResult): ToolExecutionResult {
+  formatObservation(
+    obs: CuObservationResult,
+    previousAXTree?: string,
+  ): ToolExecutionResult {
+    const prevTree = previousAXTree;
     const parts: string[] = [];
 
     // Surface user guidance prominently so the model sees it first
@@ -263,21 +280,30 @@ export class HostCuProxy {
     if (obs.axDiff) {
       parts.push(obs.axDiff);
       parts.push("");
-    } else if (this._previousAXTree != null && obs.axTree != null) {
-      // No diff means the screen didn't change
-      if (
-        this._consecutiveUnchangedSteps >=
-        CONSECUTIVE_UNCHANGED_WARNING_THRESHOLD
-      ) {
-        parts.push(
-          `WARNING: ${this._consecutiveUnchangedSteps} consecutive actions had NO VISIBLE EFFECT on the UI. You MUST try a completely different approach.`,
-        );
-      } else {
-        parts.push(
-          "Your last action had NO VISIBLE EFFECT on the UI. Try something different.",
-        );
+    } else if (prevTree != null && obs.axTree != null) {
+      // Skip unchanged warning after wait actions — they intentionally yield no immediate change
+      const lastAction =
+        this._actionHistory.length > 0
+          ? this._actionHistory[this._actionHistory.length - 1]
+          : undefined;
+      const isWaitAction = lastAction?.toolName === "computer_use_wait";
+
+      if (!isWaitAction) {
+        // No diff means the screen didn't change
+        if (
+          this._consecutiveUnchangedSteps >=
+          CONSECUTIVE_UNCHANGED_WARNING_THRESHOLD
+        ) {
+          parts.push(
+            `WARNING: ${this._consecutiveUnchangedSteps} consecutive actions had NO VISIBLE EFFECT on the UI. You MUST try a completely different approach.`,
+          );
+        } else {
+          parts.push(
+            "Your last action had NO VISIBLE EFFECT on the UI. Try something different.",
+          );
+        }
+        parts.push("");
       }
-      parts.push("");
     }
 
     // Loop detection: identical actions repeated
@@ -300,10 +326,20 @@ export class HostCuProxy {
     if (obs.axTree) {
       parts.push("<ax-tree>");
       parts.push("CURRENT SCREEN STATE:");
-      parts.push(HostCuProxy.escapeAxTreeContent(obs.axTree));
+      parts.push(escapeAxTreeContent(obs.axTree));
       parts.push("</ax-tree>");
     }
 
+    // Secondary windows for cross-app awareness
+    if (obs.secondaryWindows) {
+      parts.push("");
+      parts.push(obs.secondaryWindows);
+      parts.push("");
+      parts.push(
+        "Note: The element [ID]s above are from other windows — you can reference them for context but can only interact with the focused window's elements.",
+      );
+    }
+
     // Screenshot metadata
     const screenshotMeta = this.formatScreenshotMetadata(obs);
     if (screenshotMeta.length > 0) {
@@ -342,8 +378,9 @@ export class HostCuProxy {
   // ---------------------------------------------------------------------------
 
   dispose(): void {
-    for (const [_requestId, entry] of this.pending) {
+    for (const [requestId, entry] of this.pending) {
       clearTimeout(entry.timer);
+      this.onInternalResolve?.(requestId);
       entry.reject(
         new AssistantError("Host CU proxy disposed", ErrorCode.INTERNAL_ERROR),
       );
@@ -390,12 +427,4 @@ export class HostCuProxy {
     }
     return lines;
   }
-
-  /**
-   * Escapes literal `</ax-tree>` inside AX tree content so compaction
-   * regex does not stop prematurely.
-   */
-  static escapeAxTreeContent(content: string): string {
-    return content.replace(/<\/ax-tree>/gi, "&lt;/ax-tree&gt;");
-  }
 }

package/src/daemon/lifecycle.ts

@@ -26,13 +26,18 @@ import { closeSentry, initSentry } from "../instrument.js";
 import { disableLogfire, initLogfire } from "../logfire.js";
 import { getMcpServerManager } from "../mcp/manager.js";
 import * as attachmentsStore from "../memory/attachments-store.js";
+import { expireAllPendingCanonicalRequests } from "../memory/canonical-guardian-store.js";
 import {
   deleteMessageById,
   getConversationThreadType,
   getMessages,
 } from "../memory/conversation-crud.js";
 import { initializeDb } from "../memory/db.js";
-import { selectEmbeddingBackend } from "../memory/embedding-backend.js";
+import {
+  selectEmbeddingBackend,
+  SPARSE_EMBEDDING_VERSION,
+} from "../memory/embedding-backend.js";
+import { enqueueMemoryJob } from "../memory/jobs-store.js";
 import { startMemoryJobsWorker } from "../memory/jobs-worker.js";
 import { initQdrantClient } from "../memory/qdrant-client.js";
 import { QdrantManager } from "../memory/qdrant-manager.js";
@@ -165,6 +170,18 @@ export async function runDaemon(): Promise<void> {
     await backfillManualTokenConnections();
     log.info("Daemon startup: DB initialized");
 
+    // Expire any pending canonical guardian requests left over from before
+    // this process started.  Their in-memory pending-interaction session
+    // references are gone, so they can never be completed.  The agent loop
+    // will re-request tool approvals on the next turn.
+    const expiredCount = expireAllPendingCanonicalRequests();
+    if (expiredCount > 0) {
+      log.info(
+        { event: "startup_expired_stale_requests", expiredCount },
+        `Expired ${expiredCount} stale pending canonical request(s) from previous process`,
+      );
+    }
+
     // Ensure a vellum guardian binding exists and mint the CLI edge token
     // as an actor token bound to the guardian principal.
     let guardianPrincipalId: string | undefined;
@@ -305,9 +322,9 @@ export async function runDaemon(): Promise<void> {
       await qdrantManager.start();
       const embeddingSelection = selectEmbeddingBackend(config);
       const embeddingModel = embeddingSelection.backend
-        ? `${embeddingSelection.backend.provider}:${embeddingSelection.backend.model}`
+        ? `${embeddingSelection.backend.provider}:${embeddingSelection.backend.model}:sparse-v${SPARSE_EMBEDDING_VERSION}`
         : undefined;
-      initQdrantClient({
+      const qdrantClient = initQdrantClient({
         url: qdrantUrl,
         collection: config.memory.qdrant.collection,
         vectorSize: config.memory.qdrant.vectorSize,
@@ -315,6 +332,17 @@ export async function runDaemon(): Promise<void> {
         quantization: config.memory.qdrant.quantization,
         embeddingModel,
       });
+
+      // Eagerly ensure the collection exists so we detect migrations
+      // (unnamed→named vectors, dimension/model changes) at startup.
+      // If a destructive migration occurred, enqueue a rebuild_index job
+      // to re-embed all memory items from the SQLite cache.
+      const { migrated } = await qdrantClient.ensureCollection();
+      if (migrated) {
+        enqueueMemoryJob("rebuild_index", {});
+        log.info("Qdrant collection was migrated — enqueued rebuild_index job");
+      }
+
       log.info("Qdrant vector store initialized");
     } catch (err) {
       log.warn(

package/src/daemon/mcp-reload-service.ts

@@ -1,8 +1,8 @@
 /**
  * Shared MCP reload business logic.
  *
- * Used by the HTTP route (`runtime/routes/mcp-routes.ts`) so the reload
- * behaviour is defined in exactly one place.
+ * Called by the ConfigWatcher when config.json changes or a reload signal
+ * file is detected, so the daemon automatically reconnects MCP servers.
  */
 
 import { getConfig, invalidateConfigCache } from "../config/loader.js";

package/src/daemon/message-types/computer-use.ts

@@ -1,4 +1,4 @@
-// Computer use, task routing, and watch observation types.
+// Computer use and watch observation types.
 
 import type { CommandIntent, UserMessageAttachment } from "./shared.js";
 
@@ -89,16 +89,6 @@ export interface RecordingResume {
   recordingId: string;
 }
 
-export interface TaskRouted {
-  type: "task_routed";
-  sessionId: string;
-  interactionType: "computer_use" | "text_qa";
-  /** The task text passed to the escalated session. */
-  task?: string;
-  /** Set when a text_qa session escalates to computer_use. */
-  escalatedFrom?: string;
-}
-
 export interface WatchStarted {
   type: "watch_started";
   sessionId: string;
@@ -121,7 +111,6 @@ export type _ComputerUseClientMessages =
   | RecordingStatus;
 
 export type _ComputerUseServerMessages =
-  | TaskRouted
   | WatchStarted
   | WatchCompleteRequest
   | RecordingStart

package/src/daemon/message-types/memory.ts

@@ -11,7 +11,6 @@ export interface MemoryRecalledCandidateDebug {
   type: string;
   kind: string;
   finalScore: number;
-  lexical: number;
   semantic: number;
   recency: number;
 }
@@ -21,18 +20,14 @@ export interface MemoryRecalled {
   provider: string;
   model: string;
   degradation?: MemoryRecalledDegradation;
-  lexicalHits: number;
   semanticHits: number;
   recencyHits: number;
-  entityHits: number;
-  relationSeedEntityCount?: number;
-  relationTraversedEdgeCount?: number;
-  relationNeighborEntityCount?: number;
-  relationExpandedItemCount?: number;
-  earlyTerminated?: boolean;
+  tier1Count: number;
+  tier2Count: number;
+  hybridSearchLatencyMs: number;
+  sparseVectorUsed: boolean;
   mergedCount: number;
   selectedCount: number;
-  rerankApplied: boolean;
   injectedTokens: number;
   latencyMs: number;
   topCandidates: MemoryRecalledCandidateDebug[];
@@ -46,13 +41,6 @@ export interface MemoryStatus {
   reason?: string;
   provider?: string;
   model?: string;
-  conflictsPending: number;
-  conflictsResolved: number;
-  oldestPendingConflictAgeMs: number | null;
-  cleanupResolvedJobsPending: number;
-  cleanupSupersededJobsPending: number;
-  cleanupResolvedJobsCompleted24h: number;
-  cleanupSupersededJobsCompleted24h: number;
 }
 
 // --- Domain-level union aliases (consumed by the barrel file) ---

package/src/daemon/message-types/messages.ts

@@ -290,6 +290,7 @@ export interface AssistantActivityState {
     | "tool_result_received"
     | "confirmation_requested"
     | "confirmation_resolved"
+    | "context_compacting"
     | "message_complete"
     | "generation_cancelled"
     | "error_terminal";

package/src/daemon/message-types/sessions.ts

@@ -394,6 +394,8 @@ export type SessionErrorCode =
   | "PROVIDER_RATE_LIMIT"
   | "PROVIDER_API"
   | "PROVIDER_BILLING"
+  | "PROVIDER_ORDERING"
+  | "PROVIDER_WEB_SEARCH"
   | "CONTEXT_TOO_LARGE"
   | "SESSION_ABORTED"
   | "SESSION_PROCESSING_FAILED"
@@ -407,6 +409,8 @@ export interface SessionErrorMessage {
   userMessage: string;
   retryable: boolean;
   debugDetails?: string;
+  /** Machine-readable error category for log report metadata and triage. */
+  errorCategory?: string;
 }
 
 /** Server push — broadcast when a schedule creates a conversation, so the client can show it as a chat thread. */

package/src/daemon/server.ts

@@ -58,6 +58,7 @@ import type { SkillOperationContext } from "./handlers/skills.js";
 import { HostBashProxy } from "./host-bash-proxy.js";
 import { HostCuProxy } from "./host-cu-proxy.js";
 import { HostFileProxy } from "./host-file-proxy.js";
+import { reloadMcpServers } from "./mcp-reload-service.js";
 import type { ServerMessage } from "./message-protocol.js";
 import {
   DEFAULT_MEMORY_POLICY,
@@ -392,6 +393,11 @@ export class DaemonServer {
     this.configWatcher.start(
       () => this.evictSessionsForReload(),
       () => this.broadcastIdentityChanged(),
+      () => {
+        reloadMcpServers().catch((err: unknown) => {
+          log.error({ err }, "MCP reload triggered by config change failed");
+        });
+      },
     );
 
     // Broadcast contacts_changed to all clients when any contact mutation occurs.
@@ -663,8 +669,13 @@ export class DaemonServer {
         );
       }
       if (!session.isProcessing() || !session.hostCuProxy) {
-        session.setHostCuProxy(new HostCuProxy(session.getCurrentSender()));
+        session.setHostCuProxy(
+          new HostCuProxy(session.getCurrentSender(), (requestId) => {
+            pendingInteractions.resolve(requestId);
+          }),
+        );
       }
+      session.addPreactivatedSkillId("computer-use");
     } else if (!session.isProcessing()) {
       session.setHostBashProxy(undefined);
       session.setHostFileProxy(undefined);

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

@@ -57,6 +57,8 @@ export interface EventHandlerState {
   orderingErrorDetected: boolean;
   deferredOrderingError: string | null;
   contextTooLargeDetected: boolean;
+  /** The raw error message from the provider when context_too_large is detected. */
+  contextTooLargeErrorMessage: string | null;
   providerErrorUserMessage: string | null;
   lastAssistantMessageId: string | undefined;
   readonly pendingToolResults: Map<string, PendingToolResult>;
@@ -121,6 +123,7 @@ export function createEventHandlerState(): EventHandlerState {
     orderingErrorDetected: false,
     deferredOrderingError: null,
     contextTooLargeDetected: false,
+    contextTooLargeErrorMessage: null,
     providerErrorUserMessage: null,
     lastAssistantMessageId: undefined,
     pendingToolResults: new Map(),
@@ -595,12 +598,22 @@ export function handleError(
     state.deferredOrderingError = event.error.message;
   } else if (isContextTooLarge(event.error.message)) {
     state.contextTooLargeDetected = true;
+    state.contextTooLargeErrorMessage = event.error.message;
   } else {
     const classified = classifySessionError(event.error, {
       phase: "agent_loop",
     });
     if (classified.code === "CONTEXT_TOO_LARGE") {
       state.contextTooLargeDetected = true;
+      state.contextTooLargeErrorMessage = event.error.message;
+    } else if (
+      classified.code === "PROVIDER_ORDERING" ||
+      classified.code === "PROVIDER_WEB_SEARCH"
+    ) {
+      // Ordering errors detected via classifySessionError (e.g. from ProviderError
+      // with statusCode 400 and ordering message) — trigger the retry path.
+      state.orderingErrorDetected = true;
+      state.deferredOrderingError = event.error.message;
     } else {
       deps.onEvent(
         buildSessionErrorMessage(deps.ctx.conversationId, classified),
@@ -831,6 +844,31 @@ export async function dispatchAgentEvent(
         deps.reqId,
         statusText,
       );
+      // Emit tool_use_start so the client renders a tool chip (like other tools)
+      deps.onEvent({
+        type: "tool_use_start",
+        toolName: event.name,
+        input: event.input,
+        sessionId: deps.ctx.conversationId,
+        toolUseId: event.toolUseId,
+      });
+      break;
+    }
+    case "server_tool_complete": {
+      deps.ctx.emitActivityState(
+        "streaming",
+        "tool_result_received",
+        "assistant_turn",
+        deps.reqId,
+      );
+      deps.onEvent({
+        type: "tool_result",
+        toolName: "",
+        result: "",
+        isError: false,
+        sessionId: deps.ctx.conversationId,
+        toolUseId: event.toolUseId,
+      });
       break;
     }
     case "error":