@vellumai/assistant 0.8.0 → 0.8.2

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

@@ -0,0 +1,146 @@
+/**
+ * Filesystem watcher for the external plugins directory.
+ *
+ * Watches `<workspaceDir>/plugins/` recursively using fs.watch (FSEvents on
+ * macOS). When a plugin directory is created or modified, debounces per
+ * top-level directory name (= the plugin name) and dispatches to the
+ * watcher's internal change handler so the daemon can register or reload
+ * the plugin without a restart.
+ *
+ * Mirrors `app-source-watcher.ts` (same DebouncerMap shape, same start/stop
+ * lifecycle, same ensureStarted late-create hook), but exposes its lifecycle
+ * through a static singleton so tool side-effects can call
+ * `PluginSourceWatcher.getInstance().ensureStarted()` directly without an
+ * intermediate module-level injection.
+ */
+
+import { type FSWatcher, mkdirSync, watch } from "node:fs";
+
+import { DebouncerMap } from "../util/debounce.js";
+import { getLogger } from "../util/logger.js";
+import { getWorkspacePluginsDir } from "../util/platform.js";
+import { reregisterExternalPlugin } from "./external-plugins-bootstrap.js";
+
+const log = getLogger("plugin-source-watcher");
+
+const PLUGIN_SOURCE_DEBOUNCE_MS = 500;
+
+/**
+ * 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/`
+ * (not a plugin dir).
+ */
+function resolvePluginNameFromRelPath(relPath: string): string | null {
+  const slashIdx = relPath.indexOf("/");
+  if (slashIdx === -1) {
+    // 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;
+  }
+  const dirName = relPath.slice(0, slashIdx);
+  return dirName.length > 0 ? dirName : null;
+}
+
+export class PluginSourceWatcher {
+  /**
+   * Process-wide singleton. Callers reach the watcher via
+   * {@link PluginSourceWatcher.getInstance} rather than instantiating
+   * directly so tool side-effects (`assistant plugins install`) can call
+   * `ensureStarted()` on the same watcher the daemon `start()`/`stop()`
+   * lifecycle owns, without threading an instance through a registered
+   * module-level callback.
+   */
+  private static singleton: PluginSourceWatcher | null = null;
+
+  static getInstance(): PluginSourceWatcher {
+    PluginSourceWatcher.singleton ??= new PluginSourceWatcher();
+    return PluginSourceWatcher.singleton;
+  }
+
+  /** Test-only — drops the singleton so the next `getInstance()` rebuilds. */
+  static resetForTests(): void {
+    PluginSourceWatcher.singleton?.stop();
+    PluginSourceWatcher.singleton = null;
+  }
+
+  private watcher: FSWatcher | null = null;
+  private started = false;
+  private debouncer = new DebouncerMap({
+    defaultDelayMs: PLUGIN_SOURCE_DEBOUNCE_MS,
+    maxEntries: 50,
+  });
+
+  start(): void {
+    this.started = true;
+    this.tryWatch();
+  }
+
+  /**
+   * Ensure the watcher is running. Idempotent — safe to call after a tool
+   * side-effect that may have just created the plugins directory.
+   * No-op if `start()` has not been called yet.
+   */
+  ensureStarted(): void {
+    if (!this.started || this.watcher) return;
+    this.tryWatch();
+  }
+
+  stop(): void {
+    this.started = false;
+    this.debouncer.cancelAll();
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+  }
+
+  private onChange(pluginName: string): Promise<void> {
+    return reregisterExternalPlugin(pluginName);
+  }
+
+  private tryWatch(): void {
+    if (this.watcher) return;
+
+    let pluginsDir: string;
+    try {
+      pluginsDir = getWorkspacePluginsDir();
+    } catch {
+      log.warn(
+        "Could not resolve plugins directory; plugin source watching disabled",
+      );
+      return;
+    }
+
+    try {
+      mkdirSync(pluginsDir, { recursive: true });
+    } catch (err) {
+      log.warn(
+        { err, pluginsDir },
+        "Could not create plugins directory; source watching disabled",
+      );
+      return;
+    }
+
+    try {
+      this.watcher = watch(
+        pluginsDir,
+        { recursive: true },
+        (_eventType, filename) => {
+          if (!filename) return;
+          const pluginName = resolvePluginNameFromRelPath(filename);
+          if (!pluginName) return;
+          this.debouncer.schedule(`plugin:${pluginName}`, () => {
+            void this.onChange(pluginName);
+          });
+        },
+      );
+      log.info({ pluginsDir }, "Plugin source watcher started");
+    } catch (err) {
+      log.warn(
+        { err },
+        "Failed to watch plugins directory; source watching disabled",
+      );
+    }
+  }
+}

