@hybridaione/hybridclaw 0.2.2 → 0.2.6

package/dist/scheduler.js

@@ -1,18 +1,24 @@
 /**
  * Scheduler — timer-based, arms for exact next-fire time.
  *
- * Instead of polling every 60s, computes when the next task is due and
- * sets a single setTimeout for that moment.  Re-arms after every tick
- * and whenever a task is added/removed via rearmScheduler().
+ * Runs both legacy DB-backed tasks and config-backed scheduler.jobs.
  */
+import fs from 'node:fs';
+import path from 'node:path';
 import { CronExpressionParser } from 'cron-parser';
-import { deleteTask, getAllEnabledTasks, updateTaskLastRun } from './db.js';
+import { DATA_DIR, getConfigSnapshot } from './config.js';
+import { deleteTask, getAllEnabledTasks, markTaskFailure, markTaskSuccess, updateTaskLastRun, } from './db.js';
 import { logger } from './logger.js';
 const MAX_TIMER_DELAY_MS = 300_000; // 5 min safety net for clock drift
+const MAX_CONSECUTIVE_FAILURES = 5;
+const CONFIG_ONESHOT_RETRY_MS = 60_000;
+const SCHEDULER_STATE_VERSION = 1;
+const SCHEDULER_STATE_PATH = path.join(DATA_DIR, 'scheduler-jobs-state.json');
 let timer = null;
 let taskRunner = null;
 let ticking = false;
