vellum 0.2.1 → 0.2.2

package/src/config/bundled-skills/watcher/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: "Watcher"
+description: "Polling watcher system for monitoring external sources"
+metadata: {"vellum": {"emoji": "👀"}}
+---
+
+Create and manage watchers that poll external services for events and process them with an action prompt.
+
+## Concepts
+
+- **Provider** — The external service to poll (e.g. "gmail"). Each provider defines how to fetch and parse events.
+- **Action prompt** — LLM instructions for handling detected events. Sent along with event data to a background conversation.
+- **Poll interval** — How often to check for new events (minimum 15 seconds, default 60 seconds).
+- **Digest** — Summary of recent watcher activity, grouped by watcher with time-based filtering.
+
+## Lifecycle
+
+1. Create a watcher with a name, provider, and action prompt.
+2. The system polls the provider at the configured interval.
+3. Detected events are processed according to the action prompt.
+4. Use `watcher_digest` to review recent activity.
+
+## Usage Notes
+
+- Use `watcher_create` when the user wants to monitor an external source (e.g. "watch my Gmail for important emails").
+- `watcher_digest` is the go-to tool when the user asks "what happened with my email?" or similar questions about watcher activity.
+- Watchers can be enabled/disabled via `watcher_update` without deleting them.

package/src/config/bundled-skills/watcher/TOOLS.json

@@ -0,0 +1,147 @@
+{
+  "version": 1,
+  "tools": [
+    {
+      "name": "watcher_create",
+      "description": "Create a new watcher that polls an external service for events and processes them with an action prompt",
+      "category": "watcher",
+      "risk": "medium",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "A human-readable name for this watcher (e.g. \"My Gmail\")"
+          },
+          "provider": {
+            "type": "string",
+            "description": "The provider to poll (e.g. \"gmail\")"
+          },
+          "action_prompt": {
+            "type": "string",
+            "description": "Instructions for the LLM on how to handle detected events. This prompt is sent along with event data to a background conversation."
+          },
+          "poll_interval_ms": {
+            "type": "number",
+            "description": "How often to poll in milliseconds. Defaults to 60000 (1 minute). Minimum 15000."
+          },
+          "credential_service": {
+            "type": "string",
+            "description": "Override the credential service to use. Defaults to the provider's required service."
+          },
+          "config": {
+            "type": "object",
+            "description": "Provider-specific configuration (e.g. filter criteria)"
+          }
+        },
+        "required": ["name", "provider", "action_prompt"]
+      },
+      "executor": "tools/watcher-create.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "watcher_list",
+      "description": "List all watchers with their status, or show details for a specific watcher",
+      "category": "watcher",
+      "risk": "low",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "watcher_id": {
+            "type": "string",
+            "description": "If provided, show detailed info for this specific watcher including recent events."
+          },
+          "enabled_only": {
+            "type": "boolean",
+            "description": "When true, only show enabled watchers. Defaults to false."
+          }
+        },
+        "required": []
+      },
+      "executor": "tools/watcher-list.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "watcher_update",
+      "description": "Update a watcher's configuration (name, action prompt, interval, enabled state)",
+      "category": "watcher",
+      "risk": "medium",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "watcher_id": {
+            "type": "string",
+            "description": "The ID of the watcher to update"
+          },
+          "name": {
+            "type": "string",
+            "description": "New name for the watcher"
+          },
+          "action_prompt": {
+            "type": "string",
+            "description": "New action prompt for event processing"
+          },
+          "poll_interval_ms": {
+            "type": "number",
+            "description": "New poll interval in milliseconds (minimum 15000)"
+          },
+          "enabled": {
+            "type": "boolean",
+            "description": "Enable or disable the watcher"
+          },
+          "config": {
+            "type": "object",
+            "description": "New provider-specific configuration"
+          }
+        },
+        "required": ["watcher_id"]
+      },
+      "executor": "tools/watcher-update.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "watcher_delete",
+      "description": "Delete a watcher and all its event history",
+      "category": "watcher",
+      "risk": "medium",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "watcher_id": {
+            "type": "string",
+            "description": "The ID of the watcher to delete"
+          }
+        },
+        "required": ["watcher_id"]
+      },
+      "executor": "tools/watcher-delete.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "watcher_digest",
+      "description": "Get a summary of recent watcher activity. Use this when the user asks about what happened with their email, notifications, etc.",
+      "category": "watcher",
+      "risk": "low",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "watcher_id": {
+            "type": "string",
+            "description": "Filter to events from a specific watcher. If omitted, shows events from all watchers."
+          },
+          "hours": {
+            "type": "number",
+            "description": "How many hours back to look. Defaults to 24."
+          },
+          "limit": {
+            "type": "number",
+            "description": "Maximum number of events to return. Defaults to 50."
+          }
+        },
+        "required": []
+      },
+      "executor": "tools/watcher-digest.ts",
+      "execution_target": "host"
+    }
+  ]
+}

