kimaki 0.26.0 → 0.28.0

package/dist/agent-model.e2e.test.js

@@ -13,20 +13,21 @@ import fs from 'node:fs';
 import path from 'node:path';
 import url from 'node:url';
 import { describe, beforeAll, afterAll, test, expect, } from 'vitest';
-import { ChannelType, Client, GatewayIntentBits, Partials, REST, Routes, SlashCommandBuilder } from 'discord.js';
+import { ChannelType, Client, GatewayIntentBits, Partials, REST, Routes } from 'discord.js';
 import { DigitalDiscord } from 'discord-digital-twin/src';
 import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provider';
 import { setDataDir } from './config.js';
 import { store } from './store.js';
 import { startDiscordBot } from './discord-bot.js';
-import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, setChannelAgent, setChannelModel, getThreadSession, getSessionModel, getSessionAgent, getChannelAgent, setSessionModel, } from './database.js';
+import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, setChannelAgent, setChannelModel, getThreadSession, getSessionModel, getSessionAgent, getChannelAgent, getChannelModel, setSessionModel, } from './database.js';
 import { getDb } from './db.js';
 import * as orm from 'drizzle-orm';
 import * as schema from './schema.js';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { initializeOpencodeForDirectory, stopOpencodeServer } from './opencode.js';
