@kafca/agentdock 0.1.61 → 0.1.62

package/dist-electron/tests/electron/automation-compatibility.test.js

@@ -0,0 +1,463 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_test_1 = __importDefault(require("node:test"));
+const local_core_acp_store_js_1 = require("../../services/local-ai-core/src/acp/local-core-acp-store.js");
+const automation_monitor_service_js_1 = require("../../services/local-ai-core/src/automation/automation-monitor-service.js");
+const automation_service_js_1 = require("../../services/local-ai-core/src/automation/automation-service.js");
+const legacy_automation_mappers_js_1 = require("../../services/local-ai-core/src/automation/legacy-automation-mappers.js");
+const event_bus_js_1 = require("../../services/local-ai-core/src/kernel/event-bus.js");
+const scheduled_job_application_service_js_1 = require("../../services/local-ai-core/src/scheduler/scheduled-job-application-service.js");
+const scheduler_service_js_1 = require("../../services/local-ai-core/src/scheduler/scheduler-service.js");
+function fixture(executeAction, conditionEvaluator) {
+    const path = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'automation-compatibility-'));
+    const store = new local_core_acp_store_js_1.LocalCoreAcpStore(path);
+    const eventBus = new event_bus_js_1.LocalCoreEventBus();
+    const actions = [];
+    const automations = new automation_service_js_1.AutomationService({
+        store,
+        eventBus,
+        actionExecutor: {
+            async execute({ automation, promptVariables }) {
+                actions.push({ automationId: automation.id, promptVariables });
+                if (executeAction)
+                    return executeAction();
+                return { threadId: 'thread-1', acpRunId: 'run-1', deliveryStatus: 'succeeded' };
+            },
+        },
+        ownershipPolicy: { executes: () => true },
+        conditionEvaluator,
+    });
+    const scheduler = new scheduler_service_js_1.SchedulerService({ store, automations, triggers: [], executors: [], eventBus });
+    const jobs = new scheduled_job_application_service_js_1.ScheduledJobApplicationService({ store, scheduler, automations, eventBus });
+    return {
+        path, store, eventBus, automations, scheduler, jobs, actions,
+        close() { store.close(); (0, node_fs_1.rmSync)(path, { recursive: true, force: true }); },
+    };
+}
+(0, node_test_1.default)('legacy scheduler mappings validate origin and preserve the public shape', () => {
+    const input = (0, legacy_automation_mappers_js_1.scheduledJobToAutomationInput)({
+        workspaceId: 'workspace-1',
+        platform: 'lark:tenant-1',
+        route: { type: 'lark.chat', channelId: 'chat-1' },
+        executionMode: 'same-thread',
+        triggerType: 'cron',
+        cronExpr: '0 9 * * *',
+        promptTemplate: 'daily report',
+        description: 'Daily report',
+        enabled: true,
+    });
+    strict_1.default.deepEqual(input.activation, { kind: 'cron', expression: '0 9 * * *', timezone: 'UTC' });
+    strict_1.default.deepEqual(input.condition, { kind: 'always' });
+    strict_1.default.equal(input.originKind, 'scheduled-job');
+    strict_1.default.equal(input.action.executionMode, 'same-thread');
+    strict_1.default.deepEqual(input.legacyMetadata, { scheduledDescription: 'Daily report' });
+    strict_1.default.equal((0, legacy_automation_mappers_js_1.scheduledJobToAutomationInput)({
+        workspaceId: 'workspace-1', platform: 'local', route: { type: 'local.thread', channelId: 'workspace-1' },
+        triggerType: 'cron', cronExpr: '* * * * *', promptTemplate: 'hello', executionMode: '',
+    }).action.executionMode, 'same-thread');
+    strict_1.default.throws(() => (0, legacy_automation_mappers_js_1.scheduledJobToAutomationInput)({
+        workspaceId: 'workspace-1', platform: 'local', route: { type: 'local.thread', channelId: 'workspace-1' },
+        triggerType: 'cron', cronExpr: '* * * * *', promptTemplate: 'hello', executionMode: 'bogus',
+    }), /same-thread or side-thread/);
+    strict_1.default.deepEqual((0, legacy_automation_mappers_js_1.scheduledJobToAutomationInput)({
+        workspaceId: 'workspace-1', platform: 'local', route: { type: 'local.thread', channelId: 'workspace-1' },
+        triggerType: 'One_Time', runAt: '2026-07-06T00:00:00.000Z', promptTemplate: 'hello', description: '   ',
+    }).activation, { kind: 'once', runAt: '2026-07-06T00:00:00.000Z' });
+    strict_1.default.equal((0, legacy_automation_mappers_js_1.scheduledJobToAutomationInput)({
+        workspaceId: 'workspace-1', platform: 'local', route: { type: 'local.thread', channelId: 'workspace-1' },
+        triggerType: 'cron', cronExpr: '* * * * *', promptTemplate: 'hello', description: '   ',
+    }).title, 'hello');
+    const definition = {
+        id: 'abcd1234', health: 'healthy', consecutiveEvaluationFailures: 0,
+        createdAt: '2026-07-05T00:00:00.000Z', updatedAt: '2026-07-05T00:00:00.000Z',
+        ...input,
+    };
+    strict_1.default.equal((0, legacy_automation_mappers_js_1.automationToScheduledJob)(definition).id, 'abcd1234');
+    strict_1.default.throws(() => (0, legacy_automation_mappers_js_1.automationToScheduledJob)({ ...definition, originKind: 'native' }), /scheduled-job origin/);
+});
+(0, node_test_1.default)('legacy monitor mappings use provider events and expression conditions', () => {
+    const input = (0, legacy_automation_mappers_js_1.monitorToAutomationInput)({
+        workspaceId: 'workspace-1', title: 'Price alert', sourceType: 'stock.quote', sourceConfig: { symbol: 'AAPL' },
+        condition: { metric: 'latestPrice', operator: '>=', value: 200 }, promptTemplate: 'Price {{latestPrice}}',
+        platform: 'local', route: { type: 'local.thread', channelId: 'workspace-1' }, executionMode: 'side-thread',
+        enabled: true, cooldownMs: 60_000,
+    });
+    strict_1.default.deepEqual(input.activation, { kind: 'provider-event', sourceType: 'stock.quote', sourceConfig: { symbol: 'AAPL' } });
+    strict_1.default.deepEqual(input.condition, { kind: 'expression', expression: 'latestPrice >= 200' });
+    strict_1.default.equal(input.originKind, 'automation-monitor');
+    strict_1.default.equal(input.policies.cooldownMs, 60_000);
+    strict_1.default.equal(input.action.executionMode, 'side-thread');
+    strict_1.default.equal((0, legacy_automation_mappers_js_1.monitorToAutomationInput)({
+        workspaceId: 'workspace-1', title: 'Default', sourceType: 'stock.quote', condition: { metric: 'x', operator: '>', value: 1 },
+        promptTemplate: 'hello', platform: 'local', route: { type: 'local.thread', channelId: 'workspace-1' }, executionMode: '',
+    }).action.executionMode, 'side-thread');
+    strict_1.default.equal((0, legacy_automation_mappers_js_1.monitorToAutomationInput)({
+        workspaceId: 'workspace-1', title: 'Default', sourceType: 'stock.quote', condition: { metric: 'x', operator: '>', value: 1 },
+        promptTemplate: 'hello', platform: 'local', route: { type: 'local.thread', channelId: 'workspace-1' },
+    }).policies.cooldownMs, 15 * 60 * 1_000);
+    strict_1.default.throws(() => (0, legacy_automation_mappers_js_1.monitorToAutomationInput)({
+        workspaceId: 'workspace-1', title: 'Default', sourceType: 'stock.quote', condition: { metric: 'x', operator: '>', value: 1 },
+        promptTemplate: 'hello', platform: 'local', route: { type: 'local.thread', channelId: 'workspace-1' }, executionMode: 'bogus',
+    }), /same-thread or side-thread/);
+    strict_1.default.throws(() => (0, legacy_automation_mappers_js_1.monitorToAutomationInput)({
+        workspaceId: 'workspace-1', title: 'Default', sourceType: 'stock.quote',
+        condition: { metric: 'x', operator: 'contains', value: 1 }, promptTemplate: 'hello',
+        platform: 'local', route: { type: 'local.thread', channelId: 'workspace-1' },
+    }), /operator/i);
+    strict_1.default.throws(() => (0, legacy_automation_mappers_js_1.monitorToAutomationInput)({
+        workspaceId: 'workspace-1', title: 'Default', sourceType: 'stock.quote',
+        condition: { metric: 'x', operator: '>', value: { unsafe: true } }, promptTemplate: 'hello',
+        platform: 'local', route: { type: 'local.thread', channelId: 'workspace-1' },
+    }), /number, string, or boolean/);
+    const projected = (0, legacy_automation_mappers_js_1.automationToMonitor)({
+        id: 'monitor:one', health: 'healthy', consecutiveEvaluationFailures: 0,
+        createdAt: '2026-07-05T00:00:00.000Z', updatedAt: '2026-07-05T00:00:00.000Z', ...input,
+    });
+    strict_1.default.deepEqual(projected.condition, { metric: 'latestPrice', operator: '>=', value: 200 });
+});
+(0, node_test_1.default)('scheduler facade writes and runs only unified records while projecting legacy events', async () => {
+    const context = fixture();
+    const events = [];
+    context.eventBus.on('scheduler.job.updated', () => events.push('job'));
+    context.eventBus.on('scheduler.run.updated', () => events.push('run'));
+    try {
+        const job = context.jobs.createJob({
+            workspaceId: 'workspace-1', threadId: 'thread-1', triggerType: 'once', runAt: '2099-01-01T00:00:00.000Z',
+            promptTemplate: 'hello', description: 'One shot', enabled: true,
+        });
+        strict_1.default.match(job.id, /^[0-9a-f]{8}$/);
+        strict_1.default.equal(context.store.listScheduledJobs().length, 0);
+        strict_1.default.equal(context.automations.get(job.id)?.originKind, 'scheduled-job');
+        strict_1.default.equal(context.jobs.getJob(job.id)?.description, 'One shot');
+        context.jobs.updateJob(job.id, { description: 'Updated', enabled: false });
+        strict_1.default.equal(context.jobs.listJobs()[0]?.description, 'Updated');
+        const run = await context.jobs.runJobNow(job.id);
+        strict_1.default.equal(run.jobId, job.id);
+        strict_1.default.equal(run.status, 'succeeded');
+        strict_1.default.equal(context.store.listScheduledJobRuns(job.id).length, 0);
+        strict_1.default.equal(context.jobs.listJobRuns(job.id).length, 1);
+        strict_1.default.equal(context.actions.length, 1);
+        strict_1.default.equal(events.filter((event) => event === 'job').length, 3);
+        strict_1.default.equal(events.filter((event) => event === 'run').length, 3);
+        context.jobs.deleteJob(job.id);
+        strict_1.default.equal(context.jobs.getJob(job.id), undefined);
+    }
+    finally {
+        context.close();
+    }
+});
+(0, node_test_1.default)('scheduler empty description survives unified persistence and reopen', () => {
+    const context = fixture();
+    const path = context.path;
+    let id = '';
+    try {
+        const created = context.jobs.createJob({
+            workspaceId: 'workspace-1', triggerType: 'cron', cronExpr: '0 9 * * *', promptTemplate: 'hello',
+        });
+        id = created.id;
+        strict_1.default.equal(created.description, '');
+        strict_1.default.equal(context.automations.get(id)?.title, 'hello');
+        context.store.close();
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(path);
+        const eventBus = new event_bus_js_1.LocalCoreEventBus();
+        const automations = new automation_service_js_1.AutomationService({
+            store, eventBus,
+            actionExecutor: { async execute() { return { threadId: 'thread', acpRunId: 'run' }; } },
+            ownershipPolicy: { executes: () => true },
+        });
+        const scheduler = new scheduler_service_js_1.SchedulerService({ store, automations, triggers: [], executors: [], eventBus });
+        const jobs = new scheduled_job_application_service_js_1.ScheduledJobApplicationService({ store, scheduler, automations, eventBus });
+        strict_1.default.equal(jobs.getJob(id)?.description, '');
+        strict_1.default.equal(jobs.listJobs()[0]?.description, '');
+        store.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(path, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('monitor facade delegates provider snapshots to one unified evaluation and run', async () => {
+    const context = fixture();
+    const events = [];
+    context.eventBus.on('automation.monitor.updated', () => events.push('monitor'));
+    context.eventBus.on('automation.monitor.run.updated', () => events.push('run'));
+    const snapshot = {
+        id: 'event-1', sourceType: 'stock.quote', occurredAt: '2026-07-05T01:00:00.000Z', subject: 'AAPL',
+        payload: { latestPrice: 205, previousPrice: 190 },
+    };
+    const monitors = new automation_monitor_service_js_1.AutomationMonitorService({
+        store: context.store,
+        automations: context.automations,
+        providers: [{ sourceType: 'stock.quote', modes: ['poll'], async poll() { return snapshot; } }],
+        eventBus: context.eventBus,
+    });
+    try {
+        const monitor = await monitors.createMonitor({
+            workspaceId: 'workspace-1', title: 'Price alert', sourceType: 'stock.quote', sourceConfig: { symbol: 'AAPL' },
+            condition: { metric: 'latestPrice', operator: '>=', value: 200 }, promptTemplate: '{{subject}} {{latestPrice}}',
+            threadId: 'thread-1', enabled: true, cooldownMs: 60_000,
+        });
+        strict_1.default.equal(context.store.listAutomationMonitors().length, 0);
+        strict_1.default.equal(context.automations.get(monitor.id)?.originKind, 'automation-monitor');
+        await strict_1.default.rejects(context.automations.checkNow(monitor.id), /requires an event snapshot/);
+        const run = await monitors.runMonitorNow(monitor.id);
+        strict_1.default.equal(run.monitorId, monitor.id);
+        strict_1.default.deepEqual(run.eventSnapshot, snapshot);
+        strict_1.default.equal(context.automations.listEvaluations(monitor.id).length, 1);
+        strict_1.default.equal(context.automations.listEvaluations(monitor.id)[0]?.startedAt, snapshot.occurredAt);
+        strict_1.default.equal(context.automations.get(monitor.id)?.lastTriggeredAt, snapshot.occurredAt);
+        strict_1.default.equal(context.automations.listRuns(monitor.id).length, 1);
+        strict_1.default.equal(context.actions.length, 1);
+        strict_1.default.equal(context.actions[0]?.promptVariables.latestPrice, 205);
+        strict_1.default.deepEqual(context.actions[0]?.promptVariables.previous, {});
+        strict_1.default.deepEqual(context.actions[0]?.promptVariables.eventSnapshot, snapshot);
+        strict_1.default.equal(events.filter((event) => event === 'monitor').length, 2);
+        strict_1.default.equal(events.filter((event) => event === 'run').length, 3);
+        const notMatched = await monitors.runMonitorNow(monitor.id, {
+            ...snapshot,
+            id: 'event-2',
+            occurredAt: '2026-07-05T01:01:00.000Z',
+            payload: { latestPrice: 190, previousPrice: 205 },
+        });
+        strict_1.default.equal(notMatched.status, 'skipped');
+        strict_1.default.equal(context.automations.listEvaluations(monitor.id).length, 2);
+        strict_1.default.equal(context.automations.listRuns(monitor.id).length, 1);
+        strict_1.default.equal(context.actions.length, 1);
+        strict_1.default.equal(monitors.getMonitor(monitor.id)?.lastState?.latestPrice, 190);
+        strict_1.default.equal(events.filter((event) => event === 'run').length, 4);
+        const latestLegacyRun = monitors.listRuns(monitor.id)[0];
+        strict_1.default.equal(latestLegacyRun?.status, 'skipped');
+        strict_1.default.equal(latestLegacyRun?.eventSnapshot?.id, 'event-2');
+        context.automations.recordUnavailableProviderEvent(monitor.id, 'temporarily unavailable');
+        strict_1.default.equal(monitors.getMonitor(monitor.id)?.lastState?.latestPrice, 190);
+    }
+    finally {
+        await monitors.stop();
+        context.close();
+    }
+});
+(0, node_test_1.default)('monitor facade preserves legacy fields across stable CRUD projections', async () => {
+    const context = fixture();
+    const monitors = new automation_monitor_service_js_1.AutomationMonitorService({
+        store: context.store,
+        automations: context.automations,
+        providers: [{ sourceType: 'stock.quote', modes: ['poll'] }],
+        eventBus: context.eventBus,
+    });
+    try {
+        const created = await monitors.createMonitor({
+            workspaceId: 'workspace-1', title: 'Price alert', sourceType: 'stock.quote', sourceConfig: { symbol: 'AAPL' },
+            condition: { metric: 'latestPrice', operator: '>=', value: 200 }, promptTemplate: 'price',
+            platform: 'lark:tenant-1', route: { type: 'lark.chat', channelId: 'chat-1', threadId: 'ignored' },
+            executionMode: 'same-thread', enabled: true, cooldownMs: 30_000,
+        });
+        strict_1.default.equal(monitors.listMonitors()[0]?.id, created.id);
+        strict_1.default.equal(monitors.getMonitor(publicMonitorId(created.id))?.id, created.id);
+        strict_1.default.equal(created.platform, 'lark:tenant-1');
+        strict_1.default.equal(created.route.channelId, 'chat-1');
+        strict_1.default.equal(created.route.threadId, undefined);
+        const updated = await monitors.updateMonitor(created.id, { title: 'Updated', enabled: false, cooldownMs: 90_000 });
+        strict_1.default.equal(updated.id, created.id);
+        strict_1.default.equal(updated.title, 'Updated');
+        strict_1.default.equal(updated.enabled, false);
+        strict_1.default.equal(updated.cooldownMs, 90_000);
+        strict_1.default.deepEqual(updated.sourceConfig, { symbol: 'AAPL' });
+        strict_1.default.deepEqual(await monitors.deleteMonitor(created.id), { deleted: true });
+        strict_1.default.equal(monitors.getMonitor(created.id), undefined);
+        strict_1.default.equal(context.store.listAutomationMonitors().length, 0);
+    }
+    finally {
+        await monitors.stop();
+        context.close();
+    }
+});
+(0, node_test_1.default)('manual monitor polling without a snapshot records one unified skipped evaluation', async () => {
+    const context = fixture();
+    const events = [];
+    context.eventBus.on('automation.monitor.run.updated', () => events.push('run'));
+    const monitors = new automation_monitor_service_js_1.AutomationMonitorService({
+        store: context.store,
+        automations: context.automations,
+        providers: [{ sourceType: 'stock.quote', modes: ['poll'], async poll() { return null; } }],
+        eventBus: context.eventBus,
+    });
+    try {
+        const monitor = await monitors.createMonitor({
+            workspaceId: 'workspace-1', title: 'No quote', sourceType: 'stock.quote',
+            condition: { metric: 'latestPrice', operator: '>=', value: 200 }, promptTemplate: 'price',
+        });
+        const run = await monitors.runMonitorNow(monitor.id);
+        strict_1.default.equal(run.status, 'skipped');
+        strict_1.default.match(run.error || '', /No event snapshot/);
+        strict_1.default.equal(context.automations.listEvaluations(monitor.id).length, 1);
+        strict_1.default.equal(context.automations.listRuns(monitor.id).length, 0);
+        strict_1.default.equal(context.store.listAutomationMonitorRuns(monitor.id).length, 0);
+        strict_1.default.deepEqual(events, ['run']);
+    }
+    finally {
+        await monitors.stop();
+        context.close();
+    }
+});
+(0, node_test_1.default)('provider evaluation errors preserve snapshot, prior state, and one failed compatibility run', async () => {
+    let calls = 0;
+    const context = fixture(undefined, () => {
+        calls += 1;
+        if (calls > 1)
+            throw new Error('condition exploded');
+        return { kind: 'evaluated', matched: true };
+    });
+    const failedRuns = [];
+    context.eventBus.on('automation.monitor.run.updated', (run) => {
+        if (run.status === 'failed')
+            failedRuns.push({ error: run.error, eventId: run.eventSnapshot?.id });
+    });
+    const monitors = new automation_monitor_service_js_1.AutomationMonitorService({
+        store: context.store, automations: context.automations, providers: [], eventBus: context.eventBus,
+    });
+    try {
+        const monitor = await monitors.createMonitor({
+            workspaceId: 'workspace-1', title: 'Price', sourceType: 'stock.quote',
+            condition: { metric: 'latestPrice', operator: '>', value: 1 }, promptTemplate: 'price',
+        });
+        await monitors.runMonitorNow(monitor.id, {
+            id: 'event-ok', sourceType: 'stock.quote', occurredAt: '2026-07-05T01:00:00.000Z', subject: 'AAPL', payload: { latestPrice: 2 },
+        });
+        const failed = await monitors.runMonitorNow(monitor.id, {
+            id: 'event-error', sourceType: 'stock.quote', occurredAt: '2026-07-05T01:01:00.000Z', subject: 'AAPL', payload: { latestPrice: 3 },
+        });
+        strict_1.default.equal(failed.status, 'failed');
+        strict_1.default.match(failed.error || '', /condition exploded/);
+        strict_1.default.equal(failed.eventSnapshot?.id, 'event-error');
+        strict_1.default.deepEqual(failedRuns, [{ error: 'condition exploded', eventId: 'event-error' }]);
+        const latest = context.automations.listEvaluations(monitor.id)[0];
+        strict_1.default.equal(latest?.status, 'finished');
+        if (latest?.status === 'finished') {
+            strict_1.default.equal(latest.payload?.eventSnapshot && latest.payload.eventSnapshot.id, 'event-error');
+            strict_1.default.equal(latest.payload?.previous?.latestPrice, 2);
+            strict_1.default.equal(latest.nextState?.latestPrice, 3);
+        }
+        context.automations.recordUnavailableProviderEvent(monitor.id, 'no snapshot');
+        strict_1.default.equal(monitors.getMonitor(monitor.id)?.lastState?.latestPrice, 3);
+    }
+    finally {
+        await monitors.stop();
+        context.close();
+    }
+});
+(0, node_test_1.default)('provider cooldown and trigger timestamps use event occurrence time', async () => {
+    const context = fixture();
+    const monitors = new automation_monitor_service_js_1.AutomationMonitorService({
+        store: context.store, automations: context.automations, providers: [], eventBus: context.eventBus,
+    });
+    try {
+        const monitor = await monitors.createMonitor({
+            workspaceId: 'workspace-1', title: 'Price', sourceType: 'stock.quote', cooldownMs: 5 * 60_000,
+            condition: { metric: 'latestPrice', operator: '>', value: 1 }, promptTemplate: 'price',
+        });
+        const snapshot = (id, occurredAt, latestPrice) => ({
+            id, sourceType: 'stock.quote', occurredAt, subject: 'AAPL', payload: { latestPrice },
+        });
+        const first = await monitors.runMonitorNow(monitor.id, snapshot('one', '2026-07-05T01:00:00.000Z', 2));
+        await monitors.runMonitorNow(monitor.id, snapshot('rearm', '2026-07-05T01:00:30.000Z', 0));
+        const cooled = await monitors.runMonitorNow(monitor.id, snapshot('cooled', '2026-07-05T01:01:00.000Z', 2));
+        strict_1.default.equal(first.triggeredAt, '2026-07-05T01:00:00.000Z');
+        strict_1.default.equal(cooled.status, 'skipped');
+        strict_1.default.equal(context.automations.listEvaluations(monitor.id)[0]?.triggerDecision, 'skipped_cooldown');
+        strict_1.default.equal(context.automations.get(monitor.id)?.lastTriggeredAt, '2026-07-05T01:00:00.000Z');
+        strict_1.default.equal(context.actions.length, 1);
+    }
+    finally {
+        await monitors.stop();
+        context.close();
+    }
+});
+(0, node_test_1.default)('legacy scheduler loop is disabled after unified ownership cutover', async () => {
+    const context = fixture();
+    try {
+        await context.scheduler.start();
+        strict_1.default.equal(context.store.listScheduledJobRuns('missing').length, 0);
+        await context.scheduler.stop();
+    }
+    finally {
+        context.close();
+    }
+});
+(0, node_test_1.default)('concurrent scheduler manual run emits one compatibility skipped run without a unified run', async () => {
+    let release;
+    const blocked = new Promise((resolve) => { release = resolve; });
+    const context = fixture(async () => {
+        await blocked;
+        return { threadId: 'thread-1', acpRunId: 'run-1', deliveryStatus: 'succeeded' };
+    });
+    const skippedEvents = [];
+    context.eventBus.on('scheduler.run.updated', (run) => {
+        if (run.status === 'skipped')
+            skippedEvents.push(run.id);
+    });
+    try {
+        const job = context.jobs.createJob({
+            workspaceId: 'workspace-1', triggerType: 'cron', cronExpr: '* * * * *', promptTemplate: 'hello',
+        });
+        const first = context.jobs.runJobNow(job.id);
+        await new Promise((resolve) => setImmediate(resolve));
+        const skipped = await context.jobs.runJobNow(job.id);
+        strict_1.default.equal(skipped.status, 'skipped');
+        strict_1.default.equal(context.automations.listEvaluations(job.id).length, 2);
+        strict_1.default.equal(context.automations.listRuns(job.id).length, 1);
+        strict_1.default.deepEqual(skippedEvents, [skipped.id]);
+        release();
+        await first;
+    }
+    finally {
+        context.close();
+    }
+});
+(0, node_test_1.default)('concurrent monitor manual run emits one compatibility skipped run with its snapshot', async () => {
+    let release;
+    const blocked = new Promise((resolve) => { release = resolve; });
+    const context = fixture(async () => {
+        await blocked;
+        return { threadId: 'thread-1', acpRunId: 'run-1', deliveryStatus: 'succeeded' };
+    });
+    const skippedEvents = [];
+    context.eventBus.on('automation.monitor.run.updated', (run) => {
+        if (run.status === 'skipped')
+            skippedEvents.push({ id: run.id, eventId: run.eventSnapshot?.id });
+    });
+    const snapshot = {
+        id: 'event-1', sourceType: 'stock.quote', occurredAt: '2026-07-05T01:00:00.000Z', subject: 'AAPL',
+        payload: { latestPrice: 205 },
+    };
+    const monitors = new automation_monitor_service_js_1.AutomationMonitorService({
+        store: context.store, automations: context.automations, providers: [], eventBus: context.eventBus,
+    });
+    try {
+        const monitor = await monitors.createMonitor({
+            workspaceId: 'workspace-1', title: 'Price', sourceType: 'stock.quote',
+            condition: { metric: 'latestPrice', operator: '>=', value: 200 }, promptTemplate: 'price',
+        });
+        const first = monitors.runMonitorNow(monitor.id, snapshot);
+        await new Promise((resolve) => setImmediate(resolve));
+        const skipped = await monitors.runMonitorNow(monitor.id, { ...snapshot, id: 'event-2' });
+        strict_1.default.equal(skipped.status, 'skipped');
+        strict_1.default.equal(context.automations.listEvaluations(monitor.id).length, 2);
+        strict_1.default.equal(context.automations.listRuns(monitor.id).length, 1);
+        strict_1.default.deepEqual(skippedEvents, [{ id: skipped.id, eventId: 'event-2' }]);
+        release();
+        await first;
+    }
+    finally {
+        await monitors.stop();
+        context.close();
+    }
+});
+function publicMonitorId(monitorId) {
+    return monitorId.replace(/^monitor:/, '').split('-')[0] || monitorId;
+}

package/dist-electron/tests/electron/automation-deployment.test.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_process_1 = __importDefault(require("node:process"));
+const deployment_diagnostics_js_1 = require("../../services/local-ai-core/src/runtime/deployment-diagnostics.js");
+(0, node_test_1.default)('Linux automation diagnostics report every sandbox prerequisite independently', () => {
+    const checks = (0, deployment_diagnostics_js_1.automationSandboxDiagnosticChecks)({
+        available: false,
+        platform: 'linux',
+        missing: ['bwrap', 'socat', 'rg', 'apparmor.userns', 'network.namespace', 'seccomp'],
+        unverified: ['apparmor.userns', 'network.namespace', 'seccomp'],
+    });
+    strict_1.default.deepEqual(checks.map((check) => check.id), [
+        'automation.sandbox',
+        'automation.runtime',
+        'automation.linux.bwrap',
+        'automation.linux.socat',
+        'automation.linux.rg',
+        'automation.linux.userns-apparmor',
+        'automation.linux.network-namespace',
+        'automation.linux.seccomp',
+    ]);
+    strict_1.default.equal(checks[0]?.status, 'fail', 'the stable aggregate follows capability.available');
+    strict_1.default.equal(checks[1]?.status, 'pass', 'package/runtime presence remains independently diagnosable');
+    strict_1.default.ok(checks.slice(2).every((check) => check.status === 'fail'));
+    strict_1.default.match(checks.find((check) => check.id === 'automation.linux.network-namespace')?.summary || '', /could not be behaviorally verified/);
+});
+(0, node_test_1.default)('macOS automation diagnostics distinguish runtime, sandbox-exec, and rg', () => {
+    const checks = (0, deployment_diagnostics_js_1.automationSandboxDiagnosticChecks)({
+        available: false,
+        platform: 'macos',
+        missing: ['sandbox_runtime', 'sandbox-exec', 'rg'],
+    });
+    strict_1.default.deepEqual(checks.map((check) => check.id), [
+        'automation.sandbox',
+        'automation.runtime',
+        'automation.macos.sandbox-exec',
+        'automation.macos.rg',
+    ]);
+    strict_1.default.ok(checks.every((check) => check.status === 'fail'));
+});
+(0, node_test_1.default)('Windows automation diagnostics fail closed as unsupported', () => {
+    const checks = (0, deployment_diagnostics_js_1.automationSandboxDiagnosticChecks)({
+        available: false,
+        platform: 'windows',
+        missing: ['sandbox_unavailable'],
+    });
+    strict_1.default.equal(checks.length, 1);
+    strict_1.default.equal(checks[0]?.id, 'automation.sandbox');
+    strict_1.default.equal(checks[0]?.status, 'fail');
+    strict_1.default.match(checks[0]?.summary || '', /unsupported|fail-closed/i);
+});
+(0, node_test_1.default)('Linux core image installs conditional automation sandbox dependencies', () => {
+    const dockerfile = (0, node_fs_1.readFileSync)((0, node_path_1.join)(node_process_1.default.cwd(), 'docker', 'agentdock', 'core.Dockerfile'), 'utf8');
+    strict_1.default.match(dockerfile, /apt-get\s+update/);
+    for (const dependency of ['bubblewrap', 'socat', 'ripgrep']) {
+        strict_1.default.match(dockerfile, new RegExp(`\\b${dependency}\\b`));
+    }
+    strict_1.default.match(dockerfile, /rm -rf \/var\/lib\/apt\/lists\/\*/);
+});