@vellumai/assistant 0.8.5 → 0.8.6

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");

package/src/home/__tests__/suggested-prompts.test.ts

@@ -1,22 +1,12 @@
-import { describe, expect, mock, test } from "bun:test";
+import { afterEach, describe, expect, mock, test } from "bun:test";
 
 // ─── Mocks ─────────────────────────────────────────────────────────────
 
-let mockConnectedProviders = new Set<string>();
-
-mock.module("../../oauth/oauth-store.js", () => ({
-  listProviders: () => [
-    { provider: "google" },
-    { provider: "slack" },
-    { provider: "notion" },
-    { provider: "linear" },
-    { provider: "github" },
-  ],
-}));
+const mockIntegrationSummary = "Gmail ✓ | Slack ✓ | Twilio ✗ | Telegram ✗";
+let mockSidechainText = "";
 
 mock.module("../../schedule/integration-status.js", () => ({
-  isOAuthProviderConnected: async (provider: string) =>
-    mockConnectedProviders.has(provider),
+  formatIntegrationSummary: async () => mockIntegrationSummary,
 }));
 
 mock.module("../../util/logger.js", () => ({
@@ -31,7 +21,7 @@ mock.module("../../config/loader.js", () => ({
 }));
 
 mock.module("../../config/llm-resolver.js", () => ({
-  resolveCallSiteConfig: () => ({ provider: "mock" }),
+  resolveCallSiteConfig: () => ({ provider: "mock", maxTokens: 256 }),
 }));
 
 mock.module("../../providers/provider-send-message.js", () => ({
@@ -51,70 +41,76 @@ mock.module("../../prompts/system-prompt.js", () => ({
 }));
 
 mock.module("../../runtime/btw-sidechain.js", () => ({
-  runBtwSidechain: async () => ({ text: "" }),
+  runBtwSidechain: async () => ({ text: mockSidechainText }),
 }));
 
-const { getSuggestedPrompts } = await import("../suggested-prompts.js");
+mock.module("../../runtime/assistant-event.js", () => ({
+  buildAssistantEvent: (e: unknown) => e,
+}));
+
+mock.module("../../runtime/assistant-event-hub.js", () => ({
+  assistantEventHub: { publish: async () => {} },
+}));
+
+const {
+  getSuggestedPrompts,
+  refreshAssistantSuggestedPrompts,
+  invalidateAssistantSuggestedPromptsCache,
+} = await import("../suggested-prompts.js");
 
 // ─── Tests ─────────────────────────────────────────────────────────────
 
 describe("getSuggestedPrompts", () => {
-  test("shows 'Connect X' prompts when providers are disconnected", async () => {
-    mockConnectedProviders = new Set();
+  afterEach(() => {
+    invalidateAssistantSuggestedPromptsCache();
+    mockSidechainText = "";
+  });
 
+  test("returns empty array before cache is populated", async () => {
     const prompts = await getSuggestedPrompts();
-    const ids = prompts.map((p) => p.id);
-
-    expect(ids).toContain("connect-google");
-    expect(ids).toContain("connect-slack");
-    expect(prompts.find((p) => p.id === "connect-google")!.label).toBe(
-      "Connect Gmail",
-    );
+    expect(prompts).toEqual([]);
   });
 
-  test("shows email management prompts when Google is connected", async () => {
-    mockConnectedProviders = new Set(["google"]);
+  test("returns LLM-generated prompts after refresh", async () => {
+    mockSidechainText = JSON.stringify([
+      { label: "Triage my inbox", prompt: "Help me triage my inbox" },
+      { label: "Check meetings", prompt: "What meetings do I have today?" },
+    ]);
 
+    await refreshAssistantSuggestedPrompts();
     const prompts = await getSuggestedPrompts();
-    const ids = prompts.map((p) => p.id);
-
-    // Should NOT show "Connect Gmail"
-    expect(ids).not.toContain("connect-google");
-
-    // Should show management prompts
-    expect(ids).toContain("manage-google-triage-my-inbox");
-    expect(ids).toContain("manage-google-summarize-today's-emails");
-
-    const triage = prompts.find(
-      (p) => p.id === "manage-google-triage-my-inbox",
-    );
-    expect(triage).toBeDefined();
-    expect(triage!.label).toBe("Triage my inbox");
-    expect(triage!.icon).toBe("mail");
-    expect(triage!.source).toBe("deterministic");
+
+    expect(prompts).toHaveLength(2);
+    expect(prompts[0]!.label).toBe("Triage my inbox");
+    expect(prompts[0]!.source).toBe("assistant");
+    expect(prompts[1]!.label).toBe("Check meetings");
   });
 
-  test("still shows Connect prompts for disconnected providers alongside management prompts", async () => {
-    mockConnectedProviders = new Set(["google"]);
+  test("invalidation clears the cache", async () => {
+    mockSidechainText = JSON.stringify([
+      { label: "Do stuff", prompt: "Do stuff for me" },
+    ]);
 
-    const prompts = await getSuggestedPrompts();
-    const ids = prompts.map((p) => p.id);
+    await refreshAssistantSuggestedPrompts();
+    expect(await getSuggestedPrompts()).toHaveLength(1);
 
-    // Gmail management prompts
-    expect(ids).toContain("manage-google-triage-my-inbox");
-    // Slack still disconnected
-    expect(ids).toContain("connect-slack");
+    invalidateAssistantSuggestedPromptsCache();
+    expect(await getSuggestedPrompts()).toEqual([]);
   });
 
-  test("providers without connectedPrompts show nothing when connected", async () => {
-    mockConnectedProviders = new Set(["slack"]);
+  test("handles empty LLM response gracefully", async () => {
+    mockSidechainText = "";
 
+    await refreshAssistantSuggestedPrompts();
     const prompts = await getSuggestedPrompts();
-    const ids = prompts.map((p) => p.id);
+    expect(prompts).toEqual([]);
+  });
+
+  test("handles malformed LLM response gracefully", async () => {
+    mockSidechainText = "not valid json at all";
 
-    // No connect prompt since connected
-    expect(ids).not.toContain("connect-slack");
-    // No management prompts since Slack doesn't define any
-    expect(ids.filter((id) => id.startsWith("manage-slack"))).toHaveLength(0);
+    await refreshAssistantSuggestedPrompts();
+    const prompts = await getSuggestedPrompts();
+    expect(prompts).toEqual([]);
   });
 });

package/src/home/feed-writer.ts

@@ -44,6 +44,7 @@ import { getDataDir } from "../util/platform.js";
 import {
   type FeedItem,
   type FeedItemStatus,
+  type FeedItemUrgency,
   type HomeFeedFile,
   parseFeedFile,
 } from "./feed-types.js";
@@ -155,6 +156,72 @@ export async function patchFeedItemStatus(
   return resultPromise;
 }
 
+/**
+ * Patch the user-editable copy fields on a single feed item by id.
+ *
+ * Returns the updated `FeedItem`, or `null` if no item with the given
+ * id exists. Used by the `assistant notifications edit` flow. Patches
+ * are applied inside the same coalescing queue as appends and status
+ * patches so overlapping writes don't race.
+ *
+ * Only fields explicitly present on `patch` are touched. Pass an empty
+ * object and the call is a no-op that returns the existing item (or
+ * `null` if the id isn't on disk).
+ */
+export interface FeedItemContentPatch {
+  title?: string;
+  summary?: string;
+  urgency?: FeedItemUrgency;
+  status?: FeedItemStatus;
+}
+
+export async function patchFeedItemContent(
+  id: string,
+  patch: FeedItemContentPatch,
+): Promise<FeedItem | null> {
+  let resolveResult!: (value: FeedItem | null) => void;
+  const resultPromise = new Promise<FeedItem | null>((resolve) => {
+    resolveResult = resolve;
+  });
+  pendingContentPatches.push({ id, patch, resolve: resolveResult });
+  void scheduleWrite();
+  return resultPromise;
+}
+
+/**
+ * Remove the `conversationId` field from all feed items that reference
+ * the given conversation. Returns the number of items modified.
+ *
+ * This is the daemon-side cleanup path invoked when a conversation is
+ * deleted — it prevents "Go to Thread" buttons from linking to a
+ * conversation that no longer exists. Goes through the same coalescing
+ * queue as appends and patches so there are no file-I/O races.
+ */
+export async function stripConversationIds(
+  conversationId: string,
+): Promise<number> {
+  let resolveResult!: (count: number) => void;
+  const resultPromise = new Promise<number>((resolve) => {
+    resolveResult = resolve;
+  });
+  pendingStrips.push({ conversationId, resolve: resolveResult });
+  void scheduleWrite();
+  return resultPromise;
+}
+
+/**
+ * Remove the `conversationId` field from ALL feed items that have one.
+ * Returns the number of items modified.
+ *
+ * Used by the clear-all-conversations flow to bulk-invalidate every
+ * "Go to Thread" link at once. Uses the same coalescing queue with a
+ * `"*"` sentinel that the strip loop in `runWrite` treats as "match
+ * all items with a conversationId".
+ */
+export async function clearAllConversationIds(): Promise<number> {
+  return stripConversationIds("*");
+}
+
 // ─── Internal: coalescing queue ────────────────────────────────────────
 
 /**
@@ -168,6 +235,15 @@ const pendingPatches: Array<{
   status: FeedItemStatus;
   resolve: (value: FeedItem | null) => void;
 }> = [];
+const pendingContentPatches: Array<{
+  id: string;
+  patch: FeedItemContentPatch;
+  resolve: (value: FeedItem | null) => void;
+}> = [];
+const pendingStrips: Array<{
+  conversationId: string;
+  resolve: (count: number) => void;
+}> = [];
 
 let writeInFlight: Promise<void> | null = null;
 let writeDirty = false;
@@ -206,6 +282,11 @@ function scheduleWrite(): Promise<void> {
 async function runWrite(): Promise<void> {
   const appendsToApply = pendingAppends.splice(0, pendingAppends.length);
   const patchesToApply = pendingPatches.splice(0, pendingPatches.length);
+  const contentPatchesToApply = pendingContentPatches.splice(
+    0,
+    pendingContentPatches.length,
+  );
+  const stripsToApply = pendingStrips.splice(0, pendingStrips.length);
 
   const current = readHomeFeed();
   let items = current.items.slice();
@@ -233,6 +314,57 @@ async function runWrite(): Promise<void> {
     patchResults.push({ resolve: patch.resolve, value: updated });
   }
 
+  const contentPatchResults: Array<{
+    resolve: (v: FeedItem | null) => void;
+    value: FeedItem | null;
+  }> = [];
+  for (const { id, patch, resolve } of contentPatchesToApply) {
+    const idx = items.findIndex((i) => i.id === id);
+    if (idx === -1) {
+      contentPatchResults.push({ resolve, value: null });
+      continue;
+    }
+    const existing = items[idx]!;
+    const updated: FeedItem = { ...existing };
+    if (patch.title !== undefined) {
+      const trimmed = patch.title.trim();
+      if (trimmed.length === 0) {
+        delete updated.title;
+      } else {
+        updated.title = trimmed;
+      }
+    }
+    if (patch.summary !== undefined) {
+      updated.summary = patch.summary;
+    }
+    if (patch.urgency !== undefined) {
+      updated.urgency = patch.urgency;
+    }
+    if (patch.status !== undefined) {
+      updated.status = patch.status;
+    }
+    items[idx] = updated;
+    contentPatchResults.push({ resolve, value: updated });
+  }
+
+  // Strip conversationId from matching items.
+  const stripResults: Array<{
+    resolve: (count: number) => void;
+    count: number;
+  }> = [];
+  for (const strip of stripsToApply) {
+    let count = 0;
+    for (let i = 0; i < items.length; i++) {
+      const matchAll = strip.conversationId === "*";
+      const matchOne = items[i]!.conversationId === strip.conversationId;
+      if (matchAll ? items[i]!.conversationId != null : matchOne) {
+        items[i] = { ...items[i]!, conversationId: undefined };
+        count++;
+      }
+    }
+    stripResults.push({ resolve: strip.resolve, count });
+  }
+
   items.sort(compareFeedItems);
 
   const updatedAt = new Date().toISOString();
@@ -258,17 +390,24 @@ async function runWrite(): Promise<void> {
     publishHomeFeedUpdated(updatedAt, newItemCount);
   }
 
-  // Resolve pending patch promises AFTER we've emitted the SSE event
-  // so callers awaiting `patchFeedItemStatus` observe a fully
-  // consistent world: the on-disk file, the SSE event, and the
-  // returned `FeedItem` all reflect the same write.
+  // Resolve pending patch and strip promises AFTER we've emitted the
+  // SSE event so callers awaiting `patchFeedItemStatus` or
+  // `stripConversationIds` observe a fully consistent world: the
+  // on-disk file, the SSE event, and the returned value all reflect
+  // the same write.
   //
-  // If the write failed, resolve all patch promises with `null` — the
-  // state was not persisted, and callers (e.g. HTTP route handlers)
-  // must not report success when the underlying write failed.
+  // If the write failed, resolve patch promises with `null` and strip
+  // promises with `0` — the state was not persisted, and callers must
+  // not report success when the underlying write failed.
   for (const { resolve, value } of patchResults) {
     resolve(wrote ? value : null);
   }
+  for (const { resolve, value } of contentPatchResults) {
+    resolve(wrote ? value : null);
+  }
+  for (const { resolve, count } of stripResults) {
+    resolve(wrote ? count : 0);
+  }
 }
 
 /**