@vellumai/assistant 0.5.16 → 0.6.1

package/src/daemon/providers-setup.ts

@@ -25,6 +25,8 @@ import { githubProvider } from "../watcher/providers/github.js";
 import { gmailProvider } from "../watcher/providers/gmail.js";
 import { googleCalendarProvider } from "../watcher/providers/google-calendar.js";
 import { linearProvider } from "../watcher/providers/linear.js";
+import { outlookProvider } from "../watcher/providers/outlook.js";
+import { outlookCalendarProvider } from "../watcher/providers/outlook-calendar.js";
 const log = getLogger("lifecycle");
 
 export async function initializeProvidersAndTools(
@@ -135,6 +137,9 @@ export function registerWatcherProviders(): void {
   registerWatcherProvider(googleCalendarProvider);
   registerWatcherProvider(githubProvider);
   registerWatcherProvider(linearProvider);
+  registerWatcherProvider(outlookProvider);
+  registerWatcherProvider(outlookCalendarProvider);
+
   initWatcherEngine();
 }
 

package/src/daemon/server.ts

@@ -11,6 +11,7 @@ import {
   createAssistantMessage,
   createUserMessage,
 } from "../agent/message-types.js";
+import { compileApp } from "../bundler/app-compiler.js";
 import {
   type ChannelId,
   type InterfaceId,
@@ -22,6 +23,7 @@ import { onContactChange } from "../contacts/contact-events.js";
 import type { CesClient } from "../credential-execution/client.js";
 import type { CesProcessManager } from "../credential-execution/process-manager.js";
 import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
+import { getApp, getAppDirPath, isMultifileApp } from "../memory/app-store.js";
 import * as attachmentsStore from "../memory/attachments-store.js";
 import {
   createCanonicalGuardianRequest,
@@ -49,6 +51,7 @@ import { bridgeConfirmationRequestToGuardian } from "../runtime/confirmation-req
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { checkIngressForSecrets } from "../security/secret-ingress.js";
 import { redactSecrets } from "../security/secret-scanner.js";
+import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
 import { registerCancelCallback } from "../signals/cancel.js";
 import { registerConversationUndoCallback } from "../signals/conversation-undo.js";
 import { appendEventToStream } from "../signals/event-stream.js";
@@ -57,10 +60,12 @@ import { getSubagentManager } from "../subagent/index.js";
 import { summarizeToolInput } from "../tools/tool-input-summary.js";
 import { getLogger } from "../util/logger.js";
 import {
+  getAvatarImagePath,
   getSandboxWorkingDir,
   getWorkspacePromptPath,
 } from "../util/platform.js";
 import { registerDaemonCallbacks } from "../work-items/work-item-runner.js";
+import { AppSourceWatcher } from "./app-source-watcher.js";
 import { ConfigWatcher } from "./config-watcher.js";
 import {
   Conversation,
@@ -71,6 +76,7 @@ import { ConversationEvictor } from "./conversation-evictor.js";
 import { formatCompactResult } from "./conversation-process.js";
 import { resolveChannelCapabilities } from "./conversation-runtime-assembly.js";
 import { resolveSlash, type SlashContext } from "./conversation-slash.js";
+import { refreshSurfacesForApp } from "./conversation-surfaces.js";
 import { undoLastMessage } from "./handlers/conversations.js";
 import { parseIdentityFields } from "./handlers/identity.js";
 import type {
@@ -201,13 +207,10 @@ function makePendingInteractionRegistrar(
           guardianPrincipalId: trustContext?.guardianPrincipalId ?? undefined,
           toolName: msg.toolName,
           commandPreview:
-            redactSecrets(
-              summarizeToolInput(msg.toolName, inputRecord),
-            ) || undefined,
+            redactSecrets(summarizeToolInput(msg.toolName, inputRecord)) ||
+            undefined,
           riskLevel: msg.riskLevel,
-          activityText: activityRaw
-            ? redactSecrets(activityRaw)
-            : undefined,
+          activityText: activityRaw ? redactSecrets(activityRaw) : undefined,
           executionTarget: msg.executionTarget,
           status: "pending",
           requestCode: generateCanonicalRequestCode(),
@@ -271,6 +274,7 @@ export class DaemonServer {
 
   // Composed subsystems
   private configWatcher = new ConfigWatcher();
+  private appSourceWatcher = new AppSourceWatcher();
 
   // CES (Credential Execution Service) — process-level singleton.
   // Lifecycle is managed by startCesProcess() in lifecycle.ts; the server
@@ -369,7 +373,28 @@ export class DaemonServer {
       { channelId: transport.channelId },
       "Transport metadata received",
     );
-    conversation.setTransportHints(transport.hints);
+
+    // Build enriched hints: interface ID first, then host environment (macOS
+    // only), then any client-provided hints.
+    const enrichedHints: string[] = [];
+
+    const interfaceLabel = parseInterfaceId(transport.interfaceId) ?? "vellum";
+    enrichedHints.push(`User is messaging from interface: ${interfaceLabel}`);
+
+    if (transport.interfaceId === "macos") {
+      if (transport.hostHomeDir) {
+        enrichedHints.push(`Host home directory: ${transport.hostHomeDir}`);
+      }
+      if (transport.hostUsername) {
+        enrichedHints.push(`Host username: ${transport.hostUsername}`);
+      }
+    }
+
+    if (transport.hints) {
+      enrichedHints.push(...transport.hints);
+    }
+
+    conversation.setTransportHints(enrichedHints);
   }
 
   constructor() {
@@ -523,6 +548,55 @@ export class DaemonServer {
     }
   }
 
+  private broadcastSoundsConfigUpdated(): void {
+    this.broadcast({ type: "sounds_config_updated" });
+  }
+
+  private broadcastAvatarUpdated(): void {
+    this.broadcast({
+      type: "avatar_updated",
+      avatarPath: getAvatarImagePath(),
+    });
+  }
+
+  /**
+   * Handle a detected app source file change from the filesystem watcher.
+   * Recompiles multifile apps and refreshes surfaces across ALL conversations.
+   */
+  private handleAppSourceChange(appId: string): void {
+    const app = getApp(appId);
+    if (!app) return;
+
+    const doRefresh = () => {
+      for (const conversation of this.conversations.values()) {
+        refreshSurfacesForApp(conversation, appId, { fileChange: true });
+      }
+      this.broadcast({ type: "app_files_changed", appId });
+      void updatePublishedAppDeployment(appId);
+    };
+
+    if (isMultifileApp(app)) {
+      const appDir = getAppDirPath(appId);
+      void compileApp(appDir)
+        .then((result) => {
+          if (!result.ok) {
+            log.warn(
+              { appId, errors: result.errors },
+              "Recompile failed on app source change",
+            );
+          }
+          doRefresh();
+        })
+        .catch((err) => {
+          log.warn({ appId, err }, "Recompile threw on app source change");
+          doRefresh();
+        });
+      return;
+    }
+
+    doRefresh();
+  }
+
   // ── Server lifecycle ────────────────────────────────────────────────
 
   async start(): Promise<void> {
@@ -625,9 +699,18 @@ export class DaemonServer {
       if (conversation.isProcessing()) {
         // Hydrate file data now — the queue path won't re-read from
         // the attachment store, so base64 content must be inline.
-        for (const att of resolvedAttachments) {
+        for (let i = resolvedAttachments.length - 1; i >= 0; i--) {
+          const att = resolvedAttachments[i];
           if (att.filePath && !att.data) {
-            att.data = readFileSync(att.filePath).toString("base64");
+            try {
+              att.data = readFileSync(att.filePath).toString("base64");
+            } catch (err) {
+              log.warn(
+                { err, path: att.filePath },
+                "Failed to read queued signal attachment, skipping",
+              );
+              resolvedAttachments.splice(i, 1);
+            }
           }
         }
         const requestId = crypto.randomUUID();
@@ -663,8 +746,12 @@ export class DaemonServer {
     this.configWatcher.start(
       () => this.evictConversationsForReload(),
       () => this.broadcastIdentityChanged(),
+      () => this.broadcastSoundsConfigUpdated(),
+      () => this.broadcastAvatarUpdated(),
     );
 
+    this.appSourceWatcher.start((appId) => this.handleAppSourceChange(appId));
+
     // Broadcast contacts_changed to all clients when any contact mutation occurs.
     this.unsubscribeContactChange = onContactChange(() => {
       this.broadcast({ type: "contacts_changed" });
@@ -678,6 +765,7 @@ export class DaemonServer {
     disposeAcpSessionManager();
     this.evictor.stop();
     this.configWatcher.stop();
+    this.appSourceWatcher.stop();
     if (this.unsubscribeContactChange) {
       this.unsubscribeContactChange();
       this.unsubscribeContactChange = null;
@@ -1003,7 +1091,7 @@ export class DaemonServer {
     // Guard: don't replace an active proxy during concurrent turn races —
     // another request may have started processing between the isProcessing()
     // check above and the await on ensureActorScopedHistory().
-    if (resolvedInterface === "macos" || resolvedInterface === "ios") {
+    if (resolvedInterface === "macos") {
       if (!conversation.isProcessing() || !conversation.hostBashProxy) {
         conversation.setHostBashProxy(
           new HostBashProxy(conversation.getCurrentSender(), (requestId) => {
@@ -1360,8 +1448,9 @@ export class DaemonServer {
    */
   async getConversationForMessages(
     conversationId: string,
+    options?: ConversationCreateOptions,
   ): Promise<Conversation> {
-    return this.getOrCreateConversation(conversationId);
+    return this.getOrCreateConversation(conversationId, options);
   }
 
   /**

package/src/daemon/shutdown-handlers.ts

@@ -1,5 +1,6 @@
 import * as Sentry from "@sentry/node";
 
+import type { FilingService } from "../filing/filing-service.js";
 import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
 import type { HookManager } from "../hooks/manager.js";
 import type { McpServerManager } from "../mcp/manager.js";
@@ -7,6 +8,7 @@ import { getSqlite, resetDb } from "../memory/db.js";
 import type { QdrantManager } from "../memory/qdrant-manager.js";
 import type { RuntimeHttpServer } from "../runtime/http-server.js";
 import { browserManager } from "../tools/browser/browser-manager.js";
+import { cleanupShellOutputTempFiles } from "../tools/shared/shell-output.js";
 import { getLogger } from "../util/logger.js";
 import { getEnrichmentService } from "../workspace/commit-message-enrichment-service.js";
 import type { WorkspaceHeartbeatService } from "../workspace/heartbeat-service.js";
@@ -18,6 +20,7 @@ export interface ShutdownDeps {
   server: DaemonServer;
   workspaceHeartbeat: WorkspaceHeartbeatService;
   heartbeat: HeartbeatService;
+  filing: FilingService;
   hookManager: HookManager;
   runtimeHttp: RuntimeHttpServer | null;
   scheduler: { stop(): void };
@@ -51,6 +54,7 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
 
     await deps.workspaceHeartbeat.stop();
     await deps.heartbeat.stop();
+    await deps.filing.stop();
 
     try {
       await deps.hookManager.trigger("daemon-stop", { pid: process.pid });
@@ -105,6 +109,7 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
 
     if (deps.runtimeHttp) await deps.runtimeHttp.stop();
     await browserManager.closeAllPages();
+    cleanupShellOutputTempFiles();
     deps.scheduler.stop();
     deps.getMemoryWorker()?.stop();
 

package/src/daemon/tool-side-effects.ts

@@ -10,6 +10,7 @@
 import { compileApp } from "../bundler/app-compiler.js";
 import { generateAppIcon } from "../media/app-icon-generator.js";
 import { getApp, getAppDirPath, isMultifileApp } from "../memory/app-store.js";
+import { findActiveSession } from "../runtime/channel-verification-service.js";
 import { deliverVerificationSlack } from "../runtime/verification-outbound-actions.js";
 import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
 import type { ToolExecutionResult } from "../tools/types.js";
@@ -157,12 +158,32 @@ registerHook(
   },
 );
 
-// Trigger compilation + surface refresh + broadcast when an app is refreshed.
+// Trigger surface refresh + broadcast when an app is refreshed.
+// If the executor already compiled (multifile path), skip the redundant
+// recompile and just refresh surfaces / broadcast / deploy directly.
 registerHook(
   "app_refresh",
-  (_name, input, _result, { ctx, broadcastToAllClients }) => {
+  (_name, input, result, { ctx, broadcastToAllClients }) => {
     const appId = input.app_id as string | undefined;
-    if (appId) {
+    if (!appId) return;
+
+    // executeAppRefresh already compiled multifile apps and included a
+    // "compiled" field in the result. Skip the expensive recompile and
+    // go straight to surface refresh + broadcast + deploy.
+    let alreadyCompiled = false;
+    try {
+      const parsed = JSON.parse(result.content) as { compiled?: boolean };
+      alreadyCompiled = parsed.compiled !== undefined;
+    } catch {
+      // Result wasn't valid JSON — fall through to handleAppChange.
+    }
+
+    if (alreadyCompiled) {
+      const opts = { fileChange: true };
+      refreshSurfacesForApp(ctx, appId, opts);
+      broadcastToAllClients?.({ type: "app_files_changed", appId });
+      void updatePublishedAppDeployment(appId);
+    } else {
       handleAppChange(ctx, appId, broadcastToAllClients, { fileChange: true });
     }
   },
@@ -222,18 +243,39 @@ registerHook("bash", (_name, input, result) => {
   type PendingDm = { userId: string; text: string; assistantId: string };
   type Parsed = { _pendingSlackDm?: PendingDm };
 
-  const dispatch = (parsed: Parsed) => {
+  // Returns "delivered" when DM was sent, "rejected" when _pendingSlackDm
+  // was found but failed validation, or null when the field was absent.
+  const dispatch = (parsed: Parsed): "delivered" | "rejected" | null => {
     if (parsed._pendingSlackDm) {
       const { userId, text, assistantId } = parsed._pendingSlackDm;
+
+      // Validate that an active Slack verification session exists and
+      // that the destination matches the userId in the parsed payload.
+      const session = findActiveSession("slack");
+      if (!session) {
+        log.warn(
+          { userId, assistantId },
+          "Bash hook: no active Slack verification session — ignoring _pendingSlackDm",
+        );
+        return "rejected";
+      }
+      if (session.destinationAddress !== userId) {
+        log.warn(
+          { userId, expected: session.destinationAddress, assistantId },
+          "Bash hook: Slack DM userId does not match active session destination — ignoring",
+        );
+        return "rejected";
+      }
+
       deliverVerificationSlack(userId, text, assistantId);
-      return true;
+      return "delivered";
     }
-    return false;
+    return null;
   };
 
   // Try full content first (handles pretty-printed single-object JSON)
   try {
-    if (dispatch(JSON.parse(result.content.trim()) as Parsed)) return;
+    if (dispatch(JSON.parse(result.content.trim()) as Parsed) !== null) return;
   } catch {
     // Not a single JSON object — fall back to line-by-line for
     // multi-object output (e.g. cancel + create chained with &&).
@@ -242,7 +284,7 @@ registerHook("bash", (_name, input, result) => {
     const trimmed = line.trim();
     if (!trimmed.startsWith("{")) continue;
     try {
-      if (dispatch(JSON.parse(trimmed) as Parsed)) return;
+      if (dispatch(JSON.parse(trimmed) as Parsed) === "delivered") return;
     } catch {
       continue;
     }

package/src/export/transcript-formatter.ts

@@ -0,0 +1,148 @@
+/**
+ * Transcript formatter for conversation analysis.
+ *
+ * Builds a markdown transcript of a conversation, including inline
+ * subagent conversation sections when present in message metadata.
+ */
+
+import {
+  getConversation,
+  getMessages,
+  messageMetadataSchema,
+} from "../memory/conversation-crud.js";
+import { truncate } from "../util/truncate.js";
+
+interface ContentBlock {
+  type: string;
+  text?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+  content?: string;
+  tool_use_id?: string;
+  is_error?: boolean;
+  source?: { media_type?: string; filename?: string };
+}
+
+function formatTimestamp(ms: number): string {
+  return new Date(ms).toISOString().replace("T", " ").slice(0, 19);
+}
+
+function extractAnalysisText(blocks: ContentBlock[]): string {
+  const parts: string[] = [];
+  for (const block of blocks) {
+    switch (block.type) {
+      case "text":
+        if (block.text) parts.push(block.text);
+        break;
+      case "tool_use":
+        parts.push(
+          `[Tool: ${block.name}] ${JSON.stringify(block.input ?? {})}`,
+        );
+        break;
+      case "tool_result":
+        if (block.is_error) {
+          parts.push(`[Error: ${block.content ?? ""}]`);
+        } else {
+          parts.push(`[Result: ${truncate(block.content ?? "", 500)}]`);
+        }
+        break;
+      case "server_tool_use":
+        parts.push(`[Web search: ${block.name ?? "web_search"}]`);
+        break;
+      case "web_search_tool_result":
+        parts.push("[Web search results]");
+        break;
+      case "image":
+        parts.push("[Image attachment]");
+        break;
+      case "file":
+        parts.push(`[File: ${block.source?.filename ?? "unknown"}]`);
+        break;
+      case "thinking":
+      case "redacted_thinking":
+        // Skip internal model reasoning blocks
+        break;
+    }
+  }
+  return parts.join("\n");
+}
+
+function formatRole(role: string): string {
+  return role === "user" ? "User" : "Assistant";
+}
+
+function formatSubagentMessages(msgs: ReturnType<typeof getMessages>): string {
+  const lines: string[] = [];
+  for (const msg of msgs) {
+    const role = formatRole(msg.role);
+    const time = formatTimestamp(msg.createdAt);
+    const content = parseContent(msg.content);
+    const text = extractAnalysisText(content);
+    if (text) {
+      lines.push(`> **${role}** (${time})`);
+      for (const line of text.split("\n")) {
+        lines.push(`> ${line}`);
+      }
+      lines.push(">");
+    }
+  }
+  return lines.join("\n");
+}
+
+function parseContent(raw: string): ContentBlock[] {
+  try {
+    return JSON.parse(raw) as ContentBlock[];
+  } catch {
+    return [{ type: "text", text: raw }];
+  }
+}
+
+export function buildAnalysisTranscript(conversationId: string): string {
+  const conversation = getConversation(conversationId);
+  if (!conversation) {
+    return `# Conversation not found: ${conversationId}\n`;
+  }
+
+  const allMessages = getMessages(conversationId);
+  const title = conversation.title ?? "Untitled";
+  const lines: string[] = [];
+
+  lines.push(`# Conversation: ${title}`);
+  lines.push(`Created: ${formatTimestamp(conversation.createdAt)}`);
+  lines.push("");
+
+  for (const msg of allMessages) {
+    const role = formatRole(msg.role);
+    const time = formatTimestamp(msg.createdAt);
+    const content = parseContent(msg.content);
+    const text = extractAnalysisText(content);
+
+    lines.push(`## ${role} (${time})`);
+    lines.push(text);
+    lines.push("");
+
+    // Check for subagent notifications in metadata
+    if (msg.metadata) {
+      try {
+        const parsed = messageMetadataSchema.safeParse(JSON.parse(msg.metadata));
+        if (parsed.success && parsed.data.subagentNotification) {
+          const notif = parsed.data.subagentNotification;
+          if (
+            (notif.status === "completed" || notif.status === "failed" || notif.status === "aborted") &&
+            notif.conversationId
+          ) {
+            const subMessages = getMessages(notif.conversationId);
+            lines.push(`### Subagent: ${notif.label} (${notif.status})`);
+            lines.push("");
+            lines.push(formatSubagentMessages(subMessages));
+            lines.push("");
+          }
+        }
+      } catch {
+        // Skip unparseable metadata
+      }
+    }
+  }
+
+  return lines.join("\n");
+}