kimaki 0.21.0 → 0.22.0

package/src/cli-commands/project.ts

@@ -163,8 +163,10 @@ cli
     '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: { json?: boolean; prune?: boolean }) => {
+  .action(async (options) => {
     await initDatabase()
 
     const db = await getDb()
@@ -173,15 +175,12 @@ cli
       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 = ''
@@ -204,14 +203,19 @@ cli
             deleted = isUnknownChannel
           }
         }
-        return { ...ch, channelName, guildId, deleted }
+        return { ...ch, channelName, guildId, deleted, isLocal: true as boolean }
       }),
     )
 
     // Fetch guild names for unique guild IDs (deduplicated to save API calls)
     const guildNameMap = new Map<string, string>()
+    // 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 {
@@ -227,8 +231,76 @@ 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: typeof enriched = []
+    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))) as Array<{
+            id: string
+            name: string
+            type: number
+            parent_id: string | null
+          }>
+
+          // 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' as const,
+                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) || '') : '',
     }))
@@ -236,7 +308,7 @@ cli
     // Warn on stderr if the same directory appears in multiple channels (multi-guild duplicates)
     const directoryCounts = new Map<string, number>()
     for (const ch of enrichedWithGuild) {
-      if (!ch.deleted) {
+      if (!ch.deleted && ch.directory) {
         directoryCounts.set(ch.directory, (directoryCounts.get(ch.directory) || 0) + 1)
       }
     }
@@ -251,7 +323,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')
       } else {
@@ -268,29 +340,40 @@ cli
       }
     }
 
+    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/src/cli-commands/send.ts

@@ -16,7 +16,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'
@@ -26,7 +26,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, type ScheduledTaskPayload } from '../task-schedule.js'
 import {
@@ -95,6 +95,13 @@ cli
       '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)',
@@ -153,11 +160,19 @@ cli
           process.exit(EXIT_NO_RESTART)
         }
 
+        const filePaths = options.file?.length
+          ? options.file.map((f: string) => 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',
@@ -166,6 +181,31 @@ cli
           }
         }
 
+        // 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
@@ -483,6 +523,7 @@ cli
             botToken,
             embeds: promptEmbed,
             rest,
+            files: filePaths,
           })
 
           const threadUrl = `https://discord.com/channels/${threadData.guild_id}/${threadData.id}`
@@ -578,14 +619,23 @@ 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
-          ? `${WORKTREE_PREFIX}${baseThreadName}`
-          : baseThreadName
+        const threadName =
+          worktreeName || channelWorktreesEnabled
+            ? `${WORKTREE_PREFIX}${baseThreadName}`
+            : baseThreadName
 
         if (parsedSchedule) {
           const payload: ScheduledTaskPayload = {
@@ -654,6 +704,7 @@ cli
           embeds: autoStartEmbed,
           rest,
           splitInsteadOfAttach: notifyOnly,
+          files: filePaths,
         })
 
         // For notify-only on non-project channels, just post the message without

package/src/cli-runner.ts

