@kafca/agentdock 0.1.35 → 0.1.37

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

@@ -1,34 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalScheduleAdapter = void 0;
-const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'interrupted']);
-const SCHEDULED_RUN_PERMISSION_MODE = 'bypassPermissions';
+const scheduled_conversation_executor_js_1 = require("./scheduled-conversation-executor.js");
 class LocalScheduleAdapter {
     options;
+    executor;
     deliveryTargets = ['local'];
     constructor(options) {
         this.options = options;
+        this.executor = new scheduled_conversation_executor_js_1.ScheduledConversationExecutor({
+            store: options.store,
+            getWorkspaceRouter: options.getWorkspaceRouter,
+        });
     }
     supports(job) {
         return job.platform === 'local' && (job.route.type === 'local.thread' || job.route.type === 'thread');
     }
     async execute(context) {
         const { job } = context;
-        const workspaceRouter = this.options.getWorkspaceRouter();
-        const threadId = await this.resolveThread(job);
-        const sendResult = await workspaceRouter.sendThreadMessage(threadId, job.promptTemplate, {
-            permissionMode: SCHEDULED_RUN_PERMISSION_MODE,
-        });
-        await this.waitForRun(sendResult.runId);
-        const thread = await workspaceRouter.getThread(threadId);
-        const replyText = [...thread.messages]
-            .reverse()
-            .find((message) => message.role === 'assistant' && message.kind === 'final')
-            ?.content;
+        const execution = await this.executor.execute(job, job.promptTemplate, this.createExecutionPolicy());
+        return {
+            threadId: execution.threadId,
+            runId: execution.runId,
+            replyText: execution.replyText,
+            deliveryMode: 'thread-only',
+            deliveryStatus: 'succeeded',
+        };
+    }
+    createExecutionPolicy() {
         return {
-            threadId,
-            runId: sendResult.runId,
-            replyText,
+            resolveTarget: async (job) => ({
+                kind: 'local:thread',
+                threadId: await this.resolveThread(job),
+                workspaceId: job.workspaceId,
+                platform: job.platform,
+                route: job.route,
+            }),
         };
     }
     async resolveThread(job) {
@@ -54,19 +61,5 @@ class LocalScheduleAdapter {
             return false;
         }
     }
-    async waitForRun(runId, timeoutMs = 15 * 60 * 1000) {
-        const startedAt = Date.now();
-        while (Date.now() - startedAt < timeoutMs) {
-            const run = this.options.store.getRun(runId);
-            if (run && TERMINAL_RUN_STATES.has(run.status)) {
-                if (run.status !== 'completed') {
-                    throw new Error(`Scheduled run finished with status ${run.status}`);
-                }
-                return;
-            }
-            await new Promise((resolve) => setTimeout(resolve, 300));
-        }
-        throw new Error(`Timed out waiting for scheduled run ${runId}`);
-    }
 }
 exports.LocalScheduleAdapter = LocalScheduleAdapter;

package/dist-electron/services/local-ai-core/src/scheduler/scheduled-bridge-session.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduledBridgeSession = void 0;
+class ScheduledBridgeSession {
+    static async open(input) {
+        const sessionKey = input.workspaceRouter.getThreadSessionKey(input.threadId);
+        const unregister = await input.getChannelRuntime().registerScheduledThreadBridge?.({
+            workspaceId: input.job.workspaceId,
+            platform: input.job.platform,
+            route: input.job.route,
+            threadId: input.threadId,
+            sessionKey,
+        });
+        return {
+            mode: 'bridge-stream',
+            workspaceId: input.job.workspaceId,
+            platform: input.job.platform,
+            route: input.job.route,
+            threadId: input.threadId,
+            sessionKey,
+            close: async () => {
+                await unregister?.();
+            },
+        };
+    }
+}
+exports.ScheduledBridgeSession = ScheduledBridgeSession;

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

