kimaki 0.24.0 → 0.26.0

package/dist/config.js

@@ -70,6 +70,15 @@ export function setProjectsDir(dir) {
 export function getPermissionTimeoutMs() {
     return store.getState().permissionTimeoutMs;
 }
+/**
+ * Whether external directory access is restricted to the session working
+ * directory plus a few known-safe paths.
+ * Defaults to false: every directory is allowed and users protect specific
+ * folders with their own `deny`/`ask` rules in opencode.json.
+ */
+export function getRestrictExternalDirectories() {
+    return store.getState().restrictExternalDirectories;
+}
 const DEFAULT_LOCK_PORT = 29988;
 /**
  * Derive a lock port from the data directory path.

package/dist/database.js

@@ -95,6 +95,71 @@ export async function claimScheduledTaskRunning({ taskId, startedAt }) {
         .returning({ id: schema.scheduled_tasks.id });
     return countRows(rows) > 0;
 }
+export async function releaseScheduledTaskClaim(taskId) {
+    const db = await getDb();
+    await db.update(schema.scheduled_tasks)
+        .set({ status: 'planned', running_started_at: null })
+        .where(orm.and(orm.eq(schema.scheduled_tasks.id, taskId), orm.eq(schema.scheduled_tasks.status, 'running')));
+}
+export async function createScheduledTaskRun({ taskId, startedAt, }) {
+    const db = await getDb();
+    const [run] = await db.insert(schema.scheduled_task_runs)
+        .values({ scheduled_task_id: taskId, started_at: startedAt })
+        .returning({ id: schema.scheduled_task_runs.id });
+    if (!run)
+        throw new Error(`Failed to create run for scheduled task ${taskId}`);
+    return run.id;
+}
+export async function getActiveScheduledTaskRuns(taskId) {
+    const db = await getDb();
+    return db.query.scheduled_task_runs.findMany({
+        where: {
+            scheduled_task_id: taskId,
+            status: { in: ['pending', 'running'] },
+        },
+        orderBy: { started_at: 'desc' },
+    });
+}
+export async function setScheduledTaskRunThread({ runId, threadId, }) {
+    const db = await getDb();
+    await db.update(schema.scheduled_task_runs)
+        .set({ thread_id: threadId })
+        .where(orm.eq(schema.scheduled_task_runs.id, runId));
+}
+export async function startScheduledTaskRunSession({ runId, sessionId, projectDirectory, }) {
+    const db = await getDb();
+    await db.update(schema.scheduled_task_runs)
+        .set({ status: 'running', session_id: sessionId, project_directory: projectDirectory })
+        .where(orm.and(orm.eq(schema.scheduled_task_runs.id, runId), orm.eq(schema.scheduled_task_runs.status, 'pending')));
+}
+export async function completeScheduledTaskRunsForSession(sessionId) {
+    const db = await getDb();
+    const rows = await db.update(schema.scheduled_task_runs)
+        .set({ status: 'completed', completed_at: new Date() })
+        .where(orm.and(orm.eq(schema.scheduled_task_runs.session_id, sessionId), orm.inArray(schema.scheduled_task_runs.status, ['pending', 'running'])))
+        .returning({ id: schema.scheduled_task_runs.id });
+    return rows.length;
+}
+export async function failScheduledTaskRunsForSession({ sessionId, error, }) {
+    const db = await getDb();
+    const rows = await db.update(schema.scheduled_task_runs)
+        .set({ status: 'failed', completed_at: new Date(), error })
+        .where(orm.and(orm.eq(schema.scheduled_task_runs.session_id, sessionId), orm.inArray(schema.scheduled_task_runs.status, ['pending', 'running'])))
+        .returning({ id: schema.scheduled_task_runs.id });
+    return rows.length;
+}
+export async function failScheduledTaskRun({ runId, error, }) {
+    const db = await getDb();
+    await db.update(schema.scheduled_task_runs)
+        .set({ status: 'failed', completed_at: new Date(), error })
+        .where(orm.eq(schema.scheduled_task_runs.id, runId));
+}
+export async function finishScheduledTaskRun({ runId, status, }) {
+    const db = await getDb();
+    await db.update(schema.scheduled_task_runs)
+        .set({ status, completed_at: new Date() })
+        .where(orm.eq(schema.scheduled_task_runs.id, runId));
+}
 export async function recoverStaleRunningScheduledTasks({ staleBefore }) {
     const db = await getDb();
     const rows = await db.update(schema.scheduled_tasks)

package/dist/discord-bot.js

@@ -20,7 +20,7 @@ import { getFileAttachments, getTextAttachments, resolveMentions, } from './mess
 import { extractBtwSuffix } from './btw-prefix-detection.js';
 import { isVoiceAttachment } from './voice-attachment.js';
 import { forkSessionToBtwThread } from './commands/btw.js';
-import { extractQueueSuffix, getChannelReferencePermissionRules, preprocessExistingThreadMessage, preprocessNewThreadMessage, } from './message-preprocessing.js';
+import { extractQueueSuffix, preprocessExistingThreadMessage, preprocessNewThreadMessage, } from './message-preprocessing.js';
 import { cancelPendingActionButtons } from './commands/action-buttons.js';
 import { cancelPendingQuestion, hasPendingQuestionForThread } from './commands/ask-question.js';
 import { cancelPendingFileUpload } from './commands/file-upload.js';
@@ -142,11 +142,15 @@ function parseSessionStartSourceFromMarker(marker) {
     if (typeof marker.scheduledTaskId !== 'number' ||
         !Number.isInteger(marker.scheduledTaskId) ||
         marker.scheduledTaskId < 1) {
-        return { scheduleKind: marker.scheduledKind };
+        return {
+            scheduleKind: marker.scheduledKind,
+            scheduledTaskRunId: marker.scheduledTaskRunId,
+        };
     }
     return {
         scheduleKind: marker.scheduledKind,
         scheduledTaskId: marker.scheduledTaskId,
+        scheduledTaskRunId: marker.scheduledTaskRunId,
     };
 }
 export async function createDiscordClient() {
@@ -632,6 +636,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                         ? {
                             scheduleKind: sessionStartSource.scheduleKind,
                             scheduledTaskId: sessionStartSource.scheduledTaskId,
+                            scheduledTaskRunId: sessionStartSource.scheduledTaskRunId,
                         }
                         : undefined,
                     preprocess: () => {
@@ -1085,15 +1090,12 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     ? {
                         scheduleKind: botThreadStartSource.scheduleKind,
                         scheduledTaskId: botThreadStartSource.scheduledTaskId,
+                        scheduledTaskRunId: botThreadStartSource.scheduledTaskRunId,
                     }
                     : undefined,
                 preprocess: async () => {
-                    const permissionRules = await getChannelReferencePermissionRules({
-                        message: starterMessage,
-                    });
                     return {
                         prompt,
-                        permissionRules,
                         mode: 'opencode',
                         ...(fileAttachments.length > 0 && { images: fileAttachments }),
                     };

package/dist/discord-command-registration.js

@@ -167,18 +167,6 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
         })
             .setDMPermission(false)
             .toJSON(),
-        new SlashCommandBuilder()
-            .setName('add-dir')
-            .setDescription(truncateCommandDescription('Allow the current session to access an extra directory or * for all folders'))
-            .addStringOption((option) => {
-            option
-                .setName('directory')
-                .setDescription(truncateCommandDescription('Directory to allow, resolved from the current worktree. Use * for all folders'))
-                .setRequired(false);
-            return option;
-        })
-            .setDMPermission(false)
-            .toJSON(),
         new SlashCommandBuilder()
             .setName('abort')
             .setDescription(truncateCommandDescription('Abort, stop, terminate, or cancel the current OpenCode request in this thread'))
@@ -226,6 +214,11 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setDescription(truncateCommandDescription('Set model preference, change thinking level, or clear overrides'))
             .setDMPermission(false)
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('model-variant')
+            .setDescription(truncateCommandDescription('Change thinking level for current model. Tied to the model; lost when you switch models'))
+            .setDMPermission(false)
+            .toJSON(),
         new SlashCommandBuilder()
             .setName('login')
             .setDescription(truncateCommandDescription('Authenticate with an AI provider (OAuth or API key). Use this instead of /connect'))
@@ -248,6 +241,18 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
         })
             .setDMPermission(false)
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('clear-queue')
+            .setDescription(truncateCommandDescription('Clear all queued messages in this thread'))
+            .addIntegerOption((option) => {
+            option
+                .setName('position')
+                .setDescription(truncateCommandDescription('1-based queued message position to clear (default: all)'))
+                .setMinValue(1);
+            return option;
+        })
+            .setDMPermission(false)
+            .toJSON(),
         new SlashCommandBuilder()
             .setName('queue-command')
             .setDescription(truncateCommandDescription('Queue a user command to run after the current response finishes'))

package/dist/external-directory-permissions.e2e.test.js

@@ -0,0 +1,82 @@
+// E2e test for the default external_directory permission: every directory is
+// allowed, so reading a file outside the project never shows a permission
+// prompt. The old behaviour (allow-list + prompt) is now opt-in behind the
+// --restrict-directories CLI flag.
+import { describe, expect, test } from 'vitest';
+import fs from 'node:fs';
+import { EXTERNAL_DIRECTORY_PROBE_DIR, EXTERNAL_DIRECTORY_PROBE_FILE, setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
+import { waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
+const TEXT_CHANNEL_ID = '200000000000001021';
+describe('external directory permissions', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-external-directory-e2e',
+        dirName: 'qa-external-directory-e2e',
+        username: 'external-directory-tester',
+    });
+    test('reads outside the project without a permission prompt', async () => {
+        fs.mkdirSync(EXTERNAL_DIRECTORY_PROBE_DIR, { recursive: true });
+        fs.writeFileSync(EXTERNAL_DIRECTORY_PROBE_FILE, 'external directory file');
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'EXTERNAL_DIRECTORY_PROBE_MARKER first',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name?.includes('EXTERNAL_DIRECTORY_PROBE_MARKER') ?? false;
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'external-directory-probe-done',
+            timeout: 8_000,
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'external-directory-probe-done',
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'EXTERNAL_DIRECTORY_PROBE_MARKER followup',
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'external-directory-probe-done',
+            afterUserMessageIncludes: 'followup',
+            timeout: 8_000,
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'external-directory-probe-done',
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        const text = await th.text();
+        expect(text).toMatchInlineSnapshot(`
+      "--- from: user (external-directory-tester)
+      EXTERNAL_DIRECTORY_PROBE_MARKER first
+      --- from: assistant (TestBot)
+      *using deterministic-provider/deterministic-v2*
+      ⬥ reading external directory
+      ┣ read *probe.txt*
+      ⬥ external-directory-probe-done
+      *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+      --- from: user (external-directory-tester)
+      EXTERNAL_DIRECTORY_PROBE_MARKER followup
+      --- from: assistant (TestBot)
+      ⬥ reading external directory
+      ┣ read *probe.txt*
+      ⬥ external-directory-probe-done
+      *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    `);
+        expect(text).not.toContain('Permission Required');
+    });
+});

package/dist/external-directory-project-deny.e2e.test.js

@@ -0,0 +1,68 @@
+// Regression test: a `deny` rule in the project's own opencode.json must still
+// win over kimaki's allow-all default.
+//
+// This guards a real bug. opencode evaluates permissions with findLast() over
+// merge(agent.permission, session.permission), so session rules are evaluated
+// LAST and override user config. An earlier version of the allow-all default
+// put `external_directory: '*' allow` into the session ruleset, which silently
+// made every user `deny` rule a no-op. The allow now lives in the generated
+// server config instead, where the project opencode.json deep-merges on top.
+import { describe, expect, test } from 'vitest';
+import fs from 'node:fs';
+import { EXTERNAL_DIRECTORY_PROBE_DIR, EXTERNAL_DIRECTORY_PROBE_FILE, setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
+import { waitForBotMessageContaining } from './test-utils.js';
+const TEXT_CHANNEL_ID = '200000000000001023';
+describe('external directory project deny', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-external-directory-deny-e2e',
+        dirName: 'qa-external-directory-deny-e2e',
+        username: 'external-directory-deny-tester',
+        // Exactly what a user would write in their own opencode.json to protect a
+        // folder. Kimaki's generated config allows '*', this must still beat it.
+        projectPermission: {
+            external_directory: {
+                [EXTERNAL_DIRECTORY_PROBE_DIR]: 'deny',
+                [`${EXTERNAL_DIRECTORY_PROBE_DIR}/*`]: 'deny',
+            },
+        },
+    });
+    test('project opencode.json deny beats the allow-all default', async () => {
+        fs.mkdirSync(EXTERNAL_DIRECTORY_PROBE_DIR, { recursive: true });
+        fs.writeFileSync(EXTERNAL_DIRECTORY_PROBE_FILE, 'protected file');
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'EXTERNAL_DIRECTORY_PROBE_MARKER denied',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name?.includes('EXTERNAL_DIRECTORY_PROBE_MARKER') ?? false;
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        // The deterministic matcher only emits this after the read comes back
+        // rejected by a permission rule, so seeing it proves the deny applied.
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'external-directory-probe-denied',
+            timeout: 8_000,
+        });
+        const text = await th.text();
+        expect(text).toMatchInlineSnapshot(`
+      "--- from: user (external-directory-deny-tester)
+      EXTERNAL_DIRECTORY_PROBE_MARKER denied
+      --- from: assistant (TestBot)
+      *using deterministic-provider/deterministic-v2*
+      ⬥ reading external directory
+      ┣ read *probe.txt*
+      ⬥ external-directory-probe-denied"
+    `);
+        // A deny is silent: it must not fall back to asking the user.
+        expect(text).not.toContain('Permission Required');
+        // And the read must not have succeeded, which is what the old
+        // session-level '*' allow rule caused.
+        expect(text).not.toContain('external-directory-probe-done');
+    });
+});

package/dist/format-tables.js

@@ -267,7 +267,7 @@ function flattenCalloutChildren({ segments, }) {
             return [
                 {
                     type: ComponentType.TextDisplay,
-                    content: segment.text.trim(),
+                    content: clampTextDisplayContent(segment.text.trim()),
                 },
             ];
         }
@@ -279,15 +279,29 @@ function flattenCalloutChildren({ segments, }) {
         });
     });
 }
+// Splits callout children into chunks that fit both the 40-component budget
+// (reserving 1 for the Container wrapper itself, including nested children
+// like ActionRow buttons via childComponentCost) and the 4000-char text
+// budget. Mirrors chunkRowsByComponentLimit's approach for table rows.
 function chunkCalloutChildrenByComponentLimit({ children, }) {
     const chunks = [];
     let currentChunk = [];
+    let currentCost = 1; // reserve for the Container wrapper
+    let currentText = 0;
     for (const child of children) {
-        if (currentChunk.length > 0 && currentChunk.length + 2 > MAX_COMPONENTS) {
+        const childCost = childComponentCost(child);
+        const childText = componentTextSize(child);
+        if (currentChunk.length > 0 &&
+            (currentCost + childCost > MAX_COMPONENTS ||
+                currentText + childText > MAX_TEXT_SIZE)) {
             chunks.push(currentChunk);
             currentChunk = [];
+            currentCost = 1;
+            currentText = 0;
         }
         currentChunk.push(child);
+        currentCost += childCost;
+        currentText += childText;
     }
     if (currentChunk.length > 0) {
         chunks.push(currentChunk);
@@ -423,16 +437,34 @@ function buildTextRow({ headers, cells, }) {
         const value = cell ? getRenderedCellText({ cell }) : '';
         return `**${key}** ${value}`;
     });
+    const content = clampTextDisplayContent(lines.join('\n'));
     return {
         components: [
             {
                 type: ComponentType.TextDisplay,
-                content: lines.join('\n'),
+                content,
             },
         ],
         componentCost: 1,
+        textSize: content.length,
     };
 }
+// Discord's TextDisplay component enforces the same 4000-char content limit
+// as the overall message text budget. A single row with one huge cell value
+// (e.g. a long stack trace) could otherwise exceed it on its own, which no
+// amount of row-level chunking can fix. `maxLength` lets callers reserve
+// budget for sibling content (e.g. button labels) that shares the same
+// message-wide text limit.
+function clampTextDisplayContent(content, maxLength = MAX_TEXT_SIZE) {
+    const safeMax = Math.max(0, maxLength);
+    if (content.length <= safeMax) {
+        return content;
+    }
+    if (safeMax === 0) {
+        return '';
+    }
+    return content.slice(0, safeMax - 1) + '…';
+}
 function buildButtonRow({ headers, cells, }) {
     const buttonCells = cells.filter((cell) => {
         return cell.type === 'button';
@@ -463,32 +495,48 @@ function buildButtonRow({ headers, cells, }) {
         type: ComponentType.ActionRow,
         components: buttons,
     };
+    const buttonLabelSize = buttonCells.reduce((sum, cell) => {
+        return sum + (cell.type === 'button' ? cell.label.length : 0);
+    }, 0);
+    // Reserve budget for button labels first since they can't be truncated,
+    // then clamp the TextDisplay content to whatever remains of MAX_TEXT_SIZE.
+    const content = clampTextDisplayContent(lines.join('\n'), MAX_TEXT_SIZE - buttonLabelSize);
     return {
         components: [
             {
                 type: ComponentType.TextDisplay,
-                content: lines.join('\n'),
+                content,
             },
             actionRow,
         ],
         componentCost: 2 + buttons.length,
+        textSize: content.length + buttonLabelSize,
     };
 }
+// Splits rows into chunks that fit both the 40-component budget and the
+// 4000-char displayable text budget. Wide/long tables (many long cell values)
+// can stay under the component count while still exceeding Discord's text
+// limit, which previously caused sendMessage to fail with a 400 error.
 function chunkRowsByComponentLimit({ rows, }) {
     const chunks = [];
     let currentChunk = [];
     let currentCost = 1;
+    let currentText = 0;
     for (const row of rows) {
         const separatorCost = currentChunk.length > 0 ? 1 : 0;
         const nextCost = currentCost + separatorCost + row.componentCost;
-        if (currentChunk.length > 0 && nextCost > MAX_COMPONENTS) {
+        const nextText = currentText + row.textSize;
+        if (currentChunk.length > 0 &&
+            (nextCost > MAX_COMPONENTS || nextText > MAX_TEXT_SIZE)) {
             chunks.push(currentChunk);
             currentChunk = [row];
             currentCost = 1 + row.componentCost;
+            currentText = row.textSize;
             continue;
         }
         currentChunk.push(row);
         currentCost = nextCost;
+        currentText = nextText;
     }
     if (currentChunk.length > 0) {
         chunks.push(currentChunk);

package/dist/format-tables.test.js

@@ -205,6 +205,85 @@ describe('buildTableComponents', () => {
       ]
     `);
     });
+    test('splits table into multiple containers when text size exceeds 4000 chars even though component count fits', () => {
+        // 10 rows well under the 40-component budget (1 container + 10 TDs + 9 seps = 20),
+        // but each row has a long cell value so total text exceeds MAX_TEXT_SIZE (4000).
+        const header = '| Name | Description |';
+        const sep = '| --- | --- |';
+        const longValue = 'x'.repeat(500);
+        const rows = Array.from({ length: 10 }, (_, i) => {
+            return `| row-${i} | ${longValue} |`;
+        }).join('\n');
+        const table = parseTable(`${header}\n${sep}\n${rows}`);
+        const result = buildTableComponents(table);
+        // Total text across all rows (~5000+ chars) must not fit in a single
+        // container; it should be split across multiple component segments.
+        expect(result.length).toBeGreaterThan(1);
+        for (const segment of result) {
+            if (segment.type !== 'components')
+                continue;
+            const container = segment.components[0];
+            if (!container || container.type !== ComponentType.Container)
+                continue;
+            const totalText = container.components.reduce((sum, child) => {
+                if ('content' in child && typeof child.content === 'string') {
+                    return sum + child.content.length;
+                }
+                return sum;
+            }, 0);
+            expect(totalText).toBeLessThanOrEqual(4000);
+        }
+    });
+    test('clamps a single row whose own content exceeds the 4000-char text limit', () => {
+        const header = '| Name | Description |';
+        const sep = '| --- | --- |';
+        const hugeValue = 'y'.repeat(5000);
+        const table = parseTable(`${header}\n${sep}\n| row | ${hugeValue} |`);
+        const result = buildTableComponents(table);
+        expect(result).toHaveLength(1);
+        const segment = result[0];
+        if (segment.type !== 'components')
+            throw new Error('expected components segment');
+        const container = segment.components[0];
+        if (container.type !== ComponentType.Container)
+            throw new Error('expected container');
+        const textDisplay = container.components[0];
+        if (textDisplay.type !== ComponentType.TextDisplay)
+            throw new Error('expected text display');
+        expect(textDisplay.content.length).toBeLessThanOrEqual(4000);
+    });
+    test('clamps a huge single row with a button so text + label stays under 4000 chars', () => {
+        // Regression: content used to be clamped to 4000 chars BEFORE adding the
+        // button label length, so a huge cell + button label could total >4000.
+        const header = '| Name | Description | Action |';
+        const sep = '| --- | --- | --- |';
+        const hugeValue = 'z'.repeat(5000);
+        const table = parseTable(`${header}\n${sep}\n| row | ${hugeValue} | <button id="delete-a" variant="secondary">Delete</button> |`);
+        const result = buildTableComponents(table, {
+            resolveButtonCustomId: ({ button }) => `action:${button.id}`,
+        });
+        expect(result).toHaveLength(1);
+        const segment = result[0];
+        if (segment.type !== 'components')
+            throw new Error('expected components segment');
+        const container = segment.components[0];
+        if (container.type !== ComponentType.Container)
+            throw new Error('expected container');
+        const totalText = container.components.reduce((sum, child) => {
+            if ('content' in child && typeof child.content === 'string') {
+                sum += child.content.length;
+            }
+            if ('components' in child && Array.isArray(child.components)) {
+                for (const nested of child.components) {
+                    if ('label' in nested && typeof nested.label === 'string') {
+                        sum += nested.label.length;
+                    }
+                }
+            }
+            return sum;
+        }, 0);
+        expect(totalText).toBeLessThanOrEqual(4000);
+    });
     test('renders wide rows with buttons without using sections', () => {
         const table = parseTable(`| Thread | Name | Status | Created | Folder | Action |
 | --- | --- | --- | --- | --- | --- |
@@ -475,6 +554,48 @@ Still open`);
       ]
     `);
     });
+    test('clamps callout plain text content that alone exceeds 4000 chars', () => {
+        const hugeBody = 'a'.repeat(5000);
+        const result = splitTablesFromMarkdown(`<callout accent="#2b7fff">\n${hugeBody}\n</callout>`);
+        expect(result).toHaveLength(1);
+        const segment = result[0];
+        if (segment.type !== 'components')
+            throw new Error('expected components segment');
+        const container = segment.components[0];
+        if (container.type !== ComponentType.Container)
+            throw new Error('expected container');
+        const textDisplay = container.components[0];
+        if (textDisplay.type !== ComponentType.TextDisplay)
+            throw new Error('expected text display');
+        expect(textDisplay.content.length).toBeLessThanOrEqual(4000);
+    });
+    test('splits a callout with many button rows across chunks, counting nested button cost', () => {
+        // Regression: chunkCalloutChildrenByComponentLimit used to count
+        // `currentChunk.length` (1 per row) instead of the real component cost,
+        // so it never accounted for the ActionRow + Button nested inside each row
+        // (cost 3 per button row: TextDisplay + ActionRow + Button).
+        const header = '| Name | Action |';
+        const sep = '| --- | --- |';
+        const rows = Array.from({ length: 15 }, (_, i) => {
+            return `| wt-${i} | <button id="del-${i}" variant="secondary">Delete</button> |`;
+        }).join('\n');
+        const result = splitTablesFromMarkdown(`<callout accent="#2b7fff">\n${header}\n${sep}\n${rows}\n</callout>`, {
+            resolveButtonCustomId: ({ button }) => `action:${button.id}`,
+        });
+        // 15 button rows: each row costs TextDisplay(1) + ActionRow(1) + Button(1) = 3,
+        // plus a separator between rows. Real cost far exceeds MAX_COMPONENTS (40)
+        // for one Container, so this must split into multiple segments.
+        expect(result.length).toBeGreaterThan(1);
+        for (const segment of result) {
+            if (segment.type !== 'components')
+                continue;
+            const container = segment.components[0];
+            if (!container || container.type !== ComponentType.Container)
+                continue;
+            const cost = countComponentCost(container);
+            expect(cost).toBeLessThanOrEqual(40);
+        }
+    });
 });
 describe('truncateComponents', () => {
     // Build a worktree-like table with button rows to emulate real /worktrees output.

package/dist/interaction-handler.js

@@ -14,7 +14,6 @@ import { handleRemoveProjectCommand, handleRemoveProjectAutocomplete, } from './
 import { handleCreateNewProjectCommand } from './commands/create-new-project.js';
 import { handlePermissionButton } from './commands/permissions.js';
 import { handleAbortCommand } from './commands/abort.js';
-import { handleAddDirCommand } from './commands/add-dir.js';
 import { handleCompactCommand } from './commands/compact.js';
 import { handleShareCommand } from './commands/share.js';
 import { handleDiffCommand } from './commands/diff.js';
@@ -29,7 +28,7 @@ import { handleAskQuestionSelectMenu } from './commands/ask-question.js';
 import { handleFileUploadButton, handleFileUploadModalSubmit, } from './commands/file-upload.js';
 import { handleActionButton } from './commands/action-buttons.js';
 import { handleHtmlActionButton } from './html-actions.js';
-import { handleQueueCommand, handleQueueCommandCommand, handleQueueCommandAutocomplete, } from './commands/queue.js';
+import { handleQueueCommand, handleClearQueueCommand, handleQueueCommandCommand, handleQueueCommandAutocomplete, } from './commands/queue.js';
 import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js';
 import { handleUserCommand } from './commands/user-command.js';
 import { handleVerbosityCommand, handleVerbositySelectMenu, } from './commands/verbosity.js';
@@ -42,7 +41,7 @@ import { handleMcpCommand, handleMcpSelectMenu } from './commands/mcp.js';
 import { handleScreenshareCommand } from './commands/screenshare.js';
 import { handleVscodeCommand } from './commands/vscode.js';
 import { handleModelVariantSelectMenu } from './commands/model.js';
-import { handleVariantQuickSelectMenu, handleVariantScopeSelectMenu, } from './commands/model-variant.js';
+import { handleModelVariantCommand, handleVariantQuickSelectMenu, handleVariantScopeSelectMenu, } from './commands/model-variant.js';
 import { hasKimakiAdminPermission, hasKimakiBotPermission } from './discord-utils.js';
 import { createLogger, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
@@ -200,9 +199,6 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'abort':
                         await handleAbortCommand({ command: interaction, appId });
                         return;
-                    case 'add-dir':
-                        await handleAddDirCommand({ command: interaction, appId });
-                        return;
                     case 'compact':
                         await handleCompactCommand({ command: interaction, appId });
                         return;
@@ -224,6 +220,9 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'model':
                         await handleModelCommand({ interaction, appId });
                         return;
+                    case 'model-variant':
+                        await handleModelVariantCommand({ interaction, appId });
+                        return;
                     case 'login':
                         if (!hasKimakiAdminPermission(interaction.member, interaction.guild)) {
                             await interaction.reply({
@@ -240,6 +239,9 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'queue':
                         await handleQueueCommand({ command: interaction, appId });
                         return;
+                    case 'clear-queue':
+                        await handleClearQueueCommand({ command: interaction, appId });
+                        return;
                     case 'queue-command':
                         await handleQueueCommandCommand({ command: interaction, appId });
                         return;