kimaki 0.4.73 → 0.4.74

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

@@ -14,7 +14,7 @@ import net from 'node:net';
 import path from 'node:path';
 import url from 'node:url';
 import { describe, beforeAll, afterAll, test, expect, } from 'vitest';
-import { ChannelType, Client, GatewayIntentBits, Partials } from 'discord.js';
+import { ChannelType, Client, GatewayIntentBits, Partials, REST, Routes, SlashCommandBuilder } from 'discord.js';
 import { DigitalDiscord } from 'discord-digital-twin/src';
 import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provider';
 import { setDataDir } from './config.js';
@@ -25,9 +25,11 @@ import { getPrisma } from './db.js';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { initializeOpencodeForDirectory } from './opencode.js';
 import { cleanupOpencodeServers, cleanupTestSessions, waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
+import { buildQuickAgentCommandDescription } from './commands/agent.js';
 const TEST_USER_ID = '200000000000000920';
 const TEXT_CHANNEL_ID = '200000000000000921';
 const AGENT_MODEL = 'agent-model-v2';
+const PLAN_AGENT_MODEL = 'plan-model-v2';
 const CHANNEL_MODEL = 'channel-model-v2';
 const DEFAULT_MODEL = 'deterministic-v2';
 const PROVIDER_NAME = 'deterministic-provider';
@@ -200,14 +202,20 @@ describe('agent model resolution', () => {
         // Add extra models to the provider so opencode accepts them
         const providerConfig = opencodeConfig.provider[PROVIDER_NAME];
         providerConfig.models[AGENT_MODEL] = { name: AGENT_MODEL };
+        providerConfig.models[PLAN_AGENT_MODEL] = { name: PLAN_AGENT_MODEL };
         providerConfig.models[CHANNEL_MODEL] = { name: CHANNEL_MODEL };
         fs.writeFileSync(path.join(directories.projectDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
-        // Create the agent .md file with custom model
+        // Create agent .md files with custom models
         createAgentFile({
             projectDirectory: directories.projectDirectory,
             agentName: 'test-agent',
             model: `${PROVIDER_NAME}/${AGENT_MODEL}`,
         });
+        createAgentFile({
+            projectDirectory: directories.projectDirectory,
+            agentName: 'plan',
+            model: `${PROVIDER_NAME}/${PLAN_AGENT_MODEL}`,
+        });
         const dbPath = path.join(directories.dataDir, 'discord-sessions.db');
         const hranaResult = await startHranaServer({ dbPath });
         if (hranaResult instanceof Error) {
@@ -228,6 +236,20 @@ describe('agent model resolution', () => {
             appId: discord.botUserId,
             discordClient: botClient,
         });
+        // 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'].map((agentName) => {
+            return new SlashCommandBuilder()
+                .setName(`${agentName}-agent`)
+                .setDescription(buildQuickAgentCommandDescription({
+                agentName,
+                description: `Switch to ${agentName} agent`,
+            }))
+                .setDMPermission(false)
+                .toJSON();
+        });
+        const rest = new REST({ version: '10', api: discord.restUrl }).setToken(discord.botToken);
+        await rest.put(Routes.applicationGuildCommands(discord.botUserId, discord.guildId), { body: agentCommands });
         // Pre-warm the opencode server so agent discovery happens
         const warmup = await initializeOpencodeForDirectory(directories.projectDirectory);
         if (warmup instanceof Error) {
@@ -449,4 +471,224 @@ describe('agent model resolution', () => {
         expect(footerMessage.content).toContain(CHANNEL_MODEL);
         expect(footerMessage.content).not.toContain(DEFAULT_MODEL);
     }, 15_000);
+    test('changing channel agent via /plan-agent does not affect existing thread model', async () => {
+        // 1. Set channel agent to test-agent (uses AGENT_MODEL)
+        await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');
+        // 2. Send a message to create a thread
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: first-thread-msg',
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: first-thread-msg';
+            },
+        });
+        // Wait for footer — proves first run completed with test-agent's model
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            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();
+        // Verify the first run used test-agent's model
+        expect(firstFooter.content).toContain(AGENT_MODEL);
+        // 3. Switch channel agent to plan via /plan-agent in the CHANNEL
+        const { id: interactionId } = await discord
+            .channel(TEXT_CHANNEL_ID)
+            .user(TEST_USER_ID)
+            .runSlashCommand({ name: 'plan-agent' });
+        await discord
+            .channel(TEXT_CHANNEL_ID)
+            .waitForInteractionAck({ interactionId, timeout: 4_000 });
+        // 4. Send a second message in the EXISTING thread
+        const th = discord.thread(thread.id);
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: second-thread-msg',
+        });
+        // Wait for second footer (anchor on the user message, not bot reply)
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'second-thread-msg',
+            afterAuthorId: TEST_USER_ID,
+        });
+        expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+        "--- from: user (agent-model-tester)
+        Reply with exactly: first-thread-msg
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        --- from: user (agent-model-tester)
+        Reply with exactly: second-thread-msg
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
+      `);
+        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 test-agent's model (AGENT_MODEL),
+        // NOT plan agent's model (PLAN_AGENT_MODEL)
+        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 prisma = await getPrisma();
+        await prisma.channel_agents.deleteMany({
+            where: { channel_id: TEXT_CHANNEL_ID },
+        });
+        // Also clear channel model so we get the pure default
+        await prisma.channel_models.deleteMany({
+            where: { 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',
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: default-thread-msg';
+            },
+        });
+        // Wait for footer — should show the default model
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            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,
+        });
+        expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+        "--- from: user (agent-model-tester)
+        Reply with exactly: default-thread-msg
+        --- from: assistant (TestBot)
+        ⬥ 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*"
+      `);
+        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 inside a thread switches the model for that thread', async () => {
+        // 1. Start with test-agent on the channel
+        await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');
+        // 2. Create a thread — first run uses test-agent's model
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: switch-in-thread-msg',
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: switch-in-thread-msg';
+            },
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: discord.botUserId,
+        });
+        const firstFooter = (await discord.thread(thread.id).getMessages()).find((m) => {
+            return (m.author.id === discord.botUserId && m.content.startsWith('*'));
+        });
+        expect(firstFooter).toBeDefined();
+        expect(firstFooter.content).toContain(AGENT_MODEL);
+        // 3. Run /plan-agent INSIDE the thread
+        const th = discord.thread(thread.id);
+        const { id: interactionId } = await th
+            .user(TEST_USER_ID)
+            .runSlashCommand({ name: 'plan-agent' });
+        await th.waitForInteractionAck({ interactionId, timeout: 4_000 });
+        // 4. Send a second message in the same thread
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: after-switch-msg',
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'after-switch-msg',
+            afterAuthorId: TEST_USER_ID,
+        });
+        expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+        "--- from: user (agent-model-tester)
+        Reply with exactly: switch-in-thread-msg
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        Switched to **plan** agent for this session (was **test-agent**)
+        --- from: user (agent-model-tester)
+        Reply with exactly: after-switch-msg
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
+      `);
+        const secondFooter = [...(await discord.thread(thread.id).getMessages())]
+            .reverse()
+            .find((m) => {
+            return (m.author.id === discord.botUserId && m.content.startsWith('*'));
+        });
+        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);
 });

package/dist/cli.js

@@ -6,7 +6,7 @@ import { goke } from 'goke';
 import { intro, outro, text, password, note, cancel, isCancel, confirm, log, multiselect, select, spinner, } from '@clack/prompts';
 import { deduplicateByKey, generateBotInstallUrl, generateDiscordInstallUrlForBot, KIMAKI_GATEWAY_APP_ID, KIMAKI_WEBSITE_URL, abbreviatePath, } from './utils.js';
 import { getChannelsWithDescriptions, createDiscordClient, initDatabase, getChannelDirectory, startDiscordBot, initializeOpencodeForDirectory, ensureKimakiCategory, createProjectChannels, } from './discord-bot.js';
-import { getBotTokenWithMode, setBotToken, setBotMode, setChannelDirectory, findChannelsByDirectory, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getPrisma, createScheduledTask, listScheduledTasks, cancelScheduledTask, getSessionStartSourcesBySessionIds, touchBotTokenTimestamp, } from './database.js';
+import { getBotTokenWithMode, setBotToken, setBotMode, setChannelDirectory, findChannelsByDirectory, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getPrisma, createScheduledTask, listScheduledTasks, cancelScheduledTask, getSessionStartSourcesBySessionIds, } from './database.js';
 import { ShareMarkdown } from './markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts, } from './session-search.js';
 import { formatWorktreeName } from './commands/worktree.js';
@@ -85,22 +85,25 @@ function appIdFromToken(token) {
 // In gateway mode, also sets store.discordBaseUrl so REST calls
 // are routed through the gateway-proxy REST endpoint.
 async function resolveBotCredentials({ appIdOverride } = {}) {
-    const envToken = process.env.KIMAKI_BOT_TOKEN;
-    if (envToken) {
-        // Prefer token-derived appId over stale DB values when using env token,
-        // since the DB may have credentials from a different bot.
-        const appId = appIdOverride || appIdFromToken(envToken);
-        return { token: envToken, appId };
-    }
+    // DB first: getBotTokenWithMode() sets store.discordBaseUrl which is
+    // required in gateway mode so REST calls route through the proxy.
+    // Without this, inherited KIMAKI_BOT_TOKEN (a gateway credential like
+    // clientId:clientSecret) would be sent directly to discord.com → 401.
     const botRow = await getBotTokenWithMode().catch((e) => {
         cliLogger.error('Database error:', e instanceof Error ? e.message : String(e));
         return null;
     });
-    if (!botRow) {
-        cliLogger.error('No bot token found. Set KIMAKI_BOT_TOKEN env var or run `kimaki` first to set up.');
-        process.exit(EXIT_NO_RESTART);
+    if (botRow) {
+        return { token: botRow.token, appId: appIdOverride || botRow.appId };
+    }
+    // Fall back to env var for CI/headless deployments with no database
+    const envToken = process.env.KIMAKI_BOT_TOKEN;
+    if (envToken) {
+        const appId = appIdOverride || appIdFromToken(envToken);
+        return { token: envToken, appId };
     }
-    return { token: botRow.token, appId: appIdOverride || botRow.appId };
+    cliLogger.error('No bot token found. Set KIMAKI_BOT_TOKEN env var or run `kimaki` first to set up.');
+    process.exit(EXIT_NO_RESTART);
 }
 function isThreadChannelType(type) {
     return [
@@ -967,7 +970,6 @@ async function run({ restartOnboarding, addChannels, useWorktrees, enableVoiceCh
     startCaffeinate();
     const forceRestartOnboarding = Boolean(restartOnboarding);
     const forceGateway = Boolean(gateway);
-    store.setState({ preferGateway: forceGateway });
     // Step 0: Ensure required CLI tools are installed (OpenCode + Bun)
     await ensureCommandAvailable({
         name: 'opencode',
@@ -1253,11 +1255,14 @@ async function run({ restartOnboarding, addChannels, useWorktrees, enableVoiceCh
     if (isGatewayMode) {
         store.setState({ discordBaseUrl: KIMAKI_GATEWAY_PROXY_REST_BASE_URL });
     }
-    // Touch the active bot row so it has the most recent created_at timestamp.
-    // Subcommands in separate processes (send, upload-to-discord, project list)
-    // call getBotTokenWithMode() which returns the most recent row — this
-    // ensures they always get the bot that's actually running.
-    await touchBotTokenTimestamp(appId);
+    // Mark this bot as the most recently used so subcommands in separate
+    // processes (send, upload-to-discord, project list) pick the correct bot.
+    // getBotTokenWithMode() orders by last_used_at DESC as cross-process
+    // source of truth.
+    await (await getPrisma()).bot_tokens.update({
+        where: { app_id: appId },
+        data: { last_used_at: new Date() },
+    });
     const hasConfiguredTextChannels = Boolean(await (await getPrisma()).channel_directories.findFirst({
         where: { channel_type: 'text' },
         select: { channel_id: true },
@@ -2495,6 +2500,54 @@ cli
     cliLogger.log(channelUrl);
     process.exit(0);
 });
+cli
+    .command('user list', 'Search for Discord users in a guild/server. Returns user IDs for mentions.')
+    .option('-g, --guild <guildId>', 'Discord guild/server ID (required)')
+    .option('-q, --query [query]', 'Search query to filter users by name')
+    .action(async (options) => {
+    try {
+        if (!options.guild) {
+            cliLogger.error('Guild ID is required. Use --guild <guildId>');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const guildId = String(options.guild);
+        await initDatabase();
+        const { token: botToken } = await resolveBotCredentials();
+        const rest = createDiscordRest(botToken);
+        const members = await (async () => {
+            if (options.query) {
+                return (await rest.get(Routes.guildMembersSearch(guildId), {
+                    query: new URLSearchParams({ query: options.query, limit: '20' }),
+                }));
+            }
+            return (await rest.get(Routes.guildMembers(guildId), {
+                query: new URLSearchParams({ limit: '20' }),
+            }));
+        })();
+        if (members.length === 0) {
+            const msg = options.query
+                ? `No users found matching "${options.query}"`
+                : 'No users found in guild';
+            cliLogger.log(msg);
+            process.exit(0);
+        }
+        const userList = members
+            .map((m) => {
+            const displayName = m.nick || m.user.global_name || m.user.username;
+            return `- ${displayName} (ID: ${m.user.id}) - mention: <@${m.user.id}>`;
+        })
+            .join('\n');
+        const header = options.query
+            ? `Found ${members.length} users matching "${options.query}":`
+            : `Found ${members.length} users:`;
+        console.log(`${header}\n${userList}`);
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.message : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
 cli
     .command('tunnel', 'Expose a local port via tunnel')
     .option('-p, --port <port>', 'Local port to expose (required)')
@@ -2888,18 +2941,39 @@ cli
     process.exit(0);
 });
 cli
-    .command('session archive <threadId>', 'Archive a Discord thread and stop its mapped OpenCode session')
-    .action(async (threadId) => {
+    .command('session archive [threadId]', 'Archive a Discord thread and stop its mapped OpenCode session')
+    .option('--session <sessionId>', 'Resolve thread from an OpenCode session ID')
+    .action(async (threadIdArg, options) => {
     try {
         await initDatabase();
+        // Resolve threadId from --session or positional arg
+        if (threadIdArg && options.session) {
+            cliLogger.error('Use either a thread ID or --session, not both');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const resolvedThreadId = await (async () => {
+            if (threadIdArg) {
+                return threadIdArg;
+            }
+            if (options.session) {
+                const id = await getThreadIdBySessionId(options.session);
+                if (!id) {
+                    cliLogger.error(`No Discord thread found for session: ${options.session}`);
+                    process.exit(EXIT_NO_RESTART);
+                }
+                return id;
+            }
+            cliLogger.error('Provide a thread ID or --session <sessionId>');
+            process.exit(EXIT_NO_RESTART);
+        })();
         const { token: botToken } = await resolveBotCredentials();
         const rest = createDiscordRest(botToken);
-        const threadData = (await rest.get(Routes.channel(threadId)));
+        const threadData = (await rest.get(Routes.channel(resolvedThreadId)));
         if (!isThreadChannelType(threadData.type)) {
-            cliLogger.error(`Channel is not a thread: ${threadId}`);
+            cliLogger.error(`Channel is not a thread: ${resolvedThreadId}`);
             process.exit(EXIT_NO_RESTART);
         }
-        const sessionId = await getThreadSession(threadId);
+        const sessionId = options.session || await getThreadSession(resolvedThreadId);
         let client = null;
         if (sessionId && threadData.parent_id) {
             const channelConfig = await getChannelDirectory(threadData.parent_id);
@@ -2917,17 +2991,17 @@ cli
             }
         }
         else {
-            cliLogger.warn(`No mapped OpenCode session found for thread ${threadId}`);
+            cliLogger.warn(`No mapped OpenCode session found for thread ${resolvedThreadId}`);
         }
         await archiveThread({
             rest,
-            threadId,
+            threadId: resolvedThreadId,
             parentChannelId: threadData.parent_id,
             sessionId,
             client,
         });
-        const threadLabel = threadData.name || threadId;
-        note(`Archived thread: ${threadLabel}\nThread ID: ${threadId}`, '✅ Archived');
+        const threadLabel = threadData.name || resolvedThreadId;
+        note(`Archived thread: ${threadLabel}\nThread ID: ${resolvedThreadId}`, '✅ Archived');
         process.exit(0);
     }
     catch (error) {

package/dist/commands/worktrees.js

@@ -101,6 +101,7 @@ export async function handleWorktreesCommand({ command, }) {
     const prisma = await getPrisma();
     const worktrees = await prisma.thread_worktrees.findMany({
         orderBy: { created_at: 'desc' },
+        take: 10,
     });
     if (worktrees.length === 0) {
         await command.editReply({ content: 'No worktrees found.' });

package/dist/database.js

@@ -788,11 +788,12 @@ export async function setPartMessagesBatch(partMappings) {
  *
  * Selection logic (when multiple bot rows exist):
  * - If only one bot exists, use it regardless of mode.
- * - If multiple bots exist: prefer gateway row when `preferGateway` is true,
- *   otherwise prefer the self-hosted row. Within the preferred mode, pick
- *   the most recently created row.
- * - Falls back to the most recent row of any mode if no row matches the
- *   preferred mode (e.g. preferGateway=true but only self-hosted rows exist).
+ * - Picks the bot row with the most recent `last_used_at` timestamp, which is
+ *   set by the `run()` command when the bot starts. This ensures subcommands
+ *   in separate processes (send, project list, etc.) automatically use
+ *   whichever bot mode (gateway or self-hosted) was last started.
+ * - Falls back to `created_at` ordering when no row has `last_used_at` set
+ *   (backward compat for existing DBs before this column was added).
  *
  * For gateway mode, the token is derived from client_id:client_secret
  * and REST routing is automatically enabled (idempotent env var set).
@@ -801,26 +802,16 @@ export async function setPartMessagesBatch(partMappings) {
  */
 export async function getBotTokenWithMode() {
     const prisma = await getPrisma();
+    // Pick the bot that was most recently started via run(). last_used_at is the
+    // cross-process source of truth — no in-memory flags needed.
+    // Fall back to created_at for DBs that predate the last_used_at column.
     const allBots = await prisma.bot_tokens.findMany({
-        orderBy: { created_at: 'desc' },
+        orderBy: [{ last_used_at: 'desc' }, { created_at: 'desc' }],
     });
-    const [mostRecent] = allBots;
-    if (!mostRecent) {
+    const row = allBots[0];
+    if (!row) {
         return undefined;
     }
-    // If only one bot, use it. If multiple, prefer the mode matching store.preferGateway.
-    const row = (() => {
-        if (allBots.length === 1) {
-            return mostRecent;
-        }
-        const preferredMode = store.getState().preferGateway ? 'gateway' : 'self_hosted';
-        const match = allBots.find((b) => {
-            const m = b.bot_mode === 'gateway' ? 'gateway' : 'self_hosted';
-            return m === preferredMode;
-        });
-        // Fall back to most recent row if no row matches preferred mode
-        return match || mostRecent;
-    })();
     const mode = row.bot_mode === 'gateway' ? 'gateway' : 'self_hosted';
     const token = (mode === 'gateway' && row.client_id && row.client_secret)
         ? `${row.client_id}:${row.client_secret}`
@@ -870,19 +861,6 @@ export async function setBotMode({ appId, mode, clientId, clientSecret, proxyUrl
         update: data,
     });
 }
-/**
- * Touch the bot_tokens row so it becomes the "most recent" via created_at.
- * Called after credential resolution in run() so that subcommands in separate
- * processes (send, upload-to-discord, project list, etc.) get the correct
- * active bot from getBotTokenWithMode() which returns the most recent row.
- */
-export async function touchBotTokenTimestamp(appId) {
-    const prisma = await getPrisma();
-    await prisma.bot_tokens.update({
-        where: { app_id: appId },
-        data: { created_at: new Date() },
-    });
-}
 // ============================================================================
 // Bot API Keys Functions
 // ============================================================================

package/dist/db.js

@@ -137,6 +137,7 @@ async function migrateSchema(prisma) {
         'ALTER TABLE bot_tokens ADD COLUMN client_id TEXT',
         'ALTER TABLE bot_tokens ADD COLUMN client_secret TEXT',
         'ALTER TABLE bot_tokens ADD COLUMN proxy_url TEXT',
+        'ALTER TABLE bot_tokens ADD COLUMN last_used_at DATETIME',
     ];
     for (const stmt of botTokenAlters) {
         try {