@kafca/agentdock 0.1.58 → 0.1.62

package/dist-electron/services/local-ai-core/src/acp/store/local-core-acp-store.js

@@ -7,6 +7,9 @@ const node_path_1 = require("node:path");
 const superai_contracts_1 = require("../../../../../packages/contracts/src/index.js");
 const agent_task_store_js_1 = require("./agent-task-store.js");
 const automation_monitor_store_js_1 = require("./automation-monitor-store.js");
+const automation_script_store_js_1 = require("./automation-script-store.js");
+const automation_script_service_js_1 = require("../../automation/automation-script-service.js");
+const automation_store_js_1 = require("./automation-store.js");
 const schema_js_1 = require("./schema.js");
 const platform_store_js_1 = require("./platform-store.js");
 const scheduler_store_js_1 = require("./scheduler-store.js");
@@ -24,6 +27,9 @@ class LocalCoreAcpStore {
     agentTasks;
     scheduler;
     automationMonitors;
+    automationScripts;
+    automationScriptLifecycle;
+    automations;
     platform;
     modelProviders;
     external;
@@ -43,6 +49,9 @@ class LocalCoreAcpStore {
         });
         this.scheduler = new scheduler_store_js_1.LocalSchedulerStore(this.db);
         this.automationMonitors = new automation_monitor_store_js_1.LocalAutomationMonitorStore(this.db);
+        this.automationScripts = new automation_script_store_js_1.LocalAutomationScriptStore(this.db, userDataPath);
+        this.automationScriptLifecycle = new automation_script_service_js_1.AutomationScriptService({ db: this.db, security: this.security });
+        this.automations = new automation_store_js_1.LocalAutomationStore(this.db);
         this.platform = new platform_store_js_1.LocalPlatformStore(this.db);
         this.modelProviders = new model_provider_store_js_1.LocalModelProviderStore(this.db);
         this.external = new external_store_js_1.LocalExternalStore(this.db);
