@vellumai/assistant 0.4.54 → 0.4.56

package/src/signals/user-message.ts

@@ -0,0 +1,146 @@
+/**
+ * Handle user-message signals delivered via signal files from the CLI.
+ *
+ * Each invocation writes JSON to a unique `signals/user-message.<requestId>`
+ * file. ConfigWatcher detects the new file and invokes
+ * {@link handleUserMessageSignal}, which reads the payload, dispatches
+ * the message through the daemon's send pipeline, and writes the result
+ * to `signals/user-message.<requestId>.result` for the CLI to pick up.
+ *
+ * Per-request filenames avoid dropped messages when overlapping invocations
+ * race on the same signal file.
+ *
+ * Because the signal handler needs access to the daemon's conversation map and
+ * event hub, the daemon registers a callback at startup via
+ * {@link registerUserMessageCallback}.
+ */
+
+import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { getLogger } from "../util/logger.js";
+import { getSignalsDir } from "../util/platform.js";
+
+const log = getLogger("signal:user-message");
+
+// ── Daemon callback registry ─────────────────────────────────────────
+
+type UserMessageCallback = (params: {
+  conversationKey: string;
+  content: string;
+  sourceChannel: string;
+  sourceInterface: string;
+}) => Promise<{ accepted: boolean }>;
+
+let _sendUserMessage: UserMessageCallback | null = null;
+
+/**
+ * Register the user-message callback. Called once by the daemon server at
+ * startup so the signal handler can reach the conversation map and event hub.
+ */
+export function registerUserMessageCallback(cb: UserMessageCallback): void {
+  _sendUserMessage = cb;
+}
+
+// ── Signal handler ───────────────────────────────────────────────────
+
+/**
+ * Read a `signals/user-message.<requestId>` file and dispatch the message
+ * through the daemon's send pipeline. Writes
+ * `signals/user-message.<requestId>.result` with the outcome so the CLI
+ * can display feedback. Called by ConfigWatcher when a matching signal
+ * file is created or modified.
+ */
+export async function handleUserMessageSignal(filename: string): Promise<void> {
+  const signalsDir = getSignalsDir();
+  const signalPath = join(signalsDir, filename);
+  const resultPath = join(signalsDir, `${filename}.result`);
+
+  const writeResult = (
+    data:
+      | { ok: true; accepted: boolean; requestId: string }
+      | { ok: false; error: string; requestId: string | null },
+  ): void => {
+    try {
+      writeFileSync(resultPath, JSON.stringify(data));
+    } catch {
+      // Best-effort — filesystem may be broken.
+    }
+  };
+
+  let raw: string;
+  try {
+    raw = readFileSync(signalPath, "utf-8");
+  } catch {
+    // File may already be deleted (e.g. re-trigger from our own unlinkSync).
+    return;
+  }
+
+  try {
+    unlinkSync(signalPath);
+  } catch {
+    // Best-effort cleanup; the file may already be gone.
+  }
+
+  let parsedRequestId: string | undefined;
+
+  try {
+    const parsed = JSON.parse(raw) as {
+      conversationKey?: string;
+      content?: string;
+      sourceChannel?: string;
+      interface?: string;
+      requestId?: string;
+    };
+    const { requestId } = parsed;
+    parsedRequestId = requestId;
+
+    if (!requestId || typeof requestId !== "string") {
+      log.warn("User-message signal missing requestId");
+      writeResult({ ok: false, error: "Missing requestId", requestId: null });
+      return;
+    }
+
+    if (!parsed.conversationKey || typeof parsed.conversationKey !== "string") {
+      log.warn("User-message signal missing conversationKey");
+      writeResult({
+        ok: false,
+        error: "Missing conversationKey",
+        requestId,
+      });
+      return;
+    }
+
+    if (!parsed.content || typeof parsed.content !== "string") {
+      log.warn("User-message signal missing content");
+      writeResult({ ok: false, error: "Missing content", requestId });
+      return;
+    }
+
+    if (!_sendUserMessage) {
+      log.warn("User-message callback not registered; daemon may not be ready");
+      writeResult({ ok: false, error: "Assistant not ready", requestId });
+      return;
+    }
+
+    const result = await _sendUserMessage({
+      conversationKey: parsed.conversationKey,
+      content: parsed.content,
+      sourceChannel: parsed.sourceChannel ?? "vellum",
+      sourceInterface: parsed.interface ?? "cli",
+    });
+
+    log.info(
+      { accepted: result.accepted },
+      "User message dispatched via signal file",
+    );
+    writeResult({ ok: true, accepted: result.accepted, requestId });
+  } catch (err) {
+    log.error({ err }, "Failed to handle user-message signal");
+    writeResult({
+      ok: false,
+      error: "Internal error",
+      requestId: parsedRequestId ?? null,
+    });
+  }
+}

