@kafca/agentdock 0.1.61 → 0.1.62

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

@@ -0,0 +1,1019 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationService = exports.NATIVE_AUTOMATION_OWNERSHIP = exports.PROVIDER_LIFECYCLE_BLOCK_PREFIX = exports.AUTOMATION_ERROR_MAX_LENGTH = void 0;
+exports.normalizeAutomationError = normalizeAutomationError;
+exports.providerLifecycleBlockReason = providerLifecycleBlockReason;
+exports.normalizeProviderEventSnapshot = normalizeProviderEventSnapshot;
+const local_core_acp_store_js_1 = require("../acp/local-core-acp-store.js");
+const automation_condition_engine_js_1 = require("./automation-condition-engine.js");
+const script_protocol_runner_js_1 = require("./scripts/script-protocol-runner.js");
+const anthropic_sandbox_runner_js_1 = require("./scripts/anthropic-sandbox-runner.js");
+const condition_evaluator_js_1 = require("./condition-evaluator.js");
+const automation_trigger_engine_js_1 = require("./automation-trigger-engine.js");
+const legacy_automation_mappers_js_1 = require("./legacy-automation-mappers.js");
+const DUE_LOOP_INTERVAL_MS = 30_000;
+const DEFAULT_MAX_CONCURRENCY = 4;
+exports.AUTOMATION_ERROR_MAX_LENGTH = 2_000;
+exports.PROVIDER_LIFECYCLE_BLOCK_PREFIX = 'Automation monitor provider lifecycle blocked: ';
+const PROVIDER_JSON_MAX_DEPTH = 64;
+const PROVIDER_JSON_MAX_SIZE = 100_000;
+const PROVIDER_EVENT_STRING_MAX_LENGTH = 16_384;
+const FAILURE_ALERT_COUNTS = new Set([1, 3, 7, 15, 31]);
+const RESTART_INTERRUPTION_REASON = 'Automation action interrupted by Local AI Core restart.';
+exports.NATIVE_AUTOMATION_OWNERSHIP = {
+    executes: () => true,
+};
+class AutomationService {
+    options;
+    timer;
+    tickPromise;
+    startPromise;
+    inFlight = new Map();
+    runtimeStatus = { status: 'stopped' };
+    stopping = false;
+    lifecycleGeneration = 0;
+    scriptProtocolRunner;
+    constructor(options) {
+        this.options = options;
+        const concurrency = options.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY;
+        if (!Number.isSafeInteger(concurrency) || concurrency < 1) {
+            throw new Error('Automation maxConcurrency must be a positive safe integer.');
+        }
+        this.scriptProtocolRunner = options.scriptProtocolRunner;
+    }
+    list(workspaceId) {
+        return this.options.store.listAutomations(workspaceId);
+    }
+    get(automationId) {
+        return this.options.store.getAutomation(automationId);
+    }
+    create(input) {
+        const updated = this.options.store.createAutomationAtomically(input, (automation) => ({
+            nextCheckAt: this.initialNextCheckAt(automation),
+        }));
+        this.emitDefinition(updated);
+        return updated;
+    }
+    createFromLegacy(input) {
+        this.assertLegacyFacadesAvailable();
+        const updated = this.options.store.createTrustedAutomationAtomically(input, (automation) => ({
+            nextCheckAt: this.initialNextCheckAt(automation),
+        }));
+        this.emitDefinition(updated);
+        return updated;
+    }
+    assertLegacyFacadesAvailable() {
+        if (this.runtimeStatus.status === 'degraded') {
+            throw new Error(`Unified automation migration is unavailable: ${this.runtimeStatus.reason}`);
+        }
+    }
+    update(automationId, input) {
+        return this.updateInternal(automationId, input);
+    }
+    updateFromLegacy(automationId, input) {
+        this.assertLegacyFacadesAvailable();
+        return this.updateInternal(automationId, input, true);
+    }
+    updateInternal(automationId, input, trustedLegacy = false) {
+        const existing = this.requireAutomation(automationId);
+        const initialize = (automation) => {
+            if (input.activation !== undefined) {
+                return { nextCheckAt: this.initialNextCheckAt(automation, true) };
+            }
+            if (input.enabled === true
+                && existing.enabled === false
+                && this.options.store.getAutomationNextCheckAt(automation.id) === null
+                && !this.isConsumedOnce(automation))
+                return { nextCheckAt: this.initialNextCheckAt(automation) };
+            return undefined;
+        };
+        const updated = trustedLegacy
+            ? this.options.store.updateTrustedAutomationAtomically(automationId, input, initialize)
+            : this.options.store.updateAutomationAtomically(automationId, input, initialize);
+        this.emitDefinition(updated);
+        return updated;
+    }
+    delete(automationId) {
+        return this.options.store.deleteAutomation(automationId);
+    }
+    listEvaluations(automationId) {
+        return this.options.store.listAutomationEvaluations(automationId);
+    }
+    getLatestEvaluationWithState(automationId) {
+        return this.options.store.getLatestAutomationEvaluationWithState(automationId);
+    }
+    listRuns(automationId) {
+        return this.options.store.listAutomationRuns(automationId);
+    }
+    getRuntimeStatus() {
+        return this.runtimeStatus;
+    }
+    start() {
+        if (this.startPromise)
+            return this.startPromise;
+        if (this.runtimeStatus.status === 'running')
+            return Promise.resolve();
+        const work = this.startInternal();
+        let shared;
+        shared = work.finally(() => {
+            if (this.startPromise === shared)
+                this.startPromise = undefined;
+        });
+        this.startPromise = shared;
+        return shared;
+    }
+    async startInternal() {
+        this.stopping = false;
+        const generation = ++this.lifecycleGeneration;
+        await this.settleActiveWork();
+        if (generation !== this.lifecycleGeneration || this.stopping)
+            return;
+        try {
+            this.options.store.importLegacyAutomations();
+        }
+        catch (error) {
+            const reason = normalizeAutomationError(error, 'Legacy automation import failed: ');
+            this.runtimeStatus = { status: 'degraded', reason };
+            this.reportDiagnostic('legacy-import', reason);
+            return;
+        }
+        try {
+            const recovered = this.options.store.reconcileInterruptedAutomationRuns(normalizeAutomationError(RESTART_INTERRUPTION_REASON), this.now().toISOString());
+            for (const run of recovered)
+                this.emitRun(run);
+            for (const automation of this.list()) {
+                if (this.shouldPoll(automation)
+                    && this.options.store.getAutomationNextCheckAt(automation.id) === null
+                    && !this.isConsumedOnce(automation)) {
+                    this.persistInitialNextCheck(automation);
+                }
+            }
+            this.runtimeStatus = { status: 'running' };
+            if (this.timer === undefined) {
+                this.timer = (this.options.setInterval || setInterval)(() => {
+                    this.runTimerTick(generation);
+                }, DUE_LOOP_INTERVAL_MS);
+            }
+            await this.tick();
+        }
+        catch (error) {
+            const isCurrentGeneration = this.lifecycleGeneration === generation && !this.stopping;
+            if (isCurrentGeneration) {
+                this.clearTimer();
+                this.runtimeStatus = { status: 'stopped' };
+            }
+            const message = normalizeAutomationError(error, 'Automation startup failed: ');
+            this.reportDiagnostic('startup', message);
+            throw new Error(message);
+        }
+    }
+    async stop() {
+        this.stopping = true;
+        const stopGeneration = ++this.lifecycleGeneration;
+        this.clearTimer();
+        this.runtimeStatus = { status: 'stopped' };
+        await this.settleActiveWork();
+        if (this.lifecycleGeneration === stopGeneration) {
+            this.runtimeStatus = { status: 'stopped' };
+        }
+    }
+    async tick() {
+        if (this.tickPromise)
+            return this.tickPromise;
+        const work = this.runTick(this.lifecycleGeneration);
+        this.tickPromise = work;
+        try {
+            await work;
+        }
+        finally {
+            if (this.tickPromise === work)
+                this.tickPromise = undefined;
+        }
+    }
+    async checkNow(automationId) {
+        const automation = this.requireAutomation(automationId);
+        if (automation.activation.kind === 'provider-event') {
+            throw new Error(`Provider-event automation requires an event snapshot: ${automationId}`);
+        }
+        return this.checkAutomation(automation, undefined, true);
+    }
+    /** The HTTP layer calls this only after the approval service grants one test run. */
+    async executeAuthorizedScriptTest(versionId) {
+        const version = this.options.store.getAutomationScriptVersion(versionId);
+        if (!version || version.status !== 'testing') {
+            throw new Error('Automation script test requires a claimed test authorization.');
+        }
+        const finishedAt = this.now().toISOString();
+        try {
+            const result = await this.getScriptTestRunner().runTest({
+                scriptId: version.scriptId,
+                approvedVersionId: version.id,
+                evaluationId: `script-test:${version.id}`,
+                triggeredAt: finishedAt,
+                previousState: {},
+            });
+            return {
+                status: 'passed',
+                finishedAt: this.now().toISOString(),
+                ...(result.summary === undefined ? {} : { summary: result.summary }),
+            };
+        }
+        catch (error) {
+            return {
+                status: 'failed',
+                finishedAt: this.now().toISOString(),
+                summary: normalizeAutomationError(error),
+            };
+        }
+    }
+    async evaluateProviderEvent(automationId, event) {
+        this.assertLegacyFacadesAvailable();
+        const automation = this.requireAutomation(automationId);
+        if (automation.activation.kind !== 'provider-event') {
+            throw new Error(`Automation is not provider-event activated: ${automationId}`);
+        }
+        const snapshot = normalizeProviderEventSnapshot(event);
+        if (snapshot.sourceType !== automation.activation.sourceType) {
+            throw new Error(normalizeAutomationError(`Provider event source "${snapshot.sourceType}" does not match automation source "${automation.activation.sourceType}".`));
+        }
+        return this.checkAutomation(automation, this.providerEventContext(automation, snapshot));
+    }
+    recordUnavailableProviderEvent(automationId, reason) {
+        this.assertLegacyFacadesAvailable();
+        const automation = this.requireAutomation(automationId);
+        if (automation.activation.kind !== 'provider-event') {
+            throw new Error(`Automation is not provider-event activated: ${automationId}`);
+        }
+        const startedAt = this.now();
+        const running = this.createEvaluation(automation, startedAt);
+        const finishedAt = this.now();
+        const finished = this.finishEvaluation(running.id, {
+            conditionOutcome: 'skipped',
+            triggerDecision: 'not_evaluated',
+            finishedAt: finishedAt.toISOString(),
+            durationMs: Math.max(0, finishedAt.getTime() - startedAt.getTime()),
+            resultSummary: normalizeAutomationError(reason),
+        });
+        this.updateDefinitionAfterEvaluation(automation, finishedAt, {
+            nextMatch: automation.lastSuccessfulMatch,
+            failureCount: automation.consecutiveEvaluationFailures,
+        });
+        this.emitCompatibilityEvaluationRun(automation, finished);
+        return finished;
+    }
+    failClosedLegacyAutomation(automationId, reason) {
+        const automation = this.requireAutomation(automationId);
+        if (automation.originKind === 'native') {
+            throw new Error(`Automation is not owned by a legacy facade: ${automationId}`);
+        }
+        const blocked = this.options.store.updateAutomationAtomically(automationId, { enabled: false }, () => ({
+            health: 'blocked',
+            blockedReason: providerLifecycleBlockReason(reason),
+        }));
+        this.emitDefinition(blocked);
+        return blocked;
+    }
+    markLegacyProviderLifecycleBlocked(automationId, reason) {
+        const automation = this.requireAutomation(automationId);
+        if (automation.originKind !== 'automation-monitor') {
+            throw new Error(`Automation is not owned by the legacy monitor facade: ${automationId}`);
+        }
+        const blocked = this.options.store.updateAutomationState(automationId, {
+            health: 'blocked',
+            blockedReason: providerLifecycleBlockReason(reason),
+        });
+        this.emitDefinition(blocked);
+        return blocked;
+    }
+    clearLegacyProviderLifecycleBlocked(automationId, expectedReason) {
+        const automation = this.requireAutomation(automationId);
+        if (automation.originKind !== 'automation-monitor') {
+            throw new Error(`Automation is not owned by the legacy monitor facade: ${automationId}`);
+        }
+        if (automation.health !== 'blocked' || automation.blockedReason !== normalizeAutomationError(expectedReason)) {
+            return automation;
+        }
+        const healthy = this.options.store.updateAutomationState(automationId, { health: 'healthy' });
+        this.emitDefinition(healthy);
+        return healthy;
+    }
+    async runTick(generation) {
+        const now = this.now();
+        const due = [];
+        for (const automation of this.list()) {
+            if (!this.shouldPoll(automation))
+                continue;
+            const nextCheckAt = this.options.store.getAutomationNextCheckAt(automation.id);
+            if (nextCheckAt !== null && Date.parse(nextCheckAt) <= now.getTime()) {
+                due.push(automation);
+            }
+        }
+        let index = 0;
+        const worker = async () => {
+            while (!this.stopping && generation === this.lifecycleGeneration) {
+                const automation = due[index];
+                index += 1;
+                if (!automation)
+                    return;
+                await this.checkAutomation(automation);
+            }
+        };
+        const workerCount = Math.min(due.length, this.options.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY);
+        await Promise.all(Array.from({ length: workerCount }, () => worker()));
+        if (!this.stopping && generation === this.lifecycleGeneration) {
+            this.options.store.pruneAutomationEvaluations(now);
+        }
+    }
+    async checkAutomation(automation, context, manual = false) {
+        const existing = this.inFlight.get(automation.id);
+        if (existing)
+            return this.recordConcurrentSkip(automation, context);
+        const work = this.evaluateAndMaybeRun(automation, context, manual);
+        this.inFlight.set(automation.id, work);
+        try {
+            return await work;
+        }
+        finally {
+            if (this.inFlight.get(automation.id) === work)
+                this.inFlight.delete(automation.id);
+        }
+    }
+    async recordConcurrentSkip(automation, context) {
+        const now = context ? new Date(context.occurredAt) : this.now();
+        const running = this.createEvaluation(automation, now);
+        const finished = this.finishEvaluation(running.id, {
+            conditionOutcome: 'skipped',
+            triggerDecision: 'skipped_concurrent',
+            finishedAt: now.toISOString(),
+            durationMs: 0,
+            resultSummary: 'Skipped because another evaluation is still running.',
+            ...(context ? { payload: context.payload, nextState: context.nextState } : {}),
+        });
+        this.updateDefinitionAfterEvaluation(automation, now, {
+            nextMatch: automation.lastSuccessfulMatch,
+            failureCount: automation.consecutiveEvaluationFailures,
+        });
+        this.emitCompatibilityEvaluationRun(automation, finished);
+        return finished;
+    }
+    async evaluateAndMaybeRun(automation, context, manual = false) {
+        const startedAt = context ? new Date(context.occurredAt) : this.now();
+        const running = this.createEvaluation(automation, startedAt);
+        const actionRunning = this.listRuns(automation.id)
+            .some((run) => run.status === 'queued' || run.status === 'running');
+        const coolingDown = automation.lastTriggeredAt !== undefined
+            && startedAt.getTime() < Date.parse(automation.lastTriggeredAt) + automation.policies.cooldownMs;
+        const payload = context?.payload || {};
+        let decision;
+        try {
+            const legacySnapshot = automation.originKind === 'automation-monitor'
+                && automation.condition.kind === 'expression'
+                && isPlainRecord(payload.eventSnapshot)
+                ? payload.eventSnapshot
+                : undefined;
+            const evaluator = this.options.conditionEvaluator || (legacySnapshot
+                ? ((condition) => condition.kind === 'expression'
+                    ? { kind: 'evaluated', matched: (0, condition_evaluator_js_1.evaluateExpression)(condition.expression, legacySnapshot) }
+                    : (0, automation_condition_engine_js_1.evaluateCondition)(condition, payload))
+                : automation_condition_engine_js_1.evaluateCondition);
+            decision = (0, automation_condition_engine_js_1.decideCondition)({
+                condition: automation.condition,
+                payload,
+                previous: automation.condition.kind === 'always' ? undefined : automation.lastSuccessfulMatch,
+                coolingDown,
+                actionRunning,
+            }, evaluator);
+        }
+        catch (error) {
+            const finishedAt = this.now();
+            return this.finishError(automation, running, startedAt, finishedAt, normalizeAutomationError(error), context);
+        }
+        const finishedAt = this.now();
+        if (decision.kind === 'script-delegation') {
+            try {
+                const previousEvaluation = this.getLatestEvaluationWithState(automation.id);
+                const previousState = previousEvaluation?.status === 'finished' && previousEvaluation.nextState
+                    ? previousEvaluation.nextState
+                    : {};
+                const scriptResult = await this.getScriptProtocolRunner().run({
+                    scriptId: decision.request.scriptId,
+                    approvedVersionId: decision.request.approvedVersionId,
+                    evaluationId: running.id,
+                    triggeredAt: startedAt.toISOString(),
+                    previousState,
+                });
+                const scriptDecision = (0, automation_condition_engine_js_1.decideTrigger)({
+                    previous: automation.lastSuccessfulMatch,
+                    matched: scriptResult.matched,
+                    coolingDown,
+                    actionRunning,
+                });
+                const scriptFinishedAt = this.now();
+                const scriptPayload = scriptResult.payload || {};
+                const scriptFinishDetails = {
+                    finishedAt: scriptFinishedAt.toISOString(),
+                    durationMs: Math.max(0, scriptFinishedAt.getTime() - startedAt.getTime()),
+                    ...(scriptDecision.triggerDecision === 'triggered' ? { triggeredAt: startedAt.toISOString() } : {}),
+                    payload: scriptPayload,
+                    ...(scriptResult.nextState === undefined ? {} : { nextState: scriptResult.nextState }),
+                    stdout: scriptResult.stdout,
+                    stderr: scriptResult.stderr,
+                    exitCode: scriptResult.exitCode === null ? undefined : scriptResult.exitCode,
+                    outputTruncated: scriptResult.outputTruncated,
+                    ...(scriptResult.networkAudit === undefined ? {} : { networkAudit: scriptResult.networkAudit }),
+                    ...(scriptResult.summary === undefined ? {} : { resultSummary: scriptResult.summary }),
+                };
+                const scriptFinished = this.finishEvaluation(running.id, scriptDecision.conditionOutcome === 'matched'
+                    ? { ...scriptFinishDetails, conditionOutcome: 'matched', triggerDecision: scriptDecision.triggerDecision }
+                    : { ...scriptFinishDetails, conditionOutcome: 'not_matched', triggerDecision: 'not_rising' });
+                const updated = this.updateDefinitionAfterEvaluation(automation, startedAt, {
+                    nextMatch: scriptDecision.nextMatch,
+                    failureCount: 0,
+                    triggered: scriptDecision.triggerDecision === 'triggered',
+                });
+                if (scriptDecision.triggerDecision === 'triggered') {
+                    await this.executeAction(updated, scriptFinished, scriptPayload);
+                }
+                else {
+                    this.emitCompatibilityEvaluationRun(updated, scriptFinished);
+                }
+                return scriptFinished;
+            }
+            catch (error) {
+                const message = normalizeAutomationError(error);
+                if (error instanceof script_protocol_runner_js_1.ScriptProtocolError && error.blockAutomation)
+                    this.blockAutomation(automation, message);
+                return this.finishError(automation, running, startedAt, this.now(), message, undefined, error instanceof script_protocol_runner_js_1.ScriptProtocolError ? { networkAudit: error.networkAudit } : undefined);
+            }
+        }
+        if (decision.conditionOutcome === 'error') {
+            return this.finishError(automation, running, startedAt, finishedAt, normalizeAutomationError(decision.error || 'Condition evaluation failed.'), context);
+        }
+        const finishDetails = {
+            finishedAt: finishedAt.toISOString(),
+            durationMs: Math.max(0, finishedAt.getTime() - startedAt.getTime()),
+            ...(decision.triggerDecision === 'triggered' ? { triggeredAt: startedAt.toISOString() } : {}),
+            payload,
+            ...(context ? { nextState: context.nextState } : {}),
+        };
+        let finishInput;
+        if (decision.conditionOutcome === 'matched') {
+            finishInput = { ...finishDetails, conditionOutcome: 'matched', triggerDecision: decision.triggerDecision };
+        }
+        else if (decision.conditionOutcome === 'not_matched') {
+            finishInput = { ...finishDetails, conditionOutcome: 'not_matched', triggerDecision: 'not_rising' };
+        }
+        else {
+            finishInput = { ...finishDetails, conditionOutcome: 'skipped', triggerDecision: decision.triggerDecision };
+        }
+        const finished = this.finishEvaluation(running.id, finishInput);
+        const updated = this.updateDefinitionAfterEvaluation(automation, startedAt, {
+            nextMatch: decision.nextMatch,
+            failureCount: 0,
+            triggered: decision.triggerDecision === 'triggered',
+        });
+        if (decision.triggerDecision === 'triggered') {
+            const run = await this.executeAction(updated, finished, payload);
+            if (!manual && updated.originKind === 'scheduled-job' && updated.activation.kind === 'once' && run.status === 'succeeded') {
+                const disabled = this.options.store.updateAutomation(updated.id, { enabled: false });
+                this.emitDefinition(disabled);
+            }
+        }
+        else {
+            this.emitCompatibilityEvaluationRun(updated, finished);
+        }
+        return finished;
+    }
+    finishError(automation, running, startedAt, finishedAt, error, context, details) {
+        const finished = this.finishEvaluation(running.id, {
+            conditionOutcome: 'error',
+            triggerDecision: 'not_evaluated',
+            finishedAt: finishedAt.toISOString(),
+            durationMs: Math.max(0, finishedAt.getTime() - startedAt.getTime()),
+            errorCategory: 'condition_evaluation',
+            resultSummary: error,
+            ...(context ? { payload: context.payload, nextState: context.nextState } : {}),
+            ...(details?.networkAudit === undefined ? {} : { networkAudit: details.networkAudit }),
+        });
+        const count = automation.consecutiveEvaluationFailures + 1;
+        const updated = this.updateDefinitionAfterEvaluation(automation, context ? startedAt : finishedAt, {
+            nextMatch: automation.lastSuccessfulMatch,
+            failureCount: count,
+        });
+        this.options.log?.(normalizeAutomationError(error, `automation evaluation failed ${automation.id} (${count}): `));
+        if (FAILURE_ALERT_COUNTS.has(count))
+            this.options.alert?.({ automation: updated, count, error });
+        this.emitCompatibilityEvaluationRun(updated, finished);
+        return finished;
+    }
+    getScriptProtocolRunner() {
+        if (!this.scriptProtocolRunner) {
+            this.scriptProtocolRunner = new script_protocol_runner_js_1.ScriptProtocolRunner({
+                sandbox: (0, anthropic_sandbox_runner_js_1.createAnthropicSandboxRunner)(),
+                getVersion: (versionId) => this.options.store.getAutomationScriptVersion(versionId),
+            });
+        }
+        return this.scriptProtocolRunner;
+    }
+    getScriptTestRunner() {
+        if (!this.scriptProtocolRunner?.runTest) {
+            this.scriptProtocolRunner = new script_protocol_runner_js_1.ScriptProtocolRunner({
+                sandbox: (0, anthropic_sandbox_runner_js_1.createAnthropicSandboxRunner)(),
+                getVersion: (versionId) => this.options.store.getAutomationScriptVersion(versionId),
+            });
+        }
+        return this.scriptProtocolRunner;
+    }
+    blockAutomation(automation, reason) {
+        const blocked = this.options.store.updateAutomationState(automation.id, {
+            health: 'blocked',
+            blockedReason: normalizeAutomationError(reason),
+        });
+        this.emitDefinition(blocked);
+    }
+    async executeAction(automation, evaluation, payload) {
+        let run = this.options.store.createAutomationRun(automation.id, evaluation.id);
+        this.emitRun(run);
+        const startedAt = this.now().toISOString();
+        run = this.options.store.updateAutomationRun(run.id, { status: 'running', startedAt });
+        this.emitRun(run);
+        const promptVariables = {
+            title: automation.title,
+            timestamp: evaluation.status === 'finished' ? evaluation.finishedAt : startedAt,
+            evaluationId: evaluation.id,
+            ...payload,
+        };
+        try {
+            const result = await this.options.actionExecutor.execute({ automation, evaluation, promptVariables });
+            run = this.options.store.updateAutomationRun(run.id, this.successfulRunUpdate(result));
+        }
+        catch (error) {
+            const message = normalizeAutomationError(error);
+            run = this.options.store.updateAutomationRun(run.id, {
+                status: 'failed',
+                finishedAt: this.now().toISOString(),
+                deliveryStatus: 'failed',
+                error: message,
+            });
+            this.options.log?.(normalizeAutomationError(run.error, `automation action failed ${automation.id}: `));
+        }
+        this.emitRun(run);
+        return run;
+    }
+    successfulRunUpdate(result) {
+        const bridgeActivity = {
+            ...(result.deliveryMode ? { deliveryMode: result.deliveryMode } : {}),
+            ...(result.lastBridgeEventAt ? { lastBridgeEventAt: result.lastBridgeEventAt } : {}),
+        };
+        return {
+            status: 'succeeded',
+            threadId: result.threadId,
+            acpRunId: result.acpRunId,
+            finishedAt: this.now().toISOString(),
+            deliveryStatus: result.deliveryStatus === 'failed' ? 'failed' : 'delivered',
+            ...(result.deliveryError ? { error: normalizeAutomationError(result.deliveryError) } : {}),
+            ...(Object.keys(bridgeActivity).length > 0 ? { bridgeActivity } : {}),
+        };
+    }
+    createEvaluation(automation, now) {
+        const evaluation = this.options.store.createAutomationEvaluation(automation.id, {
+            activationKind: automation.activation.kind,
+            ...(automation.condition.kind === 'approved-script'
+                ? { scriptVersionId: automation.condition.approvedVersionId }
+                : {}),
+            startedAt: now.toISOString(),
+        });
+        this.emitEvaluation(evaluation);
+        return evaluation;
+    }
+    finishEvaluation(evaluationId, input) {
+        const evaluation = this.options.store.finishAutomationEvaluation(evaluationId, input);
+        this.emitEvaluation(evaluation);
+        return evaluation;
+    }
+    updateDefinitionAfterEvaluation(automation, now, input) {
+        const next = (0, automation_trigger_engine_js_1.nextActivationAt)(automation.activation, now);
+        const updated = this.options.store.updateAutomationState(automation.id, {
+            ...(input.nextMatch === undefined ? {} : { lastSuccessfulMatch: input.nextMatch }),
+            lastEvaluationAt: now.toISOString(),
+            ...(input.triggered ? { lastTriggeredAt: now.toISOString() } : {}),
+            consecutiveEvaluationFailures: input.failureCount,
+            nextCheckAt: next?.toISOString() || null,
+        });
+        this.emitDefinition(updated);
+        return updated;
+    }
+    persistInitialNextCheck(automation, replace = false, activationReplaced = false) {
+        if (!replace && this.options.store.getAutomationNextCheckAt(automation.id) !== null)
+            return automation;
+        return this.options.store.updateAutomationState(automation.id, {
+            nextCheckAt: this.initialNextCheckAt(automation, activationReplaced),
+        });
+    }
+    initialNextCheckAt(automation, activationReplaced = false) {
+        const now = this.now();
+        let next;
+        if ((!automation.enabled && !activationReplaced) || automation.activation.kind === 'provider-event') {
+            next = null;
+        }
+        else if (automation.activation.kind === 'once') {
+            next = new Date(automation.activation.runAt);
+        }
+        else if (automation.lastEvaluationAt) {
+            next = (0, automation_trigger_engine_js_1.missedActivationAt)(automation.activation, automation.lastEvaluationAt, now)
+                || (0, automation_trigger_engine_js_1.nextActivationAt)(automation.activation, now);
+        }
+        else if (automation.activation.kind === 'interval') {
+            next = new Date(Math.floor(now.getTime() / automation.activation.intervalMs) * automation.activation.intervalMs);
+        }
+        else {
+            const baseline = new Date(Math.min(Date.parse(automation.createdAt), now.getTime() - 24 * 60 * 60 * 1_000));
+            next = (0, automation_trigger_engine_js_1.missedActivationAt)(automation.activation, baseline.toISOString(), now)
+                || (0, automation_trigger_engine_js_1.nextActivationAt)(automation.activation, now);
+        }
+        return next?.toISOString() || null;
+    }
+    shouldPoll(automation) {
+        return automation.enabled
+            && automation.health === 'healthy'
+            && automation.activation.kind !== 'provider-event'
+            && (this.options.ownershipPolicy || exports.NATIVE_AUTOMATION_OWNERSHIP).executes(automation);
+    }
+    isConsumedOnce(automation) {
+        if (automation.activation.kind !== 'once')
+            return false;
+        if (automation.lastEvaluationAt !== undefined)
+            return true;
+        return this.listEvaluations(automation.id).some((evaluation) => evaluation.status === 'finished');
+    }
+    requireAutomation(automationId) {
+        const automation = this.get(automationId);
+        if (!automation)
+            throw new Error(`Automation not found: ${automationId}`);
+        return automation;
+    }
+    now() {
+        const now = (this.options.clock || (() => new Date()))();
+        if (!Number.isFinite(now.getTime()))
+            throw new Error('Automation clock returned an invalid date.');
+        return new Date(now);
+    }
+    emitDefinition(automation) {
+        this.emitEvent({ type: 'automation.definition.updated', payload: automation });
+        try {
+            if (automation.originKind === 'scheduled-job') {
+                this.emitEvent({
+                    type: 'scheduler.job.updated',
+                    payload: (0, legacy_automation_mappers_js_1.automationToScheduledJob)(automation, (0, legacy_automation_mappers_js_1.latestAutomationRun)(this.listRuns(automation.id))),
+                });
+            }
+            else if (automation.originKind === 'automation-monitor') {
+                const latest = (0, legacy_automation_mappers_js_1.latestFinishedEvaluation)(this.listEvaluations(automation.id));
+                this.emitEvent({
+                    type: 'automation.monitor.updated',
+                    payload: (0, legacy_automation_mappers_js_1.automationToMonitor)(automation, latest, (0, legacy_automation_mappers_js_1.latestAutomationRun)(this.listRuns(automation.id)), this.getLatestEvaluationWithState(automation.id)),
+                });
+            }
+        }
+        catch (error) {
+            this.reportDiagnostic('event-projection', normalizeAutomationError(error, 'Automation event projection failed: '));
+        }
+    }
+    emitEvaluation(evaluation) {
+        this.emitEvent({ type: 'automation.evaluation.updated', payload: evaluation });
+    }
+    emitRun(run) {
+        this.emitEvent({ type: 'automation.run.updated', payload: run });
+        try {
+            const automation = this.get(run.automationId);
+            const evaluation = this.listEvaluations(run.automationId).find((candidate) => candidate.id === run.evaluationId);
+            if (!automation || !evaluation)
+                return;
+            if (automation.originKind === 'scheduled-job') {
+                this.emitEvent({ type: 'scheduler.run.updated', payload: (0, legacy_automation_mappers_js_1.automationToScheduledJobRun)(evaluation, run) });
+            }
+            else if (automation.originKind === 'automation-monitor') {
+                this.emitEvent({ type: 'automation.monitor.run.updated', payload: (0, legacy_automation_mappers_js_1.automationToMonitorRun)(evaluation, run) });
+            }
+        }
+        catch (error) {
+            this.reportDiagnostic('event-projection', normalizeAutomationError(error, 'Automation event projection failed: '));
+        }
+    }
+    emitCompatibilityEvaluationRun(automation, evaluation) {
+        try {
+            if (automation.originKind === 'scheduled-job') {
+                this.emitEvent({
+                    type: 'scheduler.run.updated',
+                    payload: (0, legacy_automation_mappers_js_1.automationToScheduledJobRun)(evaluation),
+                });
+            }
+            else if (automation.originKind === 'automation-monitor') {
+                this.emitEvent({
+                    type: 'automation.monitor.run.updated',
+                    payload: (0, legacy_automation_mappers_js_1.automationToMonitorRun)(evaluation),
+                });
+            }
+        }
+        catch (error) {
+            this.reportDiagnostic('event-projection', normalizeAutomationError(error, 'Automation event projection failed: '));
+        }
+    }
+    providerEventContext(automation, event) {
+        const occurredAt = normalizeProviderEventTimestamp(event.occurredAt);
+        const previousEvaluation = this.getLatestEvaluationWithState(automation.id);
+        const previous = previousEvaluation?.status === 'finished' ? previousEvaluation.nextState : undefined;
+        const nextState = {
+            ...(previous || {}),
+            ...event.payload,
+            payload: event.payload,
+            lastEventId: event.id,
+            lastEventAt: occurredAt,
+        };
+        return {
+            payload: {
+                ...event.payload,
+                ...(!Object.prototype.hasOwnProperty.call(event.payload, 'subject') ? { subject: event.subject } : {}),
+                ...(!Object.prototype.hasOwnProperty.call(event.payload, 'sourceType') ? { sourceType: event.sourceType } : {}),
+                eventSubject: event.subject,
+                eventSourceType: event.sourceType,
+                occurredAt,
+                timestamp: occurredAt,
+                summary: event.summary || '',
+                eventSnapshot: event,
+                previous: previous || {},
+            },
+            nextState,
+            occurredAt,
+        };
+    }
+    emitEvent(event) {
+        try {
+            this.options.eventBus.emit(event);
+        }
+        catch (error) {
+            this.reportDiagnostic('event-projection', normalizeAutomationError(error, 'Automation event projection failed: '));
+        }
+    }
+    clearTimer() {
+        if (this.timer === undefined)
+            return;
+        (this.options.clearInterval || clearInterval)(this.timer);
+        this.timer = undefined;
+    }
+    runTimerTick(generation) {
+        if (!this.isActiveGeneration(generation))
+            return;
+        void this.tick().catch((error) => this.handleTimerFailure(error, generation));
+    }
+    handleTimerFailure(error, generation) {
+        const reason = normalizeAutomationError(error, 'Automation timer tick failed: ');
+        if (this.isActiveGeneration(generation)) {
+            try {
+                this.clearTimer();
+            }
+            catch {
+                this.timer = undefined;
+            }
+            this.runtimeStatus = { status: 'degraded', reason };
+        }
+        this.reportDiagnostic('timer-tick', reason);
+    }
+    isActiveGeneration(generation) {
+        return generation === this.lifecycleGeneration
+            && !this.stopping
+            && this.runtimeStatus.status === 'running';
+    }
+    async settleActiveWork() {
+        const tick = this.tickPromise;
+        if (tick)
+            await Promise.allSettled([tick]);
+        await Promise.allSettled([...this.inFlight.values()]);
+    }
+    reportDiagnostic(phase, error) {
+        try {
+            this.options.log?.(error);
+        }
+        catch {
+            // Diagnostics must not destabilize automation lifecycle handling.
+        }
+        try {
+            this.options.eventBus.emit({
+                type: 'localcore.error',
+                payload: { scope: 'automation-service', error, context: { phase } },
+            });
+        }
+        catch {
+            // Diagnostics must not destabilize automation lifecycle handling.
+        }
+    }
+}
+exports.AutomationService = AutomationService;
+function normalizeAutomationError(error, prefix = '') {
+    let raw;
+    try {
+        raw = error instanceof Error ? error.message : String(error);
+    }
+    catch {
+        raw = 'Unprintable error';
+    }
+    const withoutControls = `${prefix}${raw}`.replace(/[\u0000-\u001f\u007f-\u009f]/g, ' ');
+    return (0, local_core_acp_store_js_1.redactSecrets)(withoutControls)
+        .replace(/\b(password|api[-_]?key)\s*[:=]\s*[^\s]+/gi, '$1=[REDACTED_SECRET]')
+        .slice(0, exports.AUTOMATION_ERROR_MAX_LENGTH);
+}
+function providerLifecycleBlockReason(error) {
+    const normalized = normalizeAutomationError(error);
+    return normalized.startsWith(exports.PROVIDER_LIFECYCLE_BLOCK_PREFIX)
+        ? normalized
+        : normalizeAutomationError(normalized, exports.PROVIDER_LIFECYCLE_BLOCK_PREFIX);
+}
+function normalizeProviderEventTimestamp(value) {
+    if (typeof value !== 'string'
+        || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(value.trim())) {
+        throw new Error('Provider event occurredAt must be a valid ISO timestamp.');
+    }
+    const timestamp = new Date(value);
+    if (!Number.isFinite(timestamp.getTime())) {
+        throw new Error('Provider event occurredAt must be a valid ISO timestamp.');
+    }
+    return timestamp.toISOString();
+}
+function normalizeProviderEventSnapshot(value) {
+    if (!isPlainRecord(value))
+        throw new Error('Provider event must be a plain object.');
+    assertOwnDataProperties(value, 'Provider event');
+    for (const field of ['id', 'sourceType', 'subject']) {
+        const fieldValue = ownDataProperty(value, field);
+        if (typeof fieldValue !== 'string' || !fieldValue.trim()) {
+            throw new Error(`Provider event ${field} must be a non-empty string.`);
+        }
+    }
+    const summary = ownDataProperty(value, 'summary');
+    if (summary !== undefined && typeof summary !== 'string') {
+        throw new Error('Provider event summary must be a string when provided.');
+    }
+    const occurredAt = ownDataProperty(value, 'occurredAt');
+    const normalizedOccurredAt = normalizeProviderEventTimestampStrict(occurredAt);
+    const topLevelStrings = [
+        ownDataProperty(value, 'id'),
+        ownDataProperty(value, 'sourceType'),
+        ownDataProperty(value, 'subject'),
+        occurredAt,
+        ...(summary === undefined ? [] : [summary]),
+    ];
+    if (topLevelStrings.some((field) => field.length > PROVIDER_EVENT_STRING_MAX_LENGTH)) {
+        throw new Error('Provider event string field exceeds the maximum length.');
+    }
+    const topLevelSize = topLevelStrings.reduce((total, field) => total + field.length, 0);
+    if (topLevelSize > PROVIDER_JSON_MAX_SIZE)
+        throw new Error('Provider event exceeds the maximum total size.');
+    const payloadValue = ownDataProperty(value, 'payload');
+    if (!isPlainRecord(payloadValue))
+        throw new Error('Provider event payload must be a plain object.');
+    let payload;
+    try {
+        payload = cloneProviderJsonValue(payloadValue, '$', {
+            ancestors: new WeakSet(),
+            size: topLevelSize,
+        }, 0);
+    }
+    catch (error) {
+        throw new Error(normalizeAutomationError(error, 'Invalid provider event payload: '));
+    }
+    return {
+        id: ownDataProperty(value, 'id'),
+        sourceType: ownDataProperty(value, 'sourceType'),
+        subject: ownDataProperty(value, 'subject'),
+        occurredAt: normalizedOccurredAt,
+        ...(summary === undefined ? {} : { summary }),
+        payload,
+    };
+}
+function cloneProviderJsonValue(value, path, state, depth) {
+    if (depth > PROVIDER_JSON_MAX_DEPTH)
+        throw new Error(`${path} exceeds the maximum nesting depth.`);
+    state.size += typeof value === 'string' ? value.length + 1 : 1;
+    if (state.size > PROVIDER_JSON_MAX_SIZE)
+        throw new Error(`${path} exceeds the maximum payload size.`);
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw new Error(`${path} must contain only finite numbers.`);
+        return value;
+    }
+    if (typeof value !== 'object')
+        throw new Error(`${path} contains a non-JSON value.`);
+    if (state.ancestors.has(value))
+        throw new Error(`${path} contains a cycle.`);
+    state.ancestors.add(value);
+    try {
+        if (Array.isArray(value)) {
+            if (Object.getPrototypeOf(value) !== Array.prototype)
+                throw new Error(`${path} must be a plain array.`);
+            if (Object.getOwnPropertySymbols(value).length > 0)
+                throw new Error(`${path} contains a symbol property.`);
+            const keys = Object.getOwnPropertyNames(value);
+            for (const key of keys) {
+                if (key !== 'length' && !isArrayIndex(key, value.length)) {
+                    throw new Error(`${path} contains a non-index array property.`);
+                }
+            }
+            const clone = [];
+            for (let index = 0; index < value.length; index += 1) {
+                const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+                if (!descriptor)
+                    throw new Error(`${path}[${index}] must not be sparse.`);
+                if (!('value' in descriptor))
+                    throw new Error(`${path}[${index}] must be a data property.`);
+                clone.push(cloneProviderJsonValue(descriptor.value, `${path}[${index}]`, state, depth + 1));
+            }
+            return clone;
+        }
+        if (!isPlainRecord(value))
+            throw new Error(`${path} must contain only plain objects and arrays.`);
+        if (Object.getOwnPropertySymbols(value).length > 0)
+            throw new Error(`${path} contains a symbol property.`);
+        const clone = {};
+        for (const key of Object.getOwnPropertyNames(value)) {
+            state.size += key.length;
+            if (state.size > PROVIDER_JSON_MAX_SIZE)
+                throw new Error(`${path} exceeds the maximum payload size.`);
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            const propertyPath = providerJsonPropertyPath(path, key);
+            if (!('value' in descriptor))
+                throw new Error(`${propertyPath} must be a data property.`);
+            Object.defineProperty(clone, key, {
+                value: cloneProviderJsonValue(descriptor.value, propertyPath, state, depth + 1),
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            });
+        }
+        return clone;
+    }
+    finally {
+        state.ancestors.delete(value);
+    }
+}
+function assertOwnDataProperties(value, context) {
+    if (Object.getOwnPropertySymbols(value).length > 0)
+        throw new Error(`${context} must not contain symbol properties.`);
+    for (const key of Object.getOwnPropertyNames(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!('value' in descriptor))
+            throw new Error(`${context} ${key} must be a data property.`);
+    }
+}
+function ownDataProperty(value, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor && 'value' in descriptor ? descriptor.value : undefined;
+}
+function isArrayIndex(key, length) {
+    if (!/^(0|[1-9]\d*)$/.test(key))
+        return false;
+    const index = Number(key);
+    return Number.isSafeInteger(index) && index >= 0 && index < length;
+}
+function providerJsonPropertyPath(path, key) {
+    return /^[A-Za-z_$][\w$]*$/.test(key)
+        ? `${path}.${key}`
+        : `${path}[${JSON.stringify(key.slice(0, 80))}${key.length > 80 ? '…' : ''}]`;
+}
+function normalizeProviderEventTimestampStrict(value) {
+    const raw = typeof value === 'string' ? value.trim() : '';
+    const match = raw.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(Z|[+-]\d{2}:\d{2})$/);
+    if (!match)
+        throw new Error('Provider event occurredAt must be a valid ISO timestamp.');
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const hour = Number(match[4]);
+    const minute = Number(match[5]);
+    const second = Number(match[6]);
+    const fraction = String(match[7] || '').padEnd(3, '0').slice(0, 3);
+    const local = new Date(0);
+    local.setUTCFullYear(year, month - 1, day);
+    local.setUTCHours(hour, minute, second, Number(fraction));
+    if (local.getUTCFullYear() !== year || local.getUTCMonth() !== month - 1 || local.getUTCDate() !== day
+        || local.getUTCHours() !== hour || local.getUTCMinutes() !== minute || local.getUTCSeconds() !== second)
+        throw new Error('Provider event occurredAt must be a valid ISO timestamp.');
+    const zone = String(match[8]);
+    let offsetMinutes = 0;
+    if (zone !== 'Z') {
+        const zoneMatch = zone.match(/^([+-])(\d{2}):(\d{2})$/);
+        const offsetHour = Number(zoneMatch[2]);
+        const offsetMinute = Number(zoneMatch[3]);
+        if (offsetHour > 23 || offsetMinute > 59)
+            throw new Error('Provider event occurredAt must be a valid ISO timestamp.');
+        offsetMinutes = (offsetHour * 60 + offsetMinute) * (zoneMatch[1] === '+' ? 1 : -1);
+    }
+    return new Date(local.getTime() - offsetMinutes * 60_000).toISOString();
+}
+function isPlainRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}