kimaki 0.26.0 → 0.28.0

package/src/agent-model.e2e.test.ts

@@ -21,7 +21,7 @@ import {
   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,
@@ -42,6 +42,7 @@ import {
   getSessionModel,
   getSessionAgent,
   getChannelAgent,
+  getChannelModel,
   setSessionModel,
   type VerbosityLevel,
 } from './database.js'
@@ -54,10 +55,12 @@ 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'
@@ -339,6 +342,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(
@@ -400,22 +406,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,
@@ -500,7 +497,7 @@ describe('agent model resolution', () => {
       const footerMessage = messages.find((message) => {
         return (
           message.author.id === discord.botUserId &&
-          message.content.startsWith('*')
+          isFooterMessage({ message, botUserId: discord.botUserId })
         )
       })
 
@@ -508,9 +505,9 @@ describe('agent model resolution', () => {
         "--- 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) {
@@ -565,9 +562,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,
@@ -659,7 +656,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,
   )
@@ -700,7 +697,7 @@ describe('agent model resolution', () => {
       const footerMessage = messages.find((message) => {
         return (
           message.author.id === discord.botUserId &&
-          message.content.startsWith('*')
+          isFooterMessage({ message, botUserId: discord.botUserId })
         )
       })
 
@@ -708,9 +705,9 @@ describe('agent model resolution', () => {
         "--- 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) {
@@ -730,71 +727,44 @@ describe('agent model resolution', () => {
   )
 
   test(
-    'channel model with variant preference completes without error',
+    'unsupported channel model variant falls back to the selected model',
     async () => {
-      // Clear channel agent so model resolution falls through to channel model
       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,
   )
@@ -876,8 +846,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(`
         {
@@ -920,7 +890,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('*')
+          isFooterMessage({ message: m, botUserId: discord.botUserId })
         )
       })
       expect(firstFooter).toBeDefined()
@@ -956,14 +926,14 @@ 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()
@@ -971,7 +941,7 @@ describe('agent model resolution', () => {
         .reverse()
         .find((m) => {
           return (
-            m.author.id === discord.botUserId && m.content.startsWith('*')
+            isFooterMessage({ message: m, botUserId: discord.botUserId })
           )
         })
       expect(secondFooter).toBeDefined()
@@ -985,27 +955,30 @@ describe('agent model resolution', () => {
   )
 
   test(
-    'thread created with no agent keeps default model after channel agent is set',
+    '/plan-agent with prompt starts a session with the plan agent',
     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))
+      await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent')
 
-      // 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',
-      })
+      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,
@@ -1014,119 +987,122 @@ describe('agent model resolution', () => {
         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)
+      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 ⋅ <1s ⋅ 0% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
+      `)
+    },
+    20_000,
+  )
 
-      // 2. Set channel agent to test-agent via /test-agent-agent in the CHANNEL
+  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: 'test-agent-agent' })
+        .runSlashCommand({
+          name: 'plan-agent',
+          options: [
+            { name: 'prompt', type: 3, value: prompt },
+            { name: 'variant', type: 3, value: 'high' },
+          ],
+        })
 
       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',
-        })
+      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => t.name === prompt,
+      })
 
       await waitForFooterMessage({
         discord,
         threadId: thread.id,
         timeout: 4_000,
-        afterMessageIncludes: 'default-second-msg',
-        afterAuthorId: TEST_USER_ID,
+        afterMessageIncludes: 'ok',
+        afterAuthorId: discord.botUserId,
       })
 
+      const sessionId = await getThreadSession(thread.id)
+      expect(sessionId).toBeDefined()
       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-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",
+        }
       `)
-
-      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',
+    '/plan-agent variant persists on the channel without a prompt',
     async () => {
-      await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent')
+      const db = await getDb()
+      await db.delete(schema.channel_models).where(orm.eq(schema.channel_models.channel_id, TEXT_CHANNEL_ID))
 
-      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 }],
+          options: [{ name: 'variant', type: 3, value: 'max' }],
         })
 
       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
-        },
-      })
-
-      await waitForFooterMessage({
-        discord,
-        threadId: thread.id,
-        timeout: 4_000,
-        afterMessageIncludes: 'ok',
-        afterAuthorId: discord.botUserId,
-      })
+      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))
+      }
 
-      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***"
+      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,
   )
@@ -1180,12 +1156,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,
@@ -1220,7 +1196,7 @@ describe('agent model resolution', () => {
       const firstFooter = (await discord.thread(thread.id).getMessages()).find(
         (m) => {
           return (
-            m.author.id === discord.botUserId && m.content.startsWith('*')
+            isFooterMessage({ message: m, botUserId: discord.botUserId })
           )
         },
       )
@@ -1252,24 +1228,24 @@ 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('*')
+            isFooterMessage({ message: m, botUserId: discord.botUserId })
           )
         })
       expect(secondFooter).toBeDefined()
@@ -1281,6 +1257,131 @@ describe('agent model resolution', () => {
     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 () => {
@@ -1325,9 +1426,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."
@@ -1378,9 +1479,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."
@@ -1433,9 +1534,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.