@vellumai/assistant 0.5.2 → 0.5.4

package/src/daemon/conversation.ts

@@ -38,7 +38,6 @@ import {
 import { registerToolTraceListener } from "../events/tool-trace-listener.js";
 import { getHookManager } from "../hooks/manager.js";
 import { resolveCanonicalGuardianRequest } from "../memory/canonical-guardian-store.js";
-import { getMessages } from "../memory/conversation-crud.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { SecretPrompter } from "../permissions/secret-prompter.js";
 import { patternMatchesCandidate } from "../permissions/trust-store.js";
@@ -196,13 +195,24 @@ export class Conversation {
   >();
   /** @internal */ surfaceState = new Map<
     string,
-    { surfaceType: SurfaceType; data: SurfaceData; title?: string }
+    {
+      surfaceType: SurfaceType;
+      data: SurfaceData;
+      title?: string;
+      actions?: Array<{
+        id: string;
+        label: string;
+        style?: string;
+        data?: Record<string, unknown>;
+      }>;
+    }
   >();
   /** @internal */ surfaceUndoStacks = new Map<string, string[]>();
   /** @internal */ accumulatedSurfaceState = new Map<
     string,
     Record<string, unknown>
   >();
+  /** @internal */ broadcastToAllClients?: (msg: ServerMessage) => void;
   /** @internal */ withSurface = createSurfaceMutex();
   /** @internal */ currentTurnSurfaces: Array<{
     surfaceId: string;
@@ -249,6 +259,7 @@ export class Conversation {
     this.provider = provider;
     this.workingDir = workingDir;
     this.sendToClient = sendToClient;
+    this.broadcastToAllClients = broadcastToAllClients;
     this.memoryPolicy = memoryPolicy
       ? { ...memoryPolicy }
       : { ...DEFAULT_MEMORY_POLICY };
@@ -386,30 +397,36 @@ export class Conversation {
   }
 
   /**
-   * Scan ALL persisted messages (including compacted ones) for ui_surface
-   * content blocks and populate surfaceState so findConversationBySurfaceId
-   * works for surfaces restored from history (e.g. after daemon restart).
+   * Scan loaded conversation history for ui_surface content blocks and
+   * populate surfaceState so that findConversationBySurfaceId works for
+   * surfaces restored from history (e.g. after daemon restart).
+   *
+   * Only scans live (non-compacted) messages in this.messages — not all DB
+   * rows — because surface IDs are not globally unique and restoring stale
+   * compacted surfaces would let findConversationBySurfaceId route actions
+   * to the wrong conversation.
    */
   private restoreSurfaceStateFromHistory(): void {
-    const dbMessages = getMessages(this.conversationId);
-    for (const row of dbMessages) {
-      try {
-        const content = JSON.parse(row.content);
-        if (!Array.isArray(content)) continue;
-        for (const block of content) {
-          if (
-            block.type === "ui_surface" &&
-            typeof block.surfaceId === "string"
-          ) {
-            this.surfaceState.set(block.surfaceId, {
-              surfaceType: (block.surfaceType ?? "dynamic_page") as SurfaceType,
-              data: (block.data ?? {}) as SurfaceData,
-              title: block.title as string | undefined,
-            });
-          }
+    this.surfaceState.clear();
+    for (const msg of this.messages) {
+      if (!Array.isArray(msg.content)) continue;
+      for (const block of msg.content) {
+        const b = block as unknown as Record<string, unknown>;
+        if (b.type === "ui_surface" && typeof b.surfaceId === "string") {
+          this.surfaceState.set(b.surfaceId, {
+            surfaceType: (b.surfaceType ?? "dynamic_page") as SurfaceType,
+            data: (b.data ?? {}) as SurfaceData,
+            title: b.title as string | undefined,
+            actions: Array.isArray(b.actions)
+              ? (b.actions as Array<{
+                  id: string;
+                  label: string;
+                  style?: string;
+                  data?: Record<string, unknown>;
+                }>)
+              : undefined,
+          });
         }
-      } catch {
-        // Content isn't valid JSON — skip
       }
     }
   }

package/src/daemon/handlers/config-embeddings.ts

@@ -3,7 +3,10 @@ import {
   loadRawConfig,
   saveRawConfig,
 } from "../../config/loader.js";
-import { setMemoryEmbeddingField } from "../../config/raw-config-utils.js";
+import {
+  deleteMemoryEmbeddingField,
+  setMemoryEmbeddingField,
+} from "../../config/raw-config-utils.js";
 import { VALID_MEMORY_EMBEDDING_PROVIDERS } from "../../config/schemas/memory-storage.js";
 import {
   clearEmbeddingBackendCache,
@@ -118,7 +121,12 @@ export async function setEmbeddingConfig(
   if (model !== undefined) {
     const fieldName = PROVIDER_MODEL_FIELD[provider];
     if (fieldName) {
-      setMemoryEmbeddingField(raw, fieldName, model);
+      if (model === "") {
+        // Empty string means "clear override — use schema default"
+        deleteMemoryEmbeddingField(raw, fieldName);
+      } else {
+        setMemoryEmbeddingField(raw, fieldName, model);
+      }
     }
   }
 

package/src/daemon/handlers/config-model.ts

@@ -16,7 +16,6 @@ import {
   isProviderAvailable,
 } from "../../providers/provider-availability.js";
 import { initializeProviders } from "../../providers/registry.js";
-import { getMaskedProviderKey } from "../../security/secure-keys.js";
 import type {
   ImageGenModelSetRequest,
   ModelSetRequest,
@@ -44,7 +43,6 @@ export interface ModelInfo {
   configuredProviders?: string[];
   availableModels?: Array<{ id: string; displayName: string }>;
   allProviders?: ProviderCatalogEntry[];
-  maskedKeys?: Record<string, string>;
 }
 
 /** Return current model configuration. */
@@ -52,19 +50,12 @@ export async function getModelInfo(): Promise<ModelInfo> {
   const config = getConfig();
   const provider = config.services.inference.provider;
 
-  const maskedKeys: Record<string, string> = {};
-  for (const p of VALID_INFERENCE_PROVIDERS) {
-    const masked = await getMaskedProviderKey(p);
-    if (masked) maskedKeys[p] = masked;
-  }
-
   return {
     model: config.services.inference.model,
     provider,
     configuredProviders: await getConfiguredProviders(),
     availableModels: PROVIDER_CATALOG.find((p) => p.id === provider)?.models,
     allProviders: PROVIDER_CATALOG,
-    maskedKeys,
   };
 }
 

package/src/daemon/handlers/conversations.ts

@@ -23,6 +23,7 @@ import {
   queueGenerateConversationTitle,
   UNTITLED_FALLBACK,
 } from "../../memory/conversation-title-service.js";
+import { reduceBeforeSwitch } from "../../memory/reducer-scheduler.js";
 import * as pendingInteractions from "../../runtime/pending-interactions.js";
 import { getSubagentManager } from "../../subagent/index.js";
 import { truncate } from "../../util/truncate.js";
@@ -233,6 +234,12 @@ export async function handleConversationCreate(
     conversationType: normalizeConversationType(conversation.conversationType),
   });
 
+  // Reduce the previous dirty conversation before processing the initial
+  // message so its memory is fresh for the next read.
+  if (msg.initialMessage) {
+    await reduceBeforeSwitch(conversation.id);
+  }
+
   // Auto-send the initial message if provided, kick-starting the skill.
   if (msg.initialMessage) {
     // Queue title generation eagerly — some processMessage paths (guardian
@@ -343,6 +350,10 @@ export async function switchConversation(
     return null;
   }
 
+  // Reduce the previous dirty conversation before switching so its memory
+  // is fresh for the next read.
+  await reduceBeforeSwitch(conversationId);
+
   // If the target conversation is headless-locked (actively executing a task run),
   // skip rebinding so tool confirmations stay suppressed.
   const existingConversation = ctx.conversations.get(conversationId);

package/src/daemon/handlers/identity.ts

@@ -1,3 +1,12 @@
+/**
+ * Returns true when the value is a template placeholder that should be treated
+ * as empty/unset. Placeholders follow the pattern `_(…)_`, e.g.
+ * `_(not yet chosen)_` or `_(not yet established)_`.
+ */
+export function isTemplatePlaceholder(value: string): boolean {
+  return value.startsWith("_(") && value.endsWith(")_");
+}
+
 export interface IdentityFields {
   name: string;
   role: string;
@@ -14,7 +23,9 @@ export function parseIdentityFields(content: string): IdentityFields {
     const lower = trimmed.toLowerCase();
     const extract = (prefix: string): string | null => {
       if (!lower.startsWith(prefix)) return null;
-      return trimmed.split(":**").pop()?.trim() ?? null;
+      const value = trimmed.split(":**").pop()?.trim() ?? null;
+      if (value && isTemplatePlaceholder(value)) return null;
+      return value;
     };
 
     const name = extract("- **name:**");

package/src/daemon/lifecycle.ts

@@ -30,6 +30,7 @@ import {
   getConversationType,
   getMessages,
   purgePrivateConversations,
+  sweepStaleReducerJobs,
 } from "../memory/conversation-crud.js";
 import { resolveConversationId } from "../memory/conversation-key-store.js";
 import { initializeDb } from "../memory/db.js";
@@ -200,14 +201,46 @@ export async function runDaemon(): Promise<void> {
           targetId: itemId,
         });
       }
+      for (const summaryId of deletedMemory.deletedSummaryIds) {
+        enqueueMemoryJob("delete_qdrant_vectors", {
+          targetType: "summary",
+          targetId: summaryId,
+        });
+      }
+      for (const obsId of deletedMemory.deletedObservationIds) {
+        enqueueMemoryJob("delete_qdrant_vectors", {
+          targetType: "observation",
+          targetId: obsId,
+        });
+      }
+      for (const chunkId of deletedMemory.deletedChunkIds) {
+        enqueueMemoryJob("delete_qdrant_vectors", {
+          targetType: "chunk",
+          targetId: chunkId,
+        });
+      }
+      for (const episodeId of deletedMemory.deletedEpisodeIds) {
+        enqueueMemoryJob("delete_qdrant_vectors", {
+          targetType: "episode",
+          targetId: episodeId,
+        });
+      }
       if (
         deletedMemory.segmentIds.length > 0 ||
-        deletedMemory.orphanedItemIds.length > 0
+        deletedMemory.orphanedItemIds.length > 0 ||
+        deletedMemory.deletedSummaryIds.length > 0 ||
+        deletedMemory.deletedObservationIds.length > 0 ||
+        deletedMemory.deletedChunkIds.length > 0 ||
+        deletedMemory.deletedEpisodeIds.length > 0
       ) {
         log.info(
           {
             segments: deletedMemory.segmentIds.length,
             orphanedItems: deletedMemory.orphanedItemIds.length,
+            deletedSummaries: deletedMemory.deletedSummaryIds.length,
+            deletedObservations: deletedMemory.deletedObservationIds.length,
+            deletedChunks: deletedMemory.deletedChunkIds.length,
+            deletedEpisodes: deletedMemory.deletedEpisodeIds.length,
           },
           "Enqueued Qdrant vector cleanup jobs for purged private conversations",
         );
@@ -232,6 +265,24 @@ export async function runDaemon(): Promise<void> {
       );
     }
 
+    // Sweep dirty conversations whose tail messages are already past the
+    // idle delay — they should have been reduced while the daemon was down.
+    // Enqueue immediate reducer jobs so the memory worker picks them up.
+    try {
+      const sweepCount = sweepStaleReducerJobs();
+      if (sweepCount > 0) {
+        log.info(
+          { sweepCount },
+          `Enqueued reducer jobs for ${sweepCount} stale dirty conversation(s)`,
+        );
+      }
+    } catch (err) {
+      log.warn(
+        { err },
+        "Startup sweep for stale reducer jobs failed — continuing startup",
+      );
+    }
+
     // Ensure a vellum guardian binding exists so the identity system works
     // without requiring a manual bootstrap step.
     try {

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

@@ -258,7 +258,6 @@ export interface ModelInfo {
     apiKeyUrl?: string;
     apiKeyPlaceholder?: string;
   }>;
-  maskedKeys?: Record<string, string>;
 }
 
 export interface HistoryResponseToolCall {

package/src/daemon/server.ts

@@ -1262,7 +1262,7 @@ export class DaemonServer {
       const appId = surfaceId.slice(appOpenPrefix.length);
       for (const c of this.conversations.values()) {
         for (const [, state] of c.surfaceState.entries()) {
-          const data = state.data as Record<string, unknown>;
+          const data = state.data as unknown as Record<string, unknown>;
           if (data?.appId === appId) {
             // Register this surfaceId so subsequent lookups are O(1)
             c.surfaceState.set(surfaceId, state);

package/src/followups/followup-store.ts

@@ -1,4 +1,4 @@
-import { and, eq, lte, or } from "drizzle-orm";
+import { and, desc, eq, lte, or } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getDb } from "../memory/db.js";
@@ -176,3 +176,49 @@ export function markNudged(id: string): FollowUp {
 
   return getFollowUp(id)!;
 }
+
+// ── Brief Helpers ──────────────────────────────────────────────────────
+
+/**
+ * Lightweight projection of a follow-up used by the brief compiler.
+ */
+export interface BriefFollowUp {
+  id: string;
+  channel: string;
+  conversationId: string;
+  contactId: string | null;
+  expectedResponseBy: number | null;
+  status: FollowUpStatus;
+  updatedAt: number;
+}
+
+/**
+ * Return pending and overdue follow-ups for the brief compiler.
+ * Ordered by expectedResponseBy ascending (most urgent first).
+ */
+export function getPendingAndOverdueFollowUps(): BriefFollowUp[] {
+  const db = getDb();
+
+  const rows = db
+    .select({
+      id: followups.id,
+      channel: followups.channel,
+      conversationId: followups.conversationId,
+      contactId: followups.contactId,
+      expectedResponseBy: followups.expectedResponseBy,
+      status: followups.status,
+      updatedAt: followups.updatedAt,
+    })
+    .from(followups)
+    .where(
+      or(
+        eq(followups.status, "pending"),
+        eq(followups.status, "overdue"),
+        eq(followups.status, "nudged"),
+      ),
+    )
+    .orderBy(desc(followups.expectedResponseBy))
+    .all();
+
+  return rows as BriefFollowUp[];
+}