discoclaw 0.2.4 → 0.3.0

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

@@ -310,6 +310,240 @@ describe('initCronForum', () => {
         });
         expect(scheduler.register).toHaveBeenCalledWith('thread-1', 'thread-1', 'guild-1', 'Job 1', expect.objectContaining({ schedule: '0 7 * * *' }), 'cron-from-status-id');
     });
+    it('skips AI parse when stats store has stored definition (fast path)', async () => {
+        const thread = makeThread();
+        // fetchStarterMessage should NOT be called — fast path bypasses loadThreadAsCron entirely.
+        thread.fetchStarterMessage.mockResolvedValue(null);
+        const forum = makeForum([thread]);
+        const client = makeClient(forum);
+        const scheduler = makeScheduler();
+        scheduler.register.mockReturnValue({ cron: { nextRun: () => new Date() } });
+        const statsStore = {
+            getRecordByThreadId: vi.fn().mockReturnValue({
+                cronId: 'cron-stored',
+                threadId: 'thread-1',
+                disabled: false,
+                schedule: '0 7 * * *',
+                timezone: 'America/New_York',
+                channel: 'general',
+                prompt: 'Say good morning.',
+                authorId: 'u-allowed',
+                triggerType: 'schedule',
+            }),
+            getRecord: vi.fn(),
+            upsertRecord: vi.fn(async () => ({})),
+        };
+        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() },
+            statsStore: statsStore,
+        });
+        // AI parser should never be called.
+        expect(parseCronDefinition).not.toHaveBeenCalled();
+        // scheduler.register should receive the stored values.
+        expect(scheduler.register).toHaveBeenCalledWith('thread-1', 'thread-1', 'guild-1', 'Job 1', expect.objectContaining({
+            triggerType: 'schedule',
+            schedule: '0 7 * * *',
+            timezone: 'America/New_York',
+            channel: 'general',
+            prompt: 'Say good morning.',
+        }), 'cron-stored');
+        // fetchStarterMessage should not have been called (fast path skips loadThreadAsCron).
+        expect(thread.fetchStarterMessage).not.toHaveBeenCalled();
+    });
+    it('falls through to AI parse when stats store record lacks definition fields', async () => {
+        const thread = makeThread();
+        thread.fetchStarterMessage.mockResolvedValue({
+            id: 'm1',
+            content: 'every day at 7am post to #general say hello',
+            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() } });
+        vi.mocked(parseCronDefinition).mockResolvedValue({
+            triggerType: 'schedule',
+            schedule: '0 7 * * *',
+            timezone: 'UTC',
+            channel: 'general',
+            prompt: 'Say hello.',
+        });
+        // Record exists but has no stored definition fields (pre-upgrade record).
+        const statsStore = {
+            getRecordByThreadId: vi.fn().mockReturnValue({
+                cronId: 'cron-old',
+                threadId: 'thread-1',
+                disabled: false,
+            }),
+            getRecord: vi.fn().mockReturnValue({
+                cronId: 'cron-old',
+                threadId: 'thread-1',
+                disabled: false,
+            }),
+            upsertRecord: vi.fn(async () => ({})),
+        };
+        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() },
+            statsStore: statsStore,
+        });
+        // Should fall through to AI parse since record lacks definition fields.
+        expect(parseCronDefinition).toHaveBeenCalled();
+    });
+    it('falls through to AI parse when fast-path register throws', async () => {
+        const thread = makeThread();
+        thread.fetchStarterMessage.mockResolvedValue({
+            id: 'm1',
+            content: 'every day at 7am post to #general say hello',
+            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();
+        // First call (fast path) throws; second call (loadThreadAsCron fallback) succeeds.
+        scheduler.register
+            .mockImplementationOnce(() => { throw new Error('corrupt schedule'); })
+            .mockReturnValueOnce({ 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-corrupt',
+                threadId: 'thread-1',
+                disabled: false,
+                schedule: 'BAD SCHEDULE',
+                timezone: 'UTC',
+                channel: 'general',
+                prompt: 'Say hello.',
+                authorId: 'u-allowed',
+            }),
+            getRecord: vi.fn().mockReturnValue({
+                cronId: 'cron-corrupt',
+                threadId: 'thread-1',
+                disabled: false,
+            }),
+            upsertRecord: vi.fn(async () => ({})),
+        };
+        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() },
+            statsStore: statsStore,
+        });
+        // Fast path failed, should fall through to AI parse.
+        expect(parseCronDefinition).toHaveBeenCalled();
+        // scheduler.register should have been called twice (fast path + fallback).
+        expect(scheduler.register).toHaveBeenCalledTimes(2);
+    });
+    it('disabled state restored via fast path', async () => {
+        const thread = makeThread();
+        thread.fetchStarterMessage.mockResolvedValue(null);
+        const forum = makeForum([thread]);
+        const client = makeClient(forum);
+        const scheduler = makeScheduler();
+        scheduler.register.mockReturnValue({ cron: { nextRun: () => new Date() } });
+        const statsStore = {
+            getRecordByThreadId: vi.fn().mockReturnValue({
+                cronId: 'cron-disabled-fp',
+                threadId: 'thread-1',
+                disabled: true,
+                schedule: '0 7 * * *',
+                timezone: 'UTC',
+                channel: 'general',
+                prompt: 'Say hello.',
+                authorId: 'u-allowed',
+            }),
+            getRecord: vi.fn(),
+            upsertRecord: vi.fn(async () => ({})),
+        };
+        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() },
+            statsStore: statsStore,
+        });
+        // Should register then immediately disable.
+        expect(scheduler.register).toHaveBeenCalledOnce();
+        expect(scheduler.disable).toHaveBeenCalledWith('thread-1');
+        // AI parser should NOT be called.
+        expect(parseCronDefinition).not.toHaveBeenCalled();
+    });
+    it('falls through when stored authorId is not in allowlist', async () => {
+        const thread = makeThread();
+        thread.fetchStarterMessage.mockResolvedValue({
+            id: 'm1',
+            content: 'every day at 7am post to #general say hello',
+            author: { id: 'u-not-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();
+        const statsStore = {
+            getRecordByThreadId: vi.fn().mockReturnValue({
+                cronId: 'cron-unauth',
+                threadId: 'thread-1',
+                disabled: false,
+                schedule: '0 7 * * *',
+                timezone: 'UTC',
+                channel: 'general',
+                prompt: 'Say hello.',
+                authorId: 'u-not-allowed',
+            }),
+            getRecord: vi.fn(),
+            upsertRecord: vi.fn(async () => ({})),
+        };
+        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() },
+            statsStore: statsStore,
+        });
+        // Should fall through to loadThreadAsCron which will reject and disable.
+        // fetchStarterMessage is called by loadThreadAsCron.
+        expect(thread.fetchStarterMessage).toHaveBeenCalled();
+        // scheduler.register should NOT be called (auth fails in loadThreadAsCron too).
+        expect(scheduler.register).not.toHaveBeenCalled();
+        expect(scheduler.disable).toHaveBeenCalledWith('thread-1');
+    });
     it('restores disabled state from stats store', async () => {
         const thread = makeThread();
         thread.fetchStarterMessage.mockResolvedValue({

package/dist/cron/run-stats.js

@@ -5,7 +5,7 @@ import crypto from 'node:crypto';
 // Types
 // ---------------------------------------------------------------------------
 export const CADENCE_TAGS = ['yearly', 'frequent', 'hourly', 'daily', 'weekly', 'monthly'];
-export const CURRENT_VERSION = 4;
+export const CURRENT_VERSION = 6;
 // ---------------------------------------------------------------------------
 // Stable Cron ID generation
 // ---------------------------------------------------------------------------
@@ -292,7 +292,14 @@ export async function loadRunStats(filePath) {
     if (store.version === 3) {
         store.version = 4;
     }
-    // Add future migration blocks here:
-    //   if (store.version === 4) { /* transform fields */; store.version = 5; }
+    // Migrate v4 → v5: no-op — new field (silent) is optional and defaults falsy.
+    if (store.version === 4) {
+        store.version = 5;
+    }
+    // Migrate v5 → v6: no-op — new persisted definition fields (schedule, timezone, channel, prompt, authorId) are optional.
+    // Absent records fall through to AI parsing on first boot after upgrade.
+    if (store.version === 5) {
+        store.version = 6;
+    }
     return new CronRunStats(store, filePath);
 }

package/dist/cron/run-stats.test.js

@@ -38,7 +38,7 @@ describe('CronRunStats', () => {
     it('creates empty store on missing file', async () => {
         const stats = await loadRunStats(statsPath);
         const store = stats.getStore();
-        expect(store.version).toBe(4);
+        expect(store.version).toBe(6);
         expect(Object.keys(store.jobs)).toHaveLength(0);
     });
     it('upserts and retrieves records by cronId', async () => {
@@ -210,7 +210,7 @@ describe('CronRunStats', () => {
 describe('emptyStore', () => {
     it('returns valid initial structure', () => {
         const store = emptyStore();
-        expect(store.version).toBe(4);
+        expect(store.version).toBe(6);
         expect(store.updatedAt).toBeGreaterThan(0);
         expect(Object.keys(store.jobs)).toHaveLength(0);
     });
@@ -237,7 +237,7 @@ describe('loadRunStats version migration', () => {
         };
         await fs.writeFile(statsPath, JSON.stringify(v3Store), 'utf-8');
         const stats = await loadRunStats(statsPath);
-        expect(stats.getStore().version).toBe(4);
+        expect(stats.getStore().version).toBe(6);
         const rec = stats.getRecord('cron-migrated');
         expect(rec).toBeDefined();
         expect(rec.cronId).toBe('cron-migrated');
@@ -246,4 +246,68 @@ describe('loadRunStats version migration', () => {
         expect(rec.cadence).toBe('daily');
         expect(rec.purposeTags).toEqual(['monitoring']);
     });
+    it('migrates a v4 store to v5 with silent undefined on existing records', async () => {
+        const v4Store = {
+            version: 4,
+            updatedAt: Date.now(),
+            jobs: {
+                'cron-v4': {
+                    cronId: 'cron-v4',
+                    threadId: 'thread-v4',
+                    runCount: 3,
+                    lastRunAt: '2025-06-01T00:00:00.000Z',
+                    lastRunStatus: 'success',
+                    cadence: 'hourly',
+                    purposeTags: ['email'],
+                    disabled: false,
+                    model: 'sonnet',
+                    triggerType: 'schedule',
+                },
+            },
+        };
+        await fs.writeFile(statsPath, JSON.stringify(v4Store), 'utf-8');
+        const stats = await loadRunStats(statsPath);
+        expect(stats.getStore().version).toBe(6);
+        const rec = stats.getRecord('cron-v4');
+        expect(rec).toBeDefined();
+        expect(rec.cronId).toBe('cron-v4');
+        expect(rec.runCount).toBe(3);
+        expect(rec.cadence).toBe('hourly');
+        expect(rec.silent).toBeUndefined();
+    });
+    it('migrates a v5 store to v6 with definition fields undefined on existing records', async () => {
+        const v5Store = {
+            version: 5,
+            updatedAt: Date.now(),
+            jobs: {
+                'cron-v5': {
+                    cronId: 'cron-v5',
+                    threadId: 'thread-v5',
+                    runCount: 7,
+                    lastRunAt: '2025-08-01T00:00:00.000Z',
+                    lastRunStatus: 'success',
+                    cadence: 'daily',
+                    purposeTags: ['greeting'],
+                    disabled: false,
+                    model: 'haiku',
+                    triggerType: 'schedule',
+                    silent: true,
+                },
+            },
+        };
+        await fs.writeFile(statsPath, JSON.stringify(v5Store), 'utf-8');
+        const stats = await loadRunStats(statsPath);
+        expect(stats.getStore().version).toBe(6);
+        const rec = stats.getRecord('cron-v5');
+        expect(rec).toBeDefined();
+        expect(rec.cronId).toBe('cron-v5');
+        expect(rec.runCount).toBe(7);
+        expect(rec.cadence).toBe('daily');
+        expect(rec.silent).toBe(true);
+        expect(rec.schedule).toBeUndefined();
+        expect(rec.timezone).toBeUndefined();
+        expect(rec.channel).toBeUndefined();
+        expect(rec.prompt).toBeUndefined();
+        expect(rec.authorId).toBeUndefined();
+    });
 });

package/dist/discord/actions-config.js

@@ -38,14 +38,45 @@ export function executeConfigAction(action, configCtx) {
             const bp = configCtx.botParams;
             const changes = [];
             switch (action.role) {
-                case 'chat':
-                    bp.runtimeModel = model;
-                    if (bp.planCtx)
-                        bp.planCtx.model = model;
-                    if (bp.cronCtx?.executorCtx)
-                        bp.cronCtx.executorCtx.model = model;
-                    changes.push(`chat → ${model}`);
+                case 'chat': {
+                    // Check if the model string is actually a runtime name.
+                    const normalized = model.toLowerCase();
+                    const newRuntime = configCtx.runtimeRegistry?.get(normalized);
+                    if (newRuntime) {
+                        // Swap runtime across all invocation paths.
+                        const runtimeModel = newRuntime.defaultModel ?? '';
+                        bp.runtime = newRuntime;
+                        bp.runtimeModel = runtimeModel;
+                        configCtx.runtime = newRuntime;
+                        configCtx.runtimeName = normalized;
+                        if (bp.cronCtx) {
+                            bp.cronCtx.runtime = newRuntime;
+                            bp.cronCtx.syncCoordinator?.setRuntime?.(newRuntime);
+                            if (bp.cronCtx.executorCtx) {
+                                bp.cronCtx.executorCtx.runtime = newRuntime;
+                                bp.cronCtx.executorCtx.model = runtimeModel;
+                            }
+                        }
+                        if (bp.planCtx) {
+                            bp.planCtx.runtime = newRuntime;
+                            bp.planCtx.model = runtimeModel;
+                        }
+                        if (bp.deferOpts)
+                            bp.deferOpts.runtime = newRuntime;
+                        changes.push(`runtime → ${normalized}`);
+                        if (runtimeModel)
+                            changes.push(`chat → ${runtimeModel} (adapter default)`);
+                    }
+                    else {
+                        bp.runtimeModel = model;
+                        if (bp.planCtx)
+                            bp.planCtx.model = model;
+                        if (bp.cronCtx?.executorCtx)
+                            bp.cronCtx.executorCtx.model = model;
+                        changes.push(`chat → ${model}`);
+                    }
                     break;
+                }
                 case 'fast':
                     bp.summaryModel = model;
                     changes.push(`summary → ${model}`);
@@ -106,7 +137,9 @@ export function executeConfigAction(action, configCtx) {
         case 'modelShow': {
             const bp = configCtx.botParams;
             const rid = configCtx.runtime.id;
+            const runtimeName = configCtx.runtimeName ?? rid;
             const rows = [
+                ['runtime', runtimeName, `Active runtime adapter (${rid})`],
                 ['chat', bp.runtimeModel, ROLE_DESCRIPTIONS.chat],
                 ['summary', bp.summaryModel, ROLE_DESCRIPTIONS.summary],
                 ['forge-drafter', bp.forgeDrafterModel ?? `${bp.runtimeModel} (follows chat)`, ROLE_DESCRIPTIONS['forge-drafter']],
@@ -159,7 +192,7 @@ export function configActionsPromptSection() {
 <discord-action>{"type":"modelSet","role":"fast","model":"haiku"}</discord-action>
 \`\`\`
 - \`role\` (required): One of \`chat\`, \`fast\`, \`forge-drafter\`, \`forge-auditor\`, \`summary\`, \`cron\`, \`cron-exec\`.
-- \`model\` (required): Model tier (\`fast\`, \`capable\`), concrete model name (\`haiku\`, \`sonnet\`, \`opus\`), or \`default\` (for cron-exec only, to revert to following chat).
+- \`model\` (required): Model tier (\`fast\`, \`capable\`), concrete model name (\`haiku\`, \`sonnet\`, \`opus\`), runtime name (\`openrouter\`, \`gemini\` — for \`chat\` role, swaps the active runtime adapter), or \`default\` (for cron-exec only, to revert to following chat).
 
 **Roles:**
 | Role | What it controls |

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

@@ -1,28 +1,45 @@
 import { describe, expect, it } from 'vitest';
 import { CONFIG_ACTION_TYPES, executeConfigAction, configActionsPromptSection } from './actions-config.js';
+import { RuntimeRegistry } from '../runtime/registry.js';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
+const stubRuntime = {
+    id: 'claude_code',
+    capabilities: new Set(),
+    async *invoke() { },
+};
+const openrouterRuntime = {
+    id: 'openrouter',
+    capabilities: new Set(),
+    defaultModel: 'anthropic/claude-sonnet-4',
+    async *invoke() { },
+};
+function makeRegistry(...entries) {
+    const reg = new RuntimeRegistry();
+    for (const [name, adapter] of entries) {
+        reg.register(name, adapter);
+    }
+    return reg;
+}
 function makeBotParams(overrides) {
     return {
         runtimeModel: 'capable',
         summaryModel: 'fast',
+        runtime: stubRuntime,
         forgeDrafterModel: undefined,
         forgeAuditorModel: undefined,
-        cronCtx: { autoTagModel: 'fast', executorCtx: { model: 'capable' } },
+        cronCtx: { autoTagModel: 'fast', runtime: stubRuntime, executorCtx: { model: 'capable', runtime: stubRuntime } },
         taskCtx: { autoTagModel: 'fast' },
         ...overrides,
     };
 }
-const stubRuntime = {
-    id: 'claude_code',
-    capabilities: new Set(),
-    async *invoke() { },
-};
 function makeCtx(overrides) {
     return {
         botParams: makeBotParams(overrides),
         runtime: stubRuntime,
+        runtimeRegistry: makeRegistry(),
+        runtimeName: 'claude_code',
     };
 }
 // ---------------------------------------------------------------------------
@@ -142,6 +159,8 @@ describe('modelShow', () => {
         const ctx = {
             botParams: makeBotParams({ runtimeModel: '', summaryModel: '' }),
             runtime: codexRuntime,
+            runtimeRegistry: makeRegistry(),
+            runtimeName: 'codex',
         };
         const result = executeConfigAction({ type: 'modelShow' }, ctx);
         expect(result.ok).toBe(true);
@@ -159,6 +178,8 @@ describe('modelShow', () => {
         const ctx = {
             botParams: makeBotParams({ runtimeModel: '', summaryModel: '' }),
             runtime: codexRuntime,
+            runtimeRegistry: makeRegistry(),
+            runtimeName: 'codex',
         };
         const result = executeConfigAction({ type: 'modelShow' }, ctx);
         expect(result.ok).toBe(true);
@@ -322,13 +343,13 @@ describe('modelSet', () => {
     });
     it('chat propagates to planCtx.model', () => {
         const ctx = makeCtx();
-        ctx.botParams.planCtx = { model: 'old' };
+        ctx.botParams.planCtx = { model: 'old', runtime: stubRuntime };
         executeConfigAction({ type: 'modelSet', role: 'chat', model: 'sonnet' }, ctx);
         expect(ctx.botParams.planCtx.model).toBe('sonnet');
     });
     it('chat propagates to cronCtx.executorCtx.model', () => {
         const ctx = makeCtx();
-        ctx.botParams.cronCtx.executorCtx = { model: 'old' };
+        ctx.botParams.cronCtx.executorCtx = { model: 'old', runtime: stubRuntime };
         executeConfigAction({ type: 'modelSet', role: 'chat', model: 'sonnet' }, ctx);
         expect(ctx.botParams.cronCtx.executorCtx.model).toBe('sonnet');
     });
@@ -377,6 +398,107 @@ describe('modelSet', () => {
     });
 });
 // ---------------------------------------------------------------------------
+// modelSet — runtime swap
+// ---------------------------------------------------------------------------
+describe('modelSet runtime swap', () => {
+    it('swaps all runtime refs and sets default model for a registered runtime name', () => {
+        const ctx = makeCtx();
+        ctx.runtimeRegistry = makeRegistry(['openrouter', openrouterRuntime]);
+        ctx.botParams.planCtx = { model: 'capable', runtime: stubRuntime };
+        ctx.botParams.deferOpts = { runtime: stubRuntime };
+        const result = executeConfigAction({ type: 'modelSet', role: 'chat', model: 'openrouter' }, ctx);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        // Runtime swapped everywhere
+        expect(ctx.botParams.runtime).toBe(openrouterRuntime);
+        expect(ctx.runtime).toBe(openrouterRuntime);
+        expect(ctx.runtimeName).toBe('openrouter');
+        expect(ctx.botParams.runtimeModel).toBe('anthropic/claude-sonnet-4');
+        expect(ctx.botParams.planCtx.runtime).toBe(openrouterRuntime);
+        expect(ctx.botParams.planCtx.model).toBe('anthropic/claude-sonnet-4');
+        expect(ctx.botParams.cronCtx.runtime).toBe(openrouterRuntime);
+        expect(ctx.botParams.cronCtx.executorCtx.runtime).toBe(openrouterRuntime);
+        expect(ctx.botParams.cronCtx.executorCtx.model).toBe('anthropic/claude-sonnet-4');
+        expect(ctx.botParams.deferOpts.runtime).toBe(openrouterRuntime);
+        expect(result.summary).toContain('runtime → openrouter');
+        expect(result.summary).toContain('adapter default');
+    });
+    it('does not swap runtime for a plain model name like opus', () => {
+        const ctx = makeCtx();
+        ctx.runtimeRegistry = makeRegistry(['openrouter', openrouterRuntime]);
+        const result = executeConfigAction({ type: 'modelSet', role: 'chat', model: 'opus' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(ctx.botParams.runtime).toBe(stubRuntime);
+        expect(ctx.runtime).toBe(stubRuntime);
+        expect(ctx.runtimeName).toBe('claude_code');
+        expect(ctx.botParams.runtimeModel).toBe('opus');
+    });
+    it('passes through unregistered name as model string without error', () => {
+        const ctx = makeCtx();
+        ctx.runtimeRegistry = makeRegistry(['openrouter', openrouterRuntime]);
+        const result = executeConfigAction({ type: 'modelSet', role: 'chat', model: 'mistral' }, ctx);
+        expect(result.ok).toBe(true);
+        // No swap — treated as model string
+        expect(ctx.botParams.runtime).toBe(stubRuntime);
+        expect(ctx.botParams.runtimeModel).toBe('mistral');
+    });
+    it('case-insensitive matching — OpenRouter matches openrouter', () => {
+        const ctx = makeCtx();
+        ctx.runtimeRegistry = makeRegistry(['openrouter', openrouterRuntime]);
+        const result = executeConfigAction({ type: 'modelSet', role: 'chat', model: 'OpenRouter' }, ctx);
+        expect(result.ok).toBe(true);
+        expect(ctx.botParams.runtime).toBe(openrouterRuntime);
+        expect(ctx.runtimeName).toBe('openrouter');
+    });
+    it('swap then set model name — runtime stays swapped, model changes', () => {
+        const ctx = makeCtx();
+        ctx.runtimeRegistry = makeRegistry(['openrouter', openrouterRuntime]);
+        // First swap runtime
+        executeConfigAction({ type: 'modelSet', role: 'chat', model: 'openrouter' }, ctx);
+        expect(ctx.botParams.runtime).toBe(openrouterRuntime);
+        // Then set a plain model name — runtime stays
+        executeConfigAction({ type: 'modelSet', role: 'chat', model: 'gpt-4o' }, ctx);
+        expect(ctx.botParams.runtime).toBe(openrouterRuntime);
+        expect(ctx.botParams.runtimeModel).toBe('gpt-4o');
+    });
+    it('propagation to syncCoordinator.setRuntime is called when present', () => {
+        const ctx = makeCtx();
+        ctx.runtimeRegistry = makeRegistry(['openrouter', openrouterRuntime]);
+        let capturedRuntime;
+        ctx.botParams.cronCtx.syncCoordinator = {
+            setAutoTagModel: () => { },
+            setRuntime: (rt) => { capturedRuntime = rt; },
+        };
+        executeConfigAction({ type: 'modelSet', role: 'chat', model: 'openrouter' }, ctx);
+        expect(capturedRuntime).toBe(openrouterRuntime);
+    });
+});
+// ---------------------------------------------------------------------------
+// modelShow — runtime line
+// ---------------------------------------------------------------------------
+describe('modelShow runtime line', () => {
+    it('displays active runtime name', () => {
+        const ctx = makeCtx();
+        const result = executeConfigAction({ type: 'modelShow' }, ctx);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.summary).toContain('runtime');
+        expect(result.summary).toContain('claude_code');
+    });
+    it('displays swapped runtime name after swap', () => {
+        const ctx = makeCtx();
+        ctx.runtimeRegistry = makeRegistry(['openrouter', openrouterRuntime]);
+        executeConfigAction({ type: 'modelSet', role: 'chat', model: 'openrouter' }, ctx);
+        const result = executeConfigAction({ type: 'modelShow' }, ctx);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.summary).toContain('openrouter');
+    });
+});
+// ---------------------------------------------------------------------------
 // configActionsPromptSection
 // ---------------------------------------------------------------------------
 describe('configActionsPromptSection', () => {