discoclaw 0.1.0

package/dist/cron/auto-tag.js

@@ -0,0 +1,100 @@
+import { resolveModel } from '../runtime/model-tiers.js';
+// ---------------------------------------------------------------------------
+// Purpose classification (AI)
+// ---------------------------------------------------------------------------
+export async function autoTagCron(runtime, name, prompt, availableTags, opts) {
+    if (availableTags.length === 0)
+        return [];
+    const tagList = availableTags.join(', ');
+    const classifyPrompt = `Classify this scheduled task into 1-3 tags from the following list. ` +
+        `Reply with ONLY comma-separated tag names, nothing else.\n\n` +
+        `Available tags: ${tagList}\n\n` +
+        `Rules:\n` +
+        `- reporting: generates reports, summaries, digests\n` +
+        `- monitoring: health checks, alerts, status polling\n` +
+        `- cleanup: deletes old data, archives, purges\n` +
+        `- notifications: sends reminders, alerts, announcements\n` +
+        `- sync: data synchronization, imports, exports\n` +
+        `- backup: backups, snapshots, data preservation\n` +
+        `- maintenance: updates, migrations, housekeeping\n` +
+        `- analytics: metrics, tracking, dashboards\n\n` +
+        `Job name: ${name}\n` +
+        `Instruction: ${prompt.slice(0, 500)}`;
+    let finalText = '';
+    let deltaText = '';
+    for await (const evt of runtime.invoke({
+        prompt: classifyPrompt,
+        model: resolveModel(opts?.model ?? 'fast', runtime.id),
+        cwd: opts?.cwd ?? '.',
+        timeoutMs: opts?.timeoutMs ?? 15_000,
+        tools: [],
+    })) {
+        if (evt.type === 'text_final') {
+            finalText = evt.text;
+        }
+        else if (evt.type === 'text_delta') {
+            deltaText += evt.text;
+        }
+        else if (evt.type === 'error') {
+            return [];
+        }
+    }
+    const output = (finalText || deltaText).trim();
+    if (!output)
+        return [];
+    const tagSet = new Set(availableTags.map((t) => t.toLowerCase()));
+    const candidates = output.split(/[,\n]+/).map((t) => t.trim()).filter(Boolean);
+    const result = [];
+    for (const candidate of candidates) {
+        const match = availableTags.find((t) => t.toLowerCase() === candidate.toLowerCase());
+        if (match && tagSet.has(candidate.toLowerCase())) {
+            result.push(match);
+        }
+        if (result.length >= 3)
+            break;
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Model tier classification
+// ---------------------------------------------------------------------------
+/**
+ * Classify whether a cron job needs capable-tier or can run on fast.
+ *
+ * Two-step logic:
+ * 1. Cadence default: frequent/hourly (>1x/day) → fast immediately (cost optimization).
+ * 2. AI classification for daily+ crons: ask fast-tier model to decide.
+ */
+export async function classifyCronModel(runtime, name, prompt, cadence, opts) {
+    // High-frequency crons default to fast — skip AI call for cost.
+    if (cadence === 'frequent' || cadence === 'hourly') {
+        return 'fast';
+    }
+    const classifyPrompt = `Does this scheduled task require advanced reasoning (complex analysis, ` +
+        `multi-step planning, nuanced writing) or can it be handled with basic ` +
+        `capabilities (simple lookups, templated responses, data formatting)?\n\n` +
+        `Reply with ONLY one word: "capable" or "fast"\n\n` +
+        `Job name: ${name}\n` +
+        `Instruction: ${prompt.slice(0, 500)}`;
+    let finalText = '';
+    let deltaText = '';
+    for await (const evt of runtime.invoke({
+        prompt: classifyPrompt,
+        model: resolveModel(opts?.model ?? 'fast', runtime.id),
+        cwd: opts?.cwd ?? '.',
+        timeoutMs: opts?.timeoutMs ?? 15_000,
+        tools: [],
+    })) {
+        if (evt.type === 'text_final') {
+            finalText = evt.text;
+        }
+        else if (evt.type === 'text_delta') {
+            deltaText += evt.text;
+        }
+        else if (evt.type === 'error') {
+            return 'fast';
+        }
+    }
+    const output = (finalText || deltaText).trim().toLowerCase();
+    return output === 'capable' ? 'capable' : 'fast';
+}

package/dist/cron/auto-tag.test.js

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest';
+import { autoTagCron, classifyCronModel } from './auto-tag.js';
+function makeMockRuntime(output) {
+    return {
+        id: 'other',
+        capabilities: new Set(),
+        async *invoke() {
+            yield { type: 'text_final', text: output };
+        },
+    };
+}
+function makeMockErrorRuntime() {
+    return {
+        id: 'other',
+        capabilities: new Set(),
+        async *invoke() {
+            yield { type: 'error', message: 'fail' };
+        },
+    };
+}
+const TAGS = ['reporting', 'monitoring', 'cleanup', 'notifications', 'sync', 'backup', 'maintenance', 'analytics'];
+describe('autoTagCron', () => {
+    it('returns valid tags from AI output', async () => {
+        const runtime = makeMockRuntime('monitoring, cleanup');
+        const result = await autoTagCron(runtime, 'Daily Cleanup', 'Remove old logs', TAGS);
+        expect(result).toEqual(['monitoring', 'cleanup']);
+    });
+    it('drops unknown tags', async () => {
+        const runtime = makeMockRuntime('monitoring, unknown, backup');
+        const result = await autoTagCron(runtime, 'Backup Job', 'Backup database', TAGS);
+        expect(result).toEqual(['monitoring', 'backup']);
+    });
+    it('limits to 3 tags', async () => {
+        const runtime = makeMockRuntime('monitoring, cleanup, backup, sync, analytics');
+        const result = await autoTagCron(runtime, 'Big Job', 'Do many things', TAGS);
+        expect(result).toHaveLength(3);
+    });
+    it('handles case-insensitive matching', async () => {
+        const runtime = makeMockRuntime('Monitoring, CLEANUP');
+        const result = await autoTagCron(runtime, 'Test', 'Test', TAGS);
+        expect(result).toEqual(['monitoring', 'cleanup']);
+    });
+    it('returns empty on error', async () => {
+        const result = await autoTagCron(makeMockErrorRuntime(), 'Test', 'Test', TAGS);
+        expect(result).toEqual([]);
+    });
+    it('returns empty with no available tags', async () => {
+        const result = await autoTagCron(makeMockRuntime('monitoring'), 'Test', 'Test', []);
+        expect(result).toEqual([]);
+    });
+    it('returns empty for empty AI output', async () => {
+        const result = await autoTagCron(makeMockRuntime(''), 'Test', 'Test', TAGS);
+        expect(result).toEqual([]);
+    });
+});
+describe('classifyCronModel', () => {
+    it('returns fast for frequent cadence without AI call', async () => {
+        // Even if runtime would say capable, frequent → fast.
+        const runtime = makeMockRuntime('capable');
+        const result = await classifyCronModel(runtime, 'Check', 'Check health', 'frequent');
+        expect(result).toBe('fast');
+    });
+    it('returns fast for hourly cadence without AI call', async () => {
+        const runtime = makeMockRuntime('capable');
+        const result = await classifyCronModel(runtime, 'Check', 'Check health', 'hourly');
+        expect(result).toBe('fast');
+    });
+    it('returns capable when AI says capable for daily cron', async () => {
+        const runtime = makeMockRuntime('capable');
+        const result = await classifyCronModel(runtime, 'Report', 'Write detailed analysis report', 'daily');
+        expect(result).toBe('capable');
+    });
+    it('returns fast when AI says fast for daily cron', async () => {
+        const runtime = makeMockRuntime('fast');
+        const result = await classifyCronModel(runtime, 'Ping', 'Check if server is alive', 'daily');
+        expect(result).toBe('fast');
+    });
+    it('defaults to fast on unclear AI response', async () => {
+        const runtime = makeMockRuntime('maybe something');
+        const result = await classifyCronModel(runtime, 'Test', 'Test', 'weekly');
+        expect(result).toBe('fast');
+    });
+    it('defaults to fast on error', async () => {
+        const result = await classifyCronModel(makeMockErrorRuntime(), 'Test', 'Test', 'daily');
+        expect(result).toBe('fast');
+    });
+    it('defaults to fast on empty response', async () => {
+        const result = await classifyCronModel(makeMockRuntime(''), 'Test', 'Test', 'monthly');
+        expect(result).toBe('fast');
+    });
+});

package/dist/cron/cadence.js

@@ -0,0 +1,74 @@
+import { Cron } from 'croner';
+/**
+ * Count distinct values in a cron field like "1", "1,7", "3-6", "1-3,7".
+ * Returns Infinity for wildcards/steps (unbounded).
+ */
+function countFieldValues(field) {
+    if (field === '*' || /^\*\/\d+$/.test(field))
+        return Infinity;
+    let count = 0;
+    for (const part of field.split(',')) {
+        const range = part.split('-');
+        if (range.length === 2) {
+            const lo = parseInt(range[0], 10);
+            const hi = parseInt(range[1], 10);
+            if (!isNaN(lo) && !isNaN(hi) && hi >= lo) {
+                count += hi - lo + 1;
+            }
+            else {
+                count += 1;
+            }
+        }
+        else {
+            count += 1;
+        }
+    }
+    return count;
+}
+/**
+ * Detect the cadence of a cron schedule expression.
+ *
+ * Uses the same 5-field format that croner accepts. Validates the schedule
+ * parses via croner before classifying — if it throws, returns 'daily' as fallback.
+ *
+ * Logic:
+ * - single specific month (e.g., "2") → yearly
+ * - multi-month (e.g., "1,7" or "3-6") → fall through to normal classification
+ * - minute is * or *\/N → frequent (runs multiple times per hour)
+ * - minute specific + hour * → hourly
+ * - minute+hour specific, dom+dow * → daily
+ * - dow not * → weekly
+ * - dom not * → monthly
+ * - fallback: daily
+ */
+export function detectCadence(schedule) {
+    // Validate the schedule parses.
+    try {
+        new Cron(schedule).stop();
+    }
+    catch {
+        return 'daily';
+    }
+    const parts = schedule.trim().split(/\s+/);
+    if (parts.length < 5)
+        return 'daily';
+    const [minute, hour, dom, month, dow] = parts;
+    const isWild = (f) => f === '*';
+    const isStep = (f) => /^\*\/\d+$/.test(f);
+    // Single specific month → fires once a year (annual schedule).
+    // Multi-month patterns (e.g., "1,7" or "3-6") fall through to normal classification.
+    if (!isWild(month) && !isStep(month) && countFieldValues(month) === 1)
+        return 'yearly';
+    // Minute is wildcard or step → runs multiple times per hour → frequent.
+    if (isWild(minute) || isStep(minute))
+        return 'frequent';
+    // Minute specific, hour is wildcard or step → runs every hour.
+    if (isWild(hour) || isStep(hour))
+        return 'hourly';
+    // Minute + hour specific, check day fields.
+    if (!isWild(dow))
+        return 'weekly';
+    if (!isWild(dom))
+        return 'monthly';
+    return 'daily';
+}

package/dist/cron/cadence.test.js

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest';
+import { detectCadence } from './cadence.js';
+describe('detectCadence', () => {
+    it('detects frequent for wildcard minute', () => {
+        expect(detectCadence('* * * * *')).toBe('frequent');
+    });
+    it('detects frequent for step minute', () => {
+        expect(detectCadence('*/5 * * * *')).toBe('frequent');
+        expect(detectCadence('*/15 * * * *')).toBe('frequent');
+    });
+    it('detects hourly for specific minute + wildcard hour', () => {
+        expect(detectCadence('0 * * * *')).toBe('hourly');
+        expect(detectCadence('30 * * * *')).toBe('hourly');
+    });
+    it('detects daily for specific minute + hour', () => {
+        expect(detectCadence('0 7 * * *')).toBe('daily');
+        expect(detectCadence('30 12 * * *')).toBe('daily');
+    });
+    it('detects weekly for specific dow', () => {
+        expect(detectCadence('0 7 * * 1-5')).toBe('weekly');
+        expect(detectCadence('0 9 * * 1')).toBe('weekly');
+        expect(detectCadence('0 0 * * 0')).toBe('weekly');
+    });
+    it('detects monthly for specific dom', () => {
+        expect(detectCadence('0 7 1 * *')).toBe('monthly');
+        expect(detectCadence('0 0 15 * *')).toBe('monthly');
+    });
+    it('returns daily for invalid schedule', () => {
+        expect(detectCadence('not a cron')).toBe('daily');
+    });
+    it('returns daily for empty string', () => {
+        expect(detectCadence('')).toBe('daily');
+    });
+    it('detects yearly for single specific month', () => {
+        expect(detectCadence('0 6 11 2 *')).toBe('yearly');
+        expect(detectCadence('0 0 1 1 *')).toBe('yearly');
+        expect(detectCadence('0 12 25 12 *')).toBe('yearly');
+    });
+    it('falls through for multi-month patterns', () => {
+        // "1,7" = Jan + Jul → 2 months → not yearly, classify by other fields.
+        expect(detectCadence('0 7 * 1,7 *')).toBe('daily');
+        // "3-6" = Mar–Jun → 4 months → not yearly.
+        expect(detectCadence('0 7 * 3-6 *')).toBe('daily');
+        // Multi-month with specific dom → monthly.
+        expect(detectCadence('0 7 1 1,7 *')).toBe('monthly');
+        // Multi-month with wildcard minute → frequent.
+        expect(detectCadence('* * * 1,2,3 *')).toBe('frequent');
+    });
+    it('handles complex schedules', () => {
+        expect(detectCadence('0 7,19 * * *')).toBe('daily');
+        expect(detectCadence('0 7 * * 1,3,5')).toBe('weekly');
+    });
+});

package/dist/cron/cron-sync-coordinator.js

@@ -0,0 +1,66 @@
+import { reloadCronTagMapInPlace } from './tag-map.js';
+import { runCronSync } from './cron-sync.js';
+/**
+ * Shared cron sync coordinator wrapping runCronSync() with a concurrency guard,
+ * tag-map reload, and deterministic snapshotting. Mirrors TaskSyncCoordinator.
+ */
+export class CronSyncCoordinator {
+    opts;
+    syncing = false;
+    pendingSync = false;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /** Update the auto-tag model at runtime (called by modelSet propagation). */
+    setAutoTagModel(model) {
+        this.opts = { ...this.opts, autoTagModel: model };
+    }
+    /**
+     * Run sync with concurrency guard.
+     * Returns null when coalesced into a running sync's follow-up.
+     */
+    async sync() {
+        if (this.syncing) {
+            this.pendingSync = true;
+            return null;
+        }
+        this.syncing = true;
+        try {
+            // Reload tag map from disk before sync
+            if (this.opts.tagMapPath) {
+                try {
+                    await reloadCronTagMapInPlace(this.opts.tagMapPath, this.opts.tagMap);
+                }
+                catch (err) {
+                    this.opts.log?.warn({ err, tagMapPath: this.opts.tagMapPath }, 'cron:coordinator tag-map reload failed; using cached map');
+                }
+            }
+            // Snapshot for deterministic behavior within this sync run
+            const tagMapSnapshot = { ...this.opts.tagMap };
+            const result = await runCronSync({
+                client: this.opts.client,
+                forumId: this.opts.forumId,
+                scheduler: this.opts.scheduler,
+                statsStore: this.opts.statsStore,
+                runtime: this.opts.runtime,
+                tagMap: tagMapSnapshot,
+                autoTag: this.opts.autoTag,
+                autoTagModel: this.opts.autoTagModel,
+                cwd: this.opts.cwd,
+                log: this.opts.log,
+            });
+            this.opts.forumCountSync?.requestUpdate();
+            return result;
+        }
+        finally {
+            this.syncing = false;
+            if (this.pendingSync) {
+                this.pendingSync = false;
+                // Fire-and-forget follow-up for coalesced triggers
+                this.sync().catch((err) => {
+                    this.opts.log?.warn({ err }, 'cron:coordinator follow-up sync failed');
+                });
+            }
+        }
+    }
+}

package/dist/cron/cron-sync-coordinator.test.js

@@ -0,0 +1,118 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { CronSyncCoordinator } from './cron-sync-coordinator.js';
+// Mock the dependencies
+vi.mock('./tag-map.js', () => ({
+    reloadCronTagMapInPlace: vi.fn(async () => 2),
+}));
+vi.mock('./cron-sync.js', () => ({
+    runCronSync: vi.fn(async () => ({
+        tagsApplied: 1,
+        namesUpdated: 0,
+        statusMessagesUpdated: 1,
+        orphansDetected: 0,
+    })),
+}));
+import { reloadCronTagMapInPlace } from './tag-map.js';
+import { runCronSync } from './cron-sync.js';
+const mockReload = vi.mocked(reloadCronTagMapInPlace);
+const mockRunCronSync = vi.mocked(runCronSync);
+function mockLog() {
+    return { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+}
+function makeOpts(overrides) {
+    return {
+        client: {},
+        forumId: 'forum-1',
+        scheduler: {},
+        statsStore: {},
+        runtime: {},
+        tagMap: { monitoring: 'tag-1', daily: 'tag-2' },
+        tagMapPath: '/tmp/tags.json',
+        autoTag: true,
+        autoTagModel: 'haiku',
+        cwd: '/tmp',
+        log: mockLog(),
+        ...overrides,
+    };
+}
+describe('CronSyncCoordinator', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        mockReload.mockResolvedValue(2);
+        mockRunCronSync.mockResolvedValue({
+            tagsApplied: 1, namesUpdated: 0, statusMessagesUpdated: 1, orphansDetected: 0,
+        });
+    });
+    it('reloads tag map before sync when tagMapPath is set', async () => {
+        const opts = makeOpts();
+        const coordinator = new CronSyncCoordinator(opts);
+        await coordinator.sync();
+        expect(mockReload).toHaveBeenCalledWith('/tmp/tags.json', opts.tagMap);
+    });
+    it('falls back to cached map on reload failure', async () => {
+        mockReload.mockRejectedValue(new Error('ENOENT'));
+        const opts = makeOpts();
+        const coordinator = new CronSyncCoordinator(opts);
+        const result = await coordinator.sync();
+        expect(result).not.toBeNull();
+        expect(opts.log?.warn).toHaveBeenCalled();
+        expect(mockRunCronSync).toHaveBeenCalled();
+    });
+    it('passes snapshot to runCronSync (same values, different ref)', async () => {
+        const opts = makeOpts();
+        const coordinator = new CronSyncCoordinator(opts);
+        await coordinator.sync();
+        const callArgs = mockRunCronSync.mock.calls[0][0];
+        expect(callArgs.tagMap).toEqual(opts.tagMap);
+        expect(callArgs.tagMap).not.toBe(opts.tagMap);
+    });
+    it('coalesced concurrent sync returns null', async () => {
+        let resolveSync;
+        mockRunCronSync.mockImplementation(() => new Promise((resolve) => {
+            resolveSync = () => resolve({ tagsApplied: 0, namesUpdated: 0, statusMessagesUpdated: 0, orphansDetected: 0 });
+        }));
+        const coordinator = new CronSyncCoordinator(makeOpts());
+        const first = coordinator.sync();
+        const second = coordinator.sync();
+        expect(await second).toBeNull();
+        resolveSync();
+        const firstResult = await first;
+        expect(firstResult).not.toBeNull();
+    });
+    it('fires follow-up after coalesced sync', async () => {
+        let resolveSync;
+        let callCount = 0;
+        mockRunCronSync.mockImplementation(() => new Promise((resolve) => {
+            callCount++;
+            if (callCount === 1) {
+                resolveSync = () => resolve({ tagsApplied: 0, namesUpdated: 0, statusMessagesUpdated: 0, orphansDetected: 0 });
+            }
+            else {
+                resolve({ tagsApplied: 0, namesUpdated: 0, statusMessagesUpdated: 0, orphansDetected: 0 });
+            }
+        }));
+        const coordinator = new CronSyncCoordinator(makeOpts());
+        const first = coordinator.sync();
+        // Let the reload await resolve so runCronSync gets called and resolveSync is assigned
+        await new Promise((r) => setTimeout(r, 10));
+        coordinator.sync(); // coalesced
+        resolveSync();
+        await first;
+        // Wait for follow-up fire-and-forget
+        await new Promise((r) => setTimeout(r, 50));
+        expect(mockRunCronSync).toHaveBeenCalledTimes(2);
+    });
+    it('calls forumCountSync.requestUpdate on success', async () => {
+        const forumCountSync = { requestUpdate: vi.fn(), stop: vi.fn() };
+        const coordinator = new CronSyncCoordinator(makeOpts({ forumCountSync: forumCountSync }));
+        await coordinator.sync();
+        expect(forumCountSync.requestUpdate).toHaveBeenCalled();
+    });
+    it('setAutoTagModel updates the model used by subsequent syncs', async () => {
+        const coordinator = new CronSyncCoordinator(makeOpts({ autoTagModel: 'haiku' }));
+        coordinator.setAutoTagModel('opus');
+        await coordinator.sync();
+        const callArgs = mockRunCronSync.mock.calls[0][0];
+        expect(callArgs.autoTagModel).toBe('opus');
+    });
+});

