kimaki 0.20.1 → 0.22.0

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
@@ -97,6 +100,9 @@ export async function forkSessionToBtwThread({
     `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.`,
@@ -112,7 +118,7 @@ export async function forkSessionToBtwThread({
     threadId: thread.id,
     thread,
     projectDirectory,
-    sdkDirectory: projectDirectory,
+    sdkDirectory,
     channelId,
     appId,
   })
@@ -173,7 +179,7 @@ export async function handleBtwCommand({
     return
   }
 
-  const { projectDirectory } = resolved
+  const { projectDirectory, workingDirectory } = resolved
 
   await command.deferReply({ flags: MessageFlags.Ephemeral })
 
@@ -181,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

@@ -1,6 +1,6 @@
 // /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,
@@ -23,6 +23,7 @@ import {
   cancelHtmlActionsForOwner,
   registerHtmlAction,
 } from '../html-actions.js'
+import { runScheduledTaskNow } from '../task-runner.js'
 import { formatTimeAgo } from './worktrees.js'
 
 function formatTimeUntil(date: Date): string {
@@ -55,6 +56,10 @@ function scheduleLabel(task: ScheduledTask): string {
   return 'one-time'
 }
 
+function canRunTask(task: ScheduledTask): boolean {
+  return task.status === 'planned'
+}
+
 function canCancelTask(task: ScheduledTask): boolean {
   return task.status === 'planned' || task.status === 'running'
 }
@@ -65,32 +70,43 @@ function sanitizeTableCell(value: string): string {
   return value.replaceAll('|', '\\|').replace(/\s+/g, ' ').trim()
 }
 
-function buildCancelButtonHtml({ buttonId }: { buttonId: string }): string {
-  return `<button id="${buttonId}" variant="secondary">Delete</button>`
+function buildRunCell(task: ScheduledTask): string {
+  if (!canRunTask(task)) {
+    return '-'
+  }
+  return `<button id="run-task-${task.id}" variant="primary">Run now</button>`
 }
 
-function buildActionCell(task: ScheduledTask): string {
+function buildCancelCell(task: ScheduledTask): string {
   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 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 | Action |'
-  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) + '...'
@@ -107,8 +123,9 @@ function buildTaskTable({
       }
       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} | ${channel} | ${prompt} | ${schedule} | ${nextRun} | ${run} | ${cancel} |`
   })
   return [header, separator, ...rows].join('\n')
 }
@@ -171,12 +188,15 @@ async function renderTasksReply({
       : undefined
   const combinedNotice = [notice, truncatedNotice].filter(Boolean).join('\n')
 
+  const runnableTasksByButtonId = new Map<string, ScheduledTask>()
   const cancellableTasksByButtonId = new Map<string, ScheduledTask>()
   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 })
@@ -185,18 +205,34 @@ async function renderTasksReply({
     : 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,
           })
         },
@@ -224,6 +260,70 @@ async function renderTasksReply({
   })
 }
 
+async function handleRunTaskAction({
+  interaction,
+  taskId,
+  showAll,
+}: {
+  interaction: ButtonInteraction
+  taskId: number
+  showAll: boolean
+}): Promise<void> {
+  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,

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

package/src/database.ts

@@ -534,6 +534,30 @@ export async function upsertThreadSession({ threadId, sessionId, source }: { thr
     .onConflictDoUpdate({ target: schema.thread_sessions.thread_id, set: { session_id: sessionId, source } })
 }
 
+export async function getThreadParentSessionId(threadId: string) {
+  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,
+}: {
+  threadId: string
+  parentSessionId: string
+}) {
+  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: string) {
   const db = await getDb()
   return (await db.query.thread_sessions.findFirst({ where: { thread_id: threadId }, columns: { source: true } }))?.source

package/src/db.ts

@@ -158,6 +158,7 @@ async function migrateSchema({
     '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)

package/src/discord-bot.ts

@@ -52,6 +52,7 @@ import {
 } from './system-message.js'
 import YAML from 'yaml'
 import {
+  getFileAttachments,
   getTextAttachments,
   resolveMentions,
 } from './message-formatting.js'
@@ -484,6 +485,9 @@ export async function startDiscordBot({
       const cliInjectedInjectionGuardPatterns = isCliInjectedPrompt
         ? promptMarker?.injectionGuardPatterns
         : undefined
+      const cliInjectedParentSessionId = isCliInjectedPrompt
+        ? promptMarker?.parentSessionId
+        : undefined
 
       // Always ignore our own messages (unless CLI-injected prompt above).
       // Without this, assigning the Kimaki role to the bot itself would loop.
@@ -729,9 +733,15 @@ export async function startDiscordBot({
             ? extractBtwSuffix(message.content || '')
             : null
         if (btwResult?.forceBtw && projectDirectory && !isLeadingMentionToOtherUser) {
+          const btwSdkDir =
+            worktreeInfo?.status === 'ready' &&
+            worktreeInfo.workspace_directory
+              ? worktreeInfo.workspace_directory
+              : projectDirectory
           const result = await forkSessionToBtwThread({
             sourceThread: thread,
             projectDirectory,
+            sdkDirectory: btwSdkDir,
             prompt: btwResult.prompt,
             userId: message.author.id,
             username:
@@ -829,6 +839,7 @@ export async function startDiscordBot({
           model: cliInjectedModel,
           permissions: cliInjectedPermissions,
           injectionGuardPatterns: cliInjectedInjectionGuardPatterns,
+          parentSessionId: cliInjectedParentSessionId,
           noReply: isLeadingMentionToOtherUser || undefined,
           sessionStartSource: sessionStartSource
             ? {
@@ -851,7 +862,10 @@ export async function startDiscordBot({
 
         // Notify when a voice message was queued instead of sent immediately
         if (enqueueResult.queued && enqueueResult.position) {
-          await sendThreadMessage(thread, `Queued at position ${enqueueResult.position}. Edit your message to update it in queue`)
+          await sendThreadMessage(
+            thread,
+            `Queued at position ${enqueueResult.position}. Edit or delete your message to update the queue`,
+          )
         }
       }
 
@@ -1076,6 +1090,10 @@ export async function startDiscordBot({
       if (!message) return
       if (message.author.bot) return
       if (!message.content) return
+      // Discord fires MESSAGE_UPDATE for embed-only updates (link preview
+      // unfurling) without the user actually editing the message content.
+      // editedTimestamp is null for these; skip them to avoid false queue removals.
+      if (!message.editedTimestamp) return
 
       const channel = message.channel
       const isThread = [
@@ -1131,6 +1149,35 @@ export async function startDiscordBot({
     }
   })
 
+  // Handle user message deletes to remove queued messages.
+  // Discord delete events do not include author/content, so attribution comes
+  // from the queued item captured at enqueue time.
+  discordClient.on(Events.MessageDelete, async (message) => {
+    try {
+      const channel = message.channel
+      if (!channel.isThread()) return
+
+      const runtime = getRuntime(channel.id)
+      if (!runtime) return
+
+      const removed = runtime.removeQueuedMessage(message.id)
+      if (!removed) return
+
+      discordLogger.log(
+        `[MESSAGE_DELETE] Removed queued message ${message.id} in thread ${channel.id}`,
+      )
+      await sendThreadMessage(
+        channel,
+        `⬦ **${removed.username}** removed message from queue`,
+      )
+    } catch (error) {
+      discordLogger.error(
+        'Error handling message delete:',
+        error instanceof Error ? error.stack : String(error),
+      )
+    }
+  })
+
   // Handle bot-initiated threads created by `kimaki send` (without --notify-only)
   // Uses JSON embed marker to pass options (start, worktree name)
   discordClient.on(Events.ThreadCreate, async (thread, newlyCreated) => {
@@ -1188,7 +1235,10 @@ export async function startDiscordBot({
         `[BOT_SESSION] Detected bot-initiated thread: ${thread.name}`,
       )
 
-      const textAttachmentsContent = await getTextAttachments(starterMessage)
+      const [textAttachmentsContent, fileAttachments] = await Promise.all([
+        getTextAttachments(starterMessage),
+        getFileAttachments(starterMessage),
+      ])
       const messageText = resolveMentions(starterMessage).trim()
       const prompt = textAttachmentsContent
         ? `${messageText}\n\n${textAttachmentsContent}`
@@ -1221,16 +1271,28 @@ export async function startDiscordBot({
         return
       }
 
-      // Start worktree creation concurrently if requested.
+      // Start worktree creation concurrently if requested via marker OR
+      // if the channel/global toggle enables auto-worktrees.
       // The runtime is created immediately so follow-up messages queue
       // naturally; the worktree promise is awaited inside enqueueIncoming.
+      const autoWorktreeEnabled =
+        !marker.worktree &&
+        !marker.cwd &&
+        (store.getState().useWorktrees ||
+          (await getChannelWorktreesEnabled(parent.id)))
+      const effectiveWorktreeName =
+        marker.worktree ||
+        (autoWorktreeEnabled
+          ? formatAutoWorktreeName(thread.name.slice(0, 50))
+          : undefined)
+
       let worktreePromise: Promise<string | Error> | undefined
-      if (marker.worktree && (await isGitRepositoryRoot(projectDirectory))) {
-        discordLogger.log(`[BOT_SESSION] Creating worktree: ${marker.worktree}`)
+      if (effectiveWorktreeName && (await isGitRepositoryRoot(projectDirectory))) {
+        discordLogger.log(`[BOT_SESSION] Creating worktree: ${effectiveWorktreeName}`)
 
         const worktreeStatusMessage = await thread
           .send({
-            content: worktreeCreatingMessage(marker.worktree),
+            content: worktreeCreatingMessage(effectiveWorktreeName),
             flags: SILENT_MESSAGE_FLAGS,
           })
           .catch(() => undefined)
@@ -1238,7 +1300,7 @@ export async function startDiscordBot({
         worktreePromise = createWorktreeInBackground({
           thread,
           starterMessage: worktreeStatusMessage,
-          worktreeName: marker.worktree,
+          worktreeName: effectiveWorktreeName,
           projectDirectory,
           rest: discordClient.rest,
         })
@@ -1246,6 +1308,10 @@ export async function startDiscordBot({
         discordLogger.warn(
           `[BOT_SESSION] Skipping requested worktree for non-git project directory: ${projectDirectory}`,
         )
+      } else if (autoWorktreeEnabled) {
+        discordLogger.warn(
+          `[BOT_SESSION] Skipping auto-worktree for non-git project directory: ${projectDirectory}`,
+        )
       }
 
       // --cwd: reuse an existing project subfolder or worktree directory. Revalidate at bot-time
@@ -1335,6 +1401,7 @@ export async function startDiscordBot({
         model: marker.model,
         permissions: marker.permissions,
         injectionGuardPatterns: marker.injectionGuardPatterns,
+        parentSessionId: marker.parentSessionId,
         mode: 'opencode',
         sessionStartSource: botThreadStartSource
           ? {
@@ -1346,7 +1413,12 @@ export async function startDiscordBot({
           const permissionRules = await getChannelReferencePermissionRules({
             message: starterMessage,
           })
-          return { prompt, permissionRules, mode: 'opencode' }
+          return {
+            prompt,
+            permissionRules,
+            mode: 'opencode',
+            ...(fileAttachments.length > 0 && { images: fileAttachments }),
+          }
         },
       })
     } catch (error) {