kimaki 0.17.1 → 0.18.0

package/dist/bin.js

@@ -69,8 +69,11 @@ else {
                 return;
             }
             const reason = signal ? `signal ${signal}` : `code ${code}`;
-            console.error(`[kimaki] Process exited with ${reason}, restarting in ${RESTART_DELAY_MS / 1000}s...`);
-            setTimeout(start, RESTART_DELAY_MS);
+            // Progressive backoff: 2s, 4s, 8s, 16s, capped at 30s.
+            // Prevents hammering DNS/gateway during sustained network outages.
+            const delay = Math.min(RESTART_DELAY_MS * 2 ** (restartTimestamps.length - 1), 30_000);
+            console.error(`[kimaki] Process exited with ${reason}, restarting in ${(delay / 1000).toFixed(0)}s...`);
+            setTimeout(start, delay);
         });
     }
     // Forward signals to child so graceful shutdown and heap snapshots work.

package/dist/cache-drift-plugin.js

@@ -0,0 +1,176 @@
+// OpenCode plugin that detects system prompt drift across turns.
+// When the system prompt changes between user messages, it logs a warning
+// with addition/deletion line counts so you know context cache was discarded.
+// This helps spot plugins that mutate the system prompt unexpectedly.
+import { diffLines } from 'diff';
+import * as errore from 'errore';
+import { createPluginLogger, formatPluginErrorWithStack, setPluginLogFilePath } from './plugin-logger.js';
+import { initSentry, notifyError } from './sentry.js';
+const logger = createPluginLogger('OPENCODE');
+function normalizeSystemPrompt({ system }) {
+    return system.join('\n');
+}
+function buildTurnContext({ input, directory, }) {
+    const model = input.model
+        ? `${input.model.providerID}/${input.model.modelID}${input.variant ? `:${input.variant}` : ''}`
+        : undefined;
+    return {
+        agent: input.agent,
+        model,
+        directory,
+    };
+}
+function shouldSuppressDriftWarning({ previousContext, currentContext, }) {
+    if (!previousContext || !currentContext)
+        return false;
+    return (previousContext.agent !== currentContext.agent
+        || previousContext.model !== currentContext.model
+        || previousContext.directory !== currentContext.directory);
+}
+function countDiffLines({ beforeText, afterText, }) {
+    const changes = diffLines(beforeText, afterText);
+    let additions = 0;
+    let deletions = 0;
+    for (const change of changes) {
+        if (change.added)
+            additions += change.count ?? 0;
+        if (change.removed)
+            deletions += change.count ?? 0;
+    }
+    return { additions, deletions };
+}
+function getOrCreateSessionState({ sessions, sessionId, }) {
+    const existing = sessions.get(sessionId);
+    if (existing)
+        return existing;
+    const state = {
+        userTurnCount: 0,
+        previousTurnPrompt: undefined,
+        latestTurnPrompt: undefined,
+        latestTurnPromptTurn: 0,
+        comparedTurn: 0,
+        previousTurnContext: undefined,
+        currentTurnContext: undefined,
+        pendingCompareTimeout: undefined,
+    };
+    sessions.set(sessionId, state);
+    return state;
+}
+function handleSystemTransform({ input, output, sessions, }) {
+    const sessionId = input.sessionID;
+    if (!sessionId)
+        return;
+    const currentPrompt = normalizeSystemPrompt({ system: output.system });
+    const state = getOrCreateSessionState({ sessions, sessionId });
+    const currentTurn = state.userTurnCount;
+    state.latestTurnPrompt = currentPrompt;
+    state.latestTurnPromptTurn = currentTurn;
+    if (currentTurn <= 1)
+        return;
+    if (state.comparedTurn === currentTurn)
+        return;
+    const previousPrompt = state.previousTurnPrompt;
+    state.comparedTurn = currentTurn;
+    if (!previousPrompt || previousPrompt === currentPrompt)
+        return;
+    if (shouldSuppressDriftWarning({
+        previousContext: state.previousTurnContext,
+        currentContext: state.currentTurnContext,
+    })) {
+        return;
+    }
+    const { additions, deletions } = countDiffLines({
+        beforeText: previousPrompt,
+        afterText: currentPrompt,
+    });
+    logger.warn(`[cache-drift] context cache discarded for session ${sessionId}: `
+        + `system prompt changed since previous message (+${additions} / -${deletions} lines)`);
+}
+function getDeletedSessionId({ event }) {
+    if (event.type !== 'session.deleted')
+        return undefined;
+    const sessionInfo = event.properties?.info;
+    if (!sessionInfo || typeof sessionInfo !== 'object')
+        return undefined;
+    const id = sessionInfo.id;
+    return typeof id === 'string' ? id : undefined;
+}
+const cacheDriftPlugin = async ({ directory }) => {
+    initSentry();
+    const dataDir = process.env.KIMAKI_DATA_DIR;
+    if (dataDir) {
+        setPluginLogFilePath(dataDir);
+    }
+    const sessions = new Map();
+    return {
+        'chat.message': async (input) => {
+            const sessionId = input.sessionID;
+            if (!sessionId)
+                return;
+            const state = getOrCreateSessionState({ sessions, sessionId });
+            if (state.userTurnCount > 0
+                && state.latestTurnPromptTurn === state.userTurnCount) {
+                state.previousTurnPrompt = state.latestTurnPrompt;
+                state.previousTurnContext = state.currentTurnContext;
+            }
+            state.currentTurnContext = buildTurnContext({ input, directory });
+            state.userTurnCount += 1;
+        },
+        'experimental.chat.system.transform': async (input, output) => {
+            const result = errore.try({
+                try: () => {
+                    const sessionId = input.sessionID;
+                    if (!sessionId)
+                        return;
+                    const state = getOrCreateSessionState({ sessions, sessionId });
+                    if (state.pendingCompareTimeout) {
+                        clearTimeout(state.pendingCompareTimeout);
+                    }
+                    // Delay one tick so other system-transform hooks can finish mutating
+                    // output.system before we snapshot it for drift detection.
+                    state.pendingCompareTimeout = setTimeout(() => {
+                        state.pendingCompareTimeout = undefined;
+                        try {
+                            handleSystemTransform({ input, output, sessions });
+                        }
+                        catch (err) {
+                            logger.warn(`[cache-drift] ${formatPluginErrorWithStack(err)}`);
+                            void notifyError(err, 'cache drift plugin transform hook failed');
+                        }
+                    }, 0);
+                },
+                catch: (error) => {
+                    return new Error('cache drift transform hook failed', { cause: error });
+                },
+            });
+            if (result instanceof Error) {
+                logger.warn(`[cache-drift] ${formatPluginErrorWithStack(result)}`);
+                void notifyError(result, 'cache drift plugin transform hook failed');
+            }
+        },
+        event: async ({ event }) => {
+            const result = errore.try({
+                try: () => {
+                    if (event.type !== 'session.deleted')
+                        return;
+                    const deletedSessionId = getDeletedSessionId({ event });
+                    if (!deletedSessionId)
+                        return;
+                    const state = sessions.get(deletedSessionId);
+                    if (state?.pendingCompareTimeout) {
+                        clearTimeout(state.pendingCompareTimeout);
+                    }
+                    sessions.delete(deletedSessionId);
+                },
+                catch: (error) => {
+                    return new Error('cache drift event hook failed', { cause: error });
+                },
+            });
+            if (result instanceof Error) {
+                logger.warn(`[cache-drift] ${formatPluginErrorWithStack(result)}`);
+                void notifyError(result, 'cache drift plugin event hook failed');
+            }
+        },
+    };
+};
+export { cacheDriftPlugin };

