kimaki 0.27.0 → 0.29.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*** <@200000000000000920>"
+        > *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*** <@200000000000000920>"
+        > *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* <@200000000000000920>"
+        > *using deterministic-provider/channel-model-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ channel-model-v2* <@200000000000000920>"
       `);
         expect(footerMessage).toBeDefined();
         if (!footerMessage) {
@@ -588,15 +587,15 @@ describe('agent model resolution', () => {
         });
         const footer = 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: variant-check
         --- from: assistant (TestBot)
-        *using deterministic-provider/channel-model-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2* <@200000000000000920>"
+        > *using deterministic-provider/channel-model-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ channel-model-v2* <@200000000000000920>"
       `);
         expect(footer?.content).toContain(CHANNEL_MODEL);
         expect(footer?.content).not.toContain(DEFAULT_MODEL);
@@ -662,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* <@200000000000000920>"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2* <@200000000000000920>"
       `);
         expect(forkedSessionModel).toMatchInlineSnapshot(`
         {
@@ -696,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
@@ -726,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*** <@200000000000000920>
+        > *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*** <@200000000000000920>"
+        > 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),
@@ -780,10 +779,94 @@ describe('agent model resolution', () => {
         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*** <@200000000000000920>"
+        > *using deterministic-provider/plan-model-v2 ⋅ plan*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
+      `);
+    }, 20_000);
+    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 },
+                { 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) => t.name === prompt,
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: discord.botUserId,
+        });
+        const sessionId = await getThreadSession(thread.id);
+        expect(sessionId).toBeDefined();
+        expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+        "--- 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",
+        }
+      `);
+    }, 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');
@@ -825,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*** <@200000000000000920>
+        > *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*** <@200000000000000920>"
+        > 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 () => {
@@ -854,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);
@@ -879,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*** <@200000000000000920>
+        > *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*** <@200000000000000920>"
+        > 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({
@@ -936,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*** <@200000000000000920>
+        > *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."
@@ -978,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*** <@200000000000000920>
+        > *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."
@@ -1020,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* <@200000000000000920>
+        > *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,5 +1,12 @@
 // LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
-// Helpers for extracting and normalizing Anthropic OAuth account identity.
+// 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) {

package/dist/anthropic-auth-plugin.js

@@ -26,7 +26,7 @@
 import { appendToastSessionMarker } from "./plugin-logger.js";
 import { createPluginClient } from "./plugin-opencode-client.js";
 import { isPermanentOAuthRefreshFailure, loadAccountStore, rememberAnthropicOAuth, removeAccountByAuth, rotateAnthropicAccount, saveAccountStore, setAnthropicAuth, shouldRotateAuth, upsertAccount, withAuthStateLock, } from "./anthropic-auth-state.js";
-import { extractAnthropicAccountIdentity, } from "./anthropic-account-identity.js";
+import { applyClaudeCodeRequestIdentity, extractAnthropicAccountIdentity, } from "./anthropic-account-identity.js";
 // PKCE (Proof Key for Code Exchange) using Web Crypto API.
 // Reference: https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/utils/oauth/pkce.ts
 function base64urlEncode(bytes) {
@@ -63,7 +63,6 @@ const CALLBACK_PATH = "/callback";
 const REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
 const SCOPES = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
 const OAUTH_TIMEOUT_MS = 5 * 60 * 1000;
-const CLAUDE_CODE_VERSION = "2.1.75";
 const CLAUDE_CODE_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
 const OPENCODE_IDENTITY = "You are OpenCode, the best coding agent on the planet.";
 // Subagent prompts don't contain OPENCODE_IDENTITY; opencode appends this
@@ -243,13 +242,10 @@ async function fetchAnthropicAccountIdentity(accessToken) {
     for (const url of urls) {
         const responseText = await requestText(url, {
             method: "GET",
-            headers: {
-                Accept: "application/json",
-                authorization: `Bearer ${accessToken}`,
-                "user-agent": process.env.OPENCODE_ANTHROPIC_USER_AGENT ||
-                    `claude-cli/${CLAUDE_CODE_VERSION}`,
-                "x-app": "cli",
-            },
+            headers: Object.fromEntries(applyClaudeCodeRequestIdentity({
+                headers: new Headers({ Accept: "application/json" }),
+                accessToken,
+            }).entries()),
         }).catch(() => {
             return undefined;
         });
@@ -877,10 +873,10 @@ const AnthropicAuthPlugin = async ({ serverUrl, directory }) => {
                             requestHeaders.set("accept", "application/json");
                             requestHeaders.set("anthropic-beta", mergeBetas(requestHeaders.get("anthropic-beta"), betas));
                             requestHeaders.set("anthropic-dangerous-direct-browser-access", "true");
-                            requestHeaders.set("authorization", `Bearer ${auth.access}`);
-                            requestHeaders.set("user-agent", process.env.OPENCODE_ANTHROPIC_USER_AGENT ||
-                                `claude-cli/${CLAUDE_CODE_VERSION}`);
-                            requestHeaders.set("x-app", "cli");
+                            applyClaudeCodeRequestIdentity({
+                                headers: requestHeaders,
+                                accessToken: auth.access,
+                            });
                             requestHeaders.delete("x-api-key");
                             return fetch(input, {
                                 ...(init ?? {}),

package/dist/anthropic-auth-plugin.test.js

@@ -1,5 +1,6 @@
 // Tests Anthropic system prompt rewriting so project instructions survive OpenCode prompt layout changes.
 import { describe, expect, test } from 'vitest';
+import { applyClaudeCodeRequestIdentity } from './anthropic-account-identity.js';
 import { replacer } from './anthropic-auth-plugin.js';
 async function transformSystem(systemText) {
     const plugin = await replacer({});
@@ -12,6 +13,22 @@ async function transformSystem(systemText) {
     }, output);
     return output.system.join('\n');
 }
+describe('Anthropic OAuth request identity', () => {
+    test('applies the current external Claude Code client headers', () => {
+        const headers = applyClaudeCodeRequestIdentity({
+            headers: new Headers({ Accept: 'application/json' }),
+            accessToken: 'access-token',
+        });
+        expect(Object.fromEntries(headers.entries())).toMatchInlineSnapshot(`
+      {
+        "accept": "application/json",
+        "authorization": "Bearer access-token",
+        "user-agent": "claude-cli/2.1.257 (external, cli)",
+        "x-app": "cli",
+      }
+    `);
+    });
+});
 describe('Anthropic system prompt rewriting', () => {
     test('preserves instructions when OpenCode places them before skills', async () => {
         const transformed = await transformSystem(`You are OpenCode, the best coding agent on the planet.

package/dist/bash-tool-schema-plugin.js

@@ -0,0 +1,50 @@
+// Adds description and hasSideEffect to the built-in bash tool schema.
+// Uses tool.definition so OpenCode keeps the real bash execute.
+// Assign jsonSchema only. Leave parameters as the Effect Schema used to decode
+// args before execute. Extra fields stay in the model-facing schema and in
+// Discord input; they never reach the shell.
+//
+// Also injects KIMAKI_SESSION_ID into bash env. /btw and /fork clone parent
+// history, so the copied system prompt still says --session <parent>. Upload
+// then prefers this live env over that stale flag.
+import { z } from 'zod';
+export const KIMAKI_SESSION_ID_ENV = 'KIMAKI_SESSION_ID';
+export function injectKimakiSessionEnv({ sessionID, env, }) {
+    if (!sessionID)
+        return;
+    env[KIMAKI_SESSION_ID_ENV] = sessionID;
+}
+export function resolveUploadToDiscordSessionId({ flagSessionId, envSessionId = process.env[KIMAKI_SESSION_ID_ENV], } = {}) {
+    if (envSessionId)
+        return envSessionId;
+    return flagSessionId;
+}
+export const bashParameters = z.object({
+    command: z.string().describe('The command to execute'),
+    description: z
+        .string()
+        .describe('Short 5-10 word summary shown in Discord when the command is longer than 50 characters'),
+    hasSideEffect: z
+        .boolean()
+        .describe('True if the command writes files, modifies state, installs packages, or triggers external effects'),
+    workdir: z
+        .string()
+        .optional()
+        .describe('Working directory. Defaults to the current directory.'),
+    timeout: z.number().int().optional().describe('Optional timeout in milliseconds'),
+});
+export function extendBashToolDefinition(output) {
+    output.jsonSchema = z.toJSONSchema(bashParameters);
+}
+export const bashToolSchemaPlugin = async () => {
+    return {
+        'tool.definition': async (input, output) => {
+            if (input.toolID !== 'bash')
+                return;
+            extendBashToolDefinition(output);
+        },
+        'shell.env': async (input, output) => {
+            injectKimakiSessionEnv({ sessionID: input.sessionID, env: output.env });
+        },
+    };
+};