-import { chooseLockPort, cleanupTestSessions, initTestGitRepo, waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
+import { chooseLockPort, cleanupTestSessions, initTestGitRepo, isFooterMessage, waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
 import { buildQuickAgentCommandDescription } from './commands/agent.js';
+import { buildQuickAgentSlashCommand } from './discord-command-registration.js';
 const TEST_USER_ID = '200000000000000920';
 const TEXT_CHANNEL_ID = '200000000000000921';
 const AGENT_MODEL = 'agent-model-v2';
@@ -265,6 +266,9 @@ describe('agent model resolution', () => {
         }
         providerConfig.models[AGENT_MODEL] = { name: AGENT_MODEL };
         providerConfig.models[PLAN_AGENT_MODEL] = { name: PLAN_AGENT_MODEL };
+        Object.assign(providerConfig.models[PLAN_AGENT_MODEL], {
+            variants: { high: {}, max: {} },
+        });
         providerConfig.models[CHANNEL_MODEL] = { name: CHANNEL_MODEL };
         fs.writeFileSync(path.join(directories.projectDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
         // Leading /command detection only rewrites when registeredUserCommands is set
@@ -316,18 +320,13 @@ describe('agent model resolution', () => {
         // Register quick agent slash commands so /plan-agent and /test-agent-agent
         // are resolvable by handleQuickAgentCommand via guild.commands.fetch().
         const agentCommands = ['test-agent', 'plan', 'plain'].map((agentName) => {
-            return new SlashCommandBuilder()
-                .setName(`${agentName}-agent`)
-                .setDescription(buildQuickAgentCommandDescription({
-                agentName,
-                description: `Switch to ${agentName} agent`,
-            }))
-                .setDMPermission(false)
-                .addStringOption((opt) => opt
-                .setName('prompt')
-                .setDescription('Send a prompt with this agent')
-                .setRequired(false))
-                .toJSON();
+            return buildQuickAgentSlashCommand({
+                commandName: `${agentName}-agent`,
+                description: buildQuickAgentCommandDescription({
+                    agentName,
+                    description: `Switch to ${agentName} agent`,
+                }),
+            }).toJSON();
         });
         const rest = new REST({ version: '10', api: discord.restUrl }).setToken(discord.botToken);
         await rest.put(Routes.applicationGuildCommands(discord.botUserId, discord.guildId), { body: agentCommands });
@@ -394,15 +393,15 @@ describe('agent model resolution', () => {
         // Find the footer message (starts with * italic)
         const footerMessage = messages.find((message) => {
             return (message.author.id === discord.botUserId &&
-                message.content.startsWith('*'));
+                isFooterMessage({ message, botUserId: discord.botUserId }));
         });
         expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
         "--- from: user (agent-model-tester)
         Reply with exactly: agent-model-check
         --- from: assistant (TestBot)
-        *using deterministic-provider/agent-model-v2 ⋅ test-agent*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
+        > *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>"
       `);
         expect(footerMessage).toBeDefined();
         if (!footerMessage) {
@@ -444,9 +443,9 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: system-context-check
         --- from: assistant (TestBot)
-        *using deterministic-provider/agent-model-v2 ⋅ test-agent*
-        ⬥ system-context-ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
+        > *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        > system-context-ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>"
       `);
     }, 15_000);
     test('session.command path includes kimaki system prompt on first message', async () => {
@@ -514,7 +513,7 @@ describe('agent model resolution', () => {
         const threadText = await discord.thread(thread.id).text();
         expect(threadText).toContain('first message in thread');
         expect(threadText).toContain('Reply with exactly: reply-context-check');
-        expect(threadText).toContain('⬥ ok');
+        expect(threadText).toContain('ok');
     }, 15_000);
     test('new thread uses channel model when channel model preference is set', async () => {
         // Clear channel agent so model resolution falls through to channel model
@@ -544,15 +543,15 @@ describe('agent model resolution', () => {
         const messages = await discord.thread(thread.id).getMessages();
         const footerMessage = messages.find((message) => {
             return (message.author.id === discord.botUserId &&
-                message.content.startsWith('*'));
+                isFooterMessage({ message, botUserId: discord.botUserId }));
         });
         expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
         "--- from: user (agent-model-tester)
         Reply with exactly: channel-model-check
         --- from: assistant (TestBot)
-        *using deterministic-provider/channel-model-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2*"
+        > *using deterministic-provider/channel-model-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ channel-model-v2* <@200000000000000920>"
       `);
         expect(footerMessage).toBeDefined();
         if (!footerMessage) {
@@ -565,59 +564,41 @@ describe('agent model resolution', () => {
         expect(footerMessage.content).toContain(CHANNEL_MODEL);
         expect(footerMessage.content).not.toContain(DEFAULT_MODEL);
     }, 15_000);
-    test('channel model with variant preference completes without error', async () => {
-        // Clear channel agent so model resolution falls through to channel model
+    test('unsupported channel model variant falls back to the selected model', async () => {
         const db = await getDb();
         await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID));
-        // Set channel model with a variant (thinking level)
-        // The deterministic provider doesn't support thinking, so the variant
-        // is resolved but silently dropped (no matching thinking values).
-        // This test verifies the variant cascade code path runs without crashing
-        // and the correct model still appears in the footer.
         await setChannelModel({
             channelId: TEXT_CHANNEL_ID,
             modelId: `${PROVIDER_NAME}/${CHANNEL_MODEL}`,
             variant: 'high',
         });
+        const prompt = 'Reply with exactly: variant-check';
         await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-            content: 'Reply with exactly: variant-check',
+            content: prompt,
         });
         const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
             timeout: 4_000,
-            predicate: (t) => {
-                return t.name === 'Reply with exactly: variant-check';
-            },
+            predicate: (candidate) => candidate.name === prompt,
         });
-        await waitForBotMessageContaining({
+        const messages = await waitForFooterMessage({
             discord,
             threadId: thread.id,
-            userId: TEST_USER_ID,
-            text: '*project',
             timeout: 4_000,
         });
-        const messages = await discord.thread(thread.id).getMessages();
-        const footerMessage = messages.find((message) => {
-            return (message.author.id === discord.botUserId &&
-                message.content.startsWith('*'));
+        const footer = messages.find((message) => {
+            return message.author.id === discord.botUserId
+                && isFooterMessage({ message, botUserId: discord.botUserId });
         });
         expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
         "--- from: user (agent-model-tester)
         Reply with exactly: variant-check
         --- from: assistant (TestBot)
-        *using deterministic-provider/channel-model-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2*"
+        > *using deterministic-provider/channel-model-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ channel-model-v2* <@200000000000000920>"
       `);
-        expect(footerMessage).toBeDefined();
-        if (!footerMessage) {
-            throw new Error(`Expected footer message but none found. Bot messages: ${messages
-                .filter((m) => m.author.id === discord.botUserId)
-                .map((m) => m.content.slice(0, 150))
-                .join(' | ')}`);
-        }
-        // Footer should still contain the channel model (variant doesn't crash)
-        expect(footerMessage.content).toContain(CHANNEL_MODEL);
-        expect(footerMessage.content).not.toContain(DEFAULT_MODEL);
+        expect(footer?.content).toContain(CHANNEL_MODEL);
+        expect(footer?.content).not.toContain(DEFAULT_MODEL);
     }, 15_000);
     test('/btw fork keeps source session model when channel model differs', async () => {
         const db = await getDb();
@@ -680,8 +661,8 @@ describe('agent model resolution', () => {
         "--- from: assistant (TestBot)
         Reusing context from <#SOURCE_THREAD> to answer prompt...
         Reply with exactly: btw-model-check
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2* <@200000000000000920>"
       `);
         expect(forkedSessionModel).toMatchInlineSnapshot(`
         {
@@ -714,7 +695,7 @@ describe('agent model resolution', () => {
         });
         const firstMessages = await discord.thread(thread.id).getMessages();
         const firstFooter = firstMessages.find((m) => {
-            return (m.author.id === discord.botUserId && m.content.startsWith('*'));
+            return (isFooterMessage({ message: m, botUserId: discord.botUserId }));
         });
         expect(firstFooter).toBeDefined();
         // Verify the first run used test-agent's model
@@ -744,20 +725,20 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: first-thread-msg
         --- from: assistant (TestBot)
-        *using deterministic-provider/agent-model-v2 ⋅ test-agent*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        > *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>
         --- from: user (agent-model-tester)
         Reply with exactly: second-thread-msg
         --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>"
       `);
         const secondMessages = await discord.thread(thread.id).getMessages();
         const secondFooter = [...secondMessages]
             .reverse()
             .find((m) => {
-            return (m.author.id === discord.botUserId && m.content.startsWith('*'));
+            return (isFooterMessage({ message: m, botUserId: discord.botUserId }));
         });
         expect(secondFooter).toBeDefined();
         // The existing thread should still use test-agent's model (AGENT_MODEL),
@@ -765,23 +746,25 @@ describe('agent model resolution', () => {
         expect(secondFooter.content).toContain(AGENT_MODEL);
         expect(secondFooter.content).not.toContain(PLAN_AGENT_MODEL);
     }, 20_000);
-    test('thread created with no agent keeps default model after channel agent is set', async () => {
-        // Clear any channel agent — thread starts with default (no agent)
-        const db = await getDb();
-        await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID));
-        // Also clear channel model so we get the pure default
-        await db.delete(schema.channel_models).where(orm.eq(schema.channel_models.channel_id, TEXT_CHANNEL_ID));
-        // 1. Send a message to create a thread (no channel agent set)
-        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-            content: 'Reply with exactly: default-thread-msg',
+    test('/plan-agent with prompt starts a session with the plan agent', async () => {
+        await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');
+        const prompt = 'Reply with exactly: inline-plan-agent-msg';
+        const { id: interactionId } = await discord
+            .channel(TEXT_CHANNEL_ID)
+            .user(TEST_USER_ID)
+            .runSlashCommand({
+            name: 'plan-agent',
+            options: [{ name: 'prompt', type: 3, value: prompt }],
         });
+        await discord
+            .channel(TEXT_CHANNEL_ID)
+            .waitForInteractionAck({ interactionId, timeout: 4_000 });
         const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
             timeout: 4_000,
             predicate: (t) => {
-                return t.name === 'Reply with exactly: default-thread-msg';
+                return t.name === prompt;
             },
         });
-        // Wait for footer — should show the default model
         await waitForFooterMessage({
             discord,
             threadId: thread.id,
@@ -789,79 +772,36 @@ describe('agent model resolution', () => {
             afterMessageIncludes: 'ok',
             afterAuthorId: discord.botUserId,
         });
-        const firstMessages = await discord.thread(thread.id).getMessages();
-        const firstFooter = firstMessages.find((m) => {
-            return (m.author.id === discord.botUserId && m.content.startsWith('*'));
-        });
-        expect(firstFooter).toBeDefined();
-        // First run uses the default model (no agent set)
-        expect(firstFooter.content).toContain(DEFAULT_MODEL);
-        expect(firstFooter.content).not.toContain(AGENT_MODEL);
-        // 2. Set channel agent to test-agent via /test-agent-agent in the CHANNEL
-        const { id: interactionId } = await discord
-            .channel(TEXT_CHANNEL_ID)
-            .user(TEST_USER_ID)
-            .runSlashCommand({ name: 'test-agent-agent' });
-        await discord
-            .channel(TEXT_CHANNEL_ID)
-            .waitForInteractionAck({ interactionId, timeout: 4_000 });
-        // 3. Send a second message in the EXISTING thread
-        await discord
-            .thread(thread.id)
-            .user(TEST_USER_ID)
-            .sendMessage({
-            content: 'Reply with exactly: default-second-msg',
-        });
-        await waitForFooterMessage({
-            discord,
-            threadId: thread.id,
-            timeout: 4_000,
-            afterMessageIncludes: 'default-second-msg',
-            afterAuthorId: TEST_USER_ID,
-        });
+        const sessionId = await getThreadSession(thread.id);
+        expect(sessionId).toBeDefined();
+        expect(sessionId ? await getSessionAgent(sessionId) : undefined).toBe('plan');
+        expect(await getChannelAgent(TEXT_CHANNEL_ID)).toBe('test-agent');
         expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
-        "--- from: user (agent-model-tester)
-        Reply with exactly: default-thread-msg
-        --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        --- from: user (agent-model-tester)
-        Reply with exactly: default-second-msg
-        --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        "--- from: assistant (TestBot)
+        » **agent-model-tester** (plan): Reply with exactly: inline-plan-agent-msg
+        > *using deterministic-provider/plan-model-v2 ⋅ plan*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
       `);
-        const secondMessages = await discord.thread(thread.id).getMessages();
-        const secondFooter = [...secondMessages]
-            .reverse()
-            .find((m) => {
-            return (m.author.id === discord.botUserId && m.content.startsWith('*'));
-        });
-        expect(secondFooter).toBeDefined();
-        // The existing thread should still use the DEFAULT model,
-        // NOT the test-agent's model (AGENT_MODEL)
-        expect(secondFooter.content).toContain(DEFAULT_MODEL);
-        expect(secondFooter.content).not.toContain(AGENT_MODEL);
     }, 20_000);
-    test('/plan-agent with prompt starts a session with the plan agent', async () => {
-        await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');
-        const prompt = 'Reply with exactly: inline-plan-agent-msg';
+    test('/plan-agent with prompt persists a supported thinking variant', async () => {
+        const prompt = 'Reply with exactly: inline-plan-agent-variant-msg';
         const { id: interactionId } = await discord
             .channel(TEXT_CHANNEL_ID)
             .user(TEST_USER_ID)
             .runSlashCommand({
             name: 'plan-agent',
-            options: [{ name: 'prompt', type: 3, value: prompt }],
+            options: [
+                { name: 'prompt', type: 3, value: prompt },
+                { name: 'variant', type: 3, value: 'high' },
+            ],
         });
         await discord
             .channel(TEXT_CHANNEL_ID)
             .waitForInteractionAck({ interactionId, timeout: 4_000 });
         const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
             timeout: 4_000,
-            predicate: (t) => {
-                return t.name === prompt;
-            },
+            predicate: (t) => t.name === prompt,
         });
         await waitForFooterMessage({
             discord,
@@ -872,16 +812,62 @@ describe('agent model resolution', () => {
         });
         const sessionId = await getThreadSession(thread.id);
         expect(sessionId).toBeDefined();
-        expect(sessionId ? await getSessionAgent(sessionId) : undefined).toBe('plan');
-        expect(await getChannelAgent(TEXT_CHANNEL_ID)).toBe('test-agent');
         expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
         "--- from: assistant (TestBot)
-        » **agent-model-tester** (plan): Reply with exactly: inline-plan-agent-msg
-        *using deterministic-provider/plan-model-v2 ⋅ plan*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
+        » **agent-model-tester** (plan): Reply with exactly: inline-plan-agent-variant-msg
+        > *using deterministic-provider/plan-model-v2 ⋅ plan*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
+      `);
+        expect(sessionId ? await getSessionModel(sessionId) : undefined).toMatchInlineSnapshot(`
+        {
+          "modelId": "deterministic-provider/plan-model-v2",
+          "variant": "high",
+        }
       `);
     }, 20_000);
+    test('/plan-agent variant persists on the channel without a prompt', async () => {
+        const db = await getDb();
+        await db.delete(schema.channel_models).where(orm.eq(schema.channel_models.channel_id, TEXT_CHANNEL_ID));
+        const { id: interactionId } = await discord
+            .channel(TEXT_CHANNEL_ID)
+            .user(TEST_USER_ID)
+            .runSlashCommand({
+            name: 'plan-agent',
+            options: [{ name: 'variant', type: 3, value: 'max' }],
+        });
+        await discord
+            .channel(TEXT_CHANNEL_ID)
+            .waitForInteractionAck({ interactionId, timeout: 4_000 });
+        const start = Date.now();
+        let confirmation = '';
+        while (Date.now() - start < 4_000) {
+            const messages = await discord.channel(TEXT_CHANNEL_ID).getMessages();
+            const match = [...messages].reverse().find((message) => {
+                return (message.author.id === discord.botUserId &&
+                    message.content.includes('Variant: **max**'));
+            });
+            if (match) {
+                confirmation = match.content;
+                break;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        expect(confirmation).toMatchInlineSnapshot(`
+        "Switched to **plan** agent for this channel (was **test-agent**)
+        Model: *deterministic-provider/plan-model-v2* (agent "plan")
+        Variant: **max**
+        All new sessions will use this agent."
+      `);
+        expect(await getChannelAgent(TEXT_CHANNEL_ID)).toBe('plan');
+        expect(await getChannelModel(TEXT_CHANNEL_ID)).toMatchInlineSnapshot(`
+        {
+          "modelId": "deterministic-provider/plan-model-v2",
+          "variant": "max",
+        }
+      `);
+        await db.delete(schema.channel_models).where(orm.eq(schema.channel_models.channel_id, TEXT_CHANNEL_ID));
+    }, 20_000);
     test('/plan-agent with prompt in an existing thread changes the session agent', async () => {
         await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');
         await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
@@ -922,12 +908,12 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: inline-existing-first-msg
         --- from: assistant (TestBot)
-        *using deterministic-provider/agent-model-v2 ⋅ test-agent*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        > *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>
         » **agent-model-tester** (plan): Reply with exactly: inline-existing-plan-msg
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
       `);
     }, 20_000);
     test('/plan-agent inside a thread switches the model for that thread', async () => {
@@ -951,7 +937,7 @@ describe('agent model resolution', () => {
             afterAuthorId: discord.botUserId,
         });
         const firstFooter = (await discord.thread(thread.id).getMessages()).find((m) => {
-            return (m.author.id === discord.botUserId && m.content.startsWith('*'));
+            return (isFooterMessage({ message: m, botUserId: discord.botUserId }));
         });
         expect(firstFooter).toBeDefined();
         expect(firstFooter.content).toContain(AGENT_MODEL);
@@ -976,28 +962,128 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: switch-in-thread-msg
         --- from: assistant (TestBot)
-        *using deterministic-provider/agent-model-v2 ⋅ test-agent*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        > *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>
         Switched to **plan** agent for this session (was **test-agent**)
         Model: *deterministic-provider/plan-model-v2* (agent "plan")
         The agent will change on the next message.
         --- from: user (agent-model-tester)
         Reply with exactly: after-switch-msg
         --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
       `);
         const secondFooter = [...(await discord.thread(thread.id).getMessages())]
             .reverse()
             .find((m) => {
-            return (m.author.id === discord.botUserId && m.content.startsWith('*'));
+            return (isFooterMessage({ message: m, botUserId: discord.botUserId }));
         });
         expect(secondFooter).toBeDefined();
         // After /plan-agent in the thread, model should switch to plan's model
         expect(secondFooter.content).toContain(PLAN_AGENT_MODEL);
         expect(secondFooter.content).not.toContain(AGENT_MODEL);
     }, 20_000);
+    test('/plan-agent then an immediate follow-up uses the new agent', async () => {
+        await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: race-switch-first-msg',
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: race-switch-first-msg';
+            },
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: discord.botUserId,
+        });
+        const th = discord.thread(thread.id);
+        const { id: interactionId } = await th
+            .user(TEST_USER_ID)
+            .runSlashCommand({ name: 'plan-agent' });
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: race-switch-follow-up',
+        });
+        await th.waitForInteractionAck({ interactionId, timeout: 4_000 });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'race-switch-follow-up',
+            afterAuthorId: TEST_USER_ID,
+        });
+        expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+        "--- from: user (agent-model-tester)
+        Reply with exactly: race-switch-first-msg
+        --- from: assistant (TestBot)
+        > *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>
+        --- from: user (agent-model-tester)
+        Reply with exactly: race-switch-follow-up
+        --- from: assistant (TestBot)
+        Switched to **plan** agent for this session (was **test-agent**)
+        Model: *deterministic-provider/plan-model-v2* (agent "plan")
+        The agent will change on the next message.
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
+      `);
+        const secondFooter = [...(await discord.thread(thread.id).getMessages())]
+            .reverse()
+            .find((m) => {
+            return (isFooterMessage({ message: m, botUserId: discord.botUserId }));
+        });
+        expect(secondFooter).toBeDefined();
+        expect(secondFooter.content).toContain(PLAN_AGENT_MODEL);
+        expect(secondFooter.content).not.toContain(AGENT_MODEL);
+    }, 20_000);
+    test('/plan-agent in a channel then an immediate message uses the new agent', async () => {
+        await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');
+        const { id: interactionId } = await discord
+            .channel(TEXT_CHANNEL_ID)
+            .user(TEST_USER_ID)
+            .runSlashCommand({ name: 'plan-agent' });
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: race-channel-follow-up',
+        });
+        await discord
+            .channel(TEXT_CHANNEL_ID)
+            .waitForInteractionAck({ interactionId, timeout: 4_000 });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: race-channel-follow-up';
+            },
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: discord.botUserId,
+        });
+        expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+        "--- from: user (agent-model-tester)
+        Reply with exactly: race-channel-follow-up
+        --- from: assistant (TestBot)
+        > *using deterministic-provider/plan-model-v2 ⋅ plan*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
+      `);
+        const footer = [...(await discord.thread(thread.id).getMessages())]
+            .reverse()
+            .find((m) => {
+            return isFooterMessage({ message: m, botUserId: discord.botUserId });
+        });
+        expect(footer).toBeDefined();
+        expect(footer.content).toContain(PLAN_AGENT_MODEL);
+        expect(footer.content).not.toContain(AGENT_MODEL);
+    }, 20_000);
     test('/plan-agent on the same agent refreshes a stale session model', async () => {
         await setChannelAgent(TEXT_CHANNEL_ID, 'plan');
         await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
@@ -1033,9 +1119,9 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: refresh-agent-model-msg
         --- from: assistant (TestBot)
-        *using deterministic-provider/plan-model-v2 ⋅ plan*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***
+        > *using deterministic-provider/plan-model-v2 ⋅ plan*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>
         Using **plan** agent for this session
         Model: *deterministic-provider/plan-model-v2* (agent "plan")
         The agent will change on the next message."
@@ -1075,9 +1161,9 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: channel-vs-agent-msg
         --- from: assistant (TestBot)
-        *using deterministic-provider/agent-model-v2 ⋅ test-agent*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        > *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>
         Switched to **plan** agent for this session (was **test-agent**)
         Model: *deterministic-provider/plan-model-v2* (agent "plan")
         The agent will change on the next message."
@@ -1117,9 +1203,9 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: plain-agent-override-msg
         --- from: assistant (TestBot)
-        *using deterministic-provider/channel-model-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2*
+        > *using deterministic-provider/channel-model-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ channel-model-v2* <@200000000000000920>
         Switched to **plain** agent for this session
         Model: *deterministic-provider/channel-model-v2* (channel override)
         This model comes from a channel override. Use /model and press Clear override if you want this agent's model.

package/dist/anthropic-account-identity.js

@@ -1,4 +1,12 @@
-// Helpers for extracting and normalizing Anthropic OAuth account identity.
+// LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
+// Helpers for Anthropic OAuth account and Claude Code client identity.
+const CLAUDE_CODE_USER_AGENT = 'claude-cli/2.1.257 (external, cli)';
+export function applyClaudeCodeRequestIdentity({ headers, accessToken, }) {
+    headers.set('authorization', `Bearer ${accessToken}`);
+    headers.set('user-agent', process.env.OPENCODE_ANTHROPIC_USER_AGENT || CLAUDE_CODE_USER_AGENT);
+    headers.set('x-app', 'cli');
+    return headers;
+}
 const identityHintKeys = new Set(['user', 'profile', 'account', 'viewer']);
 const idKeys = ['user_id', 'userId', 'account_id', 'accountId', 'id', 'sub'];
 export function normalizeAnthropicAccountIdentity(identity) {