@vellumai/assistant 0.8.4 → 0.8.6

package/src/daemon/process-message.ts

@@ -508,13 +508,13 @@ export async function processMessage(
   const persistMetadata = options?.slackInbound
     ? { slackInbound: options.slackInbound }
     : undefined;
-  const messageId = await conversation.persistUserMessage(
-    resolvedContent,
+  const { id: messageId } = await conversation.persistUserMessage({
+    content: resolvedContent,
     attachments,
     requestId,
-    persistMetadata,
-    options?.displayContent,
-  );
+    metadata: persistMetadata,
+    displayContent: options?.displayContent,
+  });
   publishConversationMessagesChanged(conversationId);
 
   if (options?.isInteractive === true) {
@@ -571,13 +571,13 @@ export async function processMessageInBackground(
   const persistMetadata = options?.slackInbound
     ? { slackInbound: options.slackInbound }
     : undefined;
-  const messageId = await conversation.persistUserMessage(
+  const { id: messageId } = await conversation.persistUserMessage({
     content,
     attachments,
     requestId,
-    persistMetadata,
-    options?.displayContent,
-  );
+    metadata: persistMetadata,
+    displayContent: options?.displayContent,
+  });
   publishConversationMessagesChanged(conversationId);
 
   if (options?.isInteractive === true) {

package/src/daemon/providers-setup.ts

@@ -133,7 +133,7 @@ export async function initializeProvidersAndTools(
           serverConfig,
           manager,
         );
-        registerMcpTools(mcpTools);
+        registerMcpTools(serverId, mcpTools);
       }
     } catch (err) {
       log.error(

package/src/daemon/server.ts

@@ -50,6 +50,15 @@ import { refreshSkillCapabilityMemories } from "./skill-memory-refresh.js";
 
 const log = getLogger("server");
 
+function isEaddrInUse(err: unknown): boolean {
+  return (
+    typeof err === "object" &&
+    err !== null &&
+    "code" in err &&
+    (err as NodeJS.ErrnoException).code === "EADDRINUSE"
+  );
+}
+
 function readPackageVersion(): string | undefined {
   try {
     const pkgPath = join(import.meta.dir, "../../package.json");
@@ -259,6 +268,13 @@ export class DaemonServer {
     try {
       await this.cliIpc.start();
     } catch (err) {
+      if (isEaddrInUse(err)) {
+        log.error(
+          { err },
+          "CLI IPC socket already in use by another daemon — aborting startup to prevent duplicate processing",
+        );
+        throw err;
+      }
       log.warn(
         { err },
         "CLI IPC server failed to start — continuing startup with degraded CLI connectivity",

package/src/daemon/shutdown-handlers.ts

@@ -34,10 +34,9 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
   let shuttingDown = false;
   let exitCode = 0;
 
-  const shutdown = async () => {
+  const shutdown = async (_signal?: NodeJS.Signals) => {
     if (shuttingDown) return;
     shuttingDown = true;
-    log.info("Shutting down daemon...");
 
     // Force exit if graceful shutdown takes too long.
     // Set this BEFORE awaiting heartbeat stop so it covers all
@@ -156,9 +155,29 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     process.exit(exitCode);
   };
 
-  process.on("SIGTERM", shutdown);
-  process.on("SIGINT", shutdown);
-  process.on("SIGHUP", shutdown);
+  process.on("SIGTERM", () => {
+    log.warn(
+      { signal: "SIGTERM", pid: process.pid, uptime: process.uptime() },
+      "Received SIGTERM — process termination requested",
+    );
+    void shutdown("SIGTERM");
+  });
+
+  process.on("SIGINT", () => {
+    log.warn(
+      { signal: "SIGINT", pid: process.pid, uptime: process.uptime() },
+      "Received SIGINT — user interrupt",
+    );
+    void shutdown("SIGINT");
+  });
+
+  process.on("SIGHUP", () => {
+    log.warn(
+      { signal: "SIGHUP", pid: process.pid, uptime: process.uptime() },
+      "Received SIGHUP — terminal hangup",
+    );
+    void shutdown("SIGHUP");
+  });
 
   process.on("unhandledRejection", (reason) => {
     log.error(

package/src/daemon/switch-inference-profile-tool.ts

@@ -0,0 +1,62 @@
+import type { ProfileEntry } from "../config/schemas/llm.js";
+import { AUTO_PROFILE_KEY } from "../config/seed-inference-profiles.js";
+import type { ToolDefinition } from "../providers/types.js";
+
+export const SWITCH_INFERENCE_PROFILE_TOOL_NAME = "switch_inference_profile";
+
+const PROFILE_DESCRIPTION_FALLBACKS: Record<string, string> = {
+  "quality-optimized":
+    "Most capable model for complex reasoning, multi-step analysis, math, and coding",
+  balanced: "Good balance of quality, cost, and speed for most tasks",
+  "cost-optimized":
+    "Fast responses for simple factual questions, short lookups, and casual chat",
+};
+
+export function buildSwitchInferenceProfileToolDef(
+  profiles: Record<string, ProfileEntry>,
+  currentProfile?: string,
+): ToolDefinition | null {
+  const entries = Object.entries(profiles).filter(
+    ([key, entry]) =>
+      entry.status !== "disabled" &&
+      key !== AUTO_PROFILE_KEY &&
+      // Mix profiles are A/B-routing buckets, not concrete targets the model
+      // should self-select into — exclude them so the picker only offers real
+      // profiles.
+      entry.mix == null,
+  );
+  if (entries.length < 2) return null;
+
+  const profileDescriptions = entries
+    .map(([key, entry]) => {
+      const label = entry.label ?? key;
+      const desc =
+        entry.description || PROFILE_DESCRIPTION_FALLBACKS[key] || "";
+      const descSuffix = desc ? `: ${desc}` : "";
+      const current = key === currentProfile ? " (current)" : "";
+      return `- ${key} — ${label}${descSuffix}${current}`;
+    })
+    .join("\n");
+
+  const currentEntry = currentProfile ? profiles[currentProfile] : undefined;
+  const currentLabel =
+    currentProfile === AUTO_PROFILE_KEY
+      ? "Auto (starting on Balanced)"
+      : (currentEntry?.label ?? currentProfile ?? "current");
+
+  return {
+    name: SWITCH_INFERENCE_PROFILE_TOOL_NAME,
+    description: `Switch to a different inference profile BEFORE answering. You MUST call this tool when the user's query requires capabilities beyond what your current profile ("${currentLabel}") provides — AND you MUST also call it when the query is trivially simple and a faster, cheaper profile would handle it equally well.\n\nSwitch UP (to a more capable profile) for: multi-step reasoning or analysis, math proofs or derivations, complex coding tasks, detailed creative writing, or any task requiring deep thought.\n\nSwitch DOWN (to a faster profile) for: simple greetings or chitchat, one-word or single-sentence answers, factual lookups, acknowledgments, or any query that does not benefit from advanced reasoning.\n\nWhen in doubt about whether you can handle the query well, switch UP. When in doubt about whether the query is too simple for your current profile, switch DOWN.\n\nAvailable profiles:\n${profileDescriptions}`,
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        profile: {
+          type: "string",
+          enum: entries.map(([key]) => key),
+          description: "The profile key to switch to.",
+        },
+      },
+      required: ["profile"],
+    },
+  };
+}

package/src/daemon/tool-setup-types.ts

@@ -57,4 +57,11 @@ export interface ToolSetupContext extends SurfaceConversationContext {
    * return `undefined` for the in-flight (background) subagent.
    */
   currentTurnOverrideProfile?: string;
+  /**
+   * Set by the `switch_inference_profile` tool when the model self-selects a
+   * different profile mid-turn. Read by `readCurrentOverrideProfile` in the
+   * agent loop so the next LLM call uses the switched profile. Reset at
+   * turn start.
+   */
+  toolRoutedProfile?: string;
 }

package/src/daemon/wake-target-adapter.ts

@@ -136,8 +136,18 @@ function translateAgentEventToServerMessage(
     case "usage":
     case "error":
     case "provider_error":
+    case "max_tokens_reached":
     case "agent_loop_exit":
       return null;
+    case "llm_call_started":
+      // The wake path persists its assistant tail via `persistTailMessage`
+      // (an `addMessage`-shaped call below) rather than via the main
+      // event-handler's `reserve` → `updateContent` pipeline, so there is
+      // no row to reserve here. Translation returns null and the wake
+      // path's existing end-of-turn persist continues to mint the row.
+      // Following up with full wake-path pre-allocation parity is tracked
+      // as a B3 follow-up.
+      return null;
   }
 }
 

package/src/documents/document-store.ts

@@ -217,6 +217,44 @@ export function searchDocumentsByTitle(
   }
 }
 
+/**
+ * Return the most recent empty document in the given conversation with the
+ * supplied title, created within the last `withinMs` milliseconds.
+ *
+ * Used to dedupe a duplicate create-then-create flow after a failed update —
+ * when the model can't recover a malformed update and retries by creating a
+ * second same-title document, we reuse the first (still-empty) draft instead
+ * of producing a duplicate row. Returns `null` when no candidate exists.
+ */
+export function findRecentEmptyDocumentByTitle(
+  conversationId: string,
+  title: string,
+  withinMs: number,
+): { surfaceId: string } | null {
+  try {
+    const threshold = Date.now() - withinMs;
+    const row = rawGet<{ surface_id: string }>(
+      /*sql*/ `SELECT surface_id FROM documents
+       WHERE conversation_id = ?
+         AND title = ?
+         AND content = ''
+         AND created_at >= ?
+       ORDER BY created_at DESC
+       LIMIT 1`,
+      conversationId,
+      title,
+      threshold,
+    );
+    return row ? { surfaceId: row.surface_id } : null;
+  } catch (error) {
+    log.error(
+      { err: error, conversationId, title },
+      "Find-recent-empty-document error",
+    );
+    return null;
+  }
+}
+
 /**
  * Delete a document and its conversation associations.
  * Returns `true` if the document existed and was deleted, `false` otherwise.

package/src/export/__tests__/transcript-formatter.test.ts

@@ -76,6 +76,7 @@ mock.module("../../memory/conversation-crud.js", () => ({
   getMessages: (id: string) =>
     id === "child-conv-1" ? childMessages : parentMessages,
   messageMetadataSchema,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../../util/truncate.js", () => ({

package/src/heartbeat/__tests__/heartbeat-service.test.ts

@@ -14,6 +14,7 @@ mock.module("../../runtime/assistant-event-hub.js", () => ({
     publish: publishSpy,
     subscribe: () => () => {},
   },
+  broadcastMessage: () => {},
 }));
 
 // Stub workspace prompt reads so the heartbeat service doesn't try to
@@ -42,6 +43,35 @@ mock.module("../../util/platform.js", () => ({
     join(workspaceDir ?? fallbackDir, "avatar/avatar-image.png"),
 
   getXdgVellumConfigDirName: () => ".vellum",
+  getPidPath: () => join(workspaceDir ?? fallbackDir, "assistant.pid"),
+  getDbPath: () => join(workspaceDir ?? fallbackDir, "db/assistant.db"),
+  getLogsDir: () => join(workspaceDir ?? fallbackDir, "logs"),
+  getHistoryPath: () => join(workspaceDir ?? fallbackDir, "history.json"),
+  getProtectedDir: () => join(workspaceDir ?? fallbackDir, "protected"),
+  getSignalsDir: () => join(workspaceDir ?? fallbackDir, "signals"),
+  getDaemonStderrLogPath: () =>
+    join(workspaceDir ?? fallbackDir, "logs/assistant.err.log"),
+  getDaemonStartupLockPath: () =>
+    join(workspaceDir ?? fallbackDir, "assistant.lock"),
+  getExternalDir: () => join(workspaceDir ?? fallbackDir, "external"),
+  getBinDir: () => join(workspaceDir ?? fallbackDir, "bin"),
+  getDotEnvPath: () => join(workspaceDir ?? fallbackDir, ".env"),
+  getEmbedWorkerPidPath: () =>
+    join(workspaceDir ?? fallbackDir, "embed-worker.pid"),
+  getWorkspaceDirDisplay: () => workspaceDir ?? fallbackDir,
+  getWorkspaceConfigPath: () => join(workspaceDir ?? fallbackDir, "config.json"),
+  getWorkspaceSkillsDir: () => join(workspaceDir ?? fallbackDir, "skills"),
+  getWorkspaceHooksDir: () => join(workspaceDir ?? fallbackDir, ".githooks"),
+  getWorkspacePluginsDir: () => join(workspaceDir ?? fallbackDir, "plugins"),
+  getWorkspaceRoutesDir: () => join(workspaceDir ?? fallbackDir, "routes"),
+  getDeprecatedDir: () => join(workspaceDir ?? fallbackDir, "deprecated"),
+  getProfilerRootDir: () => join(workspaceDir ?? fallbackDir, "profiler"),
+  getProfilerRunsDir: () => join(workspaceDir ?? fallbackDir, "profiler/runs"),
+  getProfilerRunDir: (runId: string) =>
+    join(workspaceDir ?? fallbackDir, "profiler/runs", runId),
+  getSkillRuntimePath: () => join(workspaceDir ?? fallbackDir, "skill-runtime"),
+  getBundledBunPath: () => undefined,
+  ensureDataDir: () => {},
 }));
 
 // Stub config so heartbeat is enabled. Must export every symbol from
@@ -99,7 +129,6 @@ mock.module("../../prompts/persona-resolver.js", () => ({
 }));
 mock.module("../../prompts/system-prompt.js", () => ({
   isTemplateContent: () => false,
-  SYSTEM_PROMPT_CACHE_BOUNDARY: "<<CACHE_BOUNDARY>>",
   buildCoreIdentityContext: () => "",
   buildSystemPrompt: () => "",
   ensurePromptFiles: () => {},

package/src/heartbeat/heartbeat-service.ts

@@ -97,6 +97,16 @@ function recordReengagementTimestamp(): void {
   }
 }
 
+function refreshBackgroundWakeIntentSoon(reason: string): void {
+  void import("../background-wake/publisher.js")
+    .then(({ refreshBackgroundWakeIntent }) =>
+      refreshBackgroundWakeIntent(reason),
+    )
+    .catch((err) =>
+      log.warn({ err, reason }, "Failed to queue background wake refresh"),
+    );
+}
+
 export interface HeartbeatDeps {
   alerter: (alert: HeartbeatAlert) => void;
   onConversationCreated?: (info: {
@@ -107,6 +117,19 @@ export interface HeartbeatDeps {
   getCurrentHour?: () => number;
 }
 
+export interface ManagedWakeHeartbeatRunOptions {
+  now?: number;
+  toleranceMs?: number;
+  assumeDue?: boolean;
+  scheduledFor?: number;
+}
+
+export interface ManagedWakeHeartbeatRunResult {
+  due: boolean;
+  completed: number;
+  skipped: number;
+}
+
 export class HeartbeatService {
   private static instance?: HeartbeatService;
 
@@ -153,12 +176,47 @@ export class HeartbeatService {
     return this._nextRunAt;
   }
 
+  async runManagedWakeIfDue(
+    options: ManagedWakeHeartbeatRunOptions = {},
+  ): Promise<ManagedWakeHeartbeatRunResult> {
+    const now = options.now ?? Date.now();
+    const toleranceMs = options.toleranceMs ?? 0;
+    const dueByLocalTimer =
+      this._nextRunAt != null && this._nextRunAt <= now + toleranceMs;
+
+    if (!dueByLocalTimer && options.assumeDue !== true) {
+      return { due: false, completed: 0, skipped: 0 };
+    }
+
+    if (!dueByLocalTimer) {
+      if (this._pendingRunId) {
+        supersedePendingRun(this._pendingRunId);
+        this._pendingRunId = null;
+      }
+      this._nextRunAt = options.scheduledFor ?? now;
+      this._pendingRunId = insertPendingHeartbeatRun(this._nextRunAt);
+    }
+
+    const completed = await this.runOnce({ force: false });
+
+    if (this.cronMode && !this.stopped) {
+      this.scheduleNextCronRun(getConfig().heartbeat);
+    }
+
+    return {
+      due: true,
+      completed: completed ? 1 : 0,
+      skipped: completed ? 0 : 1,
+    };
+  }
+
   start(): void {
     this.stopped = false;
     const config = getConfig().heartbeat;
     if (!config.enabled) {
       log.info("Heartbeat disabled by config");
       this._nextRunAt = null;
+      refreshBackgroundWakeIntentSoon("heartbeat-disabled");
       return;
     }
     if (this.timer) return;
@@ -283,6 +341,7 @@ export class HeartbeatService {
         { nextRunAt: new Date(nextRunAt).toISOString(), delayMs },
         "Heartbeat cron run scheduled",
       );
+      refreshBackgroundWakeIntentSoon("heartbeat-cron-scheduled");
     } catch (err) {
       log.warn(
         { err },
@@ -309,6 +368,7 @@ export class HeartbeatService {
     this._nextRunAt = null;
     this.cronMode = false;
     this.start();
+    refreshBackgroundWakeIntentSoon("heartbeat-reconfigured");
   }
 
   /**
@@ -386,6 +446,7 @@ export class HeartbeatService {
 
     if (!force && !config.enabled) {
       if (runId) skipHeartbeatRun(runId, "disabled");
+      refreshBackgroundWakeIntentSoon("heartbeat-disabled");
       return false;
     }
 
@@ -510,6 +571,7 @@ export class HeartbeatService {
       if (!this.cronMode) {
         this.scheduleNextRun(getConfig().heartbeat.intervalMs);
       }
+      refreshBackgroundWakeIntentSoon("heartbeat-run-complete");
     }
     return true;
   }
@@ -520,6 +582,7 @@ export class HeartbeatService {
     }
     this._nextRunAt = Date.now() + intervalMs;
     this._pendingRunId = insertPendingHeartbeatRun(this._nextRunAt);
+    refreshBackgroundWakeIntentSoon("heartbeat-interval-scheduled");
   }
 
   /**

package/src/home/__tests__/feed-writer.test.ts

@@ -35,6 +35,7 @@ mock.module("../../runtime/assistant-event-hub.js", () => ({
     // hub's real shape has more fields. Tests never call them.
     subscribe: () => () => {},
   },
+  broadcastMessage: async () => {},
 }));
 
 // Dynamic import so the module resolves after the mock above is in
@@ -44,9 +45,11 @@ const {
   HOME_FEED_FILENAME,
   HOME_FEED_VERSION,
   appendFeedItem,
+  clearAllConversationIds,
   getHomeFeedPath,
   patchFeedItemStatus,
   readHomeFeed,
+  stripConversationIds,
 } = await import("../feed-writer.js");
 
 type FeedItemStatus = "new" | "seen" | "acted_on";
@@ -60,6 +63,7 @@ interface TestFeedItem {
   timestamp: string;
   status: FeedItemStatus;
   expiresAt?: string;
+  conversationId?: string;
   createdAt: string;
 }
 
@@ -422,6 +426,163 @@ describe("feed-writer", () => {
     });
   });
 
+  describe("stripConversationIds", () => {
+    test("removes conversationId from matching items and leaves others untouched", async () => {
+      await appendFeedItem(
+        makeItem({
+          id: "item-a",
+          title: "Linked",
+          conversationId: "conv-123",
+        }),
+      );
+      await appendFeedItem(
+        makeItem({
+          id: "item-b",
+          title: "Other conv",
+          conversationId: "conv-456",
+          createdAt: "2026-04-14T12:00:01.000Z",
+        }),
+      );
+      await appendFeedItem(
+        makeItem({
+          id: "item-c",
+          title: "No conv",
+          createdAt: "2026-04-14T12:00:02.000Z",
+        }),
+      );
+
+      await stripConversationIds("conv-123");
+
+      const decoded = readFileJson();
+      const itemA = decoded.items.find((i) => i.id === "item-a")!;
+      const itemB = decoded.items.find((i) => i.id === "item-b")!;
+      const itemC = decoded.items.find((i) => i.id === "item-c")!;
+
+      expect(itemA.conversationId).toBeUndefined();
+      expect(itemB.conversationId).toBe("conv-456");
+      expect(itemC.conversationId).toBeUndefined();
+    });
+
+    test("returns the count of items modified", async () => {
+      await appendFeedItem(
+        makeItem({
+          id: "m1",
+          conversationId: "conv-abc",
+        }),
+      );
+      await appendFeedItem(
+        makeItem({
+          id: "m2",
+          conversationId: "conv-abc",
+          createdAt: "2026-04-14T12:00:01.000Z",
+        }),
+      );
+      await appendFeedItem(
+        makeItem({
+          id: "m3",
+          conversationId: "conv-other",
+          createdAt: "2026-04-14T12:00:02.000Z",
+        }),
+      );
+
+      const count = await stripConversationIds("conv-abc");
+      expect(count).toBe(2);
+    });
+
+    test("returns 0 when no items match", async () => {
+      await appendFeedItem(
+        makeItem({
+          id: "no-match",
+          conversationId: "conv-xyz",
+        }),
+      );
+
+      const count = await stripConversationIds("conv-nonexistent");
+      expect(count).toBe(0);
+    });
+
+    test("coalesces with pending appends correctly", async () => {
+      // Fire an append and a strip concurrently — both should land in
+      // the same coalesced write cycle.
+      const appendPromise = appendFeedItem(
+        makeItem({
+          id: "coalesce-item",
+          conversationId: "conv-coalesce",
+        }),
+      );
+      const stripPromise = stripConversationIds("conv-coalesce");
+
+      await Promise.all([appendPromise, stripPromise]);
+
+      const decoded = readFileJson();
+      const item = decoded.items.find((i) => i.id === "coalesce-item")!;
+      // The append lands first, then the strip runs — conversationId
+      // should be gone.
+      expect(item).toBeDefined();
+      expect(item.conversationId).toBeUndefined();
+    });
+
+    test("items retain all other fields after strip", async () => {
+      await appendFeedItem(
+        makeItem({
+          id: "retain-fields",
+          title: "Keep me",
+          summary: "Important summary",
+          conversationId: "conv-strip",
+          priority: 75,
+          status: "seen",
+        }),
+      );
+
+      await stripConversationIds("conv-strip");
+
+      const decoded = readFileJson();
+      const item = decoded.items.find((i) => i.id === "retain-fields")!;
+      expect(item.conversationId).toBeUndefined();
+      expect(item.id).toBe("retain-fields");
+      expect(item.title).toBe("Keep me");
+      expect(item.summary).toBe("Important summary");
+      expect(item.priority).toBe(75);
+      expect(item.status).toBe("seen");
+      expect(item.type).toBe("notification");
+    });
+  });
+
+  describe("clearAllConversationIds", () => {
+    test("strips conversationId from all items that have one", async () => {
+      await appendFeedItem(
+        makeItem({
+          id: "all-1",
+          conversationId: "conv-aaa",
+        }),
+      );
+      await appendFeedItem(
+        makeItem({
+          id: "all-2",
+          conversationId: "conv-bbb",
+          createdAt: "2026-04-14T12:00:01.000Z",
+        }),
+      );
+      await appendFeedItem(
+        makeItem({
+          id: "all-3",
+          title: "No conv link",
+          createdAt: "2026-04-14T12:00:02.000Z",
+        }),
+      );
+
+      const count = await clearAllConversationIds();
+      expect(count).toBe(2);
+
+      const decoded = readFileJson();
+      for (const item of decoded.items) {
+        expect(item.conversationId).toBeUndefined();
+      }
+      // All three items still exist.
+      expect(decoded.items).toHaveLength(3);
+    });
+  });
+
   describe("SSE publish", () => {
     test("publishes home_feed_updated with correct newItemCount", async () => {
       await appendFeedItem(

package/src/home/__tests__/post-connect-feed.test.ts

@@ -11,6 +11,7 @@ mock.module("../../runtime/assistant-event-hub.js", () => ({
     publish: publishSpy,
     subscribe: () => () => {},
   },
+  broadcastMessage: async () => {},
 }));
 
 const { emitPostConnectNudge } = await import("../post-connect-feed.js");