discoclaw 1.0.0 → 1.1.0

package/.context/dev.md

@@ -171,18 +171,18 @@ Two setup paths:
 ### Plan & Forge
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `DISCOCLAW_PLAN_COMMANDS_ENABLED` | `1` | Enable plan commands (`!plan`, `!plan phase`, etc.) |
-| `PLAN_PHASES_ENABLED` | `1` | Enable phase-by-phase plan execution |
+| `DISCOCLAW_PLAN_COMMANDS_ENABLED` | `0` | Enable plan commands (`!plan`, `!plan phase`, etc.) |
+| `PLAN_PHASES_ENABLED` | `0` | Enable phase-by-phase plan execution |
 | `PLAN_PHASE_MAX_CONTEXT_FILES` | `5` | Max `.context/` files injected per plan phase |
 | `PLAN_PHASE_TIMEOUT_MS` | `1800000` | Per-phase timeout in milliseconds |
 | `PLAN_PHASE_AUDIT_FIX_MAX` | `3` | Max audit-fix attempts per phase before giving up |
-| `DISCOCLAW_FORGE_COMMANDS_ENABLED` | `1` | Enable forge commands (`!forge`) |
+| `DISCOCLAW_FORGE_COMMANDS_ENABLED` | `0` | Enable forge commands (`!forge`) |
 | `FORGE_MAX_AUDIT_ROUNDS` | `5` | Max audit rounds before forge accepts the draft |
 | `FORGE_DRAFTER_MODEL` | *(empty — uses `RUNTIME_MODEL`)* | Override model for the forge drafter step |
 | `FORGE_AUDITOR_MODEL` | *(empty — uses `RUNTIME_MODEL`)* | Override model for the forge auditor step |
 | `FORGE_TIMEOUT_MS` | `1800000` | Per-forge-session timeout in milliseconds |
 | `FORGE_PROGRESS_THROTTLE_MS` | `3000` | Min ms between forge progress Discord updates |
-| `FORGE_AUTO_IMPLEMENT` | `1` | Automatically implement the approved forge plan without a separate confirm step |
+| `FORGE_AUTO_IMPLEMENT` | `0` | Automatically implement the approved forge plan without a separate confirm step |
 | `FORGE_DRAFTER_RUNTIME` | *(empty — uses `PRIMARY_RUNTIME`)* | Runtime adapter for the forge drafter (e.g. `openai`, `claude`) |
 | `FORGE_AUDITOR_RUNTIME` | *(empty — uses `PRIMARY_RUNTIME`)* | Runtime adapter for the forge auditor |
 

package/.env.example.full

@@ -217,11 +217,11 @@ DISCORD_GUILD_ID=
 #DISCOCLAW_DISCORD_ACTIONS_POLLS=1
 #DISCOCLAW_DISCORD_ACTIONS_TASKS=1
 # Allow the AI to self-initiate forge runs (draft + audit loops) via action blocks.
-# Requires DISCOCLAW_FORGE_COMMANDS_ENABLED=1. Only one forge at a time. Default: 1.
-#DISCOCLAW_DISCORD_ACTIONS_FORGE=1
+# Requires DISCOCLAW_FORGE_COMMANDS_ENABLED=1. Only one forge at a time. Default: 0.
+#DISCOCLAW_DISCORD_ACTIONS_FORGE=0
 # Allow the AI to create, inspect, approve, run, and close plans via action blocks.
-# Requires DISCOCLAW_PLAN_COMMANDS_ENABLED=1. Default: 1.
-#DISCOCLAW_DISCORD_ACTIONS_PLAN=1
+# Requires DISCOCLAW_PLAN_COMMANDS_ENABLED=1. Default: 0.
+#DISCOCLAW_DISCORD_ACTIONS_PLAN=0
 # Allow the AI to read/write durable memory (facts, preferences) via action blocks.
 # Requires DISCOCLAW_DURABLE_MEMORY_ENABLED=1. Default: 1.
 #DISCOCLAW_DISCORD_ACTIONS_MEMORY=1
@@ -541,9 +541,10 @@ DISCOCLAW_DISCORD_ACTIONS_DEFER=1
 # ----------------------------------------------------------
 # Plan & Forge — AI-assisted planning and implementation
 # ----------------------------------------------------------
