kimaki 0.17.0 → 0.17.1

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/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/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/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

package/dist/format-tables.test.js

@@ -1,5 +1,5 @@
 import { test, expect, describe } from 'vitest';
-import { splitTablesFromMarkdown, buildTableComponents, } from './format-tables.js';
+import { splitTablesFromMarkdown, buildTableComponents, truncateComponents, countComponentCost, } from './format-tables.js';
 import { Lexer } from 'marked';
 import { ComponentType } from 'discord.js';
 function isTableToken(token) {
@@ -476,3 +476,226 @@ Still open`);
     `);
     });
 });
+describe('truncateComponents', () => {
+    // Build a worktree-like table with button rows to emulate real /worktrees output.
+    // Each row renders as: TextDisplay (1) + ActionRow with 1 Button (2) = 3 components.
+    // Plus separators between rows (1 each). Container itself costs 1.
+    // So N button rows = 1 (container) + N*3 (TD+AR+btn) + (N-1)*1 (seps) = 4N components.
+    function buildWorktreeTable(rowCount) {
+        const header = '| Source | Name | Status | Created | Folder | Action |';
+        const sep = '|---|---|---|---|---|---|';
+        const rows = Array.from({ length: rowCount }, (_, i) => {
+            return `| kimaki | wt-${i} | merged | ${i}m ago | /tmp/wt-${i} | <button id="del-${i}" variant="secondary">Delete</button> |`;
+        }).join('\n');
+        const markdown = `${header}\n${sep}\n${rows}`;
+        return splitTablesFromMarkdown(markdown, {
+            resolveButtonCustomId: ({ button }) => `action:${button.id}`,
+        });
+    }
+    test('no truncation when components fit within budget', () => {
+        const segments = buildWorktreeTable(2);
+        const allComponents = segments.flatMap((s) => {
+            return s.type === 'components' ? s.components : [];
+        });
+        const totalCost = allComponents.reduce((sum, c) => sum + countComponentCost(c), 0);
+        // 2 rows: 1 + 2*3 + 1*1 = 8 components
+        expect(totalCost).toBe(8);
+        const { components, truncated } = truncateComponents(allComponents, { maxComponents: 10 });
+        expect(truncated).toBe(false);
+        expect(components).toHaveLength(1);
+    });
+    test('truncates Container children when single Container exceeds budget', () => {
+        // 5 button rows: cost = 1 + 5*3 + 4*1 = 20 components
+        const segments = buildWorktreeTable(5);
+        const allComponents = segments.flatMap((s) => {
+            return s.type === 'components' ? s.components : [];
+        });
+        expect(allComponents).toHaveLength(1); // single Container
+        expect(countComponentCost(allComponents[0])).toBe(20);
+        // Budget of 10: Container(1) + children that fit in 9
+        const { components, truncated } = truncateComponents(allComponents, { maxComponents: 10 });
+        expect(truncated).toBe(true);
+        expect(components).toHaveLength(1); // Container kept, not dropped
+        const container = components[0];
+        expect(container.type).toBe(ComponentType.Container);
+        // Should have truncated children to fit within budget
+        const truncatedCost = countComponentCost(container);
+        expect(truncatedCost).toBeLessThanOrEqual(10);
+        expect(truncatedCost).toBeGreaterThan(1); // not empty
+        // Snapshot the truncated container structure
+        expect(container).toMatchInlineSnapshot(`
+      {
+        "components": [
+          {
+            "content": "**Source** kimaki
+      **Name** wt-0
+      **Status** merged
+      **Created** 0m ago
+      **Folder** /tmp/wt-0",
+            "type": 10,
+          },
+          {
+            "components": [
+              {
+                "custom_id": "action:del-0",
+                "disabled": false,
+                "label": "Delete",
+                "style": 2,
+                "type": 2,
+              },
+            ],
+            "type": 1,
+          },
+          {
+            "divider": true,
+            "spacing": 1,
+            "type": 14,
+          },
+          {
+            "content": "**Source** kimaki
+      **Name** wt-1
+      **Status** merged
+      **Created** 1m ago
+      **Folder** /tmp/wt-1",
+            "type": 10,
+          },
+          {
+            "components": [
+              {
+                "custom_id": "action:del-1",
+                "disabled": false,
+                "label": "Delete",
+                "style": 2,
+                "type": 2,
+              },
+            ],
+            "type": 1,
+          },
+        ],
+        "type": 17,
+      }
+    `);
+    });
+    test('reserveCost leaves room for caller-appended components', () => {
+        const segments = buildWorktreeTable(5);
+        const allComponents = segments.flatMap((s) => {
+            return s.type === 'components' ? s.components : [];
+        });
+        // Budget 12, reserve 2 → effective budget 10
+        const { components, truncated } = truncateComponents(allComponents, {
+            maxComponents: 12,
+            reserveCost: 2,
+        });
+        expect(truncated).toBe(true);
+        const cost = components.reduce((sum, c) => sum + countComponentCost(c), 0);
+        expect(cost).toBeLessThanOrEqual(10);
+        expect(cost + 2).toBeLessThanOrEqual(12);
+    });
+    test('does not leave trailing separator or partial button row', () => {
+        // 10 button rows at real budget (40, reserve 1 = 39 effective).
+        // Each row group = separator(1) + TextDisplay(1) + ActionRow+Button(2) = 4 cost.
+        // First group has no separator so costs 3.
+        // 9 full rows = 3 + 8*4 = 35, next group costs 4 → 39, fits.
+        // So all 10 rows should fit in budget 40 with reserve 1.
+        // With budget 15: 3 + 4 + 4 = 11, next group (4) → 15, fits → 4 rows.
+        const segments = buildWorktreeTable(10);
+        const allComponents = segments.flatMap((s) => {
+            return s.type === 'components' ? s.components : [];
+        });
+        const { components, truncated } = truncateComponents(allComponents, {
+            maxComponents: 15,
+            reserveCost: 1,
+        });
+        expect(truncated).toBe(true);
+        const container = components[0];
+        expect(container.type).toBe(ComponentType.Container);
+        if (container.type !== ComponentType.Container)
+            throw new Error('unreachable');
+        // Last child must not be a separator
+        const lastChild = container.components.at(-1);
+        expect(lastChild.type).not.toBe(ComponentType.Separator);
+        // Every TextDisplay row must be followed by its ActionRow (no orphaned text)
+        for (let i = 0; i < container.components.length; i++) {
+            const child = container.components[i];
+            if (child.type === ComponentType.TextDisplay) {
+                const next = container.components[i + 1];
+                // Next should be ActionRow or Separator (if this is a text-only row).
+                // For button rows, next must be ActionRow.
+                if (next && next.type === ComponentType.Separator) {
+                    // text-only row followed by separator — fine
+                    continue;
+                }
+                if (next && next.type === ComponentType.ActionRow) {
+                    // button row followed by its action row — fine
+                    continue;
+                }
+                // Last child is a TextDisplay — acceptable only if it's the final item
+                // (the group was included whole)
+                if (i === container.components.length - 1) {
+                    // This means we have an orphaned TextDisplay at the end without its button.
+                    // The group-based truncation should prevent this for button rows.
+                    // For this test all rows have buttons, so this should not happen.
+                    expect(next).toBeDefined();
+                }
+            }
+        }
+        const totalCost = components.reduce((sum, c) => sum + countComponentCost(c), 0);
+        expect(totalCost).toBeLessThanOrEqual(14); // 15 - 1 reserve
+    });
+    test('handles multiple top-level components before the large Container', () => {
+        const segments = buildWorktreeTable(3);
+        const allComponents = segments.flatMap((s) => {
+            return s.type === 'components' ? s.components : [];
+        });
+        // Prepend a TextDisplay (cost 1) before the Container
+        const textDisplay = { type: ComponentType.TextDisplay, content: 'Notice text' };
+        const combined = [textDisplay, ...allComponents];
+        // Budget 10: TextDisplay(1) + Container with truncated children(≤9)
+        const { components, truncated } = truncateComponents(combined, { maxComponents: 10 });
+        expect(truncated).toBe(true);
+        expect(components).toHaveLength(2); // TextDisplay + truncated Container
+        expect(components[0].type).toBe(ComponentType.TextDisplay);
+        expect(components[1].type).toBe(ComponentType.Container);
+        const totalCost = components.reduce((sum, c) => sum + countComponentCost(c), 0);
+        expect(totalCost).toBeLessThanOrEqual(10);
+    });
+    test('truncates when text size exceeds limit even if component count fits', () => {
+        // Build a table with long folder paths to simulate real /worktrees output
+        const header = '| Name | Folder |';
+        const sep = '|---|---|';
+        const rows = Array.from({ length: 10 }, (_, i) => {
+            // Each row has ~120 chars of text content
+            const longPath = `/Users/morse/.kimaki/worktrees/abcd1234/very-long-branch-name-${i}-feature`;
+            return `| worktree-${i} | ${longPath} |`;
+        }).join('\n');
+        const markdown = `${header}\n${sep}\n${rows}`;
+        const segments = splitTablesFromMarkdown(markdown);
+        const allComponents = segments.flatMap((s) => {
+            return s.type === 'components' ? s.components : [];
+        });
+        // Component count is fine (10 rows + 9 separators + 1 container = 20),
+        // but set text limit low to force text-based truncation
+        const { components, truncated } = truncateComponents(allComponents, {
+            maxComponents: 40,
+            maxTextSize: 500,
+        });
+        expect(truncated).toBe(true);
+        expect(components).toHaveLength(1);
+        // Verify total text is under the limit
+        const container = components[0];
+        expect(container.type).toBe(ComponentType.Container);
+        if (container.type !== ComponentType.Container)
+            throw new Error('unreachable');
+        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(500);
+        // Should have fewer than 10 rows
+        const textDisplays = container.components.filter((c) => c.type === ComponentType.TextDisplay);
+        expect(textDisplays.length).toBeLessThan(10);
+        expect(textDisplays.length).toBeGreaterThan(0);
+    });
+});

