@vellumai/assistant 0.6.4 → 0.6.6

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

@@ -70,28 +70,36 @@ describe("startFeedScheduler", () => {
     expect(summary2.gmailDigestRan).toBe(true);
   });
 
-  test("rollup only re-runs every 30 minutes", async () => {
+  test("rollup only re-runs every 2 hours as the safety-net cadence", async () => {
+    // The scheduler is the safety net; the primary trigger is the
+    // on-visit refresh in home-feed-routes.ts. Long cadence is
+    // intentional so the scheduler doesn't fight the route.
     handle = startFeedScheduler(defaultOptions());
 
     const t0 = new Date("2026-04-14T12:00:00.000Z");
     await handle.runOnce(t0);
 
-    // 5 min later — below the 30-min reflection gate.
-    const t1 = new Date("2026-04-14T12:05:00.000Z");
+    // 30 min later — below the 2-hour gate.
+    const t1 = new Date("2026-04-14T12:30:00.000Z");
     const summary1 = await handle.runOnce(t1);
     expect(summary1.rollupRan).toBe(false);
 
-    // 31 min later — past the 30-min gate, should re-run.
-    const t2 = new Date("2026-04-14T12:31:00.000Z");
+    // 1h later — still below the 2-hour gate.
+    const t2 = new Date("2026-04-14T13:00:00.000Z");
     const summary2 = await handle.runOnce(t2);
-    expect(summary2.rollupRan).toBe(true);
+    expect(summary2.rollupRan).toBe(false);
+
+    // 2h 1m later — past the gate, should re-run.
+    const t3 = new Date("2026-04-14T14:01:00.000Z");
+    const summary3 = await handle.runOnce(t3);
+    expect(summary3.rollupRan).toBe(true);
   });
 
   test("rollup cooldown is NOT advanced on no_provider so the next tick retries", async () => {
     // Mimic the daemon startup ordering: the scheduler boots before
     // the provider registry is ready. The first tick gets no_provider;
     // the next tick (even one second later) must still run the rollup
-    // instead of waiting 30 minutes.
+    // instead of waiting 2 hours.
     rollupRunner.mockImplementationOnce(async () => ({
       wroteCount: 0,
       skippedReason: "no_provider",
@@ -110,10 +118,30 @@ describe("startFeedScheduler", () => {
     expect(rollupRunner).toHaveBeenCalledTimes(2);
   });
 
+  test("rollup cooldown is NOT advanced on in_flight so the next tick retries", async () => {
+    // in_flight means another caller (on-visit refresh, usually) is
+    // already running the producer. Advancing the gate here would
+    // force the NEXT tick to wait out the full cadence window even
+    // though nothing broken happened — the other caller's result is
+    // effectively this tick's run.
+    rollupRunner.mockImplementationOnce(async () => ({
+      wroteCount: 0,
+      skippedReason: "in_flight",
+    }));
+
+    handle = startFeedScheduler(defaultOptions());
+    await handle.runOnce(new Date("2026-04-14T12:00:00.000Z"));
+    expect(rollupRunner).toHaveBeenCalledTimes(1);
+
+    const summary = await handle.runOnce(new Date("2026-04-14T12:00:01.000Z"));
+    expect(summary.rollupRan).toBe(true);
+    expect(rollupRunner).toHaveBeenCalledTimes(2);
+  });
+
   test("rollup cooldown is NOT advanced on no_actions so the next tick retries", async () => {
     // no_actions means the activity log was empty — no LLM call was
     // made. A subsequent tick should retry as soon as new actions
-    // land, not wait the full 30-minute window.
+    // land, not wait the full 2-hour window.
     rollupRunner.mockImplementationOnce(async () => ({
       wroteCount: 0,
       skippedReason: "no_actions",
@@ -131,7 +159,7 @@ describe("startFeedScheduler", () => {
 
   test("rollup cooldown IS advanced on other skip reasons to preserve backoff", async () => {
     // empty_items / malformed_output / provider_error are real LLM
-    // attempts — the next tick should be gated by the full 30-minute
+    // attempts — the next tick should be gated by the full 2-hour
     // window so a broken producer doesn't get hammered every tick.
     rollupRunner.mockImplementationOnce(async () => ({
       wroteCount: 0,
@@ -142,8 +170,8 @@ describe("startFeedScheduler", () => {
     await handle.runOnce(new Date("2026-04-14T12:00:00.000Z"));
     expect(rollupRunner).toHaveBeenCalledTimes(1);
 
-    // Ten minutes later — below the 30-min gate, should NOT re-run.
-    const summary = await handle.runOnce(new Date("2026-04-14T12:10:00.000Z"));
+    // Thirty minutes later — below the 2-hour gate, should NOT re-run.
+    const summary = await handle.runOnce(new Date("2026-04-14T12:30:00.000Z"));
     expect(summary.rollupRan).toBe(false);
     expect(rollupRunner).toHaveBeenCalledTimes(1);
   });

package/src/home/__tests__/rollup-producer.test.ts

@@ -364,6 +364,50 @@ describe("runRollupProducer", () => {
     expect(result.wroteCount).toBe(0);
   });
 
+  test("concurrent calls short-circuit the second with in_flight", async () => {
+    // Gate the provider behind a manually-controlled deferred so we
+    // can observe state while the first call is still inside the
+    // producer body. Without this we'd race the runtime's microtask
+    // scheduler to check in-flightness.
+    let release: ((value: ContentBlock[]) => void) | null = null;
+    const gated = new Promise<ContentBlock[]>((resolve) => {
+      release = resolve;
+    });
+    const provider = makeProvider(async () => {
+      const content = await gated;
+      return {
+        content,
+        model: "mock-model",
+        usage: { inputTokens: 0, outputTokens: 0 },
+        stopReason: "tool_use",
+      };
+    });
+
+    const first = runRollupProducer(new Date(), {
+      writeItem,
+      loadRelationshipState: stubRelationshipState,
+      loadRecentActions: stubLoadRecentActions(oneAction),
+      resolveProvider: () => provider,
+    });
+
+    // Second call lands while `first` is blocked awaiting the gated
+    // provider response — the in-flight guard must short-circuit it.
+    const second = await runRollupProducer(new Date(), {
+      writeItem,
+      loadRelationshipState: stubRelationshipState,
+      loadRecentActions: stubLoadRecentActions(oneAction),
+      resolveProvider: () => provider,
+    });
+
+    expect(second.skippedReason).toBe("in_flight");
+    expect(second.wroteCount).toBe(0);
+
+    // Release the first call and let it finish.
+    release!([toolUseContent({ items: [] })]);
+    const firstResult = await first;
+    expect(firstResult.skippedReason).toBe("empty_items");
+  });
+
   test("clamps priority to the valid [0, 100] window", async () => {
     const provider = scriptedProvider([
       toolUseContent({

package/src/home/assistant-feed-authoring.ts

@@ -41,6 +41,7 @@ import {
   feedItemSchema,
   type FeedItemSource,
   type FeedItemType,
+  type FeedItemUrgency,
 } from "./feed-types.js";
 import { appendFeedItem } from "./feed-writer.js";
 
@@ -80,6 +81,8 @@ export interface WriteAssistantFeedItemParams {
   minTimeAway?: number;
   /** Absolute ISO-8601 expiry timestamp. */
   expiresAt?: string;
+  /** Visual urgency treatment — controls badge color independently of sort priority. */
+  urgency?: FeedItemUrgency;
 }
 
 /**
@@ -110,6 +113,7 @@ export async function writeAssistantFeedItem(
     timestamp: now,
     createdAt: now,
     actions: params.actions,
+    urgency: params.urgency,
     minTimeAway: params.minTimeAway,
     expiresAt: params.expiresAt,
   };

package/src/home/emit-feed-event.ts

@@ -41,8 +41,10 @@ import { randomUUID } from "node:crypto";
 import {
   type FeedAction,
   type FeedItem,
+  type FeedItemDetailPanel,
   feedItemSchema,
   type FeedItemSource,
+  type FeedItemUrgency,
 } from "./feed-types.js";
 import { appendFeedItem } from "./feed-writer.js";
 
@@ -93,6 +95,12 @@ export interface EmitFeedEventParams {
    * until the user dismisses it (default for activity-log actions).
    */
   expiresAt?: string;
+  /** Visual urgency treatment — controls badge color independently of sort priority. */
+  urgency?: FeedItemUrgency;
+  /** Optional conversation this feed item is associated with. */
+  conversationId?: string;
+  /** Server-driven detail panel descriptor; when present, the client opens this panel kind. */
+  detailPanel?: FeedItemDetailPanel;
 }
 
 /**
@@ -144,6 +152,9 @@ export async function emitFeedEvent(
     timestamp: now,
     createdAt: now,
     actions: params.actions,
+    urgency: params.urgency,
+    conversationId: params.conversationId,
+    detailPanel: params.detailPanel,
     minTimeAway: params.minTimeAway,
     expiresAt: params.expiresAt,
   };

package/src/home/feed-scheduler.ts

@@ -43,7 +43,15 @@ const TICK_INTERVAL_MS = 5 * 60 * 1000;
 
 /** Per-producer minimum gap between runs. */
 const GMAIL_DIGEST_INTERVAL_MS = 5 * 60 * 1000;
-const ROLLUP_INTERVAL_MS = 30 * 60 * 1000;
+/**
+ * Roll-up cadence is deliberately long — 120 minutes — because the
+ * scheduler is the *safety net*, not the primary trigger. Opening the
+ * Home page fires a debounced on-visit refresh in the HTTP route (see
+ * `runtime/routes/home-feed-routes.ts`), which is the path most users
+ * actually hit. The scheduler exists so the feed still stays fresh
+ * for long idle stretches where nobody opens the Home page.
+ */
+const ROLLUP_INTERVAL_MS = 2 * 60 * 60 * 1000;
 
 export interface FeedSchedulerHandle {
   /** Stops the interval. Safe to call multiple times. */
@@ -146,8 +154,9 @@ export function startFeedScheduler(
             "Rollup producer ran",
           );
           // Only advance the cooldown gate when the producer actually
-          // had a chance to run the LLM. Two skip reasons short-circuit
-          // before any provider call and should NOT burn the window:
+          // had a chance to run the LLM. Three skip reasons short-
+          // circuit before any provider call and should NOT burn the
+          // window:
           //   - `no_provider`: the provider registry wasn't ready yet
           //     (happens on the startup tick because the feed scheduler
           //     boots before the provider init pass in
@@ -155,12 +164,19 @@ export function startFeedScheduler(
           //   - `no_actions`: there was nothing to roll up. A subsequent
           //     tick should retry as soon as new actions land, not wait
           //     the full window.
+          //   - `in_flight`: another caller (usually the on-visit
+          //     refresh trigger in `home-feed-routes.ts`) is already
+          //     running the rollup. That caller's result effectively
+          //     counts as this scheduler tick's real run; bumping the
+          //     gate here would force the NEXT tick to also wait out
+          //     the full window even though nothing broken happened.
           // Every other outcome — success, empty items, malformed
           // output, provider error — is a real LLM attempt and does
           // advance the gate so a broken producer doesn't hammer us.
           if (
             result.skippedReason !== "no_provider" &&
-            result.skippedReason !== "no_actions"
+            result.skippedReason !== "no_actions" &&
+            result.skippedReason !== "in_flight"
           ) {
             lastRollupAt = nowMs;
           }

package/src/home/feed-types.ts

@@ -25,7 +25,7 @@ import { z } from "zod";
 export type FeedItemType = "nudge" | "digest" | "action" | "thread";
 
 /** User-facing lifecycle of a feed item. */
-export type FeedItemStatus = "new" | "seen" | "acted_on";
+export type FeedItemStatus = "new" | "seen" | "acted_on" | "dismissed";
 
 /**
  * Origin of the underlying event.
@@ -34,7 +34,12 @@ export type FeedItemStatus = "new" | "seen" | "acted_on";
  * stays exhaustive. Future sources will be added explicitly rather
  * than letting arbitrary strings slip through.
  */
-export type FeedItemSource = "gmail" | "slack" | "calendar" | "assistant";
+export type FeedItemSource =
+  | "gmail"
+  | "slack"
+  | "calendar"
+  | "assistant"
+  | "telegram";
 
 /**
  * Internal field used by the hybrid authoring resolver (PR 5 writer).
@@ -46,6 +51,9 @@ export type FeedItemSource = "gmail" | "slack" | "calendar" | "assistant";
  */
 export type FeedItemAuthor = "assistant" | "platform";
 
+/** Visual urgency treatment — controls badge color independently of sort priority. */
+export type FeedItemUrgency = "low" | "medium" | "high" | "critical";
+
 /**
  * A single action button attached to a feed item.
  *
@@ -59,6 +67,20 @@ export interface FeedAction {
   prompt: string;
 }
 
+/** Which detail panel the macOS client should open for this feed item. */
+export type FeedItemDetailPanelKind =
+  | "emailDraft"
+  | "documentPreview"
+  | "permissionChat"
+  | "paymentAuth"
+  | "toolPermission"
+  | "updatesList";
+
+/** Server-driven detail panel descriptor attached to a feed item. */
+export interface FeedItemDetailPanel {
+  kind: FeedItemDetailPanelKind;
+}
+
 /**
  * A single item rendered in the Home feed.
  *
@@ -78,7 +100,7 @@ export interface FeedItem {
   priority: number;
   title: string;
   summary: string;
-  /** Optional; when present must be one of the four v1 sources. */
+  /** Optional; when present must be one of the v1 sources. */
   source?: FeedItemSource;
   /** Event time (ISO-8601). */
   timestamp: string;
@@ -89,12 +111,28 @@ export interface FeedItem {
   /** Minimum seconds the user must be away before the item is shown. */
   minTimeAway?: number;
   actions?: FeedAction[];
+  /** Visual urgency treatment — controls badge color independently of sort priority. */
+  urgency?: FeedItemUrgency;
+  /** Optional conversation this feed item is associated with. */
+  conversationId?: string;
+  /** Server-driven detail panel descriptor; when present, the client opens this panel kind. */
+  detailPanel?: FeedItemDetailPanel;
   /** Internal: who authored this item. */
   author: FeedItemAuthor;
   /** Internal: ISO-8601 writer-record time, used for ordering + TTL. */
   createdAt: string;
 }
 
+/**
+ * Summary of low-priority items that were collapsed out of the main
+ * feed list. The client renders this as a single "N low priority
+ * updates" line instead of showing each item individually.
+ */
+export interface LowPriorityCollapsed {
+  count: number;
+  itemIds: string[];
+}
+
 /**
  * On-disk file format for `~/.vellum/workspace/data/home-feed.json`.
  *
@@ -108,29 +146,66 @@ export interface HomeFeedFile {
   updatedAt: string;
 }
 
+/**
+ * Origin of a suggested prompt — whether it was deterministically derived
+ * (e.g. from a missing OAuth connection) or generated by the assistant.
+ */
+export type SuggestedPromptSource = "deterministic" | "assistant";
+
+/**
+ * A prompt suggestion shown at the top of the Home page.
+ *
+ * Deterministic prompts are derived from workspace state (e.g. missing
+ * OAuth connections). Assistant-generated prompts are contextual
+ * conversation starters produced by the LLM.
+ */
+export interface SuggestedPrompt {
+  id: string;
+  label: string;
+  icon?: string;
+  prompt: string;
+  source: SuggestedPromptSource;
+}
+
 // ---------------------------------------------------------------------------
 // Zod schemas
 // ---------------------------------------------------------------------------
 
 const feedItemTypeSchema = z.enum(["nudge", "digest", "action", "thread"]);
 
-const feedItemStatusSchema = z.enum(["new", "seen", "acted_on"]);
+const feedItemStatusSchema = z.enum(["new", "seen", "acted_on", "dismissed"]);
 
 const feedItemSourceSchema = z.enum([
   "gmail",
   "slack",
   "calendar",
   "assistant",
+  "telegram",
 ]);
 
 const feedItemAuthorSchema = z.enum(["assistant", "platform"]);
 
+const feedItemUrgencySchema = z.enum(["low", "medium", "high", "critical"]);
+
 const feedActionSchema = z.object({
   id: z.string(),
   label: z.string(),
   prompt: z.string(),
 });
 
+const feedItemDetailPanelKindSchema = z.enum([
+  "emailDraft",
+  "documentPreview",
+  "permissionChat",
+  "paymentAuth",
+  "toolPermission",
+  "updatesList",
+]);
+
+const feedItemDetailPanelSchema = z.object({
+  kind: feedItemDetailPanelKindSchema,
+});
+
 /**
  * Schema for a single `FeedItem`.
  *
@@ -157,10 +232,28 @@ export const feedItemSchema = z.object({
   expiresAt: z.string().optional(),
   minTimeAway: z.number().int().min(0).optional(),
   actions: z.array(feedActionSchema).optional(),
+  urgency: feedItemUrgencySchema.optional(),
+  conversationId: z.string().optional(),
+  detailPanel: feedItemDetailPanelSchema.optional(),
   author: feedItemAuthorSchema,
   createdAt: z.string(),
 });
 
+const suggestedPromptSourceSchema = z.enum(["deterministic", "assistant"]);
+
+export const suggestedPromptSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  icon: z.string().optional(),
+  prompt: z.string(),
+  source: suggestedPromptSourceSchema,
+});
+
+export const lowPriorityCollapsedSchema = z.object({
+  count: z.number().int().min(0),
+  itemIds: z.array(z.string()),
+});
+
 /** Schema for the on-disk `home-feed.json` file. */
 export const homeFeedFileSchema = z.object({
   version: z.literal(1),

package/src/home/relationship-state-writer.ts

@@ -161,7 +161,7 @@ export async function computeRelationshipState(): Promise<RelationshipState> {
   //   1. The guardian contact's per-user file (`users/<slug>.md`), resolved
   //      via `resolveGuardianPersonaPath()` — this is the canonical location
   //      after workspace migration 031 and handles slugged userFiles like
-  //      `users/sidd.md` that were invisible to a hardcoded `default.md`
+  //      `users/alice.md` that were invisible to a hardcoded `default.md`
   //      lookup.
   //   2. Legacy workspace-root `USER.md` as a last-ditch fallback for very
   //      old workspaces that never ran migration 031.
@@ -361,7 +361,7 @@ export async function backfillRelationshipStateIfMissing(): Promise<void> {
  * user content:
  *
  *   1. `resolveGuardianPersonaPath()` via contact-store — the canonical
- *      per-guardian slugged file (e.g. `users/sidd.md`).
+ *      per-guardian slugged file (e.g. `users/alice.md`).
  *   2. `users/default.md` — the default-guardian persona file that the
  *      workspace migration leaves in place. Catches the window where
  *      the resolver throws or returns null but the file-backed content

package/src/home/rewrite-command-preview.ts

@@ -0,0 +1,66 @@
+import { getConfiguredProvider } from "../providers/provider-send-message.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("command-preview-rewriter");
+const REWRITE_TIMEOUT_MS = 3000;
+const REWRITE_MAX_TOKENS = 100;
+
+const SYSTEM_PROMPT = `You rewrite technical computer commands into simple, human-readable descriptions.
+Output ONLY the rewritten description — no quotes, no explanation, no preamble.
+Keep it under 15 words. Use plain language a non-technical person would understand.
+Examples:
+- "ls -la ~/Desktop" → "View files on the desktop"
+- "cat ~/.bashrc" → "Read shell configuration file"
+- "rm -rf /tmp/cache" → "Delete temporary cache files"
+- "grep -r 'password' ." → "Search files for the word 'password'"
+- "curl https://api.example.com/users" → "Fetch user data from an API"`;
+
+export async function rewriteCommandPreview(
+  toolName: string,
+  commandPreview: string,
+): Promise<string | null> {
+  try {
+    const provider = await getConfiguredProvider("feedEventCopy");
+    if (!provider) return null;
+
+    const response = await provider.sendMessage(
+      [
+        {
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: `Tool: ${toolName}\nCommand: ${commandPreview}`,
+            },
+          ],
+        },
+      ],
+      [],
+      SYSTEM_PROMPT,
+      {
+        config: {
+          max_tokens: REWRITE_MAX_TOKENS,
+          callSite: "feedEventCopy",
+        },
+        signal: AbortSignal.timeout(REWRITE_TIMEOUT_MS),
+      },
+    );
+
+    const block = response.content.find((entry) => entry.type === "text");
+    const text =
+      block && "text" in block ? (block as { text: string }).text.trim() : "";
+    if (!text) return null;
+    return (
+      text
+        .replace(/^["'`]+/, "")
+        .replace(/["'`]+$/, "")
+        .trim() || null
+    );
+  } catch (err) {
+    log.warn(
+      { err, toolName, commandPreview },
+      "Command preview rewrite failed",
+    );
+    return null;
+  }
+}

package/src/home/rollup-producer.ts

@@ -144,10 +144,16 @@ export interface RollupResult {
    * `no_actions` means there was nothing to roll up — a quiet but
    * normal outcome that does not advance the cooldown gate (no point
    * re-running until new actions land).
+   *
+   * `in_flight` means another caller is already running the producer.
+   * The second call short-circuits without entering the body so we
+   * never fire two concurrent LLM requests — this guards against the
+   * scheduler tick and an on-visit refresh trigger racing each other.
    */
   skippedReason:
     | "no_provider"
     | "no_actions"
+    | "in_flight"
     | "empty_items"
     | "provider_error"
     | "malformed_output"
@@ -169,6 +175,16 @@ export interface RollupProducerDeps {
   resolveProvider?: () => Provider | null;
 }
 
+/**
+ * Module-level in-flight guard. Prevents two callers (e.g. the
+ * scheduler tick and an on-visit refresh trigger) from launching two
+ * concurrent LLM requests. A second caller short-circuits with
+ * `skippedReason: "in_flight"` without entering the body. The lock
+ * is released in the `finally` so a thrown exception can't strand
+ * it in the `true` state.
+ */
+let producerInFlight = false;
+
 /**
  * Run one roll-up pass. Loads recent action items from the feed plus
  * relationship state, builds a user prompt around them, asks the
@@ -178,6 +194,21 @@ export interface RollupProducerDeps {
 export async function runRollupProducer(
   now: Date = new Date(),
   deps: RollupProducerDeps = {},
+): Promise<RollupResult> {
+  if (producerInFlight) {
+    return { wroteCount: 0, skippedReason: "in_flight" };
+  }
+  producerInFlight = true;
+  try {
+    return await runRollupProducerInner(now, deps);
+  } finally {
+    producerInFlight = false;
+  }
+}
+
+async function runRollupProducerInner(
+  now: Date,
+  deps: RollupProducerDeps,
 ): Promise<RollupResult> {
   const writeItem = deps.writeItem ?? writeAssistantFeedItem;
   const loadRelationshipState =
@@ -261,10 +292,10 @@ export async function runRollupProducer(
 
 function resolveDefaultProvider(): ReturnType<typeof getProvider> | null {
   const config = loadConfig();
-  if (!listProviders().includes(config.services.inference.provider)) {
+  if (!listProviders().includes(config.llm.default.provider)) {
     return null;
   }
-  return getProvider(config.services.inference.provider);
+  return getProvider(config.llm.default.provider);
 }
 
 /**
@@ -337,9 +368,7 @@ function buildUserPrompt(
  * the `type` narrowing to digest/thread (actions and nudges are
  * rejected here even if the model ignores the tool schema).
  */
-function coerceRollupItem(
-  raw: unknown,
-): WriteAssistantFeedItemParams | null {
+function coerceRollupItem(raw: unknown): WriteAssistantFeedItemParams | null {
   if (!raw || typeof raw !== "object") return null;
   const obj = raw as Record<string, unknown>;