-# Enable/disable !plan and !forge commands.
-#DISCOCLAW_PLAN_COMMANDS_ENABLED=1
-#DISCOCLAW_FORGE_COMMANDS_ENABLED=1
+# Enable/disable !plan and !forge commands. Default: 0 (off).
+# When off, !plan and !forge respond with a friendly nudge explaining how to enable.
+#DISCOCLAW_PLAN_COMMANDS_ENABLED=0
+#DISCOCLAW_FORGE_COMMANDS_ENABLED=0
 # Phase decomposition for approved plans.
 #PLAN_PHASES_ENABLED=1
 # Max files per phase batch during decomposition.

package/dist/config.js

@@ -384,8 +384,8 @@ export function parseConfig(env) {
     const discordActionsTasks = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_TASKS', true);
     const discordActionsCrons = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_CRONS', true);
     const discordActionsBotProfile = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_BOT_PROFILE', true);
-    const discordActionsForge = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_FORGE', true);
-    const discordActionsPlan = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_PLAN', true);
+    const discordActionsForge = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_FORGE', false);
+    const discordActionsPlan = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_PLAN', false);
     const discordActionsMemory = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_MEMORY', true);
     const discordActionsDefer = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_DEFER', true);
     const discordActionsLoop = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_LOOP', true);
@@ -694,6 +694,8 @@ export function parseConfig(env) {
             loopMaxIntervalSeconds,
             loopMaxConcurrent,
             messageHistoryBudget: parseNonNegativeInt(env, 'DISCOCLAW_MESSAGE_HISTORY_BUDGET', 3000),
+            messageHistoryFetchLimit: parsePositiveInt(env, 'DISCOCLAW_MESSAGE_HISTORY_FETCH_LIMIT', 10),
+            messageHistoryMaxAgeMs: parsePositiveInt(env, 'DISCOCLAW_MESSAGE_HISTORY_MAX_AGE_HOURS', 48) * 3_600_000,
             summaryEnabled: parseBoolean(env, 'DISCOCLAW_SUMMARY_ENABLED', true),
             summaryModel: parseTrimmedString(env, 'DISCOCLAW_SUMMARY_MODEL') ?? fastModel,
             summaryMaxChars: parseNonNegativeInt(env, 'DISCOCLAW_SUMMARY_MAX_CHARS', 2000),
@@ -710,19 +712,19 @@ export function parseConfig(env) {
             memoryConsolidationThreshold: parsePositiveInt(env, 'DISCOCLAW_MEMORY_CONSOLIDATION_THRESHOLD', 50),
             memoryConsolidationModel: parseTrimmedString(env, 'DISCOCLAW_MEMORY_CONSOLIDATION_MODEL') ?? fastModel,
             memoryCommandsEnabled: parseBoolean(env, 'DISCOCLAW_MEMORY_COMMANDS_ENABLED', true),
-            planCommandsEnabled: parseBoolean(env, 'DISCOCLAW_PLAN_COMMANDS_ENABLED', true),
-            planPhasesEnabled: parseBoolean(env, 'PLAN_PHASES_ENABLED', true),
+            planCommandsEnabled: parseBoolean(env, 'DISCOCLAW_PLAN_COMMANDS_ENABLED', false),
+            planPhasesEnabled: parseBoolean(env, 'PLAN_PHASES_ENABLED', parseBoolean(env, 'DISCOCLAW_PLAN_COMMANDS_ENABLED', false)),
             planPhaseMaxContextFiles: parsePositiveInt(env, 'PLAN_PHASE_MAX_CONTEXT_FILES', 5),
             planPhaseTimeoutMs: parsePositiveNumber(env, 'PLAN_PHASE_TIMEOUT_MS', DEFAULT_THIRTY_MINUTES_MS),
             planPhaseMaxAuditFixAttempts: parseNonNegativeInt(env, 'PLAN_PHASE_AUDIT_FIX_MAX', 3),
             planForgeHeartbeatIntervalMs: parseNonNegativeInt(env, 'PLAN_FORGE_HEARTBEAT_INTERVAL_MS', DEFAULT_PLAN_FORGE_HEARTBEAT_INTERVAL_MS),
-            forgeCommandsEnabled: parseBoolean(env, 'DISCOCLAW_FORGE_COMMANDS_ENABLED', true),
+            forgeCommandsEnabled: parseBoolean(env, 'DISCOCLAW_FORGE_COMMANDS_ENABLED', false),
             forgeMaxAuditRounds: parsePositiveInt(env, 'FORGE_MAX_AUDIT_ROUNDS', 5),
             forgeDrafterModel: parseTrimmedString(env, 'FORGE_DRAFTER_MODEL'),
             forgeAuditorModel: parseTrimmedString(env, 'FORGE_AUDITOR_MODEL'),
             forgeTimeoutMs: parsePositiveNumber(env, 'FORGE_TIMEOUT_MS', DEFAULT_THIRTY_MINUTES_MS),
             forgeProgressThrottleMs: parseNonNegativeInt(env, 'FORGE_PROGRESS_THROTTLE_MS', 3000),
-            forgeAutoImplement: parseBoolean(env, 'FORGE_AUTO_IMPLEMENT', true),
+            forgeAutoImplement: parseBoolean(env, 'FORGE_AUTO_IMPLEMENT', parseBoolean(env, 'DISCOCLAW_FORGE_COMMANDS_ENABLED', false)),
             completionNotifyEnabled: parseBoolean(env, 'DISCOCLAW_COMPLETION_NOTIFY', true),
             completionNotifyThresholdMs: parseNonNegativeInt(env, 'DISCOCLAW_COMPLETION_NOTIFY_THRESHOLD_MS', 30000),
             actionFollowupTimeoutMs: parseNonNegativeInt(env, 'DISCOCLAW_ACTION_FOLLOWUP_TIMEOUT_MS', 30000),

package/dist/config.test.js

@@ -275,9 +275,9 @@ describe('parseConfig', () => {
         const { config } = parseConfig(env());
         expect(config.discordActionsBotProfile).toBe(true);
     });
-    it('defaults discordActionsPlan to true', () => {
+    it('defaults discordActionsPlan to false', () => {
         const { config } = parseConfig(env());
-        expect(config.discordActionsPlan).toBe(true);
+        expect(config.discordActionsPlan).toBe(false);
     });
     it('defaults discordActionsEnabled to true', () => {
         const { config } = parseConfig(env());
@@ -503,9 +503,9 @@ describe('parseConfig', () => {
         expect(warnings.some((w) => w.includes('FORGE_AUDITOR_RUNTIME=openrouter'))).toBe(true);
     });
     // --- Forge auto-implement ---
-    it('defaults forgeAutoImplement to true', () => {
+    it('defaults forgeAutoImplement to false', () => {
         const { config } = parseConfig(env());
-        expect(config.forgeAutoImplement).toBe(true);
+        expect(config.forgeAutoImplement).toBe(false);
     });
     it('parses FORGE_AUTO_IMPLEMENT=0 as false', () => {
         const { config } = parseConfig(env({ FORGE_AUTO_IMPLEMENT: '0' }));
@@ -1192,4 +1192,20 @@ describe('parseConfig', () => {
         const { config } = parseConfig(env());
         expect(config.coldStorageChannelFilter).toEqual([]);
     });
+    it('defaults messageHistoryFetchLimit to 10', () => {
+        const { config } = parseConfig(env());
+        expect(config.messageHistoryFetchLimit).toBe(10);
+    });
+    it('parses DISCOCLAW_MESSAGE_HISTORY_FETCH_LIMIT when set', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_MESSAGE_HISTORY_FETCH_LIMIT: '25' }));
+        expect(config.messageHistoryFetchLimit).toBe(25);
+    });
+    it('defaults messageHistoryMaxAgeMs to 48 hours in milliseconds', () => {
+        const { config } = parseConfig(env());
+        expect(config.messageHistoryMaxAgeMs).toBe(48 * 3_600_000);
+    });
+    it('parses DISCOCLAW_MESSAGE_HISTORY_MAX_AGE_HOURS and converts to ms', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_MESSAGE_HISTORY_MAX_AGE_HOURS: '24' }));
+        expect(config.messageHistoryMaxAgeMs).toBe(24 * 3_600_000);
+    });
 });

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

@@ -452,4 +452,117 @@ describe('runCronSync', () => {
         expect(result.orphansDetected).toBe(1);
         expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ threadId: 'thread-orphan' }), expect.stringContaining('orphan'));
     });