@@ -214,6 +214,7 @@ export async function sendDiscordMessageWithOptionalAttachment({
   embeds,
   rest,
   splitInsteadOfAttach,
+  files,
 }: {
   channelId: string
   prompt: string
@@ -224,8 +225,88 @@ export async function sendDiscordMessageWithOptionalAttachment({
    *  being attached as a file. Useful for notify-only messages where the content
    *  should be directly visible in the channel. */
   splitInsteadOfAttach?: boolean
+  /** Local file paths to attach to the message (images, text files, etc.). */
+  files?: string[]
 }): Promise<{ id: string }> {
   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: Array<{ filePath: string; filename: string; mimeType: string }> = 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()) as { id: string }
+  }
+
   if (prompt.length <= discordMaxLength) {
     return (await rest.post(Routes.channelMessages(channelId), {
       body: {

package/src/commands/btw.ts

@@ -26,6 +26,7 @@ const logger = createLogger(LogPrefix.FORK)
 export async function forkSessionToBtwThread({
   sourceThread,
   projectDirectory,
+  sdkDirectory,
   prompt,
   userId,
   username,
@@ -33,6 +34,8 @@ export async function forkSessionToBtwThread({
 }: {
   sourceThread: ThreadChannel
   projectDirectory: string
+  /** Worktree directory when forking from a worktree thread, otherwise same as projectDirectory */
+  sdkDirectory: string
   prompt: string
   userId: string
   username: string
@@ -115,7 +118,7 @@ export async function forkSessionToBtwThread({
     threadId: thread.id,
     thread,
     projectDirectory,
-    sdkDirectory: projectDirectory,
+    sdkDirectory,
     channelId,
     appId,
   })
@@ -176,7 +179,7 @@ export async function handleBtwCommand({
     return
   }
 
-  const { projectDirectory } = resolved
+  const { projectDirectory, workingDirectory } = resolved
 
   await command.deferReply({ flags: MessageFlags.Ephemeral })
 
@@ -184,6 +187,7 @@ export async function handleBtwCommand({
     const result = await forkSessionToBtwThread({
       sourceThread: threadChannel,
       projectDirectory,
+      sdkDirectory: workingDirectory,
       prompt,
       userId: command.user.id,
       username: command.user.displayName,

package/src/commands/new-worktree.ts

@@ -32,6 +32,7 @@ import { notifyError } from '../sentry.js'
 import {
   execAsync,
   listBranchesByLastCommit,
+  resolveBestBaseRef,
   validateBranchRef,
 } from '../worktrees.js'
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js'
@@ -60,10 +61,22 @@ async function resolveRequestedWorktreeBaseRef({
     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. */

package/src/commands/session.ts

@@ -1,12 +1,25 @@
 // /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, type TextChannel } from 'discord.js'
+import { ChannelType, type TextChannel, type ThreadChannel } from 'discord.js'
 import fs from 'node:fs'
 import path from 'node:path'
 import type { CommandContext, AutocompleteContext } from './types.js'
-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'
@@ -24,19 +37,52 @@ export async function handleSessionCommand({
   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: string
+  let sdkDirectory: string
+  let textChannel: TextChannel
+  let sourceWorkspace: Awaited<ReturnType<typeof getThreadWorktreeOrWorkspace>> | undefined
+
+  if (isThread) {
+    const threadChannel = channel as ThreadChannel
+    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 as TextChannel
   }
 
   if (!fs.existsSync(projectDirectory)) {
@@ -61,8 +107,8 @@ export async function handleSessionCommand({
       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,
     })
 
@@ -72,6 +118,22 @@ export async function handleSessionCommand({
       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)
 
@@ -81,8 +143,8 @@ export async function handleSessionCommand({
       threadId: thread.id,
       thread,
       projectDirectory,
-      sdkDirectory: projectDirectory,
-      channelId: channel.id,
+      sdkDirectory,
+      channelId: textChannel.id,
       appId,
     })
     await runtime.enqueueIncoming({

package/src/commands/tasks.ts

@@ -89,16 +89,24 @@ function buildCancelCell(task: ScheduledTask): string {
 // so 7 rows stays under the budget with separators.
 const MAX_TASK_ROWS = 7
 
+function formatChannelCell(task: ScheduledTask): string {
+  if (!task.channel_id) {
+    return '-'
+  }
+  return `<#${task.channel_id}>`
+}
+
 function buildTaskTable({
   tasks,
 }: {
   tasks: ScheduledTask[]
 }): string {
-  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) + '...'
@@ -117,7 +125,7 @@ function buildTaskTable({
     })()
     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/src/commands/user-command.ts

@@ -10,7 +10,7 @@ import {
   type ThreadChannel,
 } 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,
@@ -138,11 +138,12 @@ export const handleUserCommand: CommandHandler = async ({
       // 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,
       })