package/dist/cli-commands/bot.js

@@ -185,6 +185,32 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('bot token', 'Print the bot token for use in CI and automation (KIMAKI_BOT_TOKEN)')
+    .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
+    .action(async (options) => {
+    try {
+        if (options.dataDir) {
+            setDataDir(options.dataDir);
+        }
+        initLogFile(getDataDir());
+        await initDatabase();
+        const botRow = await getBotTokenWithMode();
+        if (!botRow) {
+            cliLogger.error('No bot configured. Run `kimaki` first.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        // Print the token to stdout so it can be captured by scripts.
+        // Use process.stdout.write to avoid extra newline from console.log
+        // when piping to other commands.
+        process.stdout.write(botRow.token + '\n');
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
 cli
     .command('bot status clear', 'Clear the bot presence/status')
     .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')

package/dist/cli-commands/session.js

@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, getThreadWorktree } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, getThreadWorktreeOrWorkspace } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
@@ -29,9 +29,9 @@ const cli = goke();
 async function resolveSessionDirectoryFromDatabase({ sessionId, }) {
     const threadId = await getThreadIdBySessionId(sessionId);
     if (threadId) {
-        const worktree = await getThreadWorktree(threadId);
-        if (worktree?.status === 'ready' && worktree.worktree_directory) {
-            return worktree.worktree_directory;
+        const workspace = await getThreadWorktreeOrWorkspace(threadId);
+        if (workspace?.status === 'ready' && workspace.workspace_directory) {
+            return workspace.workspace_directory;
         }
         const { token: botToken } = await resolveBotCredentials({});
         const rest = createDiscordRest(botToken);

package/dist/cli-runner.js

@@ -37,6 +37,27 @@ export const KIMAKI_GATEWAY_PROXY_URL = process.env.KIMAKI_GATEWAY_PROXY_URL ||
 export const KIMAKI_GATEWAY_PROXY_REST_BASE_URL = getGatewayProxyRestBaseUrl({
     gatewayUrl: KIMAKI_GATEWAY_PROXY_URL,
 });
+export function getOpenUrlCommand(url, platform = process.platform) {
+    if (platform === 'darwin') {
+        return { command: 'open', args: [url] };
+    }
+    if (platform === 'win32') {
+        return { command: 'rundll32.exe', args: ['url.dll,FileProtocolHandler', url] };
+    }
+    return { command: 'xdg-open', args: [url] };
+}
+function openUrlInDefaultBrowser(url) {
+    const { command, args } = getOpenUrlCommand(url);
+    const child = spawn(command, args, {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    child.on('error', (error) => {
+        cliLogger.warn('Failed to open install URL:', error instanceof Error ? error.message : String(error));
+    });
+    child.unref();
+}
 // Strip bracketed paste escape sequences from terminal input.
 // iTerm2 and other terminals wrap pasted content with \x1b[200~ and \x1b[201~
 // which can cause validation to fail on macOS. See: https://github.com/remorses/kimaki/issues/18
@@ -79,11 +100,23 @@ export function appIdFromToken(token) {
 // but don't run the interactive wizard.
 // In gateway mode, also sets store.discordBaseUrl so REST calls
 // are routed through the gateway-proxy REST endpoint.
+//
+// Priority: KIMAKI_BOT_TOKEN env var takes precedence over saved DB
+// credentials. This lets CI and cross-instance commands override the
+// local bot identity. If the env token looks like a gateway credential
+// (clientId:clientSecret), the gateway proxy REST URL is set automatically.
 export async function resolveBotCredentials({ appIdOverride } = {}) {
-    // DB first: getBotTokenWithMode() sets store.discordBaseUrl which is
-    // required in gateway mode so REST calls route through the proxy.
-    // Without this, inherited KIMAKI_BOT_TOKEN (a gateway credential like
-    // clientId:clientSecret) would be sent directly to discord.com → 401.
+    const envToken = process.env.KIMAKI_BOT_TOKEN;
+    if (envToken) {
+        const isGatewayToken = envToken.includes(':');
+        if (isGatewayToken) {
+            // Gateway tokens need REST calls routed through the proxy, not discord.com
+            store.setState({ discordBaseUrl: KIMAKI_GATEWAY_PROXY_REST_BASE_URL });
+        }
+        const appId = appIdOverride || appIdFromToken(envToken);
+        return { token: envToken, appId };
+    }
+    // Fall back to saved credentials in the database
     const botRow = await getBotTokenWithMode().catch((e) => {
         cliLogger.error('Database error:', e instanceof Error ? e.message : String(e));
         return null;
@@ -91,12 +124,6 @@ export async function resolveBotCredentials({ appIdOverride } = {}) {
     if (botRow) {
         return { token: botRow.token, appId: appIdOverride || botRow.appId };
     }
-    // Fall back to env var for CI/headless deployments with no database
-    const envToken = process.env.KIMAKI_BOT_TOKEN;
-    if (envToken) {
-        const appId = appIdOverride || appIdFromToken(envToken);
-        return { token: envToken, appId };
-    }
     cliLogger.error('No bot token found. Set KIMAKI_BOT_TOKEN env var or run `kimaki` first to set up.');
     process.exit(EXIT_NO_RESTART);
 }
@@ -281,6 +308,28 @@ function readErrorField(error, key) {
     }
     return undefined;
 }
+/** Transient network errors that may resolve on retry (DNS down, gateway unreachable). */
+const TRANSIENT_ERROR_CODES = new Set([
+    'ENOTFOUND',
+    'ECONNREFUSED',
+    'ETIMEDOUT',
+    'ECONNRESET',
+    'EAI_AGAIN',
+    'EPIPE',
+    'EHOSTUNREACH',
+    'ENETUNREACH',
+]);
+export function isTransientNetworkError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const code = error.code;
+    if (code && TRANSIENT_ERROR_CODES.has(code))
+        return true;
+    // discord.js wraps errors in cause chains
+    if (error.cause instanceof Error)
+        return isTransientNetworkError(error.cause);
+    return false;
+}
 export function isDiscordMemberLookupUnavailable(error) {
     const status = readErrorField(error, 'status');
     if (status === 403) {
@@ -827,13 +876,7 @@ export async function resolveCredentials({ forceRestartOnboarding, forceGateway,
         if (isInteractive) {
             note(`Open this URL to install the Kimaki bot in your Discord server:\n\n${oauthUrl}\n\nDo not share this URL with anyone — it contains your credentials.\n\nIf you don't have a server, create one first (+ button in the Discord sidebar).`, 'Install Bot');
             // Open URL in default browser
-            const { exec } = await import('node:child_process');
-            const openCmd = process.platform === 'darwin'
-                ? 'open'
-                : process.platform === 'win32'
-                    ? 'start'
-                    : 'xdg-open';
-            exec(`${openCmd} "${oauthUrl}"`);
+            openUrlInDefaultBrowser(oauthUrl);
         }
         else {
             // Non-TTY: emit structured JSON so the host process can show the URL to the user.
@@ -1011,7 +1054,9 @@ export async function run({ restartOnboarding, addChannels, useWorktrees, enable
             possiblePathsWindows: ['~\\.bun\\bin\\bun.exe'],
         }),
     ]);
-    void backgroundUpgradeKimaki();
+    if (store.getState().autoUpgradeEnabled) {
+        void backgroundUpgradeKimaki();
+    }
     // Start in-process Hrana server before database init. Required for the bot
     // process because it serves as both the DB server and the single-instance
     // lock (binds the fixed lock port). Without it, IPC and lock enforcement
@@ -1152,6 +1197,13 @@ export async function run({ restartOnboarding, addChannels, useWorktrees, enable
     catch (error) {
         cliLogger.log('Failed to connect to Discord', discordClient.ws.gateway);
         cliLogger.error('Error: ' + (error instanceof Error ? error.stack : String(error)));
+        // Transient network errors (DNS down, gateway unreachable) should allow
+        // the bin.ts wrapper to restart us after a delay. Only truly fatal errors
+        // (bad token, invalid intent, etc.) should use EXIT_NO_RESTART.
+        if (isTransientNetworkError(error)) {
+            cliLogger.error('Transient network error, exiting for wrapper restart...');
+            process.exit(1);
+        }
         process.exit(EXIT_NO_RESTART);
     }
     await setBotToken(appId, token);

package/dist/cli-runner.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, test } from 'vitest';
+import { getOpenUrlCommand } from './cli-runner.js';
+describe('getOpenUrlCommand', () => {
+    const installUrl = 'https://kimaki.dev/discord-install?clientId=abc&clientSecret=def';
+    test('uses a shell-free opener on Windows', () => {
+        expect(getOpenUrlCommand(installUrl, 'win32')).toEqual({
+            command: 'rundll32.exe',
+            args: ['url.dll,FileProtocolHandler', installUrl],
+        });
+    });
+    test('uses open on macOS', () => {
+        expect(getOpenUrlCommand(installUrl, 'darwin')).toEqual({
+            command: 'open',
+            args: [installUrl],
+        });
+    });
+    test('uses xdg-open on Linux', () => {
+        expect(getOpenUrlCommand(installUrl, 'linux')).toEqual({
+            command: 'xdg-open',
+            args: [installUrl],
+        });
+    });
+});

package/dist/cli.js

@@ -43,6 +43,7 @@ cli
     .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-sentry', 'Disable Sentry error reporting')
+    .option('--no-auto-upgrade', 'Disable background auto-upgrade on startup')
     .option('--gateway', 'Force gateway mode (use the gateway Kimaki bot instead of a self-hosted bot)')
     .option('--gateway-callback-url <url>', 'After gateway OAuth install, redirect to this URL instead of the default success page (appends ?guild_id=<id>)')
     .option('--allow-mention <type>', z
@@ -156,6 +157,7 @@ cli
             ...(options.noCritique && { critiqueEnabled: false }),
             ...(options.allowAllUsers && { allowAllUsers: true }),
             ...(permissionTimeoutMs !== undefined && { permissionTimeoutMs }),
+            ...(options.noAutoUpgrade && { autoUpgradeEnabled: false }),
             ...(options.disableSync && { syncEnabled: false }),
             ...(enabledSkills.length > 0 && { enabledSkills }),
             ...(disabledSkills.length > 0 && { disabledSkills }),
@@ -182,6 +184,9 @@ cli
         if (options.noCritique) {
             cliLogger.log('Critique disabled: diffs will not be auto-uploaded to critique.work');
         }
+        if (options.noAutoUpgrade) {
+            cliLogger.log('Auto-upgrade disabled: kimaki will not check for updates on startup');
+        }
         if (options.disableSync) {
             cliLogger.log('Background sync disabled: external OpenCode sessions will not appear in Discord');
         }

package/dist/commands/ask-question.js

@@ -11,6 +11,14 @@ const logger = createLogger(LogPrefix.ASK_QUESTION);
 // TTL prevents unbounded growth if user never answers a question.
 const QUESTION_CONTEXT_TTL_MS = 10 * 60 * 1000;
 export const pendingQuestionContexts = new Map();
+export function areAllQuestionsAnswered({ totalQuestions, answers, }) {
+    for (let i = 0; i < totalQuestions; i++) {
+        if (!answers[i]) {
+            return false;
+        }
+    }
+    return true;
+}
 export function findPendingQuestionContextForRequest({ threadId, requestId, }) {
     for (const [contextHash, context] of pendingQuestionContexts) {
         if (context.thread.id !== threadId) {
@@ -64,7 +72,6 @@ export async function showAskUserQuestionDropdowns({ thread, sessionId, director
         questions: input.questions,
         answers: {},
         totalQuestions: input.questions.length,
-        answeredCount: 0,
         contextHash,
     };
     pendingQuestionContexts.set(contextHash, context);
@@ -163,6 +170,10 @@ export async function handleAskQuestionSelectMenu(interaction) {
         logger.error(`Question index ${questionIndex} not found in context`);
         return;
     }
+    if (context.answers[questionIndex]) {
+        logger.log(`Ignored duplicate answer for question ${context.requestId} index ${questionIndex}`);
+        return;
+    }
     // Check if "other" was selected
     if (selectedValues.includes('other')) {
         // User wants to provide custom answer
@@ -176,7 +187,6 @@ export async function handleAskQuestionSelectMenu(interaction) {
             return question.options[optIdx]?.label || `Option ${optIdx + 1}`;
         });
     }
-    context.answeredCount++;
     // Update this question's message: show answer and remove dropdown
     const answeredText = context.answers[questionIndex].join(', ');
     await interaction.editReply({
@@ -186,7 +196,7 @@ export async function handleAskQuestionSelectMenu(interaction) {
     const username = interaction.user.globalName || interaction.user.username;
     await sendThreadMessage(context.thread, `» **${username}:** ${answeredText}`);
     // Check if all questions are answered
-    if (context.answeredCount >= context.totalQuestions) {
+    if (areAllQuestionsAnswered(context)) {
         // All questions answered - send result back to session
         await submitQuestionAnswers(context);
         deletePendingQuestionContextsForRequest({

package/dist/commands/ask-question.test.js

@@ -1,6 +1,6 @@
 // Tests AskUserQuestion request deduplication and cleanup helpers.
 import { afterEach, describe, expect, test, vi } from 'vitest';
-import { deletePendingQuestionContextsForRequest, pendingQuestionContexts, showAskUserQuestionDropdowns, } from './ask-question.js';
+import { areAllQuestionsAnswered, deletePendingQuestionContextsForRequest, pendingQuestionContexts, showAskUserQuestionDropdowns, } from './ask-question.js';
 function createFakeThread() {
     const send = vi.fn(async () => {
         return { id: 'msg-1' };
@@ -69,7 +69,6 @@ describe('ask-question', () => {
                 }],
             answers: {},
             totalQuestions: 1,
-            answeredCount: 0,
             contextHash: 'ctx-1',
         };
         pendingQuestionContexts.set('ctx-1', baseContext);
@@ -89,4 +88,21 @@ describe('ask-question', () => {
         expect(removed).toBe(2);
         expect([...pendingQuestionContexts.keys()]).toEqual(['ctx-3']);
     });
+    test('requires every question to have an answer', () => {
+        expect(areAllQuestionsAnswered({
+            totalQuestions: 3,
+            answers: {
+                0: ['Alpha'],
+                2: ['Gamma'],
+            },
+        })).toBe(false);
+        expect(areAllQuestionsAnswered({
+            totalQuestions: 3,
+            answers: {
+                0: ['Alpha'],
+                1: ['Beta'],
+                2: ['Gamma'],
+            },
+        })).toBe(true);
+    });
 });

package/dist/commands/merge-worktree.js

@@ -3,7 +3,7 @@
 // Preserves all commits (no squash). On rebase conflicts, asks the AI model
 // in the thread to resolve them.
 import {} from 'discord.js';
-import { getThreadWorktree, getThreadSession, getChannelDirectory, } from '../database.js';
+import { getThreadWorktreeOrWorkspace, getThreadSession, getChannelDirectory, } from '../database.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { notifyError } from '../sentry.js';
 import { mergeWorktree, listBranchesByLastCommit, validateBranchRef } from '../worktrees.js';
@@ -63,20 +63,21 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
         return;
     }
     const thread = channel;
-    const worktreeInfo = await getThreadWorktree(thread.id);
-    if (!worktreeInfo) {
+    // Check both thread_workspaces (new) and thread_worktrees (legacy)
+    const info = await getThreadWorktreeOrWorkspace(thread.id);
+    if (!info) {
         await command.editReply('This thread is not associated with a worktree');
         return;
     }
-    if (worktreeInfo.status !== 'ready' || !worktreeInfo.worktree_directory) {
-        await command.editReply(`Worktree is not ready (status: ${worktreeInfo.status})${worktreeInfo.error_message ? `: ${worktreeInfo.error_message}` : ''}`);
+    if (info.status !== 'ready' || !info.workspace_directory) {
+        await command.editReply(`Worktree is not ready (status: ${info.status})${info.error_message ? `: ${info.error_message}` : ''}`);
         return;
     }
     const rawTargetBranch = command.options.getString('target-branch') || undefined;
     let targetBranch = rawTargetBranch;
     if (targetBranch) {
         const validated = await validateBranchRef({
-            directory: worktreeInfo.project_directory,
+            directory: info.project_directory,
             ref: targetBranch,
         });
         if (validated instanceof Error) {
@@ -86,9 +87,9 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
         targetBranch = validated;
     }
     const result = await mergeWorktree({
-        worktreeDir: worktreeInfo.worktree_directory,
-        mainRepoDir: worktreeInfo.project_directory,
-        worktreeName: worktreeInfo.worktree_name,
+        worktreeDir: info.workspace_directory,
+        mainRepoDir: info.project_directory,
+        worktreeName: info.workspace_name,
         targetBranch,
         onProgress: (msg) => {
             logger.log(`[merge] ${msg}`);
@@ -126,7 +127,7 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
                     '9. Once the rebase is fully complete, tell me so I can run `/merge-worktree` again',
                 ].join('\n'),
                 thread,
-                projectDirectory: worktreeInfo.project_directory,
+                projectDirectory: info.project_directory,
                 command,
                 appId,
             });