+    it('sync preserves disabled flag without modifying it', async () => {
+        const forum = makeForum([{ id: 'thread-1', name: 'Paused Job', parentId: 'forum-1' }]);
+        const client = makeClient(forum);
+        const statsStore = makeStatsStore([
+            makeRecord({
+                cronId: 'cron-1',
+                threadId: 'thread-1',
+                disabled: true,
+                pauseSource: 'user',
+                cadence: 'daily',
+                purposeTags: ['monitoring'],
+                model: 'haiku',
+            }),
+        ]);
+        const scheduler = makeScheduler([
+            { id: 'thread-1', threadId: 'thread-1', cronId: 'cron-1', name: 'Paused Job', schedule: '0 7 * * *', prompt: 'Check things' },
+        ]);
+        await runCronSync({
+            client: client,
+            forumId: 'forum-1',
+            scheduler,
+            statsStore,
+            runtime: makeMockRuntime('monitoring'),
+            tagMap: { ...defaultTagMap },
+            autoTag: false,
+            autoTagModel: 'haiku',
+            cwd: '/tmp',
+            log: mockLog(),
+            throttleMs: 0,
+        });
+        // Verify disabled and pauseSource were not altered by sync
+        const record = statsStore.getRecord('cron-1');
+        expect(record?.disabled).toBe(true);
+        expect(record?.pauseSource).toBe('user');
+    });
+    it('phase 5: recreating disabled cron calls scheduler.disable on new thread', async () => {
+        const create = vi.fn(async ({ name, message }) => ({
+            id: 'thread-new',
+            name,
+            message,
+        }));
+        const forum = makeForum([], { create });
+        const client = makeClient(forum);
+        const statsStore = makeStatsStore([
+            makeRecord({
+                cronId: 'cron-disabled',
+                threadId: 'thread-old',
+                disabled: true,
+                pauseSource: 'user',
+                cadence: 'daily',
+                schedule: '0 7 * * *',
+                timezone: 'UTC',
+                channel: 'general',
+                prompt: 'Disabled job that needs thread recreation.',
+                projectionStatus: 'missing',
+                projectionHash: 'stale-hash',
+            }),
+        ]);
+        const scheduler = makeScheduler([]);
+        const result = await runCronSync({
+            client: client,
+            forumId: 'forum-1',
+            scheduler,
+            statsStore,
+            runtime: makeMockRuntime('monitoring'),
+            tagMap: { ...defaultTagMap },
+            autoTag: false,
+            autoTagModel: 'haiku',
+            cwd: '/tmp',
+            log: mockLog(),
+            throttleMs: 0,
+        });
+        expect(result.projectionsRepaired).toBe(1);
+        // Scheduler should have been called: register then disable
+        expect(scheduler.register).toHaveBeenCalled();
+        expect(scheduler.disable).toHaveBeenCalledWith('thread-new');
+        // Record should still be disabled after recreation
+        const record = statsStore.getRecord('cron-disabled');
+        expect(record?.disabled).toBe(true);
+        expect(record?.threadId).toBe('thread-new');
+    });
+    it('phase 3: updates status messages for disabled crons', async () => {
+        const forum = makeForum([{ id: 'thread-1', name: 'Paused Job', parentId: 'forum-1' }]);
+        const client = makeClient(forum);
+        const statsStore = makeStatsStore([
+            makeRecord({
+                cronId: 'cron-1',
+                threadId: 'thread-1',
+                disabled: true,
+                pauseSource: 'user',
+                cadence: 'daily',
+                model: 'haiku',
+            }),
+        ]);
+        const scheduler = makeScheduler([
+            { id: 'thread-1', threadId: 'thread-1', cronId: 'cron-1', name: 'Paused Job', schedule: '0 7 * * *', prompt: 'Check things' },
+        ]);
+        const result = await runCronSync({
+            client: client,
+            forumId: 'forum-1',
+            scheduler,
+            statsStore,
+            runtime: makeMockRuntime('monitoring'),
+            tagMap: { ...defaultTagMap },
+            autoTag: false,
+            autoTagModel: 'haiku',
+            cwd: '/tmp',
+            log: mockLog(),
+            throttleMs: 0,
+        });
+        // Disabled crons should still get status message updates
+        expect(result.statusMessagesUpdated).toBe(1);
+    });
 });