@@ -13,12 +13,13 @@ class ScheduledConversationExecutor {
         const target = await policy.resolveTarget(job);
         await policy.beforeExecute?.(target, job);
         try {
-            const sendResult = await this.options.workspaceRouter.sendThreadMessage(target.threadId, prompt, {
+            const workspaceRouter = this.options.getWorkspaceRouter();
+            const sendResult = await workspaceRouter.sendThreadMessage(target.threadId, prompt, {
                 permissionMode: SCHEDULED_RUN_PERMISSION_MODE,
                 runtimeEnv: this.buildScheduledRuntimeEnv(target),
             });
             await this.waitForRun(sendResult.runId, timeoutMs);
-            const thread = await this.options.workspaceRouter.getThread(target.threadId);
+            const thread = await workspaceRouter.getThread(target.threadId);
             const replyText = [...thread.messages]
                 .reverse()
                 .find((message) => message.role === 'assistant' && message.kind === 'final')

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

@@ -10,13 +10,18 @@ class SchedulerRunLifecycle {
         const skipped = this.options.store.createScheduledJobRun(job.id, 'skipped', {
             triggeredAt,
             error,
+            deliveryStatus: 'skipped',
+            deliveryError: error,
         });
         this.options.emitRun(skipped);
         this.emitCurrentJob(job.id);
         return skipped;
     }
     markQueued(job, triggeredAt) {
-        const run = this.options.store.createScheduledJobRun(job.id, 'queued', { triggeredAt });
+        const run = this.options.store.createScheduledJobRun(job.id, 'queued', {
+            triggeredAt,
+            deliveryStatus: 'pending',
+        });
         this.options.emitRun(run);
         return run;
     }
@@ -35,6 +40,11 @@ class SchedulerRunLifecycle {
             threadId: result.threadId,
             runId: result.runId,
             platformMessageId: result.platformMessageId,
+            platformMessageIds: result.platformMessageIds,
+            deliveryMode: result.deliveryMode,
+            deliveryStatus: result.deliveryStatus || 'succeeded',
+            deliveryError: result.deliveryError || '',
+            lastBridgeEventAt: result.lastBridgeEventAt,
             error: '',
         });
         if (disableOnceJob) {
@@ -49,6 +59,8 @@ class SchedulerRunLifecycle {
             status: 'failed',
             finishedAt: new Date().toISOString(),
             error,
+            deliveryStatus: 'failed',
+            deliveryError: error,
         });
         this.options.emitRun(failed);
         this.emitCurrentJob(jobId);

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

@@ -98,7 +98,7 @@ class SchedulerService extends node_events_1.EventEmitter {
                 if (!this.isDue(job, now)) {
                     continue;
                 }
-                await this.executeJob(job, now.toISOString(), false);
+                void this.executeJob(job, now.toISOString(), false);
             }
         }
         finally {

package/dist-electron/services/local-ai-core/src/scheduler/weixin-execution-policies.js

@@ -1,66 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createWeixinExecutionPolicy = createWeixinExecutionPolicy;
+const channel_execution_policy_js_1 = require("./channel-execution-policy.js");
 function createWeixinExecutionPolicy(job, options, resolveSameThread) {
-    if (job.executionMode === 'side-thread') {
-        return new WeixinSideThreadExecutionPolicy(options);
-    }
-    return new WeixinSameThreadExecutionPolicy(options, resolveSameThread);
-}
-class WeixinSameThreadExecutionPolicy {
-    options;
-    resolveSameThread;
-    constructor(options, resolveSameThread) {
-        this.options = options;
-        this.resolveSameThread = resolveSameThread;
-    }
-    async resolveTarget(job) {
-        return {
-            kind: 'thread',
-            threadId: await this.resolveSameThread(job),
-            workspaceId: job.workspaceId,
-            platform: job.platform,
-            route: job.route,
-        };
-    }
-    beforeExecute(target) {
-        this.options.getChannelRuntime().muteThreadBridge?.(target.threadId);
-    }
-    afterExecute(target) {
-        this.options.getChannelRuntime().unmuteThreadBridge?.(target.threadId);
-    }
-}
-class WeixinSideThreadExecutionPolicy {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    async resolveTarget(job) {
-        const title = `[Scheduled] ${job.description || job.id}`;
-        const existing = (await this.options.workspaceRouter.listThreads(job.workspaceId))
-            .find((thread) => thread.title === title);
-        if (existing) {
-            return {
-                kind: 'thread',
-                threadId: existing.id,
-                workspaceId: job.workspaceId,
-                platform: job.platform,
-                route: job.route,
-            };
-        }
-        const created = await this.options.workspaceRouter.createThread(job.workspaceId, title);
-        return {
-            kind: 'thread',
-            threadId: created.id,
-            workspaceId: job.workspaceId,
-            platform: job.platform,
-            route: job.route,
-        };
-    }
-    beforeExecute(target) {
-        this.options.getChannelRuntime().muteThreadBridge?.(target.threadId);
-    }
-    afterExecute(target) {
-        this.options.getChannelRuntime().unmuteThreadBridge?.(target.threadId);
-    }
+    return (0, channel_execution_policy_js_1.createChannelExecutionPolicy)(job, options, {
+        platformBase: 'weixin',
+        resolveSameThread,
+        sideThreadTitle: (nextJob) => `[Scheduled:Weixin] ${nextJob.description || nextJob.id}`,
+        legacySideThreadTitles: (nextJob) => [`[Scheduled] ${nextJob.description || nextJob.id}`],
+    });
 }

package/dist-electron/services/local-ai-core/src/scheduler/weixin-schedule-adapter.js

@@ -12,7 +12,7 @@ class WeixinScheduleAdapter {
         this.options = options;
         this.executor = new scheduled_conversation_executor_js_1.ScheduledConversationExecutor({
             store: options.store,
-            workspaceRouter: options.getWorkspaceRouter(),
+            getWorkspaceRouter: options.getWorkspaceRouter,
         });
     }
     supports(job) {
@@ -26,22 +26,13 @@ class WeixinScheduleAdapter {
             getChannelRuntime: this.options.getChannelRuntime,
         }, (nextJob) => this.resolveThread(nextJob));
         const execution = await this.executor.execute(job, job.promptTemplate, executionPolicy);
-        let platformMessageId = '';
-        if (execution.replyText) {
-            const channelRuntime = this.options.getChannelRuntime();
-            if (!channelRuntime.sendScheduledMessage) {
-                throw new Error('WeChat channel runtime does not support scheduled delivery.');
-            }
-            platformMessageId = await channelRuntime.sendScheduledMessage(job.workspaceId, (0, scheduled_job_route_js_1.routeWithPlatformInstance)((0, scheduled_job_route_js_1.withoutThreadRoute)(job.route), job.platform), execution.replyText);
-            if (!platformMessageId) {
-                throw new Error('WeChat gateway did not return a message id for scheduled delivery.');
-            }
-        }
         return {
             threadId: execution.threadId,
             runId: execution.runId,
             replyText: execution.replyText,
-            platformMessageId: platformMessageId || undefined,
+            deliveryMode: 'bridge-stream',
+            deliveryStatus: 'succeeded',
+            lastBridgeEventAt: new Date().toISOString(),
         };
     }
     async resolveThread(job) {

package/dist-electron/tests/electron/workspace-task-store.test.js

@@ -10,6 +10,7 @@ const node_path_1 = require("node:path");
 const node_os_1 = require("node:os");
 const local_core_acp_store_js_1 = require("../../services/local-ai-core/src/acp/local-core-acp-store.js");
 const local_core_acp_session_coordinator_js_1 = require("../../services/local-ai-core/src/acp/local-core-acp-session-coordinator.js");
+const local_core_acp_turn_coordinator_js_1 = require("../../services/local-ai-core/src/acp/local-core-acp-turn-coordinator.js");
 const scheduler_service_js_1 = require("../../services/local-ai-core/src/scheduler/scheduler-service.js");
 const lark_schedule_adapter_js_1 = require("../../services/local-ai-core/src/scheduler/lark-schedule-adapter.js");
 const bootstrap_js_1 = require("../../services/local-ai-core/src/kernel/bootstrap.js");
@@ -165,10 +166,12 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
             enabled: true,
         });
         let sentThreadId = '';
-        let deliveredRoute;
+        let registeredBridge;
+        let unregisteredBridge = false;
         const adapter = new lark_schedule_adapter_js_1.LarkScheduleAdapter({
             store,
             getWorkspaceRouter: () => ({
+                getThreadSessionKey: (threadId) => `session:${threadId}`,
                 getThread: async (threadId) => ({
                     id: threadId,
                     workspaceId: 'workspace-a',
@@ -191,23 +194,101 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
                 },
             }),
             getChannelRuntime: () => ({
-                muteThreadBridge: () => { },
-                unmuteThreadBridge: () => { },
-                sendScheduledMessage: async (_workspaceId, route) => {
-                    deliveredRoute = route;
-                    return 'platform-message-1';
+                registerScheduledThreadBridge: (input) => {
+                    registeredBridge = input;
+                    return () => {
+                        unregisteredBridge = true;
+                    };
+                },
+                sendScheduledMessage: async () => {
+                    throw new Error('scheduled Lark replies should be delivered through bridge events');
                 },
             }),
         });
         const result = await adapter.execute({ job, triggeredAt: now });
         strict_1.default.equal(sentThreadId, latestThread.id);
         strict_1.default.equal(result.threadId, latestThread.id);
-        strict_1.default.equal(result.platformMessageId, 'platform-message-1');
-        strict_1.default.deepEqual(deliveredRoute, {
-            type: 'channel.chat',
-            channelId: 'chat-1',
-            participantId: 'user-1',
+        strict_1.default.equal('platformMessageId' in result, false);
+        strict_1.default.deepEqual(registeredBridge, {
+            workspaceId: 'workspace-a',
+            platform: 'lark',
+            route: { type: 'channel.chat', channelId: 'chat-1', participantId: 'user-1', threadId: oldThread.id },
+            threadId: latestThread.id,
+            sessionKey: `session:${latestThread.id}`,
         });
+        strict_1.default.equal(unregisteredBridge, true);
+        store.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('Lark scheduled execution resolves workspace router at execution time', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-lark-lazy-router-'));
+    try {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        const thread = store.createThread('workspace-a', 'Lark thread');
+        const now = new Date().toISOString();
+        store.upsertPlatformThreadBinding({
+            workspace_id: 'workspace-a',
+            platform: 'lark:lark-1',
+            chat_id: 'chat-1',
+            platform_user_id: 'user-1',
+            thread_id: thread.id,
+            last_platform_message_id: null,
+            created_at: now,
+            updated_at: now,
+        });
+        const job = store.createScheduledJob({
+            workspaceId: 'workspace-a',
+            platform: 'lark:lark-1',
+            route: { type: 'channel.chat', channelId: 'chat-1', participantId: 'user-1' },
+            executionMode: 'same-thread',
+            triggerType: 'cron',
+            cronExpr: '30 18 * * *',
+            promptTemplate: 'ping',
+            description: 'bound lark task',
+            enabled: true,
+        });
+        let sentThreadId = '';
+        let workspaceRouter;
+        const adapter = new lark_schedule_adapter_js_1.LarkScheduleAdapter({
+            store,
+            getWorkspaceRouter: () => workspaceRouter,
+            getChannelRuntime: () => ({
+                registerScheduledThreadBridge: () => () => { },
+                sendScheduledMessage: async () => {
+                    throw new Error('scheduled Lark replies should be delivered through bridge events');
+                },
+            }),
+        });
+        workspaceRouter = {
+            getThreadSessionKey: (threadId) => `session:${threadId}`,
+            getThread: async (threadId) => ({
+                id: threadId,
+                workspaceId: 'workspace-a',
+                title: 'Thread',
+                live: false,
+                updatedAt: now,
+                createdAt: now,
+                historyCount: 1,
+                excerpt: '',
+                bridgeSessionKey: '',
+                agentType: 'localcore-acp',
+                selectedKnowledgeBaseIds: [],
+                pendingPermissionRequest: null,
+                messages: [{ id: 'message-1', role: 'assistant', kind: 'final', content: 'pong', timestamp: now }],
+            }),
+            sendThreadMessage: async (threadId) => {
+                sentThreadId = threadId;
+                store.updateRun('run-1', threadId, 'completed');
+                return { runId: 'run-1' };
+            },
+        };
+        const result = await adapter.execute({ job, triggeredAt: now });
+        strict_1.default.equal(sentThreadId, thread.id);
+        strict_1.default.equal(result.threadId, thread.id);
+        strict_1.default.equal('platformMessageId' in result, false);
         store.close();
     }
     finally {
@@ -241,10 +322,11 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
             description: 'bound lark task',
             enabled: true,
         });
-        let deliveredRoute;
+        let registeredBridge;
         const adapter = new lark_schedule_adapter_js_1.LarkScheduleAdapter({
             store,
             getWorkspaceRouter: () => ({
+                getThreadSessionKey: (threadId) => `session:${threadId}`,
                 getThread: async (threadId) => ({
                     id: threadId,
                     workspaceId: 'workspace-a',
@@ -270,22 +352,24 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
                 },
             }),
             getChannelRuntime: () => ({
-                muteThreadBridge: () => { },
-                unmuteThreadBridge: () => { },
-                sendScheduledMessage: async (_workspaceId, route) => {
-                    deliveredRoute = route;
-                    return 'platform-message-1';
+                registerScheduledThreadBridge: (input) => {
+                    registeredBridge = input;
+                    return () => { };
+                },
+                sendScheduledMessage: async () => {
+                    throw new Error('scheduled Lark replies should be delivered through bridge events');
                 },
             }),
         });
         const result = await adapter.execute({ job, triggeredAt: now });
         strict_1.default.equal(result.threadId, thread.id);
-        strict_1.default.equal(result.platformMessageId, 'platform-message-1');
-        strict_1.default.deepEqual(deliveredRoute, {
-            type: 'channel.chat',
-            channelId: 'chat-1',
-            instanceId: 'lark-1',
-            participantId: 'user-1',
+        strict_1.default.equal('platformMessageId' in result, false);
+        strict_1.default.deepEqual(registeredBridge, {
+            workspaceId: 'workspace-a',
+            platform: 'lark:lark-1',
+            route: { type: 'channel.chat', channelId: 'chat-1', participantId: 'user-1' },
+            threadId: thread.id,
+            sessionKey: `session:${thread.id}`,
         });
         store.close();
     }
@@ -421,6 +505,59 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('ACP permission requests honor scheduled session permission override', () => {
+    const sentPayloads = [];
+    let approvalCreated = false;
+    let awaitingInput = false;
+    const coordinator = new local_core_acp_turn_coordinator_js_1.LocalCoreAcpTurnCoordinator({
+        emitBridge: () => { },
+        appendMessage: () => { },
+        updateRunStatus: () => {
+            awaitingInput = true;
+        },
+        createApprovalRequest: () => {
+            approvalCreated = true;
+            return 'approval-1';
+        },
+        getThreadAgentMode: () => 'default',
+        sendRaw: (_session, payload) => {
+            sentPayloads.push(payload);
+            return true;
+        },
+    });
+    coordinator.handleAgentRequest({
+        threadId: 'thread-1',
+        bridgeSessionKey: 'bridge-1',
+        currentRunId: 'run-1',
+        currentTurn: null,
+        pendingPermissionByRun: new Map(),
+        schedulerJobCreatedByRun: new Map(),
+        launchPermissionMode: 'bypassPermissions',
+    }, {
+        jsonrpc: '2.0',
+        id: 42,
+        method: 'session/request_permission',
+        params: {
+            toolCall: { title: 'Write AI早报/AI早报-2026-05-08.md' },
+            options: [
+                { optionId: 'deny', name: 'Deny', kind: 'deny' },
+                { optionId: 'allow', name: 'Allow', kind: 'allow' },
+            ],
+        },
+    });
+    strict_1.default.equal(approvalCreated, false);
+    strict_1.default.equal(awaitingInput, false);
+    strict_1.default.deepEqual(sentPayloads[0], {
+        jsonrpc: '2.0',
+        id: 42,
+        result: {
+            outcome: {
+                outcome: 'selected',
+                optionId: 'allow',
+            },
+        },
+    });
+});
 (0, node_test_1.default)('scheduler uses short ids for new jobs and resolves legacy full ids by short id', () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-id-store-'));
     try {
@@ -467,6 +604,78 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('scheduler dispatches due jobs without waiting for long-running jobs', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-dispatch-'));
+    try {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        store.createScheduledJob({
+            workspaceId: 'workspace-a',
+            platform: 'local',
+            route: { type: 'local.thread', channelId: 'workspace-a', threadId: 'thread-1' },
+            executionMode: 'side-thread',
+            triggerType: 'cron',
+            cronExpr: '* * * * *',
+            promptTemplate: 'slow',
+            description: 'slow job',
+            enabled: true,
+        });
+        store.createScheduledJob({
+            workspaceId: 'workspace-a',
+            platform: 'local',
+            route: { type: 'local.thread', channelId: 'workspace-a', threadId: 'thread-2' },
+            executionMode: 'side-thread',
+            triggerType: 'cron',
+            cronExpr: '* * * * *',
+            promptTemplate: 'fast',
+            description: 'fast job',
+            enabled: true,
+        });
+        let releaseSlow;
+        const slowDone = new Promise((resolve) => {
+            releaseSlow = resolve;
+        });
+        const started = [];
+        let slowJobId = '';
+        const scheduler = new scheduler_service_js_1.SchedulerService({
+            store,
+            triggers: [{
+                    triggerTypes: ['cron'],
+                    supports: () => true,
+                    isDue: () => true,
+                }],
+            executors: [{
+                    deliveryTargets: ['local'],
+                    supports: () => true,
+                    execute: async ({ job }) => {
+                        const isFirstStartedJob = started.length === 0;
+                        started.push(job.id);
+                        if (isFirstStartedJob) {
+                            slowJobId = job.id;
+                            await slowDone;
+                        }
+                        return {
+                            threadId: String(job.route.threadId || job.id),
+                            runId: `run:${job.id}`,
+                        };
+                    },
+                }],
+            eventBus: { emit: () => { }, on: () => () => { } },
+        });
+        await scheduler.tick();
+        await new Promise((resolve) => setImmediate(resolve));
+        strict_1.default.equal(started.length, 2);
+        const fastJobId = started.find((id) => id !== slowJobId);
+        strict_1.default.equal(store.listScheduledJobRuns(slowJobId)[0]?.status, 'running');
+        strict_1.default.equal(store.listScheduledJobRuns(fastJobId)[0]?.status, 'succeeded');
+        releaseSlow();
+        await new Promise((resolve) => setImmediate(resolve));
+        strict_1.default.equal(store.listScheduledJobRuns(slowJobId)[0]?.status, 'succeeded');
+        store.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('scheduled jobs normalize enum-like input before persistence', () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-enum-store-'));
     try {
@@ -563,10 +772,21 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
             description: 'daily ping',
             enabled: true,
         });
-        const run = store.createScheduledJobRun(job.id, 'complete');
+        const run = store.createScheduledJobRun(job.id, 'complete', {
+            deliveryMode: 'bridge-stream',
+            deliveryStatus: 'streaming',
+            platformMessageIds: ['msg-1', 'msg-2'],
+            lastBridgeEventAt: '2026-04-22T06:00:03.000Z',
+        });
         strict_1.default.equal(run.status, 'succeeded');
+        strict_1.default.equal(run.deliveryMode, 'bridge-stream');
+        strict_1.default.equal(run.deliveryStatus, 'streaming');
+        strict_1.default.deepEqual(run.platformMessageIds, ['msg-1', 'msg-2']);
+        strict_1.default.equal(run.lastBridgeEventAt, '2026-04-22T06:00:03.000Z');
         const skipped = store.updateScheduledJobRun(run.id, { status: 'cancelled' });
         strict_1.default.equal(skipped.status, 'skipped');
+        strict_1.default.equal(skipped.deliveryMode, 'bridge-stream');
+        strict_1.default.deepEqual(skipped.platformMessageIds, ['msg-1', 'msg-2']);
         strict_1.default.equal(store.getScheduledJob(job.id)?.lastStatus, 'skipped');
         store.close();
     }