package/src/config/bundled-skills/watcher/tools/watcher-create.ts

@@ -0,0 +1,9 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { executeWatcherCreate } from '../../../../tools/watcher/create.js';
+
+export async function run(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  return executeWatcherCreate(input, context);
+}

package/src/config/bundled-skills/watcher/tools/watcher-delete.ts

@@ -0,0 +1,9 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { executeWatcherDelete } from '../../../../tools/watcher/delete.js';
+
+export async function run(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  return executeWatcherDelete(input, context);
+}

package/src/config/bundled-skills/watcher/tools/watcher-digest.ts

@@ -0,0 +1,9 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { executeWatcherDigest } from '../../../../tools/watcher/digest.js';
+
+export async function run(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  return executeWatcherDigest(input, context);
+}

package/src/config/bundled-skills/watcher/tools/watcher-list.ts

@@ -0,0 +1,9 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { executeWatcherList } from '../../../../tools/watcher/list.js';
+
+export async function run(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  return executeWatcherList(input, context);
+}

package/src/config/bundled-skills/watcher/tools/watcher-update.ts

@@ -0,0 +1,9 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { executeWatcherUpdate } from '../../../../tools/watcher/update.js';
+
+export async function run(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  return executeWatcherUpdate(input, context);
+}

package/src/config/defaults.ts

@@ -169,6 +169,10 @@ export const DEFAULT_CONFIG: AssistantConfig = {
     retentionDays: 30,
   },
   pricingOverrides: [],
+  agentHeartbeat: {
+    enabled: false,
+    intervalMs: 3_600_000,
+  },
   swarm: {
     enabled: true,
     maxWorkers: 3,
@@ -193,5 +197,34 @@ export const DEFAULT_CONFIG: AssistantConfig = {
     enrichmentConcurrency: 1,
     enrichmentJobTimeoutMs: 30000,
     enrichmentMaxRetries: 2,
+    commitMessageLLM: {
+      enabled: false,
+      useConfiguredProvider: true,
+      providerFastModelOverrides: {},
+      timeoutMs: 600,
+      maxTokens: 120,
+      temperature: 0.2,
+      maxFilesInPrompt: 30,
+      maxDiffBytes: 12000,
+      minRemainingTurnBudgetMs: 1000,
+      breaker: {
+        openAfterFailures: 3,
+        backoffBaseMs: 2000,
+        backoffMaxMs: 60000,
+      },
+    },
+  },
+  calls: {
+    enabled: true,
+    provider: 'twilio' as const,
+    maxDurationSeconds: 3600,
+    userConsultTimeoutSeconds: 120,
+    disclosure: {
+      enabled: true,
+      text: 'At the very beginning of the call, disclose that you are an AI assistant calling on behalf of the user.',
+    },
+    safety: {
+      denyCategories: [],
+    },
   },
 };

package/src/config/loader.ts

@@ -10,7 +10,7 @@ import type { AssistantConfig } from './types.js';
 const log = getLogger('config');
 
 // Providers that store API keys in secure storage (superset of VALID_PROVIDERS)
-export const API_KEY_PROVIDERS = ['anthropic', 'openai', 'gemini', 'ollama', 'fireworks', 'brave', 'perplexity'] as const;
+export const API_KEY_PROVIDERS = ['anthropic', 'openai', 'gemini', 'ollama', 'fireworks', 'openrouter', 'brave', 'perplexity'] as const;
 
 let cached: AssistantConfig | null = null;
 let loading = false;
