@crewx/cron 0.1.10-rc.13 → 0.1.10-rc.130

package/dist/src/engine.js

@@ -33,13 +33,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DATA_PATHS = void 0;
+exports.DATA_PATHS = exports.getProjectRoot = exports.BUILTIN_SCHEDULES = void 0;
 exports.getLocalTimestamp = getLocalTimestamp;
 exports.logUsage = logUsage;
-exports.getProjectRoot = getProjectRoot;
 exports.normalizeMode = normalizeMode;
 exports.loadSchedules = loadSchedules;
 exports.saveSchedules = saveSchedules;
+exports.getRemovedBuiltins = getRemovedBuiltins;
+exports.seedBuiltinSchedules = seedBuiltinSchedules;
 exports.acquireLock = acquireLock;
 exports.releaseLock = releaseLock;
 exports.shouldRunNow = shouldRunNow;
@@ -48,6 +49,7 @@ exports.calculateNextRun = calculateNextRun;
 exports.isDaemonRunning = isDaemonRunning;
 exports.startDaemon = startDaemon;
 exports.stopDaemon = stopDaemon;
+exports.startDaemonSafe = startDaemonSafe;
 exports.ensureDaemonRunning = ensureDaemonRunning;
 exports.getDaemonStatus = getDaemonStatus;
 exports.executeSchedule = executeSchedule;
@@ -62,12 +64,16 @@ const child_process_1 = require("child_process");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const sdk_1 = require("@crewx/sdk");
+const builtins_1 = require("./builtins");
+Object.defineProperty(exports, "BUILTIN_SCHEDULES", { enumerable: true, get: function () { return builtins_1.BUILTIN_SCHEDULES; } });
+Object.defineProperty(exports, "getProjectRoot", { enumerable: true, get: function () { return builtins_1.getProjectRoot; } });
 const DATA_DIR = path.join(process.cwd(), '.crewx');
 const SCHEDULES_FILE = path.join(DATA_DIR, '.cron-data.json');
 const LOG_FILE = path.join(DATA_DIR, '.cron-daemon.log');
 const LOCK_FILE = path.join(DATA_DIR, '.cron-data.json.lock');
 const USAGE_LOG_FILE = path.join(DATA_DIR, 'cron-usage.log');
 const PID_FILE = path.join(DATA_DIR, '.cron-daemon.pid');
+const BUILTINS_META_FILE = path.join(DATA_DIR, '.cron-builtins.json');
 function resolveDataDir(dir) {
     return dir ? path.join(dir, '.crewx') : DATA_DIR;
 }
