@vellumai/assistant 0.8.3 → 0.8.4

package/src/daemon/handlers/conversations.ts

@@ -202,6 +202,85 @@ export function deleteQueuedMessage(
   return { removed: false, reason: "message_not_found" };
 }
 
+/**
+ * Steer a conversation to a specific queued message.
+ * Promotes the message to the head of the queue, marks the conversation
+ * as needing tool-result repair, and aborts the current generation so the
+ * drain path picks up the promoted message.
+ *
+ * Returns `{ steered: true }` on success, or `{ steered: false, reason }` on failure.
+ */
+export function steerToMessage(
+  conversationId: string,
+  requestId: string,
+):
+  | { steered: true }
+  | {
+      steered: false;
+      reason:
+        | "conversation_not_found"
+        | "message_not_found"
+        | "not_processing";
+    } {
+  const conversation = findConversation(conversationId);
+  if (!conversation) {
+    log.warn(
+      { conversationId, requestId },
+      "No conversation found for steer_to_message",
+    );
+    return { steered: false, reason: "conversation_not_found" };
+  }
+
+  if (!conversation.isProcessing()) {
+    log.warn(
+      { conversationId, requestId },
+      "Cannot steer: conversation is not processing",
+    );
+    return { steered: false, reason: "not_processing" };
+  }
+
+  const promoted = conversation.queue.promoteToHead(requestId);
+  if (!promoted) {
+    log.warn(
+      { conversationId, requestId },
+      "Queued message not found for steering",
+    );
+    return { steered: false, reason: "message_not_found" };
+  }
+
+  // Mark the conversation for tool-result repair so the drain path can
+  // inject synthetic tool results for any pending tool_use blocks that
+  // were abandoned by the aborted generation.
+  conversation.pendingSteerRepair = true;
+
+  // Broadcast the steer event so clients can update their UI.
+  broadcastMessage({
+    type: "message_steered",
+    conversationId,
+    requestId,
+  });
+
+  log.info(
+    { conversationId, requestId },
+    "Steering to queued message — aborting current generation",
+  );
+
+  // Abort the in-flight generation. The agent loop's finally block calls
+  // drainQueue, which will pick up the promoted message at the head.
+  // Unlike abortConversation, we do NOT clear the queue or dispose
+  // prompters — we want the queue to drain with the promoted message first.
+  const reason = createAbortReason(
+    "preempted_by_new_message",
+    "steerToMessage",
+    conversationId,
+  );
+  conversation.abortController?.abort(reason);
+  // Deny pending confirmations so the abort unblocks immediately.
+  conversation.denyAllPendingConfirmations();
+
+  return { steered: true };
+}
+
 // ---------------------------------------------------------------------------
 // HTTP handler (delegates to shared logic)
 // ---------------------------------------------------------------------------

package/src/daemon/handlers/shared.ts

@@ -92,6 +92,19 @@ export interface HistorySurface {
   completionSummary?: string;
 }
 
