@crewx/cron 0.1.10-rc.18 → 0.1.10-rc.180

package/dist/src/engine.js

@@ -33,24 +33,33 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DATA_PATHS = void 0;
+exports.DATA_PATHS = exports.CRON_RUNTIME_PROCESS_LEASE_FILENAME = exports.createCronRuntime = exports.getProjectRoot = exports.BUILTIN_SCHEDULES = exports.CronStoreError = void 0;
 exports.getLocalTimestamp = getLocalTimestamp;
 exports.logUsage = logUsage;
-exports.getProjectRoot = getProjectRoot;
+exports.acquireWorkspaceLock = acquireWorkspaceLock;
+exports.releaseWorkspaceLock = releaseWorkspaceLock;
+exports.migrateLegacyMemoryDebounceSchedule = migrateLegacyMemoryDebounceSchedule;
 exports.normalizeMode = normalizeMode;
+exports.createScheduleStore = createScheduleStore;
 exports.loadSchedules = loadSchedules;
 exports.saveSchedules = saveSchedules;
+exports.getRemovedBuiltins = getRemovedBuiltins;
+exports.seedBuiltinSchedules = seedBuiltinSchedules;
 exports.acquireLock = acquireLock;
 exports.releaseLock = releaseLock;
+exports.releaseRunLock = releaseRunLock;
 exports.shouldRunNow = shouldRunNow;
 exports.describeCron = describeCron;
 exports.calculateNextRun = calculateNextRun;
 exports.isDaemonRunning = isDaemonRunning;
 exports.startDaemon = startDaemon;
 exports.stopDaemon = stopDaemon;
+exports.startDaemonSafe = startDaemonSafe;
 exports.ensureDaemonRunning = ensureDaemonRunning;
 exports.getDaemonStatus = getDaemonStatus;
 exports.executeSchedule = executeSchedule;
+exports.getLocalMinuteKey = getLocalMinuteKey;
+exports.buildOccurrenceKey = buildOccurrenceKey;
 exports.daemonTick = daemonTick;
 exports.runDaemonForeground = runDaemonForeground;
 exports.addSchedule = addSchedule;
@@ -59,26 +68,59 @@ exports.enableSchedule = enableSchedule;
 exports.disableSchedule = disableSchedule;
 exports.updateSchedule = updateSchedule;
 const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
+const types_1 = require("./types");
+Object.defineProperty(exports, "CronStoreError", { enumerable: true, get: function () { return types_1.CronStoreError; } });
 const sdk_1 = require("@crewx/sdk");
-const DATA_DIR = path.join(process.cwd(), '.crewx');
+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 DEFAULT_WORKSPACE_PATH = path.resolve(process.cwd());
+const DATA_DIR = path.join(DEFAULT_WORKSPACE_PATH, '.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;
+    return path.join(path.resolve(dir ?? DEFAULT_WORKSPACE_PATH), '.crewx');
 }
 function resolveSchedulesFile(dir) {
     return path.join(resolveDataDir(dir), '.cron-data.json');
 }
+function resolveLockFile(dir) {
+    return path.join(resolveDataDir(dir), '.cron-data.json.lock');
+}
+function resolveUsageLogFile(dir) {
+    return path.join(resolveDataDir(dir), 'cron-usage.log');
+}
 function resolvePidFile(dir) {
     return path.join(resolveDataDir(dir), '.cron-daemon.pid');
 }
+function resolveBuiltinsMetaFile(dir) {
+    return path.join(resolveDataDir(dir), '.cron-builtins.json');
+}
+function reserveAdmission(taskId, scheduleId, timeoutMs) {
+    const reserved = (0, sdk_1.reserveUpdateAdmission)(taskId, scheduleId, timeoutMs);
+    if (!reserved) {
+        console.error(`[${getLocalTimestamp()}] Failed to record update-admission reservation for task ${taskId}`);
+    }
+    return reserved;
+}
+function releaseAdmissionReservation(taskId) {
+    (0, sdk_1.releaseUpdateAdmissionReservation)(taskId);
+}
+function resolveRunLockFile(scheduleId, dir) {
+    return path.join(resolveDataDir(dir), `.cron-run-${scheduleId}.lock`);
+}
 const DAEMON_INTERVAL_MS = 60 * 1000;
