@vellumai/assistant 0.8.3 → 0.8.5

package/src/daemon/plugin-source-watcher.ts

@@ -12,10 +12,32 @@
  * through a static singleton so tool side-effects can call
  * `PluginSourceWatcher.getInstance().ensureStarted()` directly without an
  * intermediate module-level injection.
+ *
+ * ## Linux/Bun recursive-watch caveat
+ *
+ * `fs.watch(dir, { recursive: true })` on Linux (and the equivalent under
+ * Bun, which uses the platform inotify path) does **not** dynamically
+ * attach to subdirectories created after the watch was established. The
+ * kernel fires exactly one event when the new top-level entry appears,
+ * and any writes inside that new subtree are silently dropped.
+ *
+ * Reproducer (against an empty watched root):
+ *
+ *     mkdir plugin/                      → event "plugin"
+ *     mkdir plugin/hooks/                → no event delivered
+ *     echo x > plugin/hooks/file.ts      → no event delivered
+ *
+ * To work around this we close + reopen the watcher on every event (with
+ * a coalescing debounce). Reopening walks the tree from scratch and
+ * re-subscribes to every directory that currently exists, so subsequent
+ * writes anywhere under the new subtree are delivered normally. We also
+ * rescan top-level entries after the swap and dispatch a rebuild for any
+ * plugin not yet in the registry, which closes the close→reopen gap.
  */
 
-import { type FSWatcher, mkdirSync, watch } from "node:fs";
+import { type FSWatcher, mkdirSync, readdirSync, watch } from "node:fs";
 
+import { getRegisteredPlugin } from "../plugins/registry.js";
 import { DebouncerMap } from "../util/debounce.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspacePluginsDir } from "../util/platform.js";
@@ -25,6 +47,12 @@ const log = getLogger("plugin-source-watcher");
 
 const PLUGIN_SOURCE_DEBOUNCE_MS = 500;
 
