kimaki 0.24.0 → 0.25.0

package/dist/cli.js

@@ -39,6 +39,7 @@ cli
     .option('--no-critique', 'Disable automatic diff upload to critique.work in system prompts')
     .option('--auto-restart', 'Automatically restart the bot on crash or OOM kill')
     .option('--allow-all-users', 'Allow all Discord users to start sessions without needing Kimaki role or admin permissions (no-kimaki role still blocks)')
+    .option('--restrict-directories', 'Only allow the agent to access the session working directory and a few known-safe paths. Any other folder asks for permission. By default every directory is allowed and you protect folders with deny/ask rules in opencode.json')
     .option('--permission-timeout-minutes <minutes>', 'Permission prompt timeout in minutes before auto-rejecting (default: 10)')
     .option('--disable-sync', 'Disable background sync of external OpenCode sessions into Discord')
     .option('--no-analytics', 'Disable anonymous product analytics (Strada). Same as KIMAKI_STRADA_ENABLED=0')
@@ -155,6 +156,7 @@ cli
             ...(options.mentionMode && { defaultMentionMode: true }),
             ...(options.noCritique && { critiqueEnabled: false }),
             ...(options.allowAllUsers && { allowAllUsers: true }),
+            ...(options.restrictDirectories && { restrictExternalDirectories: true }),
             ...(permissionTimeoutMs !== undefined && { permissionTimeoutMs }),
             ...(options.noAutoUpgrade && { autoUpgradeEnabled: false }),
             ...(options.disableSync && { syncEnabled: false }),
@@ -171,6 +173,9 @@ cli
         if (options.allowAllUsers) {
             cliLogger.log('Allow all users: any Discord member can start sessions (no-kimaki role still blocks)');
         }
+        if (options.restrictDirectories) {
+            cliLogger.log('Restricted directories: the agent asks before reading outside the working directory');
+        }
         if (permissionTimeoutMs !== undefined) {
             cliLogger.log(`Permission timeout set to ${options.permissionTimeoutMinutes} minutes`);
         }

package/dist/cloudflare-transcription.js

@@ -0,0 +1,56 @@
+// Free Whisper transcription fallback via the kimaki.dev Cloudflare Worker.
+// Only usable in gateway mode: the worker authenticates the request against
+// the shared gateway_clients Postgres table using the CLI's own
+// clientId:clientSecret pair (the same credentials already used for
+// gateway-proxy REST/WebSocket calls), then runs
+// @cf/openai/whisper-large-v3-turbo on Cloudflare's own Workers AI account.
+// This means transcription costs Kimaki, never the user, so voice messages
+// work out of the box for gateway-mode installs with no OpenAI/Gemini key
+// configured.
+//
+// See website/src/server.tsx POST /api/transcribe for the server side.
+// Rate limits (per-client burst + daily request cap) are enforced there,
+// not here — a 429 from the worker just means this fallback is unavailable
+// right now and the caller should fall back to the "add API key" dialog.
+import { TranscriptionError } from './errors.js';
+import { createLogger, LogPrefix } from './logger.js';
+const voiceLogger = createLogger(LogPrefix.VOICE);
+const KIMAKI_TRANSCRIBE_URL = process.env.KIMAKI_TRANSCRIBE_URL || 'https://kimaki.dev/api/transcribe';
+export async function transcribeViaKimakiGateway({ audio, mediaType, clientId, clientSecret, }) {
+    const response = await fetch(KIMAKI_TRANSCRIBE_URL, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${clientId}:${clientSecret}`,
+            'Content-Type': mediaType || 'audio/ogg',
+        },
+        body: audio,
+    }).catch((cause) => {
+        return new TranscriptionError({
+            reason: 'Failed to reach kimaki.dev transcription endpoint',
+            cause,
+        });
+    });
+    if (response instanceof TranscriptionError)
+        return response;
+    if (!response.ok) {
+        const bodyText = await response.text().catch(() => '');
+        voiceLogger.log(`Kimaki gateway transcription failed: ${response.status} ${bodyText}`);
+        return new TranscriptionError({
+            reason: `kimaki.dev returned ${response.status}${bodyText ? `: ${bodyText}` : ''}`,
+        });
+    }
+    const data = (await response.json().catch((cause) => {
+        return new TranscriptionError({
+            reason: 'Failed to parse transcription response',
+            cause,
+        });
+    }));
+    if (data instanceof TranscriptionError)
+        return data;
+    if (!data.text) {
+        return new TranscriptionError({
+            reason: 'Empty transcription response from kimaki gateway',
+        });
+    }
+    return data.text;
+}

package/dist/commands/model-variant.js

@@ -6,7 +6,7 @@
 // Cross-menu state: Discord doesn't expose already-selected values on sibling
 // select menus in the same message. We track partial selections in the context
 // Map. Whichever menu fires second sees the first selection stored and applies.
-import { StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, MessageFlags, } from 'discord.js';
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, MessageFlags, } from 'discord.js';
 import crypto from 'node:crypto';
 import { setChannelModel, getThreadSession, setGlobalModel, getVariantCascade, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
@@ -39,6 +39,22 @@ function formatSourceLabel(info) {
             return 'none';
     }
 }
+/** /model-variant slash command entrypoint — defers reply then delegates to the shared picker. */
+export async function handleModelVariantCommand({ interaction, appId, }) {
+    await interaction.deferReply();
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.editReply({
+            content: 'This command can only be used in a channel',
+        });
+        return;
+    }
+    await showModelVariantPicker({
+        channel,
+        appId,
+        editReply: (options) => interaction.editReply(options),
+    });
+}
 export async function showModelVariantPicker({ channel, appId, editReply, }) {
     const isThread = [
         ChannelType.PublicThread,

package/dist/commands/queue.js

@@ -114,6 +114,70 @@ export async function handleQueueCommand({ command, appId, }) {
         flags: SILENT_MESSAGE_FLAGS,
     });
 }
+export async function handleClearQueueCommand({ command, }) {
+    const channel = command.channel;
+    const position = command.options.getInteger('position') ?? undefined;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await command.reply({
+            content: 'This command can only be used in a thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const runtime = getRuntime(channel.id);
+    const queueLength = runtime?.getQueueLength() ?? 0;
+    if (queueLength === 0) {
+        await command.reply({
+            content: 'No messages in queue',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    if (position !== undefined) {
+        const removed = runtime?.removeQueuePosition(position);
+        if (!removed) {
+            await command.reply({
+                content: `No queued message at position ${position}`,
+                flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+            });
+            return;
+        }
+        await command.reply({
+            content: `Cleared queued message at position ${position}`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        logger.log(`[QUEUE] User ${command.user.displayName} cleared queued position ${position} in thread ${channel.id}`);
+        return;
+    }
+    const cleared = runtime?.clearQueue() ?? [];
+    const lines = cleared.map((item, i) => {
+        const label = item.command
+            ? `/${item.command.name}`
+            : item.prompt;
+        return `${i + 1}. ${label}`;
+    });
+    let list = lines.join('\n');
+    if (list.length > 600) {
+        list = list.slice(0, 597) + '...';
+    }
+    await command.reply({
+        content: `Cleared ${cleared.length} queued message${cleared.length > 1 ? 's' : ''}:\n${list}`,
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+    logger.log(`[QUEUE] User ${command.user.displayName} cleared queue in thread ${channel.id}`);
+}
 export async function handleQueueCommandCommand({ command, appId, }) {
     const commandName = command.options.getString('command', true);
     const args = command.options.getString('arguments') || '';

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/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';
@@ -1088,12 +1088,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     }
                     : 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);