@kafca/agentdock 0.1.58 → 0.1.62

package/dist-electron/services/local-ai-core/src/automation/automation-monitor-service.js

@@ -2,355 +2,790 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutomationMonitorService = void 0;
 const scheduled_job_route_js_1 = require("../scheduler/scheduled-job-route.js");
-const condition_evaluator_js_1 = require("./condition-evaluator.js");
-const automation_conversation_executor_js_1 = require("./automation-conversation-executor.js");
-const automation_monitor_repository_js_1 = require("./automation-monitor-repository.js");
+const legacy_automation_mappers_js_1 = require("./legacy-automation-mappers.js");
+const automation_service_js_1 = require("./automation-service.js");
 const monitor_id_js_1 = require("./monitor-id.js");
+const PROVIDER_EVENT_CONCURRENCY = 4;
 class AutomationMonitorService {
     options;
     timer = null;
-    pollInFlight = false;
-    runningMonitors = new Set();
+    startPromise;
+    stopPromise;
+    tickPromise;
+    lifecycleState = 'stopped';
+    lifecycleGeneration = 0;
+    providerEventsInFlight = 0;
+    providerEventWaiters = [];
+    inFlight = new Set();
     subscriptionHandles = new Map();
+    handleLifecycleGenerations = new Map();
+    subscriptionGenerations = new Map();
     providers = new Map();
-    executor;
-    repository;
     constructor(options) {
         this.options = options;
-        for (const provider of options.providers) {
+        for (const provider of options.providers)
             this.providers.set(provider.sourceType, provider);
+    }
+    start() {
+        if (this.lifecycleState === 'stopping') {
+            return (this.stopPromise || Promise.resolve()).then(() => this.start());
         }
-        this.repository = new automation_monitor_repository_js_1.AutomationMonitorRepository(options.store);
-        this.executor = new automation_conversation_executor_js_1.AutomationConversationExecutor({
-            store: options.store,
-            getWorkspaceRouter: options.getWorkspaceRouter,
-            getChannelRuntime: options.getChannelRuntime,
+        if (this.startPromise)
+            return this.startPromise;
+        if (this.lifecycleState === 'running')
+            return Promise.resolve();
+        const generation = ++this.lifecycleGeneration;
+        this.lifecycleState = 'starting';
+        const work = this.startInternal(generation).catch((error) => {
+            if (this.lifecycleGeneration === generation) {
+                if (this.timer)
+                    (this.options.clearInterval || clearInterval)(this.timer);
+                this.timer = null;
+                this.lifecycleState = 'stopped';
+            }
+            throw error;
+        });
+        let shared;
+        shared = work.finally(() => {
+            if (this.startPromise === shared)
+                this.startPromise = undefined;
+            if (this.lifecycleGeneration === generation && this.lifecycleState === 'starting') {
+                this.lifecycleState = 'stopped';
+            }
         });
+        this.startPromise = shared;
+        return shared;
     }
-    async start() {
-        await this.refreshSubscriptions();
-        await this.tick();
-        this.timer = setInterval(() => {
-            void this.tick();
+    async startInternal(generation) {
+        if (this.options.automations.getRuntimeStatus().status === 'degraded') {
+            if (this.isCurrentLifecycle(generation, 'starting'))
+                this.lifecycleState = 'stopped';
+            this.reportProviderError('start', new Error('Unified automation migration is unavailable.'));
+            return;
+        }
+        await this.refreshSubscriptions(generation);
+        if (!this.isCurrentLifecycle(generation, 'starting'))
+            return;
+        this.lifecycleState = 'running';
+        await this.tick(false, generation);
+        if (!this.isCurrentLifecycle(generation, 'running'))
+            return;
+        this.timer = (this.options.setInterval || setInterval)(() => {
+            if (!this.isCurrentLifecycle(generation, 'running'))
+                return;
+            void this.tick(true, generation).catch((error) => this.reportProviderError('interval', error));
         }, 30_000);
     }
-    async stop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-        for (const handle of this.subscriptionHandles.values()) {
-            await handle.stop();
+    stop() {
+        if (this.stopPromise)
+            return this.stopPromise;
+        if (this.lifecycleState === 'stopped'
+            && this.subscriptionHandles.size === 0
+            && this.inFlight.size === 0
+            && !this.startPromise)
+            return Promise.resolve();
+        const starting = this.startPromise;
+        const generation = ++this.lifecycleGeneration;
+        this.lifecycleState = 'stopping';
+        if (this.timer)
+            (this.options.clearInterval || clearInterval)(this.timer);
+        this.timer = null;
+        this.handleLifecycleGenerations.clear();
+        for (const monitorId of this.subscriptionHandles.keys()) {
+            this.subscriptionGenerations.set(monitorId, (this.subscriptionGenerations.get(monitorId) || 0) + 1);
         }
-        this.subscriptionHandles.clear();
+        for (const waiter of this.providerEventWaiters.splice(0))
+            waiter(false);
+        const work = this.stopInternal(starting);
+        let shared;
+        shared = work.finally(() => {
+            if (this.stopPromise === shared)
+                this.stopPromise = undefined;
+            if (this.lifecycleGeneration === generation && this.lifecycleState === 'stopping') {
+                this.lifecycleState = 'stopped';
+            }
+        });
+        this.stopPromise = shared;
+        return shared;
+    }
+    async stopInternal(starting) {
+        if (starting)
+            await Promise.allSettled([starting]);
+        await this.settleInFlight();
+        const handles = [...this.subscriptionHandles.entries()];
+        const results = await Promise.allSettled(handles.map(([, handle]) => this.observeProviderWork(Promise.resolve().then(() => handle.stop()))));
+        results.forEach((result, index) => {
+            const [monitorId, handle] = handles[index] || [];
+            if (!monitorId || !handle)
+                return;
+            if (result.status === 'fulfilled') {
+                if (this.subscriptionHandles.get(monitorId) === handle) {
+                    this.subscriptionHandles.delete(monitorId);
+                    this.handleLifecycleGenerations.delete(monitorId);
+                }
+            }
+            else {
+                this.reportProviderError(`stop:${monitorId}`, result.reason);
+            }
+        });
+        await this.settleInFlight();
     }
     listMonitors(workspaceId) {
-        return this.repository.list(workspaceId);
+        return this.options.automations.list(workspaceId)
+            .filter((automation) => automation.originKind === 'automation-monitor')
+            .map((automation) => (0, legacy_automation_mappers_js_1.automationToMonitor)(automation, (0, legacy_automation_mappers_js_1.latestFinishedEvaluation)(this.options.automations.listEvaluations(automation.id)), (0, legacy_automation_mappers_js_1.latestAutomationRun)(this.options.automations.listRuns(automation.id)), this.options.automations.getLatestEvaluationWithState(automation.id)));
     }
     getMonitor(monitorId) {
-        const resolvedMonitorId = this.resolveMonitorId(monitorId);
-        return resolvedMonitorId ? this.repository.get(resolvedMonitorId) : undefined;
+        const resolved = this.resolveMonitorId(monitorId);
+        const automation = resolved ? this.options.automations.get(resolved) : undefined;
+        return automation?.originKind === 'automation-monitor'
+            ? (0, legacy_automation_mappers_js_1.automationToMonitor)(automation, (0, legacy_automation_mappers_js_1.latestFinishedEvaluation)(this.options.automations.listEvaluations(automation.id)), (0, legacy_automation_mappers_js_1.latestAutomationRun)(this.options.automations.listRuns(automation.id)), this.options.automations.getLatestEvaluationWithState(automation.id))
+            : undefined;
     }
-    createMonitor(input) {
+    async createMonitor(input) {
         const resolved = this.resolveCreateInput(input);
-        const provider = this.providers.get(resolved.sourceType);
-        provider?.validateConfig?.(resolved.sourceConfig || {});
-        const monitor = this.repository.create(resolved);
-        this.emitMonitor(monitor);
-        void this.ensureSubscription(monitor);
-        return monitor;
+        this.providers.get(resolved.sourceType)?.validateConfig?.(resolved.sourceConfig || {});
+        const mapped = (0, legacy_automation_mappers_js_1.monitorToAutomationInput)(resolved);
+        let monitor;
+        let persistedId;
+        try {
+            const persisted = this.options.automations.createFromLegacy(mapped);
+            persistedId = persisted.id;
+            monitor = (0, legacy_automation_mappers_js_1.automationToMonitor)(persisted);
+            await this.ensureSubscription(monitor);
+            return monitor;
+        }
+        catch (error) {
+            if (!persistedId)
+                throw error;
+            const message = this.lifecycleError(`create:${persistedId}`, error);
+            if (this.subscriptionHandles.has(persistedId))
+                throw new Error(message);
+            try {
+                this.options.automations.delete(persistedId);
+            }
+            catch (cleanupError) {
+                const cleanupMessage = this.lifecycleError(`create-cleanup:${persistedId}`, cleanupError);
+                this.options.automations.failClosedLegacyAutomation(persistedId, `${message}; ${cleanupMessage}`);
+            }
+            throw new Error(message);
+        }
     }
-    updateMonitor(monitorId, input) {
-        const resolvedMonitorId = this.resolveRequiredMonitorId(monitorId);
-        const existing = this.repository.get(resolvedMonitorId);
-        if (existing && input.sourceConfig) {
+    async updateMonitor(monitorId, input) {
+        this.options.automations.assertLegacyFacadesAvailable();
+        const existing = this.getRequiredMonitor(monitorId);
+        if (input.sourceConfig)
             this.providers.get(existing.sourceType)?.validateConfig?.(input.sourceConfig);
-        }
-        const monitor = this.repository.update(resolvedMonitorId, {
-            ...input,
-            ...(input.route ? { route: (0, scheduled_job_route_js_1.withoutThreadRoute)(input.route) } : {}),
+        const resolved = this.resolveCreateInput({
+            workspaceId: existing.workspaceId,
+            title: input.title ?? existing.title,
+            sourceType: existing.sourceType,
+            sourceConfig: input.sourceConfig ?? existing.sourceConfig,
+            condition: input.condition ?? existing.condition,
+            promptTemplate: input.promptTemplate ?? existing.promptTemplate,
+            platform: existing.platform,
+            route: input.route ? (0, scheduled_job_route_js_1.withoutThreadRoute)(input.route) : existing.route,
+            executionMode: input.executionMode ?? existing.executionMode,
+            enabled: input.enabled ?? existing.enabled,
+            cooldownMs: input.cooldownMs ?? existing.cooldownMs,
         });
-        this.emitMonitor(monitor);
-        void this.ensureSubscription(monitor);
+        const mapped = (0, legacy_automation_mappers_js_1.monitorToAutomationInput)(resolved);
+        const { workspaceId: _workspaceId, originKind: _originKind, ...update } = mapped;
+        if (input.sourceConfig) {
+            return this.updateSourceConfigTransaction(existing, update, resolved.sourceConfig || {});
+        }
+        if (!existing.enabled
+            && resolved.enabled
+            && this.providers.get(existing.sourceType)?.startMonitor) {
+            return this.enableSubscriptionTransaction(existing, update, resolved.sourceConfig || {});
+        }
+        if (existing.enabled
+            && !resolved.enabled
+            && this.providers.get(existing.sourceType)?.startMonitor) {
+            return this.disableSubscriptionTransaction(existing, update);
+        }
+        const monitor = (0, legacy_automation_mappers_js_1.automationToMonitor)(this.options.automations.updateFromLegacy(this.resolveRequiredMonitorId(monitorId), update));
+        await this.ensureSubscription(monitor);
         return monitor;
     }
-    deleteMonitor(monitorId) {
-        const resolvedMonitorId = this.resolveRequiredMonitorId(monitorId);
-        void this.stopSubscription(resolvedMonitorId);
-        return this.repository.delete(resolvedMonitorId);
+    async deleteMonitor(monitorId) {
+        this.options.automations.assertLegacyFacadesAvailable();
+        const resolved = this.resolveRequiredMonitorId(monitorId);
+        const existing = this.getRequiredMonitor(resolved);
+        await this.stopSubscription(resolved);
+        try {
+            return this.options.automations.delete(resolved);
+        }
+        catch (error) {
+            try {
+                const restored = await this.startSubscriptionHandle(existing);
+                if (restored) {
+                    this.installSubscriptionHandle(existing.id, restored);
+                    this.recoverSubscriptionHealth(existing.id);
+                }
+            }
+            catch (restoreError) {
+                const message = `${this.lifecycleError(`delete:${existing.id}`, error)}; ${this.lifecycleError(`delete-restore:${existing.id}`, restoreError)}`;
+                this.options.automations.failClosedLegacyAutomation(existing.id, message);
+            }
+            throw new Error(this.lifecycleError(`delete:${existing.id}`, error));
+        }
     }
     listRuns(monitorId) {
-        return this.repository.listRuns(this.resolveRequiredMonitorId(monitorId));
+        const resolved = this.resolveRequiredMonitorId(monitorId);
+        const runs = this.options.automations.listRuns(resolved);
+        const runsByEvaluationId = new Map(runs.map((run) => [run.evaluationId, run]));
+        return this.options.automations.listEvaluations(resolved).map((evaluation) => (0, legacy_automation_mappers_js_1.automationToMonitorRun)(evaluation, runsByEvaluationId.get(evaluation.id)));
     }
     async runMonitorNow(monitorId, event) {
+        this.options.automations.assertLegacyFacadesAvailable();
         const monitor = this.getRequiredMonitor(monitorId);
-        const snapshot = event || await this.pollMonitor(monitor, true);
-        if (!snapshot) {
-            const skipped = this.markSkipped(monitor, new Date().toISOString(), 'No event snapshot is available for this monitor.');
-            this.emitRun(skipped);
-            return skipped;
+        const hasExplicitEvent = event !== undefined;
+        const polled = hasExplicitEvent ? undefined : await this.pollMonitor(monitor, true);
+        if (!hasExplicitEvent && !polled)
+            throw new Error('Automation monitor changed while provider polling was in progress.');
+        const snapshot = hasExplicitEvent ? event : polled?.event;
+        this.options.automations.assertLegacyFacadesAvailable();
+        if (!hasExplicitEvent && !snapshot) {
+            const evaluation = this.options.automations.recordUnavailableProviderEvent(monitor.id, 'No event snapshot is available for this monitor.');
+            return (0, legacy_automation_mappers_js_1.automationToMonitorRun)(evaluation);
         }
-        return this.executeMonitor(monitor, snapshot, true);
+        const evaluated = await this.evaluateEvent(monitor.id, snapshot, {
+            kind: 'manual',
+            ...(polled ? { token: polled.token } : {}),
+        });
+        if (!evaluated)
+            throw new Error('Automation monitor changed before the provider event could be evaluated.');
+        return evaluated;
     }
     listMonitorsForThread(threadId) {
-        const binding = this.repository.getPlatformThreadBindingByThreadId(threadId);
-        return this.repository
-            .list()
-            .filter((monitor) => monitor.route.threadId === threadId ||
-            (binding ? (0, scheduled_job_route_js_1.scheduledJobMatchesPlatformBinding)(this.repository.toScheduledLike(monitor), binding) : false));
-    }
-    async tick() {
-        if (this.pollInFlight) {
-            return;
-        }
-        this.pollInFlight = true;
+        const binding = this.options.store.getPlatformThreadBindingByThreadId(threadId);
+        return this.listMonitors().filter((monitor) => monitor.route.threadId === threadId || (binding ? (0, scheduled_job_route_js_1.scheduledJobMatchesPlatformBinding)({
+            id: monitor.id,
+            workspaceId: monitor.workspaceId,
+            platform: monitor.platform,
+            route: monitor.route,
+            executionMode: monitor.executionMode,
+            triggerType: 'once',
+            promptTemplate: monitor.promptTemplate,
+            description: monitor.title,
+            enabled: monitor.enabled,
+            concurrencyPolicy: 'skip_if_running',
+            createdAt: monitor.createdAt,
+            updatedAt: monitor.updatedAt,
+        }, binding) : false));
+    }
+    tick(refreshSubscriptions = true, generation) {
+        if (generation !== undefined && !this.isCurrentLifecycle(generation, 'running'))
+            return Promise.resolve();
+        if (this.tickPromise)
+            return this.tickPromise;
+        const work = this.runTick(refreshSubscriptions, generation);
+        let shared;
+        shared = this.observeProviderWork(work).finally(() => {
+            if (this.tickPromise === shared)
+                this.tickPromise = undefined;
+        });
+        this.tickPromise = shared;
+        return shared;
+    }
+    async runTick(refreshSubscriptions, generation) {
         try {
-            for (const monitor of this.repository.list().filter((candidate) => candidate.enabled)) {
-                const provider = this.providers.get(monitor.sourceType);
-                if (provider?.startMonitor) {
-                    continue;
-                }
-                const event = await this.pollMonitor(monitor, false);
-                if (!event) {
-                    continue;
-                }
-                if (!(0, condition_evaluator_js_1.evaluateMonitorCondition)(monitor.condition, event)) {
-                    this.repository.updateState(monitor.id, {
-                        lastState: this.stateFromEvent(event, monitor.lastState),
-                    });
-                    continue;
+            if (refreshSubscriptions)
+                await this.refreshSubscriptions(generation);
+            if (generation !== undefined && !this.isCurrentLifecycle(generation, 'running'))
+                return;
+            const monitors = this.listMonitors().filter((candidate) => candidate.enabled && !this.providers.get(candidate.sourceType)?.startMonitor);
+            let index = 0;
+            const worker = async () => {
+                while (true) {
+                    const monitor = monitors[index++];
+                    if (!monitor)
+                        return;
+                    if (generation !== undefined && !this.isCurrentLifecycle(generation, 'running'))
+                        return;
+                    try {
+                        const polled = await this.pollMonitor(monitor, false, generation);
+                        if (generation !== undefined && !this.isCurrentLifecycle(generation, 'running'))
+                            return;
+                        if (polled?.event)
+                            await this.evaluateEvent(monitor.id, polled.event, {
+                                kind: 'poll', token: polled.token, lifecycleGeneration: generation,
+                            });
+                        if (generation !== undefined && !this.isCurrentLifecycle(generation, 'running'))
+                            return;
+                    }
+                    catch (error) {
+                        this.reportProviderError(`poll:${monitor.id}`, error);
+                    }
                 }
-                if (this.isCoolingDown(monitor, event.occurredAt)) {
-                    continue;
-                }
-                void this.executeMonitor(monitor, event, false);
-            }
+            };
+            await Promise.allSettled(Array.from({ length: Math.min(PROVIDER_EVENT_CONCURRENCY, monitors.length) }, () => worker()));
         }
         finally {
-            this.pollInFlight = false;
+            // tickPromise owns overlap and settlement state.
         }
     }
-    async pollMonitor(monitor, manual) {
+    async pollMonitor(monitor, manual, generation) {
+        if (this.lifecycleState === 'stopping')
+            return undefined;
+        const operationGeneration = this.lifecycleGeneration;
+        if (generation !== undefined && !this.isCurrentLifecycle(generation, 'running'))
+            return undefined;
         const provider = this.providers.get(monitor.sourceType);
         if (!provider?.poll) {
-            if (manual) {
+            if (manual)
                 throw new Error(`No polling provider is available for monitor source "${monitor.sourceType}"`);
-            }
-            return null;
+            return undefined;
         }
-        return provider.poll({
+        const token = this.providerDefinitionToken(monitor.id);
+        const event = await this.observeProviderWork(Promise.resolve(provider.poll({
             monitorId: monitor.id,
             workspaceId: monitor.workspaceId,
             sourceConfig: monitor.sourceConfig,
             lastState: monitor.lastState,
-        });
+        })));
+        if (operationGeneration !== this.lifecycleGeneration || this.isLifecycleStopping())
+            return undefined;
+        if (generation !== undefined && !this.isCurrentLifecycle(generation, 'running'))
+            return undefined;
+        this.options.automations.assertLegacyFacadesAvailable();
+        if (!this.isProviderDefinitionCurrent(monitor.id, token))
+            return undefined;
+        return { event, token };
     }
-    async executeMonitor(monitor, event, manual) {
-        if (this.runningMonitors.has(monitor.id)) {
-            const skipped = this.markSkipped(monitor, event.occurredAt, 'Skipped because the previous monitor run is still active.', event);
-            this.emitRun(skipped);
-            return skipped;
-        }
-        this.runningMonitors.add(monitor.id);
-        const run = this.repository.createRun(monitor.id, 'queued', {
-            triggeredAt: event.occurredAt,
-            eventSnapshot: event,
-            deliveryStatus: 'pending',
-        });
-        this.emitRun(run);
+    evaluateEvent(monitorId, event, admission) {
+        let snapshot;
         try {
-            const running = this.repository.updateRun(run.id, {
-                status: 'running',
-                startedAt: new Date().toISOString(),
-            });
-            this.emitRun(running);
-            const result = await this.executor.execute(monitor, event);
-            const succeeded = this.repository.updateRun(run.id, {
-                status: 'succeeded',
-                finishedAt: new Date().toISOString(),
-                threadId: result.threadId,
-                runId: result.runId,
-                deliveryMode: result.deliveryMode,
-                deliveryStatus: result.deliveryStatus || 'succeeded',
-                deliveryError: result.deliveryError || '',
-                lastBridgeEventAt: result.lastBridgeEventAt,
-                error: '',
-            });
-            this.repository.updateState(monitor.id, {
-                lastState: this.stateFromEvent(event, monitor.lastState),
-                lastTriggeredAt: event.occurredAt,
-                lastStatus: 'succeeded',
-                lastError: '',
-            });
-            this.emitRun(succeeded);
-            const nextMonitor = this.repository.get(monitor.id);
-            if (nextMonitor)
-                this.emitMonitor(nextMonitor);
-            return succeeded;
+            snapshot = (0, automation_service_js_1.normalizeProviderEventSnapshot)(event);
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            const failed = this.repository.updateRun(run.id, {
-                status: 'failed',
-                finishedAt: new Date().toISOString(),
-                error: message,
-                deliveryStatus: 'failed',
-                deliveryError: message,
-            });
-            this.repository.updateState(monitor.id, {
-                lastState: this.stateFromEvent(event, monitor.lastState),
-                lastTriggeredAt: event.occurredAt,
-                lastStatus: 'failed',
-                lastError: message,
-            });
-            this.emitRun(failed);
-            const nextMonitor = this.repository.get(monitor.id);
-            if (nextMonitor)
-                this.emitMonitor(nextMonitor);
-            this.options.log?.(`automation monitor failed ${monitor.id}: ${message}`);
-            return failed;
+            return Promise.reject(error);
         }
-        finally {
-            this.runningMonitors.delete(monitor.id);
-        }
-    }
-    markSkipped(monitor, triggeredAt, error, eventSnapshot) {
-        return this.repository.createRun(monitor.id, 'skipped', {
-            triggeredAt,
-            error,
-            eventSnapshot,
-            deliveryStatus: 'skipped',
-            deliveryError: error,
-        });
+        return this.observeProviderWork(this.evaluateNormalizedEvent(monitorId, snapshot, admission));
     }
-    stateFromEvent(event, previous) {
-        return {
-            ...(previous || {}),
-            lastEventId: event.id,
-            lastEventAt: event.occurredAt,
-            latestPrice: event.payload.latestPrice ?? previous?.latestPrice,
-            previousPrice: event.payload.previousPrice ?? previous?.previousPrice,
-            payload: event.payload,
-        };
-    }
-    isCoolingDown(monitor, occurredAt) {
-        if (!monitor.lastTriggeredAt || monitor.cooldownMs <= 0) {
-            return false;
-        }
-        return Date.parse(occurredAt) - Date.parse(monitor.lastTriggeredAt) < monitor.cooldownMs;
-    }
-    resolveCreateInput(input) {
-        if (input.platform && input.route) {
-            return {
-                ...input,
-                route: (0, scheduled_job_route_js_1.routeWithPlatformInstance)((0, scheduled_job_route_js_1.withoutThreadRoute)(input.route), input.platform),
-            };
-        }
-        const threadId = String(input.threadId || input.route?.threadId || '').trim();
-        if (threadId) {
-            const binding = this.repository.getPlatformThreadBindingByThreadId(threadId);
-            if (binding && binding.workspace_id === input.workspaceId) {
-                return {
-                    ...input,
-                    platform: binding.platform,
-                    route: (0, scheduled_job_route_js_1.routeFromPlatformThreadBinding)(binding),
-                };
+    async evaluateNormalizedEvent(monitorId, event, admission) {
+        const admitted = await this.acquireProviderEventPermit(admission.kind === 'manual'
+            ? undefined
+            : admission.lifecycleGeneration);
+        if (!admitted)
+            return undefined;
+        try {
+            if (admission.kind !== 'manual'
+                && admission.lifecycleGeneration !== undefined
+                && !this.isCurrentLifecycle(admission.lifecycleGeneration, 'running'))
+                return undefined;
+            this.options.automations.assertLegacyFacadesAvailable();
+            const definition = this.options.automations.get(monitorId);
+            if (!definition || definition.activation.kind !== 'provider-event')
+                return undefined;
+            if (admission.kind === 'manual') {
+                if (admission.token && !this.isProviderDefinitionCurrent(monitorId, admission.token))
+                    return undefined;
             }
+            else {
+                if (!definition.enabled || definition.health === 'blocked')
+                    return undefined;
+                if (admission.kind === 'subscription'
+                    && (this.subscriptionGenerations.get(monitorId) !== admission.generation
+                        || !this.subscriptionHandles.has(monitorId)))
+                    return undefined;
+                if (admission.kind === 'poll' && !this.isProviderDefinitionCurrent(monitorId, admission.token))
+                    return undefined;
+            }
+            const evaluation = await this.observeProviderWork(this.options.automations.evaluateProviderEvent(monitorId, event));
+            if (admission.kind !== 'manual'
+                && admission.lifecycleGeneration !== undefined
+                && !this.isCurrentLifecycle(admission.lifecycleGeneration, 'running'))
+                return undefined;
+            const run = this.options.automations.listRuns(monitorId).find((candidate) => candidate.evaluationId === evaluation.id);
+            return (0, legacy_automation_mappers_js_1.automationToMonitorRun)(evaluation, run);
         }
-        return {
-            ...input,
-            platform: 'local',
-            route: {
-                type: 'local.thread',
-                channelId: input.workspaceId,
-            },
-        };
-    }
-    getRequiredMonitor(monitorId) {
-        const monitor = this.getMonitor(monitorId);
-        if (!monitor) {
-            throw new Error(`Automation monitor not found: ${monitorId}`);
-        }
-        return monitor;
-    }
-    resolveMonitorId(monitorId) {
-        if (this.repository.get(monitorId)) {
-            return monitorId;
-        }
-        const matches = this.repository
-            .list()
-            .filter((monitor) => (0, monitor_id_js_1.toPublicAutomationMonitorId)(monitor.id) === monitorId);
-        if (matches.length === 0) {
-            return '';
-        }
-        if (matches.length > 1) {
-            throw new Error(`Automation monitor id is ambiguous: ${monitorId}`);
+        finally {
+            this.releaseProviderEventPermit();
         }
-        return matches[0].id;
     }
-    resolveRequiredMonitorId(monitorId) {
-        const resolved = this.resolveMonitorId(monitorId);
-        if (!resolved) {
-            throw new Error(`Automation monitor not found: ${monitorId}`);
+    async acquireProviderEventPermit(generation) {
+        if (!this.canAdmitProviderWork(generation))
+            return false;
+        if (this.providerEventsInFlight >= PROVIDER_EVENT_CONCURRENCY) {
+            const admitted = await new Promise((resolve) => this.providerEventWaiters.push(resolve));
+            if (!admitted)
+                return false;
         }
-        return resolved;
-    }
-    emitMonitor(monitor) {
-        this.options.eventBus.emit({ type: 'automation.monitor.updated', payload: monitor });
+        if (!this.canAdmitProviderWork(generation))
+            return false;
+        this.providerEventsInFlight += 1;
+        return true;
     }
-    emitRun(run) {
-        this.options.eventBus.emit({ type: 'automation.monitor.run.updated', payload: run });
+    releaseProviderEventPermit() {
+        this.providerEventsInFlight -= 1;
+        this.providerEventWaiters.shift()?.(true);
     }
-    async refreshSubscriptions() {
+    async refreshSubscriptions(generation) {
+        if (generation !== undefined && !this.isActiveLifecycle(generation))
+            return;
         const activeIds = new Set();
-        for (const monitor of this.repository.list().filter((candidate) => candidate.enabled)) {
-            const provider = this.providers.get(monitor.sourceType);
-            if (!provider?.startMonitor)
+        const work = [];
+        for (const monitor of this.listMonitors().filter((candidate) => candidate.enabled)) {
+            if (!this.providers.get(monitor.sourceType)?.startMonitor)
                 continue;
             activeIds.add(monitor.id);
-            await this.ensureSubscription(monitor);
+            if (!this.subscriptionHandles.has(monitor.id)) {
+                work.push({ monitorId: monitor.id, kind: 'start', run: () => this.ensureSubscription(monitor, generation) });
+            }
+            else if (generation !== undefined) {
+                this.handleLifecycleGenerations.set(monitor.id, generation);
+            }
         }
-        for (const monitorId of [...this.subscriptionHandles.keys()]) {
+        for (const monitorId of this.subscriptionHandles.keys()) {
             if (!activeIds.has(monitorId)) {
-                await this.stopSubscription(monitorId);
+                work.push({ monitorId, kind: 'stop', run: () => this.stopSubscription(monitorId) });
             }
         }
+        let index = 0;
+        const worker = async () => {
+            while (true) {
+                const entry = work[index++];
+                if (!entry)
+                    return;
+                if (generation !== undefined && !this.isActiveLifecycle(generation))
+                    return;
+                try {
+                    await entry.run();
+                    if (generation !== undefined && !this.isActiveLifecycle(generation))
+                        return;
+                }
+                catch (error) {
+                    if (generation !== undefined && !this.isActiveLifecycle(generation))
+                        return;
+                    if (entry.kind === 'start')
+                        this.blockSubscription(entry.monitorId, error);
+                    this.reportProviderError(`subscription:${entry.monitorId}`, error);
+                }
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(PROVIDER_EVENT_CONCURRENCY, work.length) }, () => worker()));
+        if (generation !== undefined && !this.isActiveLifecycle(generation))
+            return;
     }
-    async ensureSubscription(monitor) {
+    async ensureSubscription(monitor, lifecycleGeneration) {
+        if (this.lifecycleState === 'stopping')
+            return;
+        if (lifecycleGeneration !== undefined && !this.isActiveLifecycle(lifecycleGeneration))
+            return;
+        this.options.automations.assertLegacyFacadesAvailable();
         const provider = this.providers.get(monitor.sourceType);
         if (!monitor.enabled || !provider?.startMonitor) {
             await this.stopSubscription(monitor.id);
+            if (lifecycleGeneration !== undefined && !this.isActiveLifecycle(lifecycleGeneration))
+                return;
             return;
         }
         if (this.subscriptionHandles.has(monitor.id)) {
+            if (lifecycleGeneration !== undefined)
+                this.handleLifecycleGenerations.set(monitor.id, lifecycleGeneration);
+            this.recoverSubscriptionHealth(monitor.id);
+            return;
+        }
+        const handle = await this.startSubscriptionHandle(monitor, lifecycleGeneration);
+        if (lifecycleGeneration !== undefined && !this.isActiveLifecycle(lifecycleGeneration)) {
+            if (handle)
+                await this.stopProviderHandle(monitor.id, handle, 'stale-ensure');
             return;
         }
-        const handle = await provider.startMonitor({
+        if (handle) {
+            this.installSubscriptionHandle(monitor.id, handle, lifecycleGeneration);
+            this.recoverSubscriptionHealth(monitor.id);
+        }
+    }
+    async startSubscriptionHandle(monitor, lifecycleGeneration) {
+        if (this.lifecycleState === 'stopping')
+            return undefined;
+        const operationGeneration = this.lifecycleGeneration;
+        if (lifecycleGeneration !== undefined && !this.isActiveLifecycle(lifecycleGeneration))
+            return undefined;
+        const provider = this.providers.get(monitor.sourceType);
+        if (!monitor.enabled || !provider?.startMonitor)
+            return undefined;
+        const generation = (this.subscriptionGenerations.get(monitor.id) || 0) + 1;
+        this.subscriptionGenerations.set(monitor.id, generation);
+        const handle = await this.observeProviderWork(Promise.resolve(provider.startMonitor({
             monitorId: monitor.id,
             workspaceId: monitor.workspaceId,
             sourceConfig: monitor.sourceConfig,
             lastState: monitor.lastState,
             emit: async (event) => {
-                const latest = this.repository.get(monitor.id);
-                if (!latest || !latest.enabled)
-                    return;
-                if (!(0, condition_evaluator_js_1.evaluateMonitorCondition)(latest.condition, event)) {
-                    this.repository.updateState(latest.id, { lastState: this.stateFromEvent(event, latest.lastState) });
-                    return;
+                try {
+                    const callbackLifecycleGeneration = this.handleLifecycleGenerations.get(monitor.id);
+                    if (callbackLifecycleGeneration === undefined
+                        || !this.isCurrentLifecycle(callbackLifecycleGeneration, 'running'))
+                        return;
+                    const latest = this.getMonitor(monitor.id);
+                    const definition = this.options.automations.get(monitor.id);
+                    if (latest?.enabled
+                        && definition?.health !== 'blocked'
+                        && this.subscriptionHandles.has(monitor.id)) {
+                        await this.evaluateEvent(latest.id, event, {
+                            kind: 'subscription', generation, lifecycleGeneration: callbackLifecycleGeneration,
+                        });
+                    }
+                }
+                catch (error) {
+                    this.reportProviderError(`event:${monitor.id}`, error);
                 }
-                if (this.isCoolingDown(latest, event.occurredAt))
-                    return;
-                await this.executeMonitor(latest, event, false);
             },
-        });
-        this.subscriptionHandles.set(monitor.id, handle);
+        })));
+        if (operationGeneration !== this.lifecycleGeneration || this.isLifecycleStopping()) {
+            await this.stopProviderHandle(monitor.id, handle, 'stale-start');
+            return undefined;
+        }
+        if (lifecycleGeneration !== undefined && !this.isActiveLifecycle(lifecycleGeneration)) {
+            await this.stopProviderHandle(monitor.id, handle, 'stale-start');
+            return undefined;
+        }
+        try {
+            this.options.automations.assertLegacyFacadesAvailable();
+        }
+        catch (error) {
+            try {
+                await this.observeProviderWork(Promise.resolve().then(() => handle.stop()));
+            }
+            catch (stopError) {
+                this.installSubscriptionHandle(monitor.id, handle, lifecycleGeneration);
+                const message = `${this.lifecycleError(`degraded-start:${monitor.id}`, error)}; ${this.lifecycleError(`degraded-stop:${monitor.id}`, stopError)}`;
+                this.options.automations.failClosedLegacyAutomation(monitor.id, message);
+                this.reportProviderError(`degraded-stop:${monitor.id}`, stopError);
+            }
+            throw error;
+        }
+        return handle;
     }
     async stopSubscription(monitorId) {
         const handle = this.subscriptionHandles.get(monitorId);
         if (!handle)
             return;
-        this.subscriptionHandles.delete(monitorId);
-        await handle.stop();
+        await this.observeProviderWork(Promise.resolve().then(() => handle.stop()));
+        if (this.subscriptionHandles.get(monitorId) === handle) {
+            this.subscriptionHandles.delete(monitorId);
+            this.handleLifecycleGenerations.delete(monitorId);
+            this.subscriptionGenerations.set(monitorId, (this.subscriptionGenerations.get(monitorId) || 0) + 1);
+        }
+    }
+    async updateSourceConfigTransaction(existing, update, sourceConfig) {
+        await this.stopSubscription(existing.id);
+        const prospective = { ...existing, ...('enabled' in update ? { enabled: update.enabled ?? existing.enabled } : {}), sourceConfig };
+        let nextHandle;
+        try {
+            nextHandle = await this.startSubscriptionHandle(prospective);
+        }
+        catch (error) {
+            if (!this.subscriptionHandles.has(existing.id)) {
+                await this.restoreSubscriptionOrFailClosed(existing, error);
+            }
+            throw new Error(this.lifecycleError(`update-start:${existing.id}`, error));
+        }
+        try {
+            if (nextHandle)
+                this.installSubscriptionHandle(existing.id, nextHandle);
+            const monitor = (0, legacy_automation_mappers_js_1.automationToMonitor)(this.options.automations.updateFromLegacy(existing.id, update));
+            this.recoverSubscriptionHealth(existing.id);
+            return monitor;
+        }
+        catch (error) {
+            if (nextHandle) {
+                try {
+                    await this.stopSubscription(existing.id);
+                }
+                catch (stopError) {
+                    const message = `${this.lifecycleError(`update-persist:${existing.id}`, error)}; ${this.lifecycleError(`update-new-stop:${existing.id}`, stopError)}`;
+                    this.options.automations.failClosedLegacyAutomation(existing.id, message);
+                    throw new Error(message);
+                }
+            }
+            await this.restoreSubscriptionOrFailClosed(existing, error);
+            throw new Error(this.lifecycleError(`update-persist:${existing.id}`, error));
+        }
+    }
+    async enableSubscriptionTransaction(existing, update, sourceConfig) {
+        let handle = this.subscriptionHandles.get(existing.id);
+        if (!handle) {
+            try {
+                handle = await this.startSubscriptionHandle({ ...existing, enabled: true, sourceConfig });
+            }
+            catch (error) {
+                throw new Error(this.lifecycleError(`enable-start:${existing.id}`, error));
+            }
+            if (handle)
+                this.installSubscriptionHandle(existing.id, handle);
+        }
+        try {
+            const monitor = (0, legacy_automation_mappers_js_1.automationToMonitor)(this.options.automations.updateFromLegacy(existing.id, update));
+            this.recoverSubscriptionHealth(existing.id);
+            return monitor;
+        }
+        catch (error) {
+            if (handle) {
+                try {
+                    await this.stopSubscription(existing.id);
+                }
+                catch (stopError) {
+                    const message = `${this.lifecycleError(`enable-persist:${existing.id}`, error)}; ${this.lifecycleError(`enable-stop:${existing.id}`, stopError)}`;
+                    this.options.automations.failClosedLegacyAutomation(existing.id, message);
+                    throw new Error(message);
+                }
+            }
+            this.options.automations.failClosedLegacyAutomation(existing.id, this.lifecycleError(`enable-persist:${existing.id}`, error));
+            throw new Error(this.lifecycleError(`enable-persist:${existing.id}`, error));
+        }
+    }
+    async disableSubscriptionTransaction(existing, update) {
+        try {
+            await this.stopSubscription(existing.id);
+        }
+        catch (error) {
+            throw new Error(this.lifecycleError(`disable-stop:${existing.id}`, error));
+        }
+        try {
+            return (0, legacy_automation_mappers_js_1.automationToMonitor)(this.options.automations.updateFromLegacy(existing.id, update));
+        }
+        catch (error) {
+            await this.restoreSubscriptionOrFailClosed(existing, error);
+            throw new Error(this.lifecycleError(`disable-persist:${existing.id}`, error));
+        }
+    }
+    async restoreSubscriptionOrFailClosed(existing, cause) {
+        try {
+            const restored = await this.startSubscriptionHandle(existing);
+            if (restored) {
+                this.installSubscriptionHandle(existing.id, restored);
+                this.recoverSubscriptionHealth(existing.id);
+            }
+        }
+        catch (restoreError) {
+            const message = `${this.lifecycleError(`subscription-transition:${existing.id}`, cause)}; ${this.lifecycleError(`subscription-restore:${existing.id}`, restoreError)}`;
+            this.options.automations.failClosedLegacyAutomation(existing.id, message);
+        }
+    }
+    reportProviderError(scope, error) {
+        const message = this.lifecycleError(scope, error);
+        try {
+            this.options.log?.(`automation monitor provider ${scope} failed: ${message}`);
+        }
+        catch {
+            // Provider diagnostics must not destabilize lifecycle isolation.
+        }
+    }
+    lifecycleError(scope, error) {
+        return (0, automation_service_js_1.normalizeAutomationError)(error, `automation monitor provider ${scope} failed: `);
+    }
+    blockSubscription(monitorId, error) {
+        const reason = (0, automation_service_js_1.providerLifecycleBlockReason)(error);
+        try {
+            this.options.automations.assertLegacyFacadesAvailable();
+            this.options.automations.markLegacyProviderLifecycleBlocked(monitorId, reason);
+        }
+        catch (healthError) {
+            this.reportProviderError(`subscription-health:${monitorId}`, healthError);
+        }
+    }
+    recoverSubscriptionHealth(monitorId) {
+        const definition = this.options.automations.get(monitorId);
+        const reason = definition?.health === 'blocked' ? definition.blockedReason : undefined;
+        if (reason?.startsWith(automation_service_js_1.PROVIDER_LIFECYCLE_BLOCK_PREFIX)) {
+            this.options.automations.clearLegacyProviderLifecycleBlocked(monitorId, reason);
+        }
+    }
+    providerDefinitionToken(monitorId) {
+        const definition = this.options.automations.get(monitorId);
+        if (!definition || definition.activation.kind !== 'provider-event')
+            return '';
+        return `${definition.updatedAt}\n${JSON.stringify(definition.activation.sourceConfig || {})}`;
+    }
+    isProviderDefinitionCurrent(monitorId, token) {
+        return token !== '' && this.providerDefinitionToken(monitorId) === token;
+    }
+    isCurrentLifecycle(generation, state) {
+        return this.lifecycleGeneration === generation && this.lifecycleState === state;
+    }
+    isActiveLifecycle(generation) {
+        return this.lifecycleGeneration === generation
+            && (this.lifecycleState === 'starting' || this.lifecycleState === 'running');
+    }
+    canAdmitProviderWork(generation) {
+        return this.lifecycleState !== 'stopping'
+            && (generation === undefined || this.isCurrentLifecycle(generation, 'running'));
+    }
+    isLifecycleStopping() {
+        return this.lifecycleState === 'stopping';
+    }
+    installSubscriptionHandle(monitorId, handle, lifecycleGeneration = this.lifecycleGeneration) {
+        this.subscriptionHandles.set(monitorId, handle);
+        if (this.lifecycleState === 'running' && lifecycleGeneration === this.lifecycleGeneration) {
+            this.handleLifecycleGenerations.set(monitorId, lifecycleGeneration);
+        }
+        else {
+            this.handleLifecycleGenerations.delete(monitorId);
+        }
+    }
+    async stopProviderHandle(monitorId, handle, scope) {
+        try {
+            await this.observeProviderWork(Promise.resolve().then(() => handle.stop()));
+        }
+        catch (error) {
+            if (!this.subscriptionHandles.has(monitorId))
+                this.installSubscriptionHandle(monitorId, handle);
+            this.reportProviderError(`${scope}:${monitorId}`, error);
+        }
+    }
+    observeProviderWork(work) {
+        let observed;
+        observed = work.finally(() => this.inFlight.delete(observed));
+        this.inFlight.add(observed);
+        return observed;
+    }
+    async settleInFlight() {
+        while (this.inFlight.size > 0) {
+            await Promise.allSettled([...this.inFlight]);
+        }
+    }
+    resolveCreateInput(input) {
+        if (input.platform && input.route) {
+            return { ...input, route: (0, scheduled_job_route_js_1.routeWithPlatformInstance)((0, scheduled_job_route_js_1.withoutThreadRoute)(input.route), input.platform) };
+        }
+        const threadId = String(input.threadId || input.route?.threadId || '').trim();
+        if (threadId) {
+            const binding = this.options.store.getPlatformThreadBindingByThreadId(threadId);
+            if (binding && binding.workspace_id === input.workspaceId) {
+                return { ...input, platform: binding.platform, route: (0, scheduled_job_route_js_1.routeFromPlatformThreadBinding)(binding) };
+            }
+        }
+        return {
+            ...input,
+            platform: 'local',
+            route: { type: 'local.thread', channelId: input.workspaceId },
+        };
+    }
+    getRequiredMonitor(monitorId) {
+        const monitor = this.getMonitor(monitorId);
+        if (!monitor)
+            throw new Error(`Automation monitor not found: ${monitorId}`);
+        return monitor;
+    }
+    resolveMonitorId(monitorId) {
+        const direct = this.options.automations.get(monitorId);
+        if (direct?.originKind === 'automation-monitor')
+            return direct.id;
+        const matches = this.options.automations.list().filter((automation) => automation.originKind === 'automation-monitor' && (0, monitor_id_js_1.toPublicAutomationMonitorId)(automation.id) === monitorId);
+        if (matches.length > 1)
+            throw new Error(`Automation monitor id is ambiguous: ${monitorId}`);
+        return matches[0]?.id || '';
+    }
+    resolveRequiredMonitorId(monitorId) {
+        const resolved = this.resolveMonitorId(monitorId);
+        if (!resolved)
+            throw new Error(`Automation monitor not found: ${monitorId}`);
+        return resolved;
     }
 }
 exports.AutomationMonitorService = AutomationMonitorService;