+/**
+ * Positional reference to a file attachment captured while walking the
+ * content array. The index of an entry in `RenderedHistoryContent.attachments`
+ * is what `contentOrder` references as `attachment:N`.
+ */
+export interface HistoryAttachmentRef {
+  /** Stable DB attachment id when persisted on the file block (`_attachmentId`). */
+  attachmentId?: string;
+  filename: string;
+  mimeType: string;
+  sizeBytes: number;
+}
+
 export interface RenderedHistoryContent {
   text: string;
   toolCalls: HistoryToolCall[];
@@ -99,12 +112,18 @@ export interface RenderedHistoryContent {
   toolCallsBeforeText: boolean;
   /** Text segments split by tool-call boundaries. */
   textSegments: string[];
-  /** Content block ordering using "text:N", "tool:N", "surface:N" encoding. */
+  /** Content block ordering using "text:N", "tool:N", "surface:N", "attachment:N" encoding. */
   contentOrder: string[];
   /** UI surfaces (widgets) embedded in the message. */
   surfaces: HistorySurface[];
   /** Thinking segments extracted from thinking blocks. */
   thinkingSegments: string[];
+  /**
+   * File attachments captured in content order. Index `N` matches an
+   * `attachment:N` entry in `contentOrder`. Callers align their DB-sourced
+   * attachment metadata to this ordering for inline placement.
+   */
+  attachments: HistoryAttachmentRef[];
 }
 
 /**
@@ -115,6 +134,8 @@ export interface RenderedHistoryContent {
 export interface SlackInboundMessageMetadata {
   /** Slack channel id (conversation external id) — recorded as `channelId`. */
   channelId: string;
+  /** Human-readable Slack channel name, when the gateway supplied it. */
+  channelName?: string;
   /** Slack `ts` for this message — required so persistence can record `channelTs`. */
   channelTs: string;
   /** Parent `thread_ts` when the message lives inside a thread; absent for top-level. */
@@ -123,6 +144,18 @@ export interface SlackInboundMessageMetadata {
   displayName?: string;
   /** Canonical Slack external user id for the sender, when available. */
   actorExternalUserId?: string;
+  /** Raw Slack profile timezone for the sender, when supplied. */
+  actorTimezone?: string;
+  /** Compact Slack profile timezone label for the sender, when supplied. */
+  actorTimezoneLabel?: string;
+  /** Raw Slack profile timezone offset in seconds, when supplied. */
+  actorTimezoneOffsetSeconds?: number;
+  /** Timezone used to render this message's timestamp. */
+  timestampTimezone?: string;
+  /** Compact label for the rendered timestamp timezone. */
+  timestampTimezoneLabel?: string;
+  /** Compact timezone label appended to the rendered speaker name. */
+  speakerTimezoneLabel?: string;
 }
 
 /**
@@ -144,8 +177,6 @@ export interface ConversationCreateOptions {
   authContext?: AuthContext;
   /** Whether this turn can block on interactive approval prompts. */
   isInteractive?: boolean;
-  /** Slack-only non-persisted notice injected into the active model turn. */
-  slackRuntimeContextNotice?: string;
   /**
    * Persisted user-facing content. When present, storage/UI use this value
    * while the model-facing turn continues to use `content`.
@@ -192,22 +223,42 @@ function clampAttachmentText(text: string): string {
   return `${text.slice(0, HISTORY_ATTACHMENT_TEXT_LIMIT)}<truncated />`;
 }
 
-function renderFileBlockForHistory(block: Record<string, unknown>): string {
+interface FileBlockMetadata {
+  mediaType: string;
+  filename: string;
+  sizeBytes: number;
+}
+
+function extractFileBlockMetadata(
+  block: Record<string, unknown>,
+): FileBlockMetadata {
   const source = isRecord(block.source) ? block.source : null;
-  const mediaType =
-    source && typeof source.media_type === "string"
-      ? source.media_type
-      : "application/octet-stream";
-  const filename =
-    source && typeof source.filename === "string"
-      ? source.filename
-      : "attachment";
-  const sizeBytes =
-    source && typeof source.data === "string"
-      ? estimateBase64Bytes(source.data)
-      : 0;
-  const summaryParts = [`[File attachment] ${filename}`, `type=${mediaType}`];
-  if (sizeBytes > 0) summaryParts.push(`size=${formatBytes(sizeBytes)}`);
+  return {
+    mediaType:
+      source && typeof source.media_type === "string"
+        ? source.media_type
+        : "application/octet-stream",
+    filename:
+      source && typeof source.filename === "string"
+        ? source.filename
+        : "attachment",
+    sizeBytes:
+      source && typeof source.data === "string"
+        ? estimateBase64Bytes(source.data)
+        : 0,
+  };
+}
+
+function renderFileBlockForHistory(
+  block: Record<string, unknown>,
+  meta: FileBlockMetadata,
+): string {
+  const summaryParts = [
+    `[File attachment] ${meta.filename}`,
+    `type=${meta.mediaType}`,
+  ];
+  if (meta.sizeBytes > 0)
+    summaryParts.push(`size=${formatBytes(meta.sizeBytes)}`);
 
   const extractedText =
     typeof block.extracted_text === "string" ? block.extracted_text.trim() : "";
@@ -237,11 +288,13 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
       contentOrder: text ? ["text:0"] : [],
       surfaces: [],
       thinkingSegments: [],
+      attachments: [],
     };
   }
 
   const textParts: string[] = [];
   const attachmentParts: string[] = [];
+  const attachments: HistoryAttachmentRef[] = [];
   const toolCalls: HistoryToolCall[] = [];
   const surfaces: HistorySurface[] = [];
   const thinkingSegments: string[] = [];
@@ -351,7 +404,19 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
       continue;
     }
     if (block.type === "file") {
-      attachmentParts.push(renderFileBlockForHistory(block));
+      const meta = extractFileBlockMetadata(block);
+      attachmentParts.push(renderFileBlockForHistory(block, meta));
+      finalizeSegment();
+      const ref: HistoryAttachmentRef = {
+        filename: meta.filename,
+        mimeType: meta.mediaType,
+        sizeBytes: meta.sizeBytes,
+      };
+      if (typeof block._attachmentId === "string" && block._attachmentId) {
+        ref.attachmentId = block._attachmentId;
+      }
+      attachments.push(ref);
+      contentOrder.push(`attachment:${attachments.length - 1}`);
       continue;
     }
     if (block.type === "image") {
@@ -495,17 +560,14 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
           matched.imageData = imageDataList[0];
           matched.imageDataList = imageDataList;
         }
-      } else {
-        toolCalls.push({
-          name: "unknown",
-          input: {},
-          result: resultContent,
-          isError,
-          ...(imageDataList.length > 0
-            ? { imageData: imageDataList[0], imageDataList }
-            : {}),
-        });
       }
+      // Orphan tool_result with no matching tool_use — drop it. Synthesizing
+      // a "name: 'unknown'" phantom entry rendered in chat as "Used unknown"
+      // / "Completed 1 step" with no context, with a timestamp later than
+      // the assistant's final answer. Most commonly orphans appear when
+      // context-window compaction trims the parent tool_use block while
+      // leaving the paired tool_result. Losing the orphan's result content
+      // is correct: without the parent we can't tell the user what tool ran.
       continue;
     }
   }
@@ -541,6 +603,7 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
     contentOrder,
     surfaces,
     thinkingSegments,
+    attachments,
   };
 }
 

package/src/daemon/host-bash-proxy.ts

@@ -185,7 +185,7 @@ export class HostBashProxy extends HostProxyBase<
       timedOut: boolean;
     },
   ): void {
-    pendingInteractions.resolve(requestId);
+    pendingInteractions.resolve(requestId, "answered");
     this.resolve(requestId, response);
   }
 }

package/src/daemon/host-cu-proxy.ts

@@ -280,7 +280,7 @@ export class HostCuProxy {
     observation: CuObservationResult,
   ): ToolExecutionResult | undefined {
     this._ownedRequests.delete(requestId);
-    const interaction = pendingInteractions.resolve(requestId);
+    const interaction = pendingInteractions.resolve(requestId, "answered");
     if (!interaction?.rpcResolve) {
       log.warn({ requestId }, "No pending host CU request for response");
       return undefined;

package/src/daemon/host-file-proxy.ts

@@ -227,7 +227,7 @@ export class HostFileProxy {
     requestId: string,
     response: { content: string; isError: boolean; imageData?: string },
   ): void {
-    const interaction = pendingInteractions.resolve(requestId);
+    const interaction = pendingInteractions.resolve(requestId, "answered");
     if (!interaction?.rpcResolve) {
       log.warn({ requestId }, "No pending host file request for response");
       return;

package/src/daemon/host-transfer-proxy.ts

@@ -508,7 +508,7 @@ export class HostTransferProxy {
       errorMessage?: string;
     },
   ): void {
-    const interaction = pendingInteractions.resolve(requestId);
+    const interaction = pendingInteractions.resolve(requestId, "answered");
     if (!interaction?.rpcResolve) {
       log.warn({ requestId }, "No pending host transfer request for response");
       return;

package/src/daemon/lifecycle.ts

@@ -32,6 +32,7 @@ import {
 } from "../credential-execution/startup-timeout.js";
 import { FilingService } from "../filing/filing-service.js";
 import { HeartbeatService } from "../heartbeat/heartbeat-service.js";
+import { startHomeContentRefresh } from "../home/home-content-refresh.js";
 import { backfillRelationshipStateIfMissing } from "../home/relationship-state-writer.js";
 import { closeSentry, initSentry, setSentryDeviceId } from "../instrument.js";
 import { getMcpServerManager } from "../mcp/manager.js";
@@ -121,7 +122,6 @@ import {
   registerMessagingProviders,
   registerWatcherProviders,
 } from "./providers-setup.js";
-import { seedInterfaceFiles } from "./seed-files.js";
 import { DaemonServer } from "./server.js";
 import { installShutdownHandlers } from "./shutdown-handlers.js";
 import { refreshSkillCapabilityMemories } from "./skill-memory-refresh.js";
@@ -269,8 +269,13 @@ async function startCesProcess(
 
 // Entry point for the daemon process itself
 export async function runDaemon(): Promise<void> {
+  const startupStartedAt = Date.now();
+  // dotenv loads before the first log call so the lazy root logger
+  // initializes against the final VELLUM_WORKSPACE_DIR / log path, not
+  // whatever was in the live environment at process spawn.
   loadDotEnv();
   validateEnv();
+  log.info({ version: APP_VERSION }, "Daemon starting");
 
   try {
     // Initialize crash reporting eagerly so early startup failures are
@@ -353,8 +358,6 @@ export async function runDaemon(): Promise<void> {
       log.warn({ err }, "Background feature flag init failed"),
     );
 
-    seedInterfaceFiles();
-
     log.info("Daemon startup: initializing DB");
     ensurePromptFiles();
 
@@ -470,6 +473,10 @@ export async function runDaemon(): Promise<void> {
         );
       });
 
+      // Pre-warm LLM-generated home page content (greeting + suggestion
+      // prompts) so the GET handler never triggers LLM calls.
+      startHomeContentRefresh();
+
       // Backfill injection templates on Slack bot token credentials so the
       // credential proxy can inject Authorization headers. Safe on every startup.
       try {
@@ -1228,7 +1235,6 @@ export async function runDaemon(): Promise<void> {
     }
 
     writePid(process.pid);
-    log.info({ pid: process.pid }, "Daemon started");
 
     // Install the `assistant` CLI symlink idempotently on every daemon start.
     // Non-blocking — failures are logged but don't affect startup.
@@ -1345,6 +1351,14 @@ export async function runDaemon(): Promise<void> {
         cleanupPidFile();
       },
     });
+
+    log.info(
+      {
+        durationMs: Date.now() - startupStartedAt,
+        pid: process.pid,
+      },
+      "Daemon started",
+    );
   } catch (err) {
     log.error({ err }, "Daemon startup failed — cleaning up");
     stopDiskPressureGuardForLifecycle();

package/src/daemon/message-protocol.ts

@@ -22,6 +22,7 @@ export * from "./message-types/contacts.js";
 export * from "./message-types/conversations.js";
 export * from "./message-types/diagnostics.js";
 export * from "./message-types/disk-pressure.js";
+export * from "./message-types/document-comments.js";
 export * from "./message-types/documents.js";
 export * from "./message-types/guardian-actions.js";
 export * from "./message-types/home.js";
@@ -45,6 +46,7 @@ export * from "./message-types/subagents.js";
 export * from "./message-types/surfaces.js";
 export * from "./message-types/sync.js";
 export * from "./message-types/upgrades.js";
+export * from "./message-types/web-activity.js";
 export * from "./message-types/work-items.js";
 export * from "./message-types/workspace.js";
 
@@ -76,6 +78,7 @@ import type {
   _DiagnosticsServerMessages,
 } from "./message-types/diagnostics.js";
 import type { _DiskPressureServerMessages } from "./message-types/disk-pressure.js";
+import type { _DocumentCommentsServerMessages } from "./message-types/document-comments.js";
 import type {
   _DocumentsClientMessages,
   _DocumentsServerMessages,
@@ -192,6 +195,7 @@ export type ServerMessage =
   | _BrowserServerMessages
   | _SubagentsServerMessages
   | _DocumentsServerMessages
+  | _DocumentCommentsServerMessages
   | _GuardianActionsServerMessages
   | _SyncInvalidationServerMessages
   | _HomeServerMessages

package/src/daemon/message-types/conversations.ts

@@ -224,6 +224,7 @@ export interface ConversationTitleUpdated {
 interface ChannelBinding {
   sourceChannel: ChannelId;
   externalChatId: string;
+  externalChatName?: string | null;
   externalThreadId?: string | null;
   externalUserId?: string | null;
   displayName?: string | null;
@@ -236,6 +237,13 @@ interface ChannelBinding {
       webUrl?: string;
     };
   };
+  slackChannel?: {
+    channelId: string;
+    name?: string;
+    link?: {
+      webUrl?: string;
+    };
+  };
 }
 
 /** Attention state metadata for a conversation's latest assistant message. */

package/src/daemon/message-types/document-comments.ts

@@ -0,0 +1,50 @@
+// Document comment event types (Server → Client).
+
+export interface DocumentCommentCreated {
+  type: "document_comment_created";
+  conversationId: string;
+  surfaceId: string;
+  comment: {
+    id: string;
+    surfaceId: string;
+    author: string;
+    content: string;
+    anchorStart?: number;
+    anchorEnd?: number;
+    anchorText?: string;
+    parentCommentId?: string;
+    status: string;
+    createdAt: number;
+    updatedAt: number;
+  };
+}
+
+export interface DocumentCommentResolved {
+  type: "document_comment_resolved";
+  conversationId: string;
+  surfaceId: string;
+  commentId: string;
+  resolvedBy: string;
+}
+
+export interface DocumentCommentReopened {
+  type: "document_comment_reopened";
+  conversationId: string;
+  surfaceId: string;
+  commentId: string;
+}
+
+export interface DocumentCommentDeleted {
+  type: "document_comment_deleted";
+  conversationId: string;
+  surfaceId: string;
+  commentId: string;
+}
+
+// --- Domain-level union alias (consumed by the barrel file) ---
+
+export type _DocumentCommentsServerMessages =
+  | DocumentCommentCreated
+  | DocumentCommentResolved
+  | DocumentCommentReopened
+  | DocumentCommentDeleted;

package/src/daemon/message-types/messages.ts

@@ -2,6 +2,7 @@
 
 import type { ChannelId, InterfaceId } from "../../channels/types.js";
 import type { CommandIntent, UserMessageAttachment } from "./shared.js";
+import type { ToolActivityMetadata } from "./web-activity.js";
 
 // === Client → Server ===
 
@@ -175,6 +176,9 @@ export interface ToolResult {
   approvalReason?: string;
   /** Snapshot of the auto-approve threshold at execution time. */
   riskThreshold?: string;
+  /** Structured activity metadata for rich client rendering. Optional; old
+   *  clients that key off `result` continue to work unchanged. */
+  activityMetadata?: ToolActivityMetadata;
 }
 
 export interface ConfirmationRequest {
@@ -363,6 +367,12 @@ export interface MessageQueuedDeleted {
   requestId: string;
 }
 
+export interface MessageSteered {
+  type: "message_steered";
+  conversationId: string;
+  requestId: string;
+}
+
 export interface SuggestionResponse {
   type: "suggestion_response";
   requestId: string;
@@ -390,6 +400,45 @@ export interface ConfirmationStateChanged {
   toolUseId?: string;
 }
 
+/**
+ * Lifecycle states reported by `interaction_resolved`.
+ *
+ *  - `"approved"` / `"rejected"` — user-supplied verdict on a confirmation.
+ *  - `"answered"` — user/client provided a response (secret value, question
+ *    answer, host-proxy result).
+ *  - `"cancelled"` — the interaction was torn down without a user response
+ *    (timeout, abort, dispose, prompter shutdown).
+ *  - `"superseded"` — invalidated by a newer event (auto-deny on enqueue, a
+ *    fresh user message arriving while a confirmation was outstanding).
+ */
+export type InteractionResolutionState =
+  | "approved"
+  | "rejected"
+  | "answered"
+  | "cancelled"
+  | "superseded";
+
+/**
+ * Broadcast when a pending interaction (confirmation, secret, question,
+ * host-proxy request) transitions to a resolved state. Clients use this to
+ * drop attention/processing indicators without polling.
+ */
+export interface InteractionResolved {
+  type: "interaction_resolved";
+  requestId: string;
+  /**
+   * Conversation key for the interaction. The daemon's internal conversation
+   * id and the web client's conversation key coincide today (see
+   * `conversation-key-store.ts`); the field is named after the client-facing
+   * concept.
+   */
+  conversationKey: string;
+  state: InteractionResolutionState;
+  /** Kind of the resolved interaction (e.g. "confirmation", "secret", "host_bash"). */
+  kind: string;
+  conversationId?: string;
+}
+
 /**
  * Server-side assistant activity lifecycle for thinking indicator placement.
  *
@@ -426,6 +475,21 @@ export interface AssistantActivityState {
   statusText?: string;
 }
 
+/**
+ * Emitted when the query complexity auto-router selects a non-default
+ * profile for the current turn. Clients use this to show an inline
+ * notification (e.g. "Using Quality for this response"). Only fires when
+ * the router picks a profile — not when the user explicitly pinned one.
+ */
+export interface TurnProfileAutoRouted {
+  type: "turn_profile_auto_routed";
+  conversationId: string;
+  /** Profile key (e.g. "quality-optimized"). */
+  profile: string;
+  /** Human-readable label (e.g. "Quality"). */
+  profileLabel: string;
+}
+
 /**
  * Broadcast to clients when a conversation's inference-profile override
  * changes. `profile` is the profile name (a key in `llm.profiles`) or
@@ -497,8 +561,11 @@ export type _MessagesServerMessages =
   | MessageDequeued
   | MessageRequestComplete
   | MessageQueuedDeleted
+  | MessageSteered
   | SuggestionResponse
   | TraceEvent
   | ConfirmationStateChanged
   | AssistantActivityState
-  | ConversationInferenceProfileUpdated;
+  | TurnProfileAutoRouted
+  | ConversationInferenceProfileUpdated
+  | InteractionResolved;

package/src/daemon/message-types/surfaces.ts

@@ -10,13 +10,15 @@ export type SurfaceType =
   | "confirmation"
   | "dynamic_page"
   | "file_upload"
-  | "document_preview";
+  | "document_preview"
+  | "task_preferences";
 
 export const INTERACTIVE_SURFACE_TYPES: SurfaceType[] = [
   "form",
   "confirmation",
   "dynamic_page",
   "file_upload",
+  "task_preferences",
 ];
 
 export interface SurfaceAction {

package/src/daemon/message-types/web-activity.ts

@@ -0,0 +1,57 @@
+// Shared structured result types for web-search and web-fetch tool activity.
+//
+// These types describe live (SSE-time) metadata that producers (search/fetch
+// tool executors) emit and consumers (clients) render alongside the existing
+// `result: string` payload. Persistence to conversation history is out of
+// scope for this plan; the metadata is live-only.
+
+export type WebSearchProviderId =
+  | "anthropic-native"
+  | "brave"
+  | "perplexity"
+  | "tavily";
+
+export interface WebSearchResultItem {
+  rank: number; // 1-indexed
+  title: string;
+  url: string;
+  domain: string; // lowercased host
+  faviconUrl?: string;
+  snippet?: string; // not populated for anthropic-native (content encrypted)
+  age?: string; // Brave-only freshness hint
+  score?: number; // Tavily-only
+}
+
+export interface WebSearchMetadata {
+  query: string;
+  provider: WebSearchProviderId;
+  resultCount: number;
+  durationMs: number;
+  results: WebSearchResultItem[];
+  /** Present when search itself failed; results[] will be empty. */
+  errorMessage?: string;
+}
+
+export interface WebFetchMetadata {
+  url: string;
+  finalUrl: string;
+  status: number;
+  contentType?: string;
+  byteCount: number;
+  charCount: number;
+  truncated: boolean;
+  title?: string;
+  domain: string;
+  faviconUrl?: string;
+  redirectCount: number;
+  durationMs: number;
+  errorMessage?: string;
+  /** Set when extracted text is dramatically smaller than raw HTML — likely a JS-rendered SPA whose meaningful content the static fetcher missed. */
+  mayRequireJavaScript?: boolean;
+}
+
+/** Discriminated container so future tools can add their own metadata. */
+export interface ToolActivityMetadata {
+  webSearch?: WebSearchMetadata;
+  webFetch?: WebFetchMetadata;
+}