cli4ai 0.8.2 → 0.8.3

package/src/core/config.ts

@@ -2,7 +2,7 @@
  * Global cli4ai configuration (~/.cli4ai/)
  */
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, lstatSync, realpathSync } from 'fs';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, lstatSync, realpathSync, openSync, closeSync, unlinkSync, renameSync } from 'fs';
 import { resolve, join, normalize } from 'path';
 import { homedir } from 'os';
 import { outputError, log } from '../lib/cli.js';
@@ -69,12 +69,17 @@ export function isPathSafe(path: string): boolean {
 // PATHS
 // ═══════════════════════════════════════════════════════════════════════════
 
-export const CLI4AI_HOME = resolve(homedir(), '.cli4ai');
+export const CLI4AI_HOME = process.env.CLI4AI_HOME
+  ? resolve(process.env.CLI4AI_HOME)
+  : resolve(homedir(), '.cli4ai');
 export const CONFIG_FILE = resolve(CLI4AI_HOME, 'config.json');
 export const PACKAGES_DIR = resolve(CLI4AI_HOME, 'packages');
 export const CACHE_DIR = resolve(CLI4AI_HOME, 'cache');
 export const ROUTINES_DIR = resolve(CLI4AI_HOME, 'routines');
+export const SCHEDULER_DIR = resolve(CLI4AI_HOME, 'scheduler');
 export const CREDENTIALS_FILE = resolve(CLI4AI_HOME, 'credentials.json');
+const CONFIG_LOCK_FILE = CONFIG_FILE + '.lock';
+const CONFIG_TMP_FILE = CONFIG_FILE + '.tmp';
 
 // Local project paths
 export const LOCAL_DIR = '.cli4ai';
@@ -116,7 +121,7 @@ export interface InstalledPackage {
 // ═══════════════════════════════════════════════════════════════════════════
 
 export const DEFAULT_CONFIG: Config = {
-  registry: 'https://registry.cliforai.com',
+  registry: 'https://registry.cli4ai.com',
   localRegistries: [],
   defaultRuntime: 'bun',
   mcp: {
@@ -134,7 +139,7 @@ export const DEFAULT_CONFIG: Config = {
  * Ensure ~/.cli4ai directory exists with required subdirectories
  */
 export function ensureCli4aiHome(): void {
-  const dirs = [CLI4AI_HOME, PACKAGES_DIR, CACHE_DIR, ROUTINES_DIR];
+  const dirs = [CLI4AI_HOME, PACKAGES_DIR, CACHE_DIR, ROUTINES_DIR, SCHEDULER_DIR];
 
   for (const dir of dirs) {
     if (!existsSync(dir)) {
@@ -200,30 +205,26 @@ function deepMerge(target: Config, source: Partial<Config>): Config {
  * Load global config, creating defaults if needed
  */
 export function loadConfig(): Config {
-  ensureCli4aiHome();
-
-  if (!existsSync(CONFIG_FILE)) {
-    saveConfig(DEFAULT_CONFIG);
-    return DEFAULT_CONFIG;
-  }
-
-  try {
-    const content = readFileSync(CONFIG_FILE, 'utf-8');
-    const data = JSON.parse(content);
-    // Deep merge with defaults to handle missing nested fields (e.g., mcp.port)
-    return deepMerge(DEFAULT_CONFIG, data);
-  } catch {
-    log(`Warning: Invalid config file, using defaults`);
-    return DEFAULT_CONFIG;
-  }
+  return withConfigLock(() => loadConfigUnlocked());
 }
 
 /**
  * Save global config
  */
 export function saveConfig(config: Config): void {
-  ensureCli4aiHome();
-  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n');
+  withConfigLock(() => saveConfigUnlocked(config));
+}
+
+/**
+ * Update config with a read-modify-write lock to avoid cross-process races.
+ */
+export function updateConfig(mutator: (config: Config) => Config): Config {
+  return withConfigLock(() => {
+    const current = loadConfigUnlocked();
+    const next = mutator(current);
+    saveConfigUnlocked(next);
+    return next;
+  });
 }
 
 /**
@@ -238,9 +239,10 @@ export function getConfigValue<K extends keyof Config>(key: K): Config[K] {
  * Set a config value
  */
 export function setConfigValue<K extends keyof Config>(key: K, value: Config[K]): void {
-  const config = loadConfig();
-  config[key] = value;
-  saveConfig(config);
+  updateConfig((config) => {
+    config[key] = value;
+    return config;
+  });
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -295,7 +297,6 @@ function isRegistryPathSafe(registryPath: string): boolean {
  * Add a local registry path
  */
 export function addLocalRegistry(path: string): void {
-  const config = loadConfig();
   const absolutePath = resolve(path);
 
   // SECURITY: Validate registry path is not in sensitive system directories
@@ -317,28 +318,190 @@ export function addLocalRegistry(path: string): void {
     });
   }
 
-  if (!config.localRegistries.includes(safePath)) {
-    config.localRegistries.push(safePath);
-    saveConfig(config);
-    log(`Added local registry: ${safePath}`);
-  }
+  let added = false;
+  updateConfig((config) => {
+    if (!config.localRegistries.includes(safePath)) {
+      config.localRegistries.push(safePath);
+      added = true;
+    }
+    return config;
+  });
+  if (added) log(`Added local registry: ${safePath}`);
 }
 
 /**
  * Remove a local registry path
  */
 export function removeLocalRegistry(path: string): void {
-  const config = loadConfig();
   const absolutePath = resolve(path);
-  const index = config.localRegistries.indexOf(absolutePath);
+  const safePath = validateSymlinkTarget(absolutePath) ?? absolutePath;
+
+  let removed = false;
+  updateConfig((config) => {
+    const index = config.localRegistries.indexOf(safePath);
+    if (index !== -1) {
+      config.localRegistries.splice(index, 1);
+      removed = true;
+    }
+    return config;
+  });
+  if (removed) log(`Removed local registry: ${safePath}`);
+}
+
+function sleepSync(ms: number): void {
+  if (ms <= 0) return;
+  try {
+    const buf = new SharedArrayBuffer(4);
+    const view = new Int32Array(buf);
+    Atomics.wait(view, 0, 0, ms);
+  } catch {
+    const end = Date.now() + ms;
+    while (Date.now() < end) {
+      // busy wait (best effort)
+    }
+  }
+}
+
+function isPidRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isLockStale(lockPath: string, staleMs: number): boolean {
+  try {
+    const stat = lstatSync(lockPath);
+    if (Date.now() - stat.mtimeMs > staleMs) return true;
+  } catch {
+    return false;
+  }
+
+  try {
+    const raw = readFileSync(lockPath, 'utf-8');
+    const parsed = JSON.parse(raw) as { pid?: unknown; createdAt?: unknown };
+    const pid = typeof parsed.pid === 'number' ? parsed.pid : null;
+    const createdAtMs =
+      typeof parsed.createdAt === 'number'
+        ? parsed.createdAt
+        : typeof parsed.createdAt === 'string'
+          ? Date.parse(parsed.createdAt)
+          : NaN;
+
+    if (pid !== null && !isPidRunning(pid)) return true;
+    if (Number.isFinite(createdAtMs) && Date.now() - createdAtMs > staleMs) return true;
+  } catch {
+    // ignore parse errors (fall back to mtime check above)
+  }
+
+  return false;
+}
+
+function acquireLock(lockPath: string, timeoutMs: number, staleMs: number): number {
+  const start = Date.now();
+  while (true) {
+    try {
+      const fd = openSync(lockPath, 'wx');
+      try {
+        writeFileSync(fd, JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }) + '\n');
+      } catch {
+        // best effort
+      }
+      return fd;
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException).code;
+      if (code !== 'EEXIST') {
+        throw err;
+      }
+
+      if (isLockStale(lockPath, staleMs)) {
+        try {
+          unlinkSync(lockPath);
+          continue;
+        } catch {
+          // fall through to wait
+        }
+      }
+
+      if (Date.now() - start > timeoutMs) {
+        throw new Error(`Timed out waiting for config lock: ${lockPath}`);
+      }
+
+      sleepSync(25);
+    }
+  }
+}
+
+function releaseLock(lockPath: string, fd: number): void {
+  try {
+    closeSync(fd);
+  } catch {
+    // ignore
+  }
+  try {
+    unlinkSync(lockPath);
+  } catch {
+    // ignore
+  }
+}
+
+let configLockDepth = 0;
+let configLockFd: number | null = null;
+
+function withConfigLock<T>(fn: () => T): T {
+  const timeoutMs = 2000;
+  const staleMs = 30000;
+
+  if (configLockDepth > 0) {
+    configLockDepth++;
+    try {
+      return fn();
+    } finally {
+      configLockDepth--;
+    }
+  }
+
+  configLockDepth = 1;
+  const fd = acquireLock(CONFIG_LOCK_FILE, timeoutMs, staleMs);
+  configLockFd = fd;
 
-  if (index !== -1) {
-    config.localRegistries.splice(index, 1);
-    saveConfig(config);
-    log(`Removed local registry: ${absolutePath}`);
+  try {
+    return fn();
+  } finally {
+    configLockFd = null;
+    configLockDepth = 0;
+    releaseLock(CONFIG_LOCK_FILE, fd);
   }
 }
 
+function loadConfigUnlocked(): Config {
+  ensureCli4aiHome();
+
+  if (!existsSync(CONFIG_FILE)) {
+    saveConfigUnlocked(DEFAULT_CONFIG);
+    return DEFAULT_CONFIG;
+  }
+
+  try {
+    const content = readFileSync(CONFIG_FILE, 'utf-8');
+    const data = JSON.parse(content);
+    // Deep merge with defaults to handle missing nested fields (e.g., mcp.port)
+    return deepMerge(DEFAULT_CONFIG, data);
+  } catch {
+    log(`Warning: Invalid config file, using defaults`);
+    return DEFAULT_CONFIG;
+  }
+}
+
+function saveConfigUnlocked(config: Config): void {
+  ensureCli4aiHome();
+  const content = JSON.stringify(config, null, 2) + '\n';
+  writeFileSync(CONFIG_TMP_FILE, content);
+  renameSync(CONFIG_TMP_FILE, CONFIG_FILE);
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // INSTALLED PACKAGES TRACKING
 // ═══════════════════════════════════════════════════════════════════════════

package/src/core/execute.ts

@@ -10,13 +10,26 @@ import { spawn, spawnSync } from 'child_process';
 import { resolve } from 'path';
 import { existsSync, readFileSync } from 'fs';
 import { createInterface } from 'readline';
-import { platform } from 'os';
+import { platform, homedir } from 'os';
 import { log } from '../lib/cli.js';
 import { findPackage } from './config.js';
 import { loadManifest, type Manifest } from './manifest.js';
 import { getSecret } from './secrets.js';
 import { checkPackageIntegrity } from './lockfile.js';
 
+/**
+ * Expand ~ to home directory in paths
+ */
+function expandTilde(path: string): string {
+  if (path.startsWith('~/')) {
+    return resolve(homedir(), path.slice(2));
+  }
+  if (path === '~') {
+    return homedir();
+  }
+  return path;
+}
+
 export type ExecuteCaptureMode = 'inherit' | 'pipe';
 
 export interface ExecuteToolOptions {
@@ -309,8 +322,10 @@ async function checkAndPromptSecrets(pkgPath: string, pkgName: string): Promise<
       });
     }
 
-    setSecret(key, value);
-    secretsEnv[key] = value;
+    // Expand ~ to home directory for paths
+    const expandedValue = expandTilde(value);
+    setSecret(key, expandedValue);
+    secretsEnv[key] = expandedValue;
     log(`  ✓ ${key} saved to vault\n`);
   }
 
@@ -318,8 +333,7 @@ async function checkAndPromptSecrets(pkgPath: string, pkgName: string): Promise<
   return secretsEnv;
 }
 
-function buildRuntimeCommand(entryPath: string, manifest: Manifest, cmdArgs: string[]): { execCmd: string; execArgs: string[]; runtime: 'bun' | 'node' } {
-  const runtime = manifest.runtime || 'bun';
+function buildRuntimeCommand(entryPath: string, runtime: 'bun' | 'node', cmdArgs: string[]): { execCmd: string; execArgs: string[]; runtime: 'bun' | 'node' } {
   switch (runtime) {
     case 'node':
       return { execCmd: 'node', execArgs: [entryPath, ...cmdArgs], runtime: 'node' };
@@ -329,6 +343,40 @@ function buildRuntimeCommand(entryPath: string, manifest: Manifest, cmdArgs: str
   }
 }
 
+function resolveRuntime(manifest: Manifest): 'bun' | 'node' {
+  if (manifest.runtime === 'node') return 'node';
+  if (manifest.runtime === 'bun') return 'bun';
+
+  // Unspecified runtime: prefer bun if installed, otherwise fall back to node if available.
+  if (commandExists('bun')) return 'bun';
+  if (commandExists('node')) return 'node';
+
+  // Default to bun (will prompt install below).
+  return 'bun';
+}
+
+async function ensureRuntimeAvailable(runtime: 'bun' | 'node'): Promise<void> {
+  if (runtime === 'bun') {
+    if (!commandExists('bun')) {
+      log('⚠️  bun is required to run this tool\n');
+      const installed = await installDependency('bun');
+      if (!installed) {
+        throw new ExecuteToolError('MISSING_DEPENDENCY', 'bun is required', {
+          hint: 'Install bun: curl -fsSL https://bun.sh/install | bash'
+        });
+      }
+    }
+    return;
+  }
+
+  // runtime === 'node'
+  if (!commandExists('node')) {
+    throw new ExecuteToolError('MISSING_DEPENDENCY', 'node is required', {
+      hint: 'Install Node.js: https://nodejs.org/en/download/'
+    });
+  }
+}
+
 function collectStream(stream: NodeJS.ReadableStream): Promise<string> {
   return new Promise((resolve, reject) => {
     const chunks: Buffer[] = [];
@@ -378,15 +426,8 @@ export async function executeTool(options: ExecuteToolOptions): Promise<ExecuteT
     log('');
   }
 
-  if (!commandExists('bun')) {
-    log('⚠️  bun is required to run cli4ai tools\n');
-    const installed = await installDependency('bun');
-    if (!installed) {
-      throw new ExecuteToolError('MISSING_DEPENDENCY', 'bun is required', {
-        hint: 'Install bun: curl -fsSL https://bun.sh/install | bash'
-      });
-    }
-  }
+  const runtime = resolveRuntime(manifest);
+  await ensureRuntimeAvailable(runtime);
 
   await checkPeerDependencies(pkg.path);
 
@@ -403,7 +444,7 @@ export async function executeTool(options: ExecuteToolOptions): Promise<ExecuteT
   if (options.command) cmdArgs.push(options.command);
   cmdArgs.push(...options.args);
 
-  const { execCmd, execArgs, runtime } = buildRuntimeCommand(entryPath, manifest, cmdArgs);
+  const { execCmd, execArgs } = buildRuntimeCommand(entryPath, runtime, cmdArgs);
 
   const teeStderr = options.teeStderr ?? true;
 

package/src/core/link.ts

@@ -81,7 +81,18 @@ exec cli4ai run ${safeName} "$@"
 `;
 
   writeFileSync(binPath, script);
-  chmodSync(binPath, 0o755);
+  if (process.platform !== 'win32') {
+    chmodSync(binPath, 0o755);
+  }
+
+  // Windows compatibility: generate .cmd and .ps1 launchers
+  if (process.platform === 'win32') {
+    const cmdContent = `@echo off\r\ncli4ai run ${manifest.name} %*\r\nexit /b %errorlevel%\r\n`;
+    writeFileSync(binPath + '.cmd', cmdContent);
+
+    const ps1Content = `& cli4ai run ${manifest.name} @args\nexit $LASTEXITCODE\n`;
+    writeFileSync(binPath + '.ps1', ps1Content);
+  }
 
   return binPath;
 }
@@ -134,7 +145,27 @@ exec ${execCommand} "$@"
 `;
 
   writeFileSync(binPath, script);
-  chmodSync(binPath, 0o755);
+  if (process.platform !== 'win32') {
+    chmodSync(binPath, 0o755);
+  }
+
+  // Windows compatibility: generate .cmd and .ps1 launchers
+  if (process.platform === 'win32') {
+    const quotedEntry = `"${entryPath.replaceAll('"', '""')}"`;
+    const runtimeCmd = runtime === 'node' ? 'node' : 'bun';
+
+    const cmdContent =
+      runtime === 'node'
+        ? `@echo off\r\n${runtimeCmd} ${quotedEntry} %*\r\nexit /b %errorlevel%\r\n`
+        : `@echo off\r\n${runtimeCmd} run ${quotedEntry} %*\r\nexit /b %errorlevel%\r\n`;
+    writeFileSync(binPath + '.cmd', cmdContent);
+
+    const ps1Content =
+      runtime === 'node'
+        ? `& "${runtimeCmd}" ${quotedEntry} @args\nexit $LASTEXITCODE\n`
+        : `& "${runtimeCmd}" run ${quotedEntry} @args\nexit $LASTEXITCODE\n`;
+    writeFileSync(binPath + '.ps1', ps1Content);
+  }
 
   return binPath;
 }
@@ -143,21 +174,33 @@ exec ${execCommand} "$@"
  * Remove executable link for a package
  */
 export function unlinkPackage(packageName: string): boolean {
-  const binPath = join(C4AI_BIN, packageName);
-
-  if (existsSync(binPath)) {
-    unlinkSync(binPath);
-    return true;
+  const basePath = join(C4AI_BIN, packageName);
+  const candidates = process.platform === 'win32'
+    ? [basePath, basePath + '.cmd', basePath + '.ps1']
+    : [basePath];
+
+  let removed = false;
+  for (const path of candidates) {
+    if (existsSync(path)) {
+      unlinkSync(path);
+      removed = true;
+    }
   }
 
-  return false;
+  return removed;
 }
 
 /**
  * Check if a package is linked
  */
 export function isPackageLinked(packageName: string): boolean {
-  return existsSync(join(C4AI_BIN, packageName));
+  const basePath = join(C4AI_BIN, packageName);
+  if (existsSync(basePath)) return true;
+  if (process.platform === 'win32') {
+    if (existsSync(basePath + '.cmd')) return true;
+    if (existsSync(basePath + '.ps1')) return true;
+  }
+  return false;
 }
 
 /**

package/src/core/lockfile.ts

@@ -8,7 +8,7 @@
  * to detect tampered packages.
  */
 
-import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { readFileSync, writeFileSync, renameSync, existsSync, readdirSync, statSync } from 'fs';
 import { resolve, join, relative } from 'path';
 import { createHash } from 'crypto';
 
@@ -211,7 +211,9 @@ export function loadLockfile(projectDir: string): Lockfile {
 export function saveLockfile(projectDir: string, lockfile: Lockfile): void {
   const lockfilePath = getLockfilePath(projectDir);
   const content = JSON.stringify(lockfile, null, 2) + '\n';
-  writeFileSync(lockfilePath, content);
+  const tmpPath = lockfilePath + '.tmp';
+  writeFileSync(tmpPath, content);
+  renameSync(tmpPath, lockfilePath);
 }
 
 /**

package/src/core/routine-engine.ts

@@ -38,6 +38,27 @@ export class RoutineTemplateError extends Error {
 
 export type StepCapture = 'inherit' | 'text' | 'json';
 
+// ═══════════════════════════════════════════════════════════════════════════
+// SCHEDULE TYPES
+// ═══════════════════════════════════════════════════════════════════════════
+
+export interface RoutineSchedule {
+  /** Cron expression (e.g., "0 9 * * *" for 9am daily) */
+  cron?: string;
+  /** Simple interval (e.g., "30s", "5m", "1h", "1d") */
+  interval?: string;
+  /** IANA timezone (e.g., "Pacific/Auckland"). Defaults to system timezone */
+  timezone?: string;
+  /** Whether this schedule is active. Defaults to true */
+  enabled?: boolean;
+  /** Number of retry attempts on failure. Defaults to 0 */
+  retries?: number;
+  /** Delay between retries in milliseconds. Defaults to 60000 */
+  retryDelayMs?: number;
+  /** What to do if previous run is still executing. Defaults to 'skip' */
+  concurrency?: 'skip' | 'queue';
+}
+
 export interface RoutineVarDef {
   default?: string;
 }
@@ -81,6 +102,8 @@ export interface RoutineDefinition {
   description?: string;
   mcp?: { expose?: boolean; description?: string };
   vars?: Record<string, RoutineVarDef>;
+  /** Schedule configuration for automatic execution */
+  schedule?: RoutineSchedule;
   steps: RoutineStep[];
   result?: unknown;
 }
@@ -140,6 +163,80 @@ export function loadRoutineDefinition(path: string): RoutineDefinition {
   return validateRoutineDefinition(data, path);
 }
 
+const INTERVAL_PATTERN = /^(\d+)(s|m|h|d)$/;
+
+/**
+ * Validate a schedule configuration.
+ * Exported for use by scheduler and tests.
+ */
+export function validateScheduleConfig(schedule: unknown, source?: string): RoutineSchedule {
+  if (!schedule || typeof schedule !== 'object') {
+    throw new RoutineValidationError('Schedule must be an object', { source });
+  }
+
+  const s = schedule as Record<string, unknown>;
+
+  // Must have either cron or interval (or both)
+  if (s.cron === undefined && s.interval === undefined) {
+    throw new RoutineValidationError('Schedule must have "cron" or "interval"', { source });
+  }
+
+  // Validate cron (basic format check - full validation happens at runtime with cron-parser)
+  if (s.cron !== undefined) {
+    if (typeof s.cron !== 'string' || s.cron.trim().length === 0) {
+      throw new RoutineValidationError('Schedule "cron" must be a non-empty string', { source, got: s.cron });
+    }
+    // Basic cron format: should have 5 space-separated parts
+    const parts = s.cron.trim().split(/\s+/);
+    if (parts.length < 5 || parts.length > 6) {
+      throw new RoutineValidationError('Schedule "cron" must have 5 or 6 fields', { source, got: s.cron });
+    }
+  }
+
+  // Validate interval
+  if (s.interval !== undefined) {
+    if (typeof s.interval !== 'string') {
+      throw new RoutineValidationError('Schedule "interval" must be a string', { source, got: s.interval });
+    }
+    if (!INTERVAL_PATTERN.test(s.interval)) {
+      throw new RoutineValidationError('Schedule "interval" must be like "30s", "5m", "1h", or "1d"', { source, got: s.interval });
+    }
+  }
+
+  // Validate timezone (just check it's a string - actual validation happens at runtime)
+  if (s.timezone !== undefined && typeof s.timezone !== 'string') {
+    throw new RoutineValidationError('Schedule "timezone" must be a string', { source, got: s.timezone });
+  }
+
+  // Validate enabled
+  if (s.enabled !== undefined && typeof s.enabled !== 'boolean') {
+    throw new RoutineValidationError('Schedule "enabled" must be a boolean', { source, got: s.enabled });
+  }
+
+  // Validate retries
+  if (s.retries !== undefined) {
+    if (typeof s.retries !== 'number' || !Number.isInteger(s.retries) || s.retries < 0) {
+      throw new RoutineValidationError('Schedule "retries" must be a non-negative integer', { source, got: s.retries });
+    }
+  }
+
+  // Validate retryDelayMs
+  if (s.retryDelayMs !== undefined) {
+    if (typeof s.retryDelayMs !== 'number' || !Number.isInteger(s.retryDelayMs) || s.retryDelayMs < 0) {
+      throw new RoutineValidationError('Schedule "retryDelayMs" must be a non-negative integer', { source, got: s.retryDelayMs });
+    }
+  }
+
+  // Validate concurrency
+  if (s.concurrency !== undefined) {
+    if (s.concurrency !== 'skip' && s.concurrency !== 'queue') {
+      throw new RoutineValidationError('Schedule "concurrency" must be "skip" or "queue"', { source, got: s.concurrency });
+    }
+  }
+
+  return s as RoutineSchedule;
+}
+
 function validateRoutineDefinition(value: unknown, source?: string): RoutineDefinition {
   if (!value || typeof value !== 'object') {
     throw new RoutineValidationError('Routine must be an object', { source });
@@ -155,6 +252,11 @@ function validateRoutineDefinition(value: unknown, source?: string): RoutineDefi
     throw new RoutineValidationError('Invalid or missing "name"', { source, got: obj.name });
   }
 
+  // Validate schedule if present
+  if (obj.schedule !== undefined) {
+    validateScheduleConfig(obj.schedule, source);
+  }
+
   if (!Array.isArray(obj.steps)) {
     throw new RoutineValidationError('Invalid or missing "steps" (must be an array)', { source });
   }
@@ -255,7 +357,7 @@ function validateRoutineDefinition(value: unknown, source?: string): RoutineDefi
     }
   }
 
-  return obj as RoutineDefinition;
+  return obj as unknown as RoutineDefinition;
 }
 
 function getPath(root: unknown, segments: string[]): unknown {