@kafca/agentdock 0.1.61 → 0.1.62

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

@@ -48,6 +48,12 @@ function parseLocalAiCoreRoute(method, path) {
     if (segments[0] === 'automation' && segments[1] === 'monitors') {
         return parseAutomationMonitorsRoute(normalizedMethod, segments);
     }
+    if (segments[0] === 'automations') {
+        return parseAutomationsRoute(normalizedMethod, segments);
+    }
+    if (segments[0] === 'automation-scripts') {
+        return parseAutomationScriptsRoute(normalizedMethod, segments);
+    }
     if (segments[0] === 'threads') {
         return parseThreadsRoute(normalizedMethod, segments);
     }
@@ -104,6 +110,75 @@ function parseLocalAiCoreRoute(method, path) {
     }
     return null;
 }
+function parseAutomationsRoute(method, segments) {
+    if (segments.length === 1) {
+        if (method === 'GET')
+            return { name: 'automations.list' };
+        if (method === 'POST')
+            return { name: 'automations.create' };
+        return null;
+    }
+    const automationId = decodeURIComponent(segments[1] || '').trim();
+    if (!automationId)
+        return null;
+    if (segments.length === 2) {
+        if (method === 'GET')
+            return { name: 'automation.get', automationId };
+        if (method === 'PATCH')
+            return { name: 'automation.update', automationId };
+        if (method === 'DELETE')
+            return { name: 'automation.delete', automationId };
+        return null;
+    }
+    if (segments.length !== 3)
+        return null;
+    if (method === 'POST' && segments[2] === 'check')
+        return { name: 'automation.check', automationId };
+    if (method === 'GET' && segments[2] === 'evaluations')
+        return { name: 'automation.evaluations', automationId };
+    if (method === 'GET' && segments[2] === 'runs')
+        return { name: 'automation.runs', automationId };
+    return null;
+}
+function parseAutomationScriptsRoute(method, segments) {
+    if (segments.length === 1) {
+        if (method === 'GET')
+            return { name: 'automation-scripts.list' };
+        if (method === 'POST')
+            return { name: 'automation-scripts.create' };
+        return null;
+    }
+    if (segments[1] === 'versions') {
+        const versionId = decodeURIComponent(segments[2] || '').trim();
+        if (!versionId || segments.length !== 4 || method !== 'POST')
+            return null;
+        switch (segments[3]) {
+            case 'test-approval': return { name: 'automation-script-version.test-approval', versionId };
+            case 'test': return { name: 'automation-script-version.test', versionId };
+            case 'enable-approval': return { name: 'automation-script-version.enable-approval', versionId };
+            case 'approve': return { name: 'automation-script-version.approve', versionId };
+            case 'reject': return { name: 'automation-script-version.reject', versionId };
+            case 'revoke': return { name: 'automation-script-version.revoke', versionId };
+            default: return null;
+        }
+    }
+    const scriptId = decodeURIComponent(segments[1] || '').trim();
+    if (!scriptId)
+        return null;
+    if (segments.length === 2) {
+        if (method === 'GET')
+            return { name: 'automation-script.get', scriptId };
+        if (method === 'PATCH')
+            return { name: 'automation-script.update', scriptId };
+    }
+    if (segments.length === 3 && segments[2] === 'versions') {
+        if (method === 'GET')
+            return { name: 'automation-script.versions', scriptId };
+        if (method === 'POST')
+            return { name: 'automation-script.version.submit', scriptId };
+    }
+    return null;
+}
 function parseOpenAiRoute(method, segments) {
     if (method === 'POST' && segments.length === 3 && segments[1] === 'chat' && segments[2] === 'completions') {
         return { name: 'openai.chat.completions' };

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

@@ -12,6 +12,7 @@ const security_handler_js_1 = require("./handlers/security-handler.js");
 const task_handler_js_1 = require("./handlers/task-handler.js");
 const scheduler_handler_js_1 = require("./handlers/scheduler-handler.js");
 const automation_handler_js_1 = require("./handlers/automation-handler.js");
+const automations_handler_js_1 = require("./handlers/automations-handler.js");
 const knowledge_handler_js_1 = require("./handlers/knowledge-handler.js");
 const capabilities_handler_js_1 = require("./handlers/capabilities-handler.js");
 const provider_handler_js_1 = require("./handlers/provider-handler.js");
@@ -93,6 +94,14 @@ class LocalAiCoreServer {
         (0, task_handler_js_1.registerTaskHandlers)(this.handlers, b.workspaceRouter);
         (0, scheduler_handler_js_1.registerSchedulerHandlers)(this.handlers, b.scheduledJobs);
         (0, automation_handler_js_1.registerAutomationHandlers)(this.handlers, b.automationMonitors);
+        if (b.automations) {
+            (0, automations_handler_js_1.registerUnifiedAutomationHandlers)(this.handlers, {
+                automations: b.automations,
+                store: b.store,
+                executeScriptTest: (versionId) => b.automations.executeAuthorizedScriptTest(versionId),
+                emitScriptVersion: (version) => b.controller.emit('automation-script-version', version),
+            });
+        }
         (0, knowledge_handler_js_1.registerKnowledgeHandlers)(this.handlers, b.knowledgeProvider);
         (0, capabilities_handler_js_1.registerCapabilitiesHandlers)(this.handlers, b.kernel);
         (0, provider_handler_js_1.registerProviderHandlers)(this.handlers, b.store);
@@ -153,6 +162,18 @@ class LocalAiCoreServer {
         b.controller.on('automation-monitor-run', (run) => {
             this.broadcast({ type: 'automation.monitor.run.updated', run });
         });
+        b.controller.on('automation-definition', (automation) => {
+            this.broadcast({ type: 'automation.definition.updated', automation });
+        });
+        b.controller.on('automation-evaluation', (evaluation) => {
+            this.broadcast({ type: 'automation.evaluation.updated', evaluation });
+        });
+        b.controller.on('automation-run', (run) => {
+            this.broadcast({ type: 'automation.run.updated', run });
+        });
+        b.controller.on('automation-script-version', (version) => {
+            this.broadcast({ type: 'automation.script-version.updated', version });
+        });
         b.controller.on('runtime-detection', (event) => {
             this.broadcast(event);
         });

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

@@ -21,6 +21,7 @@ async function main() {
         knowledgeProvider: controller.knowledgeProvider,
         scheduledJobs: controller.scheduledJobs,
         automationMonitors: controller.automationMonitors,
+        automations: controller.automations,
         store: controller.store,
         runtimeDetection: controller.runtimeDetection,
         kernel: controller.kernel,

package/dist-electron/services/local-ai-core/src/scheduler/cron.js

@@ -1,53 +1,165 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileCronExpression = compileCronExpression;
+exports.cronMatchesFields = cronMatchesFields;
 exports.cronMatchesDate = cronMatchesDate;
+exports.findNextCronMatchUtc = findNextCronMatchUtc;
+exports.findPreviousCronMatchUtc = findPreviousCronMatchUtc;
 exports.floorToMinute = floorToMinute;
-function expandSegment(segment, min, max) {
-    const values = new Set();
-    const normalized = segment.trim();
-    if (!normalized || normalized === '*') {
-        for (let value = min; value <= max; value += 1) {
-            values.add(value);
-        }
-        return values;
+const DAY_MS = 24 * 60 * 60 * 1000;
+const GREGORIAN_CYCLE_DAYS = 146_097;
+const MIN_DATE_MS = -8_640_000_000_000_000;
+const MAX_DATE_MS = 8_640_000_000_000_000;
+function compileCronExpression(expression) {
+    const normalized = String(expression ?? '').trim();
+    const fields = normalized ? normalized.split(/\s+/) : [];
+    if (fields.length !== 5) {
+        throw invalidCron(normalized, 'expected exactly 5 fields');
     }
-    for (const part of normalized.split(',')) {
-        const token = part.trim();
-        if (!token) {
-            continue;
-        }
-        const [rangePart, stepPart] = token.split('/');
-        const step = Math.max(1, Number(stepPart || '1'));
-        let rangeStart = min;
-        let rangeEnd = max;
-        if (rangePart && rangePart !== '*') {
-            const [startPart, endPart] = rangePart.split('-');
-            rangeStart = Math.max(min, Number(startPart));
-            rangeEnd = Math.min(max, Number(endPart || startPart));
-        }
-        for (let value = rangeStart; value <= rangeEnd; value += step) {
-            if (value >= min && value <= max) {
-                values.add(value);
+    return Object.freeze({
+        expression: normalized,
+        minutes: compileField(normalized, 'minute', fields[0], 0, 59),
+        hours: compileField(normalized, 'hour', fields[1], 0, 23),
+        daysOfMonth: compileField(normalized, 'day-of-month', fields[2], 1, 31),
+        months: compileField(normalized, 'month', fields[3], 1, 12),
+        daysOfWeek: compileField(normalized, 'day-of-week', fields[4], 0, 6),
+    });
+}
+function cronMatchesFields(compiled, fields) {
+    // Preserve the legacy scheduler's DOM+DOW AND behavior.
+    return compiled.minutes.includes(fields.minute)
+        && compiled.hours.includes(fields.hour)
+        && compiled.daysOfMonth.includes(fields.dayOfMonth)
+        && compiled.months.includes(fields.month)
+        && compiled.daysOfWeek.includes(fields.dayOfWeek);
+}
+function cronMatchesDate(cronExpr, date) {
+    let compiled;
+    try {
+        compiled = compileCronExpression(cronExpr);
+    }
+    catch {
+        return false;
+    }
+    return cronMatchesFields(compiled, {
+        minute: date.getMinutes(),
+        hour: date.getHours(),
+        dayOfMonth: date.getDate(),
+        month: date.getMonth() + 1,
+        dayOfWeek: date.getDay(),
+    });
+}
+function findNextCronMatchUtc(compiled, after) {
+    const afterMs = validDateMs(after, 'cron search date');
+    let dayMs = startOfUtcDay(afterMs);
+    for (let inspectedDays = 1; inspectedDays <= GREGORIAN_CYCLE_DAYS + 1; inspectedDays += 1) {
+        if (dayMs > MAX_DATE_MS)
+            return { date: null, inspectedDays };
+        const day = new Date(dayMs);
+        if (cronMatchesUtcDay(compiled, day)) {
+            for (const hour of compiled.hours) {
+                for (const minute of compiled.minutes) {
+                    const candidateMs = dayMs + hour * 60 * 60 * 1000 + minute * 60 * 1000;
+                    if (candidateMs > afterMs && candidateMs <= MAX_DATE_MS) {
+                        return { date: new Date(candidateMs), inspectedDays };
+                    }
+                }
             }
         }
+        dayMs += DAY_MS;
     }
-    return values;
+    return { date: null, inspectedDays: GREGORIAN_CYCLE_DAYS + 1 };
 }
-function cronMatchesDate(cronExpr, date) {
-    const fields = String(cronExpr || '').trim().split(/\s+/);
-    if (fields.length !== 5) {
-        return false;
+function findPreviousCronMatchUtc(compiled, atOrBefore, afterExclusive) {
+    const atOrBeforeMs = validDateMs(atOrBefore, 'cron search date');
+    const afterExclusiveMs = afterExclusive
+        ? validDateMs(afterExclusive, 'cron search lower bound')
+        : undefined;
+    if (afterExclusiveMs !== undefined && afterExclusiveMs >= atOrBeforeMs) {
+        return { date: null, inspectedDays: 0 };
     }
-    const [minute, hour, dayOfMonth, month, dayOfWeek] = fields;
-    const checks = [
-        [minute, 0, 59, date.getMinutes()],
-        [hour, 0, 23, date.getHours()],
-        [dayOfMonth, 1, 31, date.getDate()],
-        [month, 1, 12, date.getMonth() + 1],
-        [dayOfWeek, 0, 6, date.getDay()],
-    ];
-    return checks.every(([segment, min, max, current]) => expandSegment(segment, min, max).has(current));
+    const lowerBoundDayMs = afterExclusiveMs === undefined ? undefined : startOfUtcDay(afterExclusiveMs);
+    let dayMs = startOfUtcDay(atOrBeforeMs);
+    for (let inspectedDays = 1; inspectedDays <= GREGORIAN_CYCLE_DAYS + 1; inspectedDays += 1) {
+        if (dayMs < MIN_DATE_MS)
+            return { date: null, inspectedDays };
+        if (lowerBoundDayMs !== undefined && dayMs < lowerBoundDayMs) {
+            return { date: null, inspectedDays: inspectedDays - 1 };
+        }
+        const day = new Date(dayMs);
+        if (cronMatchesUtcDay(compiled, day)) {
+            for (let hourIndex = compiled.hours.length - 1; hourIndex >= 0; hourIndex -= 1) {
+                for (let minuteIndex = compiled.minutes.length - 1; minuteIndex >= 0; minuteIndex -= 1) {
+                    const candidateMs = dayMs
+                        + compiled.hours[hourIndex] * 60 * 60 * 1000
+                        + compiled.minutes[minuteIndex] * 60 * 1000;
+                    if (candidateMs <= atOrBeforeMs
+                        && candidateMs >= MIN_DATE_MS
+                        && (afterExclusiveMs === undefined || candidateMs > afterExclusiveMs)) {
+                        return { date: new Date(candidateMs), inspectedDays };
+                    }
+                }
+            }
+        }
+        if (dayMs === lowerBoundDayMs)
+            return { date: null, inspectedDays };
+        dayMs -= DAY_MS;
+    }
+    return { date: null, inspectedDays: GREGORIAN_CYCLE_DAYS + 1 };
 }
 function floorToMinute(date) {
     return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), 0, 0);
 }
+function compileField(expression, fieldName, field, min, max) {
+    if (!field)
+        throw invalidCron(expression, `${fieldName} field is empty`);
+    const values = new Set();
+    const tokens = field.split(',');
+    if (tokens.some((token) => token === '')) {
+        throw invalidCron(expression, `${fieldName} contains an empty list item`);
+    }
+    for (const token of tokens) {
+        const match = /^(\*|\d+|\d+-\d+)(?:\/(\d+))?$/.exec(token);
+        if (!match)
+            throw invalidCron(expression, `${fieldName} contains invalid token "${token}"`);
+        const step = match[2] === undefined ? 1 : Number(match[2]);
+        if (!Number.isSafeInteger(step) || step <= 0) {
+            throw invalidCron(expression, `${fieldName} step must be a positive integer`);
+        }
+        const range = match[1];
+        let start = min;
+        let end = max;
+        if (range !== '*') {
+            const rangeParts = range.split('-');
+            start = Number(rangeParts[0]);
+            end = Number(rangeParts[1] ?? rangeParts[0]);
+            if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < min || end > max) {
+                throw invalidCron(expression, `${fieldName} values must be between ${min} and ${max}`);
+            }
+            if (start > end)
+                throw invalidCron(expression, `${fieldName} range start must not exceed its end`);
+        }
+        for (let value = start; value <= end; value += step)
+            values.add(value);
+    }
+    return Object.freeze([...values].sort((left, right) => left - right));
+}
+function cronMatchesUtcDay(compiled, day) {
+    return compiled.daysOfMonth.includes(day.getUTCDate())
+        && compiled.months.includes(day.getUTCMonth() + 1)
+        && compiled.daysOfWeek.includes(day.getUTCDay());
+}
+function startOfUtcDay(value) {
+    const date = new Date(value);
+    date.setUTCHours(0, 0, 0, 0);
+    return date.getTime();
+}
+function validDateMs(date, label) {
+    const value = date.getTime();
+    if (!Number.isFinite(value))
+        throw new Error(`Invalid ${label}.`);
+    return value;
+}
+function invalidCron(expression, reason) {
+    return new Error(`Invalid cron expression "${expression}": ${reason}.`);
+}

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScheduledConversationExecutor = void 0;
 const scheduled_job_route_js_1 = require("./scheduled-job-route.js");
 const run_polling_js_1 = require("./run-polling.js");
+const thread_resolution_js_1 = require("./thread-resolution.js");
 const SCHEDULED_RUN_PERMISSION_MODE = 'bypassPermissions';
 class ScheduledConversationExecutor {
     options;
@@ -20,10 +21,7 @@ class ScheduledConversationExecutor {
             });
             await (0, run_polling_js_1.waitForRunCompletion)(this.options.store, sendResult.runId, timeoutMs, 'Scheduled');
             const thread = await workspaceRouter.getThread(target.threadId);
-            const replyText = [...thread.messages]
-                .reverse()
-                .find((message) => message.role === 'assistant' && message.kind === 'final')
-                ?.content;
+            const replyText = (0, thread_resolution_js_1.getLatestAssistantFinalContent)(thread);
             return {
                 threadId: target.threadId,
                 runId: sendResult.runId,

package/dist-electron/services/local-ai-core/src/scheduler/scheduled-job-application-service.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScheduledJobApplicationService = void 0;
+const legacy_automation_mappers_js_1 = require("../automation/legacy-automation-mappers.js");
+const job_id_js_1 = require("./job-id.js");
 const scheduled_job_route_js_1 = require("./scheduled-job-route.js");
 class ScheduledJobApplicationService {
     options;
@@ -8,16 +10,22 @@ class ScheduledJobApplicationService {
         this.options = options;
     }
     listJobs(workspaceId) {
-        return this.options.scheduler.listJobs(workspaceId);
+        return this.options.automations.list(workspaceId)
+            .filter((automation) => automation.originKind === 'scheduled-job')
+            .map((automation) => (0, legacy_automation_mappers_js_1.automationToScheduledJob)(automation, (0, legacy_automation_mappers_js_1.latestAutomationRun)(this.options.automations.listRuns(automation.id))));
     }
     getJob(jobId) {
-        return this.options.scheduler.getJob(jobId);
+        const resolved = this.resolveJobId(jobId);
+        const automation = resolved ? this.options.automations.get(resolved) : undefined;
+        return automation?.originKind === 'scheduled-job'
+            ? (0, legacy_automation_mappers_js_1.automationToScheduledJob)(automation, (0, legacy_automation_mappers_js_1.latestAutomationRun)(this.options.automations.listRuns(automation.id)))
+            : undefined;
     }
     createJob(input) {
-        return this.options.scheduler.createJob(this.resolveCreateInput(input));
+        return (0, legacy_automation_mappers_js_1.automationToScheduledJob)(this.options.automations.createFromLegacy((0, legacy_automation_mappers_js_1.scheduledJobToAutomationInput)(this.resolveCreateInput(input))));
     }
     createCronJob(input) {
-        return this.options.scheduler.createJob({
+        return this.createJob({
             workspaceId: input.workspaceId,
             platform: input.platform,
             route: this.resolveExplicitRoute(input.platform, input.route),
@@ -29,23 +37,45 @@ class ScheduledJobApplicationService {
         });
     }
     updateJob(jobId, input) {
-        return this.options.scheduler.updateJob(jobId, {
-            ...input,
-            ...(input.route ? { route: (0, scheduled_job_route_js_1.withoutThreadRoute)(input.route) } : {}),
+        this.options.automations.assertLegacyFacadesAvailable();
+        const existing = this.getRequiredJob(jobId);
+        const resolved = this.resolveRequiredJobId(jobId);
+        const merged = this.resolveCreateInput({
+            workspaceId: existing.workspaceId,
+            platform: existing.platform,
+            route: input.route ? (0, scheduled_job_route_js_1.withoutThreadRoute)(input.route) : existing.route,
+            executionMode: input.executionMode ?? existing.executionMode,
+            triggerType: input.triggerType ?? existing.triggerType,
+            cronExpr: input.cronExpr ?? existing.cronExpr,
+            runAt: input.runAt ?? existing.runAt,
+            promptTemplate: input.promptTemplate ?? existing.promptTemplate,
+            description: input.description ?? existing.description,
+            enabled: input.enabled ?? existing.enabled,
         });
+        const mapped = (0, legacy_automation_mappers_js_1.scheduledJobToAutomationInput)(merged);
+        const { workspaceId: _workspaceId, originKind: _originKind, ...update } = mapped;
+        return (0, legacy_automation_mappers_js_1.automationToScheduledJob)(this.options.automations.updateFromLegacy(resolved, update));
     }
     deleteJob(jobId) {
-        return this.options.scheduler.deleteJob(jobId);
+        this.options.automations.assertLegacyFacadesAvailable();
+        return this.options.automations.delete(this.resolveRequiredJobId(jobId));
     }
-    runJobNow(jobId) {
-        return this.options.scheduler.runJobNow(jobId);
+    async runJobNow(jobId) {
+        this.options.automations.assertLegacyFacadesAvailable();
+        const resolved = this.resolveRequiredJobId(jobId);
+        const evaluation = await this.options.automations.checkNow(resolved);
+        const run = this.options.automations.listRuns(resolved).find((candidate) => candidate.evaluationId === evaluation.id);
+        return (0, legacy_automation_mappers_js_1.automationToScheduledJobRun)(evaluation, run);
     }
     listJobRuns(jobId) {
-        return this.options.scheduler.listJobRuns(jobId);
+        const resolved = this.resolveRequiredJobId(jobId);
+        const runs = this.options.automations.listRuns(resolved);
+        const runsByEvaluationId = new Map(runs.map((run) => [run.evaluationId, run]));
+        return this.options.automations.listEvaluations(resolved).map((evaluation) => (0, legacy_automation_mappers_js_1.automationToScheduledJobRun)(evaluation, runsByEvaluationId.get(evaluation.id)));
     }
     listJobsForThread(threadId) {
         const binding = this.options.store.getPlatformThreadBindingByThreadId(threadId);
-        return this.options.scheduler
+        return this
             .listJobs()
             .filter((job) => job.route.threadId === threadId ||
             (binding ? (0, scheduled_job_route_js_1.scheduledJobMatchesPlatformBinding)(job, binding) : false));
@@ -80,5 +110,27 @@ class ScheduledJobApplicationService {
     resolveExplicitRoute(platform, route) {
         return (0, scheduled_job_route_js_1.routeWithPlatformInstance)((0, scheduled_job_route_js_1.withoutThreadRoute)(route), platform);
     }
+    resolveJobId(jobId) {
+        const direct = this.options.automations.get(jobId);
+        if (direct?.originKind === 'scheduled-job')
+            return direct.id;
+        const matches = this.options.automations.list()
+            .filter((automation) => automation.originKind === 'scheduled-job' && (0, job_id_js_1.toPublicScheduledJobId)(automation.id) === jobId);
+        if (matches.length > 1)
+            throw new Error(`Scheduled job id is ambiguous: ${jobId}`);
+        return matches[0]?.id || '';
+    }
+    resolveRequiredJobId(jobId) {
+        const resolved = this.resolveJobId(jobId);
+        if (!resolved)
+            throw new Error(`Scheduled job not found: ${jobId}`);
+        return resolved;
+    }
+    getRequiredJob(jobId) {
+        const job = this.getJob(jobId);
+        if (!job)
+            throw new Error(`Scheduled job not found: ${jobId}`);
+        return job;
+    }
 }
 exports.ScheduledJobApplicationService = ScheduledJobApplicationService;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchedulerService = void 0;
 const node_events_1 = require("node:events");
+const legacy_automation_mappers_js_1 = require("../automation/legacy-automation-mappers.js");
 const job_id_js_1 = require("./job-id.js");
 const scheduler_run_lifecycle_js_1 = require("./scheduler-run-lifecycle.js");
 const SCHEDULER_AUTO_DISABLE_THRESHOLD = 5;
@@ -29,10 +30,7 @@ class SchedulerService extends node_events_1.EventEmitter {
         this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: run });
     }
     async start() {
-        await this.tick();
-        this.timer = setInterval(() => {
-            void this.tick();
-        }, 1000);
+        // Unified AutomationService owns scheduled-job execution after migration.
     }
     async stop() {
         if (this.timer) {
@@ -41,29 +39,88 @@ class SchedulerService extends node_events_1.EventEmitter {
         }
     }
     listJobs(workspaceId) {
+        const automations = this.options.automations;
+        if (automations) {
+            return automations.list(workspaceId)
+                .filter((automation) => automation.originKind === 'scheduled-job')
+                .map((automation) => (0, legacy_automation_mappers_js_1.automationToScheduledJob)(automation, (0, legacy_automation_mappers_js_1.latestAutomationRun)(automations.listRuns(automation.id))));
+        }
         return this.options.store.listScheduledJobs(workspaceId);
     }
     getJob(jobId) {
+        if (this.options.automations) {
+            const resolved = this.resolveJobId(jobId);
+            const automation = resolved ? this.options.automations.get(resolved) : undefined;
+            return automation?.originKind === 'scheduled-job'
+                ? (0, legacy_automation_mappers_js_1.automationToScheduledJob)(automation, (0, legacy_automation_mappers_js_1.latestAutomationRun)(this.options.automations.listRuns(automation.id)))
+                : undefined;
+        }
         const resolvedJobId = this.resolveJobId(jobId);
         return resolvedJobId ? this.options.store.getScheduledJob(resolvedJobId) : undefined;
     }
     createJob(input) {
+        if (this.options.automations) {
+            if (!input.platform || !input.route)
+                throw new Error('Scheduled job creation requires a resolved platform and route.');
+            return (0, legacy_automation_mappers_js_1.automationToScheduledJob)(this.options.automations.createFromLegacy((0, legacy_automation_mappers_js_1.scheduledJobToAutomationInput)({
+                ...input,
+                platform: input.platform,
+                route: input.route,
+            })));
+        }
         const job = this.options.store.createScheduledJob(input);
         this.emitJob(job);
         return job;
     }
     updateJob(jobId, input) {
+        if (this.options.automations) {
+            this.options.automations.assertLegacyFacadesAvailable();
+            const existing = this.getJob(jobId);
+            if (!existing)
+                throw new Error(`Scheduled job not found: ${jobId}`);
+            const mapped = (0, legacy_automation_mappers_js_1.scheduledJobToAutomationInput)({
+                workspaceId: existing.workspaceId,
+                platform: existing.platform,
+                route: input.route ?? existing.route,
+                executionMode: input.executionMode ?? existing.executionMode,
+                triggerType: input.triggerType ?? existing.triggerType,
+                cronExpr: input.cronExpr ?? existing.cronExpr,
+                runAt: input.runAt ?? existing.runAt,
+                promptTemplate: input.promptTemplate ?? existing.promptTemplate,
+                description: input.description ?? existing.description,
+                enabled: input.enabled ?? existing.enabled,
+            });
+            const { workspaceId: _workspaceId, originKind: _originKind, ...update } = mapped;
+            return (0, legacy_automation_mappers_js_1.automationToScheduledJob)(this.options.automations.updateFromLegacy(this.resolveRequiredJobId(jobId), update));
+        }
         const job = this.options.store.updateScheduledJob(this.resolveRequiredJobId(jobId), input);
         this.emitJob(job);
         return job;
     }
     deleteJob(jobId) {
+        if (this.options.automations) {
+            this.options.automations.assertLegacyFacadesAvailable();
+            return this.options.automations.delete(this.resolveRequiredJobId(jobId));
+        }
         return this.options.store.deleteScheduledJob(this.resolveRequiredJobId(jobId));
     }
     listJobRuns(jobId) {
+        if (this.options.automations) {
+            const resolved = this.resolveRequiredJobId(jobId);
+            const runs = this.options.automations.listRuns(resolved);
+            const runsByEvaluationId = new Map(runs.map((run) => [run.evaluationId, run]));
+            return this.options.automations.listEvaluations(resolved).map((evaluation) => (0, legacy_automation_mappers_js_1.automationToScheduledJobRun)(evaluation, runsByEvaluationId.get(evaluation.id)));
+        }
         return this.options.store.listScheduledJobRuns(this.resolveRequiredJobId(jobId));
     }
     async runJobNow(jobId) {
+        if (this.options.automations) {
+            this.options.automations.assertLegacyFacadesAvailable();
+            const resolved = this.resolveRequiredJobId(jobId);
+            const evaluation = await this.options.automations.checkNow(resolved);
+            const run = this.options.automations.listRuns(resolved).find((candidate) => candidate.evaluationId === evaluation.id);
+            return (0, legacy_automation_mappers_js_1.automationToScheduledJobRun)(evaluation, run);
+        }
         const resolvedJobId = this.resolveRequiredJobId(jobId);
         const job = this.options.store.getScheduledJob(resolvedJobId);
         if (!job) {
@@ -72,6 +129,16 @@ class SchedulerService extends node_events_1.EventEmitter {
         return this.executeJob(job, new Date().toISOString(), true);
     }
     resolveJobId(jobId) {
+        if (this.options.automations) {
+            const direct = this.options.automations.get(jobId);
+            if (direct?.originKind === 'scheduled-job')
+                return direct.id;
+            const matches = this.options.automations.list()
+                .filter((automation) => automation.originKind === 'scheduled-job' && (0, job_id_js_1.toPublicScheduledJobId)(automation.id) === jobId);
+            if (matches.length > 1)
+                throw new Error(`Scheduled job id is ambiguous: ${jobId}`);
+            return matches[0]?.id || '';
+        }
         if (this.options.store.getScheduledJob(jobId)) {
             return jobId;
         }

package/dist-electron/services/local-ai-core/src/scheduler/thread-resolution.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.threadExists = threadExists;
+exports.getLatestAssistantFinalContent = getLatestAssistantFinalContent;
 async function threadExists(router, threadId) {
     try {
         await router.getThread(threadId);
@@ -10,3 +11,12 @@ async function threadExists(router, threadId) {
         return false;
     }
 }
+function getLatestAssistantFinalContent(thread) {
+    for (let i = thread.messages.length - 1; i >= 0; i -= 1) {
+        const message = thread.messages[i];
+        if (message && message.role === 'assistant' && message.kind === 'final') {
+            return message.content;
+        }
+    }
+    return undefined;
+}