@kafca/agentdock 0.1.42 → 0.1.43

package/dist-electron/services/local-ai-core/src/cli/lac.js

@@ -8,6 +8,8 @@ const node_process_1 = __importDefault(require("node:process"));
 const index_js_1 = require("../../../../packages/contracts/src/index.js");
 const job_id_js_1 = require("../scheduler/job-id.js");
 const scheduled_job_route_js_1 = require("../scheduler/scheduled-job-route.js");
+const monitor_id_js_1 = require("../automation/monitor-id.js");
+const monitor_cli_parsers_js_1 = require("./monitor-cli-parsers.js");
 const DEFAULT_BASE_URL = 'http://127.0.0.1:9831/api/local/v1';
 async function runCli(argv, env = node_process_1.default.env, io = node_process_1.default) {
     try {
@@ -23,6 +25,26 @@ async function runCli(argv, env = node_process_1.default.env, io = node_process_
                     return 2;
             }
         }
+        if (domain === 'monitor') {
+            switch (action) {
+                case 'add':
+                    return await handleMonitorAdd(flags, env, io, json);
+                case 'list':
+                    return await handleMonitorList(flags, env, io, json);
+                case 'info':
+                    return await handleMonitorInfo(maybeId, flags, env, io, json);
+                case 'edit':
+                    return await handleMonitorEdit(maybeId, flags, env, io, json);
+                case 'del':
+                case 'delete':
+                    return await handleMonitorDelete(maybeId, flags, env, io, json);
+                case 'run':
+                    return await handleMonitorRun(maybeId, flags, env, io, json);
+                default:
+                    printUsage(io.stderr);
+                    return 2;
+            }
+        }
         if (domain !== 'scheduler') {
             printUsage(io.stderr);
             return 2;
@@ -51,6 +73,110 @@ async function runCli(argv, env = node_process_1.default.env, io = node_process_
         return 1;
     }
 }
+async function handleMonitorAdd(flags, env, io, json) {
+    const context = resolveContext(flags, env);
+    if (!context.workspaceId) {
+        throw new Error('monitor add requires a workspace context. Set LOCAL_AI_WORKSPACE_ID or pass --workspace.');
+    }
+    const title = getRequiredFlag(flags, 'title');
+    const sourceType = getRequiredFlag(flags, 'source');
+    const promptTemplate = getRequiredFlag(flags, 'message');
+    const condition = (0, monitor_cli_parsers_js_1.parseMonitorCondition)(getRequiredFlag(flags, 'condition'));
+    const sourceConfig = buildSourceConfig(sourceType, flags);
+    const monitor = await request(context.baseUrl, 'POST', '/automation/monitors', {
+        workspaceId: context.workspaceId,
+        ...(context.threadId ? { threadId: context.threadId } : {}),
+        title,
+        sourceType,
+        sourceConfig,
+        condition,
+        promptTemplate,
+        executionMode: getMonitorExecutionMode(flags),
+        cooldownMs: (0, monitor_cli_parsers_js_1.parseDurationMs)(getFlag(flags, 'cooldown') || '15m'),
+        enabled: true,
+    });
+    print(json, io.stdout, presentMonitor(monitor), [
+        `Created monitor ${(0, monitor_id_js_1.toPublicAutomationMonitorId)(monitor.id)}`,
+        `Title: ${monitor.title}`,
+        `Source: ${monitor.sourceType}`,
+        `Condition: ${formatCondition(monitor.condition)}`,
+        `Execution mode: ${monitor.executionMode}`,
+    ].join('\n'));
+    return 0;
+}
+async function handleMonitorList(flags, env, io, json) {
+    const context = resolveContext(flags, env);
+    const workspaceId = getFlag(flags, 'workspace') || context.workspaceId;
+    const threadId = flags.has('thread')
+        ? normalizeMaybeBooleanFlag(getFlag(flags, 'thread')) || context.threadId
+        : '';
+    const suffix = workspaceId ? `?workspace_id=${encodeURIComponent(workspaceId)}` : '';
+    const response = await request(context.baseUrl, 'GET', `/automation/monitors${suffix}`);
+    const monitors = threadId
+        ? response.monitors.filter((monitor) => monitor.route.threadId === threadId || monitorMatchesCliContext(monitor, context))
+        : response.monitors;
+    print(json, io.stdout, { monitors: monitors.map(presentMonitor) }, monitors.length === 0 ? 'No monitors.' : monitors.map(formatMonitorLine).join('\n'));
+    return 0;
+}
+async function handleMonitorInfo(monitorId, flags, env, io, json) {
+    if (!monitorId) {
+        throw new Error('monitor info requires a monitor id.');
+    }
+    const context = resolveContext(flags, env);
+    const monitor = await request(context.baseUrl, 'GET', `/automation/monitors/${encodeURIComponent(monitorId)}`);
+    const runs = await request(context.baseUrl, 'GET', `/automation/monitors/${encodeURIComponent(monitorId)}/runs`);
+    print(json, io.stdout, { monitor: presentMonitor(monitor), runs: runs.runs }, formatMonitorDetails(monitor, runs.runs[0]));
+    return 0;
+}
+async function handleMonitorEdit(monitorId, flags, env, io, json) {
+    if (!monitorId) {
+        throw new Error('monitor edit requires a monitor id.');
+    }
+    const input = {};
+    const title = getFlag(flags, 'title');
+    const promptTemplate = getFlag(flags, 'message');
+    const condition = getFlag(flags, 'condition');
+    const enabled = getOptionalBooleanFlag(flags, 'enabled');
+    const executionMode = getFlag(flags, 'execution-mode');
+    const cooldown = getFlag(flags, 'cooldown');
+    if (title)
+        input.title = title;
+    if (typeof promptTemplate === 'string' && promptTemplate)
+        input.promptTemplate = promptTemplate;
+    if (condition)
+        input.condition = (0, monitor_cli_parsers_js_1.parseMonitorCondition)(condition);
+    if (typeof enabled === 'boolean')
+        input.enabled = enabled;
+    if (executionMode)
+        input.executionMode = (0, index_js_1.normalizeScheduledJobExecutionMode)(executionMode);
+    if (cooldown)
+        input.cooldownMs = (0, monitor_cli_parsers_js_1.parseDurationMs)(cooldown);
+    if (Object.keys(input).length === 0) {
+        throw new Error('monitor edit requires at least one editable field.');
+    }
+    const context = resolveContext(flags, env);
+    const monitor = await request(context.baseUrl, 'PATCH', `/automation/monitors/${encodeURIComponent(monitorId)}`, input);
+    print(json, io.stdout, presentMonitor(monitor), `Updated monitor ${(0, monitor_id_js_1.toPublicAutomationMonitorId)(monitor.id)}`);
+    return 0;
+}
+async function handleMonitorDelete(monitorId, flags, env, io, json) {
+    if (!monitorId) {
+        throw new Error('monitor del requires a monitor id.');
+    }
+    const context = resolveContext(flags, env);
+    const result = await request(context.baseUrl, 'DELETE', `/automation/monitors/${encodeURIComponent(monitorId)}`);
+    print(json, io.stdout, result, `Deleted monitor ${monitorId}`);
+    return 0;
+}
+async function handleMonitorRun(monitorId, flags, env, io, json) {
+    if (!monitorId) {
+        throw new Error('monitor run requires a monitor id.');
+    }
+    const context = resolveContext(flags, env);
+    const run = await request(context.baseUrl, 'POST', `/automation/monitors/${encodeURIComponent(monitorId)}/run`);
+    print(json, io.stdout, run, `Triggered monitor ${monitorId}: ${run.status}`);
+    return 0;
+}
 async function handleChannelSendFile(flags, env, io, json) {
     const context = resolveContext(flags, env);
     const filePath = getRequiredFlag(flags, 'path');
@@ -282,6 +408,23 @@ function normalizeMaybeBooleanFlag(value) {
 function getExecutionMode(flags) {
     return (0, index_js_1.normalizeScheduledJobExecutionMode)(getFlag(flags, 'execution-mode'));
 }
+function getMonitorExecutionMode(flags) {
+    return (0, index_js_1.normalizeScheduledJobExecutionMode)(getFlag(flags, 'execution-mode') || 'side-thread');
+}
+function buildSourceConfig(sourceType, flags) {
+    const config = {};
+    if (sourceType === 'stock.quote') {
+        config.symbol = getRequiredFlag(flags, 'symbol').toUpperCase();
+        const price = getFlag(flags, 'price');
+        if (price)
+            config.price = Number(price);
+    }
+    const rawConfig = getFlag(flags, 'source-config');
+    if (rawConfig) {
+        return { ...config, ...JSON.parse(rawConfig) };
+    }
+    return config;
+}
 function print(asJson, output, payload, text) {
     output.write(asJson ? `${JSON.stringify(payload, null, 2)}\n` : `${text}\n`);
 }
@@ -294,6 +437,12 @@ function printUsage(output) {
         '  lac scheduler edit <job-id> [--cron "<expr>"] [--message "<text>"] [--desc "<label>"] [--enabled true|false] [--execution-mode same-thread|side-thread] [--json]',
         '  lac scheduler del <job-id> [--json]',
         '  lac scheduler run <job-id> [--json]',
+        '  lac monitor add --title "<title>" --source stock.quote --symbol <symbol> --condition "change_percent >= 3" --message "<text>" [--cooldown 15m] [--execution-mode same-thread|side-thread] [--json]',
+        '  lac monitor list [--workspace <id>] [--thread [<id>]] [--json]',
+        '  lac monitor info <monitor-id> [--json]',
+        '  lac monitor edit <monitor-id> [--title "<title>"] [--condition "<expr>"] [--message "<text>"] [--enabled true|false] [--cooldown 15m] [--execution-mode same-thread|side-thread] [--json]',
+        '  lac monitor del <monitor-id> [--json]',
+        '  lac monitor run <monitor-id> [--json]',
         '  lac channel send-file --path "<file>" [--target <chat-or-user-id>] [--workspace <id>] [--workspace-path <path>] [--platform lark] [--name <filename>] [--json]',
     ].join('\n') + '\n');
 }
@@ -321,6 +470,53 @@ function presentJob(job) {
         id: (0, job_id_js_1.toPublicScheduledJobId)(job.id),
     };
 }
