@vellumai/assistant 0.10.4-dev.202607011113.fffc936 → 0.10.4-dev.202607011307.b79a0c5

package/openapi.yaml

@@ -18137,6 +18137,12 @@ paths:
                     - low
                     - medium
                     - high
+                hidden:
+                  description:
+                    When true, persist the user message but suppress it from the UI transcript (it stays in LLM-side history
+                    and still drives the turn). Used to prime a proactive assistant greeting without showing the
+                    triggering user message. Honored on the standard send path only.
+                  type: boolean
                 onboarding:
                   type: object
                   properties:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.4-dev.202607011113.fffc936",
+  "version": "0.10.4-dev.202607011307.b79a0c5",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/conversation-routes-guardian-reply.test.ts

@@ -323,6 +323,90 @@ describe("handleSendMessage canonical guardian reply interception", () => {
     expect(runAgentLoop).toHaveBeenCalledTimes(1);
   });
 
+  test("hidden:true persists hidden metadata and still runs the turn", async () => {
+    listPendingByDestinationMock.mockReturnValue([]);
+    listCanonicalMock.mockReturnValue([]);
+    routeGuardianReplyMock.mockResolvedValue({
+      consumed: false,
+      decisionApplied: false,
+      type: "not_consumed",
+    });
+
+    const persistUserMessage = mock(async () => ({
+      id: "persisted-user-id",
+      deduplicated: false,
+    }));
+    const runAgentLoop = mock(async () => undefined);
+    const session = {
+      setTrustContext: () => {},
+      updateClient: () => {},
+      emitConfirmationStateChanged: () => {},
+      emitActivityState: () => {},
+      setTurnChannelContext: () => {},
+      setTurnInterfaceContext: () => {},
+      ensureActorScopedHistory: async () => {},
+      usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
+      isProcessing: () => false,
+      hasAnyPendingConfirmation: () => false,
+      denyAllPendingConfirmations: () => {},
+      enqueueMessage: () => ({ queued: true, requestId: "queued-id" }),
+      persistUserMessage,
+      runAgentLoop,
+      getMessages: () => [] as unknown[],
+      assistantId: "self",
+      trustContext: undefined,
+      hasPendingConfirmation: () => false,
+      setHostBrowserProxy: () => {},
+      setHostCuProxy: () => {},
+      setHostAppControlProxy: () => {},
+      restoreBrowserProxyAvailability: () => {},
+      addPreactivatedSkillId: () => {},
+    } as unknown as import("../daemon/conversation.js").Conversation;
+
+    const req = new Request("http://localhost/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-vellum-actor-principal-id": "test-user",
+        "x-vellum-principal-type": "actor",
+      },
+      body: JSON.stringify({
+        conversationKey: "guardian-conversation-key",
+        content: "Hey, how are you? Show me what you can do.",
+        sourceChannel: "vellum",
+        interface: "web",
+        hidden: true,
+      }),
+    });
+
+    const res = await callHandler(
+      (args) =>
+        handleSendMessage(args, {
+          sendMessageDeps: {
+            getOrCreateConversation: async () => session,
+            assistantEventHub: { publish: async () => {} } as any,
+            resolveAttachments: () => [],
+          },
+        }),
+      req,
+      undefined,
+      202,
+    );
+
+    expect(res.status).toBe(202);
+    // The hidden message is persisted with metadata.hidden so the list-messages
+    // filter suppresses it from the UI transcript while keeping it in LLM-side
+    // history (see list-messages-hidden-metadata.test.ts for the filter).
+    expect(persistUserMessage).toHaveBeenCalledTimes(1);
+    const persistArgs = (persistUserMessage as any).mock.calls[0][0] as {
+      metadata?: { hidden?: boolean };
+    };
+    expect(persistArgs.metadata?.hidden).toBe(true);
+    // The turn still runs — the assistant's reply streams normally, so the chat
+    // reads as a proactive greeting.
+    expect(runAgentLoop).toHaveBeenCalledTimes(1);
+  });
+
   test("excludes stale tool_approval hints without a live pending confirmation", async () => {
     listPendingByDestinationMock.mockReturnValue([
       { id: "tool-approval-live", kind: "tool_approval" },

package/src/daemon/lifecycle.ts

@@ -873,12 +873,9 @@ export async function runDaemon(): Promise<void> {
   writePid(process.pid);
 
   // Install the `assistant` CLI symlink idempotently on every daemon start.
-  // Non-blocking — failures are logged but don't affect startup.
-  try {
-    installAssistantSymlink();
-  } catch (err) {
-    log.warn({ err }, "Assistant symlink installation failed — continuing");
-  }
+  // Best-effort and self-contained: every step swallows its own errors, so a
+  // failure never affects startup.
+  installAssistantSymlink();
 
   startEmbeddingRuntimeManager();
 

package/src/persistence/schema/conversation-groups.ts

@@ -0,0 +1,12 @@
+import { integer, real, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const conversationGroups = sqliteTable("conversation_groups", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  sortPosition: real("sort_position").notNull().default(0),
+  isSystemGroup: integer("is_system_group", { mode: "boolean" })
+    .notNull()
+    .default(false),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});

package/src/persistence/schema/documents.ts

@@ -0,0 +1,65 @@
+import {
+  index,
+  integer,
+  primaryKey,
+  sqliteTable,
+  text,
+} from "drizzle-orm/sqlite-core";
+
+import { conversations } from "./conversations.js";
+
+export const documents = sqliteTable("documents", {
+  surfaceId: text("surface_id").primaryKey(),
+  conversationId: text("conversation_id")
+    .notNull()
+    .references(() => conversations.id, { onDelete: "cascade" }),
+  title: text("title").notNull(),
+  content: text("content").notNull(),
+  wordCount: integer("word_count").notNull().default(0),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
+// Junction table mapping a document surface to every conversation it appears in.
+export const documentConversations = sqliteTable(
+  "document_conversations",
+  {
+    surfaceId: text("surface_id")
+      .notNull()
+      .references(() => documents.surfaceId, { onDelete: "cascade" }),
+    conversationId: text("conversation_id").notNull(),
+    createdAt: integer("created_at").notNull(),
+  },
+  (table) => [
+    primaryKey({ columns: [table.surfaceId, table.conversationId] }),
+    index("idx_doc_conv_conversation_id").on(table.conversationId),
+  ],
+);
+
+export const documentComments = sqliteTable(
+  "document_comments",
+  {
+    id: text("id").primaryKey(),
+    surfaceId: text("surface_id")
+      .notNull()
+      .references(() => documents.surfaceId, { onDelete: "cascade" }),
+    conversationId: text("conversation_id").notNull(),
+    author: text("author").notNull(),
+    content: text("content").notNull(),
+    anchorStart: integer("anchor_start"),
+    anchorEnd: integer("anchor_end"),
+    anchorText: text("anchor_text"),
+    // Self-referential parent link (threaded replies). The FK to
+    // document_comments(id) ON DELETE CASCADE is enforced at the DB level.
+    parentCommentId: text("parent_comment_id"),
+    status: text("status").notNull().default("open"),
+    resolvedBy: text("resolved_by"),
+    resolvedAt: integer("resolved_at"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+  (table) => [
+    index("idx_document_comments_surface").on(table.surfaceId),
+    index("idx_document_comments_parent").on(table.parentCommentId),
+  ],
+);

package/src/persistence/schema/index.ts

@@ -3,12 +3,16 @@ export * from "./acp.js";
 export * from "./bookmarks.js";
 export * from "./calls.js";
 export * from "./contacts.js";
+export * from "./conversation-groups.js";
 export * from "./conversations.js";
+export * from "./documents.js";
 export * from "./guardian.js";
 export * from "./inference.js";
 export * from "./infrastructure.js";
 export * from "./memory-core.js";
 export * from "./memory-graph.js";
+export * from "./memory-injection.js";
 export * from "./notifications.js";
 export * from "./oauth.js";
 export * from "./tasks.js";
+export * from "./workflows.js";

package/src/persistence/schema/memory-injection.ts

@@ -0,0 +1,62 @@
+import {
+  index,
+  integer,
+  primaryKey,
+  sqliteTable,
+  text,
+} from "drizzle-orm/sqlite-core";
+
+// Time-series of memory-v2 card injections, used by the router to decay a
+// concept's recent injection pressure.
+export const memoryV2InjectionEvents = sqliteTable(
+  "memory_v2_injection_events",
+  {
+    id: integer("id").primaryKey(),
+    slug: text("slug").notNull(),
+    injectedAt: integer("injected_at").notNull(),
+  },
+  (table) => [
+    index("idx_memory_v2_injection_events_slug_time").on(
+      table.slug,
+      table.injectedAt,
+    ),
+    index("idx_memory_v2_injection_events_time").on(table.injectedAt),
+  ],
+);
+
+// Per-conversation record of every memory-v3 card ever injected, with a
+// pruned_at tombstone so re-injection can be suppressed after pruning.
+export const memoryV3EverInjected = sqliteTable(
+  "memory_v3_ever_injected",
+  {
+    conversationId: text("conversation_id").notNull(),
+    slug: text("slug").notNull(),
+    injectedAt: integer("injected_at").notNull(),
+    bytes: integer("bytes").notNull().default(0),
+    prunedAt: integer("pruned_at"),
+  },
+  (table) => [
+    primaryKey({ columns: [table.conversationId, table.slug] }),
+    index("idx_memory_v3_ever_injected_conv").on(table.conversationId),
+  ],
+);
+
+// Per-turn log of which memory-v3 cards were selected, with lane attribution.
+export const memoryV3Selections = sqliteTable(
+  "memory_v3_selections",
+  {
+    conversationId: text("conversation_id").notNull(),
+    turn: integer("turn").notNull(),
+    slug: text("slug").notNull(),
+    source: text("source").notNull(),
+    pinned: integer("pinned").notNull().default(0),
+    createdAt: integer("created_at").notNull(),
+    messageId: text("message_id"),
+    sectionOrdinal: integer("section_ordinal"),
+    sectionTitle: text("section_title"),
+  },
+  (table) => [
+    primaryKey({ columns: [table.conversationId, table.turn, table.slug] }),
+    index("idx_memory_v3_selections_conv").on(table.conversationId, table.turn),
+  ],
+);

package/src/persistence/schema/workflows.ts

@@ -0,0 +1,55 @@
+import {
+  index,
+  integer,
+  primaryKey,
+  sqliteTable,
+  text,
+} from "drizzle-orm/sqlite-core";
+
+export const workflowRuns = sqliteTable(
+  "workflow_runs",
+  {
+    id: text("id").primaryKey(),
+    name: text("name"),
+    scriptSource: text("script_source").notNull(),
+    scriptHash: text("script_hash").notNull(),
+    argsJson: text("args_json"),
+    capabilitiesJson: text("capabilities_json"),
+    status: text("status").notNull(),
+    conversationId: text("conversation_id"),
+    agentsSpawned: integer("agents_spawned").notNull().default(0),
+    inputTokens: integer("input_tokens").notNull().default(0),
+    outputTokens: integer("output_tokens").notNull().default(0),
+    resultJson: text("result_json"),
+    error: text("error"),
+    createdAt: integer("created_at"),
+    updatedAt: integer("updated_at"),
+    finishedAt: integer("finished_at"),
+    trustJson: text("trust_json"),
+  },
+  (table) => [
+    index("idx_workflow_runs_status_created_at").on(
+      table.status,
+      table.createdAt,
+    ),
+  ],
+);
+
+// Append-only journal of each workflow's agent() calls, keyed by run + sequence
+// for crash-recovery replay.
+export const workflowJournal = sqliteTable(
+  "workflow_journal",
+  {
+    runId: text("run_id").notNull(),
+    seq: integer("seq").notNull(),
+    callHash: text("call_hash").notNull(),
+    kind: text("kind").notNull(),
+    requestJson: text("request_json"),
+    resultJson: text("result_json"),
+    status: text("status").notNull(),
+    createdAt: integer("created_at"),
+    inputTokens: integer("input_tokens"),
+    outputTokens: integer("output_tokens"),
+  },
+  (table) => [primaryKey({ columns: [table.runId, table.seq] })],
+);

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

@@ -1275,6 +1275,11 @@ export async function handleSendMessage(
     interface?: string;
     conversationType?: string;
     automated?: boolean;
+    // Persist the user message but suppress it from the UI transcript (kept in
+    // LLM history). Used by flows like research-onboarding's "Let's chat"
+    // handoff to prime a proactive assistant greeting without showing the
+    // triggering user message. Honored on the standard send path only.
+    hidden?: boolean;
     bypassSecretCheck?: boolean;
     hostHomeDir?: string;
     hostUsername?: string;
@@ -2356,7 +2361,13 @@ export async function handleSendMessage(
     content: resolvedContent,
     attachments,
     requestId,
-    metadata: body.automated === true ? { automated: true } : undefined,
+    metadata:
+      body.automated === true || body.hidden === true
+        ? {
+            ...(body.automated === true ? { automated: true } : {}),
+            ...(body.hidden === true ? { hidden: true } : {}),
+          }
+        : undefined,
     clientMessageId,
   });
 
@@ -2370,14 +2381,20 @@ export async function handleSendMessage(
     };
   }
 
-  broadcastMessage({
-    type: "user_message_echo",
-    text: resolvedContent,
-    conversationId: mapping.conversationId,
-    messageId,
-    requestId,
-    clientMessageId,
-  });
+  // A hidden message is suppressed from the UI transcript: don't echo it back
+  // to clients (the echo would render a user bubble the list-messages filter
+  // otherwise hides). The turn still runs below, and the assistant's reply
+  // streams normally — so the chat reads as a proactive greeting.
+  if (body.hidden !== true) {
+    broadcastMessage({
+      type: "user_message_echo",
+      text: resolvedContent,
+      conversationId: mapping.conversationId,
+      messageId,
+      requestId,
+      clientMessageId,
+    });
+  }
   publishConversationMessagesChanged(mapping.conversationId, originClientId);
 
   // Fire-and-forget the agent loop; events flow to the hub via broadcastMessage.
@@ -2890,6 +2907,12 @@ export const ROUTES: RouteDefinition[] = [
         .optional(),
       inferenceProfile: z.string().nullable().optional(),
       riskThreshold: z.enum(VALID_RISK_THRESHOLDS).optional(),
+      hidden: z
+        .boolean()
+        .optional()
+        .describe(
+          "When true, persist the user message but suppress it from the UI transcript (it stays in LLM-side history and still drives the turn). Used to prime a proactive assistant greeting without showing the triggering user message. Honored on the standard send path only.",
+        ),
       onboarding: z
         .object({
           tools: z.array(z.string()),