package/dist/cron/cron-sync.js

@@ -0,0 +1,165 @@
+import { CADENCE_TAGS } from './run-stats.js';
+import { detectCadence } from './cadence.js';
+import { autoTagCron, classifyCronModel } from './auto-tag.js';
+import { buildCronThreadName, ensureStatusMessage, resolveForumChannel } from './discord-sync.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+async function sleep(ms) {
+    const n = ms ?? 0;
+    if (n <= 0)
+        return;
+    await new Promise((r) => setTimeout(r, n));
+}
+function purposeTagNames(tagMap) {
+    const cadenceSet = new Set(CADENCE_TAGS);
+    return Object.keys(tagMap).filter((k) => !cadenceSet.has(k));
+}
+// ---------------------------------------------------------------------------
+// 4-phase sync
+// ---------------------------------------------------------------------------
+export async function runCronSync(opts) {
+    const { client, forumId, scheduler, statsStore, runtime, autoTag, autoTagModel, cwd, log } = opts;
+    const throttleMs = opts.throttleMs ?? 250;
+    const forum = await resolveForumChannel(client, forumId);
+    if (!forum) {
+        log?.warn({ forumId }, 'cron-sync: forum not found');
+        return { tagsApplied: 0, namesUpdated: 0, statusMessagesUpdated: 0, orphansDetected: 0 };
+    }
+    const tagMap = opts.tagMap;
+    const purposeTags = purposeTagNames(tagMap);
+    let tagsApplied = 0;
+    let namesUpdated = 0;
+    let statusMessagesUpdated = 0;
+    let orphansDetected = 0;
+    // Get all active threads in the forum.
+    let threads = new Map();
+    try {
+        const fetched = await forum.threads.fetchActive();
+        threads = fetched.threads;
+    }
+    catch (err) {
+        log?.warn({ err, forumId }, 'cron-sync: failed to fetch active threads; continuing with metadata/status phases only');
+    }
+    // Get all registered jobs.
+    const jobs = scheduler.listJobs();
+    const jobThreadIds = new Set(jobs.map((j) => j.id));
+    // Phase 1: Tag + model sync.
+    for (const job of jobs) {
+        const fullJob = scheduler.getJob(job.id);
+        if (!fullJob)
+            continue;
+        const record = statsStore.getRecordByThreadId(fullJob.threadId);
+        if (!record)
+            continue;
+        const needsCadence = !record.cadence;
+        const needsTags = autoTag && record.purposeTags.length === 0 && purposeTags.length > 0;
+        const needsModel = !record.model;
+        const needsMetadataUpdate = needsCadence || needsTags || needsModel;
+        try {
+            const updates = {};
+            if (needsMetadataUpdate) {
+                if (needsCadence) {
+                    const cadence = fullJob.def.schedule ? detectCadence(fullJob.def.schedule) : null;
+                    updates.cadence = cadence;
+                }
+                if (needsTags) {
+                    const classified = await autoTagCron(runtime, fullJob.name, fullJob.def.prompt, purposeTags, { model: autoTagModel, cwd });
+                    if (classified.length > 0)
+                        updates.purposeTags = classified;
+                }
+                if (needsModel) {
+                    const cadence = updates.cadence ?? record.cadence ?? (fullJob.def.schedule ? detectCadence(fullJob.def.schedule) : null);
+                    if (cadence !== null) {
+                        const model = await classifyCronModel(runtime, fullJob.name, fullJob.def.prompt, cadence, { model: autoTagModel, cwd });
+                        updates.model = model;
+                    }
+                }
+                await statsStore.upsertRecord(record.cronId, record.threadId, updates);
+            }
+            // Apply tags to Discord thread.
+            const thread = threads.get(fullJob.threadId);
+            if (thread) {
+                const desiredPurposeTags = updates.purposeTags ?? record.purposeTags;
+                const desiredCadence = updates.cadence ?? record.cadence;
+                const allTags = [
+                    ...desiredPurposeTags,
+                ];
+                if (desiredCadence)
+                    allTags.push(desiredCadence);
+                const desiredTagIds = allTags
+                    .map((t) => tagMap[t])
+                    .filter((id) => Boolean(id));
+                const uniqueTagIds = [...new Set(desiredTagIds)].slice(0, 5);
+                const currentTagIds = Array.isArray(thread.appliedTags)
+                    ? thread.appliedTags.filter((id) => typeof id === 'string')
+                    : [];
+                const desiredSet = new Set(uniqueTagIds);
+                const tagsOutOfSync = currentTagIds.length !== uniqueTagIds.length
+                    || currentTagIds.some((id) => !desiredSet.has(id));
+                if (tagsOutOfSync) {
+                    try {
+                        await thread.edit({ appliedTags: uniqueTagIds });
+                        tagsApplied++;
+                    }
+                    catch (err) {
+                        log?.warn({ err, threadId: fullJob.threadId }, 'cron-sync:phase1 tag apply failed');
+                    }
+                }
+            }
+        }
+        catch (err) {
+            log?.warn({ err, jobId: job.id }, 'cron-sync:phase1 failed');
+        }
+        await sleep(throttleMs);
+    }
+    // Phase 2: Name sync.
+    for (const job of jobs) {
+        const fullJob = scheduler.getJob(job.id);
+        if (!fullJob)
+            continue;
+        const record = statsStore.getRecordByThreadId(fullJob.threadId);
+        const cadence = record?.cadence ?? null;
+        const expectedName = buildCronThreadName(fullJob.name, cadence);
+        const thread = threads.get(fullJob.threadId);
+        if (thread && thread.name !== expectedName) {
+            try {
+                await thread.setName(expectedName);
+                namesUpdated++;
+                log?.info({ threadId: fullJob.threadId, oldName: thread.name, newName: expectedName }, 'cron-sync:phase2 name updated');
+            }
+            catch (err) {
+                log?.warn({ err, threadId: fullJob.threadId }, 'cron-sync:phase2 name update failed');
+            }
+            await sleep(throttleMs);
+        }
+    }
+    // Phase 3: Status message sync.
+    for (const job of jobs) {
+        const fullJob = scheduler.getJob(job.id);
+        if (!fullJob?.cronId)
+            continue;
+        const record = statsStore.getRecord(fullJob.cronId);
+        if (!record)
+            continue;
+        try {
+            await ensureStatusMessage(client, fullJob.threadId, fullJob.cronId, record, statsStore, { log });
+            statusMessagesUpdated++;
+        }
+        catch (err) {
+            log?.warn({ err, jobId: job.id }, 'cron-sync:phase3 status message failed');
+        }
+        await sleep(throttleMs);
+    }
+    // Phase 4: Orphan detection (non-destructive, log only).
+    for (const thread of threads.values()) {
+        if (thread.parentId !== forumId)
+            continue;
+        if (!jobThreadIds.has(thread.id)) {
+            orphansDetected++;
+            log?.warn({ threadId: thread.id, name: thread.name }, 'cron-sync:phase4 orphan thread (no registered job)');
+        }
+    }
+    log?.info({ tagsApplied, namesUpdated, statusMessagesUpdated, orphansDetected }, 'cron-sync: complete');
+    return { tagsApplied, namesUpdated, statusMessagesUpdated, orphansDetected };
+}