kimaki 0.16.0 → 0.17.1

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

@@ -19,7 +19,7 @@ import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provid
 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, getSessionAgent, getChannelAgent, } from './database.js';
+import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, setChannelAgent, setChannelModel, getThreadSession, getSessionModel, getSessionAgent, getChannelAgent, setSessionModel, } from './database.js';
 import { getDb } from './db.js';
 import * as orm from 'drizzle-orm';
 import * as schema from './schema.js';
@@ -213,6 +213,9 @@ describe('agent model resolution', () => {
         });
         // Add extra models to the provider so opencode accepts them
         const providerConfig = opencodeConfig.provider[PROVIDER_NAME];
+        if (!providerConfig) {
+            throw new Error(`Missing deterministic provider config for ${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 };
@@ -532,6 +535,76 @@ describe('agent model resolution', () => {
         expect(footerMessage.content).toContain(CHANNEL_MODEL);
         expect(footerMessage.content).not.toContain(DEFAULT_MODEL);
     }, 15_000);
+    test('/btw fork keeps source session model when channel model differs', async () => {
+        const db = await getDb();
+        await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID));
+        await db.delete(schema.channel_models).where(orm.eq(schema.channel_models.channel_id, TEXT_CHANNEL_ID));
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: btw-source-msg',
+        });
+        const sourceThread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: btw-source-msg';
+            },
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: sourceThread.id,
+            timeout: 6_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: discord.botUserId,
+        });
+        const sourceSessionId = await getThreadSession(sourceThread.id);
+        expect(sourceSessionId).toBeDefined();
+        if (!sourceSessionId)
+            throw new Error('Expected source session');
+        await setSessionModel({
+            sessionId: sourceSessionId,
+            modelId: `${PROVIDER_NAME}/${PLAN_AGENT_MODEL}`,
+        });
+        await setChannelModel({
+            channelId: TEXT_CHANNEL_ID,
+            modelId: `${PROVIDER_NAME}/${CHANNEL_MODEL}`,
+        });
+        await discord.thread(sourceThread.id).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: btw-model-check. btw',
+        });
+        const forkedThread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'btw: Reply with exactly: btw-model-check';
+            },
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: forkedThread.id,
+            timeout: 6_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: discord.botUserId,
+        });
+        const forkedSessionId = await getThreadSession(forkedThread.id);
+        expect(forkedSessionId).toBeDefined();
+        const forkedSessionModel = forkedSessionId
+            ? await getSessionModel(forkedSessionId)
+            : undefined;
+        const forkedThreadText = (await discord.thread(forkedThread.id).text())
+            .replace(`<#${sourceThread.id}>`, '<#SOURCE_THREAD>');
+        expect(forkedThreadText).toMatchInlineSnapshot(`
+        "--- 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*"
+      `);
+        expect(forkedSessionModel).toMatchInlineSnapshot(`
+        {
+          "modelId": "deterministic-provider/plan-model-v2",
+          "variant": null,
+        }
+      `);
+        expect(forkedSessionModel?.modelId).not.toBe(`${PROVIDER_NAME}/${CHANNEL_MODEL}`);
+    }, 20_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');

package/dist/channel-management.js

@@ -153,7 +153,11 @@ export async function createDefaultKimakiChannel({ guild, botName, appId, isGate
         logger.log(`Default kimaki channel already exists: ${mappedChannelInGuild.id}`);
         return null;
     }
-    // 2. Fallback: detect existing channel by name+category
+    // 2. Fallback: detect existing channel by name+category.
+    // If a "kimaki" channel already exists in the guild but is NOT in our local
+    // DB, it was likely created by another kimaki instance (different machine).
+    // Do NOT adopt it — just skip channel creation entirely to avoid both
+    // instances fighting over the same channel.
     const kimakiCategory = await ensureKimakiCategory(guild, botName);
     const existingByName = guild.channels.cache.find((ch) => {
         if (ch.type !== ChannelType.GuildText) {
@@ -165,13 +169,7 @@ export async function createDefaultKimakiChannel({ guild, botName, appId, isGate
         return ch.name === 'kimaki' || ch.name.startsWith('kimaki-');
     });
     if (existingByName) {
-        logger.log(`Found existing default kimaki channel by name: ${existingByName.id}, restoring DB mapping`);
-        await setChannelDirectory({
-            channelId: existingByName.id,
-            directory: projectDirectory,
-            channelType: 'text',
-            skipIfExists: true,
-        });
+        logger.log(`Found existing default kimaki channel by name: ${existingByName.id}, but it is not in our DB — skipping (likely owned by another kimaki instance)`);
         return null;
     }
     // Git init — gracefully skip if git is not installed

package/dist/cli-runner.js

@@ -848,6 +848,7 @@ export async function resolveCredentials({ forceRestartOnboarding, forceGateway,
         pollUrl.searchParams.set('secret', clientSecret);
         let guildId;
         let installerDiscordUserId;
+        let onboardingError;
         for (let attempt = 0; attempt < 100; attempt++) {
             await new Promise((resolve) => {
                 setTimeout(resolve, 3000);
@@ -860,7 +861,7 @@ export async function resolveCredentials({ forceRestartOnboarding, forceGateway,
                 else if (attempt === 45) {
                     s?.message(`Still waiting... If you don't see any servers, create one first (+ button in Discord sidebar), then reopen the URL above`);
                 }
-                else if (attempt === 150) {
+                else if (attempt === 75) {
                     s?.message(`Still waiting... Reopen the install URL if you closed it:\n${oauthUrl}`);
                 }
             }
@@ -874,19 +875,31 @@ export async function resolveCredentials({ forceRestartOnboarding, forceGateway,
                         break;
                     }
                 }
+                else if (resp.status === 404) {
+                    // Check if the server returned a specific onboarding error
+                    // (e.g. guild_id missing from Discord callback)
+                    const data = (await resp.json().catch(() => null));
+                    if (data?.onboarding_error && data.error) {
+                        onboardingError = data.error;
+                        break;
+                    }
+                }
             }
             catch {
                 // Network error, retry
             }
         }
         if (!guildId) {
+            const errorMsg = onboardingError
+                ? `Authorization failed: ${onboardingError}`
+                : 'Bot authorization timed out after 5 minutes. Please try again.';
             if (isInteractive) {
-                s?.stop('Authorization timed out');
+                s?.stop(onboardingError ? 'Authorization failed' : 'Authorization timed out');
             }
             else {
-                emitJsonEvent({ type: 'error', message: 'Authorization timed out after 5 minutes' });
+                emitJsonEvent({ type: 'error', message: errorMsg });
             }
-            cliLogger.error('Bot authorization timed out after 5 minutes. Please try again.');
+            cliLogger.error(errorMsg);
             process.exit(EXIT_NO_RESTART);
         }
         if (isInteractive) {

package/dist/commands/btw.js

@@ -8,6 +8,7 @@ import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage, } from
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
+import { copyCurrentSessionModel } from './model.js';
 const logger = createLogger(LogPrefix.FORK);
 export async function forkSessionToBtwThread({ sourceThread, projectDirectory, prompt, userId, username, appId, }) {
     // Parallelize: session lookup + opencode init + parent channel resolve are independent
@@ -33,6 +34,15 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, p
         return new Error('Failed to fork session');
     }
     const forkedSession = forkResponse.data;
+    const channelId = sourceThread.parentId || sourceThread.id;
+    await copyCurrentSessionModel({
+        sourceSessionId: sessionId,
+        targetSessionId: forkedSession.id,
+        channelId,
+        appId,
+        getClient: getClientResult,
+        directory: projectDirectory,
+    });
     const thread = await textChannel.threads.create({
         name: `btw: ${prompt}`.slice(0, 100),
         autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
@@ -53,8 +63,7 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, p
         `Do NOT continue, resume, or reference the previous task. Only answer the question below.`,
         ``,
         `Parent session: ${sessionId} (thread <#${sourceThread.id}>)`,
-        `If the user asks you to send a message or follow-up to the parent session, use:`,
-        `  kimaki send --session ${sessionId} --prompt 'your message here'`,
+        `Do NOT send messages to the parent session unless the user explicitly asks you to.`,
         ``,
         prompt,
     ].join('\n');
@@ -63,7 +72,7 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, p
         thread,
         projectDirectory,
         sdkDirectory: projectDirectory,
-        channelId: sourceThread.parentId || sourceThread.id,
+        channelId,
         appId,
     });
     await runtime.enqueueIncoming({

package/dist/commands/last-sessions.js

@@ -5,7 +5,7 @@ import { ChatInputCommandInteraction, ComponentType, MessageFlags, } from 'disco
 import path from 'node:path';
 import { getDb } from '../db.js';
 import { getChannelDirectory } from '../database.js';
-import { splitTablesFromMarkdown } from '../format-tables.js';
+import { splitTablesFromMarkdown, truncateComponents } from '../format-tables.js';
 import { formatTimeAgo } from './worktrees.js';
 const MAX_ROWS = 20;
 async function fetchRecentSessions({ client, }) {
@@ -104,7 +104,7 @@ export async function handleLastSessionsCommand({ command, }) {
     }
     const tableMarkdown = buildSessionTable({ rows });
     const segments = splitTablesFromMarkdown(tableMarkdown);
-    const components = segments.flatMap((segment) => {
+    const allComponents = segments.flatMap((segment) => {
         if (segment.type === 'components') {
             return segment.components;
         }
@@ -114,6 +114,7 @@ export async function handleLastSessionsCommand({ command, }) {
         };
         return [textDisplay];
     });
+    const { components } = truncateComponents(allComponents);
     await command.editReply({
         components,
         flags: MessageFlags.IsComponentsV2,

package/dist/commands/merge-worktree.js

@@ -9,7 +9,7 @@ import { notifyError } from '../sentry.js';
 import { mergeWorktree, listBranchesByLastCommit, validateBranchRef } from '../worktrees.js';
 import { sendThreadMessage, resolveWorkingDirectory, resolveProjectDirectoryFromAutocomplete, } from '../discord-utils.js';
 import { getOrCreateRuntime, } from '../session-handler/thread-session-runtime.js';
-import { RebaseConflictError, DirtyWorktreeError, TargetDirtyWorktreeError, } from '../errors.js';
+import { RebaseConflictError, DirtyWorktreeError, TargetDirtyWorktreeError, NothingToMergeError, } from '../errors.js';
 const logger = createLogger(LogPrefix.WORKTREE);
 /** Worktree thread title prefix - indicates unmerged worktree */
 export const WORKTREE_PREFIX = '⬦ ';
@@ -103,6 +103,11 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
             await command.editReply('Merge failed: uncommitted changes in main. Commit changes in the main worktree first, then run `/merge-worktree` again.');
             return;
         }
+        if (result instanceof NothingToMergeError) {
+            void removeWorktreePrefixFromTitle(thread);
+            await command.editReply(`Merge failed: ${result.message}`);
+            return;
+        }
         if (result instanceof RebaseConflictError) {
             await command.editReply('Rebase conflict detected. Asking the model to resolve...');
             await sendPromptToModel({

package/dist/commands/model.js

@@ -104,6 +104,28 @@ export async function ensureSessionPreferencesSnapshot({ sessionId, channelId, a
     });
     modelLogger.log(`[MODEL] Snapshotted session model ${bootstrappedModel.model} for session ${sessionId}`);
 }
+export async function copyCurrentSessionModel({ sourceSessionId, targetSessionId, channelId, appId, getClient, directory, }) {
+    const modelInfo = await getCurrentModelInfo({
+        sessionId: sourceSessionId,
+        channelId,
+        appId,
+        getClient,
+        directory,
+    });
+    if (modelInfo.type === 'none')
+        return;
+    const variant = await getVariantCascade({
+        sessionId: sourceSessionId,
+        channelId,
+        appId,
+    });
+    await setSessionModel({
+        sessionId: targetSessionId,
+        modelId: modelInfo.model,
+        variant: variant ?? null,
+    });
+    modelLogger.log(`[MODEL] Copied session model ${modelInfo.model} from ${sourceSessionId} to ${targetSessionId}`);
+}
 /**
  * Get the current model info for a channel/session, including where it comes from.
  * Priority: session > agent > channel > global > opencode default
@@ -196,16 +218,11 @@ export async function handleModelCommand({ interaction, appId, }) {
         return;
     }
     // Determine if we're in a thread or text channel
-    const isThread = [
-        ChannelType.PublicThread,
-        ChannelType.PrivateThread,
-        ChannelType.AnnouncementThread,
-    ].includes(channel.type);
+    const thread = channel.isThread() ? channel : undefined;
     let projectDirectory;
     let targetChannelId;
     let sessionId;
-    if (isThread) {
-        const thread = channel;
+    if (thread) {
         // Parallelize: resolve metadata and session ID at the same time
         const [textChannel, threadSessionId] = await Promise.all([
             resolveTextChannel(thread),
@@ -240,7 +257,7 @@ export async function handleModelCommand({ interaction, appId, }) {
             return;
         }
         const effectiveAppId = appId;
-        if (isThread && sessionId) {
+        if (thread && sessionId) {
             await ensureSessionPreferencesSnapshot({
                 sessionId,
                 channelId: targetChannelId,
@@ -313,8 +330,8 @@ export async function handleModelCommand({ interaction, appId, }) {
             dir: projectDirectory,
             channelId: targetChannelId,
             sessionId: sessionId,
-            isThread: isThread,
-            thread: isThread ? channel : undefined,
+            isThread: Boolean(thread),
+            thread,
             appId,
             providerSelectHeader,
         };

package/dist/commands/new-worktree.js

@@ -13,6 +13,7 @@ import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js
 import { buildSessionPermissions, initializeOpencodeForDirectory, } from '../opencode.js';
 import { WORKTREE_PREFIX } from './merge-worktree.js';
 import * as errore from 'errore';
+import { copyCurrentSessionModel } from './model.js';
 const logger = createLogger(LogPrefix.WORKTREE);
 const DEFAULT_WORKTREE_BASE_REF = 'HEAD';
 async function resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch, }) {
@@ -434,6 +435,14 @@ async function handleWorktreeInThread({ command, thread, appId, }) {
             await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to reuse session context there: ${error.message}`);
             return;
         }
+        await copyCurrentSessionModel({
+            sourceSessionId,
+            targetSessionId: forkedSession.id,
+            channelId: parent.id,
+            appId,
+            getClient,
+            directory: projectDirectory,
+        });
         const permissionResponse = await getClient().session.update({
             sessionID: forkedSession.id,
             directory: result,

package/dist/commands/worktrees.js

@@ -7,7 +7,7 @@
 import { ButtonInteraction, ChatInputCommandInteraction, ChannelType, ComponentType, MessageFlags, } from 'discord.js';
 import { deleteThreadWorktree, } from '../database.js';
 import { getDb } from '../db.js';
-import { splitTablesFromMarkdown } from '../format-tables.js';
+import { splitTablesFromMarkdown, truncateComponents } from '../format-tables.js';
 import { buildHtmlActionCustomId, cancelHtmlActionsForOwner, registerHtmlAction, } from '../html-actions.js';
 import * as errore from 'errore';
 import crypto from 'node:crypto';
@@ -132,7 +132,9 @@ function buildWorktreeTable({ rows, gitStatuses, guildId, }) {
             return parts.join(', ');
         })();
         const created = row.createdAt ? formatTimeAgo(row.createdAt) : '-';
-        const folder = row.directory;
+        // Show only the last 2 path segments to keep text size under Discord's
+        // 4000-char displayable text limit. Full paths are too long.
+        const folder = `…/${path.basename(path.dirname(row.directory))}/${path.basename(row.directory)}`;
         const action = buildActionCell({ row, gitStatus: gs });
         return `| ${sourceCell} | ${name} | ${status} | ${created} | ${folder} | ${action} |`;
     });
@@ -360,7 +362,7 @@ async function renderWorktreesReply({ guildId, userId, channelId, projectDirecto
             return buildHtmlActionCustomId(actionId);
         },
     });
-    const components = segments.flatMap((segment) => {
+    const allComponents = segments.flatMap((segment) => {
         if (segment.type === 'components') {
             return segment.components;
         }
@@ -370,6 +372,20 @@ async function renderWorktreesReply({ guildId, userId, channelId, projectDirecto
         };
         return [textDisplay];
     });
+    // Reserve budget for a truncation notice (1 component + its text length)
+    // so appending the notice doesn't push us over either Discord limit.
+    const truncatedNoticeContent = `*Some worktrees were not shown due to Discord's component limit. Use \`git worktree list\` for the full list.*`;
+    const { components, truncated } = truncateComponents(allComponents, {
+        reserveCost: 1,
+        reserveTextSize: truncatedNoticeContent.length,
+    });
+    if (truncated) {
+        const truncatedNotice = {
+            type: ComponentType.TextDisplay,
+            content: truncatedNoticeContent,
+        };
+        components.push(truncatedNotice);
+    }
     await editReply({
         components,
         flags: MessageFlags.IsComponentsV2,

package/dist/db.test.js

@@ -7,9 +7,10 @@ import { afterAll, describe, expect, test } from 'vitest';
 import { closeDb, getDb } from './db.js';
 import * as orm from 'drizzle-orm';
 import * as schema from './schema.js';
-import { appendSessionEventsSinceLastTimestamp, createPendingWorktree, getSessionEventSnapshot, } from './database.js';
+import { appendSessionEventsSinceLastTimestamp, createPendingWorktree, getSessionEventSnapshot, getSessionModel, setSessionModel, } from './database.js';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { chooseLockPort } from './test-utils.js';
+import { copyCurrentSessionModel } from './commands/model.js';
 afterAll(async () => {
     await closeDb();
 });
@@ -100,6 +101,31 @@ describe('getDb', () => {
         await db.delete(schema.thread_worktrees).where(orm.eq(schema.thread_worktrees.thread_id, threadId));
         await db.delete(schema.thread_sessions).where(orm.eq(schema.thread_sessions.thread_id, threadId));
     });
+    test('copyCurrentSessionModel snapshots source session model to forked session', async () => {
+        const db = await getDb();
+        const sourceSessionId = `test-source-session-${crypto.randomUUID()}`;
+        const targetSessionId = `test-target-session-${crypto.randomUUID()}`;
+        const getClient = (() => {
+            throw new Error('provider lookup should not run for explicit session models');
+        });
+        await setSessionModel({
+            sessionId: sourceSessionId,
+            modelId: 'anthropic/claude-opus-4-6',
+            variant: 'thinking',
+        });
+        await copyCurrentSessionModel({
+            sourceSessionId,
+            targetSessionId,
+            getClient,
+        });
+        await expect(getSessionModel(targetSessionId)).resolves.toMatchInlineSnapshot(`
+      {
+        "modelId": "anthropic/claude-opus-4-6",
+        "variant": "thinking",
+      }
+    `);
+        await db.delete(schema.session_models).where(orm.inArray(schema.session_models.session_id, [sourceSessionId, targetSessionId]));
+    });
     test('session event persistence uses (timestamp, event_index) ordering for deterministic same-ms replay', async () => {
         const db = await getDb();
         const threadId = 'test-session-events-thread';

package/dist/format-tables.js

@@ -8,7 +8,144 @@ import { parseInlineHtmlRenderables, } from './html-components.js';
 // Max 40 components per message (nested components count toward the limit).
 // Row cost is dynamic now because a table row can render as a plain TextDisplay
 // or as a TextDisplay plus an Action Row holding one or more buttons.
-const MAX_COMPONENTS = 40;
+export const MAX_COMPONENTS = 40;
+// Discord caps total displayable text across all components at 4000 chars.
+export const MAX_TEXT_SIZE = 4000;
+// Count cost of a single child inside a Container.
+// ActionRow with N buttons = 1 + N, everything else = 1.
+function childComponentCost(child) {
+    if ('components' in child && Array.isArray(child.components)) {
+        return 1 + child.components.length;
+    }
+    return 1;
+}
+// Count displayable text size of a component tree.
+// Discord counts all text content (TextDisplay, button labels) toward a 4000-char limit.
+function componentTextSize(component) {
+    let size = 0;
+    if ('content' in component && typeof component.content === 'string') {
+        size += component.content.length;
+    }
+    if ('label' in component && typeof component.label === 'string') {
+        size += component.label.length;
+    }
+    if ('components' in component && Array.isArray(component.components)) {
+        for (const child of component.components) {
+            size += componentTextSize(child);
+        }
+    }
+    return size;
+}
+// Count total component cost of a top-level component including nested children.
+// Discord counts every component toward the 40-component budget:
+// Container(3 children) = 4, ActionRow(2 buttons) = 3, TextDisplay = 1.
+export function countComponentCost(component) {
+    if (component.type === ComponentType.Container) {
+        let cost = 1;
+        for (const child of component.components) {
+            cost += childComponentCost(child);
+        }
+        return cost;
+    }
+    if ('components' in component && Array.isArray(component.components)) {
+        return 1 + component.components.length;
+    }
+    return 1;
+}
+// Truncate an array of top-level components to stay within Discord limits:
+// - 40 total components (nested children count)
+// - 4000 chars total displayable text
+// When a Container alone exceeds the budget, its children are truncated instead
+// of dropping the entire Container (which would show nothing).
+// reserveCost / reserveTextSize hold back budget for caller-appended components.
+// maxComponents / maxTextSize override defaults (useful for testing).
+export function truncateComponents(components, { reserveCost = 0, reserveTextSize = 0, maxComponents = MAX_COMPONENTS, maxTextSize = MAX_TEXT_SIZE, } = {}) {
+    const componentBudget = maxComponents - reserveCost;
+    const textBudget = maxTextSize - reserveTextSize;
+    let totalCost = 0;
+    let totalText = 0;
+    const result = [];
+    for (const component of components) {
+        const cost = countComponentCost(component);
+        const text = componentTextSize(component);
+        if (totalCost + cost <= componentBudget && totalText + text <= textBudget) {
+            result.push(component);
+            totalCost += cost;
+            totalText += text;
+            continue;
+        }
+        // The component doesn't fit. If it's a Container, truncate its children
+        // to fill the remaining budget instead of dropping the whole thing.
+        if (component.type === ComponentType.Container) {
+            const remainingComponentBudget = componentBudget - totalCost - 1;
+            const remainingTextBudget = textBudget - totalText;
+            if (remainingComponentBudget > 0 && remainingTextBudget > 0) {
+                const truncatedChildren = truncateContainerChildren(component.components, remainingComponentBudget, remainingTextBudget);
+                if (truncatedChildren.length > 0) {
+                    result.push({
+                        ...component,
+                        components: truncatedChildren,
+                    });
+                }
+            }
+        }
+        return { components: result, truncated: true };
+    }
+    return { components: result, truncated: false };
+}
+// Truncate a Container's children by separator-delimited row groups.
+// A row group is everything between separators (e.g. [TextDisplay, ActionRow]).
+// Either the full group fits or it's excluded — no trailing separators or
+// partial rows (like a TextDisplay without its ActionRow button).
+// Enforces both component count and text size budgets.
+function truncateContainerChildren(children, componentBudget, textBudget) {
+    const groups = groupBySeparator(children);
+    let cost = 0;
+    let text = 0;
+    const result = [];
+    for (const group of groups) {
+        const groupCost = group.reduce((sum, child) => sum + childComponentCost(child), 0);
+        const groupText = group.reduce((sum, child) => sum + componentTextSize(child), 0);
+        if (cost + groupCost > componentBudget || text + groupText > textBudget) {
+            break;
+        }
+        result.push(...group);
+        cost += groupCost;
+        text += groupText;
+    }
+    return result;
+}
+// Split children into groups delimited by Separator components.
+// Separators are prepended to the following group (they sit between rows).
+// First group has no leading separator.
+// Drops separator-only groups and strips leading separators from the first group
+// to handle edge cases (children starting/ending with separators, consecutive separators).
+function groupBySeparator(children) {
+    const rawGroups = [];
+    let current = [];
+    for (const child of children) {
+        if (child.type === ComponentType.Separator && current.length > 0) {
+            rawGroups.push(current);
+            current = [child];
+            continue;
+        }
+        current.push(child);
+    }
+    if (current.length > 0) {
+        rawGroups.push(current);
+    }
+    // Clean up: strip leading separators from first group, drop separator-only groups
+    return rawGroups
+        .map((group, index) => {
+        if (index === 0) {
+            return group.filter((child) => child.type !== ComponentType.Separator);
+        }
+        return group;
+    })
+        .filter((group) => {
+        return group.some((child) => child.type !== ComponentType.Separator);
+    });
+}
 /**
  * Split markdown into text and table component segments.
  * Tables are rendered as CV2 Container components with bold key-value TextDisplay