-const runningSchedules = new Set();
+const STORE_LOCK_TIMEOUT_MS = 5000;
+const STORE_LOCK_POLL_MS = 25;
+const STORE_LOCK_STALE_MS = 30000;
+const RUN_LOCK_STALE_GRACE_MS = 5000;
 function getLocalTimestamp() {
     const now = new Date();
     const y = now.getFullYear();
@@ -89,12 +131,45 @@ function getLocalTimestamp() {
     const s = String(now.getSeconds()).padStart(2, '0');
     return `${y}-${m}-${d} ${h}:${min}:${s}`;
 }
-function logUsage(...args) {
-    ensureDataDir();
+function logUsage(dirOrMessage, ...args) {
+    const isWorkspacePath = (value) => value !== undefined && (value === '.' ||
+        value === '..' ||
+        path.isAbsolute(value) ||
+        value.includes(path.sep) ||
+        value.includes('/') ||
+        value.includes('\\') ||
+        value.endsWith('.crewx') ||
+        (() => {
+            try {
+                return fs.statSync(value).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        })());
+    let workspacePath;
+    let messageParts;
+    if (args.length > 0 && (dirOrMessage === undefined || isWorkspacePath(dirOrMessage))) {
+        workspacePath = dirOrMessage;
+        messageParts = args;
+    }
+    else if (args.length === 0 && isWorkspacePath(dirOrMessage)) {
+        workspacePath = dirOrMessage;
+        messageParts = [];
+    }
+    else if (args.length === 1 && isWorkspacePath(args[0])) {
+        workspacePath = args[0];
+        messageParts = dirOrMessage === undefined ? [] : [dirOrMessage];
+    }
+    else {
+        workspacePath = undefined;
+        messageParts = dirOrMessage === undefined ? args : [dirOrMessage, ...args];
+    }
+    ensureDataDir(workspacePath);
     const timestamp = getLocalTimestamp();
-    const message = args.join(' ');
+    const message = messageParts.join(' ');
     const logLine = `${timestamp} | [cron] ${message}\n`;
-    fs.appendFileSync(USAGE_LOG_FILE, logLine);
+    fs.appendFileSync(resolveUsageLogFile(workspacePath), logLine);
 }
 function ensureDataDir(dir) {
     const dataDir = resolveDataDir(dir);
@@ -110,27 +185,86 @@ function safeReadJsonFile(filePath) {
         return null;
     }
 }
-function getProjectRoot() {
+const STORE_LOCK_WAIT_BUFFER = new Int32Array(new SharedArrayBuffer(4));
+function waitForStoreLock() {
+    Atomics.wait(STORE_LOCK_WAIT_BUFFER, 0, 0, STORE_LOCK_POLL_MS);
+}
+function readStoreLock(lockPath) {
     try {
-        return (0, child_process_1.execSync)('git rev-parse --show-toplevel', { encoding: 'utf8' }).trim();
+        const parsed = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+        if (typeof parsed.token !== 'string' ||
+            typeof parsed.pid !== 'number' ||
+            typeof parsed.created_at !== 'number') {
+            return null;
+        }
+        return parsed;
     }
     catch {
-        return process.cwd();
+        return null;
     }
 }
-function getBuiltinMemoryCliPath() {
-    return path.join(getProjectRoot(), 'packages', 'built-in', 'memory', 'dist', 'cli.js');
+function acquireWorkspaceLock(workspacePath, timeout = STORE_LOCK_TIMEOUT_MS) {
+    const normalizedWorkspacePath = path.resolve(workspacePath);
+    ensureDataDir(normalizedWorkspacePath);
+    const lockPath = resolveLockFile(normalizedWorkspacePath);
+    const token = (0, crypto_1.randomUUID)();
+    const deadline = Date.now() + Math.max(0, timeout);
+    const owner = {
+        workspacePath: normalizedWorkspacePath,
+        lockPath,
+        token,
+    };
+    while (true) {
+        const payload = {
+            token,
+            pid: process.pid,
+            created_at: Date.now(),
+        };
+        try {
+            fs.writeFileSync(lockPath, JSON.stringify(payload), { flag: 'wx', mode: 0o600 });
+            return owner;
+        }
+        catch (error) {
+            const err = error;
+            if (err.code !== 'EEXIST')
+                throw error;
+            const existing = readStoreLock(lockPath);
+            if (existing && Date.now() - existing.created_at > STORE_LOCK_STALE_MS) {
+                releaseWorkspaceLock({ ...owner, token: existing.token });
+                continue;
+            }
+            if (Date.now() >= deadline) {
+                throw new types_1.CronStoreError('CRON_STORE_LOCK_TIMEOUT', `Timed out waiting for cron store lock: ${lockPath}`, lockPath);
+            }
+            waitForStoreLock();
+        }
+    }
 }
+function releaseWorkspaceLock(owner) {
+    const current = readStoreLock(owner.lockPath);
+    if (!current || current.token !== owner.token)
+        return false;
+    try {
+        fs.unlinkSync(owner.lockPath);
+        return true;
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+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');
+function migrateLegacyMemoryDebounceSchedule(workspacePath = (0, builtins_1.getProjectRoot)()) {
+    const normalizedWorkspacePath = path.resolve(workspacePath);
+    const legacyFile = path.join(normalizedWorkspacePath, 'skills', 'cron', '.cron-data.json');
     if (!fs.existsSync(legacyFile)) {
         return;
     }
@@ -138,12 +272,13 @@ 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')) {
+    const store = createScheduleStore(normalizedWorkspacePath);
+    const targetSchedules = store.list();
+    if (targetSchedules.some(s => s.name === MEMORY_DEBOUNCE_BUILTIN.name)) {
         return;
     }
     const migratedSchedule = {
@@ -152,7 +287,12 @@ function migrateLegacyMemoryDebounceSchedule() {
         updated_at: new Date().toISOString(),
         next_run: calculateNextRun(legacySchedule.cron, legacySchedule.timezone),
     };
-    saveSchedules([...targetSchedules, migratedSchedule]);
+    store.create(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')
@@ -161,69 +301,506 @@ function normalizeMode(mode) {
         return 'command';
     return 'execute';
 }
-function loadSchedules(dir) {
-    ensureDataDir(dir);
-    if (!dir) {
-        migrateLegacyMemoryDebounceSchedule();
+function cloneSchedule(schedule) {
+    return {
+        ...schedule,
+        ...(schedule.env ? { env: { ...schedule.env } } : {}),
+    };
+}
+function readSchedulesFile(schedulesFile) {
+    let data;
+    try {
+        data = fs.readFileSync(schedulesFile, 'utf8');
     }
-    const schedulesFile = resolveSchedulesFile(dir);
-    if (!fs.existsSync(schedulesFile)) {
-        return [];
+    catch (error) {
+        const err = error;
+        if (err.code === 'ENOENT')
+            return [];
+        throw error;
     }
+    let parsed;
     try {
-        const data = fs.readFileSync(schedulesFile, 'utf8');
-        return JSON.parse(data);
+        parsed = JSON.parse(data);
     }
-    catch (e) {
-        const err = e;
-        console.error('Failed to load schedules:', err.message);
-        return [];
+    catch (error) {
+        throw new types_1.CronStoreError('CRON_STORE_CORRUPT', `Cron schedule store is not valid JSON: ${schedulesFile}`, schedulesFile);
     }
+    if (!Array.isArray(parsed)) {
+        throw new types_1.CronStoreError('CRON_STORE_CORRUPT', `Cron schedule store must contain a top-level array: ${schedulesFile}`, schedulesFile);
+    }
+    return parsed;
 }
-function saveSchedules(schedules, dir) {
-    ensureDataDir(dir);
-    const schedulesFile = resolveSchedulesFile(dir);
-    const tempFile = `${schedulesFile}.tmp`;
-    fs.writeFileSync(tempFile, JSON.stringify(schedules, null, 2));
-    fs.renameSync(tempFile, schedulesFile);
-}
-async function acquireLock(timeout = 5000) {
-    ensureDataDir();
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeout) {
+function syncDirectory(directory) {
+    if (process.platform === 'win32')
+        return;
+    try {
+        const fd = fs.openSync(directory, 'r');
         try {
-            fs.writeFileSync(LOCK_FILE, String(process.pid), { flag: 'wx' });
-            return true;
+            fs.fsyncSync(fd);
         }
-        catch (e) {
-            const err = e;
-            if (err.code === 'EEXIST') {
-                try {
-                    const stat = fs.statSync(LOCK_FILE);
-                    if (Date.now() - stat.mtimeMs > 30000) {
-                        fs.unlinkSync(LOCK_FILE);
-                        continue;
-                    }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+    }
+}
+function writeSchedulesAtomic(schedulesFile, schedules) {
+    const directory = path.dirname(schedulesFile);
+    const tempFile = path.join(directory, `.${path.basename(schedulesFile)}.${process.pid}.${(0, crypto_1.randomUUID)()}.tmp`);
+    const contents = JSON.stringify(schedules, null, 2);
+    let fd;
+    try {
+        fd = fs.openSync(tempFile, 'wx', 0o600);
+        fs.writeFileSync(fd, contents);
+        fs.fsyncSync(fd);
+        fs.closeSync(fd);
+        fd = undefined;
+        fs.renameSync(tempFile, schedulesFile);
+        syncDirectory(directory);
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+            }
+        }
+        try {
+            fs.unlinkSync(tempFile);
+        }
+        catch {
+        }
+    }
+}
+function requireSchedule(schedules, id) {
+    const schedule = schedules.find(item => item.id === id);
+    if (!schedule) {
+        throw new types_1.CronStoreError('CRON_SCHEDULE_NOT_FOUND', `Schedule not found: ${id}`);
+    }
+    return schedule;
+}
+function withStoreLock(workspacePath, operation) {
+    const lock = acquireWorkspaceLock(workspacePath);
+    try {
+        const schedulesFile = resolveSchedulesFile(workspacePath);
+        const schedules = readSchedulesFile(schedulesFile);
+        const result = operation(schedules);
+        writeSchedulesAtomic(schedulesFile, schedules);
+        return result;
+    }
+    finally {
+        releaseWorkspaceLock(lock);
+    }
+}
+function createScheduleStore(workspacePath = DEFAULT_WORKSPACE_PATH) {
+    const normalizedWorkspacePath = path.resolve(workspacePath);
+    const dataDir = resolveDataDir(normalizedWorkspacePath);
+    const schedulesFile = resolveSchedulesFile(normalizedWorkspacePath);
+    const lockFile = resolveLockFile(normalizedWorkspacePath);
+    return {
+        workspacePath: normalizedWorkspacePath,
+        dataDir,
+        schedulesFile,
+        lockFile,
+        list() {
+            return readSchedulesFile(schedulesFile).map(cloneSchedule);
+        },
+        get(id) {
+            const schedule = readSchedulesFile(schedulesFile).find(item => item.id === id);
+            return schedule ? cloneSchedule(schedule) : undefined;
+        },
+        create(schedule) {
+            return withStoreLock(normalizedWorkspacePath, schedules => {
+                if (schedules.some(item => item.id === schedule.id)) {
+                    throw new types_1.CronStoreError('CRON_SCHEDULE_EXISTS', `Schedule already exists: ${schedule.id}`);
                 }
-                catch {
-                    continue;
+                schedules.push(cloneSchedule(schedule));
+                return cloneSchedule(schedule);
+            });
+        },
+        update(id, changes) {
+            return withStoreLock(normalizedWorkspacePath, schedules => {
+                const schedule = requireSchedule(schedules, id);
+                if (changes.cron !== undefined)
+                    schedule.cron = changes.cron;
+                if (changes.command !== undefined)
+                    schedule.command = changes.command;
+                if (changes.mode !== undefined)
+                    schedule.mode = changes.mode;
+                if (changes.enabled !== undefined)
+                    schedule.enabled = changes.enabled;
+                if (changes.name !== undefined)
+                    schedule.name = changes.name;
+                if (changes.working_directory !== undefined)
+                    schedule.working_directory = changes.working_directory;
+                if (changes.timezone !== undefined)
+                    schedule.timezone = changes.timezone;
+                if (changes.timeout_ms !== undefined)
+                    schedule.timeout_ms = changes.timeout_ms;
+                if (changes.allow_concurrent !== undefined)
+                    schedule.allow_concurrent = changes.allow_concurrent;
+                if (changes.env !== undefined) {
+                    if (changes.env === null)
+                        delete schedule.env;
+                    else
+                        schedule.env = { ...changes.env };
                 }
-                await new Promise(resolve => setTimeout(resolve, 100));
-            }
-            else {
-                throw e;
+                if (changes.model !== undefined) {
+                    if (changes.model === null)
+                        delete schedule.model;
+                    else
+                        schedule.model = changes.model;
+                }
+                if (changes.provider !== undefined) {
+                    if (changes.provider === null)
+                        delete schedule.provider;
+                    else
+                        schedule.provider = changes.provider;
+                }
+                schedule.updated_at = new Date().toISOString();
+                schedule.next_run = calculateNextRun(schedule.cron, schedule.timezone);
+                return cloneSchedule(schedule);
+            });
+        },
+        remove(id) {
+            return withStoreLock(normalizedWorkspacePath, schedules => {
+                const index = schedules.findIndex(item => item.id === id);
+                if (index === -1) {
+                    throw new types_1.CronStoreError('CRON_SCHEDULE_NOT_FOUND', `Schedule not found: ${id}`);
+                }
+                const [removed] = schedules.splice(index, 1);
+                return cloneSchedule(removed);
+            });
+        },
+        toggle(id, enabled) {
+            return withStoreLock(normalizedWorkspacePath, schedules => {
+                const schedule = requireSchedule(schedules, id);
+                schedule.enabled = enabled ?? !schedule.enabled;
+                schedule.updated_at = new Date().toISOString();
+                if (schedule.enabled) {
+                    schedule.next_run = calculateNextRun(schedule.cron, schedule.timezone);
+                }
+                return cloneSchedule(schedule);
+            });
+        },
+        claimOccurrence(id, options) {
+            return withStoreLock(normalizedWorkspacePath, schedules => {
+                const schedule = requireSchedule(schedules, typeof id === 'string' ? id : id.id);
+                if (schedule.last_occurrence_key === options.occurrenceKey) {
+                    return {
+                        claimed: false,
+                        schedule: cloneSchedule(schedule),
+                    };
+                }
+                const startedAt = options.startedAt ?? new Date().toISOString();
+                schedule.last_started_at = startedAt;
+                schedule.last_occurrence_key = options.occurrenceKey;
+                schedule.updated_at = startedAt;
+                return {
+                    claimed: true,
+                    schedule: cloneSchedule(schedule),
+                };
+            });
+        },
+        recordStarted(id, options) {
+            return withStoreLock(normalizedWorkspacePath, schedules => {
+                const schedule = requireSchedule(schedules, typeof id === 'string' ? id : id.id);
+                const normalizedOptions = typeof options === 'string' ? { startedAt: options } : options;
+                const startedAt = normalizedOptions?.startedAt ?? new Date().toISOString();
+                schedule.last_started_at = startedAt;
+                if (normalizedOptions?.occurrenceKey !== undefined) {
+                    schedule.last_occurrence_key = normalizedOptions.occurrenceKey;
+                }
+                schedule.updated_at = startedAt;
+                return cloneSchedule(schedule);
+            });
+        },
+        recordFinished(id, options) {
+            return withStoreLock(normalizedWorkspacePath, schedules => {
+                const schedule = requireSchedule(schedules, typeof id === 'string' ? id : id.id);
+                const finishedAt = options?.finishedAt ?? new Date().toISOString();
+                schedule.last_run = finishedAt;
+                schedule.run_count = (schedule.run_count || 0) + 1;
+                schedule.next_run = options?.nextRun !== undefined
+                    ? options.nextRun
+                    : calculateNextRun(schedule.cron, schedule.timezone);
+                if (options?.outcome !== undefined)
+                    schedule.last_outcome = options.outcome;
+                else if (options?.success !== undefined)
+                    schedule.last_outcome = options.success ? 'success' : 'failure';
+                schedule.updated_at = finishedAt;
+                return cloneSchedule(schedule);
+            });
+        },
+    };
+}
+function loadSchedules(dir) {
+    return createScheduleStore(dir ?? DEFAULT_WORKSPACE_PATH).list();
+}
+function saveSchedules(schedules, dir) {
+    const workspacePath = path.resolve(dir ?? DEFAULT_WORKSPACE_PATH);
+    const lock = acquireWorkspaceLock(workspacePath);
+    try {
+        const schedulesFile = resolveSchedulesFile(workspacePath);
+        readSchedulesFile(schedulesFile);
+        writeSchedulesAtomic(schedulesFile, schedules.map(cloneSchedule));
+    }
+    finally {
+        releaseWorkspaceLock(lock);
+    }
+}
+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 store = createScheduleStore(dir ?? DEFAULT_WORKSPACE_PATH);
+    const schedules = store.list();
+    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();
+        const schedule = {
+            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),
+        };
+        store.create(schedule);
+        existingNames.add(def.name);
+        seeded.push(def.builtin_id);
+    }
+    return seeded;
+}
+const legacyLockOwners = new Map();
+async function acquireLock(timeout = STORE_LOCK_TIMEOUT_MS, dir) {
+    const workspacePath = path.resolve(dir ?? DEFAULT_WORKSPACE_PATH);
+    try {
+        legacyLockOwners.set(workspacePath, acquireWorkspaceLock(workspacePath, timeout));
+        return true;
+    }
+    catch (error) {
+        if (error instanceof types_1.CronStoreError && error.code === 'CRON_STORE_LOCK_TIMEOUT')
+            return false;
+        throw error;
+    }
+}
+function releaseLock(dir) {
+    const workspacePath = path.resolve(dir ?? DEFAULT_WORKSPACE_PATH);
+    const owner = legacyLockOwners.get(workspacePath);
+    if (!owner)
+        return;
+    legacyLockOwners.delete(workspacePath);
+    releaseWorkspaceLock(owner);
+}
+function readRunLease(lockFile) {
+    return safeReadJsonFile(lockFile);
+}
+function writeRunLeaseAtomic(lockFile, lease) {
+    const directory = path.dirname(lockFile);
+    const tempFile = path.join(directory, `.${path.basename(lockFile)}.${process.pid}.${(0, crypto_1.randomUUID)()}.tmp`);
+    let fd;
+    try {
+        fd = fs.openSync(tempFile, 'wx', 0o600);
+        fs.writeFileSync(fd, JSON.stringify(lease));
+        fs.fsyncSync(fd);
+        fs.closeSync(fd);
+        fd = undefined;
+        fs.renameSync(tempFile, lockFile);
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                fs.closeSync(fd);
             }
+            catch { }
         }
+        try {
+            fs.unlinkSync(tempFile);
+        }
+        catch { }
     }
-    return false;
 }
-function releaseLock() {
+function withRunLeaseStoreLock(workspacePath, scheduleId, operation) {
+    const owner = acquireWorkspaceLock(workspacePath);
     try {
-        fs.unlinkSync(LOCK_FILE);
+        return operation(resolveRunLockFile(scheduleId, workspacePath));
+    }
+    finally {
+        releaseWorkspaceLock(owner);
+    }
+}
+function getLeaseAgeMs(lockFile) {
+    try {
+        return Math.max(0, Date.now() - fs.statSync(lockFile).mtimeMs);
     }
     catch {
+        return null;
     }
 }
+function compareProcessIdentity(expected, actual) {
+    if (expected.startTime !== null && actual.startTime !== null) {
+        return expected.startTime === actual.startTime;
+    }
+    if (expected.commandLine !== null && actual.commandLine !== null) {
+        return expected.commandLine === actual.commandLine;
+    }
+    return null;
+}
+function isRunLeaseStale(lease, lockFile, timeoutMs) {
+    if (lease.phase !== 'child') {
+        const ageMs = getLeaseAgeMs(lockFile);
+        if (ageMs === null)
+            return false;
+        const ownerPid = lease.hostPid ?? lease.pid;
+        const ownerAlive = isPidAlive(ownerPid);
+        return ownerAlive === false || ageMs > timeoutMs + RUN_LOCK_STALE_GRACE_MS;
+    }
+    const childPid = lease.childPid ?? lease.pid;
+    const childAlive = isPidAlive(childPid);
+    if (childAlive === false)
+        return true;
+    if (childAlive !== true)
+        return false;
+    if (!lease.childIdentity)
+        return false;
+    const currentIdentity = captureProcessIdentity(childPid);
+    if (!currentIdentity)
+        return false;
+    const identityMatch = compareProcessIdentity(lease.childIdentity, currentIdentity);
+    if (identityMatch === false)
+        return true;
+    return false;
+}
+function acquireRunLock(scheduleId, taskId, timeoutMs, dir) {
+    const workspacePath = path.resolve(dir ?? DEFAULT_WORKSPACE_PATH);
+    ensureDataDir(workspacePath);
+    const lockFile = resolveRunLockFile(scheduleId, workspacePath);
+    const leaseId = (0, crypto_1.randomUUID)();
+    const ownerToken = (0, crypto_1.randomUUID)();
+    const lease = {
+        leaseId,
+        ownerToken,
+        phase: 'admitting',
+        hostPid: process.pid,
+        pid: process.pid,
+        taskId,
+        startedAt: new Date().toISOString(),
+    };
+    return withRunLeaseStoreLock(workspacePath, scheduleId, () => {
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                fs.writeFileSync(lockFile, JSON.stringify(lease), { flag: 'wx', mode: 0o600 });
+                return {
+                    acquired: true,
+                    lease: { scheduleId, workspacePath, lockFile, leaseId, ownerToken, taskId },
+                };
+            }
+            catch (e) {
+                const err = e;
+                if (err.code !== 'EEXIST')
+                    throw err;
+                const existing = readRunLease(lockFile);
+                if (!existing) {
+                    return { acquired: false, runningTaskId: 'unknown', reason: 'execution_lease' };
+                }
+                if (isRunLeaseStale(existing, lockFile, timeoutMs)) {
+                    const current = readRunLease(lockFile);
+                    if (current?.leaseId !== undefined && current.leaseId !== existing.leaseId) {
+                        continue;
+                    }
+                    try {
+                        fs.unlinkSync(lockFile);
+                    }
+                    catch { }
+                    continue;
+                }
+                return {
+                    acquired: false,
+                    runningTaskId: existing.taskId,
+                    reason: 'execution_lease',
+                };
+            }
+        }
+        const existing = readRunLease(lockFile);
+        return {
+            acquired: false,
+            runningTaskId: existing?.taskId ?? 'unknown',
+            reason: 'execution_lease',
+        };
+    });
+}
+function handoffRunLock(lease, childPid, childIdentity) {
+    return withRunLeaseStoreLock(lease.workspacePath, lease.scheduleId, lockFile => {
+        const current = readRunLease(lockFile);
+        if (!current ||
+            current.leaseId !== lease.leaseId ||
+            current.ownerToken !== lease.ownerToken) {
+            return false;
+        }
+        writeRunLeaseAtomic(lockFile, {
+            ...current,
+            phase: 'child',
+            pid: childPid,
+            childPid,
+            childIdentity,
+        });
+        return true;
+    });
+}
+function releaseRunLock(scheduleId, leaseId, dir) {
+    const workspacePath = path.resolve(dir ?? DEFAULT_WORKSPACE_PATH);
+    ensureDataDir(workspacePath);
+    return withRunLeaseStoreLock(workspacePath, scheduleId, lockFile => {
+        const current = readRunLease(lockFile);
+        if (!current || current.leaseId !== leaseId)
+            return false;
+        try {
+            fs.unlinkSync(lockFile);
+            return true;
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === 'ENOENT')
+                return false;
+            throw error;
+        }
+    });
+}
 const DAY_NAMES = {
     SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6,
 };
@@ -452,8 +1029,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,44 +1055,141 @@ 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;
+    }
+}
+function getProcessStartTime(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}").CreationDate.ToUniversalTime().ToString("o")`,
+            ], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
+            : (0, child_process_1.execFileSync)('ps', ['-p', String(pid), '-o', 'lstart='], { 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) {
+function captureProcessIdentity(pid) {
+    const identity = {
+        commandLine: getProcessCommandLine(pid),
+        startTime: getProcessStartTime(pid),
+    };
+    return identity.commandLine !== null || identity.startTime !== null ? identity : null;
+}
+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;
+    let commandLine;
+    try {
+        commandLine = probe.getCommandLine(pid);
+    }
+    catch {
+        return 'unknown';
+    }
+    const liveness = classifyDaemonIdentity(commandLine);
+    if (liveness === 'stale') {
+        removeDaemonPidFile(dir);
+    }
+    return liveness;
 }
-function startDaemon(dir) {
-    if (isDaemonRunning(dir)) {
-        const pid = readDaemonPid(dir);
-        if (pid)
-            return pid;
-        throw new Error('Daemon is already running');
+function isDaemonRunning(dir, probe = DEFAULT_DAEMON_PROCESS_PROBE) {
+    return inspectDaemon(dir, probe) === 'running';
+}
+function spawnDaemon(dir, spawnImpl = child_process_1.spawn) {
+    if ((0, sdk_1.isDurablyQuiescing)()) {
+        throw new Error('Cannot start cron daemon: a desktop update is draining active work');
     }
     ensureDataDir(dir);
     const cliPath = getDaemonCliPath();
-    const child = (0, child_process_1.spawn)('node', [cliPath, 'daemon', '--foreground'], {
+    const daemonEnv = { ...process.env };
+    if (process.versions.electron) {
+        daemonEnv.ELECTRON_RUN_AS_NODE = '1';
+    }
+    const child = spawnImpl(process.execPath, [cliPath, 'daemon', '--foreground'], {
         cwd: dir || undefined,
         detached: true,
         stdio: 'ignore',
         windowsHide: true,
+        env: daemonEnv,
     });
     if (!child.pid) {
         throw new Error('Failed to start daemon: no PID returned');
@@ -522,37 +1198,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 schedules = createScheduleStore(dir ?? DEFAULT_WORKSPACE_PATH).list();
     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,34 +1276,162 @@ 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 workspacePath = path.resolve(dir ?? DEFAULT_WORKSPACE_PATH);
+    const trigger = options?.trigger ?? 'cron';
+    const timeoutMs = schedule.timeout_ms || 600000;
+    const taskId = (0, sdk_1.generateId)('tsk');
+    let runLease;
+    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,
+                reason: lock.reason,
+            };
+        }
+        runLease = lock.lease;
+    }
+    const releaseLease = () => {
+        if (runLease) {
+            releaseRunLock(schedule.id, runLease.leaseId, dir);
+            runLease = undefined;
+        }
+        releaseAdmissionReservation(taskId);
+    };
+    if (!reserveAdmission(taskId, schedule.id, timeoutMs)) {
+        console.log(`[${getLocalTimestamp()}] Schedule ${schedule.id} blocked: could not durably record the update-admission reservation`);
+        releaseLease();
+        return { status: 'blocked', reason: 'ADMISSION_UNKNOWN' };
+    }
+    if ((0, sdk_1.isDurablyQuiescing)()) {
+        console.log(`[${getLocalTimestamp()}] Schedule ${schedule.id} blocked: a desktop update is draining active work`);
+        releaseLease();
+        return { status: 'blocked', reason: 'UPDATE_QUIESCING' };
+    }
+    try {
+        const store = createScheduleStore(workspacePath);
+        const startedAt = new Date().toISOString();
+        if (options?.occurrenceKey !== undefined) {
+            const claim = store.claimOccurrence(schedule.id, {
+                occurrenceKey: options.occurrenceKey,
+                startedAt,
+            });
+            if (!claim.claimed) {
+                releaseLease();
+                console.log(`[${getLocalTimestamp()}] Schedule ${schedule.id} occurrence ${options.occurrenceKey} already claimed, skipping`);
+                return {
+                    status: 'conflict',
+                    runningTaskId: '',
+                    reason: 'occurrence_claim',
+                };
+            }
+        }
+        else {
+            if (store.get(schedule.id)) {
+                store.recordStarted(schedule.id, { startedAt });
+            }
+        }
     }
-    runningSchedules.add(schedule.id);
-    const workingDir = schedule.working_directory || getProjectRoot();
+    catch (error) {
+        releaseLease();
+        throw error;
+    }
+    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;
+    const effectiveProvider = options?.overrides?.provider ?? schedule.provider;
+    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 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);
+    }
+    if (mode !== 'command' && effectiveProvider) {
+        cliArgs.push('--provider', effectiveProvider);
+    }
+    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 childInvocation = (0, sdk_1.createCrewxChildInvocation)(resolution, { baseEnv: env });
+            const program = (0, sdk_1.resolveWindowsSpawnProgram)({
+                command: childInvocation.command,
+                env: childInvocation.env,
                 cwd: workingDir,
-                stdio: 'inherit',
-                windowsHide: true,
-                env,
+                packageName: 'crewx',
+                allowShellFallback: true,
+            });
+            const invocation = (0, sdk_1.materializeWindowsSpawnProgram)(program, [
+                ...childInvocation.args,
+                ...cliArgs,
+            ]);
+            child = (0, child_process_1.spawn)(invocation.command, invocation.argv, {
+                cwd: workingDir,
+                stdio: 'ignore',
+                windowsHide: invocation.windowsHide,
+                detached: true,
+                env: childInvocation.env,
+                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;
+    }
+    if (runLease && child.pid) {
+        const handedOff = handoffRunLock(runLease, child.pid, captureProcessIdentity(child.pid));
+        if (!handedOff) {
+            const error = new Error('Cron execution lease was replaced before child ownership was established');
+            console.error(`[${getLocalTimestamp()}] Schedule ${schedule.id} failed to hand off its execution lease: ${error.message}`);
+            try {
+                child.kill('SIGTERM');
+            }
+            catch {
+            }
+            releaseLease();
+            throw error;
+        }
+    }
+    child.unref();
+    const done = new Promise((resolve) => {
+        let timedOut = false;
+        let settled = false;
+        let graceTimer;
         const timeout = setTimeout(() => {
+            timedOut = true;
             console.log(`[${getLocalTimestamp()}] Schedule ${schedule.id} timeout, killing process`);
             try {
                 child.kill('SIGTERM');
@@ -609,37 +1440,72 @@ async function executeSchedule(schedule, dir) {
                 const err = e;
                 console.error(`Failed to kill process: ${err.message}`);
             }
-            runningSchedules.delete(schedule.id);
-            resolve({ success: false, error: 'Timeout' });
-        }, schedule.timeout_ms || 600000);
+            graceTimer = setTimeout(() => {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch {
+                }
+            }, RUN_LOCK_STALE_GRACE_MS);
+            if (typeof graceTimer === 'object' && graceTimer !== null && 'unref' in graceTimer) {
+                graceTimer.unref();
+            }
+            if (!settled) {
+                settled = true;
+                resolve({ success: false, error: 'Timeout' });
+            }
+        }, timeoutMs);
         child.on('close', (code) => {
             clearTimeout(timeout);
-            runningSchedules.delete(schedule.id);
-            const schedules = loadSchedules(dir);
-            const idx = schedules.findIndex(s => s.id === schedule.id);
-            if (idx !== -1) {
-                const s = schedules[idx];
-                s.last_run = new Date().toISOString();
-                s.run_count = (s.run_count || 0) + 1;
-                s.next_run = calculateNextRun(schedule.cron, schedule.timezone);
-                saveSchedules(schedules, dir);
+            if (graceTimer)
+                clearTimeout(graceTimer);
+            releaseLease();
+            const finishedAt = new Date().toISOString();
+            const outcome = timedOut ? 'timeout' : code === 0 ? 'success' : 'failure';
+            try {
+                createScheduleStore(workspacePath).recordFinished(schedule.id, {
+                    finishedAt,
+                    outcome,
+                });
+            }
+            catch (error) {
+                const err = error;
+                if (!(error instanceof types_1.CronStoreError && error.code === 'CRON_SCHEDULE_NOT_FOUND')) {
+                    console.error(`[${getLocalTimestamp()}] Failed to record schedule ${schedule.id} completion: ${err.message}`);
+                }
             }
-            if (code === 0) {
+            if (timedOut) {
+                console.log(`[${getLocalTimestamp()}] Schedule ${schedule.id} terminated after timeout`);
+                if (!settled) {
+                    settled = true;
+                    resolve({ success: false, error: 'Timeout' });
+                }
+            }
+            else if (code === 0) {
                 console.log(`[${getLocalTimestamp()}] Schedule ${schedule.id} completed successfully`);
-                resolve({ success: true });
+                if (!settled) {
+                    settled = true;
+                    resolve({ success: true });
+                }
             }
             else {
                 console.log(`[${getLocalTimestamp()}] Schedule ${schedule.id} failed with code ${code}`);
-                resolve({ success: false, error: `Exit code: ${code}` });
+                if (!settled) {
+                    settled = true;
+                    resolve({ success: false, error: `Exit code: ${code}` });
+                }
             }
         });
         child.on('error', (err) => {
             clearTimeout(timeout);
-            runningSchedules.delete(schedule.id);
             console.error(`[${getLocalTimestamp()}] Schedule ${schedule.id} error: ${err.message}`);
-            resolve({ success: false, error: err.message });
+            if (!settled) {
+                settled = true;
+                resolve({ success: false, error: err.message });
+            }
         });
     });
+    return { status: 'running', taskId, done };
 }
 function getLocalMinuteKey(now, timezone) {
     if (!timezone || !isValidTimezone(timezone)) {
@@ -652,9 +1518,16 @@ function getLocalMinuteKey(now, timezone) {
     });
     return fmt.format(now);
 }
+function buildOccurrenceKey(cronExpression, scheduledMinute) {
+    return `${cronExpression.trim()}|${scheduledMinute}`;
+}
 async function daemonTick(dir) {
+    if ((0, sdk_1.isDurablyQuiescing)()) {
+        console.log(`[${getLocalTimestamp()}] Daemon tick skipped: a desktop update is draining active work`);
+        return;
+    }
     const now = new Date();
-    const schedules = loadSchedules(dir);
+    const schedules = createScheduleStore(dir ?? DEFAULT_WORKSPACE_PATH).list();
     const enabledSchedules = schedules.filter(s => s.enabled);
     if (enabledSchedules.length === 0) {
         return;
@@ -662,16 +1535,20 @@ async function daemonTick(dir) {
     for (const schedule of enabledSchedules) {
         if (shouldRunNow(schedule.cron, now, schedule.timezone)) {
             const minuteKey = getLocalMinuteKey(now, schedule.timezone);
-            if (schedule.last_run) {
-                const lastRunMinuteKey = getLocalMinuteKey(new Date(schedule.last_run), schedule.timezone);
-                if (lastRunMinuteKey === minuteKey) {
-                    continue;
-                }
+            const occurrenceKey = buildOccurrenceKey(schedule.cron, minuteKey);
+            try {
+                await executeSchedule(schedule, { dir, occurrenceKey });
+            }
+            catch (e) {
+                const err = e;
+                console.error(`[${getLocalTimestamp()}] Schedule ${schedule.id} failed to spawn: ${err.message}`);
             }
-            await executeSchedule(schedule, dir);
         }
     }
 }
+var runtime_1 = require("./runtime");
+Object.defineProperty(exports, "createCronRuntime", { enumerable: true, get: function () { return runtime_1.createCronRuntime; } });
+Object.defineProperty(exports, "CRON_RUNTIME_PROCESS_LEASE_FILENAME", { enumerable: true, get: function () { return runtime_1.CRON_RUNTIME_PROCESS_LEASE_FILENAME; } });
 function runDaemonForeground(dir) {
     writeDaemonPid(process.pid, dir);
     let cleanedUp = false;
@@ -696,7 +1573,7 @@ function runDaemonForeground(dir) {
     console.log(`[${getLocalTimestamp()}] Cron daemon starting in foreground mode`);
     console.log(`[${getLocalTimestamp()}] Check interval: 1 minute`);
     console.log(`[${getLocalTimestamp()}] Press Ctrl+C to stop\n`);
-    const schedules = loadSchedules(dir);
+    const schedules = createScheduleStore(dir ?? DEFAULT_WORKSPACE_PATH).list();
     const enabled = schedules.filter(s => s.enabled).length;
     console.log(`[${getLocalTimestamp()}] Active schedules: ${enabled}/${schedules.length}\n`);
     void daemonTick(dir);
@@ -708,6 +1585,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,97 +1601,102 @@ function addSchedule(cron, command, options, dataDir) {
         updated_at: new Date().toISOString(),
         run_count: 0,
     };
+    if (options.model) {
+        schedule.model = options.model;
+    }
+    if (options.provider) {
+        schedule.provider = options.provider;
+    }
     schedule.next_run = calculateNextRun(cron, schedule.timezone);
-    const schedules = loadSchedules(dataDir);
-    schedules.push(schedule);
-    saveSchedules(schedules, dataDir);
-    return schedule;
+    return createScheduleStore(dataDir ?? DEFAULT_WORKSPACE_PATH).create(schedule);
 }
 function removeSchedule(id, dir) {
-    const schedules = loadSchedules(dir);
-    const idx = schedules.findIndex(s => s.id === id);
-    if (idx === -1) {
-        throw new Error(`Schedule not found: ${id}`);
+    const removed = createScheduleStore(dir ?? DEFAULT_WORKSPACE_PATH).remove(id);
+    const matchedBuiltin = (0, builtins_1.findBuiltinByName)(removed.name);
+    if (matchedBuiltin) {
+        recordRemovedBuiltin(matchedBuiltin.builtin_id, dir);
     }
-    const removed = schedules.splice(idx, 1)[0];
-    saveSchedules(schedules, dir);
     return removed;
 }
 function enableSchedule(id, dir) {
-    const schedules = loadSchedules(dir);
-    const schedule = schedules.find(s => s.id === id);
-    if (!schedule) {
-        throw new Error(`Schedule not found: ${id}`);
-    }
-    schedule.enabled = true;
-    schedule.updated_at = new Date().toISOString();
-    schedule.next_run = calculateNextRun(schedule.cron, schedule.timezone);
-    saveSchedules(schedules, dir);
-    return schedule;
+    return createScheduleStore(dir ?? DEFAULT_WORKSPACE_PATH).toggle(id, true);
 }
 function disableSchedule(id, dir) {
-    const schedules = loadSchedules(dir);
-    const schedule = schedules.find(s => s.id === id);
-    if (!schedule) {
-        throw new Error(`Schedule not found: ${id}`);
-    }
-    schedule.enabled = false;
-    schedule.updated_at = new Date().toISOString();
-    saveSchedules(schedules, dir);
-    return schedule;
+    return createScheduleStore(dir ?? DEFAULT_WORKSPACE_PATH).toggle(id, false);
 }
 function updateSchedule(id, options, dir) {
-    const schedules = loadSchedules(dir);
-    const schedule = schedules.find(s => s.id === id);
-    if (!schedule) {
-        throw new Error(`Schedule not found: ${id}`);
-    }
     if (options.timezone !== undefined && options.timezone !== null && !isValidTimezone(options.timezone)) {
         throw new Error(`Invalid timezone: ${options.timezone}`);
     }
+    const store = createScheduleStore(dir ?? DEFAULT_WORKSPACE_PATH);
+    const current = store.get(id);
+    if (!current) {
+        throw new Error(`Schedule not found: ${id}`);
+    }
     const changes = [];
+    const patch = {};
     if (options.cron !== undefined) {
-        schedule.cron = options.cron;
+        patch.cron = options.cron;
         changes.push(`cron: ${options.cron}`);
     }
     if (options.command !== undefined) {
-        schedule.command = options.command;
+        warnIfOverdriveInCommand(options.command);
+        patch.command = options.command;
         changes.push(`command: ${options.command}`);
     }
     if (options.name !== undefined) {
-        schedule.name = options.name;
+        patch.name = options.name;
         changes.push(`name: ${options.name}`);
     }
     if (options.mode !== undefined) {
-        schedule.mode = normalizeMode(options.mode);
-        changes.push(`mode: ${schedule.mode}`);
+        patch.mode = normalizeMode(options.mode);
+        changes.push(`mode: ${patch.mode}`);
     }
     if (options.timezone !== undefined) {
-        schedule.timezone = options.timezone;
+        patch.timezone = options.timezone;
         changes.push(`timezone: ${options.timezone}`);
     }
     if (options.working_directory !== undefined) {
-        schedule.working_directory = options.working_directory;
+        patch.working_directory = options.working_directory;
         changes.push(`working_directory: ${options.working_directory}`);
     }
     if (options.timeout_ms !== undefined) {
-        schedule.timeout_ms = options.timeout_ms;
+        patch.timeout_ms = options.timeout_ms;
         changes.push(`timeout: ${options.timeout_ms}ms`);
     }
     if (options.allow_concurrent !== undefined) {
-        schedule.allow_concurrent = options.allow_concurrent;
+        patch.allow_concurrent = options.allow_concurrent;
         changes.push(`allow_concurrent: ${options.allow_concurrent}`);
     }
-    schedule.updated_at = new Date().toISOString();
-    schedule.next_run = calculateNextRun(schedule.cron, schedule.timezone);
-    saveSchedules(schedules, dir);
-    return { schedule, changes };
+    if (options.model !== undefined) {
+        if (options.model === null) {
+            patch.model = null;
+            changes.push('model: (cleared, reverts to agent default)');
+        }
+        else {
+            patch.model = options.model;
+            changes.push(`model: ${options.model}`);
+        }
+    }
+    if (options.provider !== undefined) {
+        if (options.provider === null) {
+            patch.provider = null;
+            changes.push('provider: (cleared, reverts to agent default)');
+        }
+        else {
+            patch.provider = options.provider;
+            changes.push(`provider: ${options.provider}`);
+        }
+    }
+    return { schedule: store.update(current.id, patch), changes };
 }
 exports.DATA_PATHS = {
     DATA_DIR,
     SCHEDULES_FILE,
     LOG_FILE,
+    LOCK_FILE,
     USAGE_LOG_FILE,
     PID_FILE,
+    BUILTINS_META_FILE,
 };
 //# sourceMappingURL=engine.js.map