@@ -198,6 +198,9 @@ export function loadConfig(): AssistantConfig {
     if (process.env.FIREWORKS_API_KEY) {
       config.apiKeys.fireworks = process.env.FIREWORKS_API_KEY;
     }
+    if (process.env.OPENROUTER_API_KEY) {
+      config.apiKeys.openrouter = process.env.OPENROUTER_API_KEY;
+    }
     if (process.env.BRAVE_API_KEY) {
       config.apiKeys.brave = process.env.BRAVE_API_KEY;
     }

package/src/config/schema.ts

@@ -1,13 +1,14 @@
 import { z } from 'zod';
 import { getDataDir } from '../util/platform.js';
 
-const VALID_PROVIDERS = ['anthropic', 'openai', 'gemini', 'ollama', 'fireworks'] as const;
+const VALID_PROVIDERS = ['anthropic', 'openai', 'gemini', 'ollama', 'fireworks', 'openrouter'] as const;
 const VALID_WEB_SEARCH_PROVIDERS = ['perplexity', 'brave', 'anthropic-native'] as const;
 const VALID_SECRET_ACTIONS = ['redact', 'warn', 'block', 'prompt'] as const;
 const VALID_MEMORY_EMBEDDING_PROVIDERS = ['auto', 'local', 'openai', 'gemini', 'ollama'] as const;
 const VALID_SANDBOX_BACKENDS = ['native', 'docker'] as const;
 const VALID_DOCKER_NETWORKS = ['none', 'bridge'] as const;
 const VALID_PERMISSIONS_MODES = ['legacy', 'strict'] as const;
+const VALID_CALL_PROVIDERS = ['twilio'] as const;
 
 export const TimeoutConfigSchema = z.object({
   shellMaxTimeoutSec: z
@@ -744,6 +745,83 @@ export const WorkspaceGitConfigSchema = z.object({
     .int('workspaceGit.enrichmentMaxRetries must be an integer')
     .nonnegative('workspaceGit.enrichmentMaxRetries must be non-negative')
     .default(2),
+  commitMessageLLM: z.object({
+    enabled: z.boolean({ error: 'workspaceGit.commitMessageLLM.enabled must be a boolean' }).default(false),
+    useConfiguredProvider: z.boolean({ error: 'workspaceGit.commitMessageLLM.useConfiguredProvider must be a boolean' }).default(true),
+    providerFastModelOverrides: z.record(z.string(), z.string()).default({}),
+    timeoutMs: z.number({ error: 'workspaceGit.commitMessageLLM.timeoutMs must be a number' })
+      .int('workspaceGit.commitMessageLLM.timeoutMs must be an integer')
+      .positive('workspaceGit.commitMessageLLM.timeoutMs must be a positive integer')
+      .default(600),
+    maxTokens: z.number({ error: 'workspaceGit.commitMessageLLM.maxTokens must be a number' })
+      .int('workspaceGit.commitMessageLLM.maxTokens must be an integer')
+      .positive('workspaceGit.commitMessageLLM.maxTokens must be a positive integer')
+      .default(120),
+    temperature: z.number({ error: 'workspaceGit.commitMessageLLM.temperature must be a number' })
+      .min(0, 'workspaceGit.commitMessageLLM.temperature must be >= 0')
+      .max(2, 'workspaceGit.commitMessageLLM.temperature must be <= 2')
+      .default(0.2),
+    maxFilesInPrompt: z.number({ error: 'workspaceGit.commitMessageLLM.maxFilesInPrompt must be a number' })
+      .int('workspaceGit.commitMessageLLM.maxFilesInPrompt must be an integer')
+      .positive('workspaceGit.commitMessageLLM.maxFilesInPrompt must be a positive integer')
+      .default(30),
+    maxDiffBytes: z.number({ error: 'workspaceGit.commitMessageLLM.maxDiffBytes must be a number' })
+      .int('workspaceGit.commitMessageLLM.maxDiffBytes must be an integer')
+      .positive('workspaceGit.commitMessageLLM.maxDiffBytes must be a positive integer')
+      .default(12000),
+    minRemainingTurnBudgetMs: z.number({ error: 'workspaceGit.commitMessageLLM.minRemainingTurnBudgetMs must be a number' })
+      .int('workspaceGit.commitMessageLLM.minRemainingTurnBudgetMs must be an integer')
+      .nonnegative('workspaceGit.commitMessageLLM.minRemainingTurnBudgetMs must be non-negative')
+      .default(1000),
+    breaker: z.object({
+      openAfterFailures: z.number({ error: 'workspaceGit.commitMessageLLM.breaker.openAfterFailures must be a number' })
+        .int().positive().default(3),
+      backoffBaseMs: z.number({ error: 'workspaceGit.commitMessageLLM.breaker.backoffBaseMs must be a number' })
+        .int().positive().default(2000),
+      backoffMaxMs: z.number({ error: 'workspaceGit.commitMessageLLM.breaker.backoffMaxMs must be a number' })
+        .int().positive().default(60000),
+    }).default({}),
+  }).default({}),
+});
+
+export const AgentHeartbeatConfigSchema = z.object({
+  enabled: z
+    .boolean({ error: 'agentHeartbeat.enabled must be a boolean' })
+    .default(false),
+  intervalMs: z
+    .number({ error: 'agentHeartbeat.intervalMs must be a number' })
+    .int('agentHeartbeat.intervalMs must be an integer')
+    .positive('agentHeartbeat.intervalMs must be a positive integer')
+    .default(3_600_000),
+  activeHoursStart: z
+    .number({ error: 'agentHeartbeat.activeHoursStart must be a number' })
+    .int('agentHeartbeat.activeHoursStart must be an integer')
+    .min(0, 'agentHeartbeat.activeHoursStart must be >= 0')
+    .max(23, 'agentHeartbeat.activeHoursStart must be <= 23')
+    .optional(),
+  activeHoursEnd: z
+    .number({ error: 'agentHeartbeat.activeHoursEnd must be a number' })
+    .int('agentHeartbeat.activeHoursEnd must be an integer')
+    .min(0, 'agentHeartbeat.activeHoursEnd must be >= 0')
+    .max(23, 'agentHeartbeat.activeHoursEnd must be <= 23')
+    .optional(),
+}).superRefine((config, ctx) => {
+  const hasStart = config.activeHoursStart != null;
+  const hasEnd = config.activeHoursEnd != null;
+  if (hasStart !== hasEnd) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: [hasStart ? 'activeHoursEnd' : 'activeHoursStart'],
+      message: 'agentHeartbeat.activeHoursStart and agentHeartbeat.activeHoursEnd must both be set or both be omitted',
+    });
+  }
+  if (hasStart && hasEnd && config.activeHoursStart === config.activeHoursEnd) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['activeHoursEnd'],
+      message: 'agentHeartbeat.activeHoursStart and agentHeartbeat.activeHoursEnd must not be equal (would create an empty window)',
+    });
+  }
 });
 
 export const SwarmConfigSchema = z.object({
@@ -781,6 +859,51 @@ export const SwarmConfigSchema = z.object({
     .default('claude-sonnet-4-6'),
 });
 
+export const CallsDisclosureConfigSchema = z.object({
+  enabled: z
+    .boolean({ error: 'calls.disclosure.enabled must be a boolean' })
+    .default(true),
+  text: z
+    .string({ error: 'calls.disclosure.text must be a string' })
+    .default('At the very beginning of the call, disclose that you are an AI assistant calling on behalf of the user.'),
+});
+
+export const CallsSafetyConfigSchema = z.object({
+  denyCategories: z
+    .array(z.string({ error: 'calls.safety.denyCategories values must be strings' }))
+    .default([]),
+});
+
+export const CallsConfigSchema = z.object({
+  enabled: z
+    .boolean({ error: 'calls.enabled must be a boolean' })
+    .default(true),
+  provider: z
+    .enum(VALID_CALL_PROVIDERS, {
+      error: `calls.provider must be one of: ${VALID_CALL_PROVIDERS.join(', ')}`,
+    })
+    .default('twilio'),
+  maxDurationSeconds: z
+    .number({ error: 'calls.maxDurationSeconds must be a number' })
+    .int('calls.maxDurationSeconds must be an integer')
+    .positive('calls.maxDurationSeconds must be a positive integer')
+    .max(2_147_483, 'calls.maxDurationSeconds must be at most 2147483 (setTimeout-safe limit)')
+    .default(3600),
+  userConsultTimeoutSeconds: z
+    .number({ error: 'calls.userConsultTimeoutSeconds must be a number' })
+    .int('calls.userConsultTimeoutSeconds must be an integer')
+    .positive('calls.userConsultTimeoutSeconds must be a positive integer')
+    .max(2_147_483, 'calls.userConsultTimeoutSeconds must be at most 2147483 (setTimeout-safe limit)')
+    .default(120),
+  disclosure: CallsDisclosureConfigSchema.default({
+    enabled: true,
+    text: 'At the very beginning of the call, disclose that you are an AI assistant calling on behalf of the user.',
+  }),
+  safety: CallsSafetyConfigSchema.default({
+    denyCategories: [],
+  }),
+});
+
 export const SkillsConfigSchema = z.object({
   entries: z.record(z.string(), SkillEntryConfigSchema).default({}),
   load: SkillsLoadConfigSchema.default({ extraDirs: [], watch: true, watchDebounceMs: 250 }),
@@ -978,6 +1101,10 @@ export const AssistantConfigSchema = z.object({
   pricingOverrides: z
     .array(ModelPricingOverrideSchema)
     .default([]),
+  agentHeartbeat: AgentHeartbeatConfigSchema.default({
+    enabled: false,
+    intervalMs: 3_600_000,
+  }),
   swarm: SwarmConfigSchema.default({
     enabled: true,
     maxWorkers: 3,
@@ -1002,6 +1129,35 @@ export const AssistantConfigSchema = z.object({
     enrichmentConcurrency: 1,
     enrichmentJobTimeoutMs: 30000,
     enrichmentMaxRetries: 2,
+    commitMessageLLM: {
+      enabled: false,
+      useConfiguredProvider: true,
+      providerFastModelOverrides: {},
+      timeoutMs: 600,
+      maxTokens: 120,
+      temperature: 0.2,
+      maxFilesInPrompt: 30,
+      maxDiffBytes: 12000,
+      minRemainingTurnBudgetMs: 1000,
+      breaker: {
+        openAfterFailures: 3,
+        backoffBaseMs: 2000,
+        backoffMaxMs: 60000,
+      },
+    },
+  }),
+  calls: CallsConfigSchema.default({
+    enabled: true,
+    provider: 'twilio',
+    maxDurationSeconds: 3600,
+    userConsultTimeoutSeconds: 120,
+    disclosure: {
+      enabled: true,
+      text: 'At the very beginning of the call, disclose that you are an AI assistant calling on behalf of the user.',
+    },
+    safety: {
+      denyCategories: [],
+    },
   }),
 }).superRefine((config, ctx) => {
   if (config.contextWindow.targetInputTokens >= config.contextWindow.maxInputTokens) {
@@ -1056,6 +1212,10 @@ export type ModelPricingOverride = z.infer<typeof ModelPricingOverrideSchema>;
 export type SkillEntryConfig = z.infer<typeof SkillEntryConfigSchema>;
 export type SkillsLoadConfig = z.infer<typeof SkillsLoadConfigSchema>;
 export type SkillsInstallConfig = z.infer<typeof SkillsInstallConfigSchema>;
+export type AgentHeartbeatConfig = z.infer<typeof AgentHeartbeatConfigSchema>;
 export type SwarmConfig = z.infer<typeof SwarmConfigSchema>;
 export type SkillsConfig = z.infer<typeof SkillsConfigSchema>;
 export type WorkspaceGitConfig = z.infer<typeof WorkspaceGitConfigSchema>;
+export type CallsConfig = z.infer<typeof CallsConfigSchema>;
+export type CallsDisclosureConfig = z.infer<typeof CallsDisclosureConfigSchema>;
+export type CallsSafetyConfig = z.infer<typeof CallsSafetyConfigSchema>;

package/src/config/system-prompt.ts

@@ -221,21 +221,35 @@ function buildTaskScheduleReminderRoutingSection(): string {
     '**IMPORTANT:** When you call `task_list_show`, the Tasks window opens automatically on the client. Do NOT also create a separate surface/UI (via `ui_show` or `app_create`) to display the task queue. Doing so causes duplicate Task Queue windows. Just call `task_list_show` and let the native window handle the presentation.',
     '',
     '### Schedules (schedule_create / schedule_list / schedule_update / schedule_delete)',
-    'For recurring automated jobs that run on a cron schedule. Use ONLY when the user explicitly wants:',
+    'For recurring automated jobs that run on a recurrence schedule (cron or RRULE). Use ONLY when the user explicitly wants:',
     '- Recurring automation: "every day at 9am", "weekly on Mondays", "every hour"',
+    '- Complex recurrence patterns: "every other Tuesday", "last weekday of the month" (use RRULE)',
+    '- Bounded recurrence: "every day for 30 days", "weekly until March" (RRULE with COUNT or UNTIL)',
     '- Periodic background tasks: "check my email every morning", "run this report weekly"',
     '',
-    '### Reminders (reminder)',
+    '#### RRULE Set Constructs',
+    'When building RRULE expressions, these set lines are supported:',
+    '- **RRULE** — one or more recurrence rules (multiple RRULE lines form a union of occurrences)',
+    '- **RDATE** — add one-off dates that are not covered by the RRULE pattern',
+    '- **EXDATE** — exclude specific dates from the recurrence set',
+    '- **EXRULE** — exclude an entire series of dates defined by a recurrence pattern',
+    '',
+    'Exclusions (EXDATE, EXRULE) take precedence over inclusions (RRULE, RDATE). All RRULE expressions must include a DTSTART line and at least one RRULE or RDATE inclusion.',
+    '',
+    '### Reminders (reminder_create / reminder_list / reminder_cancel)',
     'For one-time time-triggered notifications. Use ONLY when the user wants:',
     '- A notification at a specific future time: "remind me at 3pm", "remind me in 2 hours"',
     '- A timed alert, not a tracked task',
     '',
     '### Common mistakes to avoid',
-    '- "Add this to my tasks" → task_list_add (NOT schedule_create or reminder)',
+    '- "Add this to my tasks" → task_list_add (NOT schedule_create or reminder_create)',
     '- "What\'s on my task list?" → task_list_show (NOT schedule_list)',
     '- "Remind me to buy groceries" without a time → task_list_add (it\'s a task, not a timed reminder)',
-    '- "Remind me at 5pm to buy groceries" → reminder (explicit time trigger)',
-    '- "Check my inbox every morning at 8am" → schedule_create (recurring automation)',
+    '- "Remind me at 5pm to buy groceries" → reminder_create (explicit time trigger)',
+    '- "Check my inbox every morning at 8am" → schedule_create (recurring automation, cron)',
+    '- "Every other Tuesday at 10am" → schedule_create (recurring automation, RRULE)',
+    '- "Every weekday except holidays" → schedule_create (RRULE with EXDATE for exclusions)',
+    '- "Daily for the next 30 days" → schedule_create (RRULE with COUNT=30)',
     '- "Bump priority on X" → task_list_update (NOT task_list_add)',
     '- "Move this up" / "change this task priority" → task_list_update (NOT task_list_add)',
     '- "Mark X as done" → task_list_update (NOT task_list_add)',
@@ -308,7 +322,7 @@ function buildDynamicUiSection(): string {
     '- **Tool auto-emissions** (e.g. `get_weather`): handled automatically — do nothing extra',
     '- **Predefined domain data** (flights, stocks): `ui_show` with `surface_type: "dynamic_page"` and domain component classes',
     '- **Simple structured data** (key-value, table, list): `ui_show` with `card`/`table`/`list`/`form` surface_type',
-    '- **Multi-step tasks** (ordering food, booking, purchasing, multi-phase workflows): `ui_show` with `card` surface_type + `template: "task_progress"` (see below)',
+    '- **Multi-step tasks** (ordering food, booking, purchasing, multi-phase workflows): `ui_show` with `card` surface_type + `data.template: "task_progress"` (see below)',
     '- **Interactive apps only**: `app_create` (calculators, dashboards, tools - NOT text content)',
     '',
     '### Loading app tools',
@@ -413,19 +427,47 @@ function buildDynamicUiSection(): string {
     'Interactive surfaces provide a better user experience than asking your user to type their choice. Only fall back to plain text when the interaction is conversational or doesn\'t fit a structured format.',
     '',
     '### Task progress for multi-step workflows',
-    'When executing a multi-step task (ordering food, booking a flight, purchasing, research with multiple phases), show live progress using the `task_progress` card template:',
+    'When executing a multi-step task (booking a flight, purchasing, research with multiple phases), show live progress using the `task_progress` card template. Note: DoorDash ordering auto-emits a task_progress card on the first `vellum doordash` command (surface ID `doordash-progress`), so you only need `ui_update` for DoorDash flows.',
     '',
-    '1. **Before starting**, call `ui_show` with `surface_type: "card"`, `template: "task_progress"`, and `templateData`:',
+    '1. **Before starting**, call `ui_show` with `surface_type: "card"` and put `template: "task_progress"` inside `data`:',
     '   ```json',
-    '   { "title": "Ordering from DoorDash", "status": "in_progress", "steps": [',
-    '     { "label": "Search restaurants", "status": "in_progress" },',
-    '     { "label": "Browse menu", "status": "pending" },',
-    '     { "label": "Add to cart", "status": "pending" },',
-    '     { "label": "Place order", "status": "pending" }',
-    '   ] }',
+    '   {',
+    '     "surface_type": "card",',
+    '     "data": {',
+    '       "title": "Booking Flight",',
+    '       "body": "",',
+    '       "template": "task_progress",',
+    '       "templateData": {',
+    '         "title": "Booking Flight",',
+    '         "status": "in_progress",',
+    '         "steps": [',
+    '           { "label": "Search flights", "status": "in_progress" },',
+    '           { "label": "Compare options", "status": "pending" },',
+    '           { "label": "Select flight", "status": "pending" },',
+    '           { "label": "Complete booking", "status": "pending" }',
+    '         ]',
+    '       }',
+    '     }',
+    '   }',
     '   ```',
-    '2. **As each step completes**, call `ui_update` with the same surface ID to update step statuses and move to the next step. Add `detail` to completed steps (e.g. `"detail": "Found 3 nearby stores"`).',
-    '3. **On completion**, set the top-level `status` to `"completed"`. On failure, set it to `"failed"` and mark the failing step accordingly.',
+    '2. **As each step completes**, call `ui_update` with the same surface ID and patch `data.templateData` (not top-level `status`/`steps`):',
+    '   ```json',
+    '   {',
+    '     "surface_id": "<surface-id>",',
+    '     "data": {',
+    '       "templateData": {',
+    '         "status": "in_progress",',
+    '         "steps": [',
+    '           { "label": "Search flights", "status": "completed", "detail": "Found 12 options" },',
+    '           { "label": "Compare options", "status": "in_progress" },',
+    '           { "label": "Select flight", "status": "pending" },',
+    '           { "label": "Complete booking", "status": "pending" }',
+    '         ]',
+    '       }',
+    '     }',
+    '   }',
+    '   ```',
+    '3. **On completion**, set `data.templateData.status` to `"completed"`. On failure, set it to `"failed"` and mark the failing step accordingly.',
     '',
     'Use this for ANY multi-step workflow where the user benefits from seeing structured progress instead of just "Running a command...".',
   ].join('\n');
@@ -940,6 +982,9 @@ function buildDynamicSkillWorkflowSection(): string {
     '',
     '### Browser Skill Prerequisite',
     'If you need browser capabilities (navigating web pages, clicking elements, extracting content) and `browser_*` tools are not available, load the "browser" skill first using `skill_load`.',
+    '',
+    '### X (Twitter) Skill',
+    'When the user asks to post, reply, or interact with X/Twitter, load the "twitter" skill using `skill_load`. Do NOT use computer-use or the browser skill for X — the X skill provides CLI commands (`vellum x post`, `vellum x reply`) that are faster and more reliable.',
   ].join('\n');
 }
 

package/src/config/templates/IDENTITY.md

@@ -14,5 +14,12 @@ _ This file defines who you are. Fill it in during your first conversation. Make
 - **Emoji:** [Choose one that matches your personality.]
 - **Style tendency:** [Will be filled in by the evolution system based on personality]
 - **Role:** Personal AI assistant
+- **Home:** Local (~/.vellum/workspace)
+
+_ Home describes where this assistant lives. Format examples:
+_ Local (path): Local (~/.vellum/workspace)
+_ GCP: GCP (project: my-project, zone: us-central1-a, instance: vellum-abc)
+_ AWS: AWS (project: my-project, region: us-east-1, instance: vellum-abc)
+_ Custom: Custom (ip: 192.168.1.100, port: 8080)
 
 The user can change their emoji at any time — just update this file when they ask.

package/src/config/types.ts

@@ -27,7 +27,11 @@ export type {
   SkillEntryConfig,
   SkillsLoadConfig,
   SkillsInstallConfig,
+  AgentHeartbeatConfig,
   SwarmConfig,
   SkillsConfig,
   WorkspaceGitConfig,
+  CallsConfig,
+  CallsDisclosureConfig,
+  CallsSafetyConfig,
 } from './schema.js';