@@ -237,6 +246,143 @@ class LocalCoreAcpStore {
     updateAutomationMonitorRun(runId, input) {
         return this.automationMonitors.updateRun(runId, input);
     }
+    listAutomations(workspaceId) {
+        return this.automations.list(workspaceId);
+    }
+    getAutomation(automationId) {
+        return this.automations.get(automationId);
+    }
+    getAutomationNextCheckAt(automationId) {
+        return this.automations.getNextCheckAt(automationId);
+    }
+    createAutomation(input) {
+        return this.automations.create(input);
+    }
+    createTrustedAutomation(input) {
+        return this.automations.createTrusted(input);
+    }
+    createAutomationAtomically(input, initialize) {
+        return this.automationTransaction(() => {
+            const created = this.automations.create(input);
+            return this.automations.updateState(created.id, initialize(created));
+        });
+    }
+    createTrustedAutomationAtomically(input, initialize) {
+        return this.automationTransaction(() => {
+            const created = this.automations.createTrusted(input);
+            return this.automations.updateState(created.id, initialize(created));
+        });
+    }
+    updateAutomation(automationId, input) {
+        return this.automations.update(automationId, input);
+    }
+    updateTrustedAutomation(automationId, input) {
+        return this.automations.updateTrusted(automationId, input);
+    }
+    updateAutomationAtomically(automationId, input, initialize) {
+        return this.automationTransaction(() => {
+            const updated = this.automations.update(automationId, input);
+            const state = initialize?.(updated);
+            return state ? this.automations.updateState(automationId, state) : updated;
+        });
+    }
+    updateTrustedAutomationAtomically(automationId, input, initialize) {
+        return this.automationTransaction(() => {
+            const updated = this.automations.updateTrusted(automationId, input);
+            const state = initialize?.(updated);
+            return state ? this.automations.updateState(automationId, state) : updated;
+        });
+    }
+    updateAutomationState(automationId, input) {
+        return this.automations.updateState(automationId, input);
+    }
+    deleteAutomation(automationId) {
+        return this.automations.delete(automationId);
+    }
+    listAutomationScripts(workspaceId) {
+        return this.automationScripts.listScripts(workspaceId);
+    }
+    getAutomationScript(scriptId) {
+        return this.automationScripts.getScript(scriptId);
+    }
+    createAutomationScript(input) {
+        return this.automationScripts.createScript(input);
+    }
+    updateAutomationScript(scriptId, input) {
+        return this.automationScripts.updateScript(scriptId, input);
+    }
+    createAutomationScriptVersionFromPackage(input) {
+        return this.automationScripts.createVersionFromPackage(input);
+    }
+    stageAutomationScriptSource(input) {
+        return this.automationScripts.stageSource(input);
+    }
+    createAutomationScriptVersionFromStaged(input) {
+        return this.automationScripts.createVersionFromStaged(input.scriptId, input.staged, input.interpreterPath, input.interpreterVersion);
+    }
+    discardUnreferencedAutomationScriptPackage(scriptId, staged) {
+        this.automationScripts.discardUnreferencedPackage(scriptId, staged);
+    }
+    listAutomationScriptVersions(scriptId) {
+        return this.automationScripts.listVersions(scriptId);
+    }
+    getAutomationScriptVersion(versionId) {
+        return this.automationScripts.getVersion(versionId);
+    }
+    requestAutomationScriptTestApproval(versionId, actor) {
+        return this.automationScriptLifecycle.requestTestApproval(versionId, actor);
+    }
+    authorizeAutomationScriptTest(versionId, approvalId, actor) {
+        return this.automationScriptLifecycle.authorizeTest(versionId, approvalId, actor);
+    }
+    recordAutomationScriptTestResult(versionId, result) {
+        return this.automationScriptLifecycle.recordTestResult(versionId, result);
+    }
+    claimAutomationScriptTestExecution(versionId) {
+        return this.automationScriptLifecycle.claimTestExecution(versionId);
+    }
+    failClaimedAutomationScriptTestExecution(versionId) {
+        return this.automationScriptLifecycle.failClaimedTestExecution(versionId);
+    }
+    requestAutomationScriptEnableApproval(versionId, actor) {
+        return this.automationScriptLifecycle.requestEnableApproval(versionId, actor);
+    }
+    approveAutomationScriptVersion(versionId, approvalId, actor) {
+        return this.automationScriptLifecycle.approveVersion(versionId, approvalId, actor);
+    }
+    revokeAutomationScriptVersion(versionId, actor) {
+        return this.automationScriptLifecycle.revokeVersion(versionId, actor);
+    }
+    createAutomationEvaluation(automationId, input) {
+        return this.automations.createEvaluation(automationId, input);
+    }
+    finishAutomationEvaluation(evaluationId, input) {
+        return this.automations.finishEvaluation(evaluationId, input);
+    }
+    listAutomationEvaluations(automationId) {
+        return this.automations.listEvaluations(automationId);
+    }
+    getLatestAutomationEvaluationWithState(automationId) {
+        return this.automations.getLatestEvaluationWithState(automationId);
+    }
+    createAutomationRun(automationId, evaluationId, input = {}) {
+        return this.automations.createRun(automationId, evaluationId, input);
+    }
+    updateAutomationRun(runId, input) {
+        return this.automations.updateRun(runId, input);
+    }
+    listAutomationRuns(automationId) {
+        return this.automations.listRuns(automationId);
+    }
+    reconcileInterruptedAutomationRuns(reason, finishedAt) {
+        return this.automations.reconcileInterruptedRuns(reason, finishedAt);
+    }
+    importLegacyAutomations() {
+        return this.automations.importLegacyRecords();
+    }
+    pruneAutomationEvaluations(now) {
+        return this.automations.pruneEvaluations(now);
+    }
     getThreadRow(threadId) {
         return this.threads.getRow(threadId);
     }
@@ -303,6 +449,18 @@ class LocalCoreAcpStore {
     listPairingRequests(workspaceId, platform) {
         return this.platform.listPairingRequests(workspaceId, platform);
     }
+    automationTransaction(work) {
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            const result = work();
+            this.db.exec('COMMIT');
+            return result;
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
 }
 exports.LocalCoreAcpStore = LocalCoreAcpStore;
 function resolveLegacyConfigPaths(runtimeDir) {

package/dist-electron/services/local-ai-core/src/acp/store/schema.js

@@ -162,6 +162,86 @@ function ensureLocalCoreAcpSchema(db) {
       FOREIGN KEY (monitor_id) REFERENCES automation_monitors(id) ON DELETE CASCADE
     );
     CREATE INDEX IF NOT EXISTS idx_automation_monitor_runs_monitor_triggered ON automation_monitor_runs (monitor_id, triggered_at DESC);
+    CREATE TABLE IF NOT EXISTS automations (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      enabled INTEGER NOT NULL,
+      health TEXT NOT NULL,
+      blocked_reason TEXT,
+      activation_json TEXT NOT NULL,
+      condition_json TEXT NOT NULL,
+      action_json TEXT NOT NULL,
+      delivery_json TEXT NOT NULL,
+      policies_json TEXT NOT NULL,
+      last_successful_match INTEGER,
+      last_evaluation_at TEXT,
+      last_triggered_at TEXT,
+      consecutive_evaluation_failures INTEGER NOT NULL DEFAULT 0,
+      next_check_at TEXT,
+      origin_kind TEXT NOT NULL DEFAULT 'native',
+      legacy_metadata_json TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_automations_workspace_updated ON automations (workspace_id, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_automations_enabled_next_check ON automations (enabled, next_check_at);
+    CREATE INDEX IF NOT EXISTS idx_automations_health ON automations (health);
+    CREATE INDEX IF NOT EXISTS idx_automations_origin ON automations (origin_kind);
+    CREATE TABLE IF NOT EXISTS automation_evaluations (
+      id TEXT PRIMARY KEY,
+      automation_id TEXT NOT NULL,
+      status TEXT NOT NULL,
+      activation_kind TEXT NOT NULL,
+      script_version_id TEXT,
+      started_at TEXT NOT NULL,
+      finished_at TEXT,
+      evaluation_json TEXT NOT NULL,
+      FOREIGN KEY (automation_id) REFERENCES automations(id) ON DELETE CASCADE
+    );
+    CREATE INDEX IF NOT EXISTS idx_automation_evaluations_automation_started
+      ON automation_evaluations (automation_id, started_at DESC);
+    CREATE TABLE IF NOT EXISTS automation_runs (
+      id TEXT PRIMARY KEY,
+      automation_id TEXT NOT NULL,
+      evaluation_id TEXT NOT NULL UNIQUE,
+      status TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      run_json TEXT NOT NULL,
+      FOREIGN KEY (automation_id) REFERENCES automations(id) ON DELETE CASCADE,
+      FOREIGN KEY (evaluation_id) REFERENCES automation_evaluations(id) ON DELETE CASCADE
+    );
+    CREATE INDEX IF NOT EXISTS idx_automation_runs_automation_created
+      ON automation_runs (automation_id, created_at DESC);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_automation_runs_evaluation_unique ON automation_runs (evaluation_id);
+    CREATE TABLE IF NOT EXISTS automation_scripts (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_automation_scripts_workspace_updated
+      ON automation_scripts (workspace_id, updated_at DESC);
+    CREATE TABLE IF NOT EXISTS automation_script_versions (
+      id TEXT PRIMARY KEY,
+      script_id TEXT NOT NULL,
+      status TEXT NOT NULL,
+      package_sha256 TEXT NOT NULL,
+      package_path TEXT NOT NULL,
+      shebang TEXT NOT NULL,
+      interpreter_path TEXT NOT NULL,
+      interpreter_version TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      version_json TEXT NOT NULL,
+      FOREIGN KEY (script_id) REFERENCES automation_scripts(id) ON DELETE CASCADE
+    );
+    CREATE INDEX IF NOT EXISTS idx_automation_script_versions_script_created
+      ON automation_script_versions (script_id, created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_automation_script_versions_hash
+      ON automation_script_versions (script_id, package_sha256);
     CREATE TABLE IF NOT EXISTS workspace_registry (
       id TEXT PRIMARY KEY,
       display_name TEXT NOT NULL,
@@ -317,6 +397,7 @@ function ensureLocalCoreAcpSchema(db) {
     ensureColumn(db, 'scheduled_job_runs', 'delivery_error', 'TEXT');
     ensureColumn(db, 'scheduled_job_runs', 'last_bridge_event_at', 'TEXT');
     ensureColumn(db, 'threads', 'agent_mode', "TEXT NOT NULL DEFAULT 'default'");
+    ensureColumn(db, 'automations', 'legacy_metadata_json', 'TEXT');
 }
 function ensureColumn(db, table, column, definition) {
     const rows = db.prepare(`PRAGMA table_info(${table})`).all();

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

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationActionExecutor = void 0;
+exports.renderAutomationPrompt = renderAutomationPrompt;
+const scheduled_bridge_session_js_1 = require("../scheduler/scheduled-bridge-session.js");
+const scheduled_job_route_js_1 = require("../scheduler/scheduled-job-route.js");
+const run_polling_js_1 = require("../scheduler/run-polling.js");
+const thread_resolution_js_1 = require("../scheduler/thread-resolution.js");
+const AUTOMATION_RUN_PERMISSION_MODE = 'bypassPermissions';
+const UNSAFE_PROMPT_KEYS = new Set(['__proto__', 'constructor', 'prototype', 'toString']);
+class AutomationActionExecutor {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async execute(input, timeoutMs = 15 * 60 * 1_000) {
+        const { automation } = input;
+        const workspaceRouter = this.options.getWorkspaceRouter();
+        const threadId = await this.resolveThread(automation);
+        const prompt = renderAutomationPrompt(automation.action.promptTemplate, input.promptVariables);
+        const channelRuntime = automation.delivery.platform === 'local'
+            ? undefined
+            : this.options.getChannelRuntime(automation.delivery.platform);
+        const bridge = channelRuntime
+            ? await scheduled_bridge_session_js_1.ScheduledBridgeSession.open({
+                target: {
+                    id: automation.id,
+                    workspaceId: automation.workspaceId,
+                    platform: automation.delivery.platform,
+                    route: automation.delivery.route,
+                    title: automation.title,
+                    promptTemplate: automation.action.promptTemplate,
+                },
+                threadId,
+                workspaceRouter,
+                getChannelRuntime: () => channelRuntime,
+                noticeIcon: automation.originKind === 'automation-monitor'
+                    && input.promptVariables.sourceType === 'stock.quote' ? '📈' : '🔔',
+                noticeTitle: automation.title,
+            })
+            : undefined;
+        try {
+            const sendResult = await workspaceRouter.sendThreadMessage(threadId, prompt, {
+                permissionMode: AUTOMATION_RUN_PERMISSION_MODE,
+                runtimeEnv: (0, scheduled_job_route_js_1.buildPlatformRuntimeEnv)(automation.delivery.platform, automation.delivery.route),
+            });
+            await (0, run_polling_js_1.waitForRunCompletion)(this.options.store, sendResult.runId, timeoutMs, automation.originKind === 'automation-monitor' ? 'Monitor' : 'Automation');
+            const thread = await workspaceRouter.getThread(threadId);
+            const replyText = [...thread.messages]
+                .reverse()
+                .find((message) => message.role === 'assistant' && message.kind === 'final')
+                ?.content;
+            return {
+                threadId,
+                acpRunId: sendResult.runId,
+                replyText,
+                deliveryMode: bridge ? 'bridge-stream' : 'thread-only',
+                deliveryStatus: 'succeeded',
+                lastBridgeEventAt: bridge ? new Date().toISOString() : undefined,
+            };
+        }
+        finally {
+            await bridge?.close();
+        }
+    }
+    async resolveThread(automation) {
+        const workspaceRouter = this.options.getWorkspaceRouter();
+        const route = automation.delivery.route;
+        const platform = automation.delivery.platform;
+        if (automation.action.executionMode === 'same-thread') {
+            const binding = this.options.store.getPlatformThreadBinding(automation.workspaceId, route.channelId, route.participantId || '', platform);
+            if (binding?.thread_id && await (0, thread_resolution_js_1.threadExists)(workspaceRouter, binding.thread_id))
+                return binding.thread_id;
+            if (route.threadId && await (0, thread_resolution_js_1.threadExists)(workspaceRouter, route.threadId))
+                return route.threadId;
+        }
+        const label = automation.originKind === 'automation-monitor' ? 'Monitor' : 'Automation';
+        const title = platform === 'local'
+            ? `[${label}] ${automation.title}`
+            : `[${label}:${(0, scheduled_job_route_js_1.getChannelPlatformBase)(platform) || platform}] ${automation.title}`;
+        const existing = (await workspaceRouter.listThreads(automation.workspaceId))
+            .find((thread) => thread.title === title);
+        if (existing)
+            return existing.id;
+        return (await workspaceRouter.createThread(automation.workspaceId, title)).id;
+    }
+}
+exports.AutomationActionExecutor = AutomationActionExecutor;
+function renderAutomationPrompt(template, values) {
+    return String(template || '').replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (_match, key) => {
+        if (UNSAFE_PROMPT_KEYS.has(key))
+            return '';
+        const descriptor = Object.getOwnPropertyDescriptor(values, key);
+        if (!descriptor || !Object.prototype.hasOwnProperty.call(descriptor, 'value'))
+            return '';
+        return serializePromptValue(descriptor.value);
+    });
+}
+function serializePromptValue(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value !== 'object')
+        return String(value);
+    try {
+        return JSON.stringify(toSafeJsonValue(value, new Set())) ?? '';
+    }
+    catch {
+        return '[Unserializable]';
+    }
+}
+function toSafeJsonValue(value, seen) {
+    if (value === null || typeof value !== 'object') {
+        return typeof value === 'bigint' ? String(value) : value;
+    }
+    if (seen.has(value))
+        throw new Error('Circular prompt value.');
+    seen.add(value);
+    try {
+        if (Array.isArray(value)) {
+            return value.map((_entry, index) => {
+                const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+                return descriptor && Object.prototype.hasOwnProperty.call(descriptor, 'value')
+                    ? toSafeJsonValue(descriptor.value, seen)
+                    : null;
+            });
+        }
+        const result = Object.create(null);
+        for (const key of Object.keys(value)) {
+            if (UNSAFE_PROMPT_KEYS.has(key))
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor || !Object.prototype.hasOwnProperty.call(descriptor, 'value'))
+                continue;
+            const nested = descriptor.value;
+            if (typeof nested === 'function' || typeof nested === 'symbol' || nested === undefined)
+                continue;
+            result[key] = toSafeJsonValue(nested, seen);
+        }
+        return result;
+    }
+    finally {
+        seen.delete(value);
+    }
+}

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

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.admitConditionEvaluation = admitConditionEvaluation;
+exports.decideTrigger = decideTrigger;
+exports.evaluateCondition = evaluateCondition;
+exports.decideCondition = decideCondition;
+const condition_evaluator_js_1 = require("./condition-evaluator.js");
+function admitConditionEvaluation(evaluationRunning) {
+    return evaluationRunning
+        ? { admitted: false, conditionOutcome: 'skipped', triggerDecision: 'skipped_concurrent' }
+        : { admitted: true };
+}
+function decideTrigger(input) {
+    if (!input.matched) {
+        return { conditionOutcome: 'not_matched', triggerDecision: 'not_rising', nextMatch: false };
+    }
+    if (input.previous === true) {
+        return { conditionOutcome: 'matched', triggerDecision: 'not_rising', nextMatch: true };
+    }
+    if (input.coolingDown) {
+        return { conditionOutcome: 'matched', triggerDecision: 'skipped_cooldown', nextMatch: true };
+    }
+    if (input.actionRunning) {
+        return { conditionOutcome: 'matched', triggerDecision: 'skipped_action_running', nextMatch: true };
+    }
+    return { conditionOutcome: 'matched', triggerDecision: 'triggered', nextMatch: true };
+}
+function evaluateCondition(condition, payload = {}) {
+    switch (condition.kind) {
+        case 'always':
+            return { kind: 'evaluated', matched: true };
+        case 'expression':
+            return { kind: 'evaluated', matched: (0, condition_evaluator_js_1.evaluateRestrictedExpression)(condition.expression, payload) };
+        case 'approved-script':
+            return {
+                kind: 'script-delegation',
+                request: {
+                    scriptId: condition.scriptId,
+                    approvedVersionId: condition.approvedVersionId,
+                    edge: condition.edge,
+                    payload,
+                },
+            };
+    }
+}
+function decideCondition(input, evaluator = evaluateCondition) {
+    const admission = admitConditionEvaluation(input.evaluationRunning === true);
+    if (!admission.admitted) {
+        return {
+            kind: 'decision',
+            conditionOutcome: admission.conditionOutcome,
+            triggerDecision: admission.triggerDecision,
+            nextMatch: input.previous,
+        };
+    }
+    try {
+        const evaluation = evaluator(input.condition, input.payload);
+        if (evaluation.kind === 'script-delegation')
+            return evaluation;
+        return {
+            kind: 'decision',
+            ...decideTrigger({
+                previous: input.previous,
+                matched: evaluation.matched,
+                coolingDown: input.coolingDown,
+                actionRunning: input.actionRunning,
+            }),
+        };
+    }
+    catch (error) {
+        return {
+            kind: 'decision',
+            conditionOutcome: 'error',
+            triggerDecision: 'not_evaluated',
+            nextMatch: input.previous,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

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

@@ -2,88 +2,55 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutomationConversationExecutor = void 0;
 exports.renderMonitorPrompt = renderMonitorPrompt;
-const scheduled_bridge_session_js_1 = require("../scheduler/scheduled-bridge-session.js");
-const scheduled_job_route_js_1 = require("../scheduler/scheduled-job-route.js");
-const run_polling_js_1 = require("../scheduler/run-polling.js");
-const thread_resolution_js_1 = require("../scheduler/thread-resolution.js");
-const MONITOR_RUN_PERMISSION_MODE = 'bypassPermissions';
+const automation_action_executor_js_1 = require("./automation-action-executor.js");
 class AutomationConversationExecutor {
-    options;
+    executor;
     constructor(options) {
-        this.options = options;
+        this.executor = new automation_action_executor_js_1.AutomationActionExecutor(options);
     }
     async execute(monitor, event, timeoutMs = 15 * 60 * 1000) {
-        const workspaceRouter = this.options.getWorkspaceRouter();
-        const threadId = await this.resolveThread(monitor);
-        const prompt = renderMonitorPrompt(monitor.promptTemplate, event, monitor);
-        const channelRuntime = monitor.platform === 'local' ? undefined : this.options.getChannelRuntime(monitor.platform);
-        const bridge = channelRuntime
-            ? await scheduled_bridge_session_js_1.ScheduledBridgeSession.open({
-                target: {
-                    id: monitor.id,
-                    workspaceId: monitor.workspaceId,
-                    platform: monitor.platform,
-                    route: monitor.route,
-                    title: monitor.title,
+        const result = await this.executor.execute({
+            automation: {
+                id: monitor.id,
+                workspaceId: monitor.workspaceId,
+                title: monitor.title,
+                enabled: monitor.enabled,
+                health: 'healthy',
+                activation: { kind: 'provider-event', sourceType: monitor.sourceType, sourceConfig: monitor.sourceConfig },
+                condition: { kind: 'always' },
+                action: {
+                    kind: 'agent-prompt',
                     promptTemplate: monitor.promptTemplate,
+                    executionMode: monitor.executionMode === 'same-thread' ? 'same-thread' : 'side-thread',
                 },
-                threadId,
-                workspaceRouter,
-                getChannelRuntime: () => channelRuntime,
-                noticeIcon: monitor.sourceType === 'stock.quote' ? '📈' : '🔔',
-                noticeTitle: monitor.title,
-            })
-            : undefined;
-        try {
-            const sendResult = await workspaceRouter.sendThreadMessage(threadId, prompt, {
-                permissionMode: MONITOR_RUN_PERMISSION_MODE,
-                runtimeEnv: (0, scheduled_job_route_js_1.buildPlatformRuntimeEnv)(monitor.platform, monitor.route),
-            });
-            await (0, run_polling_js_1.waitForRunCompletion)(this.options.store, sendResult.runId, timeoutMs, 'Monitor');
-            const thread = await workspaceRouter.getThread(threadId);
-            const replyText = [...thread.messages]
-                .reverse()
-                .find((message) => message.role === 'assistant' && message.kind === 'final')
-                ?.content;
-            return {
-                threadId,
-                runId: sendResult.runId,
-                replyText,
-                deliveryMode: bridge ? 'bridge-stream' : 'thread-only',
-                deliveryStatus: 'succeeded',
-                lastBridgeEventAt: bridge ? new Date().toISOString() : undefined,
-            };
-        }
-        finally {
-            await bridge?.close();
-        }
-    }
-    async resolveThread(monitor) {
-        const workspaceRouter = this.options.getWorkspaceRouter();
-        if (monitor.executionMode === 'same-thread') {
-            const binding = this.options.store.getPlatformThreadBinding(monitor.workspaceId, monitor.route.channelId, monitor.route.participantId || '', monitor.platform);
-            if (binding?.thread_id && await (0, thread_resolution_js_1.threadExists)(workspaceRouter, binding.thread_id)) {
-                return binding.thread_id;
-            }
-            if (monitor.route.threadId && await (0, thread_resolution_js_1.threadExists)(workspaceRouter, monitor.route.threadId)) {
-                return monitor.route.threadId;
-            }
-        }
-        const title = monitor.platform === 'local'
-            ? `[Monitor] ${monitor.title}`
-            : `[Monitor:${(0, scheduled_job_route_js_1.getChannelPlatformBase)(monitor.platform) || monitor.platform}] ${monitor.title}`;
-        const existing = (await workspaceRouter.listThreads(monitor.workspaceId))
-            .find((thread) => thread.title === title);
-        if (existing) {
-            return existing.id;
-        }
-        const created = await workspaceRouter.createThread(monitor.workspaceId, title);
-        return created.id;
+                delivery: { platform: monitor.platform, route: monitor.route },
+                policies: { concurrency: 'skip-if-running', cooldownMs: monitor.cooldownMs },
+                consecutiveEvaluationFailures: 0,
+                createdAt: monitor.createdAt,
+                updatedAt: monitor.updatedAt,
+                originKind: 'automation-monitor',
+            },
+            evaluation: {
+                id: `legacy-monitor-event:${monitor.id}`,
+                automationId: monitor.id,
+                status: 'finished',
+                activationKind: 'provider-event',
+                startedAt: event.occurredAt,
+                finishedAt: event.occurredAt,
+                conditionOutcome: 'matched',
+                triggerDecision: 'triggered',
+            },
+            promptVariables: monitorPromptVariables(event, monitor),
+        }, timeoutMs);
+        return { ...result, runId: result.acpRunId };
     }
 }
 exports.AutomationConversationExecutor = AutomationConversationExecutor;
 function renderMonitorPrompt(template, event, monitor) {
-    const values = {
+    return String(template || '').replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (_match, key) => String(monitorPromptVariables(event, monitor)[key] ?? ''));
+}
+function monitorPromptVariables(event, monitor) {
+    return {
         title: monitor.title,
         sourceType: event.sourceType,
         subject: event.subject,
@@ -91,5 +58,4 @@ function renderMonitorPrompt(template, event, monitor) {
         timestamp: event.occurredAt,
         ...event.payload,
     };
-    return String(template || '').replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (_match, key) => String(values[key] ?? ''));
 }