kimaki 0.21.0 → 0.23.0

package/dist/cli-commands/send.js

@@ -15,7 +15,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 } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, getChannelWorktreesEnabled } 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';
@@ -24,7 +24,7 @@ import { buildOpencodeEventLogLine } from '../session-handler/opencode-session-e
 import { createDiscordRest } from '../discord-urls.js';
 import { archiveThread, uploadFilesToDiscord, stripMentions } from '../discord-utils.js';
 import { setDataDir, setProjectsDir, getDataDir, getProjectsDir } from '../config.js';
-import { execAsync, resolveSessionWorkingDirectory } from '../worktrees.js';
+import { execAsync, resolveSessionWorkingDirectory, isGitRepositoryRoot } from '../worktrees.js';
 import { upgrade, getCurrentVersion } from '../upgrade.js';
 import { getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload } from '../task-schedule.js';
 import { EXIT_NO_RESTART, formatMemberLookupUnavailableMessage, formatRelativeTime, formatTaskScheduleLine, isDiscordMemberLookupUnavailable, isGuildMemberSearchResult, isThreadChannelType, printDiscordInstallUrlAndExit, resolveBotCredentials, resolveDiscordUserOption, sendDiscordMessageWithOptionalAttachment, } from '../cli-runner.js';
@@ -48,6 +48,8 @@ cli
     'Actions: allow, deny, ask. Examples: --permission "bash:deny" --permission "edit:deny"'))
     .option('--injection-guard <pattern>', z.array(z.string()).describe('Injection guard scan pattern (repeatable). Enables prompt injection detection for this session. ' +
     'Format: "tool:argsGlob". Examples: --injection-guard "bash:*" --injection-guard "webfetch:*"'))
+    .option('-f, --file <path>', z.array(z.string()).describe('Local file to attach (repeatable). Images, text files, PDFs, etc. ' +
+    'Examples: --file screenshot.png --file report.pdf'))
     .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')
@@ -80,16 +82,45 @@ cli
             cliLogger.error('Prompt is required. Use --prompt <prompt>');
             process.exit(EXIT_NO_RESTART);
         }
+        const filePaths = options.file?.length
+            ? options.file.map((f) => path.resolve(f))
+            : undefined;
         if (sendAt) {
             if (options.wait) {
                 cliLogger.error('Cannot use --wait with --send-at');
                 process.exit(EXIT_NO_RESTART);
             }
+            if (filePaths?.length) {
+                cliLogger.error('Cannot use --file with --send-at');
+                process.exit(EXIT_NO_RESTART);
+            }
             if (prompt.length > 1900) {
                 cliLogger.error('--send-at currently supports prompts up to 1900 characters');
                 process.exit(EXIT_NO_RESTART);
             }
         }
+        // Validate all --file paths exist and are regular files
+        if (filePaths?.length) {
+            // Discord allows max 10 attachments per message. Long prompts also
+            // consume one slot (prompt.md), so reserve space for that.
+            const maxUserFiles = prompt.length > 2000 ? 9 : 10;
+            if (filePaths.length > maxUserFiles) {
+                cliLogger.error(`Too many files: ${filePaths.length} provided, Discord allows at most ${maxUserFiles} attachments per message` +
+                    (maxUserFiles === 9 ? ' (1 slot reserved for long prompt)' : ''));
+                process.exit(EXIT_NO_RESTART);
+            }
+            for (const file of filePaths) {
+                if (!fs.existsSync(file)) {
+                    cliLogger.error(`File not found: ${file}`);
+                    process.exit(EXIT_NO_RESTART);
+                }
+                const stat = fs.statSync(file);
+                if (!stat.isFile()) {
+                    cliLogger.error(`Not a regular file: ${file}`);
+                    process.exit(EXIT_NO_RESTART);
+                }
+            }
+        }
         const parsedSchedule = (() => {
             if (!sendAt) {
                 return null;
@@ -345,6 +376,7 @@ cli
                 botToken,
                 embeds: promptEmbed,
                 rest,
+                files: filePaths,
             });
             const threadUrl = `https://discord.com/channels/${threadData.guild_id}/${threadData.id}`;
             const existingSessionId = sessionId || await getThreadSession(targetThreadId);
@@ -418,12 +450,19 @@ cli
                 : cleanPrompt);
         // Explicit string => use as-is via formatWorktreeName (no vowel strip).
         // Boolean true => derived from thread/prompt, compress via formatAutoWorktreeName.
