pulseed 0.4.14 → 0.4.15

package/dist/runtime/schedule/engine.js

@@ -1,6 +1,7 @@
 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";
@@ -13,6 +14,10 @@ import { hasConfiguredSoilPublishProvider } from "../../platform/soil/publish/in
 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,
@@ -43,9 +48,12 @@ export class ScheduleEngine {
     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;
@@ -60,31 +68,136 @@ export class ScheduleEngine {
     }
     // ─── 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) {
-            this.entries = [];
             return [];
         }
         const result = ScheduleEntryListSchema.safeParse(raw);
-        this.entries = result.success ? result.data : [];
-        await this.projectCurrentSchedulesToSoil();
-        return this.entries;
+        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 ensureSoilPublishSchedule() {
-        const configured = await hasConfiguredSoilPublishProvider({ baseDir: this.baseDir });
-        if (!configured) {
-            return null;
+    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();
         }
-        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;
+        finally {
+            this.scheduleLockDepth--;
+            await release();
         }
-        return this.addEntry(buildSchedulePresetEntry({ preset: "soil_publish" }));
+    }
+    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 {
@@ -104,116 +217,121 @@ export class ScheduleEngine {
         return this.baseDir;
     }
     async syncExternalSources(sources) {
-        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}` });
+        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 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({
+                    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: 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(),
+                            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),
                         });
-                        updated++;
+                        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);
+                    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) });
+                }
             }
-            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(),
+            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 };
         });
-        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,
@@ -229,90 +347,84 @@ export class ScheduleEngine {
             total_tokens_used: 0,
         });
         this.entries.push(entry);
-        await this.saveEntries();
         return entry;
     }
     async removeEntry(id) {
-        const before = this.entries.length;
-        this.entries = this.entries.filter((e) => e.id !== id);
-        if (this.entries.length === before)
-            return false;
-        await this.saveEntries();
-        return true;
+        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) {
-        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`);
+        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 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;
+            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;
+                }
             }
-            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;
             }
-        }
-        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 previousEntries = this.entries;
-        const nextEntries = [...this.entries];
-        nextEntries[idx] = parsedEntry;
-        this.entries = nextEntries;
-        try {
-            await this.saveEntries();
-        }
-        catch (error) {
-            this.entries = previousEntries;
-            throw error;
-        }
-        return parsedEntry;
+            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() {
@@ -324,7 +436,10 @@ export class ScheduleEngine {
         return filtered.slice(-limit);
     }
     async runEntryNow(entryId, options = {}) {
-        const entry = this.entries.find((candidate) => candidate.id === entryId);
+        const entry = await this.withScheduleFileLock(async () => {
+            await this.refreshEntriesForMutation();
+            return this.entries.find((candidate) => candidate.id === entryId) ?? null;
+        });
         if (!entry) {
             return null;
         }
@@ -335,7 +450,18 @@ export class ScheduleEngine {
             next_fire_at: scheduledFor,
         };
         const executedResult = await this.executeEntry(immediateEntry);
-        const applied = await this.applyExecutionOutcome(entry.id, executedResult, "manual_run", scheduledFor, { preserveEnabled: options.preserveEnabled ?? true });
+        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);
@@ -344,7 +470,6 @@ export class ScheduleEngine {
             }
         }
         if (applied) {
-            await this.saveEntries();
             await this.recordHistory({
                 entry_id: applied.entry?.id ?? entry.id,
                 entry_name: applied.entry?.name ?? entry.name,
@@ -386,28 +511,44 @@ export class ScheduleEngine {
         });
     }
     async tick() {
-        // 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;
+        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.saveEntries();
-        }
-        const due = await this.getDueEntryDescriptors();
+            if (budgetReset) {
+                await this.writeEntriesAndProject();
+            }
+            return this.getDueEntryDescriptors();
+        });
         const results = [];
         for (const descriptor of due) {
             const executedResult = await this.executeEntry(descriptor.entry);
-            const applied = await this.applyExecutionOutcome(descriptor.entry.id, executedResult, descriptor.reason, descriptor.scheduledFor);
+            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);
@@ -416,9 +557,6 @@ export class ScheduleEngine {
                 }
             }
             if (applied) {
-                // Persist cadence/retry advancement before history side effects so a crash
-                // cannot replay an already-fired entry from stale schedule state.
-                await this.saveEntries();
                 await this.recordHistory({
                     entry_id: applied.entry?.id ?? descriptor.entry.id,
                     entry_name: applied.entry?.name ?? descriptor.entry.name,
@@ -681,7 +819,10 @@ export class ScheduleEngine {
         });
     }
     async executeEscalationTargetEntry(targetEntryId) {
-        const targetEntry = this.entries.find((candidate) => candidate.id === 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;
@@ -692,9 +833,19 @@ export class ScheduleEngine {
             next_fire_at: new Date().toISOString(),
         };
         const result = await this.executeEntry(immediateEntry);
-        const applied = await this.applyExecutionOutcome(targetEntryId, result, "escalation_target", immediateEntry.next_fire_at);
+        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.saveEntries();
             await this.recordHistory({
                 entry_id: targetEntry.id,
                 entry_name: targetEntry.name,
@@ -755,55 +906,63 @@ export class ScheduleEngine {
     }
     // ─── Escalation logic ───
     async checkEscalation(entry, result) {
-        const esc = entry.escalation;
-        if (!esc?.enabled)
-            return null;
         const isFailure = result.status === "error" || result.status === "down";
         if (!isFailure)
             return null;
-        const now = Date.now();
-        // Check cooldown
-        if (entry.last_escalation_at) {
-            const lastEsc = new Date(entry.last_escalation_at).getTime();
-            if (now - lastEsc < esc.cooldown_minutes * 60 * 1000) {
-                this.logger.info(`Escalation for "${entry.name}" suppressed (cooldown)`);
+        const escalationEntry = await this.withScheduleFileLock(async () => {
+            await this.refreshEntriesForMutation();
+            const idx = this.entries.findIndex((e) => e.id === entry.id);
+            if (idx === -1) {
                 return null;
             }
-        }
-        // Rolling-window rate-limit: check escalation_timestamps within the last hour
-        const hourAgo = now - 60 * 60 * 1000;
-        const recentTimestamps = (entry.escalation_timestamps ?? []).filter((ts) => new Date(ts).getTime() > hourAgo);
-        if (recentTimestamps.length >= esc.max_per_hour) {
-            this.logger.info(`Escalation for "${entry.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 hourAgoForPrune = now - 60 * 60 * 1000;
-        const idx = this.entries.findIndex((e) => e.id === entry.id);
-        if (idx !== -1) {
+            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 = [
-                ...(this.entries[idx].escalation_timestamps ?? []).filter((ts) => new Date(ts).getTime() > hourAgoForPrune),
+                ...(current.escalation_timestamps ?? []).filter((ts) => new Date(ts).getTime() > hourAgo),
                 nowIso,
             ];
             this.entries[idx] = {
-                ...this.entries[idx],
+                ...current,
                 last_escalation_at: nowIso,
                 escalation_timestamps: prunedTimestamps,
             };
-            await this.saveEntries();
-        }
+            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: entry.id,
-            entry_name: entry.name,
+            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: entry.consecutive_failures,
+            consecutive_failures: escalationEntry.consecutive_failures,
         });
-        this.logger.warn(`Escalating "${entry.name}" to ${esc.target_layer ?? "unknown"} (failures=${entry.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);