package/src/daemon/process-message.ts

@@ -15,7 +15,6 @@ import {
   type InterfaceId,
   parseChannelId,
   parseInterfaceId,
-  supportsHostProxy,
 } from "../channels/types.js";
 import {
   getAttachmentsByIds,
@@ -31,9 +30,13 @@ import {
 import { updateMetaFile } from "../memory/conversation-disk-view.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../util/logger.js";
 import type { Conversation } from "./conversation.js";
-import { buildSlackMetaForPersistence } from "./conversation-messaging.js";
+import {
+  buildSlackMetaForPersistence,
+  serializePersistedUserMessageContent,
+} from "./conversation-messaging.js";
 import { formatCompactResult } from "./conversation-process.js";
 import { resolveChannelCapabilities } from "./conversation-runtime-assembly.js";
 import {
@@ -47,10 +50,41 @@ import {
 import type { ConversationCreateOptions } from "./handlers/shared.js";
 import { HostAppControlProxy } from "./host-app-control-proxy.js";
 import { HostCuProxy } from "./host-cu-proxy.js";
-import { preactivateHostProxySkills } from "./host-proxy-preactivation.js";
+import {
+  preactivateHostProxySkills,
+  shouldAttachHostProxyForCapability,
+} from "./host-proxy-preactivation.js";
+import type { ServerMessage } from "./message-protocol.js";
 
 const log = getLogger("process-message");
 
+type ProcessMessageOptions = ConversationCreateOptions & {
+  /** Per-turn observer for live agent-loop events. Does not replace SSE broadcast. */
+  onEvent?: (msg: ServerMessage) => void;
+};
+
+function stripPerTurnObservers(
+  options?: ProcessMessageOptions,
+): ConversationCreateOptions | undefined {
+  if (!options) return undefined;
+  const { onEvent: _onEvent, ...conversationOptions } = options;
+  return conversationOptions;
+}
+
+function buildEventEmitter(
+  observer?: (msg: ServerMessage) => void,
+): (msg: ServerMessage) => void {
+  if (!observer) return broadcastMessage;
+  return (msg) => {
+    broadcastMessage(msg);
+    try {
+      observer(msg);
+    } catch (err) {
+      log.warn({ err, messageType: msg.type }, "Agent event observer failed");
+    }
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Turn-context resolution helpers
 // ---------------------------------------------------------------------------
@@ -154,7 +188,7 @@ async function prepareConversationForMessage(
     );
   }
   // CU is per-conversation (owns step count, AX tree history, loop detection).
-  if (supportsHostProxy(resolvedInterface, "host_cu")) {
+  if (shouldAttachHostProxyForCapability("host_cu", resolvedInterface)) {
     if (!conversation.isProcessing() || !conversation.hostCuProxy) {
       conversation.setHostCuProxy(new HostCuProxy());
     }
@@ -162,10 +196,12 @@ async function prepareConversationForMessage(
     conversation.setHostCuProxy(undefined);
   }
   // App-control mirrors CU's per-conversation lifecycle. The proxy attaches
-  // unconditionally when the client supports the capability — feature-flag
-  // gating is enforced by the skill-projection layer via SKILL.md
-  // frontmatter, so an attached proxy is harmless when the flag is off.
-  if (supportsHostProxy(resolvedInterface, "host_app_control")) {
+  // unconditionally when the capability is reachable — feature-flag gating
+  // is enforced by the skill-projection layer via SKILL.md frontmatter, so
+  // an attached proxy is harmless when the flag is off.
+  if (
+    shouldAttachHostProxyForCapability("host_app_control", resolvedInterface)
+  ) {
     if (!conversation.isProcessing() || !conversation.hostAppControlProxy) {
       conversation.setHostAppControlProxy(
         new HostAppControlProxy(conversationId),
@@ -214,18 +250,20 @@ export async function processMessage(
   conversationId: string,
   content: string,
   attachmentIds?: string[],
-  options?: ConversationCreateOptions,
+  options?: ProcessMessageOptions,
   sourceChannel?: string,
   sourceInterface?: string,
 ): Promise<{ messageId: string }> {
+  const conversationOptions = stripPerTurnObservers(options);
   const { conversation, attachments } = await prepareConversationForMessage(
     conversationId,
     content,
     attachmentIds,
-    options,
+    conversationOptions,
     sourceChannel,
     sourceInterface,
   );
+  const emitEvent = buildEventEmitter(options?.onEvent);
 
   const serverInterfaceCtx = conversation.getTurnInterfaceContext();
   const slashContext = buildSlashContextForContent(content, {
@@ -280,7 +318,11 @@ export async function processMessage(
     const persisted = await addMessage(
       conversationId,
       "user",
-      JSON.stringify(cleanMsg.content),
+      serializePersistedUserMessageContent(
+        content,
+        attachments,
+        options?.displayContent,
+      ),
       userMetaWithSlack,
     );
     conversation.getMessages().push(llmMsg);
@@ -334,6 +376,7 @@ export async function processMessage(
       serverChannelMeta,
     );
     conversation.getMessages().push(assistantMsg);
+    publishConversationMessagesChanged(conversationId);
     return { messageId: persisted.id };
   }
 
@@ -365,7 +408,11 @@ export async function processMessage(
     const persisted = await addMessage(
       conversationId,
       "user",
-      JSON.stringify(cleanMsg.content),
+      serializePersistedUserMessageContent(
+        content,
+        attachments,
+        options?.displayContent,
+      ),
       compactUserMeta,
     );
     conversation.getMessages().push(cleanMsg);
@@ -375,7 +422,9 @@ export async function processMessage(
       "context_compacting",
       "assistant_turn",
     );
-    const result = await conversation.forceCompact();
+    const result = await conversation.forceCompact({
+      targetInputTokensOverride: slashResult.targetInputTokensOverride,
+    });
     const responseText = formatCompactResult(result);
     const assistantMsg = createAssistantMessage(responseText);
     await addMessage(
@@ -385,6 +434,7 @@ export async function processMessage(
       compactChannelMeta,
     );
     conversation.getMessages().push(assistantMsg);
+    publishConversationMessagesChanged(conversationId);
     return { messageId: persisted.id };
   }
 
@@ -399,7 +449,9 @@ export async function processMessage(
     attachments,
     requestId,
     persistMetadata,
+    options?.displayContent,
   );
+  publishConversationMessagesChanged(conversationId);
 
   if (options?.isInteractive === true) {
     conversation.updateClient(broadcastMessage, false);
@@ -409,16 +461,11 @@ export async function processMessage(
     conversation.setSlackRuntimeContextNotice(
       options?.slackRuntimeContextNotice,
     );
-    await conversation.runAgentLoop(
-      resolvedContent,
-      messageId,
-      broadcastMessage,
-      {
-        isInteractive: options?.isInteractive ?? false,
-        isUserMessage: true,
-        ...(options?.callSite ? { callSite: options.callSite } : {}),
-      },
-    );
+    await conversation.runAgentLoop(resolvedContent, messageId, emitEvent, {
+      isInteractive: options?.isInteractive ?? false,
+      isUserMessage: true,
+      ...(options?.callSite ? { callSite: options.callSite } : {}),
+    });
   } finally {
     conversation.setSlackRuntimeContextNotice(undefined);
     if (
@@ -444,18 +491,20 @@ export async function processMessageInBackground(
   conversationId: string,
   content: string,
   attachmentIds?: string[],
-  options?: ConversationCreateOptions,
+  options?: ProcessMessageOptions,
   sourceChannel?: string,
   sourceInterface?: string,
 ): Promise<{ messageId: string }> {
+  const conversationOptions = stripPerTurnObservers(options);
   const { conversation, attachments } = await prepareConversationForMessage(
     conversationId,
     content,
     attachmentIds,
-    options,
+    conversationOptions,
     sourceChannel,
     sourceInterface,
   );
+  const emitEvent = buildEventEmitter(options?.onEvent);
 
   const requestId = crypto.randomUUID();
   const persistMetadata = options?.slackInbound
@@ -466,7 +515,9 @@ export async function processMessageInBackground(
     attachments,
     requestId,
     persistMetadata,
+    options?.displayContent,
   );
+  publishConversationMessagesChanged(conversationId);
 
   if (options?.isInteractive === true) {
     conversation.updateClient(broadcastMessage, false);
@@ -474,7 +525,7 @@ export async function processMessageInBackground(
 
   conversation.setSlackRuntimeContextNotice(options?.slackRuntimeContextNotice);
   conversation
-    .runAgentLoop(content, messageId, broadcastMessage, {
+    .runAgentLoop(content, messageId, emitEvent, {
       isInteractive: options?.isInteractive ?? false,
       isUserMessage: true,
       ...(options?.callSite ? { callSite: options.callSite } : {}),

package/src/daemon/server.ts

@@ -14,13 +14,16 @@ import { syncIdentityNameToPlatform } from "../platform/sync-identity.js";
 import { initializeProviders } from "../providers/registry.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getSigningKeyFingerprint } from "../runtime/auth/token-service.js";
+import {
+  publishAvatarChanged,
+  publishConfigChanged,
+  publishIdentityChanged,
+  publishSoundsConfigUpdated,
+} from "../runtime/sync/resource-sync-events.js";
 import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
 import { getSubagentManager } from "../subagent/index.js";
 import { getLogger } from "../util/logger.js";
-import {
-  getAvatarImagePath,
-  getWorkspacePromptPath,
-} from "../util/platform.js";
+import { getWorkspacePromptPath } from "../util/platform.js";
 import {
   AppSourceWatcher,
   setEnsureAppSourceWatcher,
@@ -42,6 +45,8 @@ import { refreshSurfacesForApp } from "./conversation-surfaces.js";
 import { parseIdentityFields } from "./handlers/identity.js";
 import type { ConversationCreateOptions } from "./handlers/shared.js";
 import { setGlobalSkillIpcSender } from "./meet-host-supervisor.js";
+import { PluginSourceWatcher } from "./plugin-source-watcher.js";
+import { refreshSkillCapabilityMemories } from "./skill-memory-refresh.js";
 
 const log = getLogger("server");
 
@@ -67,6 +72,7 @@ export class DaemonServer {
   // Composed subsystems
   private configWatcher = getConfigWatcher();
   private appSourceWatcher = new AppSourceWatcher();
+  private pluginSourceWatcher = PluginSourceWatcher.getInstance();
   private cliIpc = new AssistantIpcServer();
   private skillIpc = new SkillIpcServer();
 
@@ -164,14 +170,7 @@ export class DaemonServer {
         ? readFileSync(identityPath, "utf-8")
         : "";
       const fields = parseIdentityFields(content);
-      broadcastMessage({
-        type: "identity_changed",
-        name: fields.name,
-        role: fields.role,
-        personality: fields.personality,
-        emoji: fields.emoji,
-        home: fields.home,
-      });
+      publishIdentityChanged(fields);
 
       // Best-effort sync of the assistant name to the platform record.
       if (fields.name) {
@@ -199,18 +198,15 @@ export class DaemonServer {
   }
 
   private broadcastConfigChanged(): void {
-    broadcastMessage({ type: "config_changed" });
+    publishConfigChanged();
   }
 
   private broadcastSoundsConfigUpdated(): void {
-    broadcastMessage({ type: "sounds_config_updated" });
+    publishSoundsConfigUpdated();
   }
 
   private broadcastAvatarUpdated(): void {
-    broadcastMessage({
-      type: "avatar_updated",
-      avatarPath: getAvatarImagePath(),
-    });
+    publishAvatarChanged();
   }
 
   /**
@@ -260,13 +256,27 @@ export class DaemonServer {
 
     this.evictor.start();
 
-    await this.cliIpc.start();
+    try {
+      await this.cliIpc.start();
+    } catch (err) {
+      log.warn(
+        { err },
+        "CLI IPC server failed to start — continuing startup with degraded CLI connectivity",
+      );
+    }
 
     // Start the skill IPC server. First-party skill processes connect to this
     // socket to access host capabilities (host.log, host.config.*,
     // host.events.*, host.registries.*). Route registry is populated by
     // subsequent PRs in the skill-isolation plan.
-    await this.skillIpc.start();
+    try {
+      await this.skillIpc.start();
+    } catch (err) {
+      log.warn(
+        { err },
+        "Skill IPC server failed to start — continuing startup with degraded skill host connectivity",
+      );
+    }
 
     this.configWatcher.start(
       () => this.evictConversationsForReload(),
@@ -274,12 +284,15 @@ export class DaemonServer {
       () => this.broadcastSoundsConfigUpdated(),
       () => this.broadcastAvatarUpdated(),
       () => this.broadcastConfigChanged(),
+      () => refreshSkillCapabilityMemories(getConfig()),
     );
 
     this.syncIdentityToPlatform();
 
     this.appSourceWatcher.start((appId) => this.handleAppSourceChange(appId));
 
+    this.pluginSourceWatcher.start();
+
     // Broadcast contacts_changed to all clients when any contact mutation occurs.
     this.unsubscribeContactChange = onContactChange(() => {
       broadcastMessage({ type: "contacts_changed" });
@@ -294,6 +307,7 @@ export class DaemonServer {
     this.evictor.stop();
     this.configWatcher.stop();
     this.appSourceWatcher.stop();
+    this.pluginSourceWatcher.stop();
     this.cliIpc.stop();
     this.skillIpc.stop();
     if (this.unsubscribeContactChange) {

package/src/daemon/shutdown-handlers.ts

@@ -23,7 +23,6 @@ export interface ShutdownDeps {
   filing: FilingService | null;
   runtimeHttp: RuntimeHttpServer | null;
   scheduler: { stop(): void };
-  feedScheduler: { stop(): void } | null;
   getMemoryWorker: () => { stop(): void } | null;
   getQdrantManager: () => QdrantManager | null;
   mcpManager: McpServerManager | null;
@@ -119,7 +118,6 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     await browserManager.closeAllPages();
     cleanupShellOutputTempFiles();
     deps.scheduler.stop();
-    deps.feedScheduler?.stop();
     deps.getMemoryWorker()?.stop();
 
     if (deps.mcpManager) {

package/src/daemon/skill-memory-refresh.ts

@@ -0,0 +1,29 @@
+import { getConfig } from "../config/loader.js";
+import type { AssistantConfig } from "../config/schema.js";
+import {
+  seedSkillGraphNodes,
+  seedUninstalledCatalogSkillMemories,
+} from "../memory/graph/capability-seed.js";
+import { getLogger } from "../util/logger.js";
+import { maybeSeedMemoryV2Skills } from "./memory-v2-startup.js";
+
+const log = getLogger("skill-memory-refresh");
+
+export function refreshSkillCapabilityMemories(
+  config: AssistantConfig = getConfig(),
+): void {
+  seedSkillGraphNodes();
+  maybeSeedMemoryV2Skills(config);
+  void seedUninstalledCatalogSkillMemories()
+    .then(() => {
+      // Re-run after the async catalog fetch populates the cache so stale
+      // installed-skill nodes can be pruned without deleting catalog-only nodes.
+      seedSkillGraphNodes();
+    })
+    .catch((err) =>
+      log.warn(
+        { err },
+        "Uninstalled catalog skill memory seeding failed — continuing",
+      ),
+    );
+}

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

@@ -40,6 +40,15 @@ export interface ToolSetupContext extends SurfaceConversationContext {
 
   /** Turn-scoped flag: true when any tool call in the current turn received explicit user approval via interactive prompt. Cleared at turn end. */
   approvedViaPromptThisTurn?: boolean;
+  /**
+   * When true, side-effect tools must prompt for confirmation even if a
+   * trust/allow rule would auto-allow them. Set by callers without an
+   * interactive approval UI (e.g. non-guardian phone voice turns) to force
+   * a `confirmation_request` event that the caller's auto-deny / scoped-grant
+   * handler can intercept. Provides a second layer of defense against broad
+   * trust rules auto-executing side-effect tools in non-interactive contexts.
+   */
+  forcePromptSideEffects?: boolean;
   /**
    * Per-turn snapshot of the resolved inference-profile override, set by
    * `runAgentLoopImpl`. Propagated into `ToolContext.overrideProfile` so

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

@@ -12,6 +12,7 @@ import { isAbsolute, resolve, sep } from "node:path";
 import { generateAppIcon } from "../media/app-icon-generator.js";
 import { addAppConversationId } from "../memory/app-store.js";
 import { invalidateEdgeIndex } from "../memory/v2/edge-index.js";
+import { invalidatePageIndex } from "../memory/v2/page-index.js";
 import { getConceptsDir } from "../memory/v2/page-store.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { findActiveSession } from "../runtime/channel-verification-service.js";
@@ -245,10 +246,10 @@ registerHook("bash", (_name, input, result) => {
   }
 });
 
-// Invalidate the in-memory v2 edge index when the LLM writes or edits a file
-// under `memory/concepts/`. The page-store invalidates on programmatic writes;
-// this hook covers consolidation, where the LLM edits page frontmatter through
-// the file tools rather than through `writePage`.
+// Invalidate the in-memory v2 edge index and page index when the LLM writes
+// or edits a file under `memory/concepts/`. The page-store invalidates on
+// programmatic writes; this hook covers consolidation, where the LLM edits
+// page frontmatter through the file tools rather than through `writePage`.
 function invalidateEdgeIndexIfConceptPage(
   input: Record<string, unknown>,
 ): void {
@@ -264,6 +265,7 @@ function invalidateEdgeIndexIfConceptPage(
     : conceptsRoot + sep;
   if (absPath.startsWith(rootWithSep)) {
     invalidateEdgeIndex(workspaceDir);
+    invalidatePageIndex(workspaceDir);
   }
 }
 registerHook("file_write", (_name, input) =>

package/src/daemon/wake-target-adapter.ts

@@ -14,6 +14,7 @@ import {
   provenanceFromTrustContext,
 } from "../memory/conversation-crud.js";
 import { syncMessageToDisk } from "../memory/conversation-disk-view.js";
+import { backfillMessageIdOnLogs } from "../memory/llm-request-log-store.js";
 import type { WakeTarget } from "../runtime/agent-wake.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getLogger } from "../util/logger.js";
@@ -197,6 +198,16 @@ export function conversationToWakeTarget(
         JSON.stringify(message.content),
         metadata,
       );
+      if (message.role === "assistant") {
+        try {
+          backfillMessageIdOnLogs(conversation.conversationId, persisted.id);
+        } catch (err) {
+          log.warn(
+            { err, conversationId: conversation.conversationId },
+            "wake adapter: backfill messageId on LLM logs failed (non-fatal)",
+          );
+        }
+      }
       try {
         const convRow = getConversation(conversation.conversationId);
         if (convRow) {