pulseed 0.4.17 → 0.4.19

package/dist/runtime/schedule/engine.js

@@ -0,0 +1,1037 @@
+import { CronExpressionParser } from "cron-parser";
+import * as path from "node:path";
+import * as net from "node:net";
+import { randomUUID } from "node:crypto";
+import { exec } from "node:child_process";
+import { ScheduleEntrySchema, ScheduleResultSchema, } from "../types/schedule.js";
+import { CronConfigSchema, GoalTriggerConfigSchema, HeartbeatConfigSchema, ProbeConfigSchema, } from "../types/schedule.js";
+import { executeCron, executeGoalTrigger, executeProbe } from "./engine-layers.js";
+import { ScheduleHistoryStore, } from "./history.js";
+import { projectSchedulesToSoil, rebuildSoilIndex } from "../../platform/soil/index.js";
+import { hasConfiguredSoilPublishProvider } from "../../platform/soil/publish/index.js";
+import { buildSchedulePresetEntry } from "./presets.js";
+import { ExternalScheduleEntrySchema } from "./source.js";
+import { ScheduleEntryStore } from "./entry-store.js";
+const DEFAULT_RETRY_POLICY = {
+    enabled: true,
+    initial_delay_ms: 30_000,
+    max_delay_ms: 15 * 60 * 1000,
+    multiplier: 2,
+    jitter_factor: 0.2,
+    max_attempts: 3,
+    max_retry_window_ms: 24 * 60 * 60 * 1000,
+    retryable_failure_kinds: ["transient"],
+};
+const noopLogger = {
+    info: (_msg, _ctx) => { },
+    warn: (_msg, _ctx) => { },
+    error: (_msg, _ctx) => { },
+};
+export class ScheduleEngine {
+    entries = [];
+    baseDir;
+    logger;
+    dataSourceRegistry;
+    llmClient;
+    notificationDispatcher;
+    coreLoop;
+    stateManager;
+    reportingEngine;
+    hookManager;
+    memoryLifecycle;
+    knowledgeManager;
+    historyStore;
+    entryStore;
+    constructor(deps) {
+        this.baseDir = deps.baseDir;
+        this.logger = deps.logger ?? noopLogger;
+        this.dataSourceRegistry = deps.dataSourceRegistry;
+        this.llmClient = deps.llmClient;
+        this.notificationDispatcher = deps.notificationDispatcher;
+        this.coreLoop = deps.coreLoop;
+        this.stateManager = deps.stateManager;
+        this.reportingEngine = deps.reportingEngine;
+        this.hookManager = deps.hookManager;
+        this.memoryLifecycle = deps.memoryLifecycle;
+        this.knowledgeManager = deps.knowledgeManager;
+        this.historyStore = new ScheduleHistoryStore(this.baseDir);
+        this.entryStore = new ScheduleEntryStore(this.baseDir, this.logger, async (entries) => {
+            this.entries = entries;
+            await this.projectCurrentSchedulesToSoil();
+        });
+    }
+    // ─── Persistence ───
+    async loadEntries() {
+        this.entries = await this.readEntriesFromDisk();
+        await this.projectCurrentSchedulesToSoil();
+        return this.entries;
+    }
+    async readEntriesFromDisk() {
+        return this.entryStore.readEntries();
+    }
+    async saveEntries() {
+        await this.entryStore.saveEntries(this.entries);
+    }
+    async writeEntriesAndProject() {
+        await this.entryStore.saveEntries(this.entries);
+    }
+    async refreshEntriesForMutation() {
+        this.entries = await this.readEntriesFromDisk();
+    }
+    captureExecutionSideEffects(entryId) {
+        const entry = this.entries.find((candidate) => candidate.id === entryId);
+        return entry ? { baseline_results: entry.baseline_results } : null;
+    }
+    applyExecutionSideEffects(entryId, sideEffects) {
+        if (!sideEffects)
+            return;
+        const idx = this.entries.findIndex((candidate) => candidate.id === entryId);
+        if (idx === -1)
+            return;
+        this.entries[idx] = {
+            ...this.entries[idx],
+            baseline_results: sideEffects.baseline_results,
+        };
+    }
+    async withScheduleMutation(mutate) {
+        return this.withScheduleFileLock(async () => {
+            const previousEntries = this.entries;
+            await this.refreshEntriesForMutation();
+            try {
+                const result = await mutate();
+                await this.saveEntries();
+                return result;
+            }
+            catch (error) {
+                this.entries = previousEntries;
+                throw error;
+            }
+        });
+    }
+    async withScheduleFileLock(work) {
+        return this.entryStore.withLock(work);
+    }
+    async ensureSoilPublishSchedule() {
+        return this.withScheduleMutation(async () => {
+            const configured = await hasConfiguredSoilPublishProvider({ baseDir: this.baseDir });
+            if (!configured) {
+                return null;
+            }
+            const existing = this.entries.find((entry) => entry.layer === "cron" &&
+                (entry.cron?.job_kind === "soil_publish" || entry.metadata?.preset_key === "soil_publish"));
+            if (existing) {
+                return existing;
+            }
+            return this.addEntryInMemory(buildSchedulePresetEntry({ preset: "soil_publish" }));
+        });
+    }
+    async projectCurrentSchedulesToSoil() {
+        try {
+            await projectSchedulesToSoil({ entries: this.entries, baseDir: this.baseDir });
+            await rebuildSoilIndex({ rootDir: path.join(this.baseDir, "soil") });
+        }
+        catch (error) {
+            this.logger.warn("Failed to project schedules into Soil", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    getEntries() {
+        return this.entries;
+    }
+    getBaseDir() {
+        return this.baseDir;
+    }
+    async syncExternalSources(sources) {
+        return this.withScheduleMutation(async () => {
+            const seenKeys = new Set();
+            const reconciledSourceIds = new Set();
+            const errors = [];
+            let added = 0;
+            let updated = 0;
+            let skipped = 0;
+            for (const source of sources) {
+                try {
+                    const health = await source.healthCheck();
+                    if (!health.healthy) {
+                        errors.push({ source_id: source.id, message: health.error ?? "source is unhealthy" });
+                        continue;
+                    }
+                    const rawEntries = await source.fetchEntries();
+                    const sourceIdsFromFetchedEntries = new Set([source.id]);
+                    let sourceHadEntryErrors = false;
+                    for (const raw of rawEntries) {
+                        const parsed = ExternalScheduleEntrySchema.safeParse(raw);
+                        if (!parsed.success) {
+                            sourceHadEntryErrors = true;
+                            skipped++;
+                            errors.push({ source_id: source.id, message: parsed.error.message });
+                            continue;
+                        }
+                        const external = parsed.data;
+                        sourceIdsFromFetchedEntries.add(external.source_id);
+                        const entryInput = this.buildExternalScheduleEntryInput(external);
+                        if (!entryInput) {
+                            sourceHadEntryErrors = true;
+                            skipped++;
+                            errors.push({ source_id: external.source_id, message: `missing ${external.layer} config for ${external.external_id}` });
+                            continue;
+                        }
+                        const key = this.externalEntryKey(external.source_id, external.external_id);
+                        seenKeys.add(key);
+                        const existingIndex = this.entries.findIndex((entry) => entry.metadata?.source === "external" &&
+                            entry.metadata.external_source_id === external.source_id &&
+                            entry.metadata.external_id === external.external_id);
+                        if (existingIndex === -1) {
+                            this.entries.push(ScheduleEntrySchema.parse({
+                                ...entryInput,
+                                id: randomUUID(),
+                                created_at: new Date().toISOString(),
+                                updated_at: new Date().toISOString(),
+                                last_fired_at: null,
+                                next_fire_at: this.computeNextFireAt(entryInput.trigger),
+                                consecutive_failures: 0,
+                                last_escalation_at: null,
+                                baseline_results: [],
+                                total_executions: 0,
+                                total_tokens_used: 0,
+                            }));
+                            added++;
+                            continue;
+                        }
+                        const existing = this.entries[existingIndex];
+                        const candidate = ScheduleEntrySchema.parse({
+                            ...existing,
+                            ...entryInput,
+                            id: existing.id,
+                            created_at: existing.created_at,
+                            updated_at: existing.updated_at,
+                            next_fire_at: JSON.stringify(existing.trigger) === JSON.stringify(entryInput.trigger)
+                                ? existing.next_fire_at
+                                : this.computeNextFireAt(entryInput.trigger),
+                        });
+                        if (JSON.stringify(existing) !== JSON.stringify(candidate)) {
+                            this.entries[existingIndex] = ScheduleEntrySchema.parse({
+                                ...candidate,
+                                updated_at: new Date().toISOString(),
+                            });
+                            updated++;
+                        }
+                    }
+                    if (!sourceHadEntryErrors) {
+                        for (const sourceId of sourceIdsFromFetchedEntries) {
+                            reconciledSourceIds.add(sourceId);
+                        }
+                    }
+                }
+                catch (error) {
+                    errors.push({ source_id: source.id, message: error instanceof Error ? error.message : String(error) });
+                }
+            }
+            let disabled = 0;
+            this.entries = this.entries.map((entry) => {
+                if (entry.metadata?.source !== "external" ||
+                    !entry.enabled ||
+                    !entry.metadata.external_source_id ||
+                    !reconciledSourceIds.has(entry.metadata.external_source_id)) {
+                    return entry;
+                }
+                const key = this.externalEntryKey(entry.metadata.external_source_id, entry.metadata.external_id ?? "");
+                if (seenKeys.has(key)) {
+                    return entry;
+                }
+                disabled++;
+                return ScheduleEntrySchema.parse({
+                    ...entry,
+                    enabled: false,
+                    updated_at: new Date().toISOString(),
+                });
+            });
+            if (added > 0 || updated > 0 || disabled > 0) {
+                await this.saveEntries();
+            }
+            return { added, updated, disabled, skipped, errors };
+        });
+    }
+    // ─── Entry management ───
+    async addEntry(input) {
+        return this.withScheduleMutation(async () => this.addEntryInMemory(input));
+    }
+    addEntryInMemory(input) {
+        const now = new Date().toISOString();
+        const entry = ScheduleEntrySchema.parse({
+            ...input,
+            id: randomUUID(),
+            created_at: now,
+            updated_at: now,
+            last_fired_at: null,
+            next_fire_at: this.computeNextFireAt(input.trigger),
+            consecutive_failures: 0,
+            last_escalation_at: null,
+            baseline_results: [],
+            total_executions: 0,
+            total_tokens_used: 0,
+        });
+        this.entries.push(entry);
+        return entry;
+    }
+    async removeEntry(id) {
+        return this.withScheduleMutation(async () => {
+            const before = this.entries.length;
+            this.entries = this.entries.filter((e) => e.id !== id);
+            if (this.entries.length === before)
+                return false;
+            return true;
+        });
+    }
+    async updateEntry(id, patch) {
+        return this.withScheduleMutation(async () => {
+            const idx = this.entries.findIndex((entry) => entry.id === id);
+            if (idx === -1)
+                return null;
+            const hasUpdatableFields = patch.name !== undefined ||
+                patch.enabled !== undefined ||
+                patch.trigger !== undefined ||
+                patch.heartbeat !== undefined ||
+                patch.probe !== undefined ||
+                patch.cron !== undefined ||
+                patch.goal_trigger !== undefined ||
+                patch.escalation !== undefined ||
+                patch.retry_policy !== undefined;
+            if (!hasUpdatableFields) {
+                throw new Error("No updatable fields provided");
+            }
+            const current = this.entries[idx];
+            const layerConfigFields = [
+                ["heartbeat", patch.heartbeat],
+                ["probe", patch.probe],
+                ["cron", patch.cron],
+                ["goal_trigger", patch.goal_trigger],
+            ];
+            for (const [field, value] of layerConfigFields) {
+                if (value === undefined)
+                    continue;
+                if (current.layer !== field) {
+                    throw new Error(`Cannot update ${field} config for ${current.layer} entry`);
+                }
+            }
+            const nextEntry = { ...current };
+            if (patch.name !== undefined)
+                nextEntry.name = patch.name;
+            if (patch.enabled !== undefined)
+                nextEntry.enabled = patch.enabled;
+            if (patch.trigger !== undefined)
+                nextEntry.trigger = patch.trigger;
+            if (patch.heartbeat !== undefined)
+                nextEntry.heartbeat = patch.heartbeat;
+            if (patch.probe !== undefined)
+                nextEntry.probe = patch.probe;
+            if (patch.cron !== undefined)
+                nextEntry.cron = patch.cron;
+            if (patch.goal_trigger !== undefined)
+                nextEntry.goal_trigger = patch.goal_trigger;
+            if (patch.retry_policy !== undefined)
+                nextEntry.retry_policy = patch.retry_policy;
+            if (patch.escalation !== undefined) {
+                if (patch.escalation === null) {
+                    delete nextEntry.escalation;
+                }
+                else {
+                    nextEntry.escalation = patch.escalation;
+                }
+            }
+            if (patch.trigger !== undefined || (current.enabled === false && patch.enabled === true)) {
+                nextEntry.next_fire_at = this.computeNextFireAt(nextEntry.trigger);
+                nextEntry.retry_state = null;
+            }
+            nextEntry.updated_at = new Date().toISOString();
+            const parsedEntry = ScheduleEntrySchema.parse(nextEntry);
+            const nextEntries = [...this.entries];
+            nextEntries[idx] = parsedEntry;
+            this.entries = nextEntries;
+            return parsedEntry;
+        });
+    }
+    // ─── Scheduling ───
+    async getDueEntries() {
+        return (await this.getDueEntryDescriptors()).map((descriptor) => descriptor.entry);
+    }
+    async getRecentHistory(limit = 20, entryId) {
+        const history = await this.historyStore.load();
+        const filtered = entryId ? history.filter((record) => record.entry_id === entryId) : history;
+        return filtered.slice(-limit);
+    }
+    async runEntryNow(entryId, options = {}) {
+        const entry = await this.withScheduleFileLock(async () => {
+            await this.refreshEntriesForMutation();
+            return this.entries.find((candidate) => candidate.id === entryId) ?? null;
+        });
+        if (!entry) {
+            return null;
+        }
+        const scheduledFor = new Date().toISOString();
+        const immediateEntry = {
+            ...entry,
+            enabled: true,
+            next_fire_at: scheduledFor,
+        };
+        const executedResult = await this.executeEntry(immediateEntry);
+        const sideEffects = entry.layer === "probe"
+            ? this.captureExecutionSideEffects(entry.id)
+            : null;
+        const applied = await this.withScheduleFileLock(async () => {
+            await this.refreshEntriesForMutation();
+            const outcome = await this.applyExecutionOutcome(entry.id, executedResult, "manual_run", scheduledFor, { preserveEnabled: options.preserveEnabled ?? true });
+            if (outcome) {
+                this.applyExecutionSideEffects(entry.id, sideEffects);
+                await this.writeEntriesAndProject();
+            }
+            return outcome;
+        });
+        let finalResult = executedResult;
+        if (options.allowEscalation && applied?.entry) {
+            const escalationResult = await this.checkEscalation(applied.entry, executedResult);
+            if (escalationResult !== null) {
+                finalResult = escalationResult;
+            }
+        }
+        if (applied) {
+            await this.recordHistory({
+                entry_id: applied.entry?.id ?? entry.id,
+                entry_name: applied.entry?.name ?? entry.name,
+                layer: entry.layer,
+                result: {
+                    ...finalResult,
+                    failure_kind: applied.failureKind,
+                },
+                reason: "manual_run",
+                attempt: applied.attempt,
+                scheduled_for: scheduledFor,
+                started_at: applied.startedAt,
+                finished_at: applied.finishedAt,
+                retry_at: applied.retryAt,
+                failure_kind: applied.failureKind,
+            });
+        }
+        return {
+            entry: applied?.entry ?? null,
+            result: finalResult,
+            reason: "manual_run",
+        };
+    }
+    async getDueEntryDescriptors() {
+        const now = Date.now();
+        return this.entries.flatMap((entry) => {
+            if (!entry.enabled) {
+                return [];
+            }
+            const retryState = entry.retry_state ?? null;
+            if (retryState?.next_retry_at) {
+                return new Date(retryState.next_retry_at).getTime() <= now
+                    ? [{ entry, reason: "retry", scheduledFor: retryState.next_retry_at }]
+                    : [];
+            }
+            return new Date(entry.next_fire_at).getTime() <= now
+                ? [{ entry, reason: "cadence", scheduledFor: entry.next_fire_at }]
+                : [];
+        });
+    }
+    async tick() {
+        const due = await this.withScheduleFileLock(async () => {
+            await this.refreshEntriesForMutation();
+            // Reset daily budget for entries whose budget_reset_at is null or in the past
+            const nowMs = Date.now();
+            let budgetReset = false;
+            for (let i = 0; i < this.entries.length; i++) {
+                const e = this.entries[i];
+                if (!e.budget_reset_at || new Date(e.budget_reset_at).getTime() <= nowMs) {
+                    this.entries[i] = {
+                        ...e,
+                        tokens_used_today: 0,
+                        budget_reset_at: new Date(nowMs + 24 * 60 * 60 * 1000).toISOString(),
+                    };
+                    budgetReset = true;
+                }
+            }
+            if (budgetReset) {
+                await this.writeEntriesAndProject();
+            }
+            return this.getDueEntryDescriptors();
+        });
+        const results = [];
+        for (const descriptor of due) {
+            const executedResult = await this.executeEntry(descriptor.entry);
+            const sideEffects = descriptor.entry.layer === "probe"
+                ? this.captureExecutionSideEffects(descriptor.entry.id)
+                : null;
+            const applied = await this.withScheduleFileLock(async () => {
+                await this.refreshEntriesForMutation();
+                const outcome = await this.applyExecutionOutcome(descriptor.entry.id, executedResult, descriptor.reason, descriptor.scheduledFor);
+                if (outcome) {
+                    this.applyExecutionSideEffects(descriptor.entry.id, sideEffects);
+                    // Persist cadence/retry advancement before history side effects so a crash
+                    // cannot replay an already-fired entry from stale schedule state.
+                    await this.writeEntriesAndProject();
+                }
+                return outcome;
+            });
+            let finalResult = executedResult;
+            if (applied?.entry) {
+                const escalationResult = await this.checkEscalation(applied.entry, executedResult);
+                if (escalationResult !== null) {
+                    finalResult = escalationResult;
+                }
+            }
+            if (applied) {
+                await this.recordHistory({
+                    entry_id: applied.entry?.id ?? descriptor.entry.id,
+                    entry_name: applied.entry?.name ?? descriptor.entry.name,
+                    layer: descriptor.entry.layer,
+                    result: {
+                        ...finalResult,
+                        failure_kind: applied.failureKind,
+                    },
+                    reason: descriptor.reason,
+                    attempt: applied.attempt,
+                    scheduled_for: descriptor.scheduledFor,
+                    started_at: applied.startedAt,
+                    finished_at: applied.finishedAt,
+                    retry_at: applied.retryAt,
+                    failure_kind: applied.failureKind,
+                });
+            }
+            results.push(finalResult);
+        }
+        return results;
+    }
+    // ─── Probe execution (Phase 2) ───
+    async executeProbe(entry) {
+        return executeProbe(entry, {
+            ...this.layerDeps(),
+            updateBaseline: (entryId, value, windowSize) => {
+                const idx = this.entries.findIndex((e) => e.id === entryId);
+                if (idx !== -1) {
+                    const updated = [...this.entries[idx].baseline_results, value];
+                    this.entries[idx] = {
+                        ...this.entries[idx],
+                        baseline_results: updated.slice(-windowSize),
+                    };
+                }
+            },
+        });
+    }
+    // ─── Cron execution (Phase 3) ───
+    async executeCron(entry) {
+        return executeCron(entry, this.layerDeps());
+    }
+    // ─── GoalTrigger execution (Phase 3) ───
+    async executeGoalTrigger(entry) {
+        return executeGoalTrigger(entry, this.layerDeps());
+    }
+    layerDeps() {
+        return {
+            baseDir: this.baseDir,
+            dataSourceRegistry: this.dataSourceRegistry,
+            llmClient: this.llmClient,
+            notificationDispatcher: this.notificationDispatcher,
+            coreLoop: this.coreLoop,
+            stateManager: this.stateManager,
+            reportingEngine: this.reportingEngine,
+            hookManager: this.hookManager,
+            memoryLifecycle: this.memoryLifecycle,
+            knowledgeManager: this.knowledgeManager,
+            logger: this.logger,
+        };
+    }
+    externalEntryKey(sourceId, externalId) {
+        return `${sourceId}:${externalId}`;
+    }
+    buildExternalScheduleEntryInput(external) {
+        const base = {
+            name: external.name,
+            layer: external.layer,
+            trigger: external.trigger.type === "cron"
+                ? { type: "cron", expression: external.trigger.expression, timezone: "UTC" }
+                : { type: "interval", seconds: external.trigger.seconds, jitter_factor: 0 },
+            enabled: external.enabled,
+            metadata: {
+                source: "external",
+                external_source_id: external.source_id,
+                external_id: external.external_id,
+                dependency_hints: [],
+                note: typeof external.metadata["note"] === "string" ? external.metadata["note"] : undefined,
+            },
+        };
+        if (external.layer === "heartbeat") {
+            const parsed = HeartbeatConfigSchema.safeParse(external.heartbeat ?? external.metadata["heartbeat"]);
+            return parsed.success ? { ...base, heartbeat: parsed.data } : null;
+        }
+        if (external.layer === "probe") {
+            const parsed = ProbeConfigSchema.safeParse(external.probe ?? external.metadata["probe"]);
+            return parsed.success ? { ...base, probe: parsed.data } : null;
+        }
+        if (external.layer === "cron") {
+            const parsed = CronConfigSchema.safeParse(external.cron ?? external.metadata["cron"]);
+            return parsed.success ? { ...base, cron: parsed.data } : null;
+        }
+        const parsed = GoalTriggerConfigSchema.safeParse(external.goal_trigger ?? external.metadata["goal_trigger"]);
+        return parsed.success ? { ...base, goal_trigger: parsed.data } : null;
+    }
+    async executeEntry(entry) {
+        if (entry.layer === "heartbeat") {
+            return this.executeHeartbeat(entry);
+        }
+        if (entry.layer === "probe") {
+            return this.executeProbe(entry);
+        }
+        if (entry.layer === "cron") {
+            return this.executeCron(entry);
+        }
+        if (entry.layer === "goal_trigger") {
+            return this.executeGoalTrigger(entry);
+        }
+        this.logger.info(`Skipping unknown layer entry: ${entry.name} (layer=${entry.layer})`);
+        return ScheduleResultSchema.parse({
+            entry_id: entry.id,
+            status: "skipped",
+            duration_ms: 0,
+            fired_at: new Date().toISOString(),
+        });
+    }
+    normalizeRetryPolicy(entry) {
+        return {
+            ...DEFAULT_RETRY_POLICY,
+            ...(entry.retry_policy ?? {}),
+        };
+    }
+    classifyFailureKind(entry, result) {
+        if (result.failure_kind) {
+            return result.failure_kind;
+        }
+        const message = `${result.error_message ?? ""}`.toLowerCase();
+        const permanentHints = [
+            "no cron config",
+            "no heartbeat config",
+            "no probe config",
+            "no coreloop",
+            "not found",
+            "missing",
+            "invalid",
+            "unsupported",
+            "cannot",
+            "schema",
+            "permission denied",
+        ];
+        if (permanentHints.some((hint) => message.includes(hint))) {
+            return "permanent";
+        }
+        const transientHints = [
+            "timeout",
+            "timed out",
+            "econnrefused",
+            "econnreset",
+            "etimedout",
+            "eai_again",
+            "enotfound",
+            "network",
+            "temporar",
+            "unavailable",
+            "rate limit",
+            "busy",
+            "abort",
+        ];
+        if (transientHints.some((hint) => message.includes(hint))) {
+            return "transient";
+        }
+        return entry.layer === "goal_trigger" ? "permanent" : "transient";
+    }
+    computeRetryDelay(policy, attempt) {
+        const baseDelay = policy.initial_delay_ms * Math.pow(policy.multiplier, Math.max(0, attempt - 1));
+        const cappedDelay = Math.min(baseDelay, policy.max_delay_ms);
+        if (policy.jitter_factor <= 0) {
+            return cappedDelay;
+        }
+        const jitter = cappedDelay * policy.jitter_factor * (Math.random() * 2 - 1);
+        return Math.max(0, Math.round(cappedDelay + jitter));
+    }
+    async applyExecutionOutcome(entryId, result, _reason, scheduledFor, options = {}) {
+        const idx = this.entries.findIndex((candidate) => candidate.id === entryId);
+        if (idx === -1) {
+            return null;
+        }
+        const entry = this.entries[idx];
+        const startedAt = scheduledFor ?? result.fired_at;
+        const finishedAt = new Date().toISOString();
+        const failureKind = this.classifyFailureKind(entry, result);
+        const isFailure = result.status === "error" || result.status === "down";
+        const retryPolicy = this.normalizeRetryPolicy(entry);
+        const currentRetryState = entry.retry_state ?? null;
+        let retryAt = null;
+        let retryState = null;
+        if (isFailure && retryPolicy.enabled && retryPolicy.retryable_failure_kinds.includes(failureKind)) {
+            const attempts = (currentRetryState?.attempts ?? 0) + 1;
+            const firstFailureAt = currentRetryState?.first_failure_at ?? result.fired_at;
+            const windowElapsed = new Date(result.fired_at).getTime() - new Date(firstFailureAt).getTime();
+            if (attempts <= retryPolicy.max_attempts && windowElapsed <= retryPolicy.max_retry_window_ms) {
+                retryAt = new Date(Date.now() + this.computeRetryDelay(retryPolicy, attempts)).toISOString();
+                retryState = {
+                    attempts,
+                    next_retry_at: retryAt,
+                    last_attempt_at: result.fired_at,
+                    first_failure_at: firstFailureAt,
+                    last_failure_kind: failureKind,
+                    last_error_message: result.error_message ?? null,
+                };
+            }
+        }
+        this.entries[idx] = {
+            ...entry,
+            enabled: options.preserveEnabled ? entry.enabled : true,
+            last_fired_at: result.fired_at,
+            next_fire_at: this.computeNextFireAt(entry.trigger),
+            updated_at: new Date().toISOString(),
+            total_executions: entry.total_executions + 1,
+            total_tokens_used: entry.total_tokens_used + (result.tokens_used ?? 0),
+            tokens_used_today: (entry.tokens_used_today ?? 0) + (result.tokens_used ?? 0),
+            consecutive_failures: isFailure ? entry.consecutive_failures + 1 : 0,
+            retry_state: retryState,
+        };
+        const updated = this.entries[idx];
+        if (updated.escalation?.circuit_breaker_threshold &&
+            updated.consecutive_failures >= updated.escalation.circuit_breaker_threshold) {
+            updated.enabled = false;
+            this.logger.warn(`Entry "${updated.name}" disabled by circuit breaker (${updated.consecutive_failures}/${updated.escalation.circuit_breaker_threshold})`);
+        }
+        if (result.status === "down" &&
+            updated.heartbeat &&
+            updated.consecutive_failures >= updated.heartbeat.failure_threshold) {
+            this.logger.warn(`Entry "${updated.name}" reached failure threshold (${updated.consecutive_failures}/${updated.heartbeat.failure_threshold})`);
+            if (updated.consecutive_failures === updated.heartbeat.failure_threshold) {
+                await this.dispatchNotification({
+                    report_type: "schedule_heartbeat_failure",
+                    entry_id: updated.id,
+                    entry_name: updated.name,
+                    failure_threshold: updated.heartbeat.failure_threshold,
+                    consecutive_failures: updated.consecutive_failures,
+                    layer: updated.layer,
+                });
+            }
+        }
+        return {
+            entry: updated,
+            attempt: retryState?.attempts ?? 0,
+            startedAt,
+            finishedAt,
+            retryAt,
+            failureKind,
+        };
+    }
+    async recordHistory(input) {
+        await this.historyStore.append({
+            entry_id: input.entry_id,
+            entry_name: input.entry_name,
+            layer: input.layer,
+            result: {
+                ...input.result,
+                failure_kind: input.failure_kind,
+            },
+            reason: input.reason,
+            attempt: input.attempt,
+            scheduled_for: input.scheduled_for,
+            started_at: input.started_at,
+            finished_at: input.finished_at,
+            retry_at: input.retry_at,
+            failure_kind: input.failure_kind,
+        });
+    }
+    async executeEscalationTargetEntry(targetEntryId) {
+        const targetEntry = await this.withScheduleFileLock(async () => {
+            await this.refreshEntriesForMutation();
+            return this.entries.find((candidate) => candidate.id === targetEntryId) ?? null;
+        });
+        if (!targetEntry) {
+            this.logger.warn(`Escalation target entry not found: ${targetEntryId}`);
+            return null;
+        }
+        const immediateEntry = {
+            ...targetEntry,
+            enabled: true,
+            next_fire_at: new Date().toISOString(),
+        };
+        const result = await this.executeEntry(immediateEntry);
+        const sideEffects = targetEntry.layer === "probe"
+            ? this.captureExecutionSideEffects(targetEntry.id)
+            : null;
+        const applied = await this.withScheduleFileLock(async () => {
+            await this.refreshEntriesForMutation();
+            const outcome = await this.applyExecutionOutcome(targetEntryId, result, "escalation_target", immediateEntry.next_fire_at);
+            if (outcome) {
+                this.applyExecutionSideEffects(targetEntryId, sideEffects);
+                await this.writeEntriesAndProject();
+            }
+            return outcome;
+        });
+        if (applied) {
+            await this.recordHistory({
+                entry_id: targetEntry.id,
+                entry_name: targetEntry.name,
+                layer: targetEntry.layer,
+                result: {
+                    ...result,
+                    failure_kind: applied.failureKind,
+                },
+                reason: "escalation_target",
+                attempt: applied.attempt,
+                scheduled_for: immediateEntry.next_fire_at,
+                started_at: applied.startedAt,
+                finished_at: applied.finishedAt,
+                retry_at: applied.retryAt,
+                failure_kind: applied.failureKind,
+            });
+        }
+        return result;
+    }
+    async executeEscalationTargetGoal(goalId) {
+        const now = new Date().toISOString();
+        if (!this.coreLoop) {
+            return ScheduleResultSchema.parse({
+                entry_id: randomUUID(),
+                status: "error",
+                duration_ms: 0,
+                fired_at: now,
+                goal_id: goalId,
+                error_message: "No coreLoop provided for escalation target goal",
+                failure_kind: "permanent",
+            });
+        }
+        const startedAt = Date.now();
+        try {
+            const result = await this.coreLoop.run(goalId);
+            return ScheduleResultSchema.parse({
+                entry_id: randomUUID(),
+                status: "ok",
+                duration_ms: Date.now() - startedAt,
+                fired_at: now,
+                goal_id: goalId,
+                tokens_used: result?.tokensUsed ?? 0,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Escalation target goal "${goalId}" failed: ${message}`);
+            return ScheduleResultSchema.parse({
+                entry_id: randomUUID(),
+                status: "error",
+                duration_ms: Date.now() - startedAt,
+                fired_at: now,
+                goal_id: goalId,
+                error_message: message,
+                failure_kind: "transient",
+            });
+        }
+    }
+    // ─── Escalation logic ───
+    async checkEscalation(entry, result) {
+        const isFailure = result.status === "error" || result.status === "down";
+        if (!isFailure)
+            return null;
+        const escalationEntry = await this.withScheduleFileLock(async () => {
+            await this.refreshEntriesForMutation();
+            const idx = this.entries.findIndex((e) => e.id === entry.id);
+            if (idx === -1) {
+                return null;
+            }
+            const current = this.entries[idx];
+            const esc = current.escalation;
+            if (!esc?.enabled)
+                return null;
+            const now = Date.now();
+            // Check cooldown
+            if (current.last_escalation_at) {
+                const lastEsc = new Date(current.last_escalation_at).getTime();
+                if (now - lastEsc < esc.cooldown_minutes * 60 * 1000) {
+                    this.logger.info(`Escalation for "${current.name}" suppressed (cooldown)`);
+                    return null;
+                }
+            }
+            // Rolling-window rate-limit: check escalation_timestamps within the last hour
+            const hourAgo = now - 60 * 60 * 1000;
+            const recentTimestamps = (current.escalation_timestamps ?? []).filter((ts) => new Date(ts).getTime() > hourAgo);
+            if (recentTimestamps.length >= esc.max_per_hour) {
+                this.logger.info(`Escalation for "${current.name}" suppressed (max_per_hour=${esc.max_per_hour} reached)`);
+                return null;
+            }
+            // Update last_escalation_at and rolling-window escalation_timestamps.
+            const nowIso = new Date(now).toISOString();
+            const prunedTimestamps = [
+                ...(current.escalation_timestamps ?? []).filter((ts) => new Date(ts).getTime() > hourAgo),
+                nowIso,
+            ];
+            this.entries[idx] = {
+                ...current,
+                last_escalation_at: nowIso,
+                escalation_timestamps: prunedTimestamps,
+            };
+            await this.writeEntriesAndProject();
+            return this.entries[idx];
+        });
+        if (!escalationEntry?.escalation)
+            return null;
+        const esc = escalationEntry.escalation;
+        // Dispatch escalation notification
+        await this.dispatchNotification({
+            report_type: "schedule_escalation",
+            entry_id: escalationEntry.id,
+            entry_name: escalationEntry.name,
+            target_layer: esc.target_layer,
+            target_entry_id: esc.target_entry_id,
+            target_goal_id: esc.target_goal_id,
+            consecutive_failures: escalationEntry.consecutive_failures,
+        });
+        this.logger.warn(`Escalating "${escalationEntry.name}" to ${esc.target_layer ?? "unknown"} (failures=${escalationEntry.consecutive_failures})`);
+        // Execute target goal or target entry immediately so escalations take effect in the same tick.
+        if (esc.target_goal_id) {
+            await this.executeEscalationTargetGoal(esc.target_goal_id);
+        }
+        if (esc.target_entry_id) {
+            await this.executeEscalationTargetEntry(esc.target_entry_id);
+        }
+        return ScheduleResultSchema.parse({
+            ...result,
+            status: "escalated",
+            escalated_to: esc.target_goal_id ?? esc.target_entry_id ?? esc.target_layer ?? null,
+        });
+    }
+    // ─── Notification dispatch ───
+    async dispatchNotification(payload) {
+        if (!this.notificationDispatcher)
+            return;
+        try {
+            await this.notificationDispatcher.dispatch(payload);
+        }
+        catch (err) {
+            this.logger.warn(`Notification dispatch failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // ─── Heartbeat execution (Phase 1) ───
+    async executeHeartbeat(entry) {
+        const firedAt = new Date().toISOString();
+        const start = Date.now();
+        const cfg = entry.heartbeat;
+        if (!cfg) {
+            return ScheduleResultSchema.parse({
+                entry_id: entry.id,
+                status: "error",
+                duration_ms: 0,
+                error_message: "No heartbeat config",
+                fired_at: firedAt,
+                failure_kind: "permanent",
+            });
+        }
+        try {
+            const timeoutMs = cfg.timeout_ms;
+            const config = cfg.check_config;
+            switch (cfg.check_type) {
+                case "http":
+                    await this.checkHttp(config.url, timeoutMs);
+                    break;
+                case "tcp":
+                    await this.checkTcp(config.host, config.port, timeoutMs);
+                    break;
+                case "process":
+                    this.checkProcess(config.pid);
+                    break;
+                case "disk":
+                    await this.checkDisk(config.path);
+                    break;
+                case "custom":
+                    await this.checkCustom(config.command, timeoutMs);
+                    break;
+            }
+            return ScheduleResultSchema.parse({
+                entry_id: entry.id,
+                status: "ok",
+                duration_ms: Date.now() - start,
+                fired_at: firedAt,
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.logger.error(`Heartbeat "${entry.name}" failed: ${msg}`);
+            return ScheduleResultSchema.parse({
+                entry_id: entry.id,
+                status: "down",
+                duration_ms: Date.now() - start,
+                error_message: msg,
+                fired_at: firedAt,
+                failure_kind: "transient",
+            });
+        }
+    }
+    // ─── Check implementations ───
+    async checkHttp(url, timeoutMs) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const res = await fetch(url, { signal: controller.signal });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    checkTcp(host, port, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const socket = net.createConnection({ host, port }, () => {
+                socket.destroy();
+                resolve();
+            });
+            socket.setTimeout(timeoutMs);
+            socket.on("timeout", () => {
+                socket.destroy();
+                reject(new Error(`TCP timeout after ${timeoutMs}ms`));
+            });
+            socket.on("error", (err) => {
+                socket.destroy();
+                reject(err);
+            });
+        });
+    }
+    checkProcess(pid) {
+        process.kill(pid, 0); // throws if process doesn't exist
+    }
+    checkCustom(command, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            exec(command, { timeout: timeoutMs }, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    async checkDisk(diskPath) {
+        const { statfs } = await import("node:fs/promises");
+        await statfs(diskPath); // throws if path doesn't exist
+    }
+    // ─── Schedule computation ───
+    computeNextFireAt(trigger) {
+        if (trigger.type === "cron") {
+            const next = CronExpressionParser.parse(trigger.expression, { tz: trigger.timezone || "UTC" }).next();
+            return next.toISOString() ?? new Date().toISOString();
+        }
+        let nextTime = new Date(Date.now() + trigger.seconds * 1000);
+        if (trigger.jitter_factor && trigger.jitter_factor > 0) {
+            const jitterMs = trigger.seconds * 1000 * trigger.jitter_factor * (Math.random() * 2 - 1);
+            nextTime = new Date(nextTime.getTime() + jitterMs);
+        }
+        // Clamp to at least now + 1s to avoid past-scheduling from negative jitter
+        const minTime = Date.now() + 1000;
+        if (nextTime.getTime() < minTime) {
+            nextTime = new Date(minTime);
+        }
+        return nextTime.toISOString();
+    }
+}
+//# sourceMappingURL=engine.js.map