@otto-assistant/bridge 0.4.102 → 0.4.103

package/src/commands/ask-question.ts

@@ -49,6 +49,48 @@ type PendingQuestionContext = {
 const QUESTION_CONTEXT_TTL_MS = 10 * 60 * 1000
 export const pendingQuestionContexts = new Map<string, PendingQuestionContext>()
 
+export function findPendingQuestionContextForRequest({
+  threadId,
+  requestId,
+}: {
+  threadId: string
+  requestId: string
+}): { contextHash: string; context: PendingQuestionContext } | null {
+  for (const [contextHash, context] of pendingQuestionContexts) {
+    if (context.thread.id !== threadId) {
+      continue
+    }
+    if (context.requestId !== requestId) {
+      continue
+    }
+    return { contextHash, context }
+  }
+  return null
+}
+
+export function deletePendingQuestionContextsForRequest({
+  threadId,
+  requestId,
+}: {
+  threadId: string
+  requestId: string
+}): number {
+  const matchingContextHashes = [...pendingQuestionContexts.entries()]
+    .filter(([, context]) => {
+      return context.thread.id === threadId && context.requestId === requestId
+    })
+    .map(([contextHash]) => {
+      return contextHash
+    })
+
+  matchingContextHashes.map((contextHash) => {
+    pendingQuestionContexts.delete(contextHash)
+    return contextHash
+  })
+
+  return matchingContextHashes.length
+}
+
 export function hasPendingQuestionForThread(threadId: string): boolean {
   return [...pendingQuestionContexts.values()].some((ctx) => {
     return ctx.thread.id === threadId
@@ -75,6 +117,17 @@ export async function showAskUserQuestionDropdowns({
   /** Suppress notification when queue has pending items */
   silent?: boolean
 }): Promise<void> {
+  const existingPending = findPendingQuestionContextForRequest({
+    threadId: thread.id,
+    requestId,
+  })
+  if (existingPending) {
+    logger.log(
+      `Deduped question ${requestId} for thread ${thread.id} (existing context ${existingPending.contextHash})`,
+    )
+    return
+  }
+
   const contextHash = crypto.randomBytes(8).toString('hex')
 
   const context: PendingQuestionContext = {
@@ -103,7 +156,10 @@ export async function showAskUserQuestionDropdowns({
     // Without this, a user clicking during the abort() await would still
     // be accepted by handleAskQuestionSelectMenu, then abort() would
     // kill that valid run.
-    pendingQuestionContexts.delete(contextHash)
+    deletePendingQuestionContextsForRequest({
+      threadId: ctx.thread.id,
+      requestId: ctx.requestId,
+    })
     // Abort the session so OpenCode isn't stuck waiting for a reply
     const client = getOpencodeClient(ctx.directory)
     if (client) {
@@ -232,7 +288,10 @@ export async function handleAskQuestionSelectMenu(
   if (context.answeredCount >= context.totalQuestions) {
     // All questions answered - send result back to session
     await submitQuestionAnswers(context)
-    pendingQuestionContexts.delete(contextHash)
+    deletePendingQuestionContextsForRequest({
+      threadId: context.thread.id,
+      requestId: context.requestId,
+    })
   }
 }
 
@@ -357,7 +416,10 @@ export async function cancelPendingQuestion(
   // the question without providing an answer (e.g. voice/attachment-only
   // messages where content needs transcription before it can be an answer).
   if (userMessage === undefined) {
-    pendingQuestionContexts.delete(contextHash)
+    deletePendingQuestionContextsForRequest({
+      threadId: context.thread.id,
+      requestId: context.requestId,
+    })
     return 'no-pending'
   }
 
@@ -385,6 +447,9 @@ export async function cancelPendingQuestion(
     return 'reply-failed'
   }
 
-  pendingQuestionContexts.delete(contextHash)
+  deletePendingQuestionContextsForRequest({
+    threadId: context.thread.id,
+    requestId: context.requestId,
+  })
   return 'replied'
 }

package/src/commands/btw.ts

@@ -22,6 +22,94 @@ import type { CommandContext } from './types.js'
 
 const logger = createLogger(LogPrefix.FORK)
 
+export async function forkSessionToBtwThread({
+  sourceThread,
+  projectDirectory,
+  prompt,
+  userId,
+  username,
+  appId,
+}: {
+  sourceThread: ThreadChannel
+  projectDirectory: string
+  prompt: string
+  userId: string
+  username: string
+  appId: string | undefined
+}): Promise<{ thread: ThreadChannel; forkedSessionId: string } | Error> {
+  const sessionId = await getThreadSession(sourceThread.id)
+  if (!sessionId) {
+    return new Error('No active session in this thread')
+  }
+
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    return new Error(`Failed to fork session: ${getClient.message}`, {
+      cause: getClient,
+    })
+  }
+
+  const forkResponse = await getClient().session.fork({
+    sessionID: sessionId,
+  })
+  if (!forkResponse.data) {
+    return new Error('Failed to fork session')
+  }
+
+  const textChannel = await resolveTextChannel(sourceThread)
+  if (!textChannel) {
+    return new Error('Could not resolve parent text channel')
+  }
+
+  const forkedSession = forkResponse.data
+  const thread = await textChannel.threads.create({
+    name: `btw: ${prompt}`.slice(0, 100),
+    autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+    reason: `btw fork from session ${sessionId}`,
+  })
+
+  await setThreadSession(thread.id, forkedSession.id)
+  await thread.members.add(userId)
+
+  logger.log(
+    `Created btw fork session ${forkedSession.id} in thread ${thread.id} from ${sessionId}`,
+  )
+
+  const sourceThreadLink = `<#${sourceThread.id}>`
+  await sendThreadMessage(
+    thread,
+    `Reusing context from ${sourceThreadLink} to answer prompt...\n${prompt}`,
+  )
+
+  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.`,
+    `Do NOT continue, resume, or reference the previous task. Only answer the question below.\n`,
+    prompt,
+  ].join('\n')
+
+  const runtime = getOrCreateRuntime({
+    threadId: thread.id,
+    thread,
+    projectDirectory,
+    sdkDirectory: projectDirectory,
+    channelId: textChannel.id,
+    appId,
+  })
+  await runtime.enqueueIncoming({
+    prompt: wrappedPrompt,
+    userId,
+    username,
+    appId,
+    mode: 'opencode',
+  })
+
+  return {
+    thread,
+    forkedSessionId: forkedSession.id,
+  }
+}
+
 export async function handleBtwCommand({
   command,
   appId,
@@ -36,13 +124,11 @@ export async function handleBtwCommand({
     return
   }
 
-  const isThread = [
-    ChannelType.PublicThread,
-    ChannelType.PrivateThread,
-    ChannelType.AnnouncementThread,
-  ].includes(channel.type)
-
-  if (!isThread) {
+  if (
+    channel.type !== ChannelType.PublicThread
+    && channel.type !== ChannelType.PrivateThread
+    && channel.type !== ChannelType.AnnouncementThread
+  ) {
     await command.reply({
       content:
         'This command can only be used in a thread with an active session',
@@ -51,10 +137,12 @@ export async function handleBtwCommand({
     return
   }
 
+  const threadChannel = channel
+
   const prompt = command.options.getString('prompt', true)
 
   const resolved = await resolveWorkingDirectory({
-    channel: channel as ThreadChannel,
+    channel: threadChannel,
   })
 
   if (!resolved) {
@@ -67,93 +155,25 @@ export async function handleBtwCommand({
 
   const { projectDirectory } = resolved
 
-  const sessionId = await getThreadSession(channel.id)
-
-  if (!sessionId) {
-    await command.reply({
-      content: 'No active session in this thread',
-      flags: MessageFlags.Ephemeral,
-    })
-    return
-  }
-
   await command.deferReply({ flags: MessageFlags.Ephemeral })
 
-  const getClient = await initializeOpencodeForDirectory(projectDirectory)
-  if (getClient instanceof Error) {
-    await command.editReply({
-      content: `Failed to fork session: ${getClient.message}`,
-    })
-    return
-  }
-
   try {
-    // Fork the entire session (no messageID = fork at the latest point)
-    const forkResponse = await getClient().session.fork({
-      sessionID: sessionId,
-    })
-
-    if (!forkResponse.data) {
-      await command.editReply('Failed to fork session')
-      return
-    }
-
-    const forkedSession = forkResponse.data
-
-    const textChannel = await resolveTextChannel(channel as ThreadChannel)
-    if (!textChannel) {
-      await command.editReply('Could not resolve parent text channel')
-      return
-    }
-
-    const threadName = `btw: ${prompt}`.slice(0, 100)
-    const thread = await textChannel.threads.create({
-      name: threadName,
-      autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
-      reason: `btw fork from session ${sessionId}`,
-    })
-
-    // Claim the forked session immediately so external polling does not race
-    await setThreadSession(thread.id, forkedSession.id)
-
-    await thread.members.add(command.user.id)
-
-    logger.log(
-      `Created btw fork session ${forkedSession.id} in thread ${thread.id} from ${sessionId}`,
-    )
-
-    // Short status message with prompt instead of replaying past messages
-    const sourceThreadLink = `<#${channel.id}>`
-    await sendThreadMessage(
-      thread,
-      `Reusing context from ${sourceThreadLink} to answer prompt...\n${prompt}`,
-    )
-
-    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.`,
-      `Do NOT continue, resume, or reference the previous task. Only answer the question below.\n`,
-      prompt,
-    ].join('\n')
-
-    const runtime = getOrCreateRuntime({
-      threadId: thread.id,
-      thread,
+    const result = await forkSessionToBtwThread({
+      sourceThread: threadChannel,
       projectDirectory,
-      sdkDirectory: projectDirectory,
-      channelId: textChannel.id,
-      appId,
-    })
-    await runtime.enqueueIncoming({
-      prompt: wrappedPrompt,
+      prompt,
       userId: command.user.id,
       username: command.user.displayName,
       appId,
-      mode: 'opencode',
     })
 
+    if (result instanceof Error) {
+      await command.editReply(result.message)
+      return
+    }
+
     await command.editReply(
-      `Session forked! Continue in ${thread.toString()}`,
+      `Session forked! Continue in ${result.thread.toString()}`,
     )
   } catch (error) {
     logger.error('Error in /btw:', error)

package/src/commands/new-worktree.ts

@@ -36,6 +36,26 @@ import type { AutocompleteContext } from './types.js'
 import * as errore from 'errore'
 
 const logger = createLogger(LogPrefix.WORKTREE)
+const DEFAULT_WORKTREE_BASE_REF = 'HEAD'
+
+async function resolveRequestedWorktreeBaseRef({
+  projectDirectory,
+  rawBaseBranch,
+}: {
+  projectDirectory: string
+  rawBaseBranch?: string
+}): Promise<string | Error> {
+  if (!rawBaseBranch) {
+    // Default to the current local HEAD so worktrees can branch from
+    // unpublished commits in the main checkout.
+    return DEFAULT_WORKTREE_BASE_REF
+  }
+
+  return validateBranchRef({
+    directory: projectDirectory,
+    ref: rawBaseBranch,
+  })
+}
 
 /** Status message shown while a worktree is being created. */
 export function worktreeCreatingMessage(worktreeName: string): string {
@@ -43,33 +63,89 @@ export function worktreeCreatingMessage(worktreeName: string): string {
 }
 
 class WorktreeError extends Error {
-  constructor(message: string, options?: { cause?: unknown }) {
+  constructor(message: string, options?: ErrorOptions) {
     super(message, options)
     this.name = 'WorktreeError'
   }
 }
 
 /**
- * Format worktree name: lowercase, spaces to dashes, remove special chars, add opencode/kimaki- prefix.
- * "My Feature" → "opencode/kimaki-my-feature"
- * Returns empty string if no valid name can be extracted.
+ * Lowercase, collapse whitespace to dashes, drop non-[a-z0-9-] chars.
+ * Does NOT add the `opencode/kimaki-` prefix — callers do that so they can
+ * optionally compress the slug first for auto-derived names.
  */
-export function formatWorktreeName(name: string): string {
-  const formatted = name
+export function slugifyWorktreeName(name: string): string {
+  return name
     .toLowerCase()
     .trim()
     .replace(/\s+/g, '-')
     .replace(/[^a-z0-9-]/g, '')
+}
 
-  if (!formatted) {
+/**
+ * Compress a slug by stripping vowels from each dash-separated word, but
+ * keeping the first character so the word stays recognizable.
+ * Only applied to slugs longer than 20 chars — short names are left alone.
+ *
+ * "configurable-sidebar-width-by-component" → "cnfgrbl-sdbr-wdth-by-cmpnnt"
+ *
+ * Used ONLY for auto-derived worktree names (thread name, prompt slug)
+ * so long Discord titles don't produce 80-char folder paths that make
+ * the agent lazy and reuse the previous worktree. User-provided names
+ * via `--worktree <name>` or `/new-worktree name:` are never compressed.
+ */
+export function shortenWorktreeSlug(slug: string): string {
+  if (slug.length <= 20) {
+    return slug
+  }
+  const shortened = slug
+    .split('-')
+    .map((word) => {
+      if (!word) {
+        return word
+      }
+      const first = word[0]
+      const rest = word.slice(1).replace(/[aeiou]/g, '')
+      return first + rest
+    })
+    .join('-')
+  return shortened || slug
+}
+
+/**
+ * Format worktree name: lowercase, spaces to dashes, remove special chars, add opencode/kimaki- prefix.
+ * "My Feature" → "opencode/kimaki-my-feature"
+ * Returns empty string if no valid name can be extracted.
+ *
+ * This is the "explicit" path used when the user provides a specific name.
+ * The slug is NOT compressed — if you ask for `my-long-explicit-branch-name`
+ * you get `opencode/kimaki-my-long-explicit-branch-name` verbatim.
+ */
+export function formatWorktreeName(name: string): string {
+  const slug = slugifyWorktreeName(name)
+  if (!slug) {
     return ''
   }
-  return `opencode/kimaki-${formatted}`
+  return `opencode/kimaki-${slug}`
+}
+
+/**
+ * Format an auto-derived worktree name (from a Discord thread title or a
+ * prompt). Same as formatWorktreeName but compresses slugs longer than 20
+ * chars by stripping vowels so the on-disk folder name stays short.
+ */
+export function formatAutoWorktreeName(name: string): string {
+  const slug = slugifyWorktreeName(name)
+  if (!slug) {
+    return ''
+  }
+  return `opencode/kimaki-${shortenWorktreeSlug(slug)}`
 }
 
 /**
  * Derive worktree name from thread name.
  * Handles existing "⬦ worktree: opencode/kimaki-name" format or uses thread name directly.
+ * Uses formatAutoWorktreeName so long thread titles get vowel-compressed.
  */
 function deriveWorktreeNameFromThread(threadName: string): string {
   // Handle existing "⬦ worktree: opencode/kimaki-name" format
@@ -80,10 +156,10 @@ function deriveWorktreeNameFromThread(threadName: string): string {
     if (extractedName.startsWith('opencode/kimaki-')) {
       return extractedName
     }
-    return formatWorktreeName(extractedName)
+    return formatAutoWorktreeName(extractedName)
   }
-  // Use thread name directly
-  return formatWorktreeName(threadName)
+  // Use thread name directly (compressed if > 20 chars)
+  return formatAutoWorktreeName(threadName)
 }
 
 /**
@@ -254,15 +330,14 @@ export async function handleNewWorktreeCommand({
     return
   }
 
-  const isThread =
+  // Handle command in existing thread - attach worktree to this thread
+  if (
     channel.type === ChannelType.PublicThread ||
     channel.type === ChannelType.PrivateThread
-
-  // Handle command in existing thread - attach worktree to this thread
-  if (isThread) {
+  ) {
     await handleWorktreeInThread({
       command,
-      thread: channel as ThreadChannel,
+      thread: channel,
     })
     return
   }
@@ -292,7 +367,7 @@ export async function handleNewWorktreeCommand({
     return
   }
 
-  const textChannel = channel as TextChannel
+  const textChannel = channel
 
   const projectDirectory = await getProjectDirectoryFromChannel(
     textChannel,
@@ -302,17 +377,13 @@ export async function handleNewWorktreeCommand({
     return
   }
 
-  let baseBranch = rawBaseBranch
-  if (baseBranch) {
-    const validated = await validateBranchRef({
-      directory: projectDirectory,
-      ref: baseBranch,
-    })
-    if (validated instanceof Error) {
-      await command.editReply(`Invalid base branch: \`${baseBranch}\``)
-      return
-    }
-    baseBranch = validated
+  const baseBranch = await resolveRequestedWorktreeBaseRef({
+    projectDirectory,
+    rawBaseBranch,
+  })
+  if (baseBranch instanceof Error) {
+    await command.editReply(`Invalid base branch: \`${rawBaseBranch}\``)
+    return
   }
 
   const existingWorktree = await findExistingWorktreePath({
@@ -415,24 +486,20 @@ async function handleWorktreeInThread({
   }
 
   const projectDirectory = await getProjectDirectoryFromChannel(
-    parent as TextChannel,
+    parent,
   )
   if (errore.isError(projectDirectory)) {
     await command.editReply(projectDirectory.message)
     return
   }
 
-  let baseBranch = rawBaseBranch
-  if (baseBranch) {
-    const validated = await validateBranchRef({
-      directory: projectDirectory,
-      ref: baseBranch,
-    })
-    if (validated instanceof Error) {
-      await command.editReply(`Invalid base branch: \`${baseBranch}\``)
-      return
-    }
-    baseBranch = validated
+  const baseBranch = await resolveRequestedWorktreeBaseRef({
+    projectDirectory,
+    rawBaseBranch,
+  })
+  if (baseBranch instanceof Error) {
+    await command.editReply(`Invalid base branch: \`${rawBaseBranch}\``)
+    return
   }
 
   const existingWorktreePath = await findExistingWorktreePath({

package/src/commands/queue.ts

@@ -100,6 +100,7 @@ export async function handleClearQueueCommand({
   command,
 }: CommandContext): Promise<void> {
   const channel = command.channel
+  const position = command.options.getInteger('position') ?? undefined
 
   if (!channel) {
     await command.reply({
@@ -134,6 +135,27 @@ export async function handleClearQueueCommand({
     return
   }
 
+  if (position !== undefined) {
+    const removed = runtime?.removeQueuePosition(position)
+    if (!removed) {
+      await command.reply({
+        content: `No queued message at position ${position}`,
+        flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+      })
+      return
+    }
+
+    await command.reply({
+      content: `Cleared queued message at position ${position}`,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+
+    logger.log(
+      `[QUEUE] User ${command.user.displayName} cleared queued position ${position} in thread ${channel.id}`,
+    )
+    return
+  }
+
   runtime?.clearQueue()
 
   await command.reply({