kimaki 0.20.0 → 0.21.0

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

@@ -539,13 +539,14 @@ describe('agent model resolution', () => {
         const db = await getDb();
         await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID));
         await db.delete(schema.channel_models).where(orm.eq(schema.channel_models.channel_id, TEXT_CHANNEL_ID));
+        const existingThreadIds = new Set((await discord.channel(TEXT_CHANNEL_ID).getThreads()).map((thread) => thread.id));
         await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
             content: 'Reply with exactly: btw-source-msg',
         });
         const sourceThread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
             timeout: 4_000,
-            predicate: (t) => {
-                return t.name === 'Reply with exactly: btw-source-msg';
+            predicate: (thread) => {
+                return !existingThreadIds.has(thread.id);
             },
         });
         await waitForFooterMessage({
@@ -567,13 +568,14 @@ describe('agent model resolution', () => {
             channelId: TEXT_CHANNEL_ID,
             modelId: `${PROVIDER_NAME}/${CHANNEL_MODEL}`,
         });
+        const existingForkThreadIds = new Set((await discord.channel(TEXT_CHANNEL_ID).getThreads()).map((thread) => thread.id));
         await discord.thread(sourceThread.id).user(TEST_USER_ID).sendMessage({
             content: 'Reply with exactly: btw-model-check. btw',
         });
         const forkedThread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
             timeout: 4_000,
-            predicate: (t) => {
-                return t.name === 'btw: Reply with exactly: btw-model-check';
+            predicate: (thread) => {
+                return !existingForkThreadIds.has(thread.id);
             },
         });
         await waitForFooterMessage({

package/dist/cli-commands/project.js

@@ -110,16 +110,18 @@ cli
         cliLogger.log('No projects registered');
         process.exit(0);
     }
-    // Fetch Discord channel names via REST API
+    // Fetch Discord channel names and guild IDs via REST API
     const botRow = await getBotTokenWithMode();
     const rest = botRow ? createDiscordRest(botRow.token) : null;
     const enriched = await Promise.all(channels.map(async (ch) => {
         let channelName = '';
+        let guildId = '';
         let deleted = false;
         if (rest) {
             try {
                 const data = (await rest.get(Routes.channel(ch.channel_id)));
                 channelName = data.name || '';
+                guildId = data.guild_id || '';
             }
             catch (error) {
                 // Only mark as deleted for Unknown Channel (10003) or 404,
@@ -130,13 +132,43 @@ cli
                 deleted = isUnknownChannel;
             }
         }
-        return { ...ch, channelName, deleted };
+        return { ...ch, channelName, guildId, deleted };
     }));
+    // Fetch guild names for unique guild IDs (deduplicated to save API calls)
+    const guildNameMap = new Map();
+    if (rest) {
+        const uniqueGuildIds = [...new Set(enriched.map((ch) => ch.guildId).filter(Boolean))];
+        await Promise.all(uniqueGuildIds.map(async (guildId) => {
+            try {
+                const data = (await rest.get(Routes.guild(guildId)));
+                guildNameMap.set(guildId, data.name || '');
+            }
+            catch (error) {
+                cliLogger.debug(`Failed to fetch guild ${guildId}:`, error instanceof Error ? error.stack : String(error));
+            }
+        }));
+    }
+    // Build final enriched entries with guild names resolved
+    const enrichedWithGuild = enriched.map((ch) => ({
+        ...ch,
+        guildName: ch.guildId ? (guildNameMap.get(ch.guildId) || '') : '',
+    }));
+    // Warn on stderr if the same directory appears in multiple channels (multi-guild duplicates)
+    const directoryCounts = new Map();
+    for (const ch of enrichedWithGuild) {
+        if (!ch.deleted) {
+            directoryCounts.set(ch.directory, (directoryCounts.get(ch.directory) || 0) + 1);
+        }
+    }
+    for (const [dir, count] of directoryCounts) {
+        if (count > 1) {
+            cliLogger.warn(`Directory "${dir}" is registered in ${count} channels. Use channel_id to disambiguate.`);
+        }
+    }
     // Prune stale entries if requested
+    let finalEntries = enrichedWithGuild;
     if (options.prune) {
-        const stale = enriched.filter((ch) => {
-            return ch.deleted;
-        });
+        const stale = finalEntries.filter((ch) => ch.deleted);
         if (stale.length === 0) {
             cliLogger.log('No stale channels to prune');
         }
@@ -147,21 +179,18 @@ cli
             }
             cliLogger.log(`Pruned ${stale.length} stale channel(s)`);
         }
-        // Re-filter to only show live entries after pruning
-        const live = enriched.filter((ch) => {
-            return !ch.deleted;
-        });
-        if (live.length === 0) {
+        finalEntries = finalEntries.filter((ch) => !ch.deleted);
+        if (finalEntries.length === 0) {
             cliLogger.log('No projects registered');
             process.exit(0);
         }
-        enriched.length = 0;
-        enriched.push(...live);
     }
     if (options.json) {
-        const output = enriched.map((ch) => ({
+        const output = finalEntries.map((ch) => ({
             channel_id: ch.channel_id,
             channel_name: ch.channelName,
+            guild_id: ch.guildId,
+            guild_name: ch.guildName,
             directory: ch.directory,
             folder_name: path.basename(ch.directory),
             deleted: ch.deleted,
@@ -169,15 +198,43 @@ cli
         console.log(JSON.stringify(output, null, 2));
         process.exit(0);
     }
-    for (const ch of enriched) {
+    for (const ch of finalEntries) {
         const folderName = path.basename(ch.directory);
         const deletedTag = ch.deleted ? ' (deleted from Discord)' : '';
         const channelLabel = ch.channelName ? `#${ch.channelName}` : ch.channel_id;
-        console.log(`\n${channelLabel}${deletedTag}`);
+        const guildLabel = ch.guildName || ch.guildId || '';
+        const guildSuffix = guildLabel ? ` (${guildLabel})` : '';
+        console.log(`\n${channelLabel}${guildSuffix}${deletedTag}`);
         console.log(`   Folder: ${folderName}`);
         console.log(`   Directory: ${ch.directory}`);
         console.log(`   Channel ID: ${ch.channel_id}`);
+        if (ch.guildId) {
+            console.log(`   Guild ID: ${ch.guildId}`);
+        }
+    }
+    process.exit(0);
+});
+cli
+    .command('project remove <channelId>', 'Remove a project channel mapping from the local database (does not delete the Discord channel)')
+    .action(async (channelId) => {
+    await initDatabase();
+    const db = await getDb();
+    const row = await db.query.channel_directories.findFirst({
+        where: { channel_id: channelId },
+    });
+    if (!row) {
+        cliLogger.error(`No channel mapping found for channel ID: ${channelId}`);
+        process.exit(EXIT_NO_RESTART);
+    }
+    const removed = await deleteChannelDirectoryById(channelId);
+    if (!removed) {
+        cliLogger.error(`Channel mapping disappeared before it could be removed: ${channelId}`);
+        process.exit(EXIT_NO_RESTART);
     }
+    cliLogger.log(`Removed channel mapping:`);
+    cliLogger.log(`  Channel ID: ${channelId}`);
+    cliLogger.log(`  Directory: ${row.directory}`);
+    cliLogger.log(`  Type: ${row.channel_type}`);
     process.exit(0);
 });
 cli

package/dist/cli-commands/send.js

@@ -51,6 +51,7 @@ cli
     .option('--send-at <schedule>', 'Schedule send for future (UTC ISO date/time ending in Z, or cron expression)')
     .option('--thread <threadId>', 'Post prompt to an existing thread')
     .option('--session <sessionId>', 'Post prompt to thread mapped to an existing session')
+    .option('--parent-session <sessionId>', 'Parent OpenCode session ID for newly created child sessions')
     .option('--wait', 'Wait for session to complete, then print session text to stdout')
     .action(async (options) => {
     try {
@@ -299,6 +300,7 @@ cli
                     userId: null,
                     permissions: options.permission?.length ? options.permission : null,
                     injectionGuardPatterns: options.injectionGuard?.length ? options.injectionGuard : null,
+                    parentSessionId: options.parentSession || null,
                 };
                 const taskId = await createScheduledTask({
                     scheduleKind: parsedSchedule.scheduleKind,
@@ -325,6 +327,7 @@ cli
                 ...(options.model && { model: options.model }),
                 ...(options.permission?.length ? { permissions: options.permission } : {}),
                 ...(options.injectionGuard?.length ? { injectionGuardPatterns: options.injectionGuard } : {}),
+                ...(options.parentSession && { parentSessionId: options.parentSession }),
             };
             const promptEmbed = [
                 {
@@ -438,6 +441,7 @@ cli
                 userId: resolvedUser?.id || null,
                 permissions: options.permission?.length ? options.permission : null,
                 injectionGuardPatterns: options.injectionGuard?.length ? options.injectionGuard : null,
+                parentSessionId: options.parentSession || null,
             };
             const taskId = await createScheduledTask({
                 scheduleKind: parsedSchedule.scheduleKind,
@@ -471,6 +475,7 @@ cli
                 ...(options.model && { model: options.model }),
                 ...(options.permission?.length && { permissions: options.permission }),
                 ...(options.injectionGuard?.length && { injectionGuardPatterns: options.injectionGuard }),
+                ...(options.parentSession && { parentSessionId: options.parentSession }),
             };
         const autoStartEmbed = embedMarker
             ? [{ color: 0x2b2d31, footer: { text: YAML.stringify(embedMarker) } }]

package/dist/cli-runner.js

@@ -12,6 +12,7 @@ import { discordApiUrl, getDiscordRestApiUrl, getGatewayProxyRestBaseUrl, getInt
 import crypto from 'node:crypto';
 import path from 'node:path';
 import fs from 'node:fs';
+import os from 'node:os';
 import { spawn } from 'node:child_process';
 import { createLogger, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
@@ -174,11 +175,8 @@ export async function sendDiscordMessageWithOptionalAttachment({ channelId, prom
     }
     const preview = prompt.slice(0, 100).replace(/\n/g, ' ');
     const summaryContent = `Prompt attached as file (${prompt.length} chars)\n\n> ${preview}...`;
-    const tmpDir = path.join(process.cwd(), 'tmp');
-    if (!fs.existsSync(tmpDir)) {
-        fs.mkdirSync(tmpDir, { recursive: true });
-    }
-    const tmpFile = path.join(tmpDir, `prompt-${Date.now()}.md`);
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-prompt-'));
+    const tmpFile = path.join(tmpDir, 'prompt.md');
     // Wrap long lines so the file is readable in Discord's preview
     // (Discord doesn't wrap text in file attachments)
     const wrappedPrompt = prompt
@@ -235,6 +233,7 @@ export async function sendDiscordMessageWithOptionalAttachment({ channelId, prom
     }
     finally {
         fs.unlinkSync(tmpFile);
+        fs.rmdirSync(tmpDir);
     }
 }
 export function formatRelativeTime(target) {
@@ -308,7 +307,7 @@ function readErrorField(error, key) {
     }
     return undefined;
 }
-/** Transient network errors that may resolve on retry (DNS down, gateway unreachable). */
+/** Transient network errors that may resolve on retry (DNS down, gateway unreachable, TLS blips). */
 const TRANSIENT_ERROR_CODES = new Set([
     'ENOTFOUND',
     'ECONNREFUSED',
@@ -318,13 +317,37 @@ const TRANSIENT_ERROR_CODES = new Set([
     'EPIPE',
     'EHOSTUNREACH',
     'ENETUNREACH',
+    // TLS/cert errors can be transient (intermediate CA blip, MITM proxy, cert rotation).
+    // Without these, Discord login failure exits EXIT_NO_RESTART and the bin wrapper
+    // never restarts — the bot dies permanently on "unable to verify the first certificate".
+    'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
+    'UNABLE_TO_GET_ISSUER_CERT',
+    'UNABLE_TO_GET_ISSUER_CERT_LOCALLY',
+    'UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY',
+    'CERT_SIGNATURE_FAILURE',
+    'CERT_NOT_YET_VALID',
+    'CERT_HAS_EXPIRED',
+    'CRL_HAS_EXPIRED',
+    'DEPTH_ZERO_SELF_SIGNED_CERT',
+    'SELF_SIGNED_CERT_IN_CHAIN',
+    'ERR_TLS_CERT_ALTNAME_INVALID',
 ]);
+const TRANSIENT_ERROR_MESSAGE_PATTERNS = [
+    /unable to verify the first certificate/i,
+    /certificate has expired/i,
+    /self[- ]signed certificate/i,
+    /unable to get local issuer certificate/i,
+];
 export function isTransientNetworkError(error) {
     if (!(error instanceof Error))
         return false;
     const code = error.code;
     if (code && TRANSIENT_ERROR_CODES.has(code))
         return true;
+    // Fallback when code is stripped by wrappers (discord.js sometimes rethrows by message only).
+    if (TRANSIENT_ERROR_MESSAGE_PATTERNS.some((pattern) => pattern.test(error.message))) {
+        return true;
+    }
     // discord.js wraps errors in cause chains
     if (error.cause instanceof Error)
         return isTransientNetworkError(error.cause);

package/dist/cli-runner.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { getOpenUrlCommand } from './cli-runner.js';
+import { getOpenUrlCommand, isTransientNetworkError } 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', () => {
@@ -21,3 +21,30 @@ describe('getOpenUrlCommand', () => {
         });
     });
 });
+describe('isTransientNetworkError', () => {
+    test('treats TLS leaf verification failures as transient', () => {
+        const error = Object.assign(new Error('unable to verify the first certificate'), {
+            code: 'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
+        });
+        expect(isTransientNetworkError(error)).toBe(true);
+    });
+    test('matches TLS cert failures by message when code is missing', () => {
+        expect(isTransientNetworkError(new Error('unable to verify the first certificate'))).toBe(true);
+    });
+    test('walks cause chains for nested TLS errors', () => {
+        const cause = Object.assign(new Error('unable to verify the first certificate'), {
+            code: 'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
+        });
+        expect(isTransientNetworkError(new Error('Discord login failed', { cause }))).toBe(true);
+    });
+    test('keeps fatal auth-style errors non-transient', () => {
+        expect(isTransientNetworkError(new Error('An invalid token was provided.'))).toBe(false);
+        expect(isTransientNetworkError(new Error('Used disallowed intents'))).toBe(false);
+    });
+    test('still treats classic socket codes as transient', () => {
+        const error = Object.assign(new Error('getaddrinfo ENOTFOUND'), {
+            code: 'ENOTFOUND',
+        });
+        expect(isTransientNetworkError(error)).toBe(true);
+    });
+});

package/dist/commands/btw.js

@@ -57,6 +57,9 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, p
         sendThreadMessage(thread, `Reusing context from ${sourceThreadLink} to answer prompt...\n${prompt}`),
     ]);
     logger.log(`Created btw fork session ${forkedSession.id} in thread ${thread.id} from source thread ${sourceThread.id} (session ${sessionId})`);
+    // Parent context stays in the user prompt only. Do NOT pass parentSessionId
+    // into enqueueIncoming: that would inject a parent block into the system
+    // message and bust prompt cache shared with the parent session.
     const wrappedPrompt = [
         `The user asked a side question while you were working on another task.`,
         `This is a forked session whose ONLY goal is to answer this question.`,

package/dist/commands/tasks.js

@@ -1,10 +1,11 @@
 // /tasks command — list all scheduled tasks sorted by next run time.
 // Renders a markdown table that the CV2 pipeline auto-formats for Discord,
-// including HTML-backed action buttons for cancellable tasks.
+// including HTML-backed Run now / Delete action buttons.
 import { ButtonInteraction, ChatInputCommandInteraction, ComponentType, MessageFlags, } from 'discord.js';
 import { cancelScheduledTask, listScheduledTasks, } from '../database.js';
 import { splitTablesFromMarkdown } from '../format-tables.js';
 import { buildHtmlActionCustomId, cancelHtmlActionsForOwner, registerHtmlAction, } from '../html-actions.js';
+import { runScheduledTaskNow } from '../task-runner.js';
 import { formatTimeAgo } from './worktrees.js';
 function formatTimeUntil(date) {
     const diffMs = date.getTime() - Date.now();
@@ -34,6 +35,9 @@ function scheduleLabel(task) {
     }
     return 'one-time';
 }
+function canRunTask(task) {
+    return task.status === 'planned';
+}
 function canCancelTask(task) {
     return task.status === 'planned' || task.status === 'running';
 }
@@ -42,22 +46,25 @@ function canCancelTask(task) {
 function sanitizeTableCell(value) {
     return value.replaceAll('|', '\\|').replace(/\s+/g, ' ').trim();
 }
-function buildCancelButtonHtml({ buttonId }) {
-    return `<button id="${buttonId}" variant="secondary">Delete</button>`;
+function buildRunCell(task) {
+    if (!canRunTask(task)) {
+        return '-';
+    }
+    return `<button id="run-task-${task.id}" variant="primary">Run now</button>`;
 }
-function buildActionCell(task) {
+function buildCancelCell(task) {
     if (!canCancelTask(task)) {
         return '-';
     }
-    return buildCancelButtonHtml({ buttonId: `cancel-task-${task.id}` });
+    return `<button id="cancel-task-${task.id}" variant="secondary">Delete</button>`;
 }
 // Cap rows to avoid exceeding Discord's 40-component CV2 limit.
-// Each cancellable row renders as text + action row + button (~4 components),
-// so 10 rows is a safe ceiling.
-const MAX_TASK_ROWS = 10;
+// Each actionable row is text + action row + up to 2 buttons (~4 components),
+// so 7 rows stays under the budget with separators.
+const MAX_TASK_ROWS = 7;
 function buildTaskTable({ tasks, }) {
-    const header = '| ID | Status | Prompt | Schedule | Next Run | Action |';
-    const separator = '|---|---|---|---|---|---|';
+    const header = '| ID | Status | Prompt | Schedule | Next Run | Run | Delete |';
+    const separator = '|---|---|---|---|---|---|---|';
     const rows = tasks.map((task) => {
         const id = String(task.id);
         const status = task.status;
@@ -73,8 +80,9 @@ function buildTaskTable({ tasks, }) {
             }
             return formatTimeUntil(task.next_run_at);
         })();
-        const action = buildActionCell(task);
-        return `| ${id} | ${status} | ${prompt} | ${schedule} | ${nextRun} | ${action} |`;
+        const run = buildRunCell(task);
+        const cancel = buildCancelCell(task);
+        return `| ${id} | ${status} | ${prompt} | ${schedule} | ${nextRun} | ${run} | ${cancel} |`;
     });
     return [header, separator, ...rows].join('\n');
 }
@@ -107,12 +115,15 @@ async function renderTasksReply({ guildId, userId, channelId, showAll, notice, e
         ? `Showing ${MAX_TASK_ROWS}/${allTasks.length} tasks. Use \`kimaki task list\` for full list.`
         : undefined;
     const combinedNotice = [notice, truncatedNotice].filter(Boolean).join('\n');
+    const runnableTasksByButtonId = new Map();
     const cancellableTasksByButtonId = new Map();
     tasks.forEach((task) => {
-        if (!canCancelTask(task)) {
-            return;
+        if (canRunTask(task)) {
+            runnableTasksByButtonId.set(`run-task-${task.id}`, task);
+        }
+        if (canCancelTask(task)) {
+            cancellableTasksByButtonId.set(`cancel-task-${task.id}`, task);
         }
-        cancellableTasksByButtonId.set(`cancel-task-${task.id}`, task);
     });
     const tableMarkdown = buildTaskTable({ tasks });
     const markdown = combinedNotice
@@ -120,17 +131,32 @@ async function renderTasksReply({ guildId, userId, channelId, showAll, notice, e
         : tableMarkdown;
     const segments = splitTablesFromMarkdown(markdown, {
         resolveButtonCustomId: ({ button }) => {
-            const task = cancellableTasksByButtonId.get(button.id);
-            if (!task) {
+            const runTask = runnableTasksByButtonId.get(button.id);
+            if (runTask) {
+                const actionId = registerHtmlAction({
+                    ownerKey,
+                    threadId: String(runTask.id),
+                    run: async ({ interaction }) => {
+                        await handleRunTaskAction({
+                            interaction,
+                            taskId: runTask.id,
+                            showAll,
+                        });
+                    },
+                });
+                return buildHtmlActionCustomId(actionId);
+            }
+            const cancelTask = cancellableTasksByButtonId.get(button.id);
+            if (!cancelTask) {
                 return new Error(`No task registered for button ${button.id}`);
             }
             const actionId = registerHtmlAction({
                 ownerKey,
-                threadId: String(task.id),
+                threadId: String(cancelTask.id),
                 run: async ({ interaction }) => {
                     await handleCancelTaskAction({
                         interaction,
-                        taskId: task.id,
+                        taskId: cancelTask.id,
                         showAll,
                     });
                 },
@@ -153,6 +179,58 @@ async function renderTasksReply({ guildId, userId, channelId, showAll, notice, e
         flags: MessageFlags.IsComponentsV2,
     });
 }
+async function handleRunTaskAction({ interaction, taskId, showAll, }) {
+    const guildId = interaction.guildId;
+    if (!guildId) {
+        await interaction.editReply({
+            components: [
+                {
+                    type: ComponentType.TextDisplay,
+                    content: 'This action can only be used in a server.',
+                },
+            ],
+            flags: MessageFlags.IsComponentsV2,
+        });
+        return;
+    }
+    const token = interaction.client.token;
+    if (!token) {
+        await renderTasksReply({
+            guildId,
+            userId: interaction.user.id,
+            channelId: interaction.channelId,
+            showAll,
+            notice: `Could not run task #${taskId}: bot token unavailable.`,
+            editReply: (options) => {
+                return interaction.editReply(options);
+            },
+        });
+        return;
+    }
+    const result = await runScheduledTaskNow({ token, taskId });
+    const notice = (() => {
+        if (result instanceof Error) {
+            return `Could not run task #${taskId}: ${result.message}`;
+        }
+        if (result.kind === 'skipped') {
+            return `Task #${taskId} is already running or was claimed elsewhere.`;
+        }
+        if (result.kind === 'failed') {
+            return `Task #${taskId} failed: ${result.error.message}`;
+        }
+        return `Started task #${taskId}.`;
+    })();
+    await renderTasksReply({
+        guildId,
+        userId: interaction.user.id,
+        channelId: interaction.channelId,
+        showAll,
+        notice,
+        editReply: (options) => {
+            return interaction.editReply(options);
+        },
+    });
+}
 async function handleCancelTaskAction({ interaction, taskId, showAll, }) {
     const guildId = interaction.guildId;
     if (!guildId) {

package/dist/commands/user-command.js

@@ -1,11 +1,14 @@
 // User-defined OpenCode command handler.
 // Handles slash commands that map to user-configured commands in opencode.json.
-import { ChannelType, MessageFlags, } from 'discord.js';
+import { ChannelType, MessageFlags, ThreadAutoArchiveDuration, } from 'discord.js';
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
-import { getChannelDirectory, getThreadSession } from '../database.js';
+import { getChannelDirectory, getChannelWorktreesEnabled, getThreadSession, } from '../database.js';
 import { store } from '../store.js';
+import { isGitRepositoryRoot } from '../worktrees.js';
+import { formatAutoWorktreeName, createWorktreeInBackground, worktreeCreatingMessage, } from './new-worktree.js';
+import { WORKTREE_PREFIX } from './merge-worktree.js';
 import fs from 'node:fs';
 const userCommandLogger = createLogger(LogPrefix.USER_CMD);
 const DISCORD_MESSAGE_LIMIT = 2000;
@@ -107,23 +110,62 @@ export const handleUserCommand = async ({ command, appId, }) => {
         }
         else if (textChannel) {
             // Running in text channel - create a new thread
+            // Check if worktrees should be enabled (CLI flag OR channel setting),
+            // mirroring the logic in discord-bot.ts message handler.
+            const wantsWorktrees = store.getState().useWorktrees ||
+                (await getChannelWorktreesEnabled(textChannel.id));
+            const shouldUseWorktrees = wantsWorktrees && (await isGitRepositoryRoot(projectDirectory));
+            if (wantsWorktrees && !shouldUseWorktrees) {
+                userCommandLogger.warn(`[WORKTREE] Skipping automatic worktree for non-git project directory: ${projectDirectory}`);
+            }
+            const baseThreadName = commandInvocation.slice(0, DISCORD_THREAD_NAME_LIMIT);
+            const threadName = shouldUseWorktrees
+                ? `${WORKTREE_PREFIX}${baseThreadName}`
+                : baseThreadName;
             const starterMessage = await textChannel.send({
                 content: threadOpeningMessage,
                 flags: SILENT_MESSAGE_FLAGS,
             });
             const newThread = await starterMessage.startThread({
-                name: commandInvocation.slice(0, DISCORD_THREAD_NAME_LIMIT),
-                autoArchiveDuration: 1440,
+                name: threadName.slice(0, DISCORD_THREAD_NAME_LIMIT),
+                autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
                 reason: `OpenCode command: ${commandName}`,
             });
             // Add user to thread so it appears in their sidebar
             await newThread.members.add(command.user.id);
+            // Create worktree in background if enabled, same as discord-bot.ts
+            let worktreePromise;
+            if (shouldUseWorktrees) {
+                const worktreeName = formatAutoWorktreeName(baseThreadName.slice(0, 50));
+                userCommandLogger.log(`[WORKTREE] Creating worktree: ${worktreeName}`);
+                const worktreeStatusMessage = await newThread
+                    .send({
+                    content: worktreeCreatingMessage(worktreeName),
+                    flags: SILENT_MESSAGE_FLAGS,
+                })
+                    .catch(() => undefined);
+                worktreePromise = createWorktreeInBackground({
+                    thread: newThread,
+                    starterMessage: worktreeStatusMessage,
+                    worktreeName,
+                    projectDirectory,
+                    rest: command.client.rest,
+                });
+            }
+            const sessionDirectory = await (async () => {
+                if (!worktreePromise)
+                    return projectDirectory;
+                const result = await worktreePromise;
+                if (result instanceof Error)
+                    return projectDirectory;
+                return result;
+            })();
             await command.editReply(`Started /${commandName} in ${newThread.toString()}`);
             const runtime = getOrCreateRuntime({
                 threadId: newThread.id,
                 thread: newThread,
                 projectDirectory,
-                sdkDirectory: projectDirectory,
+                sdkDirectory: sessionDirectory,
                 channelId: textChannel.id,
                 appId,
             });

package/dist/database.js

@@ -380,6 +380,20 @@ export async function upsertThreadSession({ threadId, sessionId, source }) {
         .values({ thread_id: threadId, session_id: sessionId, source })
         .onConflictDoUpdate({ target: schema.thread_sessions.thread_id, set: { session_id: sessionId, source } });
 }
+export async function getThreadParentSessionId(threadId) {
+    const db = await getDb();
+    return (await db.query.thread_sessions.findFirst({
+        where: { thread_id: threadId },
+        columns: { parent_session_id: true },
+    }))?.parent_session_id ?? undefined;
+}
+export async function setThreadParentSessionId({ threadId, parentSessionId, }) {
+    const db = await getDb();
+    await db
+        .update(schema.thread_sessions)
+        .set({ parent_session_id: parentSessionId })
+        .where(orm.eq(schema.thread_sessions.thread_id, threadId));
+}
 export async function getThreadSessionSource(threadId) {
     const db = await getDb();
     return (await db.query.thread_sessions.findFirst({ where: { thread_id: threadId }, columns: { source: true } }))?.source;

package/dist/db.js

@@ -119,6 +119,7 @@ async function migrateSchema({ db, client, }) {
         'ALTER TABLE bot_tokens ADD COLUMN last_used_at DATETIME',
         "ALTER TABLE thread_sessions ADD COLUMN source TEXT DEFAULT 'kimaki'",
         'ALTER TABLE thread_sessions ADD COLUMN last_synced_name TEXT',
+        'ALTER TABLE thread_sessions ADD COLUMN parent_session_id TEXT',
     ];
     for (const stmt of alterStatements) {
         await client.execute(stmt).catch(() => undefined);