@minionry/minion 0.7.36 → 0.7.39

package/dist/server/services/schedule/agent-schedule-store.js

@@ -5,10 +5,12 @@ import { existsSync, readFileSync } from 'node:fs';
 import { writeFileAtomic } from '../../utils/file-store.js';
 import { spacePath } from '../space-layout.js';
 import { isEngineId } from '../websocket/types.js';
-import { computeNextFireAt, MAX_SCHEDULE_HISTORY, SCHEDULE_MIN_INTERVAL_MS, } from './schedule-store.js';
-export { computeNextFireAt, MAX_SCHEDULE_HISTORY, SCHEDULE_MIN_INTERVAL_MS };
+import { nextWallClockFireAt, normalizeWallClockTiming } from './daily-timing.js';
+import { isValidPromptFilePath } from './prompt-file.js';
+import { computeNextFireAt, exceedsMaxLateness, isValidMaxLatenessMs, MAX_SCHEDULE_HISTORY, SCHEDULE_MIN_INTERVAL_MS, SCHEDULE_MIN_LATENESS_MS, SCHEDULE_MISSED_LATENESS_ERROR, } from './schedule-store.js';
+export { computeNextFireAt, exceedsMaxLateness, isValidMaxLatenessMs, MAX_SCHEDULE_HISTORY, SCHEDULE_MIN_INTERVAL_MS, SCHEDULE_MIN_LATENESS_MS, SCHEDULE_MISSED_LATENESS_ERROR, };
 export function isAgentScheduleTiming(timing) {
-    return timing.kind === 'once' || timing.kind === 'interval';
+    return timing.kind !== 'continuous';
 }
 export function agentScheduleStorePath(workingDir) {
     return spacePath(workingDir, 'agents', 'schedules.json');
@@ -20,6 +22,9 @@ function clampTiming(timing) {
     if (timing.kind === 'interval') {
         return { kind: 'interval', everyMs: Math.max(timing.everyMs, SCHEDULE_MIN_INTERVAL_MS) };
     }
+    if (timing.kind === 'daily' || timing.kind === 'monthly') {
+        return normalizeWallClockTiming(timing) ?? timing;
+    }
     return timing;
 }
 function isScheduleFireStatus(value) {
@@ -43,6 +48,16 @@ function normalizeTiming(raw) {
             return null;
         return clampTiming({ kind: 'interval', everyMs: t.everyMs });
     }
+    if (t.kind === 'daily' || t.kind === 'monthly') {
+        return normalizeWallClockTiming(raw);
+    }
+    return null;
+}
+function normalizeNextFireAt(raw, timing, now) {
+    if (typeof raw === 'string')
+        return raw;
+    if (timing.kind === 'daily' || timing.kind === 'monthly')
+        return nextWallClockFireAt(timing, now);
     return null;
 }
 function normalizeEngineOverride(raw) {
@@ -96,7 +111,20 @@ function normalizeLastFire(raw) {
         return undefined;
     return { at: l.at, status: l.status, tabId: l.tabId };
 }
-function normalizeAgentScheduleRecord(raw) {
+function normalizePromptFile(raw) {
+    return typeof raw === 'string' && isValidPromptFilePath(raw) ? raw : undefined;
+}
+function normalizeInitiator(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const i = raw;
+    if (typeof i.appId !== 'string' || !i.appId)
+        return undefined;
+    if (typeof i.origin !== 'string' || !i.origin)
+        return undefined;
+    return { appId: i.appId, origin: i.origin };
+}
+function normalizeAgentScheduleRecord(raw, now) {
     if (!raw || typeof raw !== 'object')
         return null;
     const r = raw;
@@ -107,21 +135,27 @@ function normalizeAgentScheduleRecord(raw) {
     const timing = normalizeTiming(r.timing);
     if (!timing)
         return null;
+    const maxLatenessMs = r.maxLatenessMs;
+    if (maxLatenessMs !== undefined && !isValidMaxLatenessMs(maxLatenessMs))
+        return null;
     const history = Array.isArray(r.history)
         ? r.history.map(normalizeHistoryEntry).filter((e) => e !== null)
         : [];
     return {
         ...r,
         id: r.id,
-        createdAt: typeof r.createdAt === 'string' ? r.createdAt : new Date().toISOString(),
+        createdAt: typeof r.createdAt === 'string' ? r.createdAt : now.toISOString(),
         name: typeof r.name === 'string' ? r.name : undefined,
         prompt: r.prompt,
+        promptFile: normalizePromptFile(r.promptFile),
+        initiator: normalizeInitiator(r.initiator),
         engineOverride: normalizeEngineOverride(r.engineOverride),
         timing,
         enabled: typeof r.enabled === 'boolean' ? r.enabled : true,
-        nextFireAt: typeof r.nextFireAt === 'string' ? r.nextFireAt : null,
+        nextFireAt: normalizeNextFireAt(r.nextFireAt, timing, now),
         lastFire: normalizeLastFire(r.lastFire),
         history,
+        maxLatenessMs,
     };
 }
 export class AgentScheduleStore {
@@ -136,8 +170,9 @@ export class AgentScheduleStore {
             if (existsSync(this.schedulesPath)) {
                 const raw = JSON.parse(readFileSync(this.schedulesPath, 'utf-8'));
                 const rawSchedules = Array.isArray(raw?.schedules) ? raw.schedules : [];
+                const now = new Date();
                 const schedules = rawSchedules
-                    .map((s) => normalizeAgentScheduleRecord(s))
+                    .map((s) => normalizeAgentScheduleRecord(s, now))
                     .filter((s) => s !== null);
                 return { version: 1, schedules };
             }
@@ -170,11 +205,14 @@ export class AgentScheduleStore {
             createdAt: now.toISOString(),
             name: fields.name,
             prompt: fields.prompt,
+            ...(fields.promptFile !== undefined ? { promptFile: fields.promptFile } : {}),
+            ...(fields.initiator !== undefined ? { initiator: fields.initiator } : {}),
             engineOverride: fields.engineOverride,
             timing,
             enabled: fields.enabled ?? true,
             nextFireAt: computeNextFireAt(timing, now),
             history: [],
+            ...(fields.maxLatenessMs !== undefined ? { maxLatenessMs: fields.maxLatenessMs } : {}),
         };
         this.data.schedules.push(record);
         this.save();
@@ -186,13 +224,20 @@ export class AgentScheduleStore {
             return undefined;
         if (patch.name !== undefined)
             record.name = patch.name;
-        if (patch.prompt !== undefined)
+        if (patch.prompt !== undefined) {
             record.prompt = patch.prompt;
+            record.promptFile = undefined;
+        }
+        if (patch.promptFile !== undefined)
+            record.promptFile = patch.promptFile;
         if (patch.engineOverride !== undefined) {
             record.engineOverride = patch.engineOverride === null ? undefined : patch.engineOverride;
         }
         if (patch.enabled !== undefined)
             record.enabled = patch.enabled;
+        if (patch.maxLatenessMs !== undefined) {
+            record.maxLatenessMs = patch.maxLatenessMs === null ? undefined : patch.maxLatenessMs;
+        }
         if (patch.timing !== undefined) {
             record.timing = clampTiming(patch.timing);
             record.nextFireAt = computeNextFireAt(record.timing, new Date());
@@ -216,6 +261,22 @@ export class AgentScheduleStore {
         this.save();
         return { ...record };
     }
+    refreshPromptFromFile(id, content) {
+        const record = this.data.schedules.find((s) => s.id === id);
+        if (!record)
+            return undefined;
+        record.prompt = content;
+        this.save();
+        return { ...record };
+    }
+    restoreNextFireAt(id, nextFireAt) {
+        const record = this.data.schedules.find((s) => s.id === id);
+        if (!record)
+            return undefined;
+        record.nextFireAt = nextFireAt;
+        this.save();
+        return { ...record };
+    }
     recordFire(id, entry, nextFireAt) {
         const record = this.data.schedules.find((s) => s.id === id);
         if (!record)

package/dist/server/services/schedule/agent-scheduler.js

@@ -4,7 +4,8 @@ import { ImprovisationSessionManager } from '../../cli/improvisation-session-man
 import { ENGINE_EFFORT_LEVELS, engineForModel } from '../../engines/types.js';
 import { getEffortLevel, getEngine, getFastMode, getModel } from '../settings.js';
 import { resolveEngineForSession, runAcceptedExecute, setupSessionListeners } from '../websocket/session-handlers.js';
-import { AgentScheduleStore } from './agent-schedule-store.js';
+import { AgentScheduleStore, computeNextFireAt, exceedsMaxLateness, SCHEDULE_MISSED_LATENESS_ERROR, } from './agent-schedule-store.js';
+import { readPromptFile } from './prompt-file.js';
 import { SCHEDULE_ONCE_GRACE_MS } from './scheduler.js';
 export const AGENT_SCHEDULER_TICK_MS = 30_000;
 export { SCHEDULE_ONCE_GRACE_MS };
@@ -74,6 +75,26 @@ export class AgentSchedulerEngine {
         this.runs.reset();
         this.store = null;
     }
+    fireNow(scheduleId) {
+        const store = this.store;
+        if (!store)
+            return { kind: 'not-found' };
+        this.reapFinishedRuns();
+        const before = store.get(scheduleId);
+        if (!before)
+            return { kind: 'not-found' };
+        if (!before.enabled)
+            return { kind: 'disabled' };
+        const plannedNextFireAt = before.nextFireAt;
+        if (this.runs.has(scheduleId)) {
+            this.recordSkippedOverlap(before, Date.now());
+        }
+        else {
+            this.fire(before, Date.now());
+        }
+        store.restoreNextFireAt(scheduleId, plannedNextFireAt);
+        return { kind: 'ok', record: store.get(scheduleId) };
+    }
     tick() {
         const store = this.store;
         if (!store)
@@ -94,6 +115,10 @@ export class AgentSchedulerEngine {
             }
             if (!this.isDue(record, now))
                 continue;
+            if (exceedsMaxLateness(record, now)) {
+                this.recordMissedLate(record, now);
+                continue;
+            }
             this.fire(record, now);
         }
     }
@@ -140,9 +165,18 @@ export class AgentSchedulerEngine {
         if (!store)
             return;
         const firedAt = new Date(now).toISOString();
+        let runRecord = record;
+        if (record.promptFile) {
+            const result = readPromptFile(this.workingDir, record.promptFile);
+            if (!result.ok) {
+                this.recordFailedFire(record, firedAt, result.reason);
+                return;
+            }
+            runRecord = store.refreshPromptFromFile(record.id, result.content) ?? { ...record, prompt: result.content };
+        }
         let handle;
         try {
-            handle = (this.deps.launch ?? launchScheduledAgentRun)(this.ctx, this.workingDir, record);
+            handle = (this.deps.launch ?? launchScheduledAgentRun)(this.ctx, this.workingDir, runRecord);
         }
         catch (error) {
             this.recordFailedFire(record, firedAt, errorMessage(error));
@@ -203,20 +237,27 @@ export class AgentSchedulerEngine {
         }, this.nextFireAtAfterStart(record, now));
         this.broadcastSchedules();
     }
+    recordMissedLate(record, now) {
+        const store = this.store;
+        if (!store)
+            return;
+        store.recordFire(record.id, { at: new Date(now).toISOString(), status: 'missed', tabId: null, error: SCHEDULE_MISSED_LATENESS_ERROR }, this.nextFireAtAfterStart(record, now));
+        this.broadcastSchedules();
+    }
     nextFireAtAfterStart(record, now) {
-        if (record.timing.kind === 'interval')
-            return new Date(now + record.timing.everyMs).toISOString();
-        return null;
+        if (record.timing.kind === 'once')
+            return null;
+        return computeNextFireAt(record.timing, new Date(now));
     }
     nextFireAtAfterFailure(record, now) {
         if (record.timing.kind === 'once')
             return null;
-        return new Date(now + record.timing.everyMs).toISOString();
+        return computeNextFireAt(record.timing, new Date(now));
     }
     nextFireAtAfterSettle(record, now) {
         if (record.timing.kind === 'once')
             return null;
-        return this.store?.get(record.id)?.nextFireAt ?? new Date(now + record.timing.everyMs).toISOString();
+        return this.store?.get(record.id)?.nextFireAt ?? computeNextFireAt(record.timing, new Date(now));
     }
     broadcastSchedules() {
         if (!this.store)

package/dist/server/services/schedule/daily-timing.js

@@ -3,6 +3,7 @@
 const TIME_PATTERN = /^([01]\d|2[0-3]):[0-5]\d$/;
 const WEEKDAY_NAMES = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
 const CANDIDATE_DAYS = 8;
+const CANDIDATE_MONTHS = 13;
 const formatterCache = new Map();
 function zoneFormatter(timeZone) {
     let formatter = formatterCache.get(timeZone);
@@ -61,6 +62,32 @@ export function normalizeDailyTiming(raw) {
         timing.days = [...new Set(raw.days)].sort((a, b) => a - b);
     return timing;
 }
+function isDayOfMonth(raw) {
+    return raw === 'last' || (Number.isInteger(raw) && raw >= 1 && raw <= 31);
+}
+export function isValidMonthlyTiming(raw) {
+    if (!raw || typeof raw !== 'object')
+        return false;
+    const t = raw;
+    if (t.kind !== 'monthly')
+        return false;
+    if (typeof t.time !== 'string' || !TIME_PATTERN.test(t.time))
+        return false;
+    if (!isValidTimeZone(t.timeZone))
+        return false;
+    return isDayOfMonth(t.dayOfMonth);
+}
+export function normalizeMonthlyTiming(raw) {
+    if (!isValidMonthlyTiming(raw))
+        return null;
+    return { kind: 'monthly', time: raw.time, timeZone: raw.timeZone, dayOfMonth: raw.dayOfMonth };
+}
+export function isValidWallClockTiming(raw) {
+    return isValidDailyTiming(raw) || isValidMonthlyTiming(raw);
+}
+export function normalizeWallClockTiming(raw) {
+    return normalizeDailyTiming(raw) ?? normalizeMonthlyTiming(raw);
+}
 export function zonedParts(instant, timeZone) {
     const parts = zoneFormatter(timeZone).formatToParts(new Date(instant));
     const read = (type) => parts.find((part) => part.type === type)?.value ?? '0';
@@ -103,3 +130,28 @@ export function nextDailyFireAt(timing, from) {
     }
     throw new Error(`no daily slot within ${CANDIDATE_DAYS} days for ${timing.time} in ${timing.timeZone}`);
 }
+function daysInMonth(year, month) {
+    return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+export function nextMonthlyFireAt(timing, from) {
+    const [hour, minute] = timing.time.split(':').map(Number);
+    const fromMs = from.getTime();
+    const today = zonedParts(fromMs, timing.timeZone);
+    for (let offset = 0; offset < CANDIDATE_MONTHS; offset++) {
+        const monthIndex = today.month - 1 + offset;
+        const year = today.year + Math.floor(monthIndex / 12);
+        const month = (monthIndex % 12) + 1;
+        const lastDay = daysInMonth(year, month);
+        const day = timing.dayOfMonth === 'last' ? lastDay : timing.dayOfMonth;
+        if (day > lastDay)
+            continue;
+        const candidate = instantForWallTime(year, month, day, hour, minute, timing.timeZone);
+        if (candidate <= fromMs)
+            continue;
+        return new Date(candidate).toISOString();
+    }
+    throw new Error(`no monthly slot within ${CANDIDATE_MONTHS} months for day ${timing.dayOfMonth} at ${timing.time} in ${timing.timeZone}`);
+}
+export function nextWallClockFireAt(timing, from) {
+    return timing.kind === 'daily' ? nextDailyFireAt(timing, from) : nextMonthlyFireAt(timing, from);
+}

package/dist/server/services/schedule/prompt-file.js

@@ -0,0 +1,55 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { readFileSync, statSync } from 'node:fs';
+import { guardWorkspacePath } from '../sdk/files-workspace.js';
+export const PROMPT_FILE_MAX_BYTES = 262_144;
+export function isValidPromptFilePath(path) {
+    if (typeof path !== 'string' || path.length === 0 || path.startsWith('/'))
+        return false;
+    return path.split('/').every((segment) => segment !== '..');
+}
+export function readPromptFile(workingDir, promptFile) {
+    if (!isValidPromptFilePath(promptFile)) {
+        return {
+            ok: false,
+            reason: `promptFile '${promptFile}' must be a Space-relative POSIX path with no leading '/' and no '..' segment`,
+        };
+    }
+    let resolvedPath;
+    try {
+        ;
+        ({ resolvedPath } = guardWorkspacePath(workingDir, promptFile));
+    }
+    catch (error) {
+        return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+    }
+    let stat;
+    try {
+        stat = statSync(resolvedPath);
+    }
+    catch {
+        return { ok: false, reason: `promptFile '${promptFile}' does not exist` };
+    }
+    if (stat.isDirectory()) {
+        return { ok: false, reason: `promptFile '${promptFile}' is a directory, not a file` };
+    }
+    if (stat.size > PROMPT_FILE_MAX_BYTES) {
+        return {
+            ok: false,
+            reason: `promptFile '${promptFile}' is ${stat.size} bytes — exceeds the ${PROMPT_FILE_MAX_BYTES}-byte limit`,
+        };
+    }
+    const buffer = readFileSync(resolvedPath);
+    let content;
+    try {
+        content = new TextDecoder('utf-8', { fatal: true }).decode(buffer);
+    }
+    catch {
+        return { ok: false, reason: `promptFile '${promptFile}' is not valid UTF-8` };
+    }
+    const trimmed = content.trim();
+    if (trimmed.length === 0) {
+        return { ok: false, reason: `promptFile '${promptFile}' is empty after trimming` };
+    }
+    return { ok: true, content: trimmed };
+}

package/dist/server/services/schedule/run-bootstrap.js

@@ -123,16 +123,31 @@ function ensureStateFile(boardDir) {
     writeFileSync(statePath, skeleton, 'utf-8');
 }
 export function writeRunInputFile(boardDir, options) {
+    const outDir = join(boardDir, 'out');
+    const path = join(outDir, 'run-input.json');
+    let existing = null;
+    if (options.upstream && existsSync(path)) {
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+            return null;
+        existing = parsed;
+    }
+    const scheduleId = options.scheduleId ?? existing?.scheduleId;
     const file = {
         schema: RUN_INPUT_SCHEMA,
-        runAt: options.runAt ?? new Date().toISOString(),
+        runAt: options.runAt ?? existing?.runAt ?? new Date().toISOString(),
         boardId: options.boardId,
-        ...(options.scheduleId ? { scheduleId: options.scheduleId } : {}),
-        data: options.data,
+        ...(scheduleId ? { scheduleId } : {}),
+        data: options.data !== undefined ? options.data : existing && 'data' in existing ? existing.data : null,
+        ...(options.upstream ? { upstream: options.upstream } : {}),
     };
-    const outDir = join(boardDir, 'out');
     mkdirSync(outDir, { recursive: true });
-    const path = join(outDir, 'run-input.json');
     writeFileSync(path, JSON.stringify(file, null, 2), 'utf-8');
     return path;
 }

package/dist/server/services/schedule/schedule-store.js

@@ -4,8 +4,14 @@ import { randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { defaultPmDir } from '../plan/parser.js';
+import { nextWallClockFireAt, normalizeWallClockTiming } from './daily-timing.js';
+export function isRecurringTiming(timing) {
+    return timing.kind !== 'once' && timing.kind !== 'continuous';
+}
 export const SCHEDULE_MIN_INTERVAL_MS = 60_000;
 export const MAX_SCHEDULE_HISTORY = 20;
+export const SCHEDULE_MIN_LATENESS_MS = 60_000;
+export const SCHEDULE_MISSED_LATENESS_ERROR = 'missed by more than the allowed lateness';
 function generateScheduleId() {
     return `sched-${randomUUID().replace(/-/g, '').slice(0, 8)}`;
 }
@@ -13,8 +19,14 @@ function clampTiming(timing) {
     if (timing.kind === 'interval') {
         return { kind: 'interval', everyMs: Math.max(timing.everyMs, SCHEDULE_MIN_INTERVAL_MS) };
     }
+    if (timing.kind === 'daily' || timing.kind === 'monthly') {
+        return normalizeWallClockTiming(timing) ?? timing;
+    }
     return timing;
 }
+export function isValidMaxLatenessMs(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= SCHEDULE_MIN_LATENESS_MS;
+}
 export function computeNextFireAt(timing, from) {
     if (timing.kind === 'once') {
         const at = new Date(timing.at);
@@ -26,8 +38,19 @@ export function computeNextFireAt(timing, from) {
         const everyMs = Math.max(timing.everyMs, SCHEDULE_MIN_INTERVAL_MS);
         return new Date(from.getTime() + everyMs).toISOString();
     }
+    if (timing.kind === 'daily' || timing.kind === 'monthly') {
+        return nextWallClockFireAt(timing, from);
+    }
     return null;
 }
+export function exceedsMaxLateness(record, now) {
+    if (record.maxLatenessMs === undefined || !isRecurringTiming(record.timing))
+        return false;
+    if (!record.nextFireAt)
+        return false;
+    const planned = Date.parse(record.nextFireAt);
+    return Number.isFinite(planned) && now - planned > record.maxLatenessMs;
+}
 function isScheduleFireStatus(value) {
     return value === 'started' || value === 'completed' || value === 'failed' || value === 'skipped-overlap' || value === 'missed';
 }
@@ -61,6 +84,9 @@ function normalizeTiming(raw) {
     if (t.kind === 'continuous') {
         return { kind: 'continuous' };
     }
+    if (t.kind === 'daily' || t.kind === 'monthly') {
+        return normalizeWallClockTiming(raw);
+    }
     return null;
 }
 function normalizeInput(raw) {
@@ -95,7 +121,14 @@ function normalizeLastFire(raw) {
         return undefined;
     return { at: l.at, status: l.status, boardId: l.boardId };
 }
-function normalizeScheduleRecord(raw) {
+function normalizeNextFireAt(raw, timing, now) {
+    if (typeof raw === 'string')
+        return raw;
+    if (timing.kind === 'daily' || timing.kind === 'monthly')
+        return nextWallClockFireAt(timing, now);
+    return null;
+}
+function normalizeScheduleRecord(raw, now) {
     if (!raw || typeof raw !== 'object')
         return null;
     const r = raw;
@@ -105,22 +138,26 @@ function normalizeScheduleRecord(raw) {
     const timing = normalizeTiming(r.timing);
     if (!source || !timing)
         return null;
+    const maxLatenessMs = r.maxLatenessMs;
+    if (maxLatenessMs !== undefined && !isValidMaxLatenessMs(maxLatenessMs))
+        return null;
     const history = Array.isArray(r.history)
         ? (r.history.map(normalizeHistoryEntry).filter((e) => e !== null))
         : [];
     return {
         ...r,
         id: r.id,
-        createdAt: typeof r.createdAt === 'string' ? r.createdAt : new Date().toISOString(),
+        createdAt: typeof r.createdAt === 'string' ? r.createdAt : now.toISOString(),
         name: typeof r.name === 'string' ? r.name : undefined,
         source,
         input: normalizeInput(r.input),
         timing,
         enabled: typeof r.enabled === 'boolean' ? r.enabled : true,
-        nextFireAt: typeof r.nextFireAt === 'string' ? r.nextFireAt : null,
+        nextFireAt: normalizeNextFireAt(r.nextFireAt, timing, now),
         lastFire: normalizeLastFire(r.lastFire),
         history,
         consecutiveEmptyRuns: typeof r.consecutiveEmptyRuns === 'number' ? r.consecutiveEmptyRuns : 0,
+        maxLatenessMs,
     };
 }
 export class ScheduleStore {
@@ -142,8 +179,9 @@ export class ScheduleStore {
             if (existsSync(this.schedulesPath)) {
                 const raw = JSON.parse(readFileSync(this.schedulesPath, 'utf-8'));
                 const rawSchedules = Array.isArray(raw?.schedules) ? raw.schedules : [];
+                const now = new Date();
                 const schedules = rawSchedules
-                    .map((s) => normalizeScheduleRecord(s))
+                    .map((s) => normalizeScheduleRecord(s, now))
                     .filter((s) => s !== null);
                 return { version: 1, schedules };
             }
@@ -182,6 +220,7 @@ export class ScheduleStore {
             nextFireAt: computeNextFireAt(timing, now),
             history: [],
             consecutiveEmptyRuns: 0,
+            ...(fields.maxLatenessMs !== undefined ? { maxLatenessMs: fields.maxLatenessMs } : {}),
         };
         this.data.schedules.push(record);
         this.save();
@@ -197,6 +236,9 @@ export class ScheduleStore {
             record.input = patch.input === null ? undefined : patch.input;
         if (patch.enabled !== undefined)
             record.enabled = patch.enabled;
+        if (patch.maxLatenessMs !== undefined) {
+            record.maxLatenessMs = patch.maxLatenessMs === null ? undefined : patch.maxLatenessMs;
+        }
         if (patch.timing !== undefined) {
             record.timing = clampTiming(patch.timing);
             record.nextFireAt = computeNextFireAt(record.timing, new Date());
@@ -220,6 +262,14 @@ export class ScheduleStore {
         this.save();
         return { ...record };
     }
+    restoreNextFireAt(id, nextFireAt) {
+        const record = this.data.schedules.find((s) => s.id === id);
+        if (!record)
+            return undefined;
+        record.nextFireAt = nextFireAt;
+        this.save();
+        return { ...record };
+    }
     recordFire(id, lastFire, nextFireAt, consecutiveEmptyRuns) {
         const record = this.data.schedules.find((s) => s.id === id);
         if (!record)

package/dist/server/services/schedule/schedule-wire.js

@@ -3,6 +3,8 @@
 import { randomUUID } from 'node:crypto';
 import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join, relative } from 'node:path';
+import { isValidWallClockTiming } from './daily-timing.js';
+import { isValidMaxLatenessMs } from './schedule-store.js';
 import { resolveTemplateSource, TemplateSourceError } from './template-source.js';
 export function parseCreateSourceWire(raw) {
     if (!raw || typeof raw !== 'object')
@@ -24,8 +26,15 @@ export function isValidTiming(t) {
         return typeof timing.at === 'string' && !Number.isNaN(Date.parse(timing.at));
     if (timing.kind === 'interval')
         return typeof timing.everyMs === 'number' && Number.isFinite(timing.everyMs);
+    if (timing.kind === 'daily' || timing.kind === 'monthly')
+        return isValidWallClockTiming(t);
     return timing.kind === 'continuous';
 }
+export function parseMaxLatenessMs(raw) {
+    if (raw === undefined)
+        return { ok: true, value: undefined };
+    return isValidMaxLatenessMs(raw) ? { ok: true, value: raw } : { ok: false };
+}
 export function resolveCreateSource(raw, workingDir, pmDir) {
     const retentionKey = randomUUID();
     const retentionDir = join(pmDir, 'schedules', retentionKey);
@@ -73,5 +82,13 @@ export function parseUpdatePatch(patch) {
             return null;
         safePatch.timing = patch.timing;
     }
+    if (patch.maxLatenessMs === null) {
+        safePatch.maxLatenessMs = null;
+    }
+    else if (patch.maxLatenessMs !== undefined) {
+        if (!isValidMaxLatenessMs(patch.maxLatenessMs))
+            return null;
+        safePatch.maxLatenessMs = patch.maxLatenessMs;
+    }
     return safePatch;
 }