+function formatMonitorLine(monitor) {
+    return `${(0, monitor_id_js_1.toPublicAutomationMonitorId)(monitor.id)} | ${monitor.enabled ? 'enabled' : 'disabled'} | ${monitor.executionMode} | ${monitor.sourceType} | ${formatCondition(monitor.condition)} | ${monitor.title}`;
+}
+function formatMonitorDetails(monitor, latestRun) {
+    return [
+        `Monitor: ${(0, monitor_id_js_1.toPublicAutomationMonitorId)(monitor.id)}`,
+        `Title: ${monitor.title}`,
+        `Workspace: ${monitor.workspaceId}`,
+        `Platform: ${monitor.platform}`,
+        `Thread: ${monitor.route.threadId || ''}`,
+        `Execution mode: ${monitor.executionMode}`,
+        `Source: ${monitor.sourceType}`,
+        `Condition: ${formatCondition(monitor.condition)}`,
+        `Cooldown: ${monitor.cooldownMs}ms`,
+        `Enabled: ${monitor.enabled ? 'true' : 'false'}`,
+        `Message: ${monitor.promptTemplate}`,
+        latestRun ? `Latest run: ${latestRun.status} @ ${latestRun.triggeredAt}` : 'Latest run: none',
+    ].join('\n');
+}
+function formatCondition(condition) {
+    if (condition.expression) {
+        return condition.expression;
+    }
+    return `${condition.metric} ${condition.operator} ${condition.value}`;
+}
+function presentMonitor(monitor) {
+    return {
+        ...monitor,
+        id: (0, monitor_id_js_1.toPublicAutomationMonitorId)(monitor.id),
+    };
+}
+function monitorMatchesCliContext(monitor, context) {
+    return (0, scheduled_job_route_js_1.scheduledJobMatchesCliContext)({
+        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: monitor.concurrencyPolicy,
+        createdAt: monitor.createdAt,
+        updatedAt: monitor.updatedAt,
+    }, context);
+}
 function formatError(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist-electron/services/local-ai-core/src/cli/monitor-cli-parsers.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMonitorCondition = parseMonitorCondition;
+exports.parseDurationMs = parseDurationMs;
+const index_js_1 = require("../../../../packages/contracts/src/index.js");
+function parseMonitorCondition(value) {
+    const expression = String(value || '').trim();
+    if (expression.includes('&&') || expression.includes('||')) {
+        return {
+            metric: 'expression',
+            operator: '==',
+            value: true,
+            expression,
+        };
+    }
+    const match = expression.match(/^([a-zA-Z0-9_.-]+)\s*(>=|<=|==|!=|>|<)\s*(.+)$/);
+    if (!match) {
+        throw new Error('Monitor condition must look like "change_percent >= 3".');
+    }
+    const rawValue = String(match[3] || '').trim();
+    const numeric = Number(rawValue);
+    return {
+        metric: String(match[1] || '').trim(),
+        operator: (0, index_js_1.normalizeAutomationMonitorConditionOperator)(match[2]),
+        value: Number.isFinite(numeric) && rawValue !== '' ? numeric : rawValue,
+    };
+}
+function parseDurationMs(value) {
+    const match = String(value || '').trim().match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/i);
+    if (!match) {
+        throw new Error('Duration must be a number with optional ms, s, m, or h suffix.');
+    }
+    const amount = Number(match[1]);
+    const unit = String(match[2] || 'ms').toLowerCase();
+    const multiplier = unit === 'h' ? 60 * 60 * 1000 : unit === 'm' ? 60 * 1000 : unit === 's' ? 1000 : 1;
+    return Math.round(amount * multiplier);
+}