package/dist/cron/forum-sync.js

@@ -1,5 +1,5 @@
 import { ChannelType, EmbedBuilder } from 'discord.js';
-import { parseCronDefinition } from './parser.js';
+import { parseCronDefinition, parseStarterContent } from './parser.js';
 import { generateCronId, parseCronIdFromContent } from './run-stats.js';
 import { detectCadence } from './cadence.js';
 import { ensureStatusMessage } from './discord-sync.js';
@@ -106,15 +106,24 @@ async function loadThreadAsCron(thread, guildId, scheduler, runtime, opts) {
         }
         return false;
     }
-    const def = await parseCronDefinition(starter.content, runtime, { model: opts.cronModel, cwd: opts.cwd });
+    // Try deterministic parse of bot-formatted starter first (no LLM needed).
+    const deterministicDef = parseStarterContent(starter.content);
+    const def = deterministicDef ?? await parseCronDefinition(starter.content, runtime, { model: opts.cronModel, cwd: opts.cwd });
     if (!def) {
-        opts.log?.warn({ threadId: thread.id, name: thread.name }, 'cron:forum parse failed');
-        scheduler.disable(thread.id);
-        try {
-            await thread.send('Could not parse this cron definition. Please edit the starter message with a clearer schedule, timezone, target channel, and instruction.');
+        if (opts.isNew) {
+            // Fresh thread — user just created it and needs feedback.
+            opts.log?.warn({ threadId: thread.id, name: thread.name }, 'cron:forum parse failed');
+            scheduler.disable(thread.id);
+            try {
+                await thread.send('Could not parse this cron definition. Please edit the starter message with a clearer schedule, timezone, target channel, and instruction.');
+            }
+            catch {
+                // Ignore send failures.
+            }
         }
-        catch {
-            // Ignore send failures.
+        else {
+            // Boot/re-parse — soft failure: leave unregistered so cron-sync can retry.
+            opts.log?.warn({ threadId: thread.id, name: thread.name }, 'cron:forum parse failed (boot re-parse), skipping without disabling');
         }
         return false;
     }
@@ -417,15 +426,10 @@ export async function initCronForum(opts) {
             // Archive state changed.
             if (oldThread.archived !== newThread.archived) {
                 if (newThread.archived) {
-                    log?.info({ threadId: newThread.id }, 'cron:forum thread archived, disabling');
-                    scheduler.disable(newThread.id);
-                    // Persist disabled state.
-                    if (statsStore) {
-                        const record = statsStore.getRecordByThreadId(newThread.id);
-                        if (record) {
-                            void statsStore.upsertRecord(record.cronId, newThread.id, { disabled: true }).catch(() => { });
-                        }
-                    }
+                    // Auto-archive (Discord inactivity) must NOT disable crons.
+                    // Only explicit cronPause commands persist disabled: true.
+                    // The cron keeps firing to its target channel; the thread is just UI.
+                    log?.info({ threadId: newThread.id }, 'cron:forum thread archived (cron continues)');
                 }
                 else {
                     // Reject unarchived manual threads not already grandfathered into the scheduler.

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

@@ -1,7 +1,7 @@
 import { describe, expect, it, vi, beforeEach } from 'vitest';
 import { ChannelType } from 'discord.js';
 vi.mock('./parser.js', () => {
-    return { parseCronDefinition: vi.fn() };
+    return { parseCronDefinition: vi.fn(), parseStarterContent: vi.fn() };
 });
 // Mock ensureStatusMessage and detectCadence to avoid side effects.
 vi.mock('./discord-sync.js', async (importOriginal) => {
@@ -64,11 +64,13 @@ function makeScheduler() {
 describe('initCronForum', () => {
     let initCronForum;
     let parseCronDefinition;
+    let parseStarterContent;
     beforeEach(async () => {
         // Dynamic import after mocks are registered.
         ({ initCronForum } = await import('./forum-sync.js'));
-        ({ parseCronDefinition } = await import('./parser.js'));
+        ({ parseCronDefinition, parseStarterContent } = await import('./parser.js'));
         vi.mocked(parseCronDefinition).mockReset();
+        vi.mocked(parseStarterContent).mockReset();
     });
     it('does not register when starter author is not allowlisted', async () => {
         const thread = makeThread();
@@ -134,7 +136,7 @@ describe('initCronForum', () => {
         expect(scheduler.register).toHaveBeenCalledOnce();
         expect(scheduler.disable).not.toHaveBeenCalled();
     });
-    it('disables and reports when parsing fails', async () => {
+    it('soft-fails on boot re-parse (isNew: false) when both parsers return null — no disable, no error post', async () => {
         const thread = makeThread();
         thread.fetchStarterMessage.mockResolvedValue({
             id: 'm1',
@@ -157,8 +159,9 @@ describe('initCronForum', () => {
             log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
         });
         expect(scheduler.register).not.toHaveBeenCalled();
-        expect(scheduler.disable).toHaveBeenCalledOnce();
-        expect(thread.send).toHaveBeenCalledOnce();
+        // Boot re-parse: soft failure — no disable, no error message.
+        expect(scheduler.disable).not.toHaveBeenCalled();
+        expect(thread.send).not.toHaveBeenCalled();
     });
     it('registers when parsing succeeds and author is allowlisted', async () => {
         const thread = makeThread();
@@ -592,14 +595,129 @@ describe('initCronForum', () => {
         // Should disable the job because stats record says disabled: true.
         expect(scheduler.disable).toHaveBeenCalledWith('thread-1');
     });
+    it('uses deterministic parser when no stats record exists (AI parser not called)', async () => {
+        const thread = makeThread();
+        const botContent = [
+            '**Schedule:** `0 7 * * 1-5` (America/Los_Angeles)',
+            '**Channel:** #general',
+            '**Input:** prompt-only',
+            '',
+            'Check the weather.',
+        ].join('\n');
+        thread.fetchStarterMessage.mockResolvedValue({
+            id: 'm1',
+            content: botContent,
+            author: { id: 'bot-user-1' },
+            react: vi.fn().mockResolvedValue(undefined),
+        });
+        thread.messages.fetch = vi.fn().mockResolvedValue(new Map());
+        const forum = makeForum([thread]);
+        const client = makeClient(forum);
+        const scheduler = makeScheduler();
+        scheduler.register.mockReturnValue({ cron: { nextRun: () => new Date() } });
+        // No stats store — fast path is skipped, falls into loadThreadAsCron.
+        // Deterministic parser returns a valid def.
+        vi.mocked(parseStarterContent).mockReturnValue({
+            triggerType: 'schedule',
+            schedule: '0 7 * * 1-5',
+            timezone: 'America/Los_Angeles',
+            channel: 'general',
+            prompt: 'Check the weather.',
+        });
+        await initCronForum({
+            client: client,
+            forumChannelNameOrId: 'forum-1',
+            allowUserIds: new Set(['u-allowed']),
+            scheduler: scheduler,
+            runtime: {},
+            cronModel: 'haiku',
+            cwd: '/tmp',
+            log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+        });
+        // Deterministic parser was called, AI parser was NOT called.
+        expect(parseStarterContent).toHaveBeenCalledWith(botContent);
+        expect(parseCronDefinition).not.toHaveBeenCalled();
+        expect(scheduler.register).toHaveBeenCalledOnce();
+    });
+    it('falls through to AI parser when deterministic parse returns null', async () => {
+        const thread = makeThread();
+        thread.fetchStarterMessage.mockResolvedValue({
+            id: 'm1',
+            content: 'Every weekday at 7am Pacific, check the weather and post to #general',
+            author: { id: 'u-allowed' },
+            react: vi.fn().mockResolvedValue(undefined),
+        });
+        thread.messages.fetch = vi.fn().mockResolvedValue(new Map());
+        const forum = makeForum([thread]);
+        const client = makeClient(forum);
+        const scheduler = makeScheduler();
+        scheduler.register.mockReturnValue({ cron: { nextRun: () => new Date() } });
+        // Deterministic parser returns null (freeform text).
+        vi.mocked(parseStarterContent).mockReturnValue(null);
+        vi.mocked(parseCronDefinition).mockResolvedValue({
+            triggerType: 'schedule',
+            schedule: '0 7 * * 1-5',
+            timezone: 'America/Los_Angeles',
+            channel: 'general',
+            prompt: 'Check the weather.',
+        });
+        await initCronForum({
+            client: client,
+            forumChannelNameOrId: 'forum-1',
+            allowUserIds: new Set(['u-allowed']),
+            scheduler: scheduler,
+            runtime: {},
+            cronModel: 'haiku',
+            cwd: '/tmp',
+            log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+        });
+        // Deterministic parser was called first, then AI parser.
+        expect(parseStarterContent).toHaveBeenCalled();
+        expect(parseCronDefinition).toHaveBeenCalled();
+        expect(scheduler.register).toHaveBeenCalledOnce();
+    });
+    it('new thread (isNew: true) still posts error when both parsers fail', async () => {
+        // This test uses the threadCreate listener which passes isNew: true.
+        const forum = makeForum([]);
+        const client = makeClient(forum);
+        const scheduler = makeScheduler();
+        scheduler.getJob.mockReturnValue(undefined);
+        await initCronForum({
+            client: client,
+            forumChannelNameOrId: 'forum-1',
+            allowUserIds: new Set(['u-allowed']),
+            scheduler: scheduler,
+            runtime: {},
+            cronModel: 'haiku',
+            cwd: '/tmp',
+            log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+        });
+        const threadCreateCallbacks = client._listeners['threadCreate'] ?? [];
+        const listener = threadCreateCallbacks[0];
+        vi.mocked(parseStarterContent).mockReturnValue(null);
+        vi.mocked(parseCronDefinition).mockResolvedValue(null);
+        const thread = makeThread({ id: 'thread-new-fail', parentId: 'forum-1' });
+        thread.fetchStarterMessage.mockResolvedValue({
+            id: 'm1',
+            content: 'total nonsense',
+            author: { id: 'bot-user-1' },
+            react: vi.fn().mockResolvedValue(undefined),
+        });
+        await listener(thread);
+        // isNew: true — should disable and post error message.
+        expect(scheduler.disable).toHaveBeenCalledWith('thread-new-fail');
+        expect(thread.send).toHaveBeenCalledWith(expect.stringContaining('Could not parse'));
+    });
 });
 describe('threadCreate listener', () => {
     let initCronForum;
     let parseCronDefinition;
+    let parseStarterContent;
     beforeEach(async () => {
         ({ initCronForum } = await import('./forum-sync.js'));
-        ({ parseCronDefinition } = await import('./parser.js'));
+        ({ parseCronDefinition, parseStarterContent } = await import('./parser.js'));
         vi.mocked(parseCronDefinition).mockReset();
+        vi.mocked(parseStarterContent).mockReset();
     });
     async function setupAndGetListener(opts = {}) {
         const forum = makeForum([]);
@@ -712,10 +830,12 @@ describe('threadCreate listener', () => {
 describe('threadUpdate listener', () => {
     let initCronForum;
     let parseCronDefinition;
+    let parseStarterContent;
     beforeEach(async () => {
         ({ initCronForum } = await import('./forum-sync.js'));
-        ({ parseCronDefinition } = await import('./parser.js'));
+        ({ parseCronDefinition, parseStarterContent } = await import('./parser.js'));
         vi.mocked(parseCronDefinition).mockReset();
+        vi.mocked(parseStarterContent).mockReset();
     });
     async function setupAndGetListener(opts = {}) {
         const forum = makeForum([]);
@@ -730,11 +850,64 @@ describe('threadUpdate listener', () => {
             cronModel: 'haiku',
             cwd: '/tmp',
             log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+            statsStore: opts.statsStore,
         });
         const threadUpdateCallbacks = client._listeners['threadUpdate'] ?? [];
         expect(threadUpdateCallbacks.length).toBeGreaterThan(0);
         return { listener: threadUpdateCallbacks[0], scheduler, client };
     }
+    it('does not disable scheduler or persist disabled when thread is archived', async () => {
+        const scheduler = makeScheduler();
+        const statsStore = {
+            getRecordByThreadId: vi.fn().mockReturnValue({ cronId: 'cron-1', threadId: 'thread-1', disabled: false }),
+            getRecord: vi.fn(),
+            getStore: vi.fn().mockReturnValue({ jobs: {} }),
+            upsertRecord: vi.fn(async () => ({})),
+        };
+        const { listener } = await setupAndGetListener({ scheduler, statsStore });
+        const oldThread = makeThread({ id: 'thread-1', parentId: 'forum-1', archived: false });
+        const newThread = makeThread({ id: 'thread-1', parentId: 'forum-1', archived: true });
+        await listener(oldThread, newThread);
+        // Archiving should NOT disable the scheduler — cron keeps running.
+        expect(scheduler.disable).not.toHaveBeenCalled();
+        // Should NOT persist disabled: true to the stats store.
+        expect(statsStore.upsertRecord).not.toHaveBeenCalled();
+    });
+    it('cron survives archive+unarchive cycle without becoming stuck disabled', async () => {
+        const scheduler = makeScheduler();
+        scheduler.register.mockReturnValue({ cron: { nextRun: () => new Date() } });
+        vi.mocked(parseCronDefinition).mockResolvedValue({
+            triggerType: 'schedule',
+            schedule: '0 7 * * *',
+            timezone: 'UTC',
+            channel: 'general',
+            prompt: 'Say hello.',
+        });
+        const statsStore = {
+            getRecordByThreadId: vi.fn().mockReturnValue({ cronId: 'cron-1', threadId: 'thread-1', disabled: false }),
+            getRecord: vi.fn().mockReturnValue({ cronId: 'cron-1', threadId: 'thread-1', disabled: false }),
+            getStore: vi.fn().mockReturnValue({ jobs: {} }),
+            upsertRecord: vi.fn(async () => ({})),
+        };
+        const { listener } = await setupAndGetListener({ scheduler, statsStore });
+        // Step 1: archive
+        const oldThread = makeThread({ id: 'thread-1', parentId: 'forum-1', archived: false });
+        const archivedThread = makeThread({ id: 'thread-1', parentId: 'forum-1', archived: true });
+        await listener(oldThread, archivedThread);
+        // Step 2: unarchive
+        const unarchivedThread = makeThread({ id: 'thread-1', parentId: 'forum-1', archived: false });
+        unarchivedThread.fetchStarterMessage.mockResolvedValue({
+            id: 'm1',
+            content: 'every day at 7am say hello',
+            author: { id: 'u-allowed' },
+            react: vi.fn().mockResolvedValue(undefined),
+        });
+        unarchivedThread.messages = { fetch: vi.fn().mockResolvedValue(new Map()) };
+        await listener(archivedThread, unarchivedThread);
+        // The cron should be re-registered, NOT disabled.
+        expect(scheduler.register).toHaveBeenCalled();
+        expect(scheduler.disable).not.toHaveBeenCalled();
+    });
     it('rejects unarchived manual thread not in scheduler', async () => {
         const scheduler = makeScheduler();
         scheduler.getJob.mockReturnValue(undefined);

package/dist/cron/parser.js

@@ -1,5 +1,68 @@
 import { resolveModel } from '../runtime/model-tiers.js';
 import { getDefaultTimezone } from './default-timezone.js';
+/**
+ * Deterministic parser for bot-formatted starter messages produced by
+ * `buildStarterContent` in `src/discord/actions-crons.ts`.
+ *
+ * Expected format:
+ *   **Schedule:** `<schedule>` (<timezone>)
+ *   **Channel:** #<channel>
+ *   **Input:** <input-mode>
+ *   [optional ```bash block```]
+ *
+ *   <prompt text>
+ *
+ * Returns null if any required field is missing — non-bot-formatted
+ * messages silently fall through to AI.
+ */
+export function parseStarterContent(text) {
+    // Extract schedule and timezone from: **Schedule:** `<schedule>` (<timezone>)
+    const scheduleMatch = text.match(/\*\*Schedule:\*\*\s*`([^`]+)`\s*\(([^)]+)\)/);
+    if (!scheduleMatch)
+        return null;
+    const schedule = scheduleMatch[1].trim();
+    const timezone = scheduleMatch[2].trim();
+    if (!schedule || !timezone)
+        return null;
+    // Extract channel from: **Channel:** #<channel>
+    const channelMatch = text.match(/\*\*Channel:\*\*\s*#(\S+)/);
+    if (!channelMatch)
+        return null;
+    const channel = channelMatch[1].trim();
+    if (!channel)
+        return null;
+    // The prompt is everything after the blank-line separator following the metadata block.
+    // The metadata block ends after the **Input:** line (and optional ```bash``` block).
+    // Split on the first blank line that follows the metadata lines.
+    const lines = text.split('\n');
+    let blankLineIdx = -1;
+    let pastMetadata = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Track when we've passed the metadata lines (lines starting with ** or code fences)
+        if (line.startsWith('**') || line.startsWith('```')) {
+            pastMetadata = true;
+            continue;
+        }
+        // After metadata, find the first blank line
+        if (pastMetadata && line.trim() === '') {
+            blankLineIdx = i;
+            break;
+        }
+    }
+    if (blankLineIdx === -1)
+        return null;
+    const prompt = lines.slice(blankLineIdx + 1).join('\n').trim();
+    if (!prompt)
+        return null;
+    return {
+        triggerType: 'schedule',
+        schedule,
+        timezone,
+        channel,
+        prompt,
+    };
+}
 function buildSystemPrompt() {
     const defaultTz = getDefaultTimezone();
     return `You are a cron definition parser. Extract a cron schedule from a natural-language task description.