discoclaw 0.1.0

package/dist/discord/actions-crons.test.js

@@ -0,0 +1,499 @@
+import { describe, expect, it, vi } from 'vitest';
+import { executeCronAction, CRON_ACTION_TYPES } from './actions-crons.js';
+function makeMockRuntime(output) {
+    return {
+        id: 'other',
+        capabilities: new Set(),
+        async *invoke() {
+            yield { type: 'text_final', text: output };
+        },
+    };
+}
+function mockLog() {
+    return { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+}
+function makeRecord(overrides) {
+    return {
+        cronId: 'cron-test0001',
+        threadId: 'thread-1',
+        runCount: 5,
+        lastRunAt: '2025-01-15T10:00:00Z',
+        lastRunStatus: 'success',
+        cadence: 'daily',
+        purposeTags: ['monitoring'],
+        disabled: false,
+        model: 'haiku',
+        ...overrides,
+    };
+}
+function makeStatsStore(records) {
+    const store = {};
+    for (const r of records)
+        store[r.cronId] = r;
+    return {
+        getStore: () => ({ version: 1, updatedAt: Date.now(), jobs: store }),
+        getRecord: (id) => store[id],
+        getRecordByThreadId: (tid) => Object.values(store).find((r) => r.threadId === tid),
+        upsertRecord: vi.fn(async (cronId, threadId, updates) => {
+            const existing = store[cronId] ?? makeRecord({ cronId, threadId });
+            if (updates)
+                Object.assign(existing, updates);
+            store[cronId] = existing;
+            return existing;
+        }),
+        recordRun: vi.fn(async () => { }),
+        removeRecord: vi.fn(async (cronId) => { delete store[cronId]; return true; }),
+        removeByThreadId: vi.fn(async () => true),
+    };
+}
+function makeScheduler(jobs) {
+    const jobMap = new Map(jobs.map((j) => [j.id, { id: j.id, cronId: j.cronId, threadId: j.threadId, guildId: 'guild-1', name: j.name, def: { schedule: j.schedule, timezone: 'UTC', channel: 'general', prompt: 'Test' }, cron: null, running: false }]));
+    return {
+        register: vi.fn((...args) => {
+            const newJob = { id: args[0], cronId: args[5] ?? '', threadId: args[1], guildId: args[2], name: args[3], def: args[4], cron: null, running: false };
+            jobMap.set(args[0], newJob);
+            return newJob;
+        }),
+        unregister: vi.fn((id) => {
+            const existed = jobMap.has(id);
+            jobMap.delete(id);
+            return existed;
+        }),
+        disable: vi.fn((id) => jobMap.has(id)),
+        enable: vi.fn((id) => jobMap.has(id)),
+        getJob: (id) => jobMap.get(id),
+        listJobs: () => Array.from(jobMap.values()).map((j) => ({ id: j.id, name: j.name, schedule: j.def.schedule, timezone: j.def.timezone, nextRun: null })),
+    };
+}
+function makeActionCtx() {
+    return {
+        guild: { id: 'guild-1' },
+        client: {},
+        channelId: 'ch-1',
+        messageId: 'msg-1',
+    };
+}
+function makeCronCtx(overrides) {
+    const forumThread = { id: 'new-thread', isThread: () => true, send: vi.fn(), fetchStarterMessage: vi.fn() };
+    const forum = {
+        id: 'forum-1',
+        type: 15, // ChannelType.GuildForum
+        threads: {
+            create: vi.fn(async () => forumThread),
+        },
+    };
+    const client = {
+        channels: {
+            cache: {
+                get: vi.fn((id) => {
+                    if (id === 'forum-1')
+                        return forum;
+                    if (id === 'thread-1')
+                        return { id: 'thread-1', isThread: () => true, send: vi.fn(), fetchStarterMessage: vi.fn(), setArchived: vi.fn() };
+                    return undefined;
+                }),
+            },
+            fetch: vi.fn(async (id) => id === 'forum-1' ? forum : null),
+        },
+        user: { id: 'bot-user' },
+    };
+    return {
+        scheduler: makeScheduler([{ id: 'thread-1', threadId: 'thread-1', cronId: 'cron-test0001', name: 'Test Job', schedule: '0 7 * * *' }]),
+        client: client,
+        forumId: 'forum-1',
+        tagMapPath: '/tmp/tags.json',
+        tagMap: { monitoring: 'tag-1', daily: 'tag-2' },
+        statsStore: makeStatsStore([makeRecord()]),
+        runtime: makeMockRuntime('monitoring'),
+        autoTag: false,
+        autoTagModel: 'haiku',
+        cwd: '/tmp',
+        allowUserIds: new Set(['user-1']),
+        log: mockLog(),
+        pendingThreadIds: new Set(),
+        ...overrides,
+    };
+}
+// Mock reloadCronTagMapInPlace (best-effort reload in actions)
+vi.mock('../cron/tag-map.js', () => ({
+    reloadCronTagMapInPlace: vi.fn(async () => 2),
+}));
+// Mock ensureStatusMessage
+vi.mock('../cron/discord-sync.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        ensureStatusMessage: vi.fn(async () => 'msg-1'),
+    };
+});
+describe('CRON_ACTION_TYPES', () => {
+    it('includes all cron action types', () => {
+        expect(CRON_ACTION_TYPES.has('cronCreate')).toBe(true);
+        expect(CRON_ACTION_TYPES.has('cronUpdate')).toBe(true);
+        expect(CRON_ACTION_TYPES.has('cronList')).toBe(true);
+        expect(CRON_ACTION_TYPES.has('cronShow')).toBe(true);
+        expect(CRON_ACTION_TYPES.has('cronPause')).toBe(true);
+        expect(CRON_ACTION_TYPES.has('cronResume')).toBe(true);
+        expect(CRON_ACTION_TYPES.has('cronDelete')).toBe(true);
+        expect(CRON_ACTION_TYPES.has('cronTrigger')).toBe(true);
+        expect(CRON_ACTION_TYPES.has('cronSync')).toBe(true);
+    });
+});
+describe('executeCronAction', () => {
+    it('cronList returns registered jobs', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronList' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.summary).toContain('Test Job');
+            expect(result.summary).toContain('cron-test0001');
+        }
+    });
+    it('cronList returns empty message when no jobs', async () => {
+        const cronCtx = makeCronCtx({ scheduler: makeScheduler([]) });
+        const result = await executeCronAction({ type: 'cronList' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok)
+            expect(result.summary).toContain('No cron jobs');
+    });
+    it('cronShow returns details for known cronId', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronShow', cronId: 'cron-test0001' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.summary).toContain('cron-test0001');
+            expect(result.summary).toContain('haiku');
+            expect(result.summary).toContain('monitoring');
+        }
+    });
+    it('cronShow returns error for unknown cronId', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronShow', cronId: 'cron-nope' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(false);
+    });
+    it('cronPause disables the job', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronPause', cronId: 'cron-test0001' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        expect(cronCtx.scheduler.disable).toHaveBeenCalledWith('thread-1');
+    });
+    it('cronPause returns error when scheduler job is missing', async () => {
+        const cronCtx = makeCronCtx({ scheduler: makeScheduler([]) });
+        const result = await executeCronAction({ type: 'cronPause', cronId: 'cron-test0001' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error).toContain('not registered in scheduler');
+    });
+    it('cronResume enables the job', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronResume', cronId: 'cron-test0001' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        expect(cronCtx.scheduler.enable).toHaveBeenCalledWith('thread-1');
+    });
+    it('cronResume returns error when scheduler job is missing', async () => {
+        const cronCtx = makeCronCtx({ scheduler: makeScheduler([]) });
+        const result = await executeCronAction({ type: 'cronResume', cronId: 'cron-test0001' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error).toContain('not registered in scheduler');
+    });
+    it('cronDelete unregisters and archives', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronDelete', cronId: 'cron-test0001' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        expect(cronCtx.scheduler.unregister).toHaveBeenCalledWith('thread-1');
+        expect(cronCtx.statsStore.removeRecord).toHaveBeenCalledWith('cron-test0001');
+    });
+    it('cronDelete warns when archive fails', async () => {
+        const cronCtx = makeCronCtx();
+        // Override the cached thread to have a failing setArchived
+        cronCtx.client.channels.cache.get.mockImplementation((id) => {
+            if (id === 'thread-1')
+                return { id: 'thread-1', isThread: () => true, send: vi.fn(), setArchived: vi.fn().mockRejectedValue(new Error('Missing Permissions')) };
+            return undefined;
+        });
+        const result = await executeCronAction({ type: 'cronDelete', cronId: 'cron-test0001' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.summary).toContain('could not be archived');
+        }
+        expect(cronCtx.scheduler.unregister).toHaveBeenCalledWith('thread-1');
+        expect(cronCtx.log?.warn).toHaveBeenCalled();
+    });
+    it('cronList shows running emoji when job is running', async () => {
+        const cronCtx = makeCronCtx();
+        const job = cronCtx.scheduler.getJob('thread-1');
+        job.running = true;
+        const result = await executeCronAction({ type: 'cronList' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.summary).toContain('\uD83D\uDD04');
+        }
+    });
+    it('cronShow shows Runtime line when job is running', async () => {
+        const cronCtx = makeCronCtx();
+        const job = cronCtx.scheduler.getJob('thread-1');
+        job.running = true;
+        const result = await executeCronAction({ type: 'cronShow', cronId: 'cron-test0001' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.summary).toContain('Runtime:');
+        }
+    });
+    it('cronShow does not show Runtime line when job is not running', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronShow', cronId: 'cron-test0001' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.summary).not.toContain('Runtime:');
+        }
+    });
+    it('cronCreate calls forumCountSync.requestUpdate', async () => {
+        const mockSync = { requestUpdate: vi.fn(), stop: vi.fn() };
+        const cronCtx = makeCronCtx({ forumCountSync: mockSync });
+        const result = await executeCronAction({ type: 'cronCreate', name: 'New Cron', schedule: '0 7 * * *', channel: 'general', prompt: 'Do something' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        expect(mockSync.requestUpdate).toHaveBeenCalled();
+    });
+    it('cronDelete calls forumCountSync.requestUpdate', async () => {
+        const mockSync = { requestUpdate: vi.fn(), stop: vi.fn() };
+        const cronCtx = makeCronCtx({ forumCountSync: mockSync });
+        const result = await executeCronAction({ type: 'cronDelete', cronId: 'cron-test0001' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        expect(mockSync.requestUpdate).toHaveBeenCalled();
+    });
+    it('cronSync calls forumCountSync.requestUpdate', async () => {
+        const mockSync = { requestUpdate: vi.fn(), stop: vi.fn() };
+        const cronCtx = makeCronCtx({ forumCountSync: mockSync });
+        const result = await executeCronAction({ type: 'cronSync' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        expect(mockSync.requestUpdate).toHaveBeenCalled();
+    });
+    it('cronCreate validates required fields', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronCreate', name: '', schedule: '', channel: '', prompt: '' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(false);
+    });
+    it('cronCreate creates thread and registers job', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronCreate', name: 'New Cron', schedule: '0 7 * * *', channel: 'general', prompt: 'Do something' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok)
+            expect(result.summary).toContain('New Cron');
+    });
+    it('cronCreate rejects invalid schedule before creating a thread', async () => {
+        const invoke = vi.fn(async function* () {
+            yield { type: 'text_final', text: 'monitoring' };
+        });
+        const runtime = {
+            id: 'other',
+            capabilities: new Set(),
+            invoke,
+        };
+        const cronCtx = makeCronCtx({ runtime });
+        const result = await executeCronAction({ type: 'cronCreate', name: 'Bad Cron', schedule: 'not-a-cron', channel: 'general', prompt: 'Do something' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error).toContain('Invalid cron definition');
+        expect(cronCtx.scheduler.register).not.toHaveBeenCalled();
+        expect(invoke).not.toHaveBeenCalled();
+        const forum = cronCtx.client.channels.cache.get('forum-1');
+        expect(forum.threads.create).not.toHaveBeenCalled();
+    });
+    it('cronCreate reports timezone validation errors as definition errors', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({
+            type: 'cronCreate',
+            name: 'TZ Fail',
+            schedule: '0 7 * * *',
+            timezone: 'Not/A_Real_Timezone',
+            channel: 'general',
+            prompt: 'Do something',
+        }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error).toContain('Invalid cron definition');
+    });
+    it('cronUpdate returns error for unknown cronId', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronUpdate', cronId: 'cron-nope' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(false);
+    });
+    it('cronUpdate with model sets override', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronUpdate', cronId: 'cron-test0001', model: 'opus' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        expect(cronCtx.statsStore.upsertRecord).toHaveBeenCalledWith('cron-test0001', 'thread-1', expect.objectContaining({ modelOverride: 'opus' }));
+    });
+    it('cronUpdate rejects invalid schedule before thread edits or scheduler mutation', async () => {
+        const cronCtx = makeCronCtx();
+        const thread = cronCtx.client.channels.cache.get('thread-1');
+        const starter = { author: { id: 'bot-user' }, edit: vi.fn() };
+        thread.fetchStarterMessage = vi.fn(async () => starter);
+        const result = await executeCronAction({ type: 'cronUpdate', cronId: 'cron-test0001', schedule: 'bad-schedule' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error).toContain('Invalid cron definition');
+        expect(starter.edit).not.toHaveBeenCalled();
+        expect(cronCtx.scheduler.register).not.toHaveBeenCalled();
+    });
+    it('cronCreate without timezone uses getDefaultTimezone', async () => {
+        vi.stubEnv('DEFAULT_TIMEZONE', 'America/Chicago');
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronCreate', name: 'TZ Test', schedule: '0 12 * * *', channel: 'general', prompt: 'Test timezone' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        // The scheduler.register call should receive a def with America/Chicago timezone.
+        expect(cronCtx.scheduler.register).toHaveBeenCalledWith(expect.any(String), expect.any(String), expect.any(String), 'TZ Test', expect.objectContaining({ timezone: 'America/Chicago' }), expect.any(String));
+        vi.unstubAllEnvs();
+    });
+    it('cronCreate does not set modelOverride', async () => {
+        const cronCtx = makeCronCtx();
+        await executeCronAction({ type: 'cronCreate', name: 'New Cron', schedule: '0 7 * * *', channel: 'general', prompt: 'Do something', model: 'opus' }, makeActionCtx(), cronCtx);
+        // Should set model but NOT modelOverride.
+        expect(cronCtx.statsStore.upsertRecord).toHaveBeenCalledWith(expect.any(String), expect.any(String), expect.not.objectContaining({ modelOverride: expect.anything() }));
+    });
+    it('cronTrigger returns ok for known job', async () => {
+        // Mock the dynamic import of executeCronJob.
+        vi.mock('../cron/executor.js', () => ({
+            executeCronJob: vi.fn(async () => { }),
+        }));
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronTrigger', cronId: 'cron-test0001' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok)
+            expect(result.summary).toContain('triggered');
+    });
+    it('cronTrigger returns error for unknown cronId', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronTrigger', cronId: 'cron-nope' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(false);
+    });
+    it('cronSync returns sync results', async () => {
+        // Mock the dynamic import of runCronSync.
+        vi.mock('../cron/cron-sync.js', () => ({
+            runCronSync: vi.fn(async () => ({ tagsApplied: 1, namesUpdated: 0, statusMessagesUpdated: 2, orphansDetected: 0 })),
+        }));
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronSync' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.summary).toContain('1 tags');
+            expect(result.summary).toContain('2 status msgs');
+        }
+    });
+    it('cronCreate returns error when thread creation fails', async () => {
+        const forum = {
+            id: 'forum-1',
+            type: 15,
+            threads: {
+                create: vi.fn(async () => { throw new Error('Missing Permissions'); }),
+            },
+        };
+        const client = {
+            channels: {
+                cache: { get: vi.fn((id) => id === 'forum-1' ? forum : undefined) },
+                fetch: vi.fn(async (id) => id === 'forum-1' ? forum : null),
+            },
+            user: { id: 'bot-user' },
+        };
+        const cronCtx = makeCronCtx({ client: client });
+        const result = await executeCronAction({ type: 'cronCreate', name: 'Fail Cron', schedule: '0 7 * * *', channel: 'general', prompt: 'Test' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error).toContain('Missing Permissions');
+    });
+    it('cronTrigger force is rejected in Discord actions', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronTrigger', cronId: 'cron-test0001', force: true }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error).toContain('force is disabled');
+    });
+    it('cronPause requests cancellation when a run is active', async () => {
+        const runControl = { requestCancel: vi.fn(() => true) };
+        const cronCtx = makeCronCtx({ executorCtx: { runControl } });
+        const result = await executeCronAction({ type: 'cronPause', cronId: 'cron-test0001' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        expect(runControl.requestCancel).toHaveBeenCalledWith('thread-1');
+        if (result.ok)
+            expect(result.summary).toContain('cancel requested');
+    });
+    it('cronDelete requests cancellation when a run is active', async () => {
+        const runControl = { requestCancel: vi.fn(() => true) };
+        const cronCtx = makeCronCtx({ executorCtx: { runControl } });
+        const result = await executeCronAction({ type: 'cronDelete', cronId: 'cron-test0001' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        expect(runControl.requestCancel).toHaveBeenCalledWith('thread-1');
+        if (result.ok)
+            expect(result.summary).toContain('cancel requested');
+    });
+    it('cronSync uses coordinator when present and returns result summary', async () => {
+        const coordinator = {
+            sync: vi.fn(async () => ({ tagsApplied: 2, namesUpdated: 1, statusMessagesUpdated: 3, orphansDetected: 0 })),
+        };
+        const cronCtx = makeCronCtx({ syncCoordinator: coordinator });
+        const result = await executeCronAction({ type: 'cronSync' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.summary).toContain('2 tags');
+            expect(result.summary).toContain('1 names');
+            expect(result.summary).toContain('3 status msgs');
+        }
+        expect(coordinator.sync).toHaveBeenCalled();
+    });
+    it('cronSync coalesced case returns "already running" message', async () => {
+        const coordinator = { sync: vi.fn(async () => null) };
+        const cronCtx = makeCronCtx({ syncCoordinator: coordinator });
+        const result = await executeCronAction({ type: 'cronSync' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok)
+            expect(result.summary).toContain('coalesced');
+    });
+    it('cronSync fallback when coordinator absent', async () => {
+        vi.mock('../cron/cron-sync.js', () => ({
+            runCronSync: vi.fn(async () => ({ tagsApplied: 1, namesUpdated: 0, statusMessagesUpdated: 2, orphansDetected: 0 })),
+        }));
+        const cronCtx = makeCronCtx();
+        // Ensure no coordinator
+        delete cronCtx.syncCoordinator;
+        const result = await executeCronAction({ type: 'cronSync' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.summary).toContain('1 tags');
+        }
+    });
+    it('cronTagMapReload success with coordinator queues sync', async () => {
+        const { reloadCronTagMapInPlace } = await import('../cron/tag-map.js');
+        vi.mocked(reloadCronTagMapInPlace).mockResolvedValue(3);
+        const coordinator = { sync: vi.fn(async () => null) };
+        const cronCtx = makeCronCtx({ syncCoordinator: coordinator });
+        const result = await executeCronAction({ type: 'cronTagMapReload' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.summary).toContain('sync queued');
+        }
+    });
+    it('cronTagMapReload success without coordinator', async () => {
+        const { reloadCronTagMapInPlace } = await import('../cron/tag-map.js');
+        vi.mocked(reloadCronTagMapInPlace).mockResolvedValue(2);
+        const cronCtx = makeCronCtx();
+        delete cronCtx.syncCoordinator;
+        const result = await executeCronAction({ type: 'cronTagMapReload' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.summary).toContain('no sync coordinator configured');
+        }
+    });
+    it('cronTagMapReload failure returns error', async () => {
+        const { reloadCronTagMapInPlace } = await import('../cron/tag-map.js');
+        vi.mocked(reloadCronTagMapInPlace).mockRejectedValue(new Error('bad json'));
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronTagMapReload' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error).toContain('bad json');
+    });
+    it('CRON_ACTION_TYPES includes cronTagMapReload', () => {
+        expect(CRON_ACTION_TYPES.has('cronTagMapReload')).toBe(true);
+    });
+});

package/dist/discord/actions-defer.js

@@ -0,0 +1,60 @@
+import { fmtTime } from './action-utils.js';
+const DEFER_TYPES = ['defer'];
+export const DEFER_ACTION_TYPES = new Set(DEFER_TYPES);
+export async function executeDeferAction(action, ctx) {
+    const scheduler = ctx.deferScheduler;
+    if (!scheduler) {
+        return { ok: false, error: 'Deferred actions are not configured for this bot' };
+    }
+    const channel = action.channel?.trim();
+    if (!channel) {
+        return { ok: false, error: 'Deferred actions require a target channel' };
+    }
+    const prompt = action.prompt?.trim();
+    if (!prompt) {
+        return { ok: false, error: 'Deferred actions require a prompt to re-run' };
+    }
+    const delaySeconds = action.delaySeconds;
+    if (!Number.isFinite(delaySeconds)) {
+        return { ok: false, error: 'delaySeconds must be a valid number' };
+    }
+    const normalizedAction = {
+        ...action,
+        channel,
+        prompt,
+        delaySeconds,
+    };
+    const result = scheduler.schedule({ action: normalizedAction, context: ctx });
+    if (!result.ok) {
+        return { ok: false, error: buildDeferRejection(channel, result.error) };
+    }
+    const delayLabel = formatDuration(result.delaySeconds);
+    const when = fmtTime(result.runsAt);
+    return {
+        ok: true,
+        summary: `Deferred follow-up scheduled for ${channel} in ${delayLabel} (runs at ${when})`,
+    };
+}
+function formatDuration(seconds) {
+    const parts = [];
+    let remaining = seconds;
+    const hours = Math.floor(remaining / 3600);
+    if (hours > 0) {
+        parts.push(`${hours}h`);
+        remaining -= hours * 3600;
+    }
+    const minutes = Math.floor(remaining / 60);
+    if (minutes > 0) {
+        parts.push(`${minutes}m`);
+        remaining -= minutes * 60;
+    }
+    const secs = Math.floor(remaining);
+    if (secs > 0 || parts.length === 0) {
+        parts.push(`${secs}s`);
+    }
+    return parts.join(' ');
+}
+function buildDeferRejection(channel, reason) {
+    const target = channel || 'requested channel';
+    return `Deferred follow-up for ${target} rejected: ${reason}`;
+}