+        // When no --worktree flag but channel has worktrees enabled via toggle,
+        // the bot-side ThreadCreate handler auto-creates the worktree. We add
+        // the prefix here for cosmetic consistency (thread name shows 🌳).
+        const channelWorktreesEnabled = !options.worktree && !options.cwd && !notifyOnly && projectDirectory
+            ? (await getChannelWorktreesEnabled(channelId)) &&
+                (await isGitRepositoryRoot(projectDirectory))
+            : false;
         const worktreeName = options.worktree
             ? typeof options.worktree === 'string'
                 ? formatWorktreeName(options.worktree)
                 : formatAutoWorktreeName(baseThreadName)
             : undefined;
-        const threadName = worktreeName
+        const threadName = worktreeName || channelWorktreesEnabled
             ? `${WORKTREE_PREFIX}${baseThreadName}`
             : baseThreadName;
         if (parsedSchedule) {
@@ -487,6 +526,7 @@ cli
             embeds: autoStartEmbed,
             rest,
             splitInsteadOfAttach: notifyOnly,
+            files: filePaths,
         });
         // For notify-only on non-project channels, just post the message without
         // creating a thread. There's no session to start, so a thread is unnecessary.

package/dist/cli-runner.js

@@ -135,8 +135,64 @@ export function isThreadChannelType(type) {
         ChannelType.AnnouncementThread,
     ].includes(type);
 }
