kimaki 0.5.0 → 0.7.0

package/dist/anthropic-auth-plugin.js

@@ -22,6 +22,7 @@
  * - https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/utils/oauth/anthropic.ts
  * - https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/providers/anthropic.ts
  */
+import { appendToastSessionMarker } from "./plugin-logger.js";
 import { loadAccountStore, rememberAnthropicOAuth, rotateAnthropicAccount, saveAccountStore, setAnthropicAuth, shouldRotateAuth, upsertAccount, withAuthStateLock, } from "./anthropic-auth-state.js";
 import { extractAnthropicAccountIdentity, } from "./anthropic-account-identity.js";
 // PKCE (Proof Key for Code Exchange) using Web Crypto API.
@@ -484,14 +485,20 @@ function sanitizeAnthropicSystemText(text, onError) {
         onError?.("sanitizeAnthropicSystemText: could not find Anthropic prompt marker after OpenCode identity");
         return text;
     }
-    // Re-inject the process working directory that was inside the stripped block.
-    const envContext = `\n<environment>\n<cwd>${process.cwd()}</cwd>\n</environment>\n`;
-    // Replace all case-insensitive whole-word occurrences of "opencode" with "openc0de"
+    // Extract the cwd from the block we're about to strip. OpenCode's system
+    // prompt embeds <environment><cwd>/path</cwd></environment> in the identity
+    // block. We preserve the per-session cwd instead of falling back to
+    // process.cwd() which is the opencode server's cwd and wrong for
+    // multi-session/worktree setups where each session has a different directory.
+    const strippedBlock = text.slice(startIdx, endIdx);
+    const cwdMatch = strippedBlock.match(/<cwd>([^<]+)<\/cwd>/);
+    const cwd = cwdMatch?.[1] || process.cwd();
+    const envContext = `\n<environment>\n<cwd>${cwd}</cwd>\n</environment>\n` +
+        `Read, write, and edit files under <cwd>.\n\n`;
     const result = text.slice(0, startIdx) +
         envContext +
         text.slice(endIdx);