-// --- Prompt framing (OpenClaw style) ---
+const schedulerState = loadSchedulerState();
+// --- Prompt framing ---
 function formatFireTime() {
     return new Date().toLocaleString('en-US', {
         weekday: 'short',
@@ -23,38 +29,236 @@ function formatFireTime() {
         timeZoneName: 'short',
     });
 }
-export function wrapCronPrompt(taskId, taskName, message) {
+export function wrapCronPrompt(jobLabel, message) {
     const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    return `[cron:#${taskId} ${taskName}] ${message}\nCurrent time: ${formatFireTime()} (${tz})\n\nReturn your response as plain text; it will be delivered automatically. If the task explicitly calls for messaging a specific external recipient, note who/where it should go instead of sending it yourself.`;
+    return `[cron:${jobLabel}] ${message}\nCurrent time: ${formatFireTime()} (${tz})\n\nReturn your response as plain text; it will be delivered automatically. If the task explicitly calls for messaging a specific external recipient, note who/where it should go instead of sending it yourself.`;
 }
-// --- Timer logic ---
-function computeNextFireMs() {
-    const tasks = getAllEnabledTasks();
-    let earliest = null;
-    for (const task of tasks) {
-        if (task.run_at) {
-            if (!task.last_run) {
-                const ms = new Date(task.run_at).getTime();
-                if (earliest === null || ms < earliest)
-                    earliest = ms;
-            }
-            continue;
+function defaultConfigJobMeta() {
+    return {
+        lastRun: null,
+        lastStatus: null,
+        nextRunAt: null,
+        consecutiveErrors: 0,
+        disabled: false,
+        oneShotCompleted: false,
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function normalizeConfigJobMeta(value) {
+    if (!isRecord(value))
+        return defaultConfigJobMeta();
+    const lastRun = typeof value.lastRun === 'string' && value.lastRun.trim()
+        ? value.lastRun.trim()
+        : null;
+    const lastStatus = value.lastStatus === 'success' || value.lastStatus === 'error'
+        ? value.lastStatus
+        : null;
+    const nextRunAt = typeof value.nextRunAt === 'string' && value.nextRunAt.trim()
+        ? value.nextRunAt.trim()
+        : null;
+    const consecutiveErrors = typeof value.consecutiveErrors === 'number' &&
+        Number.isFinite(value.consecutiveErrors)
+        ? Math.max(0, Math.floor(value.consecutiveErrors))
+        : 0;
+    return {
+        lastRun,
+        lastStatus,
+        nextRunAt,
+        consecutiveErrors,
+        disabled: Boolean(value.disabled),
+        oneShotCompleted: Boolean(value.oneShotCompleted),
+    };
+}
+function loadSchedulerState() {
+    try {
+        if (!fs.existsSync(SCHEDULER_STATE_PATH)) {
+            return {
+                version: SCHEDULER_STATE_VERSION,
+                updatedAt: new Date(0).toISOString(),
+                configJobs: {},
+            };
         }
-        if (task.every_ms) {
-            const lastRunMs = task.last_run ? new Date(task.last_run).getTime() : 0;
-            const nextMs = lastRunMs > 0 ? lastRunMs + task.every_ms : Date.now();
-            if (earliest === null || nextMs < earliest)
-                earliest = nextMs;
-            continue;
+        const raw = fs.readFileSync(SCHEDULER_STATE_PATH, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed))
+            throw new Error('state file root must be object');
+        const rawJobs = isRecord(parsed.configJobs) ? parsed.configJobs : {};
+        const configJobs = {};
+        for (const [id, meta] of Object.entries(rawJobs)) {
+            const key = id.trim();
+            if (!key)
+                continue;
+            configJobs[key] = normalizeConfigJobMeta(meta);
         }
-        if (!task.cron_expr)
+        return {
+            version: SCHEDULER_STATE_VERSION,
+            updatedAt: typeof parsed.updatedAt === 'string' && parsed.updatedAt.trim()
+                ? parsed.updatedAt
+                : new Date(0).toISOString(),
+            configJobs,
+        };
+    }
+    catch (error) {
+        logger.warn({ error }, 'Failed to load scheduler state file; starting with defaults');
+        return {
+            version: SCHEDULER_STATE_VERSION,
+            updatedAt: new Date(0).toISOString(),
+            configJobs: {},
+        };
+    }
+}
+function persistSchedulerState() {
+    try {
+        fs.mkdirSync(path.dirname(SCHEDULER_STATE_PATH), { recursive: true });
+        schedulerState.updatedAt = new Date().toISOString();
+        const payload = `${JSON.stringify(schedulerState, null, 2)}\n`;
+        const tmpPath = `${SCHEDULER_STATE_PATH}.tmp-${process.pid}-${Date.now()}`;
+        fs.writeFileSync(tmpPath, payload, 'utf-8');
+        fs.renameSync(tmpPath, SCHEDULER_STATE_PATH);
+    }
+    catch (error) {
+        logger.warn({ error }, 'Failed to persist scheduler state file');
+    }
+}
+function getConfigJobMeta(jobId) {
+    const existing = schedulerState.configJobs[jobId];
+    if (existing)
+        return existing;
+    const created = defaultConfigJobMeta();
+    schedulerState.configJobs[jobId] = created;
+    return created;
+}
+function pruneConfigJobMeta(activeJobs) {
+    const activeIds = new Set(activeJobs.map((job) => job.id));
+    let changed = false;
+    for (const id of Object.keys(schedulerState.configJobs)) {
+        if (activeIds.has(id))
             continue;
-        try {
-            const ms = CronExpressionParser.parse(task.cron_expr).next().toDate().getTime();
-            if (earliest === null || ms < earliest)
-                earliest = ms;
-        }
-        catch { /* skip invalid */ }
+        delete schedulerState.configJobs[id];
+        changed = true;
+    }
+    if (changed)
+        persistSchedulerState();
+}
+function resolveConfigJobLabel(job) {
+    const candidate = typeof job.name === 'string' ? job.name.trim() : '';
+    return candidate || job.id;
+}
+function parseCronExpression(expr, tz) {
+    const trimmedTz = tz?.trim();
+    if (trimmedTz) {
+        return CronExpressionParser.parse(expr, { tz: trimmedTz });
+    }
+    return CronExpressionParser.parse(expr);
+}
+function nextFireMsForDbTask(task, nowMs) {
+    if (task.run_at) {
+        if (task.last_run)
+            return null;
+        const ms = new Date(task.run_at).getTime();
+        return Number.isFinite(ms) ? ms : null;
+    }
+    if (task.every_ms) {
+        const lastRunMs = task.last_run ? new Date(task.last_run).getTime() : 0;
+        return lastRunMs > 0 ? lastRunMs + task.every_ms : nowMs;
+    }
+    if (!task.cron_expr)
+        return null;
+    try {
+        const ms = CronExpressionParser.parse(task.cron_expr)
+            .next()
+            .toDate()
+            .getTime();
+        return Number.isFinite(ms) ? ms : null;
+    }
+    catch {
+        return null;
+    }
+}
+function toIsoTimestamp(ms) {
+    if (ms == null || !Number.isFinite(ms))
+        return null;
+    return new Date(ms).toISOString();
+}
+function syncConfigJobNextRunAt(job, nowMs) {
+    const meta = getConfigJobMeta(job.id);
+    const nextRunAt = toIsoTimestamp(nextFireMsForConfigJob(job, nowMs));
+    if (meta.nextRunAt === nextRunAt)
+        return false;
+    meta.nextRunAt = nextRunAt;
+    return true;
+}
+function syncConfigJobsNextRunAt(jobs, nowMs) {
+    let changed = false;
+    for (const job of jobs) {
+        if (syncConfigJobNextRunAt(job, nowMs))
+            changed = true;
+    }
+    return changed;
+}
+function nextFireMsForConfigJob(job, nowMs) {
+    if (!job.enabled)
+        return null;
+    const meta = getConfigJobMeta(job.id);
+    if (meta.disabled)
+        return null;
+    if (job.schedule.kind === 'at') {
+        if (meta.oneShotCompleted)
+            return null;
+        if (!job.schedule.at)
+            return null;
+        const atMs = new Date(job.schedule.at).getTime();
+        if (!Number.isFinite(atMs))
+            return null;
+        const lastRunMs = meta.lastRun ? new Date(meta.lastRun).getTime() : 0;
+        if (atMs > nowMs)
+            return atMs;
+        if (lastRunMs <= 0)
+            return atMs;
+        return lastRunMs + CONFIG_ONESHOT_RETRY_MS;
+    }
+    if (job.schedule.kind === 'every') {
+        if (!job.schedule.everyMs)
+            return null;
+        const lastRunMs = meta.lastRun ? new Date(meta.lastRun).getTime() : 0;
+        return lastRunMs > 0 ? lastRunMs + job.schedule.everyMs : nowMs;
+    }
+    if (!job.schedule.expr)
+        return null;
+    try {
+        const ms = parseCronExpression(job.schedule.expr, job.schedule.tz || undefined)
+            .next()
+            .toDate()
+            .getTime();
+        return Number.isFinite(ms) ? ms : null;
+    }
+    catch {
+        return null;
+    }
+}
+function computeNextFireMs(nowMs = Date.now()) {
+    const dbTasks = getAllEnabledTasks();
+    const cfgJobs = getConfigSnapshot().scheduler.jobs;
+    pruneConfigJobMeta(cfgJobs);
+    if (syncConfigJobsNextRunAt(cfgJobs, nowMs)) {
+        persistSchedulerState();
+    }
+    let earliest = null;
+    for (const task of dbTasks) {
+        const fireMs = nextFireMsForDbTask(task, nowMs);
+        if (fireMs === null)
+            continue;
+        if (earliest === null || fireMs < earliest)
+            earliest = fireMs;
+    }
+    for (const job of cfgJobs) {
+        const fireMs = nextFireMsForConfigJob(job, nowMs);
+        if (fireMs === null)
+            continue;
+        if (earliest === null || fireMs < earliest)
+            earliest = fireMs;
     }
     return earliest;
 }
@@ -64,58 +268,141 @@ function arm() {
     timer = null;
     const nextFireMs = computeNextFireMs();
     if (nextFireMs === null)
-        return; // nothing scheduled
+        return;
     const delay = Math.max(nextFireMs - Date.now(), 0);
     const clamped = Math.min(delay, MAX_TIMER_DELAY_MS);
     logger.debug({ delayMs: clamped, nextFire: new Date(nextFireMs).toISOString() }, 'Scheduler armed');
     timer = setTimeout(() => {
         void tick().catch((err) => {
             logger.error({ err }, 'Scheduler tick failed');
-            arm(); // re-arm even on error
+            arm();
         });
     }, clamped);
 }
+async function dispatchDbTask(task) {
+    if (!taskRunner)
+        return;
+    const prompt = wrapCronPrompt(`#${task.id}`, task.prompt);
+    await taskRunner({
+        source: 'db-task',
+        taskId: task.id,
+        sessionId: task.session_id,
+        channelId: task.channel_id,
+        prompt,
+        actionKind: 'agent_turn',
+        delivery: {
+            kind: 'channel',
+            channelId: task.channel_id,
+        },
+    });
+}
+async function dispatchConfigJob(job) {
+    if (!taskRunner)
+        return;
+    const jobLabel = resolveConfigJobLabel(job);
+    const contextChannelId = job.delivery.kind === 'channel' ? job.delivery.to : 'scheduler';
+    const prompt = job.action.kind === 'agent_turn'
+        ? wrapCronPrompt(jobLabel, job.action.message)
+        : job.action.message;
+    await taskRunner({
+        source: 'config-job',
+        jobId: job.id,
+        sessionId: `scheduler:${job.id}`,
+        channelId: contextChannelId,
+        prompt,
+        actionKind: job.action.kind,
+        delivery: job.delivery.kind === 'channel'
+            ? { kind: 'channel', channelId: job.delivery.to }
+            : job.delivery.kind === 'last-channel'
+                ? { kind: 'last-channel' }
+                : { kind: 'webhook', webhookUrl: job.delivery.webhookUrl },
+    });
+}
+function markConfigJobSuccess(job, markOneShotDone = false) {
+    const meta = getConfigJobMeta(job.id);
+    meta.lastStatus = 'success';
+    meta.consecutiveErrors = 0;
+    if (markOneShotDone)
+        meta.oneShotCompleted = true;
+    syncConfigJobNextRunAt(job, Date.now());
+    persistSchedulerState();
+}
+function markConfigJobFailure(job) {
+    const meta = getConfigJobMeta(job.id);
+    meta.lastStatus = 'error';
+    meta.consecutiveErrors = Math.max(0, meta.consecutiveErrors) + 1;
+    if (meta.consecutiveErrors >= MAX_CONSECUTIVE_FAILURES) {
+        meta.disabled = true;
+    }
+    syncConfigJobNextRunAt(job, Date.now());
+    persistSchedulerState();
+    return {
+        disabled: meta.disabled,
+        consecutiveErrors: meta.consecutiveErrors,
+    };
+}
 async function tick() {
     if (ticking) {
-        arm(); // re-check later
+        arm();
         return;
     }
     ticking = true;
     try {
-        const tasks = getAllEnabledTasks();
+        const dbTasks = getAllEnabledTasks();
+        const cfgJobs = getConfigSnapshot().scheduler.jobs;
+        pruneConfigJobMeta(cfgJobs);
         const now = new Date();
-        for (const task of tasks) {
+        const nowMs = now.getTime();
+        for (const task of dbTasks) {
             try {
-                // --- One-shot task ---
                 if (task.run_at) {
                     const runAt = new Date(task.run_at);
-                    if (runAt.getTime() <= now.getTime() && !task.last_run) {
+                    if (runAt.getTime() <= nowMs && !task.last_run) {
                         logger.info({ taskId: task.id, runAt: task.run_at, prompt: task.prompt }, 'One-shot task firing');
-                        updateTaskLastRun(task.id); // prevents re-fire
-                        const prompt = wrapCronPrompt(task.id, task.prompt, task.prompt);
-                        taskRunner(task.session_id, task.channel_id, prompt, task.id)
-                            .then(() => deleteTask(task.id)) // cleanup on success
+                        updateTaskLastRun(task.id);
+                        dispatchDbTask(task)
+                            .then(() => {
+                            markTaskSuccess(task.id);
+                            deleteTask(task.id);
+                        })
                             .catch((err) => {
+                            const failure = markTaskFailure(task.id, MAX_CONSECUTIVE_FAILURES);
                             logger.error({ taskId: task.id, err }, 'One-shot task failed (task preserved)');
+                            if (failure.disabled) {
+                                logger.warn({
+                                    taskId: task.id,
+                                    consecutiveErrors: failure.consecutiveErrors,
+                                }, 'Scheduled task auto-disabled after repeated failures');
+                            }
                         });
                     }
                     continue;
                 }
-                // --- Interval task ---
                 if (task.every_ms) {
-                    const lastRunMs = task.last_run ? new Date(task.last_run).getTime() : 0;
-                    const dueAt = lastRunMs > 0 ? lastRunMs + task.every_ms : 0; // fire immediately if never run
-                    if (dueAt <= now.getTime()) {
+                    const lastRunMs = task.last_run
+                        ? new Date(task.last_run).getTime()
+                        : 0;
+                    const dueAt = lastRunMs > 0 ? lastRunMs + task.every_ms : 0;
+                    if (dueAt <= nowMs) {
                         logger.info({ taskId: task.id, everyMs: task.every_ms, prompt: task.prompt }, 'Interval task firing');
                         updateTaskLastRun(task.id);
-                        const prompt = wrapCronPrompt(task.id, task.prompt, task.prompt);
-                        taskRunner(task.session_id, task.channel_id, prompt, task.id).catch((err) => {
+                        dispatchDbTask(task)
+                            .then(() => {
+                            markTaskSuccess(task.id);
+                        })
+                            .catch((err) => {
+                            const failure = markTaskFailure(task.id, MAX_CONSECUTIVE_FAILURES);
                             logger.error({ taskId: task.id, err }, 'Interval task failed');
+                            if (failure.disabled) {
+                                logger.warn({
+                                    taskId: task.id,
+                                    consecutiveErrors: failure.consecutiveErrors,
+                                }, 'Scheduled task auto-disabled after repeated failures');
+                            }
                         });
                     }
                     continue;
                 }
-                // --- Recurring cron task ---
                 if (!task.cron_expr)
                     continue;
                 const cron = CronExpressionParser.parse(task.cron_expr);
@@ -124,22 +411,210 @@ async function tick() {
                 if (prev.toDate() > lastRun) {
                     logger.info({ taskId: task.id, cron: task.cron_expr, prompt: task.prompt }, 'Cron task firing');
                     updateTaskLastRun(task.id);
-                    const prompt = wrapCronPrompt(task.id, task.prompt, task.prompt);
-                    taskRunner(task.session_id, task.channel_id, prompt, task.id).catch((err) => {
+                    dispatchDbTask(task)
+                        .then(() => {
+                        markTaskSuccess(task.id);
+                    })
+                        .catch((err) => {
+                        const failure = markTaskFailure(task.id, MAX_CONSECUTIVE_FAILURES);
                         logger.error({ taskId: task.id, err }, 'Cron task failed');
+                        if (failure.disabled) {
+                            logger.warn({
+                                taskId: task.id,
+                                consecutiveErrors: failure.consecutiveErrors,
+                            }, 'Scheduled task auto-disabled after repeated failures');
+                        }
                     });
                 }
             }
             catch (err) {
-                logger.error({ taskId: task.id, cron: task.cron_expr, err }, 'Scheduler error for task');
+                logger.error({ taskId: task.id, cron: task.cron_expr, err }, 'Scheduler error for DB task');
+            }
+        }
+        for (const job of cfgJobs) {
+            if (!job.enabled)
+                continue;
+            const meta = getConfigJobMeta(job.id);
+            if (meta.disabled)
+                continue;
+            const jobLabel = resolveConfigJobLabel(job);
+            try {
+                if (job.schedule.kind === 'at') {
+                    if (meta.oneShotCompleted || !job.schedule.at)
+                        continue;
+                    const runAtMs = new Date(job.schedule.at).getTime();
+                    if (!Number.isFinite(runAtMs) || runAtMs > nowMs)
+                        continue;
+                    const lastRunMs = meta.lastRun ? new Date(meta.lastRun).getTime() : 0;
+                    if (lastRunMs > 0 && nowMs - lastRunMs < CONFIG_ONESHOT_RETRY_MS)
+                        continue;
+                    meta.lastRun = now.toISOString();
+                    persistSchedulerState();
+                    logger.info({ jobId: job.id, jobLabel, runAt: job.schedule.at }, 'Config one-shot job firing');
+                    dispatchConfigJob(job)
+                        .then(() => {
+                        markConfigJobSuccess(job, true);
+                    })
+                        .catch((err) => {
+                        const failure = markConfigJobFailure(job);
+                        logger.error({ jobId: job.id, jobLabel, err }, 'Config one-shot job failed');
+                        if (failure.disabled) {
+                            logger.warn({
+                                jobId: job.id,
+                                jobLabel,
+                                consecutiveErrors: failure.consecutiveErrors,
+                            }, 'Config scheduler job auto-disabled after repeated failures');
+                        }
+                    });
+                    continue;
+                }
+                if (job.schedule.kind === 'every') {
+                    const everyMs = job.schedule.everyMs;
+                    if (!everyMs)
+                        continue;
+                    const lastRunMs = meta.lastRun ? new Date(meta.lastRun).getTime() : 0;
+                    const dueAt = lastRunMs > 0 ? lastRunMs + everyMs : 0;
+                    if (dueAt > nowMs)
+                        continue;
+                    meta.lastRun = now.toISOString();
+                    persistSchedulerState();
+                    logger.info({ jobId: job.id, jobLabel, everyMs }, 'Config interval job firing');
+                    dispatchConfigJob(job)
+                        .then(() => {
+                        markConfigJobSuccess(job, false);
+                    })
+                        .catch((err) => {
+                        const failure = markConfigJobFailure(job);
+                        logger.error({ jobId: job.id, jobLabel, err }, 'Config interval job failed');
+                        if (failure.disabled) {
+                            logger.warn({
+                                jobId: job.id,
+                                jobLabel,
+                                consecutiveErrors: failure.consecutiveErrors,
+                            }, 'Config scheduler job auto-disabled after repeated failures');
+                        }
+                    });
+                    continue;
+                }
+                if (!job.schedule.expr)
+                    continue;
+                const cron = parseCronExpression(job.schedule.expr, job.schedule.tz || undefined);
+                const prev = cron.prev().toDate();
+                const lastRun = meta.lastRun ? new Date(meta.lastRun) : new Date(0);
+                if (prev <= lastRun)
+                    continue;
+                meta.lastRun = now.toISOString();
+                persistSchedulerState();
+                logger.info({
+                    jobId: job.id,
+                    jobLabel,
+                    expr: job.schedule.expr,
+                    tz: job.schedule.tz,
+                }, 'Config cron job firing');
+                dispatchConfigJob(job)
+                    .then(() => {
+                    markConfigJobSuccess(job, false);
+                })
+                    .catch((err) => {
+                    const failure = markConfigJobFailure(job);
+                    logger.error({ jobId: job.id, jobLabel, err }, 'Config cron job failed');
+                    if (failure.disabled) {
+                        logger.warn({
+                            jobId: job.id,
+                            jobLabel,
+                            consecutiveErrors: failure.consecutiveErrors,
+                        }, 'Config scheduler job auto-disabled after repeated failures');
+                    }
+                });
+            }
+            catch (err) {
+                logger.error({ jobId: job.id, jobLabel, err }, 'Scheduler error for config job');
             }
         }
     }
     finally {
         ticking = false;
-        arm(); // re-arm for next task
+        arm();
     }
 }
+function toRuntimeState(meta) {
+    return {
+        lastRun: meta.lastRun,
+        lastStatus: meta.lastStatus,
+        nextRunAt: meta.nextRunAt,
+        disabled: meta.disabled,
+        consecutiveErrors: meta.consecutiveErrors,
+    };
+}
+export function getConfigJobState(jobId) {
+    const normalizedJobId = jobId.trim();
+    if (!normalizedJobId)
+        return null;
+    const jobs = getConfigSnapshot().scheduler.jobs;
+    pruneConfigJobMeta(jobs);
+    const job = jobs.find((candidate) => candidate.id === normalizedJobId);
+    if (!job)
+        return null;
+    if (syncConfigJobNextRunAt(job, Date.now())) {
+        persistSchedulerState();
+    }
+    return toRuntimeState(getConfigJobMeta(normalizedJobId));
+}
+export function getSchedulerStatus() {
+    const jobs = getConfigSnapshot().scheduler.jobs;
+    pruneConfigJobMeta(jobs);
+    if (syncConfigJobsNextRunAt(jobs, Date.now())) {
+        persistSchedulerState();
+    }
+    return jobs.map((job) => {
+        const meta = getConfigJobMeta(job.id);
+        const description = typeof job.description === 'string' && job.description.trim()
+            ? job.description.trim()
+            : null;
+        return {
+            id: job.id,
+            name: resolveConfigJobLabel(job),
+            description,
+            enabled: job.enabled,
+            ...toRuntimeState(meta),
+        };
+    });
+}
+export function pauseConfigJob(jobId) {
+    const normalizedJobId = jobId.trim();
+    if (!normalizedJobId)
+        return false;
+    const jobs = getConfigSnapshot().scheduler.jobs;
+    pruneConfigJobMeta(jobs);
+    const job = jobs.find((candidate) => candidate.id === normalizedJobId);
+    if (!job)
+        return false;
+    const meta = getConfigJobMeta(normalizedJobId);
+    meta.disabled = true;
+    meta.nextRunAt = null;
+    persistSchedulerState();
+    rearmScheduler();
+    logger.info({ jobId: normalizedJobId, jobLabel: resolveConfigJobLabel(job) }, 'Config scheduler job paused');
+    return true;
+}
+export function resumeConfigJob(jobId) {
+    const normalizedJobId = jobId.trim();
+    if (!normalizedJobId)
+        return false;
+    const jobs = getConfigSnapshot().scheduler.jobs;
+    pruneConfigJobMeta(jobs);
+    const job = jobs.find((candidate) => candidate.id === normalizedJobId);
+    if (!job)
+        return false;
+    const meta = getConfigJobMeta(normalizedJobId);
+    meta.disabled = false;
+    meta.consecutiveErrors = 0;
+    syncConfigJobNextRunAt(job, Date.now());
+    persistSchedulerState();
+    rearmScheduler();
+    logger.info({ jobId: normalizedJobId, jobLabel: resolveConfigJobLabel(job) }, 'Config scheduler job resumed');
+    return true;
+}
 // --- Public API ---
 export function startScheduler(runner) {
     logger.info('Scheduler started');
@@ -147,8 +622,7 @@ export function startScheduler(runner) {
     arm();
 }
 /**
- * Re-arm the scheduler timer.  Call after creating or deleting tasks
- * so newly scheduled work is picked up immediately.
+ * Re-arm the scheduler timer. Call after creating/deleting tasks or updating config scheduler jobs.
  */
 export function rearmScheduler() {
     if (taskRunner)