vellum 0.2.1 → 0.2.2

package/src/tools/followups/followup_list.ts

@@ -1,6 +1,4 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { listFollowUps, getOverdueFollowUps } from '../../followups/followup-store.js';
 import type { FollowUp, FollowUpStatus } from '../../followups/types.js';
 
@@ -18,83 +16,45 @@ function formatFollowUpSummary(f: FollowUp): string {
   return parts.join('\n');
 }
 
-const definition: ToolDefinition = {
-  name: 'followup_list',
-  description: 'List follow-ups with optional filters by status, channel, or contact. Can also show only overdue follow-ups.',
-  input_schema: {
-    type: 'object',
-    properties: {
-      status: {
-        type: 'string',
-        enum: [...VALID_STATUSES],
-        description: 'Filter by status (pending, resolved, overdue, nudged)',
-      },
-      channel: {
-        type: 'string',
-        description: 'Filter by communication channel (e.g. email, slack)',
-      },
-      contact_id: {
-        type: 'string',
-        description: 'Filter by contact ID',
-      },
-      overdue_only: {
-        type: 'boolean',
-        description: 'When true, return only pending follow-ups past their expected response deadline',
-      },
-    },
-    required: [],
-  },
-};
-
-class FollowUpListTool implements Tool {
-  name = 'followup_list';
-  description = definition.description;
-  category = 'followups';
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return definition;
+export async function executeFollowupList(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const status = input.status as FollowUpStatus | undefined;
+  const channel = input.channel as string | undefined;
+  const contactId = input.contact_id as string | undefined;
+  const overdueOnly = input.overdue_only as boolean | undefined;
+
+  if (status && !VALID_STATUSES.includes(status as typeof VALID_STATUSES[number])) {
+    return {
+      content: `Error: Invalid status "${status}". Must be one of: ${VALID_STATUSES.join(', ')}`,
+      isError: true,
+    };
   }
 
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const status = input.status as FollowUpStatus | undefined;
-    const channel = input.channel as string | undefined;
-    const contactId = input.contact_id as string | undefined;
-    const overdueOnly = input.overdue_only as boolean | undefined;
+  try {
+    let results: FollowUp[];
 
-    if (status && !VALID_STATUSES.includes(status as typeof VALID_STATUSES[number])) {
-      return {
-        content: `Error: Invalid status "${status}". Must be one of: ${VALID_STATUSES.join(', ')}`,
-        isError: true,
-      };
+    if (overdueOnly || status === 'overdue') {
+      results = getOverdueFollowUps();
+      if (channel) results = results.filter((f) => f.channel === channel);
+      if (contactId) results = results.filter((f) => f.contactId === contactId);
+    } else {
+      results = listFollowUps({ status, channel, contactId });
     }
 
-    try {
-      let results: FollowUp[];
-
-      if (overdueOnly || status === 'overdue') {
-        results = getOverdueFollowUps();
-        if (channel) results = results.filter((f) => f.channel === channel);
-        if (contactId) results = results.filter((f) => f.contactId === contactId);
-      } else {
-        results = listFollowUps({ status, channel, contactId });
-      }
-
-      if (results.length === 0) {
-        return { content: 'No follow-ups found matching the criteria.', isError: false };
-      }
-
-      const lines = [`Found ${results.length} follow-up(s):\n`];
-      for (const followUp of results) {
-        lines.push(formatFollowUpSummary(followUp));
-      }
+    if (results.length === 0) {
+      return { content: 'No follow-ups found matching the criteria.', isError: false };
+    }
 
-      return { content: lines.join('\n'), isError: false };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { content: `Error: ${msg}`, isError: true };
+    const lines = [`Found ${results.length} follow-up(s):\n`];
+    for (const followUp of results) {
+      lines.push(formatFollowUpSummary(followUp));
     }
+
+    return { content: lines.join('\n'), isError: false };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: `Error: ${msg}`, isError: true };
   }
 }
-
-export const followupListTool = new FollowUpListTool();

package/src/tools/followups/followup_resolve.ts

@@ -1,6 +1,4 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { resolveFollowUp, resolveByThread } from '../../followups/followup-store.js';
 import type { FollowUp } from '../../followups/types.js';
 
@@ -15,77 +13,44 @@ function formatFollowUp(f: FollowUp): string {
   return lines.join('\n');
 }
 
-const definition: ToolDefinition = {
-  name: 'followup_resolve',
-  description: 'Manually resolve a follow-up by ID, or auto-resolve by channel + thread ID when a response is received.',
-  input_schema: {
-    type: 'object',
-    properties: {
-      id: {
-        type: 'string',
-        description: 'Follow-up ID to resolve directly',
-      },
-      channel: {
-        type: 'string',
-        description: 'Channel to match (used with thread_id for auto-resolution)',
-      },
-      thread_id: {
-        type: 'string',
-        description: 'Thread ID to match (used with channel for auto-resolution)',
-      },
-    },
-    required: [],
-  },
-};
-
-class FollowUpResolveTool implements Tool {
-  name = 'followup_resolve';
-  description = definition.description;
-  category = 'followups';
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return definition;
+export async function executeFollowupResolve(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const id = input.id as string | undefined;
+  const channel = input.channel as string | undefined;
+  const threadId = input.thread_id as string | undefined;
+
+  if (!id && !(channel && threadId)) {
+    return {
+      content: 'Error: Either id or both channel and thread_id are required',
+      isError: true,
+    };
   }
 
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const id = input.id as string | undefined;
-    const channel = input.channel as string | undefined;
-    const threadId = input.thread_id as string | undefined;
-
-    if (!id && !(channel && threadId)) {
+  try {
+    if (id) {
+      const followUp = resolveFollowUp(id);
       return {
-        content: 'Error: Either id or both channel and thread_id are required',
-        isError: true,
+        content: `Resolved follow-up:\n${formatFollowUp(followUp)}`,
+        isError: false,
       };
-    }
-
-    try {
-      if (id) {
-        const followUp = resolveFollowUp(id);
+    } else {
+      const resolved = resolveByThread(channel!, threadId!);
+      if (resolved.length === 0) {
         return {
-          content: `Resolved follow-up:\n${formatFollowUp(followUp)}`,
-          isError: false,
-        };
-      } else {
-        const resolved = resolveByThread(channel!, threadId!);
-        if (resolved.length === 0) {
-          return {
-            content: `No pending follow-up found for channel="${channel}" thread="${threadId}"`,
-            isError: false,
-          };
-        }
-        const summaries = resolved.map(formatFollowUp).join('\n\n');
-        return {
-          content: `Resolved ${resolved.length} follow-up(s):\n${summaries}`,
+          content: `No pending follow-up found for channel="${channel}" thread="${threadId}"`,
           isError: false,
         };
       }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { content: `Error: ${msg}`, isError: true };
+      const summaries = resolved.map(formatFollowUp).join('\n\n');
+      return {
+        content: `Resolved ${resolved.length} follow-up(s):\n${summaries}`,
+        isError: false,
+      };
     }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: `Error: ${msg}`, isError: true };
   }
 }
-
-export const followupResolveTool = new FollowUpResolveTool();

package/src/tools/host-terminal/cli-discover.ts

@@ -3,6 +3,7 @@ import { RiskLevel } from '../../permissions/types.js';
 import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
 import type { ToolDefinition } from '../../providers/types.js';
 import { getLogger } from '../../util/logger.js';
+import { truncate } from '../../util/truncate.js';
 
 const log = getLogger('cli-discover');
 
@@ -141,7 +142,7 @@ class CliDiscoverTool implements Tool {
         result.authenticated = authOutput !== null && authOutput.length > 0;
         if (authOutput) {
           // Keep auth info brief — first line, max 200 chars
-          result.authInfo = authOutput.split('\n')[0].slice(0, 200);
+          result.authInfo = truncate(authOutput.split('\n')[0], 200, '');
         }
       }
 

package/src/tools/host-terminal/host-shell.ts

@@ -40,6 +40,16 @@ function buildSanitizedEnv(): Record<string, string> {
       env[key] = process.env[key]!;
     }
   }
+  // Ensure ~/.local/bin and ~/.bun/bin are in PATH so `vellum` and `bun` are
+  // always reachable, even when the daemon is launched from a macOS app
+  // bundle that inherits a minimal PATH.
+  const home = homedir();
+  const extraDirs = [`${home}/.local/bin`, `${home}/.bun/bin`];
+  const currentPath = env.PATH ?? '';
+  const missing = extraDirs.filter(d => !currentPath.split(':').includes(d));
+  if (missing.length > 0) {
+    env.PATH = [...missing, currentPath].filter(Boolean).join(':');
+  }
   return env;
 }
 

package/src/tools/memory/handlers.ts

@@ -2,6 +2,7 @@ import { and, eq } from 'drizzle-orm';
 import { v4 as uuid } from 'uuid';
 import type { AssistantConfig } from '../../config/types.js';
 import { getLogger } from '../../util/logger.js';
+import { truncate } from '../../util/truncate.js';
 import { getDb } from '../../memory/db.js';
 import { computeMemoryFingerprint } from '../../memory/fingerprint.js';
 import { memoryItems } from '../../memory/schema.js';
@@ -84,14 +85,14 @@ export async function handleMemorySave(
   }
 
   const subject = typeof args.subject === 'string' && args.subject.trim().length > 0
-    ? args.subject.trim().slice(0, 80)
+    ? truncate(args.subject.trim(), 80, '')
     : inferSubjectFromStatement(statement.trim());
 
   try {
     const db = getDb();
     const id = uuid();
     const now = Date.now();
-    const trimmedStatement = statement.trim().slice(0, 500);
+    const trimmedStatement = truncate(statement.trim(), 500, '');
 
     const fingerprint = computeMemoryFingerprint(scopeId, kind, subject, trimmedStatement);
 
@@ -185,7 +186,7 @@ export async function handleMemoryUpdate(
     }
 
     const now = Date.now();
-    const trimmedStatement = statement.trim().slice(0, 500);
+    const trimmedStatement = truncate(statement.trim(), 500, '');
 
     const fingerprint = computeMemoryFingerprint(scopeId, existing.kind, existing.subject, trimmedStatement);
 
@@ -232,7 +233,7 @@ export async function handleMemoryUpdate(
 function inferSubjectFromStatement(statement: string): string {
   // Take first few words as a subject label
   const words = statement.split(/\s+/).slice(0, 6).join(' ');
-  return words.slice(0, 80);
+  return truncate(words, 80, '');
 }
 
 /**