pulseed 0.4.15 → 0.4.17

package/dist/runtime/schedule/engine.js

@@ -1,1111 +0,0 @@
-import { CronExpressionParser } from "cron-parser";
-import * as path from "node:path";
-import * as net from "node:net";
-import * as fsp from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { exec } from "node:child_process";
-import { writeJsonFileAtomic, readJsonFileOrNull } from "../../base/utils/json-io.js";
-import { ScheduleEntrySchema, ScheduleEntryListSchema, 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";
-const SCHEDULES_FILE = "schedules.json";
-const SCHEDULE_LOCK_DIR = `${SCHEDULES_FILE}.lock`;
-const SCHEDULE_LOCK_TIMEOUT_MS = 5000;
-const SCHEDULE_LOCK_STALE_MS = 30_000;
-const SCHEDULE_LOCK_RETRY_MS = 25;
-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;
-    schedulesPath;
-    logger;
-    dataSourceRegistry;
-    llmClient;
-    notificationDispatcher;
-    coreLoop;
-    stateManager;
-    reportingEngine;
-    hookManager;
-    memoryLifecycle;
-    knowledgeManager;
-    historyStore;
-    schedulesLockPath;
-    scheduleLockDepth = 0;
-    constructor(deps) {
-        this.baseDir = deps.baseDir;
-        this.schedulesPath = path.join(deps.baseDir, SCHEDULES_FILE);
-        this.schedulesLockPath = path.join(deps.baseDir, SCHEDULE_LOCK_DIR);
-        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);
-    }
-    // ─── Persistence ───
-    async loadEntries() {
-        this.entries = await this.readEntriesFromDisk();
-        await this.projectCurrentSchedulesToSoil();
-        return this.entries;
-    }
-    async readEntriesFromDisk() {
-        const raw = await readJsonFileOrNull(this.schedulesPath);
-        if (raw === null) {
-            return [];
-        }
-        const result = ScheduleEntryListSchema.safeParse(raw);
-        return result.success ? result.data : [];
-    }
-    async saveEntries() {
-        await this.withScheduleFileLock(async () => {
-            await this.writeEntriesAndProject();
-        });
-    }
-    async writeEntriesAndProject() {
-        await writeJsonFileAtomic(this.schedulesPath, this.entries);
-        await this.projectCurrentSchedulesToSoil();
-    }
-    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) {
-        if (this.scheduleLockDepth > 0) {
-            return work();
-        }
-        const release = await this.acquireScheduleFileLock();
-        this.scheduleLockDepth++;
-        try {
-            return await work();
-        }
-        finally {
-            this.scheduleLockDepth--;
-            await release();
-        }
-    }
-    async acquireScheduleFileLock() {
-        await fsp.mkdir(this.baseDir, { recursive: true });
-        const startedAt = Date.now();
-        while (true) {
-            try {
-                await fsp.mkdir(this.schedulesLockPath);
-                await fsp.writeFile(path.join(this.schedulesLockPath, "owner.json"), JSON.stringify({ pid: process.pid, created_at: new Date().toISOString() }), "utf-8");
-                return async () => {
-                    await fsp.rm(this.schedulesLockPath, { recursive: true, force: true });
-                };
-            }
-            catch (error) {
-                const code = error.code;
-                if (code !== "EEXIST") {
-                    throw error;
-                }
-                await this.removeStaleScheduleLock().catch(() => undefined);
-                if (Date.now() - startedAt >= SCHEDULE_LOCK_TIMEOUT_MS) {
-                    throw new Error(`Timed out waiting for schedule file lock at ${this.schedulesLockPath}`);
-                }
-                await new Promise((resolve) => setTimeout(resolve, SCHEDULE_LOCK_RETRY_MS));
-            }
-        }
-    }
-    async removeStaleScheduleLock() {
-        const stat = await fsp.stat(this.schedulesLockPath);
-        if (Date.now() - stat.mtimeMs <= SCHEDULE_LOCK_STALE_MS) {
-            return;
-        }
-        try {
-            const raw = await fsp.readFile(path.join(this.schedulesLockPath, "owner.json"), "utf-8");
-            const owner = JSON.parse(raw);
-            if (typeof owner.pid === "number") {
-                try {
-                    process.kill(owner.pid, 0);
-                    return;
-                }
-                catch {
-                    // Owner is gone; stale lock can be removed.
-                }
-            }
-        }
-        catch {
-            // Missing or malformed owner data is treated as stale after the age threshold.
-        }
-        if (Date.now() - stat.mtimeMs > SCHEDULE_LOCK_STALE_MS) {
-            await fsp.rm(this.schedulesLockPath, { recursive: true, force: true });
-        }
-    }
-    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