package/dist/interaction-handler.js

@@ -484,13 +484,32 @@ export function registerInteractionHandler({ discordClient, appId, }) {
             interactionLogger.error('[INTERACTION] Error handling interaction:', error);
             void notifyError(error, 'Interaction handler error');
             try {
-                if (interaction.isRepliable() &&
-                    !interaction.replied &&
-                    !interaction.deferred) {
-                    await interaction.reply({
-                        content: 'An error occurred processing this command.',
-                        flags: MessageFlags.Ephemeral,
-                    });
+                if (interaction.isRepliable() && !interaction.replied) {
+                    if (interaction.deferred) {
+                        // Component interactions that used deferUpdate() set ephemeral
+                        // to null. For those, followUp is correct (editReply would
+                        // overwrite the original message). For deferReply() interactions
+                        // (ephemeral is true/false), editReply resolves the pending reply.
+                        const usedDeferUpdate = interaction.isMessageComponent() &&
+                            interaction.ephemeral === null;
+                        if (usedDeferUpdate) {
+                            await interaction.followUp({
+                                content: 'An error occurred processing this interaction.',
+                                flags: MessageFlags.Ephemeral,
+                            });
+                        }
+                        else {
+                            await interaction.editReply({
+                                content: 'An error occurred processing this command.',
+                            });
+                        }
+                    }
+                    else {
+                        await interaction.reply({
+                            content: 'An error occurred processing this command.',
+                            flags: MessageFlags.Ephemeral,
+                        });
+                    }
                 }
             }
             catch (replyError) {

package/dist/voice-handler.js

@@ -599,6 +599,12 @@ export function registerVoiceStateHandler({ discordClient, appId, }) {
                 }
                 return;
             }
+            // Check for Gemini API key before joining — voice requires it for live audio
+            const geminiApiKey = (await getGeminiApiKey(appId)) || process.env.GEMINI_API_KEY;
+            if (!geminiApiKey) {
+                voiceLogger.log(`No Gemini API key available, skipping voice channel join. Use /audio-api-key in Discord to set one.`);
+                return;
+            }
             try {
                 voiceLogger.log(`Attempting to join voice channel: ${voiceChannel.name} (${voiceChannel.id})`);
                 const connection = joinVoiceChannel({

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.17.0",
+  "version": "0.17.1",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -24,10 +24,10 @@
     "lintcn": "^0.7.1",
     "tsx": "^4.20.5",
     "undici": "^8.0.2",
+    "db": "^0.0.0",
     "discord-digital-twin": "^0.1.0",
-    "opencode-cached-provider": "^0.0.1",
     "opencode-deterministic-provider": "^0.0.1",
-    "db": "^0.0.0"
+    "opencode-cached-provider": "^0.0.1"
   },
   "dependencies": {
     "@ai-sdk/google": "^3.0.53",

package/src/channel-management.ts

@@ -250,7 +250,11 @@ export async function createDefaultKimakiChannel({
     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): ch is TextChannel => {
     if (ch.type !== ChannelType.GuildText) {
@@ -263,14 +267,8 @@ export async function createDefaultKimakiChannel({
   })
   if (existingByName) {
     logger.log(
-      `Found existing default kimaki channel by name: ${existingByName.id}, restoring DB mapping`,
+      `Found existing default kimaki channel by name: ${existingByName.id}, but it is not in our DB — skipping (likely owned by another kimaki instance)`,
     )
-    await setChannelDirectory({
-      channelId: existingByName.id,
-      directory: projectDirectory,
-      channelType: 'text',
-      skipIfExists: true,
-    })
     return null
   }
 

package/src/cli-runner.ts

@@ -1215,6 +1215,7 @@ export async function resolveCredentials({
 
     let guildId: string | undefined
     let installerDiscordUserId: string | undefined
+    let onboardingError: string | undefined
     for (let attempt = 0; attempt < 100; attempt++) {
       await new Promise((resolve) => {
         setTimeout(resolve, 3000)
@@ -1230,7 +1231,7 @@ export async function resolveCredentials({
           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}`,
           )
@@ -1249,6 +1250,17 @@ export async function resolveCredentials({
             installerDiscordUserId = data.discord_user_id
             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)) as {
+            error?: string
+            onboarding_error?: boolean
+          } | null
+          if (data?.onboarding_error && data.error) {
+            onboardingError = data.error
+            break
+          }
         }
       } catch {
         // Network error, retry
@@ -1256,14 +1268,15 @@ export async function resolveCredentials({
     }
 
     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)
     }
 

package/src/commands/last-sessions.ts

@@ -13,7 +13,7 @@ import {
 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
@@ -148,7 +148,7 @@ export async function handleLastSessionsCommand({
   const tableMarkdown = buildSessionTable({ rows })
   const segments = splitTablesFromMarkdown(tableMarkdown)
 
-  const components: APIMessageTopLevelComponent[] = segments.flatMap(
+  const allComponents: APIMessageTopLevelComponent[] = segments.flatMap(
     (segment) => {
       if (segment.type === 'components') {
         return segment.components
@@ -161,6 +161,8 @@ export async function handleLastSessionsCommand({
     },
   )
 
+  const { components } = truncateComponents(allComponents)
+
   await command.editReply({
     components,
     flags: MessageFlags.IsComponentsV2,

package/src/commands/worktrees.ts

@@ -22,7 +22,7 @@ import {
   type ThreadWorktree,
 } from '../database.js'
 import { getDb } from '../db.js'
-import { splitTablesFromMarkdown } from '../format-tables.js'
+import { splitTablesFromMarkdown, truncateComponents } from '../format-tables.js'
 import {
   buildHtmlActionCustomId,
   cancelHtmlActionsForOwner,
@@ -214,7 +214,9 @@ function buildWorktreeTable({
       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} |`
   })
@@ -514,7 +516,7 @@ async function renderWorktreesReply({
     },
   })
 
-  const components: APIMessageTopLevelComponent[] = segments.flatMap((segment) => {
+  const allComponents: APIMessageTopLevelComponent[] = segments.flatMap((segment) => {
     if (segment.type === 'components') {
       return segment.components
     }
@@ -526,6 +528,21 @@ async function renderWorktreesReply({
     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: APITextDisplayComponent = {
+      type: ComponentType.TextDisplay,
+      content: truncatedNoticeContent,
+    }
+    components.push(truncatedNotice)
+  }
+
   await editReply({
     components,
     flags: MessageFlags.IsComponentsV2,

package/src/format-tables.test.ts

@@ -2,6 +2,8 @@ import { test, expect, describe } from 'vitest'
 import {
   splitTablesFromMarkdown,
   buildTableComponents,
+  truncateComponents,
+  countComponentCost,
   type ContentSegment,
 } from './format-tables.js'
 import { Lexer, type Tokens } from 'marked'
@@ -513,3 +515,247 @@ Still open`)
     `)
   })
 })
+
+describe('truncateComponents', () => {
+  // Build a worktree-like table with button rows to emulate real /worktrees output.
+  // Each row renders as: TextDisplay (1) + ActionRow with 1 Button (2) = 3 components.
+  // Plus separators between rows (1 each). Container itself costs 1.
+  // So N button rows = 1 (container) + N*3 (TD+AR+btn) + (N-1)*1 (seps) = 4N components.
+  function buildWorktreeTable(rowCount: number) {
+    const header = '| Source | Name | Status | Created | Folder | Action |'
+    const sep = '|---|---|---|---|---|---|'
+    const rows = Array.from({ length: rowCount }, (_, i) => {
+      return `| kimaki | wt-${i} | merged | ${i}m ago | /tmp/wt-${i} | <button id="del-${i}" variant="secondary">Delete</button> |`
+    }).join('\n')
+    const markdown = `${header}\n${sep}\n${rows}`
+    return splitTablesFromMarkdown(markdown, {
+      resolveButtonCustomId: ({ button }) => `action:${button.id}`,
+    })
+  }
+
+  test('no truncation when components fit within budget', () => {
+    const segments = buildWorktreeTable(2)
+    const allComponents = segments.flatMap((s) => {
+      return s.type === 'components' ? s.components : []
+    })
+    const totalCost = allComponents.reduce((sum, c) => sum + countComponentCost(c), 0)
+    // 2 rows: 1 + 2*3 + 1*1 = 8 components
+    expect(totalCost).toBe(8)
+
+    const { components, truncated } = truncateComponents(allComponents, { maxComponents: 10 })
+    expect(truncated).toBe(false)
+    expect(components).toHaveLength(1)
+  })
+
+  test('truncates Container children when single Container exceeds budget', () => {
+    // 5 button rows: cost = 1 + 5*3 + 4*1 = 20 components
+    const segments = buildWorktreeTable(5)
+    const allComponents = segments.flatMap((s) => {
+      return s.type === 'components' ? s.components : []
+    })
+    expect(allComponents).toHaveLength(1) // single Container
+    expect(countComponentCost(allComponents[0]!)).toBe(20)
+
+    // Budget of 10: Container(1) + children that fit in 9
+    const { components, truncated } = truncateComponents(allComponents, { maxComponents: 10 })
+    expect(truncated).toBe(true)
+    expect(components).toHaveLength(1) // Container kept, not dropped
+
+    const container = components[0]!
+    expect(container.type).toBe(ComponentType.Container)
+    // Should have truncated children to fit within budget
+    const truncatedCost = countComponentCost(container)
+    expect(truncatedCost).toBeLessThanOrEqual(10)
+    expect(truncatedCost).toBeGreaterThan(1) // not empty
+
+    // Snapshot the truncated container structure
+    expect(container).toMatchInlineSnapshot(`
+      {
+        "components": [
+          {
+            "content": "**Source** kimaki
+      **Name** wt-0
+      **Status** merged
+      **Created** 0m ago
+      **Folder** /tmp/wt-0",
+            "type": 10,
+          },
+          {
+            "components": [
+              {
+                "custom_id": "action:del-0",
+                "disabled": false,
+                "label": "Delete",
+                "style": 2,
+                "type": 2,
+              },
+            ],
+            "type": 1,
+          },
+          {
+            "divider": true,
+            "spacing": 1,
+            "type": 14,
+          },
+          {
+            "content": "**Source** kimaki
+      **Name** wt-1
+      **Status** merged
+      **Created** 1m ago
+      **Folder** /tmp/wt-1",
+            "type": 10,
+          },
+          {
+            "components": [
+              {
+                "custom_id": "action:del-1",
+                "disabled": false,
+                "label": "Delete",
+                "style": 2,
+                "type": 2,
+              },
+            ],
+            "type": 1,
+          },
+        ],
+        "type": 17,
+      }
+    `)
+  })
+
+  test('reserveCost leaves room for caller-appended components', () => {
+    const segments = buildWorktreeTable(5)
+    const allComponents = segments.flatMap((s) => {
+      return s.type === 'components' ? s.components : []
+    })
+
+    // Budget 12, reserve 2 → effective budget 10
+    const { components, truncated } = truncateComponents(allComponents, {
+      maxComponents: 12,
+      reserveCost: 2,
+    })
+    expect(truncated).toBe(true)
+    const cost = components.reduce((sum, c) => sum + countComponentCost(c), 0)
+    expect(cost).toBeLessThanOrEqual(10)
+    expect(cost + 2).toBeLessThanOrEqual(12)
+  })
+
+  test('does not leave trailing separator or partial button row', () => {
+    // 10 button rows at real budget (40, reserve 1 = 39 effective).
+    // Each row group = separator(1) + TextDisplay(1) + ActionRow+Button(2) = 4 cost.
+    // First group has no separator so costs 3.
+    // 9 full rows = 3 + 8*4 = 35, next group costs 4 → 39, fits.
+    // So all 10 rows should fit in budget 40 with reserve 1.
+    // With budget 15: 3 + 4 + 4 = 11, next group (4) → 15, fits → 4 rows.
+    const segments = buildWorktreeTable(10)
+    const allComponents = segments.flatMap((s) => {
+      return s.type === 'components' ? s.components : []
+    })
+
+    const { components, truncated } = truncateComponents(allComponents, {
+      maxComponents: 15,
+      reserveCost: 1,
+    })
+    expect(truncated).toBe(true)
+
+    const container = components[0]!
+    expect(container.type).toBe(ComponentType.Container)
+    if (container.type !== ComponentType.Container) throw new Error('unreachable')
+
+    // Last child must not be a separator
+    const lastChild = container.components.at(-1)!
+    expect(lastChild.type).not.toBe(ComponentType.Separator)
+
+    // Every TextDisplay row must be followed by its ActionRow (no orphaned text)
+    for (let i = 0; i < container.components.length; i++) {
+      const child = container.components[i]!
+      if (child.type === ComponentType.TextDisplay) {
+        const next = container.components[i + 1]
+        // Next should be ActionRow or Separator (if this is a text-only row).
+        // For button rows, next must be ActionRow.
+        if (next && next.type === ComponentType.Separator) {
+          // text-only row followed by separator — fine
+          continue
+        }
+        if (next && next.type === ComponentType.ActionRow) {
+          // button row followed by its action row — fine
+          continue
+        }
+        // Last child is a TextDisplay — acceptable only if it's the final item
+        // (the group was included whole)
+        if (i === container.components.length - 1) {
+          // This means we have an orphaned TextDisplay at the end without its button.
+          // The group-based truncation should prevent this for button rows.
+          // For this test all rows have buttons, so this should not happen.
+          expect(next).toBeDefined()
+        }
+      }
+    }
+
+    const totalCost = components.reduce((sum, c) => sum + countComponentCost(c), 0)
+    expect(totalCost).toBeLessThanOrEqual(14) // 15 - 1 reserve
+  })
+
+  test('handles multiple top-level components before the large Container', () => {
+    const segments = buildWorktreeTable(3)
+    const allComponents = segments.flatMap((s) => {
+      return s.type === 'components' ? s.components : []
+    })
+
+    // Prepend a TextDisplay (cost 1) before the Container
+    const textDisplay = { type: ComponentType.TextDisplay as const, content: 'Notice text' }
+    const combined = [textDisplay, ...allComponents]
+
+    // Budget 10: TextDisplay(1) + Container with truncated children(≤9)
+    const { components, truncated } = truncateComponents(combined, { maxComponents: 10 })
+    expect(truncated).toBe(true)
+    expect(components).toHaveLength(2) // TextDisplay + truncated Container
+    expect(components[0]!.type).toBe(ComponentType.TextDisplay)
+    expect(components[1]!.type).toBe(ComponentType.Container)
+
+    const totalCost = components.reduce((sum, c) => sum + countComponentCost(c), 0)
+    expect(totalCost).toBeLessThanOrEqual(10)
+  })
+
+  test('truncates when text size exceeds limit even if component count fits', () => {
+    // Build a table with long folder paths to simulate real /worktrees output
+    const header = '| Name | Folder |'
+    const sep = '|---|---|'
+    const rows = Array.from({ length: 10 }, (_, i) => {
+      // Each row has ~120 chars of text content
+      const longPath = `/Users/morse/.kimaki/worktrees/abcd1234/very-long-branch-name-${i}-feature`
+      return `| worktree-${i} | ${longPath} |`
+    }).join('\n')
+    const markdown = `${header}\n${sep}\n${rows}`
+    const segments = splitTablesFromMarkdown(markdown)
+    const allComponents = segments.flatMap((s) => {
+      return s.type === 'components' ? s.components : []
+    })
+
+    // Component count is fine (10 rows + 9 separators + 1 container = 20),
+    // but set text limit low to force text-based truncation
+    const { components, truncated } = truncateComponents(allComponents, {
+      maxComponents: 40,
+      maxTextSize: 500,
+    })
+    expect(truncated).toBe(true)
+    expect(components).toHaveLength(1)
+
+    // Verify total text is under the limit
+    const container = components[0]!
+    expect(container.type).toBe(ComponentType.Container)
+    if (container.type !== ComponentType.Container) throw new Error('unreachable')
+
+    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(500)
+    // Should have fewer than 10 rows
+    const textDisplays = container.components.filter((c) => c.type === ComponentType.TextDisplay)
+    expect(textDisplays.length).toBeLessThan(10)
+    expect(textDisplays.length).toBeGreaterThan(0)
+  })
+})

package/src/format-tables.ts

@@ -58,7 +58,182 @@ type CalloutDescriptor = {
 // 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: APIComponentInContainer,
+): number {
+  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: { type: number; [key: string]: unknown }): number {
+  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 as { type: number })
+    }
+  }
+  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: APIMessageTopLevelComponent,
+): number {
+  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: APIMessageTopLevelComponent[],
+  {
+    reserveCost = 0,
+    reserveTextSize = 0,
+    maxComponents = MAX_COMPONENTS,
+    maxTextSize = MAX_TEXT_SIZE,
+  }: { reserveCost?: number; reserveTextSize?: number; maxComponents?: number; maxTextSize?: number } = {},
+): { components: APIMessageTopLevelComponent[]; truncated: boolean } {
+  const componentBudget = maxComponents - reserveCost
+  const textBudget = maxTextSize - reserveTextSize
+  let totalCost = 0
+  let totalText = 0
+  const result: APIMessageTopLevelComponent[] = []
+
+  for (const component of components) {
+    const cost = countComponentCost(component)
+    const text = componentTextSize(component as { type: number })
+
+    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: APIComponentInContainer[],
+  componentBudget: number,
+  textBudget: number,
+): APIComponentInContainer[] {
+  const groups = groupBySeparator(children)
+  let cost = 0
+  let text = 0
+  const result: APIComponentInContainer[] = []
+
+  for (const group of groups) {
+    const groupCost = group.reduce((sum, child) => sum + childComponentCost(child), 0)
+    const groupText = group.reduce((sum, child) => sum + componentTextSize(child as { type: number }), 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: APIComponentInContainer[],
+): APIComponentInContainer[][] {
+  const rawGroups: APIComponentInContainer[][] = []
+  let current: APIComponentInContainer[] = []
+
+  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.

package/src/interaction-handler.ts

@@ -670,15 +670,31 @@ export function registerInteractionHandler({
         )
         void notifyError(error, 'Interaction handler error')
         try {
-          if (
-            interaction.isRepliable() &&
-            !interaction.replied &&
-            !interaction.deferred
-          ) {
-            await interaction.reply({
-              content: 'An error occurred processing this command.',
-              flags: MessageFlags.Ephemeral,
-            })
+          if (interaction.isRepliable() && !interaction.replied) {
+            if (interaction.deferred) {
+              // Component interactions that used deferUpdate() set ephemeral
+              // to null. For those, followUp is correct (editReply would
+              // overwrite the original message). For deferReply() interactions
+              // (ephemeral is true/false), editReply resolves the pending reply.
+              const usedDeferUpdate =
+                interaction.isMessageComponent() &&
+                interaction.ephemeral === null
+              if (usedDeferUpdate) {
+                await interaction.followUp({
+                  content: 'An error occurred processing this interaction.',
+                  flags: MessageFlags.Ephemeral,
+                })
+              } else {
+                await interaction.editReply({
+                  content: 'An error occurred processing this command.',
+                })
+              }
+            } else {
+              await interaction.reply({
+                content: 'An error occurred processing this command.',
+                flags: MessageFlags.Ephemeral,
+              })
+            }
           }
         } catch (replyError) {
           interactionLogger.error(

package/src/voice-handler.ts

@@ -835,6 +835,16 @@ export function registerVoiceStateHandler({
           return
         }
 
+        // Check for Gemini API key before joining — voice requires it for live audio
+        const geminiApiKey =
+          (await getGeminiApiKey(appId)) || process.env.GEMINI_API_KEY
+        if (!geminiApiKey) {
+          voiceLogger.log(
+            `No Gemini API key available, skipping voice channel join. Use /audio-api-key in Discord to set one.`,
+          )
+          return
+        }
+
         try {
           voiceLogger.log(
             `Attempting to join voice channel: ${voiceChannel.name} (${voiceChannel.id})`,