-    // Use a regex with global, case-insensitive, and word boundary flags
-    return result.replace(/\bopencode\b/gi, "openc0de");
+    return result;
 }
 function mapSystemTextPart(part, onError) {
     if (typeof part === "string") {
@@ -511,7 +518,10 @@ function mapSystemTextPart(part, onError) {
     return part;
 }
 function prependClaudeCodeIdentity(system, onError) {
-    const identityBlock = { type: "text", text: CLAUDE_CODE_IDENTITY };
+    const identityBlock = {
+        type: "text",
+        text: CLAUDE_CODE_IDENTITY,
+    };
     if (typeof system === "undefined")
         return [identityBlock];
     if (typeof system === "string") {
@@ -649,12 +659,6 @@ function wrapResponseStream(response, reverseToolNameMap) {
         headers: response.headers,
     });
 }
-function appendToastSessionMarker({ message, sessionId, }) {
-    if (!sessionId) {
-        return message;
-    }
-    return `${message} ${sessionId}`;
-}
 // --- Beta headers ---
 function getRequiredBetas(modelId) {
     const betas = [

package/dist/bundled-skills.js

@@ -0,0 +1,37 @@
+// Bundled Kimaki skills path helpers.
+// The canonical tracked skills live at the repository root in /skills.
+// Build and publish scripts copy them into cli/skills so the npm package ships
+// the same files. Prefer the repo-root directory during local development and
+// fall back to the packaged cli/skills directory when running from npm.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+function getCliDir() {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    return path.resolve(path.dirname(currentFilePath), '..');
+}
+export function resolvePackagedBundledSkillsDir() {
+    return path.join(getCliDir(), 'skills');
+}
+export function resolveBundledSkillsDir() {
+    const repoSkillsDir = path.resolve(getCliDir(), '..', 'skills');
+    if (fs.existsSync(repoSkillsDir)) {
+        return repoSkillsDir;
+    }
+    return resolvePackagedBundledSkillsDir();
+}
+export function listBundledSkillNames() {
+    try {
+        return fs
+            .readdirSync(resolveBundledSkillsDir(), { withFileTypes: true })
+            .filter((entry) => {
+            return entry.isDirectory();
+        })
+            .map((entry) => {
+            return entry.name;
+        });
+    }
+    catch {
+        return [];
+    }
+}

package/dist/cli.js

@@ -1291,11 +1291,11 @@ cli
     .option('--enable-skill <name>', z
     .array(z.string())
     .optional()
-    .describe('Whitelist a built-in skill by name. Only the listed skills are injected into the model (all others are hidden via an opencode permission.skill deny-all rule). Repeatable: pass --enable-skill multiple times. Mutually exclusive with --disable-skill. See https://github.com/remorses/kimaki/tree/main/cli/skills for available skills.'))
+    .describe('Whitelist a built-in skill by name. Only the listed skills are injected into the model (all others are hidden via an opencode permission.skill deny-all rule). Repeatable: pass --enable-skill multiple times. Mutually exclusive with --disable-skill. See https://github.com/remorses/kimaki/tree/main/skills for available skills.'))
     .option('--disable-skill <name>', z
     .array(z.string())
     .optional()
-    .describe('Blacklist a built-in skill by name. Listed skills are hidden from the model. Repeatable: pass --disable-skill multiple times. Mutually exclusive with --enable-skill. See https://github.com/remorses/kimaki/tree/main/cli/skills for available skills.'))
+    .describe('Blacklist a built-in skill by name. Listed skills are hidden from the model. Repeatable: pass --disable-skill multiple times. Mutually exclusive with --enable-skill. See https://github.com/remorses/kimaki/tree/main/skills for available skills.'))
     .action(async (options) => {
     // Guard: only one kimaki bot process can run at a time (they share a lock
     // port). Running `kimaki` here would kill the already-running bot process
@@ -2788,7 +2788,7 @@ cli
     });
 });
 cli
