@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

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

@@ -45,6 +45,7 @@ const {
   HOME_FEED_FILENAME,
   HOME_FEED_VERSION,
   appendFeedItem,
+  bulkSetFeedItemStatus,
   clearAllConversationIds,
   getHomeFeedPath,
   patchFeedItemStatus,
@@ -52,7 +53,7 @@ const {
   stripConversationIds,
 } = await import("../feed-writer.js");
 
-type FeedItemStatus = "new" | "seen" | "acted_on";
+type FeedItemStatus = "new" | "seen" | "acted_on" | "dismissed";
 
 interface TestFeedItem {
   id: string;
@@ -583,6 +584,251 @@ describe("feed-writer", () => {
     });
   });
 
+  describe("bulkSetFeedItemStatus", () => {
+    test("flips every new item to seen, leaves other statuses alone", async () => {
+      await appendFeedItem(makeItem({ id: "n1", status: "new" }));
+      await appendFeedItem(
+        makeItem({
+          id: "n2",
+          status: "new",
+          createdAt: "2026-04-14T12:00:01.000Z",
+        }),
+      );
+      await appendFeedItem(
+        makeItem({
+          id: "s1",
+          status: "seen",
+          createdAt: "2026-04-14T12:00:02.000Z",
+        }),
+      );
+      await appendFeedItem(
+        makeItem({
+          id: "a1",
+          status: "acted_on",
+          createdAt: "2026-04-14T12:00:03.000Z",
+        }),
+      );
+
+      const count = await bulkSetFeedItemStatus(["new"], "seen");
+      expect(count).toBe(2);
+
+      const decoded = readFileJson();
+      const byId = new Map(decoded.items.map((i) => [i.id, i]));
+      expect(byId.get("n1")!.status).toBe("seen");
+      expect(byId.get("n2")!.status).toBe("seen");
+      expect(byId.get("s1")!.status).toBe("seen");
+      expect(byId.get("a1")!.status).toBe("acted_on");
+    });
+
+    test("returns 0 when nothing matches", async () => {
+      await appendFeedItem(makeItem({ id: "s1", status: "seen" }));
+      await appendFeedItem(
+        makeItem({
+          id: "s2",
+          status: "seen",
+          createdAt: "2026-04-14T12:00:01.000Z",
+        }),
+      );
+      await appendFeedItem(
+        makeItem({
+          id: "s3",
+          status: "seen",
+          createdAt: "2026-04-14T12:00:02.000Z",
+        }),
+      );
+      publishSpy.mockClear();
+
+      const count = await bulkSetFeedItemStatus(["new"], "seen");
+      expect(count).toBe(0);
+      // The writer still emits a publish for the empty-pass cycle,
+      // matching the strip/patch pattern.
+      expect(publishSpy.mock.calls.length).toBeGreaterThanOrEqual(1);
+    });
+
+    test("skips items already at target status", async () => {
+      await appendFeedItem(makeItem({ id: "n1", status: "new" }));
+      await appendFeedItem(
+        makeItem({
+          id: "s1",
+          status: "seen",
+          createdAt: "2026-04-14T12:00:01.000Z",
+        }),
+      );
+
+      const count = await bulkSetFeedItemStatus(["new", "seen"], "seen");
+      expect(count).toBe(1);
+
+      const decoded = readFileJson();
+      for (const item of decoded.items) {
+        expect(item.status).toBe("seen");
+      }
+    });
+
+    test("clear-all flips new + seen + acted_on to dismissed and leaves dismissed alone", async () => {
+      await appendFeedItem(makeItem({ id: "n1", status: "new" }));
+      await appendFeedItem(
+        makeItem({
+          id: "s1",
+          status: "seen",
+          createdAt: "2026-04-14T12:00:01.000Z",
+        }),
+      );
+      await appendFeedItem(
+        makeItem({
+          id: "a1",
+          status: "acted_on",
+          createdAt: "2026-04-14T12:00:02.000Z",
+        }),
+      );
+      await appendFeedItem(
+        makeItem({
+          id: "d1",
+          status: "dismissed",
+          createdAt: "2026-04-14T12:00:03.000Z",
+        }),
+      );
+
+      const count = await bulkSetFeedItemStatus(
+        ["new", "seen", "acted_on"],
+        "dismissed",
+      );
+      expect(count).toBe(3);
+
+      const decoded = readFileJson();
+      for (const item of decoded.items) {
+        expect(item.status).toBe("dismissed");
+      }
+    });
+
+    test("ids scope limits bulk update to matching item ids only", async () => {
+      await appendFeedItem(makeItem({ id: "n1", status: "new" }));
+      await appendFeedItem(
+        makeItem({
+          id: "n2",
+          status: "new",
+          createdAt: "2026-04-14T12:00:01.000Z",
+        }),
+      );
+      await appendFeedItem(
+        makeItem({
+          id: "n3",
+          status: "new",
+          createdAt: "2026-04-14T12:00:02.000Z",
+        }),
+      );
+
+      const count = await bulkSetFeedItemStatus(
+        ["new"],
+        "seen",
+        ["n1", "n3"],
+      );
+      expect(count).toBe(2);
+
+      const decoded = readFileJson();
+      const byId = new Map(decoded.items.map((i) => [i.id, i.status]));
+      expect(byId.get("n1")).toBe("seen");
+      expect(byId.get("n2")).toBe("new");
+      expect(byId.get("n3")).toBe("seen");
+    });
+
+    test("ids scope with no matching ids returns 0", async () => {
+      await appendFeedItem(makeItem({ id: "n1", status: "new" }));
+
+      const count = await bulkSetFeedItemStatus(["new"], "seen", ["nonexistent"]);
+      expect(count).toBe(0);
+
+      const decoded = readFileJson();
+      expect(decoded.items[0]!.status).toBe("new");
+    });
+
+    test("returns -1 when the underlying writeFileSync throws", async () => {
+      await appendFeedItem(
+        makeItem({
+          id: "fail-bulk",
+          status: "new",
+        }),
+      );
+
+      const feedPath = getHomeFeedPath();
+      const originalWrite = fs.writeFileSync;
+      const spy = spyOn(fs, "writeFileSync").mockImplementation(((
+        path: fs.PathOrFileDescriptor,
+        data: string | NodeJS.ArrayBufferView,
+        options?: fs.WriteFileOptions,
+      ) => {
+        if (typeof path === "string" && path === feedPath) {
+          throw new Error("Simulated write failure");
+        }
+        return originalWrite(path, data, options);
+      }) as typeof fs.writeFileSync);
+
+      try {
+        const count = await bulkSetFeedItemStatus(["new"], "seen");
+        expect(count).toBe(-1);
+
+        const decoded = readFileJson();
+        expect(decoded.items[0]!.status).toBe("new");
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    test("SSE home_feed_updated fires with correct post-flip newItemCount", async () => {
+      await appendFeedItem(makeItem({ id: "n1", status: "new" }));
+      await appendFeedItem(
+        makeItem({
+          id: "n2",
+          status: "new",
+          createdAt: "2026-04-14T12:00:01.000Z",
+        }),
+      );
+      await appendFeedItem(
+        makeItem({
+          id: "s1",
+          status: "seen",
+          createdAt: "2026-04-14T12:00:02.000Z",
+        }),
+      );
+      publishSpy.mockClear();
+
+      await bulkSetFeedItemStatus(["new"], "seen");
+
+      expect(publishSpy.mock.calls.length).toBeGreaterThanOrEqual(1);
+      const lastCall = publishSpy.mock.calls[publishSpy.mock.calls.length - 1]!;
+      const event = lastCall[0] as {
+        message: { type: string; newItemCount: number };
+      };
+      expect(event.message.type).toBe("home_feed_updated");
+      expect(event.message.newItemCount).toBe(0);
+    });
+
+    test("coalesces with a concurrent append: late-appended new item is also flipped", async () => {
+      await appendFeedItem(makeItem({ id: "existing", status: "new" }));
+
+      // Both calls push to their pending arrays synchronously before
+      // the async scheduleWrite runs, so they land in the same
+      // runWrite cycle. runWrite applies appends before bulk-status,
+      // so the late item is observed as `new` by the bulk pass and
+      // gets flipped.
+      const appendPromise = appendFeedItem(
+        makeItem({
+          id: "late",
+          status: "new",
+          createdAt: "2026-04-14T12:00:05.000Z",
+        }),
+      );
+      const bulkPromise = bulkSetFeedItemStatus(["new"], "seen");
+
+      const [_, count] = await Promise.all([appendPromise, bulkPromise]);
+      expect(count).toBe(2);
+
+      const decoded = readFileJson();
+      const byId = new Map(decoded.items.map((i) => [i.id, i]));
+      expect(byId.get("existing")!.status).toBe("seen");
+      expect(byId.get("late")!.status).toBe("seen");
+    });
+  });
+
   describe("SSE publish", () => {
     test("publishes home_feed_updated with correct newItemCount", async () => {
       await appendFeedItem(

package/src/home/conversation-starter-checkpoints.ts

@@ -57,6 +57,7 @@ export function upsertCheckpoint(
 export function countActiveMemoryNodes(scopeId: string): number {
   return (
     rawGet<{ c: number }>(
+      "starters:countActiveMemoryNodes",
       `SELECT COUNT(*) AS c FROM memory_graph_nodes WHERE fidelity != 'gone' AND scope_id = ?`,
       scopeId,
     )?.c ?? 0

package/src/home/feed-writer.ts

@@ -222,6 +222,32 @@ export async function clearAllConversationIds(): Promise<number> {
   return stripConversationIds("*");
 }
 
+/**
+ * Bulk-flip the status of every feed item currently at one of the
+ * `from` statuses to the single `to` status. Returns the count of
+ * items whose status was changed. Items already at the target status
+ * (or outside `from`) are left untouched, so the returned count is
+ * the real "how many did we mutate" figure the caller can surface.
+ *
+ * Goes through the same coalescing write queue as appends and single
+ * patches, so overlapping callers cannot race on the on-disk file.
+ * Returns `-1` when the underlying write fails so callers can
+ * distinguish a legitimate zero-count from a persistence failure.
+ */
+export async function bulkSetFeedItemStatus(
+  from: readonly FeedItemStatus[],
+  to: FeedItemStatus,
+  ids?: readonly string[],
+): Promise<number> {
+  let resolveResult!: (count: number) => void;
+  const resultPromise = new Promise<number>((resolve) => {
+    resolveResult = resolve;
+  });
+  pendingBulkStatus.push({ from, to, ids, resolve: resolveResult });
+  void scheduleWrite();
+  return resultPromise;
+}
+
 // ─── Internal: coalescing queue ────────────────────────────────────────
 
 /**
@@ -244,6 +270,12 @@ const pendingStrips: Array<{
   conversationId: string;
   resolve: (count: number) => void;
 }> = [];
+const pendingBulkStatus: Array<{
+  from: readonly FeedItemStatus[];
+  to: FeedItemStatus;
+  ids?: readonly string[];
+  resolve: (count: number) => void;
+}> = [];
 
 let writeInFlight: Promise<void> | null = null;
 let writeDirty = false;
@@ -287,6 +319,10 @@ async function runWrite(): Promise<void> {
     pendingContentPatches.length,
   );
   const stripsToApply = pendingStrips.splice(0, pendingStrips.length);
+  const bulkStatusToApply = pendingBulkStatus.splice(
+    0,
+    pendingBulkStatus.length,
+  );
 
   const current = readHomeFeed();
   let items = current.items.slice();
@@ -365,6 +401,28 @@ async function runWrite(): Promise<void> {
     stripResults.push({ resolve: strip.resolve, count });
   }
 
+  // Bulk-flip status. Applied after single patches so overlapping
+  // single-item patches land first and the bulk pass observes the
+  // post-patch statuses.
+  const bulkStatusResults: Array<{
+    resolve: (count: number) => void;
+    count: number;
+  }> = [];
+  for (const op of bulkStatusToApply) {
+    const fromSet = new Set(op.from);
+    const idSet = op.ids ? new Set(op.ids) : null;
+    let count = 0;
+    for (let i = 0; i < items.length; i++) {
+      const current = items[i]!;
+      if (current.status === op.to) continue;
+      if (!fromSet.has(current.status)) continue;
+      if (idSet && !idSet.has(current.id)) continue;
+      items[i] = { ...current, status: op.to };
+      count++;
+    }
+    bulkStatusResults.push({ resolve: op.resolve, count });
+  }
+
   items.sort(compareFeedItems);
 
   const updatedAt = new Date().toISOString();
@@ -408,6 +466,9 @@ async function runWrite(): Promise<void> {
   for (const { resolve, count } of stripResults) {
     resolve(wrote ? count : 0);
   }
+  for (const { resolve, count } of bulkStatusResults) {
+    resolve(wrote ? count : -1);
+  }
 }
 
 /**

package/src/home/job-handlers/conversation-starters.ts

@@ -109,6 +109,7 @@ function buildNewItemsDiff(scopeId: string): string {
     kind: string;
     content: string;
   }>(
+    "starters:buildNewItemsDiff",
     `SELECT type AS kind, content FROM memory_graph_nodes
      WHERE fidelity != 'gone' AND scope_id = ? AND created > ?
      ORDER BY created DESC LIMIT 20`,

package/src/hooks/hook-loader.ts

@@ -144,14 +144,26 @@ async function resolveCachedHook<TCtx>(
  * Added and removed hook files are picked up live (discovery is by directory
  * listing). A content edit to an existing file is only reflected after a
  * process restart, since Bun caches dynamic imports by resolved path.
+ *
+ * `effectiveEnabledPlugins` carries the per-chat plugin scope: when non-null, a
+ * plugin whose name is not in the set is skipped (its hooks do not run for this
+ * conversation). The standalone workspace hook is not owned by a plugin, so it
+ * always runs. `null`/omitted means no per-chat restriction.
  */
 export async function collectUserHooks<TCtx = unknown>(
   hookName: string,
   pluginDirs: Iterable<readonly [string, string]>,
+  effectiveEnabledPlugins?: Set<string> | null,
 ): Promise<HookFunction<TCtx>[]> {
   const out: HookFunction<TCtx>[] = [];
 
   for (const [pluginDir, pluginName] of pluginDirs) {
+    if (
+      effectiveEnabledPlugins != null &&
+      !effectiveEnabledPlugins.has(pluginName)
+    ) {
+      continue;
+    }
     const hookFile = listSurfaceDir(join(pluginDir, "hooks")).find(
       (f) => f.name === hookName,
     );

package/src/hooks/registry.ts

@@ -89,23 +89,51 @@ export function unregisterPluginHooks(pluginName: string): void {
  * over the concrete context type their hook receives. Hooks that mutate the
  * context in place return `void`; hooks that return a new context replace
  * the threaded value for the next hook in the chain.
+ *
+ * When `conversationId` is given, the conversation's effective plugin scope is
+ * resolved from it (memory, then DB) and layered on top of the global disabled
+ * check: a hook's contributing plugin must also be a member of that set or the
+ * hook is excluded for this turn (applies to both in-process default plugins
+ * and user-land plugins). Omit it (or pass a conversation with no per-chat
+ * restriction) and every globally-enabled plugin's hooks run, unchanged.
  */
 export async function getHooksFor<TCtx = unknown>(
   name: string,
+  options?: { conversationId?: string },
 ): Promise<HookFunction<TCtx>[]> {
+  // Resolve the per-chat scope through a lazy import: a static import of the
+  // daemon resolver would add `hooks/ → daemon/conversation-tool-setup` to the
+  // module-init graph and perturb the capability-seed init order. Importing at
+  // call time keeps that edge out of module evaluation (this only runs at
+  // hook-dispatch, well after boot). The module is cached after the first load.
+  let effectiveEnabledPlugins: Set<string> | null = null;
+  if (options?.conversationId) {
+    const { resolveConversationPluginScope } =
+      await import("../daemon/conversation-plugin-scope.js");
+    effectiveEnabledPlugins = resolveConversationPluginScope(
+      options.conversationId,
+    );
+  }
   // First-party defaults from the hook registry, filtered by the `.disabled`
   // sentinel at read time. This is what makes `assistant plugins disable
   // default-*` take effect immediately in a running assistant: the hooks stay
   // registered but are filtered out on the next turn.
   const defaultHooks: HookFunction<TCtx>[] = [];
   for (const entry of hookRegistry.get(name) ?? []) {
-    if (!isPluginDisabled(entry.pluginName)) {
-      defaultHooks.push(entry.fn as HookFunction<TCtx>);
+    if (isPluginDisabled(entry.pluginName)) continue;
+    if (
+      effectiveEnabledPlugins != null &&
+      !effectiveEnabledPlugins.has(entry.pluginName)
+    ) {
+      continue;
     }
+    defaultHooks.push(entry.fn as HookFunction<TCtx>);
   }
 
-  // User-land hooks from the mtime cache (async, may re-import).
-  const userHooks = await getUserHooksFor<TCtx>(name);
+  // User-land hooks from the mtime cache (async, may re-import). The per-chat
+  // scope is threaded through so a deselected user plugin's hooks are excluded
+  // too — standalone workspace hooks (not owned by a plugin) always run.
+  const userHooks = await getUserHooksFor<TCtx>(name, effectiveEnabledPlugins);
 
   return [...defaultHooks, ...userHooks];
 }

package/src/inbound/public-ingress-urls.ts

@@ -28,9 +28,7 @@
  */
 
 import {
-  buildTwilioConnectActionUrl,
   buildTwilioMediaStreamUrl,
-  buildTwilioRelayUrl,
   buildTwilioStatusWebhookUrl,
   buildTwilioVoiceWebhookUrl,
   normalizePublicBaseUrl,
@@ -105,21 +103,6 @@ export function getTwilioStatusCallbackUrl(config: IngressConfig): string {
   return buildTwilioStatusWebhookUrl(getPublicBaseUrl(config));
 }
 
-/**
- * Build the Twilio connect-action callback URL.
- */
-export function getTwilioConnectActionUrl(config: IngressConfig): string {
-  return buildTwilioConnectActionUrl(getPublicBaseUrl(config));
-}
-
-/**
- * Build the Twilio ConversationRelay WebSocket URL.
- * Converts http:// → ws:// and https:// → wss://.
- */
-export function getTwilioRelayUrl(config: IngressConfig): string {
-  return buildTwilioRelayUrl(getPublicBaseUrl(config));
-}
-
 /**
  * Build the Twilio media-stream WebSocket URL.
  * Used for the `<Stream>` TwiML path when the STT provider requires