-export async function sendDiscordMessageWithOptionalAttachment({ channelId, prompt, botToken, embeds, rest, splitInsteadOfAttach, }) {
+export async function sendDiscordMessageWithOptionalAttachment({ channelId, prompt, botToken, embeds, rest, splitInsteadOfAttach, files, }) {
     const discordMaxLength = 2000;
+    // When files are provided, always use multipart FormData upload
+    if (files?.length) {
+        const { DISCORD_DEFAULT_MAX_FILE_SIZE } = await import('./discord-utils.js');
+        const { default: mime } = await import('mime');
+        for (const file of files) {
+            const stat = fs.statSync(file);
+            if (stat.size > DISCORD_DEFAULT_MAX_FILE_SIZE) {
+                const fileMB = (stat.size / 1024 / 1024).toFixed(1);
+                const limitMB = (DISCORD_DEFAULT_MAX_FILE_SIZE / 1024 / 1024).toFixed(0);
+                throw new Error(`File "${path.basename(file)}" is ${fileMB} MB, which exceeds Discord's ${limitMB} MB upload limit`);
+            }
+        }
+        // When prompt exceeds Discord's limit, attach it as prompt.md alongside
+        // user files so nothing is silently lost.
+        const isLongPrompt = prompt.length > discordMaxLength;
+        const content = isLongPrompt
+            ? `Prompt attached as file (${prompt.length} chars)\n\n> ${prompt.slice(0, 100).replace(/\n/g, ' ')}...`
+            : prompt;
+        // Build attachment metadata: user files + optional prompt.md
+        const allFiles = files.map((file) => ({
+            filePath: file,
+            filename: path.basename(file),
+            mimeType: mime.getType(file) || 'application/octet-stream',
+        }));
+        if (isLongPrompt) {
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-prompt-'));
+            const tmpFile = path.join(tmpDir, 'prompt.md');
+            fs.writeFileSync(tmpFile, prompt);
+            allFiles.push({ filePath: tmpFile, filename: 'prompt.md', mimeType: 'text/markdown' });
+        }
+        const attachments = allFiles.map((f, index) => ({
+            id: index,
+            filename: f.filename,
+        }));
+        const formData = new FormData();
+        formData.append('payload_json', JSON.stringify({
+            content,
+            attachments,
+            embeds,
+            allowed_mentions: { parse: store.getState().allowedMentions },
+        }));
+        for (const [index, f] of allFiles.entries()) {
+            const buffer = fs.readFileSync(f.filePath);
+            formData.append(`files[${index}]`, new Blob([buffer], { type: f.mimeType }), f.filename);
+        }
+        const response = await fetch(discordApiUrl(`/channels/${channelId}/messages`), {
+            method: 'POST',
+            headers: { Authorization: `Bot ${botToken}` },
+            body: formData,
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Discord API error: ${response.status} - ${error}`);
+        }
+        return (await response.json());
+    }
     if (prompt.length <= discordMaxLength) {
         return (await rest.post(Routes.channelMessages(channelId), {
             body: {

package/dist/commands/btw.js

@@ -10,7 +10,7 @@ import { createLogger, LogPrefix } from '../logger.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { copyCurrentSessionModel } from './model.js';
 const logger = createLogger(LogPrefix.FORK);
-export async function forkSessionToBtwThread({ sourceThread, projectDirectory, prompt, userId, username, appId, }) {
+export async function forkSessionToBtwThread({ sourceThread, projectDirectory, sdkDirectory, prompt, userId, username, appId, }) {
     // Parallelize: session lookup + opencode init + parent channel resolve are independent
     const [sessionId, getClientResult, textChannel] = await Promise.all([
         getThreadSession(sourceThread.id),
@@ -74,7 +74,7 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, p
         threadId: thread.id,
         thread,
         projectDirectory,
-        sdkDirectory: projectDirectory,
+        sdkDirectory,
         channelId,
         appId,
     });
@@ -120,12 +120,13 @@ export async function handleBtwCommand({ command, appId, }) {
         });
         return;
     }
-    const { projectDirectory } = resolved;
+    const { projectDirectory, workingDirectory } = resolved;
     await command.deferReply({ flags: MessageFlags.Ephemeral });
     try {
         const result = await forkSessionToBtwThread({
             sourceThread: threadChannel,
             projectDirectory,
+            sdkDirectory: workingDirectory,
             prompt,
             userId: command.user.id,
             username: command.user.displayName,

package/dist/commands/login.js

@@ -843,7 +843,7 @@ async function startOAuthFlow(interaction, ctx, hash) {
             // completing login in a browser (possibly on a different machine).
             const button = new ButtonBuilder()
                 .setCustomId(`login_oauth_code_btn:${hash}`)
-                .setLabel('Paste authorization code')
+                .setLabel('Paste authorization code or callback url')
                 .setStyle(ButtonStyle.Primary);
             await interaction.editReply({
                 content: message,

package/dist/commands/new-worktree.js

@@ -4,11 +4,11 @@
 import { ChannelType, REST, } from 'discord.js';
 import fs from 'node:fs';
 import { OpenCodeSdkError } from '../errors.js';
-import { createPendingWorkspace, setWorkspaceReady, setWorkspaceError, getChannelDirectory, getThreadSession, setThreadSession, } from '../database.js';
+import { createPendingWorkspace, setWorkspaceReady, setWorkspaceError, getChannelDirectory, getThreadSession, getThreadWorktreeOrWorkspace, setThreadSession, } from '../database.js';
 import { SILENT_MESSAGE_FLAGS, reactToThread, resolveProjectDirectoryFromAutocomplete, resolveTextChannel, sendThreadMessage, } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { notifyError } from '../sentry.js';
-import { execAsync, listBranchesByLastCommit, validateBranchRef, } from '../worktrees.js';
+import { execAsync, listBranchesByLastCommit, resolveBestBaseRef, validateBranchRef, } from '../worktrees.js';
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { buildSessionPermissions, initializeOpencodeForDirectory, } from '../opencode.js';
 import { WORKTREE_PREFIX } from './merge-worktree.js';
@@ -22,10 +22,22 @@ async function resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch
         // unpublished commits in the main checkout.
         return DEFAULT_WORKTREE_BASE_REF;
     }
-    return validateBranchRef({
+    const validated = await validateBranchRef({
         directory: projectDirectory,
         ref: rawBaseBranch,
     });
+    if (validated instanceof Error)
+        return validated;
+    // Fetch and prefer the remote tracking ref if it's strictly ahead of local.
+    // Handles the common case where user says "main" but upstream/main has new commits.
+    const bestRef = await resolveBestBaseRef({
+        directory: projectDirectory,
+        branch: validated,
+    });
+    if (bestRef !== validated) {
+        logger.log(`Base branch resolved: ${validated} → ${bestRef} (remote is ahead)`);
+    }
+    return bestRef;
 }
 /** Status message shown while a worktree is being created. */
 export function worktreeCreatingMessage(worktreeName) {
@@ -161,8 +173,8 @@ async function tryWorkspaceCreate({ threadId, worktreeName, projectDirectory, ba
         return new Error(`Workspace creation failed: ${JSON.stringify(response.error)}`);
     }
     const workspace = response.data;
-    if (!workspace?.directory) {
-        return new Error('Workspace SDK returned no directory');
+    if (!workspace?.directory || !workspace.id) {
+        return new Error('Workspace SDK returned no directory or ID');
     }
     return { directory: workspace.directory, workspaceId: workspace.id };
 }
@@ -439,6 +451,11 @@ async function handleWorktreeInThread({ command, thread, appId, }) {
             await sendThreadMessage(worktreeThread, 'Worktree is ready. Send a message here to start a fresh session in this checkout.');
             return;
         }
+        const workspace = await getThreadWorktreeOrWorkspace(worktreeThread.id);
+        if (!workspace?.workspace_id) {
+            await sendThreadMessage(worktreeThread, '✗ Worktree is ready, but OpenCode returned no workspace ID for context reuse.');
+            return;
+        }
         const getClient = await initializeOpencodeForDirectory(result, {
             originalRepoDirectory: projectDirectory,
             channelId: parent.id,
@@ -450,6 +467,7 @@ async function handleWorktreeInThread({ command, thread, appId, }) {
         const forkResponse = await getClient().session.fork({
             sessionID: sourceSessionId,
             directory: result,
+            workspace: workspace.workspace_id,
         }).catch((e) => new OpenCodeSdkError({ operation: 'session.fork', cause: e }));
         if (forkResponse instanceof Error) {
             logger.error('[NEW-WORKTREE] Failed to fork session into worktree:', forkResponse);

package/dist/commands/queue.js

@@ -117,9 +117,19 @@ export async function handleClearQueueCommand({ command, }) {
         logger.log(`[QUEUE] User ${command.user.displayName} cleared queued position ${position} in thread ${channel.id}`);
         return;
     }
-    runtime?.clearQueue();
+    const cleared = runtime?.clearQueue() ?? [];
+    const lines = cleared.map((item, i) => {
+        const label = item.command
+            ? `/${item.command.name}`
+            : item.prompt;
+        return `${i + 1}. ${label}`;
+    });
+    let list = lines.join('\n');
+    if (list.length > 600) {
+        list = list.slice(0, 597) + '...';
+    }
     await command.reply({
-        content: `Cleared ${queueLength} queued message${queueLength > 1 ? 's' : ''}`,
+        content: `Cleared ${cleared.length} queued message${cleared.length > 1 ? 's' : ''}:\n${list}`,
         flags: SILENT_MESSAGE_FLAGS,
     });
     logger.log(`[QUEUE] User ${command.user.displayName} cleared queue in thread ${channel.id}`);

package/dist/commands/session.js

@@ -1,10 +1,13 @@
 // /new-session command - Start a new OpenCode session.
+// Works in both text channels and threads. When used in a thread, the new
+// session inherits the same working directory (worktree/workspace) so the
+// user stays in the same folder context.
 import { ChannelType } from 'discord.js';
 import fs from 'node:fs';
 import path from 'node:path';
-import { getChannelDirectory } from '../database.js';
+import { getChannelDirectory, getThreadWorktreeOrWorkspace, createPendingWorkspace, setWorkspaceReady, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
-import { SILENT_MESSAGE_FLAGS, resolveProjectDirectoryFromAutocomplete } from '../discord-utils.js';
+import { SILENT_MESSAGE_FLAGS, resolveProjectDirectoryFromAutocomplete, resolveWorkingDirectory, resolveTextChannel, } from '../discord-utils.js';
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
@@ -15,15 +18,50 @@ export async function handleSessionCommand({ command, appId, }) {
     const filesString = command.options.getString('files') || '';
     const agent = command.options.getString('agent') || undefined;
     const channel = command.channel;
-    if (!channel || channel.type !== ChannelType.GuildText) {
-        await command.editReply('This command can only be used in text channels');
+    const isThread = channel && [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+    ].includes(channel.type);
+    if (!channel || (channel.type !== ChannelType.GuildText && !isThread)) {
+        await command.editReply('This command can only be used in text channels or threads');
         return;
     }
-    const channelConfig = await getChannelDirectory(channel.id);
-    const projectDirectory = channelConfig?.directory;
-    if (!projectDirectory) {
-        await command.editReply('This channel is not configured with a project directory');
-        return;
+    // Resolve project and working directories.
+    // In a thread: inherit from the thread's session (worktree/workspace aware).
+    // In a text channel: look up the channel's configured directory.
+    let projectDirectory;
+    let sdkDirectory;
+    let textChannel;
+    let sourceWorkspace;
+    if (isThread) {
+        const threadChannel = channel;
+        const [resolved, parentChannel, workspace] = await Promise.all([
+            resolveWorkingDirectory({ channel: threadChannel }),
+            resolveTextChannel(threadChannel),
+            getThreadWorktreeOrWorkspace(threadChannel.id),
+        ]);
+        if (!resolved) {
+            await command.editReply('Could not determine project directory for this thread');
+            return;
+        }
+        if (!parentChannel) {
+            await command.editReply('Could not resolve parent text channel');
+            return;
+        }
+        projectDirectory = resolved.projectDirectory;
+        sdkDirectory = resolved.workingDirectory;
+        textChannel = parentChannel;
+        sourceWorkspace = workspace;
+    }
+    else {
+        const channelConfig = await getChannelDirectory(channel.id);
+        if (!channelConfig?.directory) {
+            await command.editReply('This channel is not configured with a project directory');
+            return;
+        }
+        projectDirectory = channelConfig.directory;
+        sdkDirectory = channelConfig.directory;
+        textChannel = channel;
     }
     if (!fs.existsSync(projectDirectory)) {
         await command.editReply(`Directory does not exist: ${projectDirectory}`);
@@ -43,8 +81,8 @@ export async function handleSessionCommand({ command, appId, }) {
         if (files.length > 0) {
             fullPrompt = `${prompt}\n\n@${files.join(' @')}`;
         }
-        const starterMessage = await channel.send({
-            content: `🚀 **Starting OpenCode session**\n📝 ${prompt}${files.length > 0 ? `\n📎 Files: ${files.join(', ')}` : ''}`,
+        const starterMessage = await textChannel.send({
+            content: `**Starting OpenCode session**\n${prompt}${files.length > 0 ? `\nFiles: ${files.join(', ')}` : ''}`,
             flags: SILENT_MESSAGE_FLAGS,
         });
         const thread = await starterMessage.startThread({
@@ -52,6 +90,21 @@ export async function handleSessionCommand({ command, appId, }) {
             autoArchiveDuration: 1440,
             reason: 'OpenCode session',
         });
+        // Persist workspace association so commands in the new thread resolve the
+        // correct working directory, and the runtime survives bot restarts.
+        if (sourceWorkspace?.status === 'ready' && sourceWorkspace.workspace_directory) {
+            await createPendingWorkspace({
+                threadId: thread.id,
+                workspaceType: sourceWorkspace.workspace_type,
+                workspaceName: sourceWorkspace.workspace_name ?? '',
+                projectDirectory,
+            });
+            await setWorkspaceReady({
+                threadId: thread.id,
+                workspaceId: sourceWorkspace.workspace_id ?? undefined,
+                workspaceDirectory: sourceWorkspace.workspace_directory,
+            });
+        }
         // Add user to thread so it appears in their sidebar
         await thread.members.add(command.user.id);
         await command.editReply(`Created new session in ${thread.toString()}`);
@@ -59,8 +112,8 @@ export async function handleSessionCommand({ command, appId, }) {
             threadId: thread.id,
             thread,
             projectDirectory,
-            sdkDirectory: projectDirectory,
-            channelId: channel.id,
+            sdkDirectory,
+            channelId: textChannel.id,
             appId,
         });
         await runtime.enqueueIncoming({

package/dist/commands/tasks.js

@@ -62,12 +62,19 @@ function buildCancelCell(task) {
 // 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 formatChannelCell(task) {
+    if (!task.channel_id) {
+        return '-';
+    }
+    return `<#${task.channel_id}>`;
+}
 function buildTaskTable({ tasks, }) {
-    const header = '| ID | Status | Prompt | Schedule | Next Run | Run | Delete |';
-    const separator = '|---|---|---|---|---|---|---|';
+    const header = '| ID | Status | Channel | Prompt | Schedule | Next Run | Run | Delete |';
+    const separator = '|---|---|---|---|---|---|---|---|';
     const rows = tasks.map((task) => {
         const id = String(task.id);
         const status = task.status;
+        const channel = formatChannelCell(task);
         const prompt = sanitizeTableCell(task.prompt_preview.length > 240
             ? task.prompt_preview.slice(0, 237) + '...'
             : task.prompt_preview);
@@ -82,7 +89,7 @@ function buildTaskTable({ tasks, }) {
         })();
         const run = buildRunCell(task);
         const cancel = buildCancelCell(task);
-        return `| ${id} | ${status} | ${prompt} | ${schedule} | ${nextRun} | ${run} | ${cancel} |`;
+        return `| ${id} | ${status} | ${channel} | ${prompt} | ${schedule} | ${nextRun} | ${run} | ${cancel} |`;
     });
     return [header, separator, ...rows].join('\n');
 }

package/dist/commands/user-command.js

@@ -2,7 +2,7 @@
 // Handles slash commands that map to user-configured commands in opencode.json.
 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 { SILENT_MESSAGE_FLAGS, resolveWorkingDirectory } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { getChannelDirectory, getChannelWorktreesEnabled, getThreadSession, } from '../database.js';
 import { store } from '../store.js';
@@ -91,11 +91,12 @@ export const handleUserCommand = async ({ command, appId, }) => {
         if (isThread && thread) {
             // Running in existing thread - just send the command
             await command.editReply(`Running ${commandInvocation}...`);
+            const resolved = await resolveWorkingDirectory({ channel: thread });
             const runtime = getOrCreateRuntime({
                 threadId: thread.id,
                 thread,
                 projectDirectory,
-                sdkDirectory: projectDirectory,
+                sdkDirectory: resolved?.workingDirectory || projectDirectory,
                 channelId: textChannel?.id,
                 appId,
             });

package/dist/database.js

@@ -103,10 +103,9 @@ export async function recoverStaleRunningScheduledTasks({ staleBefore }) {
         .returning({ id: schema.scheduled_tasks.id });
     return countRows(rows);
 }
-export async function markScheduledTaskOneShotCompleted({ taskId, completedAt }) {
+export async function deleteScheduledTask(taskId) {
     const db = await getDb();
-    await db.update(schema.scheduled_tasks)
-        .set({ status: 'completed', last_run_at: completedAt, running_started_at: null, last_error: null })
+    await db.delete(schema.scheduled_tasks)
         .where(orm.eq(schema.scheduled_tasks.id, taskId));
 }
 export async function markScheduledTaskCronRescheduled({ taskId, completedAt, nextRunAt }) {
@@ -584,17 +583,17 @@ export async function getAnyAudioApiKey() {
         return { provider: 'gemini', apiKey: row.gemini_api_key, appId: row.app_id };
     return null;
 }
-export async function setChannelDirectory({ channelId, directory, channelType, skipIfExists = false }) {
+export async function setChannelDirectory({ channelId, directory, channelType, guildId, skipIfExists = false }) {
     const db = await getDb();
     if (skipIfExists) {
         await db.insert(schema.channel_directories)
-            .values({ channel_id: channelId, directory, channel_type: channelType })
+            .values({ channel_id: channelId, directory, channel_type: channelType, guild_id: guildId })
             .onConflictDoNothing({ target: schema.channel_directories.channel_id });
         return;
     }
     await db.insert(schema.channel_directories)
-        .values({ channel_id: channelId, directory, channel_type: channelType })
-        .onConflictDoUpdate({ target: schema.channel_directories.channel_id, set: { directory, channel_type: channelType } });
+        .values({ channel_id: channelId, directory, channel_type: channelType, guild_id: guildId })
+        .onConflictDoUpdate({ target: schema.channel_directories.channel_id, set: { directory, channel_type: channelType, guild_id: guildId } });
 }
 export async function findChannelsByDirectory({ directory, channelType }) {
     const db = await getDb();
@@ -605,7 +604,7 @@ export async function findChannelsByDirectory({ directory, channelType }) {
             : channelType
                 ? { channel_type: channelType }
                 : undefined;
-    return db.query.channel_directories.findMany({ where, columns: { channel_id: true, directory: true, channel_type: true } });
+    return db.query.channel_directories.findMany({ where, columns: { channel_id: true, directory: true, channel_type: true, guild_id: true } });
 }
 export async function getAllTextChannelDirectories() {
     const db = await getDb();

package/dist/db.js

@@ -120,6 +120,7 @@ async function migrateSchema({ db, client, }) {
         "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',
+        'ALTER TABLE channel_directories ADD COLUMN guild_id TEXT',
     ];
     for (const stmt of alterStatements) {
         await client.execute(stmt).catch(() => undefined);