-    .command('screenshare', 'Share your screen via VNC tunnel. Auto-stops after 30 minutes. Runs until Ctrl+C. Use tmux to run in background.')
+    .command('screenshare', 'Share your screen via VNC tunnel. Auto-stops after 30 minutes. Runs until Ctrl+C. For background usage, start with bunx tuistory --help, then run it in a tuistory session.')
     .action(async () => {
     const { startScreenshare } = await import('./commands/screenshare.js');
     try {

package/dist/commands/add-dir.js

@@ -71,7 +71,7 @@ export async function handleAddDirCommand({ command, }) {
         });
         return;
     }
-    const requestedDirectory = command.options.getString('directory', true);
+    const requestedDirectory = command.options.getString('directory') ?? ALL_DIRECTORIES_PATTERN;
     const resolvedPattern = resolveDirectoryPermissionPattern({
         input: requestedDirectory,
         workingDirectory: resolvedDirectories.workingDirectory,

package/dist/commands/add-dir.test.js

@@ -1,6 +1,7 @@
 // Tests for /add-dir permission helpers.
 import { describe, expect, test } from 'vitest';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { buildAddDirPermissionRules, resolveDirectoryPermissionPattern, } from './add-dir.js';
 import { buildExternalDirectoryPermissionRules, buildSessionPermissions, } from '../opencode.js';
@@ -16,6 +17,10 @@ describe('resolveDirectoryPermissionPattern', () => {
         expect(result).toBe(nested.replaceAll('\\', '/'));
     });
     test('supports allowing every directory with *', () => {
+        expect(resolveDirectoryPermissionPattern({
+            input: ' * ',
+            workingDirectory: '/repo',
+        })).toBe('*');
         expect(buildAddDirPermissionRules({
             resolvedPattern: '*',
         })).toMatchInlineSnapshot(`
@@ -84,4 +89,38 @@ describe('resolveDirectoryPermissionPattern', () => {
       ]
     `);
     });
+    test('pre-allows common toolchain caches under home with ~ patterns', () => {
+        const home = os.homedir().replaceAll('\\', '/');
+        expect(buildSessionPermissions({
+            directory: '/Users/me/project',
+        }).filter((rule) => {
+            return [
+                `${home}/.cache/zig`,
+                `${home}/.cargo`,
+                `${home}/.cache/go-build`,
+                `${home}/go/pkg`,
+            ].includes(rule.pattern);
+        })).toEqual([
+            {
+                permission: 'external_directory',
+                pattern: `${home}/.cache/zig`,
+                action: 'allow',
+            },
+            {
+                permission: 'external_directory',
+                pattern: `${home}/.cargo`,
+                action: 'allow',
+            },
+            {
+                permission: 'external_directory',
+                pattern: `${home}/.cache/go-build`,
+                action: 'allow',
+            },
+            {
+                permission: 'external_directory',
+                pattern: `${home}/go/pkg`,
+                action: 'allow',
+            },
+        ]);
+    });
 });

package/dist/commands/btw.js

@@ -4,10 +4,10 @@
 // dispatches the user's prompt so the forked session starts working right away.
 import { ChannelType, ThreadAutoArchiveDuration, MessageFlags, } from 'discord.js';
 import { getThreadSession, setThreadSession } from '../database.js';
-import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage, } from '../discord-utils.js';
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
 const logger = createLogger(LogPrefix.FORK);
 export async function forkSessionToBtwThread({ sourceThread, projectDirectory, prompt, userId, username, appId, }) {
     const sessionId = await getThreadSession(sourceThread.id);
@@ -52,7 +52,7 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, p
         thread,
         projectDirectory,
         sdkDirectory: projectDirectory,
-        channelId: textChannel.id,
+        channelId: sourceThread.parentId || sourceThread.id,
         appId,
     });
     await runtime.enqueueIncoming({

package/dist/commands/fork-subagent.js

@@ -0,0 +1,177 @@
+// /fork-subagent command - Fork a subagent task session into a new thread.
+import { ActionRowBuilder, MessageFlags, StringSelectMenuBuilder, ThreadAutoArchiveDuration, } from 'discord.js';
+import { getSessionEventSnapshot, getThreadSession, setThreadSession, } from '../database.js';
+import { resolveTextChannel, resolveWorkingDirectory, sendThreadMessage, } from '../discord-utils.js';
+import { collectSessionChunks, batchChunksForDiscord, } from '../message-formatting.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { getDerivedSubagentSessions, } from '../session-handler/event-stream-state.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { getThreadChannel, parsePersistedEventRows, } from './fork.js';
+const forkLogger = createLogger(LogPrefix.FORK);
+function truncateLabelPart(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    if (maxLength <= 1) {
+        return text.slice(0, maxLength);
+    }
+    return `${text.slice(0, maxLength - 1)}…`;
+}
+function getSubagentOptionLabel({ subagentType, description, }) {
+    const agent = truncateLabelPart(subagentType || 'task', 24);
+    const cleanedDescription = description?.trim() || 'No description';
+    const descriptionBudget = Math.max(1, 100 - agent.length - 3);
+    const truncatedDescription = truncateLabelPart(cleanedDescription, descriptionBudget);
+    return `${agent} · ${truncatedDescription}`;
+}
+export async function handleForkSubagentCommand(interaction) {
+    const threadChannel = getThreadChannel(interaction.channel);
+    if (threadChannel instanceof Error) {
+        await interaction.reply({
+            content: threadChannel.message,
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: threadChannel,
+    });
+    if (!resolved) {
+        await interaction.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const sessionId = await getThreadSession(threadChannel.id);
+    if (!sessionId) {
+        await interaction.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+    const rows = await getSessionEventSnapshot({ sessionId });
+    const events = parsePersistedEventRows({ rows });
+    const subagentSessions = getDerivedSubagentSessions({
+        events,
+        mainSessionId: sessionId,
+    }).slice(0, 25);
+    if (subagentSessions.length === 0) {
+        await interaction.editReply({
+            content: 'No subagent task sessions found in this thread',
+        });
+        return;
+    }
+    const options = subagentSessions.map((subagentSession) => ({
+        label: getSubagentOptionLabel({
+            subagentType: subagentSession.subagentType,
+            description: subagentSession.description,
+        }),
+        value: subagentSession.childSessionId,
+        description: new Date(subagentSession.timestamp).toLocaleString().slice(0, 100),
+    }));
+    const selectMenu = new StringSelectMenuBuilder()
+        .setCustomId(`fork_subagent_select:${sessionId}`)
+        .setPlaceholder('Select a subagent session to fork')
+        .addOptions(options);
+    const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+    await interaction.editReply({
+        content: '**Fork Subagent Session**\nSelect a subagent task session to fork into a new thread:',
+        components: [actionRow],
+    });
+}
+export async function handleForkSubagentSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('fork_subagent_select:')) {
+        return;
+    }
+    const [, parentSessionId] = customId.split(':');
+    if (!parentSessionId) {
+        await interaction.reply({
+            content: 'Invalid selection data',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const selectedSessionId = interaction.values[0];
+    if (!selectedSessionId) {
+        await interaction.reply({
+            content: 'No subagent session selected',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    await interaction.deferReply();
+    const threadChannel = getThreadChannel(interaction.channel);
+    if (threadChannel instanceof Error) {
+        await interaction.editReply(threadChannel.message);
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: threadChannel,
+    });
+    if (!resolved) {
+        await interaction.editReply('Could not determine project directory for this channel');
+        return;
+    }
+    const rows = await getSessionEventSnapshot({ sessionId: parentSessionId });
+    const events = parsePersistedEventRows({ rows });
+    const selectedSubagent = getDerivedSubagentSessions({
+        events,
+        mainSessionId: parentSessionId,
+    }).find((candidate) => {
+        return candidate.childSessionId === selectedSessionId;
+    });
+    const getClient = await initializeOpencodeForDirectory(resolved.projectDirectory);
+    if (getClient instanceof Error) {
+        await interaction.editReply(`Failed to fork session: ${getClient.message}`);
+        return;
+    }
+    const forkResponse = await getClient().session.fork({
+        sessionID: selectedSessionId,
+    });
+    if (!forkResponse.data) {
+        await interaction.editReply('Failed to fork session');
+        return;
+    }
+    const textChannel = await resolveTextChannel(threadChannel);
+    if (!textChannel) {
+        await interaction.editReply('Could not resolve parent text channel');
+        return;
+    }
+    const forkedSession = forkResponse.data;
+    const forkedThread = await textChannel.threads.create({
+        name: `Fork: ${selectedSubagent?.description || selectedSubagent?.subagentType || 'subagent session'}`.slice(0, 100),
+        autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+        reason: `Forked subagent session ${selectedSessionId}`,
+    });
+    await setThreadSession(forkedThread.id, forkedSession.id);
+    await forkedThread.members.add(interaction.user.id);
+    forkLogger.log(`Created forked subagent session ${forkedSession.id} in thread ${forkedThread.id} from ${selectedSessionId}`);
+    const agentLabel = selectedSubagent?.subagentType || 'task';
+    const descriptionLabel = selectedSubagent?.description || 'No description';
+    await sendThreadMessage(forkedThread, `**Forked subagent session created!**\nAgent: \`${agentLabel}\`\nTask: ${descriptionLabel}\nFrom: \`${selectedSessionId}\`\nNew session: \`${forkedSession.id}\``);
+    try {
+        const messagesResponse = await getClient().session.messages({
+            sessionID: forkedSession.id,
+        });
+        if (messagesResponse.data) {
+            const { chunks } = collectSessionChunks({
+                messages: messagesResponse.data,
+                limit: 30,
+            });
+            const batched = batchChunksForDiscord(chunks);
+            for (const batch of batched) {
+                await sendThreadMessage(forkedThread, batch.content);
+            }
+        }
+    }
+    catch (error) {
+        forkLogger.error('Error replaying forked subagent history:', error);
+        await sendThreadMessage(forkedThread, 'Failed to load session messages, but the session is connected and ready to continue.');
+    }
+    await sendThreadMessage(forkedThread, 'You can now continue the conversation from this point.');
+    await interaction.editReply(`Subagent session forked! Continue in ${forkedThread.toString()}`);
+}

package/dist/commands/fork.js

@@ -3,34 +3,78 @@ import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectM
 import { getThreadSession, setThreadSession, setPartMessagesBatch, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage, } from '../discord-utils.js';
-import { collectSessionChunks, batchChunksForDiscord } from '../message-formatting.js';
+import { collectSessionChunks, batchChunksForDiscord, } from '../message-formatting.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
 const sessionLogger = createLogger(LogPrefix.SESSION);
 const forkLogger = createLogger(LogPrefix.FORK);
-export async function handleForkCommand(interaction) {
-    const channel = interaction.channel;
+function isTruthy(value) {
+    return Boolean(value);
+}
+function getThreadChannelFromCommand(interaction) {
+    return getThreadChannel(interaction.channel);
+}
+function getThreadChannel(channel) {
     if (!channel) {
-        await interaction.reply({
-            content: 'This command can only be used in a channel',
-            flags: MessageFlags.Ephemeral,
+        return new Error('This command can only be used in a channel');
+    }
+    if (channel.type !== ChannelType.PublicThread
+        && channel.type !== ChannelType.PrivateThread
+        && channel.type !== ChannelType.AnnouncementThread) {
+        return new Error('This command can only be used in a thread with an active session');
+    }
+    return channel;
+}
+function parsePersistedEventRows({ rows, }) {
+    return rows.flatMap((row) => {
+        const parsed = errore.try({
+            try: () => {
+                return JSON.parse(row.event_json);
+            },
+            catch: (error) => {
+                return new Error('Failed to parse persisted event JSON', {
+                    cause: error,
+                });
+            },
         });
-        return;
+        if (parsed instanceof Error) {
+            forkLogger.warn(`[fork] Skipping invalid persisted event row ${row.id}: ${parsed.message}`);
+            return [];
+        }
+        return [{
+                event: parsed,
+                timestamp: Number(row.timestamp),
+                eventIndex: Number(row.event_index),
+            }];
+    });
+}
+function truncateLabelPart(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
     }
-    const isThread = [
-        ChannelType.PublicThread,
-        ChannelType.PrivateThread,
-        ChannelType.AnnouncementThread,
-    ].includes(channel.type);
-    if (!isThread) {
+    if (maxLength <= 1) {
+        return text.slice(0, maxLength);
+    }
+    return `${text.slice(0, maxLength - 1)}…`;
+}
+function getSubagentOptionLabel({ subagentType, description, }) {
+    const agent = truncateLabelPart(subagentType || 'task', 24);
+    const cleanedDescription = description?.trim() || 'No description';
+    const descriptionBudget = Math.max(1, 100 - agent.length - 3);
+    const truncatedDescription = truncateLabelPart(cleanedDescription, descriptionBudget);
+    return `${agent} · ${truncatedDescription}`;
+}
+export async function handleForkCommand(interaction) {
+    const threadChannel = getThreadChannelFromCommand(interaction);
+    if (threadChannel instanceof Error) {
         await interaction.reply({
-            content: 'This command can only be used in a thread with an active session',
+            content: threadChannel.message,
             flags: MessageFlags.Ephemeral,
         });
         return;
     }
     const resolved = await resolveWorkingDirectory({
-        channel: channel,
+        channel: threadChannel,
     });
     if (!resolved) {
         await interaction.reply({
@@ -40,7 +84,7 @@ export async function handleForkCommand(interaction) {
         return;
     }
     const { projectDirectory } = resolved;
-    const sessionId = await getThreadSession(channel.id);
+    const sessionId = await getThreadSession(threadChannel.id);
     if (!sessionId) {
         await interaction.reply({
             content: 'No active session in this thread',
@@ -79,7 +123,9 @@ export async function handleForkCommand(interaction) {
         // injected by the opencode plugin — they clutter the dropdown preview.
         const options = recentMessages
             .map((m, index) => {
-            const textPart = m.parts.find((p) => p.type === 'text' && !p.synthetic);
+            const textPart = m.parts.find((p) => {
+                return p.type === 'text' && !p.synthetic && typeof p.text === 'string';
+            });
             if (!textPart?.text) {
                 return null;
             }
@@ -93,7 +139,7 @@ export async function handleForkCommand(interaction) {
                     .slice(0, 50),
             };
         })
-            .filter((o) => o !== null);
+            .filter(isTruthy);
         const selectMenu = new StringSelectMenuBuilder()
             // Discord component custom_id max length is 100 chars.
             // Avoid embedding long directory paths (or base64 of them) in the custom ID.
@@ -136,9 +182,9 @@ export async function handleForkSelectMenu(interaction) {
         return;
     }
     await interaction.deferReply();
-    const threadChannel = interaction.channel;
-    if (!threadChannel) {
-        await interaction.editReply('Could not access thread channel');
+    const threadChannel = getThreadChannel(interaction.channel);
+    if (threadChannel instanceof Error) {
+        await interaction.editReply(threadChannel.message);
         return;
     }
     const resolved = await resolveWorkingDirectory({
@@ -164,14 +210,9 @@ export async function handleForkSelectMenu(interaction) {
             return;
         }
         const forkedSession = forkResponse.data;
-        const parentChannel = interaction.channel;
-        if (!parentChannel ||
-            ![
-                ChannelType.PublicThread,
-                ChannelType.PrivateThread,
-                ChannelType.AnnouncementThread,
-            ].includes(parentChannel.type)) {
-            await interaction.editReply('Could not access parent channel');
+        const parentChannel = getThreadChannel(interaction.channel);
+        if (parentChannel instanceof Error) {
+            await interaction.editReply(parentChannel.message);
             return;
         }
         const textChannel = await resolveTextChannel(parentChannel);
@@ -218,3 +259,4 @@ export async function handleForkSelectMenu(interaction) {
         await interaction.editReply(`Failed to fork session: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
+export { getThreadChannel, parsePersistedEventRows };

package/dist/discord-command-registration.js

@@ -206,7 +206,7 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             option
                 .setName('directory')
                 .setDescription(truncateCommandDescription('Directory to allow, resolved from the current worktree. Use * for all folders'))
-                .setRequired(true);
+                .setRequired(false);
             return option;
         })
             .setDMPermission(false)
@@ -236,6 +236,11 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setDescription(truncateCommandDescription('Fork the session from a past user message'))
             .setDMPermission(false)
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('fork-subagent')
+            .setDescription(truncateCommandDescription('Fork a subagent task session into a new thread'))
+            .setDMPermission(false)
+            .toJSON(),
         new SlashCommandBuilder()
             .setName('btw')
             .setDescription(truncateCommandDescription('Ask something without polluting or blocking the current session'))
@@ -255,7 +260,7 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .toJSON(),
         new SlashCommandBuilder()
             .setName('model-variant')
-            .setDescription(truncateCommandDescription('Quickly change the thinking level variant for the current model'))
+            .setDescription(truncateCommandDescription('Change thinking level for current model. Tied to the model; lost when you switch models'))
             .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()