vellum 0.2.0 → 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

@@ -4,6 +4,7 @@ import type { AssistantConfig } from './types.js';
 export const DEFAULT_CONFIG: AssistantConfig = {
   provider: 'anthropic',
   model: 'claude-opus-4-6', // alias: claude-opus-4
+  imageGenModel: 'gemini-2.5-flash-image',
   apiKeys: {},
   webSearchProvider: 'perplexity',
   providerOrder: [],
@@ -168,6 +169,10 @@ export const DEFAULT_CONFIG: AssistantConfig = {
     retentionDays: 30,
   },
   pricingOverrides: [],
+  agentHeartbeat: {
+    enabled: false,
+    intervalMs: 3_600_000,
+  },
   swarm: {
     enabled: true,
     maxWorkers: 3,
@@ -183,4 +188,43 @@ export const DEFAULT_CONFIG: AssistantConfig = {
     install: { nodeManager: 'npm' },
     allowBundled: null,
   },
+  workspaceGit: {
+    turnCommitMaxWaitMs: 4000,
+    failureBackoffBaseMs: 2000,
+    failureBackoffMaxMs: 60000,
+    interactiveGitTimeoutMs: 10000,
+    enrichmentQueueSize: 50,
+    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
@@ -703,6 +704,126 @@ export const SkillsInstallConfigSchema = z.object({
   }).default('npm'),
 });
 
+export const WorkspaceGitConfigSchema = z.object({
+  turnCommitMaxWaitMs: z
+    .number({ error: 'workspaceGit.turnCommitMaxWaitMs must be a number' })
+    .int('workspaceGit.turnCommitMaxWaitMs must be an integer')
+    .positive('workspaceGit.turnCommitMaxWaitMs must be a positive integer')
+    .default(4000),
+  failureBackoffBaseMs: z
+    .number({ error: 'workspaceGit.failureBackoffBaseMs must be a number' })
+    .int('workspaceGit.failureBackoffBaseMs must be an integer')
+    .positive('workspaceGit.failureBackoffBaseMs must be a positive integer')
+    .default(2000),
+  failureBackoffMaxMs: z
+    .number({ error: 'workspaceGit.failureBackoffMaxMs must be a number' })
+    .int('workspaceGit.failureBackoffMaxMs must be an integer')
+    .positive('workspaceGit.failureBackoffMaxMs must be a positive integer')
+    .default(60000),
+  interactiveGitTimeoutMs: z
+    .number({ error: 'workspaceGit.interactiveGitTimeoutMs must be a number' })
+    .int('workspaceGit.interactiveGitTimeoutMs must be an integer')
+    .positive('workspaceGit.interactiveGitTimeoutMs must be a positive integer')
+    .default(10000),
+  enrichmentQueueSize: z
+    .number({ error: 'workspaceGit.enrichmentQueueSize must be a number' })
+    .int('workspaceGit.enrichmentQueueSize must be an integer')
+    .positive('workspaceGit.enrichmentQueueSize must be a positive integer')
+    .default(50),
+  enrichmentConcurrency: z
+    .number({ error: 'workspaceGit.enrichmentConcurrency must be a number' })
+    .int('workspaceGit.enrichmentConcurrency must be an integer')
+    .positive('workspaceGit.enrichmentConcurrency must be a positive integer')
+    .default(1),
+  enrichmentJobTimeoutMs: z
+    .number({ error: 'workspaceGit.enrichmentJobTimeoutMs must be a number' })
+    .int('workspaceGit.enrichmentJobTimeoutMs must be an integer')
+    .positive('workspaceGit.enrichmentJobTimeoutMs must be a positive integer')
+    .default(30000),
+  enrichmentMaxRetries: z
+    .number({ error: 'workspaceGit.enrichmentMaxRetries must be a number' })
+    .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({
   enabled: z
     .boolean({ error: 'swarm.enabled must be a boolean' })
@@ -738,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 }),
@@ -754,6 +920,9 @@ export const AssistantConfigSchema = z.object({
   model: z
     .string({ error: 'model must be a string' })
     .default('claude-opus-4-6'),
+  imageGenModel: z
+    .string({ error: 'imageGenModel must be a string' })
+    .default('gemini-2.5-flash-image'),
   apiKeys: z
     .record(z.string(), z.string({ error: 'Each apiKeys value must be a string' }))
     .default({}),
@@ -932,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,
@@ -947,6 +1120,45 @@ export const AssistantConfigSchema = z.object({
     install: { nodeManager: 'npm' },
     allowBundled: null,
   }),
+  workspaceGit: WorkspaceGitConfigSchema.default({
+    turnCommitMaxWaitMs: 4000,
+    failureBackoffBaseMs: 2000,
+    failureBackoffMaxMs: 60000,
+    interactiveGitTimeoutMs: 10000,
+    enrichmentQueueSize: 50,
+    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) {
     ctx.addIssue({
@@ -1000,5 +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>;