@vellumai/assistant 0.5.16 → 0.6.0

package/src/daemon/lifecycle.ts

@@ -82,7 +82,10 @@ import {
   setCesClient,
   setCesReconnect,
 } from "../security/secure-keys.js";
-import { seedCatalogSkillMemories } from "../skills/skill-memory.js";
+import {
+  seedCatalogSkillMemories,
+  seedUninstalledCatalogSkillMemories,
+} from "../skills/skill-memory.js";
 import { UsageTelemetryReporter } from "../telemetry/usage-telemetry-reporter.js";
 import { getDeviceId } from "../util/device-id.js";
 import { getLogger, initLogger } from "../util/logger.js";
@@ -650,11 +653,47 @@ export async function runDaemon(): Promise<void> {
         log.warn({ err }, "Catalog skill memory seeding failed — continuing");
       }
 
+      // Seed memories for catalog skills not yet installed so they're
+      // discoverable via memory injection and can be auto-installed.
+      void seedUninstalledCatalogSkillMemories().catch((err) =>
+        log.warn(
+          { err },
+          "Uninstalled catalog skill memory seeding failed — continuing",
+        ),
+      );
+
       try {
         seedCliCommandMemories();
       } catch (err) {
         log.warn({ err }, "CLI command memory seeding failed — continuing");
       }
+
+      // Seed capability graph nodes (new memory graph system)
+      try {
+        const { seedSkillGraphNodes, seedCliGraphNodes } =
+          await import("../memory/graph/capability-seed.js");
+        seedSkillGraphNodes();
+        seedCliGraphNodes();
+      } catch (err) {
+        log.warn({ err }, "Graph capability seeding failed — continuing");
+      }
+
+      // Auto-bootstrap: if the graph has no non-procedural nodes but historical
+      // segments exist, enqueue a one-time graph_bootstrap job to populate the
+      // graph from conversation history and journal files.
+      try {
+        const {
+          maybeEnqueueGraphBootstrap,
+          cleanupStaleItemVectors,
+        } = await import("../memory/graph/bootstrap.js");
+        maybeEnqueueGraphBootstrap();
+        // Fire-and-forget: clean up orphaned Qdrant vectors from dropped memory_items table
+        void cleanupStaleItemVectors().catch((err) =>
+          log.warn({ err }, "Stale item vector cleanup failed — continuing"),
+        );
+      } catch (err) {
+        log.warn({ err }, "Graph bootstrap check failed — continuing");
+      }
     }
 
     // Fire-and-forget: Qdrant init runs concurrently with the rest of startup

package/src/daemon/main.ts

@@ -1,9 +1,13 @@
 #!/usr/bin/env bun
 process.title = "vellum-daemon";
 
+import { homedir } from "node:os";
+import { join } from "node:path";
+
 import * as Sentry from "@sentry/node";
 
 import { getLogger } from "../util/logger.js";
+import { getDataDir } from "../util/platform.js";
 import { runDaemon } from "./lifecycle.js";
 import { emitDaemonError } from "./startup-error.js";
 
