@vellumai/assistant 0.3.4 → 0.3.6

package/src/cli/config-commands.ts

@@ -81,7 +81,7 @@ export function registerConfigCommand(program: Command): void {
       const { validateAllowlistFile } = require('../security/secret-allowlist.js') as typeof import('../security/secret-allowlist.js');
       try {
         const errors = validateAllowlistFile();
-        if (errors === null) {
+        if (errors == null) {
           log.info('No secret-allowlist.json file found');
           return;
         }
@@ -256,7 +256,7 @@ export function registerMemoryCommand(program: Command): void {
       log.info(`Embeddings: ${status.counts.embeddings.toLocaleString()}`);
       log.info(`Pending conflicts: ${status.conflicts.pending.toLocaleString()}`);
       log.info(`Resolved conflicts: ${status.conflicts.resolved.toLocaleString()}`);
-      if (status.conflicts.oldestPendingAgeMs !== null) {
+      if (status.conflicts.oldestPendingAgeMs != null) {
         const oldestMinutes = Math.floor(status.conflicts.oldestPendingAgeMs / 60_000);
         log.info(`Oldest pending conflict age: ${oldestMinutes} min`);
       } else {

package/src/cli/core-commands.ts

@@ -13,6 +13,7 @@ import {
 } from '../daemon/lifecycle.js';
 import { startCli } from '../cli.js';
 import { getSocketPath, getRootDir, getDataDir, getDbPath, getLogPath, getWorkspaceDir, getWorkspaceSkillsDir, getWorkspaceHooksDir } from '../util/platform.js';
+import { getQdrantUrlEnv } from '../config/env.js';
 import { IpcError } from '../util/errors.js';
 import { getCliLogger } from '../util/logger.js';
 import { timeAgo } from '../util/time.js';
@@ -271,7 +272,7 @@ export function registerSessionsCommand(program: Command): void {
       }
 
       const config = getConfig();
-      const qdrantUrl = process.env.QDRANT_URL?.trim() || config.memory.qdrant.url;
+      const qdrantUrl = getQdrantUrlEnv() || config.memory.qdrant.url;
       const qdrant = initQdrantClient({
         url: qdrantUrl,
         collection: config.memory.qdrant.collection,
@@ -526,7 +527,7 @@ export function registerDoctorCommand(program: Command): void {
         try {
           const rawTrust = readFileSync(trustPath, 'utf-8');
           const data = JSON.parse(rawTrust);
-          if (typeof data !== 'object' || data === null) {
+          if (typeof data !== 'object' || data == null) {
             fail('Trust rule syntax', 'trust.json is not a JSON object');
           } else if (typeof data.version !== 'number') {
             fail('Trust rule syntax', 'missing or invalid "version" field');
@@ -535,7 +536,7 @@ export function registerDoctorCommand(program: Command): void {
           } else {
             const invalid = data.rules.filter(
               (r: unknown) =>
-                typeof r !== 'object' || r === null ||
+                typeof r !== 'object' || r == null ||
                 typeof (r as Record<string, unknown>).tool !== 'string' ||
                 typeof (r as Record<string, unknown>).pattern !== 'string' ||
                 typeof (r as Record<string, unknown>).scope !== 'string',

package/src/cli/influencer.ts

@@ -0,0 +1,244 @@
+/**
+ * CLI command group: `vellum influencer`
+ *
+ * Research influencers on Instagram, TikTok, and X/Twitter via the Chrome extension relay.
+ * All commands output JSON to stdout. Use --json for machine-readable output.
+ */
+
+import { Command } from 'commander';
+import {
+  searchInfluencers,
+  getInfluencerProfile,
+  compareInfluencers,
+  type InfluencerSearchCriteria,
+} from '../influencer/client.js';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function output(data: unknown, json: boolean): void {
+  process.stdout.write(
+    json ? JSON.stringify(data) + '\n' : JSON.stringify(data, null, 2) + '\n',
+  );
+}
+
+function outputError(message: string, code = 1): void {
+  output({ ok: false, error: message }, true);
+  process.exitCode = code;
+}
+
+function getJson(cmd: Command): boolean {
+  let c: Command | null = cmd;
+  while (c) {
+    if ((c.opts() as { json?: boolean }).json) return true;
+    c = c.parent;
+  }
+  return false;
+}
+
+async function run(cmd: Command, fn: () => Promise<unknown>): Promise<void> {
+  try {
+    const result = await fn();
+    output(
+      { ok: true, ...(result as Record<string, unknown>) },
+      getJson(cmd),
+    );
+  } catch (err) {
+    outputError(err instanceof Error ? err.message : String(err));
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Command registration
+// ---------------------------------------------------------------------------
+
+export function registerInfluencerCommand(program: Command): void {
+  const inf = program
+    .command('influencer')
+    .description(
+      'Research influencers on Instagram, TikTok, and X/Twitter. ' +
+      'Uses the Chrome extension relay to browse each platform. ' +
+      'Requires the user to be logged in on each platform in Chrome.',
+    )
+    .option('--json', 'Machine-readable JSON output');
+
+  // =========================================================================
+  // search — search for influencers across platforms
+  // =========================================================================
+  inf
+    .command('search')
+    .description(
+      'Search for influencers matching criteria across Instagram, TikTok, and X/Twitter',
+    )
+    .argument('<query>', 'Search query — niche, topic, or keywords (e.g. "fitness coach", "vegan food")')
+    .option(
+      '--platforms <platforms>',
+      'Comma-separated list of platforms to search (instagram,tiktok,twitter)',
+      'instagram,tiktok,twitter',
+    )
+    .option('--min-followers <n>', 'Minimum follower count (e.g. 10000, 10k, 1m)')
+    .option('--max-followers <n>', 'Maximum follower count (e.g. 100000, 100k, 1m)')
+    .option('--limit <n>', 'Max results per platform', '10')
+    .option('--verified', 'Only return verified accounts')
+    .action(
+      async (
+        query: string,
+        opts: {
+          platforms: string;
+          minFollowers?: string;
+          maxFollowers?: string;
+          limit: string;
+          verified?: boolean;
+        },
+        cmd: Command,
+      ) => {
+        await run(cmd, async () => {
+          const platforms = opts.platforms
+            .split(',')
+            .map((p) => p.trim().toLowerCase())
+            .filter((p): p is 'instagram' | 'tiktok' | 'twitter' =>
+              ['instagram', 'tiktok', 'twitter'].includes(p),
+            );
+
+          const criteria: InfluencerSearchCriteria = {
+            query,
+            platforms,
+            minFollowers: opts.minFollowers
+              ? parseHumanNumber(opts.minFollowers)
+              : undefined,
+            maxFollowers: opts.maxFollowers
+              ? parseHumanNumber(opts.maxFollowers)
+              : undefined,
+            limit: parseInt(opts.limit, 10),
+            verifiedOnly: opts.verified,
+          };
+
+          const results = await searchInfluencers(criteria);
+
+          const totalProfiles = results.reduce((sum, r) => sum + r.count, 0);
+
+          return {
+            results,
+            totalProfiles,
+            platforms: platforms.length,
+            query,
+          };
+        });
+      },
+    );
+
+  // =========================================================================
+  // profile — get detailed profile data for a specific influencer
+  // =========================================================================
+  inf
+    .command('profile')
+    .description('Get detailed profile data for a specific influencer')
+    .argument('<username>', 'Username/handle (without @ prefix)')
+    .option(
+      '--platform <platform>',
+      'Platform (instagram, tiktok, or twitter)',
+      'instagram',
+    )
+    .action(
+      async (
+        username: string,
+        opts: { platform: string },
+        cmd: Command,
+      ) => {
+        await run(cmd, async () => {
+          const platform = opts.platform.toLowerCase() as
+            | 'instagram'
+            | 'tiktok'
+            | 'twitter';
+          if (!['instagram', 'tiktok', 'twitter'].includes(platform)) {
+            throw new Error(
+              `Invalid platform: ${opts.platform}. Use instagram, tiktok, or twitter.`,
+            );
+          }
+
+          const cleanUsername = username.replace(/^@/, '');
+          const profile = await getInfluencerProfile(platform, cleanUsername);
+
+          if (!profile) {
+            throw new Error(
+              `Could not find profile @${cleanUsername} on ${platform}`,
+            );
+          }
+
+          return { profile };
+        });
+      },
+    );
+
+  // =========================================================================
+  // compare — compare multiple influencers side by side
+  // =========================================================================
+  inf
+    .command('compare')
+    .description(
+      'Compare multiple influencers side by side. ' +
+      'Provide usernames as platform:username pairs.',
+    )
+    .argument(
+      '<influencers...>',
+      'Space-separated list of platform:username pairs (e.g. instagram:nike twitter:nike tiktok:nike)',
+    )
+    .action(async (influencers: string[], _opts: unknown, cmd: Command) => {
+      await run(cmd, async () => {
+        const parsed = influencers.map((inf) => {
+          const [platform, username] = inf.includes(':')
+            ? inf.split(':', 2)
+            : ['instagram', inf];
+
+          const cleanPlatform = platform.toLowerCase() as
+            | 'instagram'
+            | 'tiktok'
+            | 'twitter';
+          if (!['instagram', 'tiktok', 'twitter'].includes(cleanPlatform)) {
+            throw new Error(
+              `Invalid platform "${platform}" in "${inf}". Use instagram, tiktok, or twitter.`,
+            );
+          }
+
+          return {
+            platform: cleanPlatform,
+            username: username.replace(/^@/, ''),
+          };
+        });
+
+        const profiles = await compareInfluencers(parsed);
+
+        return {
+          profiles,
+          count: profiles.length,
+          requested: parsed.length,
+        };
+      });
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Utilities
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse human-friendly numbers like "10k", "1.5m", "100000" into integers.
+ */
+function parseHumanNumber(text: string): number {
+  const cleaned = text.toLowerCase().replace(/,/g, '').trim();
+  const match = cleaned.match(/^([\d.]+)\s*([kmbt]?)$/);
+  if (!match) return parseInt(text, 10) || 0;
+
+  const num = parseFloat(match[1]);
+  const suffix = match[2];
+  const multipliers: Record<string, number> = {
+    '': 1,
+    k: 1_000,
+    m: 1_000_000,
+    b: 1_000_000_000,
+    t: 1_000_000_000_000,
+  };
+
+  return Math.round(num * (multipliers[suffix] || 1));
+}

package/src/cli/map.ts

@@ -72,6 +72,75 @@ async function isCdpReady(): Promise<boolean> {
   }
 }
 
+/**
+ * Bring the Chrome CDP tab to the foreground so the user sees the right window.
+ * Optionally navigates to a URL first (used when Chrome was already running).
+ */
+async function bringChromeToFront(navigateUrl?: string): Promise<string | null> {
+  try {
+    const res = await fetch(`${CDP_BASE}/json/list`);
+    if (!res.ok) return null;
+    const targets = (await res.json()) as Array<{ type: string; url: string; webSocketDebuggerUrl: string }>;
+    const pageTarget = targets.find(t => t.type === 'page');
+    if (!pageTarget?.webSocketDebuggerUrl) return null;
+
+    const ws = new WebSocket(pageTarget.webSocketDebuggerUrl);
+    await new Promise<void>((resolve, reject) => {
+      ws.onopen = () => resolve();
+      ws.onerror = (e) => reject(new Error(`CDP WebSocket error: ${e}`));
+    });
+
+    let nextId = 1;
+    const cdpSend = (method: string, params?: Record<string, unknown>): Promise<unknown> =>
+      new Promise((resolve, reject) => {
+        const id = nextId++;
+        const cleanup = () => {
+          clearTimeout(timeout);
+          ws.removeEventListener('message', handler);
+          ws.removeEventListener('close', onClose);
+          ws.removeEventListener('error', onError);
+        };
+        const timeout = setTimeout(() => {
+          cleanup();
+          reject(new Error(`CDP command ${method} timed out`));
+        }, 5000);
+        const onClose = () => {
+          cleanup();
+          reject(new Error('WebSocket closed before CDP response'));
+        };
+        const onError = (e: Event) => {
+          cleanup();
+          reject(new Error(`WebSocket error: ${e}`));
+        };
+        const handler = (event: MessageEvent) => {
+          const msg = JSON.parse(String(event.data));
+          if (msg.id === id) {
+            cleanup();
+            if (msg.error) reject(new Error(msg.error.message));
+            else resolve(msg.result);
+          }
+        };
+        ws.addEventListener('message', handler);
+        ws.addEventListener('close', onClose);
+        ws.addEventListener('error', onError);
+        ws.send(JSON.stringify({ id, method, params }));
+      });
+
+    if (navigateUrl) {
+      await cdpSend('Page.navigate', { url: navigateUrl });
+      // Brief wait for navigation to start
+      await new Promise(r => setTimeout(r, 500));
+    }
+
+    await cdpSend('Page.bringToFront');
+    const tabUrl = navigateUrl ?? pageTarget.url;
+    ws.close();
+    return tabUrl;
+  } catch {
+    return null;
+  }
+}
+
 async function ensureChromeWithCDP(domain: string): Promise<void> {
   // Already running with CDP?
   if (await isCdpReady()) return;
@@ -110,9 +179,16 @@ async function startLearnSession(
   navigateDomain: string,
   recordDomain: string,
   durationSeconds: number,
+  autoNavigate: boolean = true,
 ): Promise<LearnResult> {
   await ensureChromeWithCDP(navigateDomain);
 
+  // Activate the Chrome window so the user knows which tab to watch
+  const tabUrl = await bringChromeToFront(`https://${navigateDomain}/`);
+  if (tabUrl) {
+    process.stderr.write(`Chrome is ready — using tab at ${tabUrl}\n`);
+  }
+
   return new Promise((resolve, reject) => {
     const socketPath = getSocketPath();
     const sessionToken = readSessionToken();
@@ -140,7 +216,7 @@ async function startLearnSession(
           mode: 'learn',
           targetDomain: recordDomain,
           navigateDomain,
-          autoNavigate: true,
+          autoNavigate,
         } as unknown as import('../daemon/ipc-protocol.js').ClientMessage),
       );
     };
@@ -211,11 +287,15 @@ export function registerMapCommand(program: Command): void {
       'then analyzes captured network traffic.',
     )
     .argument('<domain>', 'Domain to map (e.g., example.com)')
-    .option('--duration <seconds>', 'Recording duration in seconds', '120')
+    .option('--duration <seconds>', 'Recording duration in seconds')
+    .option('--manual', 'Manual mode: browse the site yourself while network traffic is recorded')
     .option('--json', 'Machine-readable JSON output')
-    .action(async (domain: string, opts: { duration: string; json?: boolean }, cmd: Command) => {
+    .action(async (domain: string, opts: { duration?: string; manual?: boolean; json?: boolean }, cmd: Command) => {
       const json = getJson(cmd);
-      const duration = parseInt(opts.duration, 10);
+      const manual = opts.manual ?? false;
+      const duration = opts.duration
+        ? parseInt(opts.duration, 10)
+        : manual ? 60 : 120;
 
       try {
         // Split into navigation domain (what Chrome browses) and recording domain (network filter).
@@ -224,13 +304,16 @@ export function registerMapCommand(program: Command): void {
         const recordDomain = getBaseDomain(domain);
 
         if (!json) {
-          if (navigateDomain !== recordDomain) {
+          if (manual) {
+            console.log(`Starting manual API map session for ${domain} (${duration}s)...`);
+            console.log('Browse the site manually. Press Ctrl+C or wait for idle detection to stop recording.');
+          } else if (navigateDomain !== recordDomain) {
             console.log(`Starting API map session: navigating ${navigateDomain}, recording *.${recordDomain} (${duration}s)...`);
           } else {
             console.log(`Starting API map session for ${domain} (${duration}s)...`);
           }
         }
-        const result = await startLearnSession(navigateDomain, recordDomain, duration);
+        const result = await startLearnSession(navigateDomain, recordDomain, duration, !manual);
 
         if (!result.recordingId) {
           outputError('Recording completed but no recording ID returned');

package/src/cli.ts

@@ -785,7 +785,7 @@ export async function startCli(): Promise<void> {
 
     if (content === '/copy-code') {
       const code = extractLastCodeBlock(lastResponse);
-      if (code === null) {
+      if (code == null) {
         process.stdout.write('No code block found.\n');
       } else {
         try {

package/src/config/agent-schema.ts

@@ -0,0 +1,171 @@
+import { z } from 'zod';
+
+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' })
+    .default(true),
+  maxWorkers: z
+    .number({ error: 'swarm.maxWorkers must be a number' })
+    .int('swarm.maxWorkers must be an integer')
+    .positive('swarm.maxWorkers must be a positive integer')
+    .max(6, 'swarm.maxWorkers must be at most 6')
+    .default(3),
+  maxTasks: z
+    .number({ error: 'swarm.maxTasks must be a number' })
+    .int('swarm.maxTasks must be an integer')
+    .positive('swarm.maxTasks must be a positive integer')
+    .max(20, 'swarm.maxTasks must be at most 20')
+    .default(8),
+  maxRetriesPerTask: z
+    .number({ error: 'swarm.maxRetriesPerTask must be a number' })
+    .int('swarm.maxRetriesPerTask must be an integer')
+    .nonnegative('swarm.maxRetriesPerTask must be a non-negative integer')
+    .max(3, 'swarm.maxRetriesPerTask must be at most 3')
+    .default(1),
+  workerTimeoutSec: z
+    .number({ error: 'swarm.workerTimeoutSec must be a number' })
+    .int('swarm.workerTimeoutSec must be an integer')
+    .positive('swarm.workerTimeoutSec must be a positive integer')
+    .default(900),
+  plannerModel: z
+    .string({ error: 'swarm.plannerModel must be a string' })
+    .default('claude-haiku-4-5-20251001'),
+  synthesizerModel: z
+    .string({ error: 'swarm.synthesizerModel must be a string' })
+    .default('claude-sonnet-4-6'),
+});
+
+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({ openAfterFailures: 3, backoffBaseMs: 2000, backoffMaxMs: 60000 }),
+  }).default({
+    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 },
+  }),
+});
+
+export type AgentHeartbeatConfig = z.infer<typeof AgentHeartbeatConfigSchema>;
+export type SwarmConfig = z.infer<typeof SwarmConfigSchema>;
+export type WorkspaceGitConfig = z.infer<typeof WorkspaceGitConfigSchema>;