discoclaw 0.1.0

package/dist/config.test.js

@@ -0,0 +1,589 @@
+import { describe, expect, it } from 'vitest';
+import { parseConfig, DEFAULT_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT, DEFAULT_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS, } from './config.js';
+function env(overrides = {}) {
+    return {
+        DISCORD_TOKEN: 'token',
+        DISCORD_ALLOW_USER_IDS: '123',
+        // Provide valid snowflakes for forums that are enabled by default.
+        DISCOCLAW_CRON_FORUM: '1000000000000000001',
+        DISCOCLAW_TASKS_FORUM: '1000000000000000002',
+        ...overrides,
+    };
+}
+describe('parseConfig', () => {
+    it('parses required fields and defaults', () => {
+        const { config, warnings, infos } = parseConfig(env());
+        expect(config.token).toBe('token');
+        expect(config.allowUserIds.has('123')).toBe(true);
+        expect(config.primaryRuntime).toBe('claude');
+        expect(config.runtimeModel).toBe('capable');
+        expect(config.summaryModel).toBe('fast');
+        expect(config.cronModel).toBe('fast');
+        expect(config.cronAutoTagModel).toBe('fast');
+        expect(config.tasksAutoTagModel).toBe('fast');
+        expect(config.tasksSyncFailureRetryEnabled).toBe(true);
+        expect(config.tasksSyncFailureRetryDelayMs).toBe(30_000);
+        expect(config.tasksSyncDeferredRetryDelayMs).toBe(30_000);
+        expect(config.outputFormat).toBe('text');
+        expect(warnings.some((w) => w.includes('category flags are ignored'))).toBe(false);
+        expect(infos.some((i) => i.includes('category flags are ignored'))).toBe(false);
+    });
+    it('throws on invalid boolean values', () => {
+        expect(() => parseConfig(env({ DISCOCLAW_SUMMARY_ENABLED: 'yes' })))
+            .toThrow(/DISCOCLAW_SUMMARY_ENABLED must be "0"\/"1" or "true"\/"false"/);
+    });
+    it('parses true/false booleans', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_SUMMARY_ENABLED: 'false', DISCOCLAW_CRON_ENABLED: 'true' }));
+        expect(config.summaryEnabled).toBe(false);
+        expect(config.cronEnabled).toBe(true);
+    });
+    it('throws on invalid numeric values', () => {
+        expect(() => parseConfig(env({ RUNTIME_TIMEOUT_MS: '-1' })))
+            .toThrow(/RUNTIME_TIMEOUT_MS must be a positive number/);
+    });
+    it('warns (does not throw) on unknown runtime tools', () => {
+        const { config, warnings } = parseConfig(env({ RUNTIME_TOOLS: 'Read,InvalidTool' }));
+        expect(config.runtimeTools).toEqual(['Read', 'InvalidTool']);
+        expect(warnings.some((w) => w.includes('RUNTIME_TOOLS includes unknown tools'))).toBe(true);
+    });
+    it('warns when DISCORD_CHANNEL_IDS has no valid IDs', () => {
+        const { warnings } = parseConfig(env({ DISCORD_CHANNEL_IDS: 'abc def' }));
+        expect(warnings.some((w) => w.includes('DISCORD_CHANNEL_IDS was set but no valid IDs'))).toBe(true);
+    });
+    it('parses PRIMARY_RUNTIME and normalizes claude_code alias', () => {
+        const { config } = parseConfig(env({ PRIMARY_RUNTIME: 'claude_code' }));
+        expect(config.primaryRuntime).toBe('claude');
+    });
+    it('warns when PRIMARY_RUNTIME=openai without OPENAI_API_KEY', () => {
+        const { warnings } = parseConfig(env({ PRIMARY_RUNTIME: 'openai', OPENAI_API_KEY: undefined }));
+        expect(warnings.some((w) => w.includes('PRIMARY_RUNTIME=openai'))).toBe(true);
+    });
+    it('does not warn about action category flags when master actions are enabled', () => {
+        const { warnings, infos } = parseConfig(env({ DISCOCLAW_DISCORD_ACTIONS: '1' }));
+        expect(warnings.some((w) => w.includes('category flags are ignored'))).toBe(false);
+        expect(infos.some((i) => i.includes('category flags are ignored'))).toBe(false);
+    });
+    it('defaults discordActionsDefer settings', () => {
+        const { config } = parseConfig(env());
+        expect(config.discordActionsDefer).toBe(true);
+        expect(config.deferMaxDelaySeconds).toBe(DEFAULT_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS);
+        expect(config.deferMaxConcurrent).toBe(DEFAULT_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT);
+    });
+    it('parses defer config overrides', () => {
+        const { config } = parseConfig(env({
+            DISCOCLAW_DISCORD_ACTIONS_DEFER: '1',
+            DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS: '900',
+            DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT: '2',
+        }));
+        expect(config.discordActionsDefer).toBe(true);
+        expect(config.deferMaxDelaySeconds).toBe(900);
+        expect(config.deferMaxConcurrent).toBe(2);
+    });
+    it('reports ignored action category flags as info-level advisories', () => {
+        const { warnings, infos } = parseConfig(env({
+            DISCOCLAW_DISCORD_ACTIONS: '0',
+            DISCOCLAW_DISCORD_ACTIONS_MESSAGING: '1',
+        }));
+        expect(warnings.some((w) => w.includes('category flags are ignored'))).toBe(false);
+        expect(infos.some((i) => i.includes('category flags are ignored'))).toBe(true);
+    });
+    it('reports ignored defer category flag when master actions off', () => {
+        const { infos } = parseConfig(env({
+            DISCOCLAW_DISCORD_ACTIONS: '0',
+            DISCOCLAW_DISCORD_ACTIONS_DEFER: '1',
+        }));
+        expect(infos.some((i) => i.includes('DISCOCLAW_DISCORD_ACTIONS_DEFER'))).toBe(true);
+    });
+    it('parses DISCOCLAW_BOT_NAME when set', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_BOT_NAME: 'Weston' }));
+        expect(config.botDisplayName).toBe('Weston');
+    });
+    it('returns undefined for botDisplayName when DISCOCLAW_BOT_NAME is unset', () => {
+        const { config } = parseConfig(env());
+        expect(config.botDisplayName).toBeUndefined();
+    });
+    it('returns undefined for botDisplayName when DISCOCLAW_BOT_NAME is whitespace-only', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_BOT_NAME: '   ' }));
+        expect(config.botDisplayName).toBeUndefined();
+    });
+    // --- Bot profile: status ---
+    it('parses valid bot status values', () => {
+        for (const status of ['online', 'idle', 'dnd', 'invisible']) {
+            const { config } = parseConfig(env({ DISCOCLAW_BOT_STATUS: status }));
+            expect(config.botStatus).toBe(status);
+        }
+    });
+    it('parses bot status case-insensitively', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_BOT_STATUS: 'DND' }));
+        expect(config.botStatus).toBe('dnd');
+    });
+    it('throws on invalid bot status', () => {
+        expect(() => parseConfig(env({ DISCOCLAW_BOT_STATUS: 'away' })))
+            .toThrow(/DISCOCLAW_BOT_STATUS must be one of online\|idle\|dnd\|invisible/);
+    });
+    it('returns undefined for botStatus when unset', () => {
+        const { config } = parseConfig(env());
+        expect(config.botStatus).toBeUndefined();
+    });
+    // --- Bot profile: activity type ---
+    it('defaults botActivityType to Playing', () => {
+        const { config } = parseConfig(env());
+        expect(config.botActivityType).toBe('Playing');
+    });
+    it('parses activity type case-insensitively', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_BOT_ACTIVITY_TYPE: 'listening' }));
+        expect(config.botActivityType).toBe('Listening');
+    });
+    it('throws on invalid activity type', () => {
+        expect(() => parseConfig(env({ DISCOCLAW_BOT_ACTIVITY_TYPE: 'Streaming' })))
+            .toThrow(/DISCOCLAW_BOT_ACTIVITY_TYPE must be one of Playing\|Listening\|Watching\|Competing\|Custom/);
+    });
+    // --- Bot profile: avatar ---
+    it('accepts absolute file path for botAvatar', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_BOT_AVATAR: '/home/user/avatar.png' }));
+        expect(config.botAvatar).toBe('/home/user/avatar.png');
+    });
+    it('accepts https URL for botAvatar', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_BOT_AVATAR: 'https://example.com/avatar.png' }));
+        expect(config.botAvatar).toBe('https://example.com/avatar.png');
+    });
+    it('accepts http URL for botAvatar', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_BOT_AVATAR: 'http://example.com/avatar.png' }));
+        expect(config.botAvatar).toBe('http://example.com/avatar.png');
+    });
+    it('rejects relative path for botAvatar', () => {
+        expect(() => parseConfig(env({ DISCOCLAW_BOT_AVATAR: 'images/avatar.png' })))
+            .toThrow('DISCOCLAW_BOT_AVATAR must be an absolute file path or URL');
+    });
+    it('returns undefined for botAvatar when unset', () => {
+        const { config } = parseConfig(env());
+        expect(config.botAvatar).toBeUndefined();
+    });
+    // --- Bot profile: action flag ---
+    it('defaults discordActionsBotProfile to true', () => {
+        const { config } = parseConfig(env());
+        expect(config.discordActionsBotProfile).toBe(true);
+    });
+    it('defaults discordActionsPlan to true', () => {
+        const { config } = parseConfig(env());
+        expect(config.discordActionsPlan).toBe(true);
+    });
+    it('defaults discordActionsEnabled to true', () => {
+        const { config } = parseConfig(env());
+        expect(config.discordActionsEnabled).toBe(true);
+    });
+    it('defaults discordActionsMessaging to true', () => {
+        const { config } = parseConfig(env());
+        expect(config.discordActionsMessaging).toBe(true);
+    });
+    it('defaults discordActionsGuild to true', () => {
+        const { config } = parseConfig(env());
+        expect(config.discordActionsGuild).toBe(true);
+    });
+    it('defaults discordActionsPolls to true', () => {
+        const { config } = parseConfig(env());
+        expect(config.discordActionsPolls).toBe(true);
+    });
+    it('defaults discordActionsMemory to true', () => {
+        const { config } = parseConfig(env());
+        expect(config.discordActionsMemory).toBe(true);
+    });
+    it('defaults sessionScanning to true', () => {
+        const { config } = parseConfig(env());
+        expect(config.sessionScanning).toBe(true);
+    });
+    it('defaults toolAwareStreaming to true', () => {
+        const { config } = parseConfig(env());
+        expect(config.toolAwareStreaming).toBe(true);
+    });
+    it('defaults cronAutoTag to true', () => {
+        const { config } = parseConfig(env());
+        expect(config.cronAutoTag).toBe(true);
+    });
+    it('defaults autoJoinThreads to true', () => {
+        const { config } = parseConfig(env());
+        expect(config.autoJoinThreads).toBe(true);
+    });
+    it('reports ignored bot profile action flag when master actions off', () => {
+        const { infos } = parseConfig(env({
+            DISCOCLAW_DISCORD_ACTIONS: '0',
+            DISCOCLAW_DISCORD_ACTIONS_BOT_PROFILE: '1',
+        }));
+        expect(infos.some((i) => i.includes('DISCOCLAW_DISCORD_ACTIONS_BOT_PROFILE'))).toBe(true);
+    });
+    // --- FORGE_DRAFTER_RUNTIME ---
+    it('returns undefined for forgeDrafterRuntime when unset', () => {
+        const { config } = parseConfig(env());
+        expect(config.forgeDrafterRuntime).toBeUndefined();
+    });
+    it('parses FORGE_DRAFTER_RUNTIME=openai', () => {
+        const { config } = parseConfig(env({ FORGE_DRAFTER_RUNTIME: 'openai', OPENAI_API_KEY: 'sk-test' }));
+        expect(config.forgeDrafterRuntime).toBe('openai');
+    });
+    it('normalizes FORGE_DRAFTER_RUNTIME claude_code to claude', () => {
+        const { config } = parseConfig(env({ FORGE_DRAFTER_RUNTIME: 'claude_code' }));
+        expect(config.forgeDrafterRuntime).toBe('claude');
+    });
+    it('warns when FORGE_DRAFTER_RUNTIME=openai without OPENAI_API_KEY', () => {
+        const { warnings } = parseConfig(env({ FORGE_DRAFTER_RUNTIME: 'openai', OPENAI_API_KEY: undefined }));
+        expect(warnings.some((w) => w.includes('FORGE_DRAFTER_RUNTIME=openai'))).toBe(true);
+    });
+    // --- OpenRouter adapter ---
+    it('parses OPENROUTER_API_KEY when set', () => {
+        const { config } = parseConfig(env({ OPENROUTER_API_KEY: 'sk-or-test' }));
+        expect(config.openrouterApiKey).toBe('sk-or-test');
+    });
+    it('defaults openrouterModel to "anthropic/claude-sonnet-4"', () => {
+        const { config } = parseConfig(env());
+        expect(config.openrouterModel).toBe('anthropic/claude-sonnet-4');
+    });
+    it('warns when PRIMARY_RUNTIME=openrouter without OPENROUTER_API_KEY', () => {
+        const { warnings } = parseConfig(env({ PRIMARY_RUNTIME: 'openrouter', OPENROUTER_API_KEY: undefined }));
+        expect(warnings.some((w) => w.includes('PRIMARY_RUNTIME=openrouter'))).toBe(true);
+    });
+    it('warns when FORGE_DRAFTER_RUNTIME=openrouter without OPENROUTER_API_KEY', () => {
+        const { warnings } = parseConfig(env({ FORGE_DRAFTER_RUNTIME: 'openrouter', OPENROUTER_API_KEY: undefined }));
+        expect(warnings.some((w) => w.includes('FORGE_DRAFTER_RUNTIME=openrouter'))).toBe(true);
+    });
+    it('warns when FORGE_AUDITOR_RUNTIME=openrouter without OPENROUTER_API_KEY', () => {
+        const { warnings } = parseConfig(env({ FORGE_AUDITOR_RUNTIME: 'openrouter', OPENROUTER_API_KEY: undefined }));
+        expect(warnings.some((w) => w.includes('FORGE_AUDITOR_RUNTIME=openrouter'))).toBe(true);
+    });
+    // --- Forge auto-implement ---
+    it('defaults forgeAutoImplement to true', () => {
+        const { config } = parseConfig(env());
+        expect(config.forgeAutoImplement).toBe(true);
+    });
+    it('parses FORGE_AUTO_IMPLEMENT=0 as false', () => {
+        const { config } = parseConfig(env({ FORGE_AUTO_IMPLEMENT: '0' }));
+        expect(config.forgeAutoImplement).toBe(false);
+    });
+    it('parses FORGE_AUTO_IMPLEMENT=true as true', () => {
+        const { config } = parseConfig(env({ FORGE_AUTO_IMPLEMENT: 'true' }));
+        expect(config.forgeAutoImplement).toBe(true);
+    });
+    // --- Summary-to-durable ---
+    it('defaults summaryToDurableEnabled to true', () => {
+        const { config } = parseConfig(env());
+        expect(config.summaryToDurableEnabled).toBe(true);
+    });
+    it('parses DISCOCLAW_SUMMARY_TO_DURABLE_ENABLED=1 as true', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_SUMMARY_TO_DURABLE_ENABLED: '1' }));
+        expect(config.summaryToDurableEnabled).toBe(true);
+    });
+    // --- Short-term memory ---
+    it('defaults shortTermMemoryEnabled to true', () => {
+        const { config } = parseConfig(env());
+        expect(config.shortTermMemoryEnabled).toBe(true);
+    });
+    it('parses short-term memory config fields', () => {
+        const { config } = parseConfig(env({
+            DISCOCLAW_SHORTTERM_MEMORY_ENABLED: '1',
+            DISCOCLAW_SHORTTERM_MAX_ENTRIES: '10',
+            DISCOCLAW_SHORTTERM_MAX_AGE_HOURS: '12',
+            DISCOCLAW_SHORTTERM_INJECT_MAX_CHARS: '500',
+        }));
+        expect(config.shortTermMemoryEnabled).toBe(true);
+        expect(config.shortTermMaxEntries).toBe(10);
+        expect(config.shortTermMaxAgeHours).toBe(12);
+        expect(config.shortTermInjectMaxChars).toBe(500);
+    });
+    it('parses DISCOCLAW_SHORTTERM_MEMORY_ENABLED=0 as false', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_SHORTTERM_MEMORY_ENABLED: '0' }));
+        expect(config.shortTermMemoryEnabled).toBe(false);
+    });
+    it('uses default values for short-term memory fields', () => {
+        const { config } = parseConfig(env());
+        expect(config.shortTermMaxEntries).toBe(20);
+        expect(config.shortTermMaxAgeHours).toBe(6);
+        expect(config.shortTermInjectMaxChars).toBe(1000);
+    });
+    // --- Tasks enabled ---
+    it('defaults tasksEnabled to true', () => {
+        const { config } = parseConfig(env());
+        expect(config.tasksEnabled).toBe(true);
+    });
+    // --- Tasks sidebar ---
+    it('defaults tasksSidebar to true', () => {
+        const { config } = parseConfig(env());
+        expect(config.tasksSidebar).toBe(true);
+    });
+    it('parses DISCOCLAW_TASKS_SIDEBAR=1 as true', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_TASKS_SIDEBAR: '1' }));
+        expect(config.tasksSidebar).toBe(true);
+    });
+    // --- Fallback model ---
+    it('parses RUNTIME_FALLBACK_MODEL when set', () => {
+        const { config } = parseConfig(env({ RUNTIME_FALLBACK_MODEL: 'sonnet' }));
+        expect(config.runtimeFallbackModel).toBe('sonnet');
+    });
+    it('returns undefined for runtimeFallbackModel when unset', () => {
+        const { config } = parseConfig(env());
+        expect(config.runtimeFallbackModel).toBeUndefined();
+    });
+    // --- Max budget USD ---
+    it('parses RUNTIME_MAX_BUDGET_USD positive number', () => {
+        const { config } = parseConfig(env({ RUNTIME_MAX_BUDGET_USD: '5.00' }));
+        expect(config.runtimeMaxBudgetUsd).toBe(5);
+    });
+    it('returns undefined for runtimeMaxBudgetUsd when unset', () => {
+        const { config } = parseConfig(env());
+        expect(config.runtimeMaxBudgetUsd).toBeUndefined();
+    });
+    it('throws on RUNTIME_MAX_BUDGET_USD=0', () => {
+        expect(() => parseConfig(env({ RUNTIME_MAX_BUDGET_USD: '0' })))
+            .toThrow(/RUNTIME_MAX_BUDGET_USD must be a positive number/);
+    });
+    it('throws on RUNTIME_MAX_BUDGET_USD negative', () => {
+        expect(() => parseConfig(env({ RUNTIME_MAX_BUDGET_USD: '-1' })))
+            .toThrow(/RUNTIME_MAX_BUDGET_USD must be a positive number/);
+    });
+    it('throws on RUNTIME_MAX_BUDGET_USD non-numeric', () => {
+        expect(() => parseConfig(env({ RUNTIME_MAX_BUDGET_USD: 'abc' })))
+            .toThrow(/RUNTIME_MAX_BUDGET_USD must be a positive number/);
+    });
+    // --- Append system prompt ---
+    it('parses CLAUDE_APPEND_SYSTEM_PROMPT when set', () => {
+        const { config } = parseConfig(env({ CLAUDE_APPEND_SYSTEM_PROMPT: 'You are Weston.' }));
+        expect(config.appendSystemPrompt).toBe('You are Weston.');
+    });
+    it('returns undefined for appendSystemPrompt when unset', () => {
+        const { config } = parseConfig(env());
+        expect(config.appendSystemPrompt).toBeUndefined();
+    });
+    it('throws when CLAUDE_APPEND_SYSTEM_PROMPT exceeds 4000 chars', () => {
+        expect(() => parseConfig(env({ CLAUDE_APPEND_SYSTEM_PROMPT: 'x'.repeat(4001) })))
+            .toThrow(/CLAUDE_APPEND_SYSTEM_PROMPT exceeds 4000 char limit/);
+    });
+    it('accepts CLAUDE_APPEND_SYSTEM_PROMPT at exactly 4000 chars', () => {
+        const { config } = parseConfig(env({ CLAUDE_APPEND_SYSTEM_PROMPT: 'x'.repeat(4000) }));
+        expect(config.appendSystemPrompt).toHaveLength(4000);
+    });
+    // --- Default tools include Glob, Grep, Write ---
+    it('default RUNTIME_TOOLS includes Glob, Grep, Write', () => {
+        const { config } = parseConfig(env());
+        expect(config.runtimeTools).toEqual(['Bash', 'Read', 'Write', 'Edit', 'Glob', 'Grep', 'WebSearch', 'WebFetch']);
+    });
+    // --- Reaction remove handler ---
+    it('defaults reactionRemoveHandlerEnabled to false', () => {
+        const { config } = parseConfig(env());
+        expect(config.reactionRemoveHandlerEnabled).toBe(false);
+    });
+    it('parses DISCOCLAW_REACTION_REMOVE_HANDLER=1 as true', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_REACTION_REMOVE_HANDLER: '1' }));
+        expect(config.reactionRemoveHandlerEnabled).toBe(true);
+    });
+    // --- Gemini CLI adapter ---
+    it('defaults geminiBin to "gemini"', () => {
+        const { config } = parseConfig(env());
+        expect(config.geminiBin).toBe('gemini');
+    });
+    it('parses GEMINI_BIN when set', () => {
+        const { config } = parseConfig(env({ GEMINI_BIN: '/usr/local/bin/gemini' }));
+        expect(config.geminiBin).toBe('/usr/local/bin/gemini');
+    });
+    it('defaults geminiModel to "gemini-2.5-pro"', () => {
+        const { config } = parseConfig(env());
+        expect(config.geminiModel).toBe('gemini-2.5-pro');
+    });
+    it('parses GEMINI_MODEL when set', () => {
+        const { config } = parseConfig(env({ GEMINI_MODEL: 'gemini-2.0-flash' }));
+        expect(config.geminiModel).toBe('gemini-2.0-flash');
+    });
+    it('does not warn when PRIMARY_RUNTIME=gemini (no preflight-checkable auth)', () => {
+        const { warnings } = parseConfig(env({ PRIMARY_RUNTIME: 'gemini' }));
+        expect(warnings.some((w) => w.includes('gemini'))).toBe(false);
+    });
+    // --- Codex dangerous bypass ---
+    it('defaults codexDangerouslyBypassApprovalsAndSandbox to false', () => {
+        const { config } = parseConfig(env());
+        expect(config.codexDangerouslyBypassApprovalsAndSandbox).toBe(false);
+    });
+    it('parses CODEX_DANGEROUSLY_BYPASS_APPROVALS_AND_SANDBOX=1 as true', () => {
+        const { config } = parseConfig(env({ CODEX_DANGEROUSLY_BYPASS_APPROVALS_AND_SANDBOX: '1' }));
+        expect(config.codexDangerouslyBypassApprovalsAndSandbox).toBe(true);
+    });
+    it('defaults codexDisableSessions to false', () => {
+        const { config } = parseConfig(env());
+        expect(config.codexDisableSessions).toBe(false);
+    });
+    it('parses CODEX_DISABLE_SESSIONS=1 as true', () => {
+        const { config } = parseConfig(env({ CODEX_DISABLE_SESSIONS: '1' }));
+        expect(config.codexDisableSessions).toBe(true);
+    });
+    // --- Forum ID validation (auto-create when missing, warn on invalid) ---
+    it('allows missing cronForum when cronEnabled (bootstrap will auto-create)', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_CRON_ENABLED: '1', DISCOCLAW_CRON_FORUM: undefined }));
+        expect(config.cronEnabled).toBe(true);
+        expect(config.cronForum).toBeUndefined();
+    });
+    it('warns and clears cronForum when not a snowflake', () => {
+        const { config, warnings } = parseConfig(env({ DISCOCLAW_CRON_ENABLED: '1', DISCOCLAW_CRON_FORUM: 'crons' }));
+        expect(config.cronForum).toBeUndefined();
+        expect(warnings.some(w => w.includes('DISCOCLAW_CRON_FORUM is not a valid snowflake'))).toBe(true);
+    });
+    it('accepts valid snowflake for cronForum when cronEnabled=true', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_CRON_ENABLED: '1', DISCOCLAW_CRON_FORUM: '1000000000000000002' }));
+        expect(config.cronForum).toBe('1000000000000000002');
+        expect(config.cronEnabled).toBe(true);
+    });
+    it('does not validate cronForum when cronEnabled=false', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_CRON_ENABLED: '0' }));
+        expect(config.cronEnabled).toBe(false);
+    });
+    it('allows missing tasksForum when tasksEnabled (bootstrap will auto-create)', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_TASKS_ENABLED: '1', DISCOCLAW_TASKS_FORUM: undefined }));
+        expect(config.tasksEnabled).toBe(true);
+        expect(config.tasksForum).toBeUndefined();
+    });
+    it('warns and clears tasksForum when not a snowflake', () => {
+        const { config, warnings } = parseConfig(env({ DISCOCLAW_TASKS_ENABLED: '1', DISCOCLAW_TASKS_FORUM: 'tasks' }));
+        expect(config.tasksForum).toBeUndefined();
+        expect(warnings.some(w => w.includes('DISCOCLAW_TASKS_FORUM is not a valid snowflake'))).toBe(true);
+    });
+    it('accepts valid snowflake for tasksForum when tasksEnabled=true', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_TASKS_ENABLED: '1', DISCOCLAW_TASKS_FORUM: '1000000000000000002' }));
+        expect(config.tasksForum).toBe('1000000000000000002');
+        expect(config.tasksEnabled).toBe(true);
+    });
+    it('does not validate tasksForum when tasksEnabled=false', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_TASKS_ENABLED: '0' }));
+        expect(config.tasksEnabled).toBe(false);
+    });
+    it('parses DISCOCLAW_TASKS_* vars', () => {
+        const { config } = parseConfig(env({
+            DISCOCLAW_TASKS_ENABLED: '0',
+            DISCOCLAW_TASKS_FORUM: '1000000000000000009',
+            DISCOCLAW_TASKS_CWD: '/tmp/tasks',
+            DISCOCLAW_TASKS_TAG_MAP: '/tmp/tasks/tag-map.json',
+            DISCOCLAW_TASKS_MENTION_USER: '123456789012345678',
+            DISCOCLAW_TASKS_SIDEBAR: '1',
+            DISCOCLAW_TASKS_AUTO_TAG: '0',
+            DISCOCLAW_TASKS_AUTO_TAG_MODEL: 'fast',
+            DISCOCLAW_TASKS_PREFIX: 'dev',
+            DISCOCLAW_TASKS_SYNC_SKIP_PHASE5: '1',
+            DISCOCLAW_TASKS_SYNC_FAILURE_RETRY_ENABLED: '0',
+            DISCOCLAW_TASKS_SYNC_FAILURE_RETRY_DELAY_MS: '12000',
+            DISCOCLAW_TASKS_SYNC_DEFERRED_RETRY_DELAY_MS: '18000',
+        }));
+        expect(config.tasksEnabled).toBe(false);
+        expect(config.tasksForum).toBe('1000000000000000009');
+        expect(config.tasksCwdOverride).toBe('/tmp/tasks');
+        expect(config.tasksTagMapPathOverride).toBe('/tmp/tasks/tag-map.json');
+        expect(config.tasksMentionUser).toBe('123456789012345678');
+        expect(config.tasksSidebar).toBe(true);
+        expect(config.tasksAutoTag).toBe(false);
+        expect(config.tasksAutoTagModel).toBe('fast');
+        expect(config.tasksPrefix).toBe('dev');
+        expect(config.tasksSyncSkipPhase5).toBe(true);
+        expect(config.tasksSyncFailureRetryEnabled).toBe(false);
+        expect(config.tasksSyncFailureRetryDelayMs).toBe(12000);
+        expect(config.tasksSyncDeferredRetryDelayMs).toBe(18000);
+    });
+    it('rejects non-positive task sync retry delay values', () => {
+        expect(() => parseConfig(env({ DISCOCLAW_TASKS_SYNC_FAILURE_RETRY_DELAY_MS: '0' })))
+            .toThrow(/DISCOCLAW_TASKS_SYNC_FAILURE_RETRY_DELAY_MS must be a positive number/);
+        expect(() => parseConfig(env({ DISCOCLAW_TASKS_SYNC_DEFERRED_RETRY_DELAY_MS: '-1' })))
+            .toThrow(/DISCOCLAW_TASKS_SYNC_DEFERRED_RETRY_DELAY_MS must be a positive number/);
+    });
+    // --- Verbose CLI flag ---
+    it('CLAUDE_VERBOSE defaults to false', () => {
+        const { config } = parseConfig(env());
+        expect(config.verbose).toBe(false);
+    });
+    it('CLAUDE_VERBOSE=1 sets verbose to true with stream-json', () => {
+        const { config } = parseConfig(env({ CLAUDE_VERBOSE: '1', CLAUDE_OUTPUT_FORMAT: 'stream-json' }));
+        expect(config.verbose).toBe(true);
+    });
+    it('CLAUDE_VERBOSE=1 is auto-disabled when outputFormat=text', () => {
+        const { config, warnings } = parseConfig(env({ CLAUDE_VERBOSE: '1', CLAUDE_OUTPUT_FORMAT: 'text' }));
+        expect(config.verbose).toBe(false);
+        expect(warnings).toContainEqual(expect.stringContaining('CLAUDE_VERBOSE=1 ignored'));
+    });
+    it('CLAUDE_VERBOSE=1 is allowed when outputFormat=stream-json', () => {
+        const { config, warnings } = parseConfig(env({ CLAUDE_VERBOSE: '1', CLAUDE_OUTPUT_FORMAT: 'stream-json' }));
+        expect(config.verbose).toBe(true);
+        expect(warnings).not.toContainEqual(expect.stringContaining('CLAUDE_VERBOSE=1 ignored'));
+    });
+    it('CLAUDE_VERBOSE=1 is auto-disabled when outputFormat defaults to text', () => {
+        const { config, warnings } = parseConfig(env({ CLAUDE_VERBOSE: '1' }));
+        // outputFormat defaults to 'text', so verbose should be auto-disabled
+        expect(config.verbose).toBe(false);
+        expect(warnings).toContainEqual(expect.stringContaining('CLAUDE_VERBOSE=1 ignored'));
+    });
+    // --- Stream stall detection ---
+    it('defaults streamStallTimeoutMs to 300000', () => {
+        const { config } = parseConfig(env());
+        expect(config.streamStallTimeoutMs).toBe(300000);
+    });
+    it('defaults streamStallWarningMs to 150000', () => {
+        const { config } = parseConfig(env());
+        expect(config.streamStallWarningMs).toBe(150000);
+    });
+    it('parses custom streamStallTimeoutMs', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_STREAM_STALL_TIMEOUT_MS: '30000' }));
+        expect(config.streamStallTimeoutMs).toBe(30000);
+    });
+    it('parses custom streamStallWarningMs', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_STREAM_STALL_WARNING_MS: '15000' }));
+        expect(config.streamStallWarningMs).toBe(15000);
+    });
+    it('accepts 0 for streamStallTimeoutMs (disables feature)', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_STREAM_STALL_TIMEOUT_MS: '0' }));
+        expect(config.streamStallTimeoutMs).toBe(0);
+    });
+    it('accepts 0 for streamStallWarningMs (disables feature)', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_STREAM_STALL_WARNING_MS: '0' }));
+        expect(config.streamStallWarningMs).toBe(0);
+    });
+    // --- Progress stall detection ---
+    it('defaults progressStallTimeoutMs to 300000', () => {
+        const { config } = parseConfig(env());
+        expect(config.progressStallTimeoutMs).toBe(300000);
+    });
+    it('parses custom progressStallTimeoutMs', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_PROGRESS_STALL_TIMEOUT_MS: '60000' }));
+        expect(config.progressStallTimeoutMs).toBe(60000);
+    });
+    it('accepts 0 for progressStallTimeoutMs (disables feature)', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_PROGRESS_STALL_TIMEOUT_MS: '0' }));
+        expect(config.progressStallTimeoutMs).toBe(0);
+    });
+    // --- Webhook ---
+    it('defaults webhookEnabled to false', () => {
+        const { config } = parseConfig(env());
+        expect(config.webhookEnabled).toBe(false);
+    });
+    it('parses DISCOCLAW_WEBHOOK_ENABLED=1 as true', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_WEBHOOK_ENABLED: '1' }));
+        expect(config.webhookEnabled).toBe(true);
+    });
+    it('defaults webhookPort to 9400', () => {
+        const { config } = parseConfig(env());
+        expect(config.webhookPort).toBe(9400);
+    });
+    it('parses DISCOCLAW_WEBHOOK_PORT when set', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_WEBHOOK_PORT: '8765' }));
+        expect(config.webhookPort).toBe(8765);
+    });
+    it('throws on DISCOCLAW_WEBHOOK_PORT=0 (non-positive)', () => {
+        expect(() => parseConfig(env({ DISCOCLAW_WEBHOOK_PORT: '0' })))
+            .toThrow(/DISCOCLAW_WEBHOOK_PORT must be a positive number/);
+    });
+    it('throws on DISCOCLAW_WEBHOOK_PORT=-1 (negative)', () => {
+        expect(() => parseConfig(env({ DISCOCLAW_WEBHOOK_PORT: '-1' })))
+            .toThrow(/DISCOCLAW_WEBHOOK_PORT must be a positive number/);
+    });
+    it('throws on DISCOCLAW_WEBHOOK_PORT=3000.5 (non-integer)', () => {
+        expect(() => parseConfig(env({ DISCOCLAW_WEBHOOK_PORT: '3000.5' })))
+            .toThrow(/DISCOCLAW_WEBHOOK_PORT must be an integer/);
+    });
+    it('returns undefined for webhookConfigPath when DISCOCLAW_WEBHOOK_CONFIG is unset', () => {
+        const { config } = parseConfig(env());
+        expect(config.webhookConfigPath).toBeUndefined();
+    });
+    it('parses DISCOCLAW_WEBHOOK_CONFIG when set', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_WEBHOOK_CONFIG: '/etc/discoclaw/webhooks.json' }));
+        expect(config.webhookConfigPath).toBe('/etc/discoclaw/webhooks.json');
+    });
+});