@@ -21,7 +25,7 @@ runDaemon().catch(async (err) => {
   }
   console.error("Failed to start assistant:", err);
   console.error(
-    "Troubleshooting: check if another assistant is already running, verify ~/.vellum/ permissions, and review logs at ~/.vellum/workspace/data/logs/",
+    `Troubleshooting: check if another assistant is already running, verify ${join(homedir(), ".vellum")} permissions, and review logs at ${getDataDir()}/logs/`,
   );
   // Emit a structured error line as the last line of stderr so consumers
   // (e.g. the macOS app) can parse it reliably.

package/src/daemon/message-types/conversations.ts

@@ -264,8 +264,10 @@ export interface HistoryResponseToolCall {
   input: Record<string, unknown>;
   result?: string;
   isError?: boolean;
-  /** Base64-encoded image data from tool contentBlocks (e.g. browser_screenshot). */
+  /** Base64-encoded image data from tool contentBlocks (e.g. browser_screenshot). @deprecated Use imageDataList. */
   imageData?: string;
+  /** Base64-encoded image data from tool contentBlocks (e.g. browser_screenshot, image generation). */
+  imageDataList?: string[];
   /** Unix ms when the tool started executing. */
   startedAt?: number;
   /** Unix ms when the tool completed. */
@@ -370,6 +372,7 @@ export interface ContextCompacted {
 export type ConversationErrorCode =
   | "PROVIDER_NETWORK"
   | "PROVIDER_RATE_LIMIT"
+  | "PROVIDER_OVERLOADED"
   | "PROVIDER_API"
   | "PROVIDER_BILLING"
   | "PROVIDER_ORDERING"

package/src/daemon/message-types/messages.ts

@@ -124,8 +124,10 @@ export interface ToolResult {
   };
   status?: string;
   conversationId?: string;
-  /** Base64-encoded image data extracted from contentBlocks (e.g. browser_screenshot). */
+  /** Base64-encoded image data extracted from contentBlocks (e.g. browser_screenshot). @deprecated Use imageDataList. */
   imageData?: string;
+  /** Base64-encoded image data extracted from contentBlocks (e.g. browser_screenshot, image generation). */
+  imageDataList?: string[];
   /** The tool_use block ID for client-side correlation. */
   toolUseId?: string;
 }

package/src/daemon/message-types/skills.ts

@@ -76,33 +76,50 @@ export interface SkillsCreateRequest {
 
 // === Server → Client ===
 
+/** Fields shared by all skill origins. */
+interface SlimSkillBase {
+  id: string;
+  name: string;
+  description: string;
+  emoji?: string;
+  kind: "bundled" | "installed" | "catalog";
+  status: "enabled" | "disabled" | "available";
+}
+
+interface VellumSlimSkill extends SlimSkillBase {
+  origin: "vellum";
+}
+
+interface ClawhubSlimSkill extends SlimSkillBase {
+  origin: "clawhub";
+  slug: string;
+  author: string;
+  stars: number;
+  installs: number;
+  reports: number;
+  publishedAt?: string;
+}
+
+interface SkillsshSlimSkill extends SlimSkillBase {
+  origin: "skillssh";
+  slug: string;
+  sourceRepo: string;
+  installs: number;
+}
+
+interface CustomSlimSkill extends SlimSkillBase {
+  origin: "custom";
+}
+
+export type SlimSkillResponse =
+  | VellumSlimSkill
+  | ClawhubSlimSkill
+  | SkillsshSlimSkill
+  | CustomSlimSkill;
+
 export interface SkillsListResponse {
   type: "skills_list_response";
-  skills: Array<{
-    id: string;
-    name: string;
-    description: string;
-    emoji?: string;
-    homepage?: string;
-    source: "bundled" | "managed" | "workspace" | "clawhub" | "extra";
-    state: "enabled" | "disabled";
-    installedVersion?: string;
-    latestVersion?: string;
-    updateAvailable: boolean;
-    clawhub?: {
-      author: string;
-      stars: number;
-      installs: number;
-      reports: number;
-      publishedAt: string;
-    };
-    provenance?: {
-      kind: "first-party" | "third-party" | "local";
-      provider?: string;
-      originId?: string;
-      sourceUrl?: string;
-    };
-  }>;
+  skills: SlimSkillResponse[];
 }
 
 export interface SkillStateChanged {
@@ -111,15 +128,7 @@ export interface SkillStateChanged {
   state: "enabled" | "disabled" | "installed" | "uninstalled";
 }
 
-export interface SkillsOperationResponse {
-  type: "skills_operation_response";
-  operation: string;
-  success: boolean;
-  error?: string;
-  data?: unknown;
-}
-
-export interface SkillDetailResponse {
+export interface SkillBodyResponse {
   type: "skill_detail_response";
   skillId: string;
   body: string;
@@ -127,6 +136,59 @@ export interface SkillDetailResponse {
   error?: string;
 }
 
+// ─── Detail endpoint response (HTTP API) ──────────────────────────────────
+
+interface SkillDetailBase {
+  id: string;
+  name: string;
+  description: string;
+  emoji?: string;
+  kind: "bundled" | "installed" | "catalog";
+  status: "enabled" | "disabled" | "available";
+}
+
+interface VellumSkillDetail extends SkillDetailBase {
+  origin: "vellum";
+}
+
+interface ClawhubSkillDetail extends SkillDetailBase {
+  origin: "clawhub";
+  slug: string;
+  author: string;
+  stars: number;
+  installs: number;
+  reports: number;
+  publishedAt?: string;
+  // Enrichment fields (from clawhubInspect):
+  owner?: { handle: string; displayName: string; image?: string } | null;
+  stats?: {
+    stars: number;
+    installs: number;
+    downloads: number;
+    versions: number;
+  } | null;
+  latestVersion?: { version: string; changelog?: string } | null;
+  createdAt?: number | null;
+  updatedAt?: number | null;
+}
+
+interface SkillsshSkillDetail extends SkillDetailBase {
+  origin: "skillssh";
+  slug: string;
+  sourceRepo: string;
+  installs: number;
+}
+
+interface CustomSkillDetail extends SkillDetailBase {
+  origin: "custom";
+}
+
+export type SkillDetailResponse =
+  | VellumSkillDetail
+  | ClawhubSkillDetail
+  | SkillsshSkillDetail
+  | CustomSkillDetail;
+
 export interface SkillsDraftResponse {
   type: "skills_draft_response";
   success: boolean;
@@ -181,8 +243,7 @@ export type _SkillsClientMessages =
 
 export type _SkillsServerMessages =
   | SkillsListResponse
-  | SkillDetailResponse
+  | SkillBodyResponse
   | SkillStateChanged
-  | SkillsOperationResponse
   | SkillsInspectResponse
   | SkillsDraftResponse;

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

@@ -625,9 +625,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();

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";
@@ -222,18 +223,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 +264,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/heartbeat/heartbeat-service.ts

@@ -178,6 +178,7 @@ export class HeartbeatService {
       const conversation = bootstrapConversation({
         conversationType: "background",
         source: "heartbeat",
+        groupId: "system:background",
         origin: "heartbeat",
         systemHint: "Heartbeat",
       });

package/src/hooks/cli.ts

@@ -20,7 +20,7 @@ export function registerHooksCommand(program: Command): void {
 Hooks are user-installed scripts that run in response to assistant lifecycle
 events (e.g. tool invocations, message sends). Each hook is a directory
 containing a hook.json manifest and a script file. Hooks are stored in
-~/.vellum/hooks/ and must be explicitly enabled after installation.
+$VELLUM_WORKSPACE_DIR/hooks/ and must be explicitly enabled after installation.
 
 Examples:
   $ assistant hooks list
@@ -136,7 +136,7 @@ Arguments:
          The manifest must have name, script, description, version, and at
          least one valid event.
 
-Copies the hook directory into ~/.vellum/hooks/<name>/ and registers it as
+Copies the hook directory into $VELLUM_WORKSPACE_DIR/hooks/<name>/ and registers it as
 disabled by default. Run 'assistant hooks enable <name>' to activate.
 
 Examples:

package/src/hooks/runner.ts

@@ -1,42 +1,19 @@
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
-import { basename, extname, join } from "node:path";
+import { extname, join } from "node:path";
 
-import { pathExists } from "../util/fs.js";
+import { ensureBun } from "../util/bun-runtime.js";
 import { getWorkspaceDir } from "../util/platform.js";
 import { getHookSettings } from "./config.js";
 import type { DiscoveredHook, HookEventData } from "./types.js";
 
-/**
- * Resolve a usable bun runtime path. When the daemon runs under plain bun
- * (dev mode), `process.execPath` is the bun CLI and works directly.  When the
- * daemon is a `bun build --compile` binary, `process.execPath` points to the
- * compiled binary itself -- spawning it with `['run', script]` would re-launch
- * the daemon.  In that case we locate bun via PATH or at `~/.bun/bin/bun`.
- */
-function resolveBunPath(): string {
-  const execBasename = basename(process.execPath);
-  if (execBasename === "bun" || execBasename === "bun.exe") {
-    return process.execPath;
-  }
-
-  // Compiled-binary mode -- find a standalone bun runtime.
-  const found = Bun.which("bun");
-  if (found) return found;
-
-  const fallback = join(homedir(), ".bun", "bin", "bun");
-  if (pathExists(fallback)) return fallback;
-
-  throw new Error(
-    "Cannot find a bun runtime to execute .ts hooks. " +
-      "Install bun (https://bun.sh) or ensure it is on your PATH.",
-  );
-}
-
-function getSpawnArgs(scriptPath: string): { command: string; args: string[] } {
+async function getSpawnArgs(
+  scriptPath: string,
+): Promise<{ command: string; args: string[] }> {
   const ext = extname(scriptPath);
   if (ext === ".ts") {
-    return { command: resolveBunPath(), args: ["run", scriptPath] };
+    const bunPath = await ensureBun();
+    return { command: bunPath, args: ["run", scriptPath] };
   }
   return { command: scriptPath, args: [] };
 }
@@ -54,15 +31,15 @@ export async function runHookScript(
 ): Promise<HookRunResult> {
   const timeoutMs = options?.timeoutMs ?? 5000;
 
+  let spawnResult: { command: string; args: string[] };
+  try {
+    spawnResult = await getSpawnArgs(hook.scriptPath);
+  } catch (err) {
+    return { exitCode: null, stdout: "", stderr: (err as Error).message };
+  }
+  const { command, args } = spawnResult;
+
   return new Promise<HookRunResult>((resolve) => {
-    let spawnResult: { command: string; args: string[] };
-    try {
-      spawnResult = getSpawnArgs(hook.scriptPath);
-    } catch (err) {
-      resolve({ exitCode: null, stdout: "", stderr: (err as Error).message });
-      return;
-    }
-    const { command, args } = spawnResult;
     const child = spawn(command, args, {
       cwd: hook.dir,
       env: {

package/src/inbound/platform-callback-registration.ts

@@ -1,7 +1,7 @@
 /**
- * Platform callback route registration for containerized deployments.
+ * Platform callback route registration for platform-managed deployments.
  *
- * When the assistant daemon runs inside a container (IS_CONTAINERIZED=true)
+ * When the assistant daemon runs as a platform-managed instance (IS_PLATFORM=true)
  * with a configured VELLUM_PLATFORM_URL and PLATFORM_ASSISTANT_ID, external
  * service callbacks (Twilio webhooks, OAuth redirects, Telegram webhooks, etc.)
  * must route through the platform's gateway proxy instead of hitting the
@@ -9,7 +9,7 @@
  *
  * This module registers callback routes with the platform's internal
  * gateway endpoint so the platform knows how to forward inbound provider
- * webhooks to the correct containerized assistant instance.
+ * webhooks to the correct platform-managed assistant instance.
  *
  * The platform endpoint is:
  *   POST {VELLUM_PLATFORM_URL}/v1/internal/gateway/callback-routes/register/
@@ -23,7 +23,7 @@ import {
   getPlatformBaseUrl,
   getPlatformInternalApiKey,
 } from "../config/env.js";
-import { getIsContainerized } from "../config/env-registry.js";
+import { getIsPlatform } from "../config/env-registry.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
 import { getLogger } from "../util/logger.js";
@@ -31,7 +31,7 @@ import { getLogger } from "../util/logger.js";
 const log = getLogger("platform-callback-registration");
 
 export interface PlatformCallbackRegistrationContext {
-  containerized: boolean;
+  isPlatform: boolean;
   platformBaseUrl: string;
   assistantId: string;
   hasInternalApiKey: boolean;
@@ -42,21 +42,21 @@ export interface PlatformCallbackRegistrationContext {
 
 /**
  * Whether the daemon should register callback routes with the platform.
- * True when IS_CONTAINERIZED, VELLUM_PLATFORM_URL, and PLATFORM_ASSISTANT_ID
+ * True when IS_PLATFORM, VELLUM_PLATFORM_URL, and PLATFORM_ASSISTANT_ID
  * are all set. Intentionally does **not** require the managed proxy API key
  * so that callback-only flows (OAuth transport, Telegram/Twilio callback
  * registration) work during partial bootstrap before the key is injected.
  */
 export function shouldUsePlatformCallbacks(): boolean {
   return (
-    getIsContainerized() &&
+    getIsPlatform() &&
     !!getPlatformBaseUrl() &&
     !!getPlatformAssistantId()
   );
 }
 
 export async function resolvePlatformCallbackRegistrationContext(): Promise<PlatformCallbackRegistrationContext> {
-  const containerized = getIsContainerized();
+  const platform = getIsPlatform();
   const [storedBaseUrlRaw, storedAssistantIdRaw, storedAssistantApiKeyRaw] =
     await Promise.all([
       getSecureKeyAsync(credentialKey("vellum", "platform_base_url")),
@@ -80,14 +80,14 @@ export async function resolvePlatformCallbackRegistrationContext(): Promise<Plat
       : null;
 
   return {
-    containerized,
+    isPlatform: platform,
     platformBaseUrl,
     assistantId,
     hasInternalApiKey: internalApiKey.length > 0,
     hasAssistantApiKey: assistantApiKey.length > 0,
     authHeader,
     enabled:
-      containerized &&
+      platform &&
       platformBaseUrl.length > 0 &&
       assistantId.length > 0 &&
       authHeader !== null,
@@ -119,7 +119,7 @@ export async function registerCallbackRoute(
   const context = await resolvePlatformCallbackRegistrationContext();
   if (!context.enabled || !context.authHeader) {
     throw new Error(
-      "Platform callbacks not available — missing containerized platform registration context",
+      "Platform callbacks not available — missing platform registration context",
     );
   }
 
@@ -166,7 +166,7 @@ export async function registerCallbackRoute(
 }
 
 /**
- * Resolve a callback URL, registering with the platform when containerized.
+ * Resolve a callback URL, registering with the platform when platform-managed.
  *
  * When platform callbacks are enabled, registers the route and returns the
  * platform's stable callback URL (optionally with query parameters appended).
@@ -176,7 +176,7 @@ export async function registerCallbackRoute(
  * string) rather than an eagerly-evaluated string. This is critical because
  * the direct URL builders (e.g. `getTwilioVoiceWebhookUrl`) call
  * `getPublicBaseUrl()` which throws when no public ingress URL is configured.
- * In containerized environments that rely solely on platform callbacks, the
+ * In platform-managed environments that rely solely on platform callbacks, the
  * direct URL is never needed — deferring evaluation avoids the throw.
  *
  * @param directUrl - Lazy supplier for the direct callback URL.
@@ -204,7 +204,7 @@ export async function resolveCallbackUrl(
     }
     return url;
   } catch (err) {
-    // In managed/containerized mode there is no local-ingress fallback and
+    // In platform-managed mode there is no local-ingress fallback and
     // ngrok is not applicable. Surface a clear error so callers (and the
     // user) understand this is a platform-side issue, not a tunnel problem.
     const detail = err instanceof Error ? err.message : String(err);