@vellumai/assistant 0.6.4 → 0.6.6

package/src/runtime/routes/debug-routes.ts

@@ -65,7 +65,7 @@ function handleDebug(): Response {
       startedAt: new Date(startedAt).toISOString(),
     },
     provider: {
-      configuredProvider: config.services.inference.provider,
+      configuredProvider: config.llm.default.provider,
       registeredProviders,
       routingSources,
       inferenceMode: config.services.inference.mode,

package/src/runtime/routes/diagnostics-routes.ts

@@ -222,7 +222,7 @@ async function handleDictation(body: DictationBody): Promise<Response> {
   const transcription = expandSnippets(body.transcription, profile.snippets);
 
   try {
-    const provider = await getConfiguredProvider();
+    const provider = await getConfiguredProvider("interactionClassifier");
     if (!provider) {
       log.warn(
         "Dictation: no provider available, using heuristic + raw transcription",
@@ -288,7 +288,7 @@ async function handleDictation(body: DictationBody): Promise<Response> {
         systemPrompt,
         {
           config: {
-            modelIntent: "latency-optimized",
+            callSite: "interactionClassifier",
             max_tokens: maxTokens,
             tool_choice: {
               type: "tool" as const,
@@ -381,7 +381,7 @@ async function handleCommandMode(
   const maxTokens = Math.max(1024, computeMaxTokens(inputLength));
 
   try {
-    const provider = await getConfiguredProvider();
+    const provider = await getConfiguredProvider("interactionClassifier");
     if (!provider) {
       log.warn("Command mode: no provider available, returning selected text");
       const normalizedText = applyDictionary(
@@ -399,7 +399,9 @@ async function handleCommandMode(
       [userMessage(body.transcription)],
       [],
       systemPrompt,
-      { config: { modelIntent: "latency-optimized", max_tokens: maxTokens } },
+      {
+        config: { callSite: "interactionClassifier", max_tokens: maxTokens },
+      },
     );
 
     const textBlock = response.content.find((b) => b.type === "text");

package/src/runtime/routes/events-routes.ts

@@ -10,6 +10,16 @@
  * When `conversationKey` is provided, subscribers receive events scoped to
  * that conversation. When omitted, subscribers receive events from ALL
  * conversations for this assistant (unfiltered).
+ *
+ * If the conversationKey has no server-side mapping yet (e.g. a client-
+ * generated draft UUID that has not been sent a first message), this
+ * handler eagerly materialises the conversation so the subscriber's
+ * `filter.conversationId` matches the id under which the first turn's
+ * scoped events (text deltas, tool calls, message_complete) will be
+ * published by `handleSendMessage`. The `conversation_list_invalidated`
+ * notification for other clients is driven by `handleSendMessage`'s
+ * first-message check, so eager materialisation here is safe and does
+ * not hide the first-message notification from other clients.
  */
 
 import { getOrCreateConversation } from "../../memory/conversation-key-store.js";
@@ -75,6 +85,12 @@ export function handleSubscribeAssistantEvents(
     assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
   };
   if (conversationKey) {
+    // Eagerly resolve (and if necessary create) the conversation so the
+    // subscriber's filter matches the id under which first-turn scoped
+    // events will be published. The `conversation_list_invalidated`
+    // publish is driven by `handleSendMessage`'s first-message check,
+    // so eager materialisation here is safe and does not suppress the
+    // cross-client notification.
     const mapping = getOrCreateConversation(conversationKey);
     filter.conversationId = mapping.conversationId;
   }

package/src/runtime/routes/guardian-approval-interception.ts

@@ -31,6 +31,7 @@ import type {
   ApprovalCopyGenerator,
 } from "../http-types.js";
 import { parseApprovalIntent } from "../nl-approval-parser.js";
+import { isTrackedApprovalPromptTs } from "./approval-prompt-ts-tracker.js";
 import { handleGuardianCallbackDecision } from "./approval-strategies/guardian-callback-strategy.js";
 import { handleGuardianTextEngineDecision } from "./approval-strategies/guardian-text-engine-strategy.js";
 import {
@@ -139,7 +140,15 @@ export async function handleApprovalInterception(
   // so getChannelApprovalPrompt(conversationId) would return null.
   // Only guardians can approve via reaction — non-guardian reactions are
   // silently ignored to prevent self-approval.
-  if (callbackData?.startsWith("reaction:")) {
+  //
+  // `reaction_removed:` callbackData never expresses an approval intent, and
+  // `isSlackReactionEvent` short-circuits before reaching here for removals,
+  // but guard explicitly so a future refactor can't turn an un-react into an
+  // unintended approval.
+  if (
+    callbackData?.startsWith("reaction:") &&
+    !callbackData.startsWith("reaction_removed:")
+  ) {
     if (trustCtx.trustClass !== "guardian" || !actorExternalId) {
       return { handled: true, type: "stale_ignored" };
     }
@@ -149,6 +158,23 @@ export async function handleApprovalInterception(
       return { handled: true, type: "stale_ignored" };
     }
 
+    // Require the reacted-to message to be a tracked approval prompt. Without
+    // this check, any unrelated 👍 reaction from the guardian in a subscribed
+    // channel would approve the outstanding pending request (now that
+    // reactions are admitted from any subscribed channel, not just tracked
+    // bot threads). `approvalMessageTs` is `item.ts` of the reacted-to
+    // Slack message, propagated from `sourceMetadata.messageId`.
+    if (
+      !approvalMessageTs ||
+      !isTrackedApprovalPromptTs(
+        sourceChannel,
+        conversationExternalId,
+        approvalMessageTs,
+      )
+    ) {
+      return { handled: true, type: "stale_ignored" };
+    }
+
     const allPending = getAllPendingApprovalsByGuardianChat(
       sourceChannel,
       conversationExternalId,
@@ -493,8 +519,12 @@ export async function handleApprovalInterception(
   // ── Slack reaction path ──
   // Reactions produce `callbackData` of the form `reaction:<emoji_name>`.
   // Only guardians can approve via reaction — non-guardian reactions are
-  // silently ignored to prevent self-approval.
-  if (callbackData?.startsWith("reaction:")) {
+  // silently ignored to prevent self-approval. `reaction_removed:` never
+  // expresses an approval intent.
+  if (
+    callbackData?.startsWith("reaction:") &&
+    !callbackData.startsWith("reaction_removed:")
+  ) {
     if (trustCtx.trustClass !== "guardian") {
       return { handled: true, type: "stale_ignored" };
     }

package/src/runtime/routes/guardian-approval-prompt.ts

@@ -17,6 +17,7 @@ import {
 } from "../gateway-client.js";
 import { buildActionLegend } from "../guardian-decision-types.js";
 import type { ApprovalCopyGenerator } from "../http-types.js";
+import { trackApprovalPromptTs } from "./approval-prompt-ts-tracker.js";
 import { requiredDecisionKeywords } from "./channel-route-shared.js";
 
 const log = getLogger("runtime-http");
@@ -141,7 +142,7 @@ export async function deliverGeneratedApprovalPrompt(
     }
 
     try {
-      await deliverApprovalPrompt(
+      const deliveryResult = await deliverApprovalPrompt(
         replyCallbackUrl,
         chatId,
         enrichedText,
@@ -149,6 +150,9 @@ export async function deliverGeneratedApprovalPrompt(
         assistantId,
         bearerToken,
       );
+      if (deliveryResult.ts) {
+        trackApprovalPromptTs(sourceChannel, chatId, deliveryResult.ts);
+      }
       return true;
     } catch (err) {
       log.error(
@@ -168,7 +172,7 @@ export async function deliverGeneratedApprovalPrompt(
     const taggedFallback = `${plainTextFallback}\n[ref:${uiMetadata.requestId}]`;
 
     try {
-      await deliverChannelReply(
+      const fallbackResult = await deliverChannelReply(
         replyCallbackUrl,
         {
           chatId,
@@ -177,6 +181,9 @@ export async function deliverGeneratedApprovalPrompt(
         },
         bearerToken,
       );
+      if (fallbackResult.ts) {
+        trackApprovalPromptTs(sourceChannel, chatId, fallbackResult.ts);
+      }
       return true;
     } catch (err) {
       log.error(
@@ -197,7 +204,7 @@ export async function deliverGeneratedApprovalPrompt(
   const taggedPlainText = `${plainText}\n[ref:${uiMetadata.requestId}]`;
 
   try {
-    await deliverChannelReply(
+    const plainResult = await deliverChannelReply(
       replyCallbackUrl,
       {
         chatId,
@@ -206,6 +213,9 @@ export async function deliverGeneratedApprovalPrompt(
       },
       bearerToken,
     );
+    if (plainResult.ts) {
+      trackApprovalPromptTs(sourceChannel, chatId, plainResult.ts);
+    }
     return true;
   } catch (err) {
     log.error(

package/src/runtime/routes/home-feed-routes.ts

@@ -26,8 +26,12 @@ import {
   type FeedItem,
   feedItemSchema,
   type FeedItemStatus,
+  lowPriorityCollapsedSchema,
+  suggestedPromptSchema,
 } from "../../home/feed-types.js";
 import { patchFeedItemStatus, readHomeFeed } from "../../home/feed-writer.js";
+import { runRollupProducer } from "../../home/rollup-producer.js";
+import { getSuggestedPrompts } from "../../home/suggested-prompts.js";
 import {
   addMessage,
   createConversation,
@@ -38,6 +42,26 @@ import type { RouteDefinition } from "../http-router.js";
 
 const log = getLogger("home-feed-routes");
 
+/**
+ * Debounce window for the on-visit rollup refresh. A GET on the feed
+ * route fires the rollup producer fire-and-forget at most once per
+ * window — repeat GETs within this interval (e.g. from a client that
+ * polls aggressively, or from multiple panels opening in rapid
+ * succession) skip the trigger and just return the cached feed.
+ */
+const ON_VISIT_REFRESH_DEBOUNCE_MS = 10 * 60 * 1000;
+
+let lastOnVisitRefreshAt = 0;
+
+/**
+ * Reset the on-visit debounce gate. Test-only — production callers
+ * should never touch this. Exported with an underscore-prefixed name
+ * so lint rules can flag misuse.
+ */
+export function __resetOnVisitRefreshStateForTests(): void {
+  lastOnVisitRefreshAt = 0;
+}
+
 // ---------------------------------------------------------------------------
 // Response / request schemas
 // ---------------------------------------------------------------------------
@@ -52,10 +76,12 @@ const getHomeFeedResponseSchema = z.object({
   items: z.array(feedItemSchema),
   updatedAt: z.string(),
   contextBanner: contextBannerSchema,
+  suggestedPrompts: z.array(suggestedPromptSchema),
+  lowPriorityCollapsed: lowPriorityCollapsedSchema,
 });
 
 const patchFeedItemRequestSchema = z.object({
-  status: z.enum(["new", "seen", "acted_on"]),
+  status: z.enum(["new", "seen", "acted_on", "dismissed"]),
 });
 
 // ---------------------------------------------------------------------------
@@ -148,6 +174,14 @@ export async function handleGetHomeFeed(req: Request): Promise<Response> {
     return item.minTimeAway <= timeAwaySeconds;
   });
 
+  // Compute low-priority metadata the client can use to decide how
+  // to render collapsed sections. All items stay in the response —
+  // the client handles collapsing in the UI layer.
+  const LOW_PRIORITY_THRESHOLD = 30;
+  const lowPriorityItems = filtered.filter(
+    (item) => item.priority < LOW_PRIORITY_THRESHOLD,
+  );
+
   const now = new Date();
   const contextBanner = {
     greeting: computeGreeting(now),
@@ -155,27 +189,111 @@ export async function handleGetHomeFeed(req: Request): Promise<Response> {
     newCount: filtered.filter((i) => i.status === "new").length,
   };
 
+  const lowPriorityCollapsed = {
+    count: lowPriorityItems.length,
+    itemIds: lowPriorityItems.map((item) => item.id),
+  };
+
+  const suggestedPrompts = await getSuggestedPrompts();
+
   log.debug(
     {
       timeAwayBucket: timeAwayBucket(timeAwaySeconds),
       totalItems: feed.items.length,
       filteredItems: filtered.length,
+      lowPriorityCount: lowPriorityItems.length,
       newCount: contextBanner.newCount,
+      suggestedPromptsCount: suggestedPrompts.length,
     },
     "GET /v1/home/feed",
   );
 
+  // Fire the on-visit rollup refresh AFTER computing the response so
+  // nothing in the trigger path can delay the GET. The rollup runs
+  // fire-and-forget; its writes will publish `home_feed_updated` via
+  // the writer's SSE path, and the client auto-refreshes.
+  maybeTriggerOnVisitRollupRefresh(now);
+
   return Response.json({
     items: filtered,
     updatedAt: feed.updatedAt,
     contextBanner,
+    suggestedPrompts,
+    lowPriorityCollapsed,
   });
 }
 
+/**
+ * Fire the rollup producer fire-and-forget when the debounce window
+ * has elapsed since the last trigger. Returns immediately — the
+ * caller never awaits the rollup, and any error inside the producer
+ * is swallowed into a warn log so an LLM hiccup can never turn a
+ * GET /v1/home/feed into a 500.
+ *
+ * The debounce is deliberately set in this module rather than the
+ * producer itself so the producer stays reusable from the scheduler
+ * (which has its own separate 2h safety-net cadence). The
+ * producer's internal in-flight guard handles the rare race where
+ * both the scheduler and the route fire at the same instant.
+ *
+ * Debounce semantics: we eager-advance `lastOnVisitRefreshAt` before
+ * awaiting the producer so concurrent GETs during the LLM call are
+ * blocked at the guard check above. When the producer returns with
+ * a skip reason that short-circuited BEFORE the LLM call
+ * (`no_provider`, `no_actions`, `in_flight`) we roll the gate back
+ * to its previous value — burning the full 10-minute window on a
+ * daemon that hasn't finished booting would leave Home stale the
+ * whole time the user is actively trying to refresh. Real LLM
+ * attempts (success / `empty_items` / `malformed_output` /
+ * `provider_error`) keep the advanced gate so a broken producer
+ * can't be hammered by an aggressive client.
+ */
+function maybeTriggerOnVisitRollupRefresh(now: Date): void {
+  const nowMs = now.getTime();
+  if (nowMs - lastOnVisitRefreshAt < ON_VISIT_REFRESH_DEBOUNCE_MS) return;
+  const previousRefreshAt = lastOnVisitRefreshAt;
+  lastOnVisitRefreshAt = nowMs;
+  void runRollupProducer(now)
+    .then((result) => {
+      const skippedBeforeLLM =
+        result.skippedReason === "no_provider" ||
+        result.skippedReason === "no_actions" ||
+        result.skippedReason === "in_flight";
+      if (skippedBeforeLLM) {
+        // Only roll back if no subsequent GET has since advanced the
+        // gate past our eager value. Defensive: given the guard at
+        // the top of this function a concurrent GET shouldn't be
+        // able to advance past our `nowMs`, but if some future
+        // refactor changes that we don't want to silently clobber a
+        // newer timestamp.
+        if (lastOnVisitRefreshAt === nowMs) {
+          lastOnVisitRefreshAt = previousRefreshAt;
+        }
+        log.debug(
+          { skippedReason: result.skippedReason },
+          "On-visit rollup refresh skipped; debounce gate rolled back",
+        );
+      } else if (result.skippedReason !== null) {
+        log.debug(
+          { skippedReason: result.skippedReason },
+          "On-visit rollup refresh skipped",
+        );
+      } else {
+        log.info(
+          { wroteCount: result.wroteCount },
+          "On-visit rollup refresh completed",
+        );
+      }
+    })
+    .catch((err) => {
+      log.warn({ err }, "On-visit rollup refresh failed");
+    });
+}
+
 /**
  * `PATCH /v1/home/feed/:id`.
  *
- * Body: `{ status: "new" | "seen" | "acted_on" }`. Returns the updated
+ * Body: `{ status: "new" | "seen" | "acted_on" | "dismissed" }`. Returns the updated
  * `FeedItem` on success.
  *
  * Disambiguates the writer's `null` return by looking up the item via