package/dist-electron/services/local-ai-core/src/kernel/bootstrap.js

@@ -17,10 +17,12 @@ const scheduler_cron_plugin_js_1 = require("../plugins/builtin/scheduler-cron-pl
 const scheduler_lark_plugin_js_1 = require("../plugins/builtin/scheduler-lark-plugin.js");
 const scheduler_local_plugin_js_1 = require("../plugins/builtin/scheduler-local-plugin.js");
 const scheduler_weixin_plugin_js_1 = require("../plugins/builtin/scheduler-weixin-plugin.js");
+const monitor_stock_plugin_js_1 = require("../plugins/builtin/monitor-stock-plugin.js");
 const workspace_router_js_1 = require("../router/workspace-router.js");
 const local_core_runtime_state_js_1 = require("../runtime/local-core-runtime-state.js");
 const scheduled_job_application_service_js_1 = require("../scheduler/scheduled-job-application-service.js");
 const scheduler_service_js_1 = require("../scheduler/scheduler-service.js");
+const automation_monitor_service_js_1 = require("../automation/automation-monitor-service.js");
 function bootstrapLocalCoreKernel(options) {
     const capabilities = new capability_registry_js_1.LocalCoreCapabilityRegistry();
     const plugins = new plugin_registry_js_1.LocalCorePluginRegistry(options?.disabledPluginIds);
@@ -59,6 +61,7 @@ function bootstrapLocalCoreKernel(options) {
         diagnostics,
         getCapabilitySnapshot() {
             const snapshot = capabilities.snapshot();
+            const monitorCapabilities = snapshot.monitors || [];
             return {
                 adapters: {
                     channels: snapshot.channels.map((capability) => capability.platform),
@@ -74,6 +77,14 @@ function bootstrapLocalCoreKernel(options) {
                     deliveryTargets: [...new Set(snapshot.schedulers.flatMap((capability) => capability.deliveryTargets || capability.deliveryPlatforms || []))],
                     platforms: [...new Set(snapshot.schedulers.flatMap((capability) => capability.deliveryTargets || capability.deliveryPlatforms || []))],
                 },
+                ...(monitorCapabilities.length > 0
+                    ? {
+                        monitors: {
+                            enabled: monitorCapabilities.some((capability) => capability.enabled !== false),
+                            sourceTypes: [...new Set(monitorCapabilities.flatMap((capability) => capability.sourceTypes))],
+                        },
+                    }
+                    : {}),
                 snapshot,
             };
         },
@@ -99,6 +110,7 @@ function logCapabilityContributions(plugin, log) {
         ...(plugin.capabilities.channels || []).map((capability) => capability.id),
         ...(plugin.capabilities.knowledge || []).map((capability) => capability.id),
         ...(plugin.capabilities.schedulers || []).map((capability) => capability.id),
+        ...(plugin.capabilities.monitors || []).map((capability) => capability.id),
         ...(plugin.capabilities.ui || []).map((capability) => capability.id),
     ];
     for (const capabilityId of capabilityIds) {
@@ -145,6 +157,16 @@ function resolveSchedulerRuntime(plugin, context) {
     }
     return runtime;
 }
+function resolveMonitorRuntime(plugin, context) {
+    if (!plugin.createRuntime) {
+        throw new Error(`Monitor plugin ${plugin.manifest.id} does not provide a runtime factory.`);
+    }
+    const runtime = plugin.createRuntime(context);
+    if (runtime instanceof Promise) {
+        throw new Error(`Monitor plugin ${plugin.manifest.id} returned an async runtime factory during synchronous bootstrap.`);
+    }
+    return runtime;
+}
 function bootstrapLocalCoreRuntime(options) {
     const state = (0, local_core_runtime_state_js_1.createLocalCoreRuntimeState)({
         userDataPath: options.userDataPath,
@@ -209,6 +231,9 @@ function bootstrapLocalCoreRuntime(options) {
             log: options.log,
         }),
     ];
+    const monitorPlugins = [
+        (0, monitor_stock_plugin_js_1.createBuiltinStockMonitorPlugin)(),
+    ];
     for (const plugin of agentPlugins.filter((plugin) => plugin !== localCoreAgentPlugin)) {
         registerPlugin(kernel, plugin);
     }
@@ -218,6 +243,9 @@ function bootstrapLocalCoreRuntime(options) {
     for (const plugin of schedulerPlugins) {
         registerPlugin(kernel, plugin);
     }
+    for (const plugin of monitorPlugins) {
+        registerPlugin(kernel, plugin);
+    }
     const agentRuntimes = agentPlugins
         .filter((plugin) => kernel.plugins.isEnabled(plugin.manifest.id))
         .map((plugin) => resolveAgentRuntime(plugin, kernel.context).runtime);
@@ -241,6 +269,10 @@ function bootstrapLocalCoreRuntime(options) {
     ];
     const schedulerTriggers = schedulerRuntimes.flatMap((runtime) => runtime.triggers || []);
     const schedulerExecutors = schedulerRuntimes.flatMap((runtime) => runtime.executors || []);
+    const monitorRuntimes = monitorPlugins
+        .filter((plugin) => kernel.plugins.isEnabled(plugin.manifest.id))
+        .map((plugin) => resolveMonitorRuntime(plugin, kernel.context));
+    const monitorProviders = monitorRuntimes.flatMap((runtime) => runtime.providers || []);
     const knowledgeProvider = knowledgeRuntime.provider;
     const knowledgeAttachments = knowledgeRuntime.attachments;
     workspaceRouter = (0, workspace_router_js_1.createWorkspaceRouter)({
@@ -266,6 +298,14 @@ function bootstrapLocalCoreRuntime(options) {
         store,
         scheduler,
     });
+    const automationMonitors = new automation_monitor_service_js_1.AutomationMonitorService({
+        store,
+        providers: monitorProviders,
+        getWorkspaceRouter: () => workspaceRouter,
+        getChannelRuntime: (platform) => channelRuntimes.find((runtime) => runtime.platform === platform || platform.startsWith(`${runtime.platform}:`)),
+        eventBus: kernel.context.bus,
+        log: options.log,
+    });
     workspaceRouter.setSchedulerBridge({
         createJob: async ({ workspaceId, platform, route, name, schedule, scheduleDescription, message }) => scheduledJobs.createCronJob({ workspaceId, platform, route, name, schedule, scheduleDescription, message }),
         listJobsForThread: async (threadId) => scheduledJobs.listJobsForThread(threadId),
@@ -286,11 +326,14 @@ function bootstrapLocalCoreRuntime(options) {
         workspaceRouter,
         scheduler,
         scheduledJobs,
+        automationMonitors,
         async start() {
             await kernel.lifecycle.startAll();
             await scheduler.start();
+            await automationMonitors.start();
         },
         async stop() {
+            await automationMonitors.stop();
             await scheduler.stop();
             await kernel.lifecycle.stopAll();
             workspaceRouter.close();

package/dist-electron/services/local-ai-core/src/kernel/capability-registry.js

@@ -6,6 +6,7 @@ class LocalCoreCapabilityRegistry {
     channels = new Map();
     knowledge = new Map();
     schedulers = new Map();
+    monitors = new Map();
     ui = new Map();
     registerAgent(capability) {
         this.agents.set(capability.id, capability);
@@ -19,6 +20,9 @@ class LocalCoreCapabilityRegistry {
     registerScheduler(capability) {
         this.schedulers.set(capability.id, capability);
     }
+    registerMonitor(capability) {
+        this.monitors.set(capability.id, capability);
+    }
     registerUi(capability) {
         this.ui.set(capability.id, capability);
     }
@@ -35,6 +39,9 @@ class LocalCoreCapabilityRegistry {
         for (const capability of contributions.schedulers || []) {
             this.registerScheduler(capability);
         }
+        for (const capability of contributions.monitors || []) {
+            this.registerMonitor(capability);
+        }
         for (const capability of contributions.ui || []) {
             this.registerUi(capability);
         }
@@ -51,15 +58,20 @@ class LocalCoreCapabilityRegistry {
     listSchedulers() {
         return [...this.schedulers.values()];
     }
+    listMonitors() {
+        return [...this.monitors.values()];
+    }
     listUi() {
         return [...this.ui.values()];
     }
     snapshot() {
+        const monitors = this.listMonitors();
         return {
             agents: this.listAgents(),
             channels: this.listChannels(),
             knowledge: this.listKnowledge(),
             schedulers: this.listSchedulers(),
+            ...(monitors.length > 0 ? { monitors } : {}),
             ui: this.listUi(),
         };
     }

package/dist-electron/services/local-ai-core/src/plugins/builtin/monitor-stock-plugin.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinStockMonitorPlugin = createBuiltinStockMonitorPlugin;
+const mock_stock_provider_js_1 = require("../../automation/mock-stock-provider.js");
+function createBuiltinStockMonitorPlugin() {
+    return {
+        manifest: {
+            id: 'builtin.monitor-stock',
+            kind: 'monitor',
+            version: '0.1.0',
+            provides: ['monitor.source.stock.quote'],
+        },
+        capabilities: {
+            monitors: [
+                {
+                    id: 'monitor.source.stock.quote',
+                    sourceTypes: ['stock.quote'],
+                    modes: ['poll'],
+                    enabled: true,
+                    displayName: 'Stock Quote Monitor',
+                },
+            ],
+        },
+        createRuntime() {
+            return {
+                providers: [new mock_stock_provider_js_1.MockStockQuoteProvider()],
+            };
+        },
+    };
+}

package/dist-electron/services/local-ai-core/src/runtime/local-core-controller.js

@@ -12,6 +12,7 @@ class LocalCoreController extends node_events_1.EventEmitter {
     knowledgeProvider;
     channelRuntimes;
     scheduledJobs;
+    automationMonitors;
     kernel;
     runtime;
     runtimeDetection;
@@ -33,6 +34,15 @@ class LocalCoreController extends node_events_1.EventEmitter {
         const runtimeChannels = this.runtime.channelRuntimes || [this.runtime.channelRuntime, this.runtime.weixinChannelRuntime];
         this.channelRuntimes = new Map(runtimeChannels.filter(Boolean).map((runtime) => [runtime.platform, runtime]));
         this.scheduledJobs = this.runtime.scheduledJobs;
+        this.automationMonitors = this.runtime.automationMonitors || {
+            listMonitors: () => [],
+            getMonitor: () => undefined,
+            createMonitor: () => { throw new Error('Automation monitor service is not available.'); },
+            updateMonitor: () => { throw new Error('Automation monitor service is not available.'); },
+            deleteMonitor: () => ({ deleted: false }),
+            runMonitorNow: async () => { throw new Error('Automation monitor service is not available.'); },
+            listRuns: () => [],
+        };
         this.runtimeDetection = new runtime_detection_service_js_1.RuntimeDetectionService({
             userDataPath,
             readConfig: async () => (await this.readConfigFile()).parsed,
@@ -42,10 +52,16 @@ class LocalCoreController extends node_events_1.EventEmitter {
         this.flushPendingLogs();
         this.busUnsubscribers.push(this.kernel.context.bus.on('platform.bridge.updated', (event) => {
             this.emit('bridge', event);
+        }), this.kernel.context.bus.on('thread.session.activated', (event) => {
+            this.emit('thread-session-activated', event);
         }), this.kernel.context.bus.on('scheduler.job.updated', (job) => {
             this.emit('scheduler-job', job);
         }), this.kernel.context.bus.on('scheduler.run.updated', (run) => {
             this.emit('scheduler-run', run);
+        }), this.kernel.context.bus.on('automation.monitor.updated', (monitor) => {
+            this.emit('automation-monitor', monitor);
+        }), this.kernel.context.bus.on('automation.monitor.run.updated', (run) => {
+            this.emit('automation-monitor-run', run);
         }), this.kernel.context.bus.on('runtime.state.changed', () => {
             void this.emitRuntime();
         }));
@@ -208,6 +224,31 @@ class LocalCoreController extends node_events_1.EventEmitter {
     async listScheduledJobRuns(jobId) {
         return this.scheduledJobs.listJobRuns(jobId);
     }
+    async listAutomationMonitors(workspaceId) {
+        return this.automationMonitors.listMonitors(workspaceId);
+    }
+    async getAutomationMonitor(monitorId) {
+        const monitor = this.automationMonitors.getMonitor(monitorId);
+        if (!monitor) {
+            throw new Error(`Automation monitor not found: ${monitorId}`);
+        }
+        return monitor;
+    }
+    async createAutomationMonitor(input) {
+        return this.automationMonitors.createMonitor(input);
+    }
+    async updateAutomationMonitor(monitorId, input) {
+        return this.automationMonitors.updateMonitor(monitorId, input);
+    }
+    async deleteAutomationMonitor(monitorId) {
+        return this.automationMonitors.deleteMonitor(monitorId);
+    }
+    async runAutomationMonitor(monitorId) {
+        return this.automationMonitors.runMonitorNow(monitorId);
+    }
+    async listAutomationMonitorRuns(monitorId) {
+        return this.automationMonitors.listRuns(monitorId);
+    }
     async listThreads(workspaceId) {
         return this.workspaceRouter.listThreads(workspaceId);
     }

package/dist-electron/services/local-ai-core/src/runtime/server-routes.js

@@ -48,6 +48,9 @@ function parseLocalAiCoreRoute(method, path) {
     if (segments[0] === 'scheduler' && segments[1] === 'jobs') {
         return parseSchedulerJobsRoute(normalizedMethod, segments);
     }
+    if (segments[0] === 'automation' && segments[1] === 'monitors') {
+        return parseAutomationMonitorsRoute(normalizedMethod, segments);
+    }
     if (segments[0] === 'threads') {
         return parseThreadsRoute(normalizedMethod, segments);
     }
@@ -92,6 +95,34 @@ function parseLocalAiCoreRoute(method, path) {
     }
     return null;
 }
+function parseAutomationMonitorsRoute(method, segments) {
+    if (method === 'GET' && segments.length === 2) {
+        return { name: 'automation.monitors.list' };
+    }
+    if (method === 'POST' && segments.length === 2) {
+        return { name: 'automation.monitors.create' };
+    }
+    const monitorId = segments.length >= 3 ? decodeURIComponent(segments[2] || '') : '';
+    if (!monitorId) {
+        return null;
+    }
+    if (method === 'GET' && segments.length === 3) {
+        return { name: 'automation.monitor.get', monitorId };
+    }
+    if (method === 'GET' && segments.length === 4 && segments[3] === 'runs') {
+        return { name: 'automation.monitor.runs', monitorId };
+    }
+    if (method === 'POST' && segments.length === 4 && segments[3] === 'run') {
+        return { name: 'automation.monitor.run', monitorId };
+    }
+    if (method === 'PATCH' && segments.length === 3) {
+        return { name: 'automation.monitor.update', monitorId };
+    }
+    if (method === 'DELETE' && segments.length === 3) {
+        return { name: 'automation.monitor.delete', monitorId };
+    }
+    return null;
+}
 function parseRuntimesRoute(method, segments) {
     if (method === 'GET' && segments.length === 1) {
         return { name: 'runtimes.list' };

package/dist-electron/services/local-ai-core/src/runtime/server.js

@@ -62,12 +62,21 @@ class LocalAiCoreServer {
                 });
             }
         });
+        this.bindings.on('thread-session-activated', (event) => {
+            this.broadcast({ type: 'thread.session.activated', ...event });
+        });
         this.bindings.on('scheduler-job', (job) => {
             this.broadcast({ type: 'scheduler.job.updated', job });
         });
         this.bindings.on('scheduler-run', (run) => {
             this.broadcast({ type: 'scheduler.run.updated', run });
         });
+        this.bindings.on('automation-monitor', (monitor) => {
+            this.broadcast({ type: 'automation.monitor.updated', monitor });
+        });
+        this.bindings.on('automation-monitor-run', (run) => {
+            this.broadcast({ type: 'automation.monitor.run.updated', run });
+        });
         this.bindings.on('runtime-detection', (event) => {
             this.broadcast(event);
         });
@@ -226,6 +235,33 @@ class LocalAiCoreServer {
             case 'scheduler.job.delete':
                 json(res, 200, await this.bindings.deleteScheduledJob(route.jobId));
                 return;
+            case 'automation.monitors.list': {
+                const workspaceId = String(url.searchParams.get('workspace_id') || '');
+                json(res, 200, { monitors: await this.bindings.listAutomationMonitors(workspaceId || undefined) });
+                return;
+            }
+            case 'automation.monitors.create': {
+                const body = await readJsonBody(req);
+                json(res, 200, await this.bindings.createAutomationMonitor(body));
+                return;
+            }
+            case 'automation.monitor.get':
+                json(res, 200, await this.bindings.getAutomationMonitor(route.monitorId));
+                return;
+            case 'automation.monitor.runs':
+                json(res, 200, { runs: await this.bindings.listAutomationMonitorRuns(route.monitorId) });
+                return;
+            case 'automation.monitor.run':
+                json(res, 200, await this.bindings.runAutomationMonitor(route.monitorId));
+                return;
+            case 'automation.monitor.update': {
+                const body = await readJsonBody(req);
+                json(res, 200, await this.bindings.updateAutomationMonitor(route.monitorId, body));
+                return;
+            }
+            case 'automation.monitor.delete':
+                json(res, 200, await this.bindings.deleteAutomationMonitor(route.monitorId));
+                return;
             case 'threads.list': {
                 const workspaceId = String(url.searchParams.get('workspace_id') || '');
                 json(res, 200, { threads: workspaceId ? await this.bindings.listThreads(workspaceId) : [] });