+/**
+ * Single shared debouncer key for the "restart the watcher" path. Bursty
+ * events for many plugin names all collapse to one restart.
+ */
+const WATCHER_RESTART_KEY = "__restart__";
+
 /**
  * Extract the plugin's top-level directory name from a relative path within
  * the plugins root. Returns null for a stray file directly in `plugins/`
@@ -36,10 +64,12 @@ function resolvePluginNameFromRelPath(relPath: string): string | null {
     // Bare entry under plugins/ — fs.watch reports these when a new
     // directory is first created. We treat the name as the plugin name and
     // let the install path decide whether it's a real plugin.
-    return relPath.length > 0 ? relPath : null;
+    if (relPath.length === 0 || relPath.startsWith(".")) return null;
+    return relPath;
   }
   const dirName = relPath.slice(0, slashIdx);
-  return dirName.length > 0 ? dirName : null;
+  if (dirName.length === 0 || dirName.startsWith(".")) return null;
+  return dirName;
 }
 
 export class PluginSourceWatcher {
@@ -70,6 +100,14 @@ export class PluginSourceWatcher {
     defaultDelayMs: PLUGIN_SOURCE_DEBOUNCE_MS,
     maxEntries: 50,
   });
+  /**
+   * Coalesces watcher-restart requests across bursty events. See
+   * {@link restartWatcher} for why we restart on every event.
+   */
+  private restartDebouncer = new DebouncerMap({
+    defaultDelayMs: PLUGIN_SOURCE_DEBOUNCE_MS,
+    maxEntries: 1,
+  });
 
   start(): void {
     this.started = true;
@@ -89,6 +127,7 @@ export class PluginSourceWatcher {
   stop(): void {
     this.started = false;
     this.debouncer.cancelAll();
+    this.restartDebouncer.cancelAll();
     if (this.watcher) {
       this.watcher.close();
       this.watcher = null;
@@ -99,6 +138,89 @@ export class PluginSourceWatcher {
     return reregisterExternalPlugin(pluginName);
   }
 
+  /**
+   * Close the current FSWatcher and open a fresh one on the same root.
+   *
+   * Workaround for the Linux/Bun recursive-watch limitation documented at
+   * the top of this file. Reopening re-walks the tree and re-subscribes
+   * to every directory that exists at that moment, including any subtree
+   * that grew under the watched root since the previous watcher started.
+   *
+   * Belt-and-suspenders: after the swap, we rescan top-level entries and
+   * dispatch a rebuild for any plugin not yet in the registry — this
+   * closes the (sub-millisecond) gap between close and reopen during
+   * which a brand-new plugin's first event could be lost.
+   *
+   * Failure mode: if the reopen fails, keep the previous watcher active.
+   * It may still miss newly-created subtrees, but it preserves existing
+   * plugin source coverage instead of degrading to no watcher at all.
+   */
+  private restartWatcher(): void {
+    if (!this.started) return;
+
+    const oldWatcher = this.watcher;
+    this.watcher = null; // tryWatch returns early when non-null
+    this.tryWatch();
+
+    if (this.watcher === null) {
+      // Keep the previous watcher alive if the replacement failed. It may not
+      // cover newly-created subtrees, but it is still better than dropping all
+      // plugin source coverage.
+      this.watcher = oldWatcher;
+      log.warn(
+        "Plugin source watcher restart failed; keeping previous watcher active",
+      );
+      return;
+    }
+
+    if (oldWatcher) {
+      try {
+        oldWatcher.close();
+      } catch (err) {
+        log.warn({ err }, "Failed to close previous plugin watcher");
+      }
+    }
+
+    this.rescanPlugins();
+  }
+
+  /**
+   * Schedule a rebuild for every top-level entry under the plugins dir
+   * that isn't already in the registry. Called after a successful
+   * {@link restartWatcher} to catch new-plugin events that may have been
+   * lost during the close→reopen swap.
+   *
+   * Existing plugins are skipped — their normal change events are
+   * delivered through the freshly-attached watcher.
+   */
+  private rescanPlugins(): void {
+    let pluginsDir: string;
+    try {
+      pluginsDir = getWorkspacePluginsDir();
+    } catch {
+      return;
+    }
+
+    let entries: string[];
+    try {
+      entries = readdirSync(pluginsDir);
+    } catch (err) {
+      log.warn({ err, pluginsDir }, "Failed to rescan plugins directory");
+      return;
+    }
+
+    for (const entry of entries) {
+      // Skip dotfiles / dot-directories (e.g. macOS `.DS_Store`, npm cache).
+      if (entry.startsWith(".")) continue;
+      // Existing plugins ride the watcher's normal event delivery. The
+      // rescan is purely to catch installs whose first event was lost.
+      if (getRegisteredPlugin(entry) !== undefined) continue;
+      this.debouncer.schedule(`plugin:${entry}`, () => {
+        void this.onChange(entry);
+      });
+    }
+  }
+
   private tryWatch(): void {
     if (this.watcher) return;
 
@@ -130,9 +252,19 @@ export class PluginSourceWatcher {
           if (!filename) return;
           const pluginName = resolvePluginNameFromRelPath(filename);
           if (!pluginName) return;
+
+          // Per-plugin rebuild — debounced under the plugin name so bursty
+          // edits collapse to a single rebuild.
           this.debouncer.schedule(`plugin:${pluginName}`, () => {
             void this.onChange(pluginName);
           });
+
+          // Refresh the watcher to pick up any subtree that grew under us.
+          // Coalesced across all plugin names; single watcher restart per
+          // event burst. See restartWatcher for the rationale.
+          this.restartDebouncer.schedule(WATCHER_RESTART_KEY, () => {
+            this.restartWatcher();
+          });
         },
       );
       log.info({ pluginsDir }, "Plugin source watcher started");

package/src/daemon/process-message.ts

@@ -38,7 +38,10 @@ import {
   buildSlackMetaForPersistence,
   serializePersistedUserMessageContent,
 } from "./conversation-messaging.js";
-import { formatCompactResult } from "./conversation-process.js";
+import {
+  formatCleanResult,
+  formatCompactResult,
+} from "./conversation-process.js";
 import { resolveChannelCapabilities } from "./conversation-runtime-assembly.js";
 import {
   buildSlashContextForContent,
@@ -254,7 +257,7 @@ export async function processMessage(
   options?: ProcessMessageOptions,
   sourceChannel?: string,
   sourceInterface?: string,
-): Promise<{ messageId: string }> {
+): Promise<{ messageId: string; assistantMessageId?: string }> {
   const conversationOptions = stripPerTurnObservers(options);
   const { conversation, attachments } = await prepareConversationForMessage(
     conversationId,
@@ -370,7 +373,7 @@ export async function processMessage(
     }
 
     const assistantMsg = createAssistantMessage(slashResult.message);
-    await addMessage(
+    const persistedAssistant = await addMessage(
       conversationId,
       "assistant",
       JSON.stringify(assistantMsg.content),
@@ -378,7 +381,10 @@ export async function processMessage(
     );
     conversation.getMessages().push(assistantMsg);
     publishConversationMessagesChanged(conversationId);
-    return { messageId: persisted.id };
+    return {
+      messageId: persisted.id,
+      assistantMessageId: persistedAssistant.id,
+    };
   }
 
   if (slashResult.kind === "compact") {
@@ -428,7 +434,7 @@ export async function processMessage(
     });
     const responseText = formatCompactResult(result);
     const assistantMsg = createAssistantMessage(responseText);
-    await addMessage(
+    const persistedAssistant = await addMessage(
       conversationId,
       "assistant",
       JSON.stringify(assistantMsg.content),
@@ -436,7 +442,64 @@ export async function processMessage(
     );
     conversation.getMessages().push(assistantMsg);
     publishConversationMessagesChanged(conversationId);
-    return { messageId: persisted.id };
+    return {
+      messageId: persisted.id,
+      assistantMessageId: persistedAssistant.id,
+    };
+  }
+
+  if (slashResult.kind === "clean") {
+    const serverTurnCtx = conversation.getTurnChannelContext();
+    const serverProvenance = provenanceFromTrustContext(
+      conversation.trustContext,
+    );
+    const cleanChannelMeta = {
+      ...serverProvenance,
+      ...(serverTurnCtx
+        ? {
+            userMessageChannel: serverTurnCtx.userMessageChannel,
+            assistantMessageChannel: serverTurnCtx.assistantMessageChannel,
+          }
+        : {}),
+      ...(serverInterfaceCtx
+        ? {
+            userMessageInterface: serverInterfaceCtx.userMessageInterface,
+            assistantMessageInterface:
+              serverInterfaceCtx.assistantMessageInterface,
+          }
+        : {}),
+    };
+    const cleanUserMeta = slackMeta
+      ? { ...cleanChannelMeta, slackMeta }
+      : cleanChannelMeta;
+    const cleanMsg = createUserMessage(content, attachments);
+    const persisted = await addMessage(
+      conversationId,
+      "user",
+      serializePersistedUserMessageContent(
+        content,
+        attachments,
+        options?.displayContent,
+      ),
+      cleanUserMeta,
+    );
+    conversation.getMessages().push(cleanMsg);
+
+    const result = await conversation.forceClean();
+    const responseText = formatCleanResult(result);
+    const assistantMsg = createAssistantMessage(responseText);
+    const persistedAssistant = await addMessage(
+      conversationId,
+      "assistant",
+      JSON.stringify(assistantMsg.content),
+      cleanChannelMeta,
+    );
+    conversation.getMessages().push(assistantMsg);
+    publishConversationMessagesChanged(conversationId);
+    return {
+      messageId: persisted.id,
+      assistantMessageId: persistedAssistant.id,
+    };
   }
 
   const resolvedContent = slashResult.content;
@@ -460,16 +523,12 @@ export async function processMessage(
   }
 
   try {
-    conversation.setSlackRuntimeContextNotice(
-      options?.slackRuntimeContextNotice,
-    );
     await conversation.runAgentLoop(resolvedContent, messageId, emitEvent, {
       isInteractive: options?.isInteractive ?? false,
       isUserMessage: true,
       ...(options?.callSite ? { callSite: options.callSite } : {}),
     });
   } finally {
-    conversation.setSlackRuntimeContextNotice(undefined);
     if (
       options?.isInteractive === true &&
       conversation.getCurrentSender() === broadcastMessage
@@ -526,7 +585,6 @@ export async function processMessageInBackground(
     getSubagentManager().updateParentSender(conversationId, broadcastMessage);
   }
 
-  conversation.setSlackRuntimeContextNotice(options?.slackRuntimeContextNotice);
   conversation
     .runAgentLoop(content, messageId, emitEvent, {
       isInteractive: options?.isInteractive ?? false,
@@ -534,7 +592,6 @@ export async function processMessageInBackground(
       ...(options?.callSite ? { callSite: options.callSite } : {}),
     })
     .finally(() => {
-      conversation.setSlackRuntimeContextNotice(undefined);
       if (
         options?.isInteractive === true &&
         conversation.getCurrentSender() === broadcastMessage

package/src/daemon/shutdown-handlers.ts

@@ -34,10 +34,9 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
   let shuttingDown = false;
   let exitCode = 0;
 
-  const shutdown = async () => {
+  const shutdown = async (_signal?: NodeJS.Signals) => {
     if (shuttingDown) return;
     shuttingDown = true;
-    log.info("Shutting down daemon...");
 
     // Force exit if graceful shutdown takes too long.
     // Set this BEFORE awaiting heartbeat stop so it covers all
@@ -156,9 +155,29 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     process.exit(exitCode);
   };
 
-  process.on("SIGTERM", shutdown);
-  process.on("SIGINT", shutdown);
-  process.on("SIGHUP", shutdown);
+  process.on("SIGTERM", () => {
+    log.warn(
+      { signal: "SIGTERM", pid: process.pid, uptime: process.uptime() },
+      "Received SIGTERM — process termination requested",
+    );
+    void shutdown("SIGTERM");
+  });
+
+  process.on("SIGINT", () => {
+    log.warn(
+      { signal: "SIGINT", pid: process.pid, uptime: process.uptime() },
+      "Received SIGINT — user interrupt",
+    );
+    void shutdown("SIGINT");
+  });
+
+  process.on("SIGHUP", () => {
+    log.warn(
+      { signal: "SIGHUP", pid: process.pid, uptime: process.uptime() },
+      "Received SIGHUP — terminal hangup",
+    );
+    void shutdown("SIGHUP");
+  });
 
   process.on("unhandledRejection", (reason) => {
     log.error(

package/src/daemon/switch-inference-profile-tool.ts

@@ -0,0 +1,52 @@
+import type { ProfileEntry } from "../config/schemas/llm.js";
+import type { ToolDefinition } from "../providers/types.js";
+
+export const SWITCH_INFERENCE_PROFILE_TOOL_NAME = "switch_inference_profile";
+
+const PROFILE_DESCRIPTION_FALLBACKS: Record<string, string> = {
+  "quality-optimized":
+    "Most capable model for complex reasoning, multi-step analysis, math, and coding",
+  balanced: "Good balance of quality, cost, and speed for most tasks",
+  "cost-optimized":
+    "Fast responses for simple factual questions, short lookups, and casual chat",
+};
+
+export function buildSwitchInferenceProfileToolDef(
+  profiles: Record<string, ProfileEntry>,
+  currentProfile?: string,
+): ToolDefinition | null {
+  const entries = Object.entries(profiles).filter(
+    ([, entry]) => entry.status !== "disabled",
+  );
+  if (entries.length < 2) return null;
+
+  const profileDescriptions = entries
+    .map(([key, entry]) => {
+      const label = entry.label ?? key;
+      const desc =
+        entry.description || PROFILE_DESCRIPTION_FALLBACKS[key] || "";
+      const descSuffix = desc ? `: ${desc}` : "";
+      const current = key === currentProfile ? " (current)" : "";
+      return `- ${key} — ${label}${descSuffix}${current}`;
+    })
+    .join("\n");
+
+  const currentEntry = currentProfile ? profiles[currentProfile] : undefined;
+  const currentLabel = currentEntry?.label ?? currentProfile ?? "current";
+
+  return {
+    name: SWITCH_INFERENCE_PROFILE_TOOL_NAME,
+    description: `Switch to a different inference profile BEFORE answering. You MUST call this tool when the user's query requires capabilities beyond what your current profile ("${currentLabel}") provides. Examples of when to switch to a more capable profile: multi-step reasoning or analysis, math proofs or derivations, complex coding tasks, detailed creative writing, or any task requiring deep thought. Examples of when to switch to a faster profile: simple greetings, one-word answers, factual lookups. When in doubt about whether you can handle the query well, switch to a more capable profile.\n\nAvailable profiles:\n${profileDescriptions}`,
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        profile: {
+          type: "string",
+          enum: entries.map(([key]) => key),
+          description: "The profile key to switch to.",
+        },
+      },
+      required: ["profile"],
+    },
+  };
+}

package/src/daemon/tool-setup-types.ts

@@ -57,4 +57,17 @@ export interface ToolSetupContext extends SurfaceConversationContext {
    * return `undefined` for the in-flight (background) subagent.
    */
   currentTurnOverrideProfile?: string;
+  /**
+   * Set by the `switch_inference_profile` tool when the model self-selects a
+   * different profile mid-turn. Read by `readCurrentOverrideProfile` in the
+   * agent loop so the next LLM call uses the switched profile. Reset at
+   * turn start.
+   */
+  toolRoutedProfile?: string;
+  /**
+   * True when the user has explicitly selected an inference profile for this
+   * conversation (via the composer profile picker). When set, tool-based
+   * auto-routing is suppressed — the user's explicit choice takes precedence.
+   */
+  hasExplicitProfileOverride?: boolean;
 }

package/src/daemon/trust-context.ts

@@ -25,6 +25,12 @@ export interface TrustContext {
   requesterSenderDisplayName?: string;
   /** Guardian-managed display name from the contact record. */
   requesterMemberDisplayName?: string;
+  /** Raw timezone for the requester, when supplied by the source channel. */
+  requesterTimezone?: string;
+  /** Compact timezone label for the requester, when supplied by the source channel. */
+  requesterTimezoneLabel?: string;
+  /** Raw timezone offset in seconds for the requester, when supplied by the source channel. */
+  requesterTimezoneOffsetSeconds?: number;
   /** Canonical external user ID of the requester (the current actor). */
   requesterExternalUserId?: string;
   /** Chat/conversation ID the requester is interacting through. */