@crewx/cron 0.1.10-rc.145 → 0.1.10-rc.147

package/dist/src/engine.js

@@ -33,16 +33,21 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DATA_PATHS = exports.getProjectRoot = exports.BUILTIN_SCHEDULES = 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.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;
@@ -53,6 +58,8 @@ 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;
@@ -61,13 +68,17 @@ 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 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 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');
@@ -75,11 +86,17 @@ 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');
 }
@@ -100,6 +117,9 @@ function resolveRunLockFile(scheduleId, dir) {
     return path.join(resolveDataDir(dir), `.cron-run-${scheduleId}.lock`);
 }
 const DAEMON_INTERVAL_MS = 60 * 1000;
+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();
@@ -111,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);
@@ -132,6 +185,76 @@ function safeReadJsonFile(filePath) {
         return null;
     }
 }
+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 {
+        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 null;
+    }
+}
+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')) {
@@ -139,9 +262,9 @@ function maybeRewriteLegacyMemoryCommand(command) {
     }
     return MEMORY_DEBOUNCE_BUILTIN.buildCommand();
 }
-function migrateLegacyMemoryDebounceSchedule() {
-    ensureDataDir();
-    const legacyFile = path.join((0, builtins_1.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;
     }
@@ -153,7 +276,8 @@ function migrateLegacyMemoryDebounceSchedule() {
     if (!legacySchedule) {
         return;
     }
-    const targetSchedules = fs.existsSync(SCHEDULES_FILE) ? safeReadJsonFile(SCHEDULES_FILE) ?? [] : [];
+    const store = createScheduleStore(normalizedWorkspacePath);
+    const targetSchedules = store.list();
     if (targetSchedules.some(s => s.name === MEMORY_DEBOUNCE_BUILTIN.name)) {
         return;
     }
@@ -163,7 +287,7 @@ 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')) {
@@ -177,31 +301,255 @@ 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 syncDirectory(directory) {
+    if (process.platform === 'win32')
+        return;
+    try {
+        const fd = fs.openSync(directory, 'r');
+        try {
+            fs.fsyncSync(fd);
+        }
+        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}`);
+                }
+                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 };
+                }
+                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) {
-    ensureDataDir(dir);
-    const schedulesFile = resolveSchedulesFile(dir);
-    const tempFile = `${schedulesFile}.tmp`;
-    fs.writeFileSync(tempFile, JSON.stringify(schedules, null, 2));
-    fs.renameSync(tempFile, schedulesFile);
+    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));
@@ -225,7 +573,8 @@ function recordRemovedBuiltin(builtinId, dir) {
     }
 }
 function seedBuiltinSchedules(dir) {
-    const schedules = loadSchedules(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 = [];
@@ -235,7 +584,7 @@ function seedBuiltinSchedules(dir) {
         if (removedBuiltins.has(def.builtin_id))
             continue;
         const now = new Date().toISOString();
-        schedules.push({
+        const schedule = {
             id: (0, sdk_1.generateId)('cron'),
             cron: def.cron,
             command: def.buildCommand(),
@@ -250,102 +599,207 @@ function seedBuiltinSchedules(dir) {
             updated_at: now,
             run_count: 0,
             next_run: calculateNextRun(def.cron, null),
-        });
+        };
+        store.create(schedule);
+        existingNames.add(def.name);
         seeded.push(def.builtin_id);
     }
-    if (seeded.length > 0) {
-        saveSchedules(schedules, dir);
-    }
     return seeded;
 }
-async function acquireLock(timeout = 5000) {
-    ensureDataDir();
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeout) {
-        try {
-            fs.writeFileSync(LOCK_FILE, String(process.pid), { flag: 'wx' });
-            return true;
-        }
-        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;
-                    }
-                }
-                catch {
-                    continue;
-                }
-                await new Promise(resolve => setTimeout(resolve, 100));
-            }
-            else {
-                throw e;
+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 { }
+    }
+}
+function withRunLeaseStoreLock(workspacePath, scheduleId, operation) {
+    const owner = acquireWorkspaceLock(workspacePath);
+    try {
+        return operation(resolveRunLockFile(scheduleId, workspacePath));
+    }
+    finally {
+        releaseWorkspaceLock(owner);
     }
-    return false;
 }
-function releaseLock() {
+function getLeaseAgeMs(lockFile) {
     try {
-        fs.unlinkSync(LOCK_FILE);
+        return Math.max(0, Date.now() - fs.statSync(lockFile).mtimeMs);
     }
     catch {
+        return null;
     }
 }
-function readRunLease(lockFile) {
-    return safeReadJsonFile(lockFile);
+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) {
-    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;
+    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 {
-                ageMs = Date.now() - fs.statSync(lockFile).mtimeMs;
-            }
-            catch {
-                continue;
+                fs.writeFileSync(lockFile, JSON.stringify(lease), { flag: 'wx', mode: 0o600 });
+                return {
+                    acquired: true,
+                    lease: { scheduleId, workspacePath, lockFile, leaseId, ownerToken, taskId },
+                };
             }
-            const stale = !isPidAlive(existing.pid) || ageMs > timeoutMs + RUN_LOCK_STALE_GRACE_MS;
-            if (stale) {
-                try {
-                    fs.unlinkSync(lockFile);
+            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' };
                 }
-                catch { }
-                continue;
+                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',
+                };
             }
-            return { acquired: false, runningTaskId: existing.taskId };
         }
-    }
-    const existing = readRunLease(lockFile);
-    return { acquired: false, runningTaskId: existing?.taskId ?? taskId };
+        const existing = readRunLease(lockFile);
+        return {
+            acquired: false,
+            runningTaskId: existing?.taskId ?? 'unknown',
+            reason: 'execution_lease',
+        };
+    });
 }
-function releaseRunLock(scheduleId, dir) {
-    try {
-        fs.unlinkSync(resolveRunLockFile(scheduleId, dir));
-    }
-    catch {
-    }
+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,
@@ -622,6 +1076,30 @@ function getProcessCommandLine(pid) {
         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;
+    }
+}
+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,
@@ -702,11 +1180,16 @@ function spawnDaemon(dir, spawnImpl = child_process_1.spawn) {
     }
     ensureDataDir(dir);
     const cliPath = getDaemonCliPath();
-    const child = spawnImpl('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');
@@ -769,7 +1252,7 @@ function ensureDaemonRunning(dir, probe = DEFAULT_DAEMON_PROCESS_PROBE) {
     }
 }
 function getDaemonStatus(dir) {
-    const schedules = loadSchedules(dir);
+    const schedules = createScheduleStore(dir ?? DEFAULT_WORKSPACE_PATH).list();
     const enabled = schedules.filter(s => s.enabled).length;
     const running = isDaemonRunning(dir);
     const pid = running ? readDaemonPid(dir) : null;
@@ -795,19 +1278,28 @@ function getDaemonStatus(dir) {
 }
 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 };
+            return {
+                status: 'conflict',
+                runningTaskId: lock.runningTaskId,
+                reason: lock.reason,
+            };
         }
+        runLease = lock.lease;
     }
     const releaseLease = () => {
-        if (!schedule.allow_concurrent)
-            releaseRunLock(schedule.id, dir);
+        if (runLease) {
+            releaseRunLock(schedule.id, runLease.leaseId, dir);
+            runLease = undefined;
+        }
         releaseAdmissionReservation(taskId);
     };
     if (!reserveAdmission(taskId, schedule.id, timeoutMs)) {
@@ -820,6 +1312,34 @@ async function executeSchedule(schedule, options) {
         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 });
+            }
+        }
+    }
+    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';
@@ -859,18 +1379,16 @@ async function executeSchedule(schedule, options) {
                 Object.assign(error, { code: 'CLI_UNRESOLVABLE' });
                 throw error;
             }
-            const childEnv = {
-                ...env,
-                CREWX_CLI_ARGV: JSON.stringify(resolution.argv),
-            };
+            const childInvocation = (0, sdk_1.createCrewxChildInvocation)(resolution, { baseEnv: env });
             const program = (0, sdk_1.resolveWindowsSpawnProgram)({
-                command: resolution.argv[0],
-                env: childEnv,
+                command: childInvocation.command,
+                env: childInvocation.env,
                 cwd: workingDir,
                 packageName: 'crewx',
+                allowShellFallback: true,
             });
             const invocation = (0, sdk_1.materializeWindowsSpawnProgram)(program, [
-                ...resolution.argv.slice(1),
+                ...childInvocation.args,
                 ...cliArgs,
             ]);
             child = (0, child_process_1.spawn)(invocation.command, invocation.argv, {
@@ -878,7 +1396,7 @@ async function executeSchedule(schedule, options) {
                 stdio: 'ignore',
                 windowsHide: invocation.windowsHide,
                 detached: true,
-                env: childEnv,
+                env: childInvocation.env,
                 shell: invocation.shell ?? false,
             });
         }
@@ -893,9 +1411,27 @@ async function executeSchedule(schedule, options) {
         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');
@@ -904,35 +1440,69 @@ async function executeSchedule(schedule, options) {
                 const err = e;
                 console.error(`Failed to kill process: ${err.message}`);
             }
-            releaseLease();
-            resolve({ success: false, error: 'Timeout' });
+            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);
+            if (graceTimer)
+                clearTimeout(graceTimer);
             releaseLease();
-            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);
+            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 (timedOut) {
+                console.log(`[${getLocalTimestamp()}] Schedule ${schedule.id} terminated after timeout`);
+                if (!settled) {
+                    settled = true;
+                    resolve({ success: false, error: 'Timeout' });
+                }
             }
-            if (code === 0) {
+            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);
-            releaseLease();
             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 };
@@ -948,13 +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;
@@ -962,17 +1535,9 @@ 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 {
-                const outcome = await executeSchedule(schedule, { dir });
-                if (outcome.status === 'running') {
-                    await outcome.done;
-                }
+                await executeSchedule(schedule, { dir, occurrenceKey });
             }
             catch (e) {
                 const err = e;
@@ -981,6 +1546,9 @@ async function daemonTick(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;
@@ -1005,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);
@@ -1040,19 +1608,10 @@ function addSchedule(cron, command, options, dataDir) {
         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 = schedules.splice(idx, 1)[0];
-    saveSchedules(schedules, dir);
+    const removed = createScheduleStore(dir ?? DEFAULT_WORKSPACE_PATH).remove(id);
     const matchedBuiltin = (0, builtins_1.findBuiltinByName)(removed.name);
     if (matchedBuiltin) {
         recordRemovedBuiltin(matchedBuiltin.builtin_id, dir);
@@ -1060,100 +1619,82 @@ function removeSchedule(id, 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) {
         warnIfOverdriveInCommand(options.command);
-        schedule.command = 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}`);
     }
     if (options.model !== undefined) {
         if (options.model === null) {
-            delete schedule.model;
+            patch.model = null;
             changes.push('model: (cleared, reverts to agent default)');
         }
         else {
-            schedule.model = options.model;
+            patch.model = options.model;
             changes.push(`model: ${options.model}`);
         }
     }
     if (options.provider !== undefined) {
         if (options.provider === null) {
-            delete schedule.provider;
+            patch.provider = null;
             changes.push('provider: (cleared, reverts to agent default)');
         }
         else {
-            schedule.provider = options.provider;
+            patch.provider = options.provider;
             changes.push(`provider: ${options.provider}`);
         }
     }
-    schedule.updated_at = new Date().toISOString();
-    schedule.next_run = calculateNextRun(schedule.cron, schedule.timezone);
-    saveSchedules(schedules, dir);
-    return { schedule, changes };
+    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,