package/src/skills/catalog-install.ts

@@ -90,7 +90,7 @@ function buildHeaders(): Record<string, string> {
   const headers: Record<string, string> = {};
   const token = readPlatformToken();
   if (token) {
-    headers["X-Session-Token"] = token;
+    headers["X-Conversation-Token"] = token;
   }
   return headers;
 }

package/src/skills/managed-store.ts

@@ -52,8 +52,6 @@ interface BuildSkillMarkdownInput {
   description: string;
   bodyMarkdown: string;
   emoji?: string;
-  userInvocable?: boolean;
-  disableModelInvocation?: boolean;
   includes?: string[];
 }
 
@@ -72,17 +70,10 @@ export function buildSkillMarkdown(input: BuildSkillMarkdownInput): string {
   // metadata:
   //   vellum:
   //     emoji: "..."
-  //     user-invocable: false
   const vellum: Record<string, unknown> = {};
   if (input.emoji) {
     vellum.emoji = input.emoji;
   }
-  if (input.userInvocable === false) {
-    vellum["user-invocable"] = false;
-  }
-  if (input.disableModelInvocation === true) {
-    vellum["disable-model-invocation"] = true;
-  }
   if (input.includes && input.includes.length > 0) {
     vellum.includes = input.includes;
   }
@@ -201,8 +192,6 @@ interface CreateManagedSkillParams {
   description: string;
   bodyMarkdown: string;
   emoji?: string;
-  userInvocable?: boolean;
-  disableModelInvocation?: boolean;
   overwrite?: boolean;
   addToIndex?: boolean;
   includes?: string[];
@@ -263,8 +252,6 @@ export function createManagedSkill(
     description: params.description,
     bodyMarkdown: params.bodyMarkdown,
     emoji: params.emoji,
-    userInvocable: params.userInvocable,
-    disableModelInvocation: params.disableModelInvocation,
     includes: params.includes,
   });
 

package/src/subagent/manager.ts

@@ -1,18 +1,21 @@
 /**
- * SubagentManager — owns the lifecycle of all subagent sessions.
+ * SubagentManager — owns the lifecycle of all subagent conversations.
  *
  * Responsibilities:
- *   - spawn / abort / dispose subagent sessions
+ *   - spawn / abort / dispose subagent conversations
  *   - enforce concurrency and depth limits
- *   - route events from child sessions through parent's socket
+ *   - route events from child conversations through parent's socket
  *   - inject completion summaries back into parent context
  */
 
 import { v4 as uuid } from "uuid";
 
 import { getConfig } from "../config/loader.js";
+import {
+  Conversation,
+  type ConversationMemoryPolicy,
+} from "../daemon/conversation.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
-import { Session, type SessionMemoryPolicy } from "../daemon/session.js";
 import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
 import { RateLimitProvider } from "../providers/ratelimit.js";
 import { getFailoverProvider } from "../providers/registry.js";
@@ -47,7 +50,7 @@ function buildSubagentSystemPrompt(config: SubagentConfig): string {
 // ── Manager ─────────────────────────────────────────────────────────────
 
 interface ManagedSubagent {
-  session: Session;
+  conversation: Conversation;
   state: SubagentState;
   /** Mutable reference to the parent's current sendToClient. Updated on reconnect. */
   parentSendToClient: (msg: ServerMessage) => void;
@@ -62,7 +65,7 @@ export interface SubagentNotificationInfo {
 }
 
 export type ParentNotifyCallback = (
-  parentSessionId: string,
+  parentConversationId: string,
   message: string,
   sendToClient: (msg: ServerMessage) => void,
   notification: SubagentNotificationInfo,
@@ -71,12 +74,12 @@ export type ParentNotifyCallback = (
 export class SubagentManager {
   /** subagentId → ManagedSubagent */
   private subagents = new Map<string, ManagedSubagent>();
-  /** parentSessionId → Set<subagentId> */
+  /** parentConversationId → Set<subagentId> */
   private parentToChildren = new Map<string, Set<string>>();
 
   /**
    * Optional callback to inject a completion/failure message into the parent
-   * session's conversation so the LLM can automatically inform the user.
+   * conversation so the LLM can automatically inform the user.
    * Wired by DaemonServer at startup.
    */
   onSubagentFinished?: ParentNotifyCallback;
@@ -87,6 +90,13 @@ export class SubagentManager {
    */
   sharedRequestTimestamps: number[] = [];
 
+  /**
+   * Broadcast callback from the daemon server.
+   * Set by DaemonServer at startup so subagent conversations can broadcast
+   * to all connected clients (e.g. app_files_changed side-effects).
+   */
+  broadcastToAllClients?: (msg: ServerMessage) => void;
+
   // ── Spawn ───────────────────────────────────────────────────────────
 
   /**
@@ -101,7 +111,7 @@ export class SubagentManager {
 
     // Depth check: prevent subagents from spawning nested subagents.
     const isParentASubagent = [...this.subagents.values()].some(
-      (s) => s.state.conversationId === config.parentSessionId,
+      (s) => s.state.conversationId === config.parentConversationId,
     );
     if (isParentASubagent) {
       throw new Error(
@@ -111,16 +121,16 @@ export class SubagentManager {
 
     // ── Create conversation ─────────────────────────────────────────
     const subagentId = uuid();
-    const conversation = bootstrapConversation({
-      threadType: "background",
+    const conversationRecord = bootstrapConversation({
+      conversationType: "background",
       origin: "subagent",
       systemHint: `Subagent: ${config.label}`,
     });
 
-    // ── Build session dependencies ──────────────────────────────────
+    // ── Build conversation dependencies ─────────────────────────────
     const appConfig = getConfig();
     let provider = getFailoverProvider(
-      appConfig.provider,
+      appConfig.services.inference.provider,
       appConfig.providerOrder,
     );
     const { rateLimit } = appConfig;
@@ -141,7 +151,7 @@ export class SubagentManager {
     const maxTokens = appConfig.maxTokens;
     const workingDir = getSandboxWorkingDir();
 
-    const memoryPolicy: SessionMemoryPolicy = {
+    const memoryPolicy: ConversationMemoryPolicy = {
       scopeId: `subagent:${subagentId}`,
       includeDefaultFallback: true,
       strictSideEffects: false,
@@ -152,7 +162,7 @@ export class SubagentManager {
     const state: SubagentState = {
       config: { ...config, id: subagentId },
       status: "pending",
-      conversationId: conversation.id,
+      conversationId: conversationRecord.id,
       createdAt: now,
       usage: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     };
@@ -160,9 +170,9 @@ export class SubagentManager {
     // Store the managed subagent early so the wrapper can read the mutable
     // parentSendToClient reference — this ensures reconnects are picked up.
     const managed: ManagedSubagent = {
-      // Placeholder — replaced with the real Session a few lines below, before
+      // Placeholder — replaced with the real Conversation a few lines below, before
       // any code reads this field. Using null! avoids the `as unknown as` cast.
-      session: null! as Session,
+      conversation: null! as Conversation,
       state,
       parentSendToClient,
     };
@@ -177,35 +187,35 @@ export class SubagentManager {
       } as ServerMessage);
     };
 
-    const session = new Session(
-      conversation.id,
+    const conversation = new Conversation(
+      conversationRecord.id,
       provider,
       systemPrompt,
       maxTokens,
       wrappedSendToClient,
       workingDir,
-      undefined, // no broadcastToAllClients for subagents
+      this.broadcastToAllClients, // forward parent's broadcast so tool side-effects (e.g. app_files_changed) reach all clients
       memoryPolicy,
     );
 
-    // Mark session as having no direct client — it routes through parent.
+    // Mark conversation as having no direct client — it routes through parent.
     // This ensures interactive prompts (host attachment reads) fail fast.
-    session.updateClient(wrappedSendToClient, true);
+    conversation.updateClient(wrappedSendToClient, true);
 
-    managed.session = session;
+    managed.conversation = conversation;
     this.subagents.set(subagentId, managed);
 
     // Track parent → child relationship.
-    if (!this.parentToChildren.has(config.parentSessionId)) {
-      this.parentToChildren.set(config.parentSessionId, new Set());
+    if (!this.parentToChildren.has(config.parentConversationId)) {
+      this.parentToChildren.set(config.parentConversationId, new Set());
     }
-    this.parentToChildren.get(config.parentSessionId)!.add(subagentId);
+    this.parentToChildren.get(config.parentConversationId)!.add(subagentId);
 
     // Notify client that a subagent was spawned.
     parentSendToClient({
       type: "subagent_spawned",
       subagentId,
-      parentSessionId: config.parentSessionId,
+      parentConversationId: config.parentConversationId,
       label: config.label,
       objective: config.objective,
     } as ServerMessage);
@@ -213,7 +223,7 @@ export class SubagentManager {
     log.info(
       {
         subagentId,
-        parentSessionId: config.parentSessionId,
+        parentConversationId: config.parentConversationId,
         label: config.label,
       },
       "Subagent spawned",
@@ -242,16 +252,19 @@ export class SubagentManager {
     this.setStatus(subagentId, "running", getSender());
     managed.state.startedAt = Date.now();
 
-    const onEvent = managed.session.sendToClient;
+    const onEvent = managed.conversation.sendToClient;
 
     try {
       // Send the objective as the first user message and process it.
-      const messageId = await managed.session.persistUserMessage(objective, []);
-      await managed.session.runAgentLoop(objective, messageId, onEvent);
+      const messageId = await managed.conversation.persistUserMessage(
+        objective,
+        [],
+      );
+      await managed.conversation.runAgentLoop(objective, messageId, onEvent);
 
       // Agent loop completed successfully.
-      // Copy usage stats from the session before sending status (which includes usage).
-      managed.state.usage = { ...managed.session.usageStats };
+      // Copy usage stats from the conversation before sending status (which includes usage).
+      managed.state.usage = { ...managed.conversation.usageStats };
       // Only update state + notify if still non-terminal (guards against abort race).
       if (!TERMINAL_STATUSES.has(managed.state.status)) {
         managed.state.completedAt = Date.now();
@@ -259,14 +272,14 @@ export class SubagentManager {
 
         log.info({ subagentId }, "Subagent completed");
 
-        // Notify the parent session so the LLM can call subagent_read.
+        // Notify the parent conversation so the LLM can call subagent_read.
         this.notifyParent(managed, "completed", getSender());
       }
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);
       managed.state.error = errorMsg;
       managed.state.completedAt = Date.now();
-      managed.state.usage = { ...managed.session.usageStats };
+      managed.state.usage = { ...managed.conversation.usageStats };
 
       // Only update status if not already terminal (e.g. aborted).
       if (!TERMINAL_STATUSES.has(managed.state.status)) {
@@ -283,34 +296,34 @@ export class SubagentManager {
   abort(
     subagentId: string,
     parentSendToClient?: (msg: ServerMessage) => void,
-    callerSessionId?: string,
+    callerConversationId?: string,
     options?: { suppressNotification?: boolean },
   ): boolean {
     const managed = this.subagents.get(subagentId);
     if (!managed) return false;
     if (TERMINAL_STATUSES.has(managed.state.status)) return false;
-    // If a caller session is specified, verify ownership.
+    // If a caller conversation is specified, verify ownership.
     if (
-      callerSessionId &&
-      managed.state.config.parentSessionId !== callerSessionId
+      callerConversationId &&
+      managed.state.config.parentConversationId !== callerConversationId
     ) {
       log.warn(
         {
           subagentId,
-          callerSessionId,
-          parentSessionId: managed.state.config.parentSessionId,
+          callerConversationId,
+          parentConversationId: managed.state.config.parentConversationId,
         },
         "Abort rejected: caller does not own this subagent",
       );
       return false;
     }
 
-    managed.session.abort();
+    managed.conversation.abort();
     managed.state.completedAt = Date.now();
     if (parentSendToClient) {
       // Route the status update through the stored parent sender so the
-      // owning session's UI chip updates, even when the abort comes from a
-      // different socket (e.g. after thread switching). Fall back to the
+      // owning conversation's UI chip updates, even when the abort comes from a
+      // different socket (e.g. after conversation switching). Fall back to the
       // caller-provided sender if no stored sender exists.
       const statusSender = managed.parentSendToClient ?? parentSendToClient;
       this.setStatus(subagentId, "aborted", statusSender);
@@ -323,10 +336,10 @@ export class SubagentManager {
           `This subagent was cancelled on purpose. Do NOT re-spawn or retry it.`;
         try {
           // Use the managed subagent's stored parentSendToClient so the
-          // notification routes to the parent session's socket, not the
-          // aborting socket (which may be a different thread after switching).
+          // notification routes to the parent conversation's socket, not the
+          // aborting socket (which may be a different conversation after switching).
           this.onSubagentFinished(
-            managed.state.config.parentSessionId,
+            managed.state.config.parentConversationId,
             message,
             managed.parentSendToClient,
             {
@@ -349,14 +362,14 @@ export class SubagentManager {
   }
 
   /**
-   * Abort all subagents belonging to a parent session.
-   * Called when the parent session is aborted or evicted.
+   * Abort all subagents belonging to a parent conversation.
+   * Called when the parent conversation is aborted or evicted.
    */
   abortAllForParent(
-    parentSessionId: string,
+    parentConversationId: string,
     parentSendToClient?: (msg: ServerMessage) => void,
   ): number {
-    const children = this.parentToChildren.get(parentSessionId);
+    const children = this.parentToChildren.get(parentConversationId);
     if (!children) return 0;
 
     let count = 0;
@@ -366,7 +379,7 @@ export class SubagentManager {
       }
     }
 
-    // Dispose all children — the parent session is going away so nobody
+    // Dispose all children — the parent conversation is going away so nobody
     // will call subagent_read.  Use snapshot since dispose mutates the set.
     for (const childId of [...children]) {
       this.dispose(childId);
@@ -388,11 +401,11 @@ export class SubagentManager {
     if (!managed) return "not_found";
     if (TERMINAL_STATUSES.has(managed.state.status)) return "terminal";
 
-    const onEvent = managed.session.sendToClient;
+    const onEvent = managed.conversation.sendToClient;
     const requestId = uuid();
 
-    // If the session is busy, queue the message; otherwise process immediately.
-    const result = managed.session.enqueueMessage(
+    // If the conversation is busy, queue the message; otherwise process immediately.
+    const result = managed.conversation.enqueueMessage(
       trimmed,
       [],
       onEvent,
@@ -402,11 +415,16 @@ export class SubagentManager {
       return "sent"; // error event already delivered via onEvent
     }
     if (!result.queued) {
-      // Session is idle — send directly.  Fire-and-forget so we don't block.
-      const messageId = await managed.session.persistUserMessage(trimmed, []);
-      managed.session.runAgentLoop(trimmed, messageId, onEvent).catch((err) => {
-        log.error({ subagentId, err }, "Subagent message processing failed");
-      });
+      // Conversation is idle — send directly.  Fire-and-forget so we don't block.
+      const messageId = await managed.conversation.persistUserMessage(
+        trimmed,
+        [],
+      );
+      managed.conversation
+        .runAgentLoop(trimmed, messageId, onEvent)
+        .catch((err) => {
+          log.error({ subagentId, err }, "Subagent message processing failed");
+        });
     }
     return "sent";
   }
@@ -417,8 +435,8 @@ export class SubagentManager {
     return this.subagents.get(subagentId)?.state;
   }
 
-  getChildrenOf(parentSessionId: string): SubagentState[] {
-    const children = this.parentToChildren.get(parentSessionId);
+  getChildrenOf(parentConversationId: string): SubagentState[] {
+    const children = this.parentToChildren.get(parentConversationId);
     if (!children) return [];
     return [...children]
       .map((id) => this.subagents.get(id)?.state)
@@ -433,14 +451,14 @@ export class SubagentManager {
   }
 
   /**
-   * Update the parent sender for all active children of a session.
+   * Update the parent sender for all active children of a conversation.
    * Called when the parent client reconnects to a new socket.
    */
   updateParentSender(
-    parentSessionId: string,
+    parentConversationId: string,
     newSendToClient: (msg: ServerMessage) => void,
   ): void {
-    const children = this.parentToChildren.get(parentSessionId);
+    const children = this.parentToChildren.get(parentConversationId);
     if (!children) return;
 
     for (const childId of children) {
@@ -463,13 +481,13 @@ export class SubagentManager {
     if (!managed) return;
 
     if (!TERMINAL_STATUSES.has(managed.state.status)) {
-      managed.session.abort();
+      managed.conversation.abort();
     }
-    managed.session.dispose();
+    managed.conversation.dispose();
     this.subagents.delete(subagentId);
 
     // Remove from parent tracking.
-    const parentId = managed.state.config.parentSessionId;
+    const parentId = managed.state.config.parentConversationId;
     const siblings = this.parentToChildren.get(parentId);
     if (siblings) {
       siblings.delete(subagentId);
@@ -518,7 +536,7 @@ export class SubagentManager {
   }
 
   /**
-   * Inject a completion/failure notification into the parent session
+   * Inject a completion/failure notification into the parent conversation
    * so the LLM automatically informs the user.
    */
   private notifyParent(
@@ -559,7 +577,7 @@ export class SubagentManager {
 
     try {
       this.onSubagentFinished(
-        config.parentSessionId,
+        config.parentConversationId,
         message,
         parentSendToClient,
         notification,
@@ -567,7 +585,7 @@ export class SubagentManager {
     } catch (err) {
       log.error(
         { subagentId: config.id, err },
-        "Failed to notify parent session",
+        "Failed to notify parent conversation",
       );
     }
   }

package/src/subagent/types.ts

@@ -1,7 +1,7 @@
 /**
  * Subagent domain types.
  *
- * A subagent is a child Session spawned by a parent Session's LLM via the
+ * A subagent is a child Conversation spawned by a parent Conversation's LLM via the
  * `subagent_spawn` tool.  It runs an independent AgentLoop and streams events
  * back to the parent's client socket wrapped in `subagent_event` envelopes.
  */
@@ -27,8 +27,8 @@ export const TERMINAL_STATUSES: ReadonlySet<SubagentStatus> =
 export interface SubagentConfig {
   /** Unique subagent identifier (UUID). */
   id: string;
-  /** The parent Session's conversationId. */
-  parentSessionId: string;
+  /** The parent Conversation's conversationId. */
+  parentConversationId: string;
   /** Human-readable label (e.g. "Research competitor pricing"). */
   label: string;
   /** The task objective for this subagent. */
@@ -37,7 +37,7 @@ export interface SubagentConfig {
   context?: string;
   /** Optional system prompt override. Falls back to a default subagent prompt. */
   systemPromptOverride?: string;
-  /** Optional skill IDs to pre-activate on the subagent session. */
+  /** Optional skill IDs to pre-activate on the subagent conversation. */
   preactivatedSkillIds?: string[];
   /** Whether the parent should present the result to the user. Defaults to true. */
   sendResultToUser?: boolean;
@@ -48,7 +48,7 @@ export interface SubagentConfig {
 export interface SubagentState {
   config: SubagentConfig;
   status: SubagentStatus;
-  /** The subagent's own conversationId (different from parentSessionId). */
+  /** The subagent's own conversationId (different from parentConversationId). */
   conversationId: string;
   /** Error message if status is 'failed'. */
   error?: string;

package/src/swarm/backend-claude-code.ts

@@ -129,7 +129,7 @@ export function createClaudeCodeBackend(): SwarmWorkerBackend {
           if (message.type === "assistant") {
             if (message.error) {
               log.error(
-                { error: message.error, sessionId: message.session_id },
+                { error: message.error, conversationId: message.session_id },
                 "Swarm worker assistant message error",
               );
               hasError = true;