kimaki 0.21.0 → 0.22.0

package/dist/cli-commands/project.js

@@ -98,6 +98,8 @@ cli
 cli
     .command('project list', 'List all registered projects with their Discord channels')
     .option('--json', 'Output as JSON')
+    .option('--all', 'Include remote projects from other machines (scans Kimaki category in Discord)')
+    .option('-g, --guild <guildId>', 'Discord guild/server ID to scan (used with --all when no local projects exist)')
     .option('--prune', 'Remove stale entries whose Discord channel no longer exists')
     .action(async (options) => {
     await initDatabase();
@@ -106,13 +108,10 @@ cli
         where: { channel_type: 'text' },
         orderBy: { created_at: 'desc' },
     });
-    if (channels.length === 0) {
-        cliLogger.log('No projects registered');
-        process.exit(0);
-    }
     // Fetch Discord channel names and guild IDs via REST API
     const botRow = await getBotTokenWithMode();
     const rest = botRow ? createDiscordRest(botRow.token) : null;
+    const localChannelIds = new Set(channels.map((ch) => ch.channel_id));
     const enriched = await Promise.all(channels.map(async (ch) => {
         let channelName = '';
         let guildId = '';
@@ -132,12 +131,17 @@ cli
                 deleted = isUnknownChannel;
             }
         }
-        return { ...ch, channelName, guildId, deleted };
+        return { ...ch, channelName, guildId, deleted, isLocal: true };
     }));
     // Fetch guild names for unique guild IDs (deduplicated to save API calls)
     const guildNameMap = new Map();
+    // Collect guild IDs from local channels + explicit --guild flag
+    const guildIdsFromChannels = enriched.map((ch) => ch.guildId).filter(Boolean);
+    if (options.guild) {
+        guildIdsFromChannels.push(options.guild);
+    }
+    const uniqueGuildIds = [...new Set(guildIdsFromChannels)];
     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)));
@@ -148,15 +152,67 @@ cli
             }
         }));
     }
+    // When --all is passed, scan each guild's channels to find Kimaki category
+    // text channels not in our local DB (projects from other machines).
+    // Fail explicitly when prerequisites are missing so the user doesn't
+    // confuse "scan never ran" with "no remote projects found".
+    let remoteEntries = [];
+    if (options.all) {
+        if (!rest) {
+            cliLogger.error('Discord credentials are required to scan remote projects. Run `kimaki` first.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (uniqueGuildIds.length === 0) {
+            cliLogger.error('Cannot determine which Discord server to scan. Pass `--guild <guildId>` or register a local project first.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        let guildScanFailures = 0;
+        for (const guildId of uniqueGuildIds) {
+            try {
+                const guildChannels = (await rest.get(Routes.guildChannels(guildId)));
+                // Find Kimaki category channels (type 4 = GuildCategory)
+                const kimakiCategoryIds = new Set(guildChannels
+                    .filter((ch) => ch.type === 4 && /^kimaki(\s|$)/i.test(ch.name))
+                    .map((ch) => ch.id));
+                // Find text channels (type 0) in Kimaki categories that are not in our local DB
+                for (const ch of guildChannels) {
+                    if (ch.type === 0 &&
+                        ch.parent_id &&
+                        kimakiCategoryIds.has(ch.parent_id) &&
+                        !localChannelIds.has(ch.id)) {
+                        remoteEntries.push({
+                            channel_id: ch.id,
+                            directory: '',
+                            channel_type: 'text',
+                            created_at: null,
+                            channelName: ch.name,
+                            guildId,
+                            deleted: false,
+                            isLocal: false,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                guildScanFailures++;
+                cliLogger.warn(`Failed to scan guild ${guildNameMap.get(guildId) || guildId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (guildScanFailures === uniqueGuildIds.length) {
+            cliLogger.error('Failed to scan all guilds. Check bot permissions or try again.');
+            process.exit(EXIT_NO_RESTART);
+        }
+    }
     // Build final enriched entries with guild names resolved
-    const enrichedWithGuild = enriched.map((ch) => ({
+    const allEntries = [...enriched, ...remoteEntries];
+    const enrichedWithGuild = allEntries.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) {
+        if (!ch.deleted && ch.directory) {
             directoryCounts.set(ch.directory, (directoryCounts.get(ch.directory) || 0) + 1);
         }
     }
@@ -168,7 +224,7 @@ cli
     // Prune stale entries if requested
     let finalEntries = enrichedWithGuild;
     if (options.prune) {
-        const stale = finalEntries.filter((ch) => ch.deleted);
+        const stale = finalEntries.filter((ch) => ch.deleted && ch.isLocal);
         if (stale.length === 0) {
             cliLogger.log('No stale channels to prune');
         }
@@ -185,28 +241,39 @@ cli
             process.exit(0);
         }
     }
+    if (finalEntries.length === 0) {
+        cliLogger.log('No projects registered');
+        process.exit(0);
+    }
     if (options.json) {
         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),
+            directory: ch.directory || null,
+            folder_name: ch.directory ? path.basename(ch.directory) : null,
             deleted: ch.deleted,
+            is_local: ch.isLocal,
         }));
         console.log(JSON.stringify(output, null, 2));
         process.exit(0);
     }
     for (const ch of finalEntries) {
-        const folderName = path.basename(ch.directory);
         const deletedTag = ch.deleted ? ' (deleted from Discord)' : '';
+        const remoteTag = !ch.isLocal ? ' [remote]' : '';
         const channelLabel = ch.channelName ? `#${ch.channelName}` : ch.channel_id;
         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(`\n${channelLabel}${guildSuffix}${deletedTag}${remoteTag}`);
+        if (ch.isLocal && ch.directory) {
+            const folderName = path.basename(ch.directory);
+            console.log(`   Folder: ${folderName}`);
+            console.log(`   Directory: ${ch.directory}`);
+        }
+        else if (!ch.isLocal) {
+            console.log(`   (Not registered on this machine)`);
+        }
         console.log(`   Channel ID: ${ch.channel_id}`);
         if (ch.guildId) {
             console.log(`   Guild ID: ${ch.guildId}`);

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/new-worktree.js

@@ -8,7 +8,7 @@ import { createPendingWorkspace, setWorkspaceReady, setWorkspaceError, getChanne
 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) {

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,
             });