@@ -77,8 +83,14 @@ function resolveSchedulesFile(dir) {
 function resolvePidFile(dir) {
     return path.join(resolveDataDir(dir), '.cron-daemon.pid');
 }
+function resolveBuiltinsMetaFile(dir) {
+    return path.join(resolveDataDir(dir), '.cron-builtins.json');
+}
+function resolveRunLockFile(scheduleId, dir) {
+    return path.join(resolveDataDir(dir), `.cron-run-${scheduleId}.lock`);
+}
 const DAEMON_INTERVAL_MS = 60 * 1000;
-const runningSchedules = new Set();
+const RUN_LOCK_STALE_GRACE_MS = 5000;
 function getLocalTimestamp() {
     const now = new Date();
     const y = now.getFullYear();
@@ -110,27 +122,16 @@ function safeReadJsonFile(filePath) {
         return null;
     }
 }
-function getProjectRoot() {
-    try {
-        return (0, child_process_1.execSync)('git rev-parse --show-toplevel', { encoding: 'utf8' }).trim();
-    }
-    catch {
-        return process.cwd();
-    }
-}
-function getBuiltinMemoryCliPath() {
-    return path.join(getProjectRoot(), 'packages', 'built-in', 'memory', 'dist', 'cli.js');
-}
+const MEMORY_DEBOUNCE_BUILTIN = (0, builtins_1.findBuiltinById)('memory-debounce');
 function maybeRewriteLegacyMemoryCommand(command) {
     if (!command.includes('/skills/memory-v2/memory-v2.js')) {
         return command;
     }
-    const builtinMemoryCli = getBuiltinMemoryCliPath();
-    return `node ${builtinMemoryCli} summarize-dirty`;
+    return MEMORY_DEBOUNCE_BUILTIN.buildCommand();
 }
 function migrateLegacyMemoryDebounceSchedule() {
     ensureDataDir();
-    const legacyFile = path.join(getProjectRoot(), 'skills', 'cron', '.cron-data.json');
+    const legacyFile = path.join((0, builtins_1.getProjectRoot)(), 'skills', 'cron', '.cron-data.json');
     if (!fs.existsSync(legacyFile)) {
         return;
     }
@@ -138,12 +139,12 @@ function migrateLegacyMemoryDebounceSchedule() {
     if (!Array.isArray(legacySchedules)) {
         return;
     }
-    const legacySchedule = legacySchedules.find(s => s.name === 'memory-debounce');
+    const legacySchedule = legacySchedules.find(s => s.name === MEMORY_DEBOUNCE_BUILTIN.name);
     if (!legacySchedule) {
         return;
     }
     const targetSchedules = fs.existsSync(SCHEDULES_FILE) ? safeReadJsonFile(SCHEDULES_FILE) ?? [] : [];
-    if (targetSchedules.some(s => s.name === 'memory-debounce')) {
+    if (targetSchedules.some(s => s.name === MEMORY_DEBOUNCE_BUILTIN.name)) {
         return;
     }
     const migratedSchedule = {
@@ -154,6 +155,11 @@ function migrateLegacyMemoryDebounceSchedule() {
     };
     saveSchedules([...targetSchedules, migratedSchedule]);
 }
+function warnIfOverdriveInCommand(command) {
+    if (command.includes('--overdrive')) {
+        console.warn('warning: --overdrive in cron command is ignored and may silently override --model');
+    }
+}
 function normalizeMode(mode) {
     if (mode === 'query')
         return 'query';
@@ -187,6 +193,61 @@ function saveSchedules(schedules, dir) {
     fs.writeFileSync(tempFile, JSON.stringify(schedules, null, 2));
     fs.renameSync(tempFile, schedulesFile);
 }
+function loadBuiltinsMeta(dir) {
+    const data = safeReadJsonFile(resolveBuiltinsMetaFile(dir));
+    return { removed_builtins: Array.isArray(data?.removed_builtins) ? data.removed_builtins : [] };
+}
+function saveBuiltinsMeta(meta, dir) {
+    ensureDataDir(dir);
+    const metaFile = resolveBuiltinsMetaFile(dir);
+    const tempFile = `${metaFile}.tmp`;
+    fs.writeFileSync(tempFile, JSON.stringify(meta, null, 2));
+    fs.renameSync(tempFile, metaFile);
+}
+function getRemovedBuiltins(dir) {
+    return loadBuiltinsMeta(dir).removed_builtins;
+}
+function recordRemovedBuiltin(builtinId, dir) {
+    const meta = loadBuiltinsMeta(dir);
+    if (!meta.removed_builtins.includes(builtinId)) {
+        meta.removed_builtins.push(builtinId);
+        saveBuiltinsMeta(meta, dir);
+    }
+}
+function seedBuiltinSchedules(dir) {
+    const schedules = loadSchedules(dir);
+    const existingNames = new Set(schedules.map(s => s.name));
+    const removedBuiltins = new Set(getRemovedBuiltins(dir));
+    const seeded = [];
+    for (const def of builtins_1.BUILTIN_SCHEDULES) {
+        if (existingNames.has(def.name))
+            continue;
+        if (removedBuiltins.has(def.builtin_id))
+            continue;
+        const now = new Date().toISOString();
+        schedules.push({
+            id: (0, sdk_1.generateId)('cron'),
+            cron: def.cron,
+            command: def.buildCommand(),
+            mode: def.mode,
+            enabled: true,
+            name: def.name,
+            working_directory: null,
+            timezone: null,
+            timeout_ms: 600000,
+            allow_concurrent: false,
+            created_at: now,
+            updated_at: now,
+            run_count: 0,
+            next_run: calculateNextRun(def.cron, null),
+        });
+        seeded.push(def.builtin_id);
+    }
+    if (seeded.length > 0) {
+        saveSchedules(schedules, dir);
+    }
+    return seeded;
+}
 async function acquireLock(timeout = 5000) {
     ensureDataDir();
     const startTime = Date.now();
@@ -224,6 +285,58 @@ function releaseLock() {
     catch {
     }
 }
+function readRunLease(lockFile) {
+    return safeReadJsonFile(lockFile);
+}
+function acquireRunLock(scheduleId, taskId, timeoutMs, dir) {
+    ensureDataDir(dir);
+    const lockFile = resolveRunLockFile(scheduleId, dir);
+    const lease = { pid: process.pid, taskId, startedAt: new Date().toISOString() };
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            fs.writeFileSync(lockFile, JSON.stringify(lease), { flag: 'wx' });
+            return { acquired: true };
+        }
+        catch (e) {
+            const err = e;
+            if (err.code !== 'EEXIST')
+                throw err;
+            const existing = readRunLease(lockFile);
+            if (!existing) {
+                try {
+                    fs.unlinkSync(lockFile);
+                }
+                catch { }
+                continue;
+            }
+            let ageMs;
+            try {
+                ageMs = Date.now() - fs.statSync(lockFile).mtimeMs;
+            }
+            catch {
+                continue;
+            }
+            const stale = !isPidAlive(existing.pid) || ageMs > timeoutMs + RUN_LOCK_STALE_GRACE_MS;
+            if (stale) {
+                try {
+                    fs.unlinkSync(lockFile);
+                }
+                catch { }
+                continue;
+            }
+            return { acquired: false, runningTaskId: existing.taskId };
+        }
+    }
+    const existing = readRunLease(lockFile);
+    return { acquired: false, runningTaskId: existing?.taskId ?? taskId };
+}
+function releaseRunLock(scheduleId, dir) {
+    try {
+        fs.unlinkSync(resolveRunLockFile(scheduleId, dir));
+    }
+    catch {
+    }
+}
 const DAY_NAMES = {
     SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6,
 };
@@ -452,8 +565,10 @@ function calculateNextRun(cronExpr, timezone) {
 function readDaemonPid(dir) {
     try {
         const raw = fs.readFileSync(resolvePidFile(dir), 'utf8').trim();
-        const pid = Number.parseInt(raw, 10);
-        return Number.isInteger(pid) && pid > 0 ? pid : null;
+        if (!/^\d+$/.test(raw))
+            return null;
+        const pid = Number(raw);
+        return Number.isSafeInteger(pid) && pid > 0 ? pid : null;
     }
     catch {
         return null;
@@ -476,40 +591,105 @@ function isPidAlive(pid) {
         return true;
     }
     catch (e) {
-        const err = e;
-        if (err.code === 'EPERM')
-            return true;
-        return false;
+        const error = e;
+        return error.code === 'ESRCH' ? false : 'unknown';
     }
 }
-function getDaemonCliPath() {
-    const distCli = path.join(__dirname, '..', 'cli.js');
-    if (fs.existsSync(distCli)) {
-        return distCli;
+function getProcessCommandLine(pid) {
+    try {
+        const output = process.platform === 'win32'
+            ? (0, child_process_1.execFileSync)('powershell.exe', [
+                '-NoLogo',
+                '-NoProfile',
+                '-NonInteractive',
+                '-Command',
+                `(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").CommandLine`,
+            ], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
+            : (0, child_process_1.execFileSync)('ps', ['-ww', '-p', String(pid), '-o', 'command='], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+        return output.trim() || null;
+    }
+    catch {
+        return null;
     }
-    throw new Error(`Cron CLI entrypoint not found: ${distCli}`);
 }
-function isDaemonRunning(dir) {
+const DEFAULT_DAEMON_PROCESS_PROBE = {
+    isAlive: isPidAlive,
+    getCommandLine: getProcessCommandLine,
+};
+function normalizeCommandLine(value) {
+    const normalized = value.replace(/\\/g, '/');
+    return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+function getDaemonCliPathTail() {
+    try {
+        const segments = normalizeCommandLine(getDaemonCliPath()).split('/').filter(Boolean);
+        const tail = segments.slice(-3).join('/');
+        return tail || null;
+    }
+    catch {
+        return null;
+    }
+}
+function classifyDaemonIdentity(commandLine) {
+    if (!commandLine?.trim())
+        return 'unknown';
+    const cliPathTail = getDaemonCliPathTail();
+    if (!cliPathTail)
+        return 'unknown';
+    const normalizedCommandLine = normalizeCommandLine(commandLine);
+    return normalizedCommandLine.includes('daemon --foreground')
+        && normalizedCommandLine.includes(cliPathTail)
+        ? 'running'
+        : 'stale';
+}
+function getDaemonCliPath() {
+    const candidates = [
+        path.join(__dirname, '..', 'cli.js'),
+        path.join(__dirname, '..', 'dist', 'cli.js'),
+    ];
+    const cliPath = candidates.find(candidate => fs.existsSync(candidate));
+    if (cliPath) {
+        return cliPath;
+    }
+    throw new Error(`Cron CLI entrypoint not found: ${candidates[0]}`);
+}
+function inspectDaemon(dir, probe = DEFAULT_DAEMON_PROCESS_PROBE) {
     const pid = readDaemonPid(dir);
     if (!pid) {
-        return false;
+        removeDaemonPidFile(dir);
+        return 'stale';
+    }
+    let alive;
+    try {
+        alive = probe.isAlive(pid);
+    }
+    catch {
+        alive = 'unknown';
     }
-    const alive = isPidAlive(pid);
     if (!alive) {
         removeDaemonPidFile(dir);
+        return 'stale';
     }
-    return alive;
-}
-function startDaemon(dir) {
-    if (isDaemonRunning(dir)) {
-        const pid = readDaemonPid(dir);
-        if (pid)
-            return pid;
-        throw new Error('Daemon is already running');
+    let commandLine;
+    try {
+        commandLine = probe.getCommandLine(pid);
+    }
+    catch {
+        return 'unknown';
+    }
+    const liveness = classifyDaemonIdentity(commandLine);
+    if (liveness === 'stale') {
+        removeDaemonPidFile(dir);
     }
+    return liveness;
+}
+function isDaemonRunning(dir, probe = DEFAULT_DAEMON_PROCESS_PROBE) {
+    return inspectDaemon(dir, probe) === 'running';
+}
+function spawnDaemon(dir, spawnImpl = child_process_1.spawn) {
     ensureDataDir(dir);
     const cliPath = getDaemonCliPath();
-    const child = (0, child_process_1.spawn)('node', [cliPath, 'daemon', '--foreground'], {
+    const child = spawnImpl('node', [cliPath, 'daemon', '--foreground'], {
         cwd: dir || undefined,
         detached: true,
         stdio: 'ignore',
@@ -522,37 +702,64 @@ function startDaemon(dir) {
     writeDaemonPid(child.pid, dir);
     return child.pid;
 }
-function stopDaemon(dir) {
-    const pid = readDaemonPid(dir);
-    if (!pid) {
-        removeDaemonPidFile(dir);
-        return false;
+function startDaemon(dir, probe = DEFAULT_DAEMON_PROCESS_PROBE) {
+    const liveness = inspectDaemon(dir, probe);
+    if (liveness === 'running') {
+        const pid = readDaemonPid(dir);
+        if (pid)
+            return pid;
+        throw new Error('Daemon is already running');
     }
-    if (!isPidAlive(pid)) {
-        removeDaemonPidFile(dir);
-        return false;
+    if (liveness === 'unknown') {
+        const pid = readDaemonPid(dir);
+        throw new Error(`Unable to determine cron daemon liveness (pid=${pid ?? 'unknown'}, pidFile=${resolvePidFile(dir)}); refusing to start`);
     }
+    return spawnDaemon(dir, probe.spawnImpl);
+}
+function stopDaemon(dir, probe = DEFAULT_DAEMON_PROCESS_PROBE) {
+    if (inspectDaemon(dir, probe) !== 'running')
+        return false;
+    const pid = readDaemonPid(dir);
+    if (!pid)
+        return false;
     process.kill(pid, 'SIGTERM');
     return true;
 }
-function ensureDaemonRunning(dir) {
-    if (isDaemonRunning(dir))
-        return;
-    console.log('⚡ cron 데몬이 꺼져 있어서 자동 시작합니다...');
+function startDaemonSafe(dir, probe = DEFAULT_DAEMON_PROCESS_PROBE) {
+    const liveness = inspectDaemon(dir, probe);
+    if (liveness === 'running') {
+        return { started: false };
+    }
+    if (liveness === 'unknown') {
+        return {
+            started: false,
+            error: `Unable to determine cron daemon liveness (pid=${readDaemonPid(dir) ?? 'unknown'}, pidFile=${resolvePidFile(dir)}); refusing to start`,
+        };
+    }
     try {
-        startDaemon(dir);
+        const pid = spawnDaemon(dir, probe.spawnImpl);
+        return { started: true, pid };
     }
     catch (e) {
         const err = e;
-        console.error('Failed to auto-start daemon:', err.message);
+        return { started: false, error: err.message };
+    }
+}
+function ensureDaemonRunning(dir, probe = DEFAULT_DAEMON_PROCESS_PROBE) {
+    if (isDaemonRunning(dir, probe))
+        return;
+    console.log('⚡ Cron daemon is not running; starting it automatically...');
+    const result = startDaemonSafe(dir, probe);
+    if (!result.started) {
+        console.error('Failed to auto-start daemon:', result.error);
         process.exit(1);
     }
 }
 function getDaemonStatus(dir) {
     const schedules = loadSchedules(dir);
     const enabled = schedules.filter(s => s.enabled).length;
-    const pid = readDaemonPid(dir);
-    const running = pid !== null && isDaemonRunning(dir);
+    const running = isDaemonRunning(dir);
+    const pid = running ? readDaemonPid(dir) : null;
     let started_at = null;
     const pidFile = resolvePidFile(dir);
     if (running && fs.existsSync(pidFile)) {
@@ -573,33 +780,93 @@ function getDaemonStatus(dir) {
         },
     };
 }
-async function executeSchedule(schedule, dir) {
-    if (!schedule.allow_concurrent && runningSchedules.has(schedule.id)) {
-        console.log(`[${getLocalTimestamp()}] Schedule ${schedule.id} already running, skipping`);
-        return { success: false, error: 'Already running' };
+async function executeSchedule(schedule, options) {
+    const dir = options?.dir;
+    const trigger = options?.trigger ?? 'cron';
+    const timeoutMs = schedule.timeout_ms || 600000;
+    const taskId = (0, sdk_1.generateId)('tsk');
+    if (!schedule.allow_concurrent) {
+        const lock = acquireRunLock(schedule.id, taskId, timeoutMs, dir);
+        if (!lock.acquired) {
+            console.log(`[${getLocalTimestamp()}] Schedule ${schedule.id} already running (task ${lock.runningTaskId}), skipping`);
+            return { status: 'conflict', runningTaskId: lock.runningTaskId };
+        }
     }
-    runningSchedules.add(schedule.id);
-    const workingDir = schedule.working_directory || getProjectRoot();
+    const workingDir = schedule.working_directory || options?.dir || (0, builtins_1.getProjectRoot)();
     const mode = schedule.mode;
     const modeFlag = mode === 'execute' ? 'x' : 'q';
-    console.log(`[${getLocalTimestamp()}] Executing schedule ${schedule.id}: ${schedule.name ?? schedule.cron}`);
+    const effectiveModel = options?.overrides?.model ?? schedule.model;
+    console.log(`[${getLocalTimestamp()}] Executing schedule ${schedule.id}: ${schedule.name ?? schedule.cron} (task ${taskId})`);
     console.log(`[${getLocalTimestamp()}] Command: ${schedule.command}`);
-    return new Promise((resolve) => {
-        const env = { ...process.env, ...schedule.env };
-        delete env['CLAUDECODE'];
-        const child = mode === 'command'
-            ? (0, child_process_1.spawn)('sh', ['-c', schedule.command], {
+    const releaseLease = () => {
+        if (!schedule.allow_concurrent)
+            releaseRunLock(schedule.id, dir);
+    };
+    const env = (0, sdk_1.withoutCrewxRootContext)({ ...process.env, ...schedule.env, CREWX_TRACE_ID: taskId });
+    delete env['CLAUDECODE'];
+    if (!schedule.env || !('CREWX_CONFIG' in schedule.env)) {
+        delete env['CREWX_CONFIG'];
+    }
+    env['CREWX_WORKSPACE'] = workingDir;
+    const cliArgs = [modeFlag, schedule.command];
+    if (effectiveModel) {
+        cliArgs.push('--model', effectiveModel);
+    }
+    cliArgs.push('--metadata', JSON.stringify({ trigger, schedule_id: schedule.id }));
+    let child;
+    try {
+        if (mode === 'command') {
+            child = (0, child_process_1.spawn)('sh', ['-c', schedule.command], {
                 cwd: workingDir,
-                stdio: 'inherit',
+                stdio: 'ignore',
                 windowsHide: true,
+                detached: true,
                 env,
-            })
-            : (0, child_process_1.spawn)('crewx', [modeFlag, schedule.command], {
+            });
+        }
+        else {
+            const resolution = (0, sdk_1.resolveCrewxExecutable)({ env, cwd: workingDir });
+            if (!resolution.ok) {
+                const error = new Error((0, sdk_1.formatCrewxExecutableFailure)(resolution));
+                Object.assign(error, { code: 'CLI_UNRESOLVABLE' });
+                throw error;
+            }
+            const childEnv = {
+                ...env,
+                CREWX_CLI_ARGV: JSON.stringify(resolution.argv),
+            };
+            const program = (0, sdk_1.resolveWindowsSpawnProgram)({
+                command: resolution.argv[0],
+                env: childEnv,
                 cwd: workingDir,
-                stdio: 'inherit',
-                windowsHide: true,
-                env,
+                packageName: 'crewx',
             });
+            const invocation = (0, sdk_1.materializeWindowsSpawnProgram)(program, [
+                ...resolution.argv.slice(1),
+                ...cliArgs,
+            ]);
+            child = (0, child_process_1.spawn)(invocation.command, invocation.argv, {
+                cwd: workingDir,
+                stdio: 'ignore',
+                windowsHide: invocation.windowsHide,
+                detached: true,
+                env: childEnv,
+                shell: invocation.shell ?? false,
+            });
+        }
+        await new Promise((resolve, reject) => {
+            child.once('spawn', () => resolve());
+            child.once('error', (err) => reject(err));
+        });
+    }
+    catch (e) {
+        const err = e;
+        console.error(`[${getLocalTimestamp()}] Schedule ${schedule.id} failed to spawn: ${err.message}`);
+        releaseLease();
+        throw err;
+    }
+    child.unref();
+    const done = new Promise((resolve) => {
         const timeout = setTimeout(() => {
             console.log(`[${getLocalTimestamp()}] Schedule ${schedule.id} timeout, killing process`);
             try {
@@ -609,12 +876,12 @@ async function executeSchedule(schedule, dir) {
                 const err = e;
                 console.error(`Failed to kill process: ${err.message}`);
             }
-            runningSchedules.delete(schedule.id);
+            releaseLease();
             resolve({ success: false, error: 'Timeout' });
-        }, schedule.timeout_ms || 600000);
+        }, timeoutMs);
         child.on('close', (code) => {
             clearTimeout(timeout);
-            runningSchedules.delete(schedule.id);
+            releaseLease();
             const schedules = loadSchedules(dir);
             const idx = schedules.findIndex(s => s.id === schedule.id);
             if (idx !== -1) {
@@ -635,11 +902,12 @@ async function executeSchedule(schedule, dir) {
         });
         child.on('error', (err) => {
             clearTimeout(timeout);
-            runningSchedules.delete(schedule.id);
+            releaseLease();
             console.error(`[${getLocalTimestamp()}] Schedule ${schedule.id} error: ${err.message}`);
             resolve({ success: false, error: err.message });
         });
     });
+    return { status: 'running', taskId, done };
 }
 function getLocalMinuteKey(now, timezone) {
     if (!timezone || !isValidTimezone(timezone)) {
@@ -668,7 +936,16 @@ async function daemonTick(dir) {
                     continue;
                 }
             }
-            await executeSchedule(schedule, dir);
+            try {
+                const outcome = await executeSchedule(schedule, { dir });
+                if (outcome.status === 'running') {
+                    await outcome.done;
+                }
+            }
+            catch (e) {
+                const err = e;
+                console.error(`[${getLocalTimestamp()}] Schedule ${schedule.id} failed to spawn: ${err.message}`);
+            }
         }
     }
 }
@@ -708,6 +985,7 @@ function addSchedule(cron, command, options, dataDir) {
     if (options.timezone && !isValidTimezone(options.timezone)) {
         throw new Error(`Invalid timezone: ${options.timezone}`);
     }
+    warnIfOverdriveInCommand(command);
     const schedule = {
         id: (0, sdk_1.generateId)('cron'),
         cron,
@@ -723,6 +1001,9 @@ function addSchedule(cron, command, options, dataDir) {
         updated_at: new Date().toISOString(),
         run_count: 0,
     };
+    if (options.model) {
+        schedule.model = options.model;
+    }
     schedule.next_run = calculateNextRun(cron, schedule.timezone);
     const schedules = loadSchedules(dataDir);
     schedules.push(schedule);
@@ -737,6 +1018,10 @@ function removeSchedule(id, dir) {
     }
     const removed = schedules.splice(idx, 1)[0];
     saveSchedules(schedules, dir);
+    const matchedBuiltin = (0, builtins_1.findBuiltinByName)(removed.name);
+    if (matchedBuiltin) {
+        recordRemovedBuiltin(matchedBuiltin.builtin_id, dir);
+    }
     return removed;
 }
 function enableSchedule(id, dir) {
@@ -777,6 +1062,7 @@ function updateSchedule(id, options, dir) {
         changes.push(`cron: ${options.cron}`);
     }
     if (options.command !== undefined) {
+        warnIfOverdriveInCommand(options.command);
         schedule.command = options.command;
         changes.push(`command: ${options.command}`);
     }
@@ -804,6 +1090,16 @@ function updateSchedule(id, options, dir) {
         schedule.allow_concurrent = options.allow_concurrent;
         changes.push(`allow_concurrent: ${options.allow_concurrent}`);
     }
+    if (options.model !== undefined) {
+        if (options.model === null) {
+            delete schedule.model;
+            changes.push('model: (cleared, reverts to agent default)');
+        }
+        else {
+            schedule.model = options.model;
+            changes.push(`model: ${options.model}`);
+        }
+    }
     schedule.updated_at = new Date().toISOString();
     schedule.next_run = calculateNextRun(schedule.cron, schedule.timezone);
     saveSchedules(schedules, dir);
@@ -815,5 +1111,6 @@ exports.DATA_PATHS = {
     LOG_FILE,
     USAGE_LOG_FILE,
     PID_FILE,
+    BUILTINS_META_FILE,
 };
 //# sourceMappingURL=engine.js.map