@vellumai/assistant 0.8.3 → 0.8.4

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/query-complexity-router.ts

@@ -0,0 +1,75 @@
+import {
+  createTimeout,
+  extractText,
+  getConfiguredProvider,
+  userMessage,
+} from "../providers/provider-send-message.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("query-complexity-router");
+
+export type ComplexityTier = "speed" | "balanced" | "quality";
+
+const CLASSIFICATION_TIMEOUT_MS = 5_000;
+
+const SYSTEM_PROMPT = `You are a query complexity classifier. Given a user message, classify its complexity into exactly one tier.
+
+Reply with a single word — one of: speed, balanced, quality
+
+- speed: trivial queries — greetings, acknowledgements, simple yes/no questions, basic factual lookups, short commands, small talk
+- balanced: moderate queries — explanations, summaries, standard coding tasks, general conversation, most everyday requests
+- quality: complex queries — deep analysis, long-form creative writing, complex multi-step reasoning, debugging intricate code, architectural design, research synthesis
+
+When uncertain, reply "balanced".`;
+
+export async function classifyQueryComplexity(
+  messageText: string,
+): Promise<ComplexityTier | null> {
+  const provider = await getConfiguredProvider("queryComplexityRouter");
+  if (!provider) {
+    log.warn("No provider available for query complexity routing");
+    return null;
+  }
+
+  const truncated =
+    messageText.length > 2000 ? messageText.slice(0, 2000) : messageText;
+
+  const { signal, cleanup } = createTimeout(CLASSIFICATION_TIMEOUT_MS);
+  try {
+    const response = await provider.sendMessage(
+      [userMessage(truncated)],
+      undefined,
+      SYSTEM_PROMPT,
+      { signal },
+    );
+    const text = extractText(response).toLowerCase().trim();
+    if (text === "speed" || text === "balanced" || text === "quality") {
+      return text;
+    }
+    // Parse partial matches (model might say "speed." or "quality - because...")
+    if (text.startsWith("speed")) return "speed";
+    if (text.startsWith("quality")) return "quality";
+    if (text.startsWith("balanced")) return "balanced";
+    log.warn({ raw: text }, "Unexpected classifier output, defaulting to null");
+    return null;
+  } catch (err) {
+    if (signal.aborted) {
+      log.warn("Query complexity classification timed out");
+    } else {
+      log.warn({ err }, "Query complexity classification failed");
+    }
+    return null;
+  } finally {
+    cleanup();
+  }
+}
+
+const PROFILE_MAP: Record<ComplexityTier, string> = {
+  speed: "cost-optimized",
+  balanced: "balanced",
+  quality: "quality-optimized",
+};
+
+export function complexityTierToProfileKey(tier: ComplexityTier): string {
+  return PROFILE_MAP[tier];
+}

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. */