kimaki 0.4.46 → 0.4.48

package/dist/system-message.js

@@ -111,19 +111,21 @@ headings are discouraged anyway. instead try to use bold text for titles which r
 
 you can create diagrams wrapping them in code blocks.
 
-## ending conversations with options
+## proactivity
 
-IMPORTANT: At the end of each response, especially after completing a task or presenting a plan, use the question tool to offer the user clear options for what to do next.
+Be proactive. When the user asks you to do something, do it. Do NOT stop to ask for confirmation.
 
-IMPORTANT: The question tool must be called last, after all text parts. If it is called before your final text response, the user will not see the text.
+Only ask questions when the request is genuinely ambiguous with multiple valid approaches, or the action is destructive and irreversible.
 
-Examples:
-- After showing a plan: offer "Start implementing?" with Yes/No options
-- After completing edits: offer "Commit changes?" with Yes/No options
-- After debugging: offer "How to proceed?" with options like "Apply fix", "Investigate further", "Try different approach"
+## ending conversations with options
 
-The user can always select "Other" to type a custom response if the provided options don't fit their needs, or if the plan needs updating.
+After **completing** a task, use the question tool to offer follow-up options. The question tool must be called last, after all text parts.
 
-This makes the interaction more guided and reduces friction for the user.
+IMPORTANT: Do NOT use the question tool to ask permission before doing work. Do the work first, then offer follow-ups.
+
+Examples:
+- After completing edits: offer "Commit changes?" or "Run tests?"
+- After debugging: offer "Apply fix", "Investigate further", "Try different approach"
+- After a genuinely ambiguous request where you cannot infer intent: offer the different approaches
 `;
 }

package/dist/tools.js

@@ -6,9 +6,9 @@ import { z } from 'zod';
 import { spawn } from 'node:child_process';
 import net from 'node:net';
 import { createOpencodeClient, } from '@opencode-ai/sdk';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import * as errore from 'errore';
-const toolsLogger = createLogger('TOOLS');
+const toolsLogger = createLogger(LogPrefix.TOOLS);
 import { ShareMarkdown } from './markdown.js';
 import { formatDistanceToNow } from './utils.js';
 import pc from 'picocolors';
@@ -289,6 +289,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
             }),
             execute: async ({ sessionId }) => {
                 try {
+                    toolsLogger.log(`[ABORT] reason=voice-tool sessionId=${sessionId} - user requested abort via voice assistant tool`);
                     const result = await getClient().session.abort({
                         path: { id: sessionId },
                     });

package/dist/utils.js

@@ -50,6 +50,7 @@ export function isAbortError(error, signal) {
             error.name === 'Aborterror' ||
             error.name === 'aborterror' ||
             error.name.toLowerCase() === 'aborterror' ||
+            error.name === 'MessageAbortedError' ||
             error.message?.includes('aborted') ||
             (signal?.aborted ?? false))) ||
         (error instanceof DOMException && error.name === 'AbortError'));

package/dist/voice-handler.js

@@ -17,8 +17,8 @@ import { getDatabase } from './database.js';
 import { sendThreadMessage, escapeDiscordFormatting, SILENT_MESSAGE_FLAGS, } from './discord-utils.js';
 import { transcribeAudio } from './voice.js';
 import { FetchError } from './errors.js';
-import { createLogger } from './logger.js';
-const voiceLogger = createLogger('VOICE');
+import { createLogger, LogPrefix } from './logger.js';
+const voiceLogger = createLogger(LogPrefix.VOICE);
 export const voiceConnections = new Map();
 export function convertToMono16k(buffer) {
     const inputSampleRate = 48000;

package/dist/voice.js

@@ -4,11 +4,11 @@
 // Uses errore for type-safe error handling.
 import { GoogleGenAI, Type } from '@google/genai';
 import * as errore from 'errore';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { glob } from 'glob';
 import { ripGrep } from 'ripgrep-js';
 import { ApiKeyMissingError, InvalidAudioFormatError, TranscriptionError, EmptyTranscriptionError, NoResponseContentError, NoToolResponseError, GrepSearchError, GlobSearchError, } from './errors.js';
-const voiceLogger = createLogger('VOICE');
+const voiceLogger = createLogger(LogPrefix.VOICE);
 function runGrep({ pattern, directory }) {
     return errore.tryAsync({
         try: async () => {

package/dist/worktree-utils.js

@@ -1,15 +1,19 @@
 // Worktree utility functions.
 // Wrapper for OpenCode worktree creation that also initializes git submodules.
-import { exec } from 'node:child_process';
+// Also handles capturing and applying git diffs when creating worktrees from threads.
+import { exec, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 export const execAsync = promisify(exec);
-const logger = createLogger('WORKTREE-UTILS');
+const logger = createLogger(LogPrefix.WORKTREE);
 /**
  * Create a worktree using OpenCode SDK and initialize git submodules.
  * This wrapper ensures submodules are properly set up in new worktrees.
+ *
+ * If diff is provided, it's applied BEFORE submodule update to ensure
+ * any submodule pointer changes in the diff are respected.
  */
-export async function createWorktreeWithSubmodules({ clientV2, directory, name, }) {
+export async function createWorktreeWithSubmodules({ clientV2, directory, name, diff, }) {
     // 1. Create worktree via OpenCode SDK
     const response = await clientV2.worktree.create({
         directory,
@@ -22,7 +26,17 @@ export async function createWorktreeWithSubmodules({ clientV2, directory, name,
         return new Error('No worktree data returned from SDK');
     }
     const worktreeDir = response.data.directory;
-    // 2. Init submodules in new worktree (don't block on failure)
+    let diffApplied = false;
+    // 2. Apply diff BEFORE submodule update (if provided)
+    // This ensures any submodule pointer changes in the diff are applied first,
+    // so submodule update checks out the correct commits.
+    if (diff) {
+        logger.log(`Applying diff to ${worktreeDir} before submodule init`);
+        diffApplied = await applyGitDiff(worktreeDir, diff);
+    }
+    // 3. Init submodules in new worktree (don't block on failure)
+    // Uses --init to initialize, --recursive for nested submodules.
+    // Submodules will be checked out at the commit specified by the (possibly updated) index.
     try {
         logger.log(`Initializing submodules in ${worktreeDir}`);
         await execAsync('git submodule update --init --recursive', {
@@ -34,7 +48,7 @@ export async function createWorktreeWithSubmodules({ clientV2, directory, name,
         // Log but don't fail - submodules might not exist
         logger.warn(`Failed to init submodules in ${worktreeDir}: ${e instanceof Error ? e.message : String(e)}`);
     }
-    // 3. Install dependencies using ni (detects package manager from lockfile)
+    // 4. Install dependencies using ni (detects package manager from lockfile)
     try {
         logger.log(`Installing dependencies in ${worktreeDir}`);
         await execAsync('npx -y ni', {
@@ -46,5 +60,75 @@ export async function createWorktreeWithSubmodules({ clientV2, directory, name,
         // Log but don't fail - might not be a JS project or might fail for various reasons
         logger.warn(`Failed to install dependencies in ${worktreeDir}: ${e instanceof Error ? e.message : String(e)}`);
     }
-    return response.data;
+    return { ...response.data, diffApplied };
+}
+/**
+ * Capture git diff from a directory (both staged and unstaged changes).
+ * Returns null if no changes or on error.
+ */
+export async function captureGitDiff(directory) {
+    try {
+        // Capture unstaged changes
+        const unstagedResult = await execAsync('git diff', { cwd: directory });
+        const unstaged = unstagedResult.stdout.trim();
+        // Capture staged changes
+        const stagedResult = await execAsync('git diff --staged', { cwd: directory });
+        const staged = stagedResult.stdout.trim();
+        if (!unstaged && !staged) {
+            return null;
+        }
+        return { unstaged, staged };
+    }
+    catch (e) {
+        logger.warn(`Failed to capture git diff from ${directory}: ${e instanceof Error ? e.message : String(e)}`);
+        return null;
+    }
+}
+/**
+ * Run a git command with stdin input.
+ * Uses spawn to pipe the diff content to git apply.
+ */
+function runGitWithStdin(args, cwd, input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', args, { cwd, stdio: ['pipe', 'pipe', 'pipe'] });
+        let stderr = '';
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(stderr || `git ${args.join(' ')} failed with code ${code}`));
+            }
+        });
+        child.on('error', reject);
+        child.stdin?.write(input);
+        child.stdin?.end();
+    });
+}
+/**
+ * Apply a captured git diff to a directory.
+ * Applies staged changes first, then unstaged.
+ */
+export async function applyGitDiff(directory, diff) {
+    try {
+        // Apply staged changes first (and stage them)
+        if (diff.staged) {
+            logger.log(`Applying staged diff to ${directory}`);
+            await runGitWithStdin(['apply', '--index'], directory, diff.staged);
+        }
+        // Apply unstaged changes (don't stage them)
+        if (diff.unstaged) {
+            logger.log(`Applying unstaged diff to ${directory}`);
+            await runGitWithStdin(['apply'], directory, diff.unstaged);
+        }
+        logger.log(`Successfully applied diff to ${directory}`);
+        return true;
+    }
+    catch (e) {
+        logger.warn(`Failed to apply git diff to ${directory}: ${e instanceof Error ? e.message : String(e)}`);
+        return false;
+    }
 }

package/dist/xml.js

@@ -2,8 +2,8 @@
 // Parses XML-like tags from strings (e.g., channel topics) to extract
 // Kimaki configuration like directory paths and app IDs.
 import { DomHandler, Parser, ElementType } from 'htmlparser2';
-import { createLogger } from './logger.js';
-const xmlLogger = createLogger('XML');
+import { createLogger, LogPrefix } from './logger.js';
+const xmlLogger = createLogger(LogPrefix.XML);
 export function extractTagsArrays({ xml, tags, }) {
     const result = {
         others: [],

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.46",
+  "version": "0.4.48",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -20,7 +20,7 @@
     "tsx": "^4.20.5"
   },
   "dependencies": {
-    "@clack/prompts": "^0.11.0",
+    "@clack/prompts": "^1.0.0",
     "@discordjs/voice": "^0.19.0",
     "@google/genai": "^1.34.0",
     "@opencode-ai/sdk": "^1.1.31",
@@ -41,7 +41,7 @@
     "string-dedent": "^3.0.2",
     "undici": "^7.16.0",
     "zod": "^4.2.1",
-    "errore": "^0.9.0"
+    "errore": "^0.10.0"
   },
   "optionalDependencies": {
     "@discordjs/opus": "^0.10.0",

package/src/cli.ts

@@ -43,14 +43,34 @@ import path from 'node:path'
 import fs from 'node:fs'
 import * as errore from 'errore'
 
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 import { uploadFilesToDiscord } from './discord-utils.js'
 import { spawn, spawnSync, execSync, type ExecSyncOptions } from 'node:child_process'
 import http from 'node:http'
-import { setDataDir, getDataDir, getLockPort } from './config.js'
+import { setDataDir, getDataDir, getLockPort, setDefaultVerbosity } from './config.js'
 import { sanitizeAgentName } from './commands/agent.js'
 
-const cliLogger = createLogger('CLI')
+const cliLogger = createLogger(LogPrefix.CLI)
+
+// Spawn caffeinate on macOS to prevent system sleep while bot is running.
+// Not detached, so it dies automatically with the parent process.
+function startCaffeinate() {
+  if (process.platform !== 'darwin') {
+    return
+  }
+  try {
+    const proc = spawn('caffeinate', ['-i'], {
+      stdio: 'ignore',
+      detached: false,
+    })
+    proc.on('error', (err) => {
+      cliLogger.warn('Failed to start caffeinate:', err.message)
+    })
+    cliLogger.log('Started caffeinate to prevent system sleep')
+  } catch (err) {
+    cliLogger.warn('Failed to spawn caffeinate:', err instanceof Error ? err.message : String(err))
+  }
+}
 const cli = cac('kimaki')
 
 process.title = 'kimaki'
@@ -125,7 +145,11 @@ async function checkSingleInstance(): Promise<void> {
         setTimeout(resolve, 500)
       })
     }
-  } catch {
+  } catch (error) {
+    cliLogger.debug(
+      'Lock port check failed:',
+      error instanceof Error ? error.message : String(error),
+    )
     cliLogger.debug('No other kimaki instance detected on lock port')
   }
 }
@@ -301,6 +325,10 @@ async function registerCommands({
       .setName('abort')
       .setDescription('Abort the current OpenCode request in this thread')
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('compact')
+      .setDescription('Compact the session context by summarizing conversation history')
+      .toJSON(),
     new SlashCommandBuilder()
       .setName('stop')
       .setDescription('Abort the current OpenCode request in this thread')
@@ -527,11 +555,23 @@ async function backgroundInit({
       getClient()
         .command.list({ query: { directory: currentDir } })
         .then((r) => r.data || [])
-        .catch(() => []),
+        .catch((error) => {
+          cliLogger.warn(
+            'Failed to load user commands during background init:',
+            error instanceof Error ? error.message : String(error),
+          )
+          return []
+        }),
       getClient()
         .app.agents({ query: { directory: currentDir } })
         .then((r) => r.data || [])
-        .catch(() => []),
+        .catch((error) => {
+          cliLogger.warn(
+            'Failed to load agents during background init:',
+            error instanceof Error ? error.message : String(error),
+          )
+          return []
+        }),
     ])
 
     await registerCommands({ token, appId, userCommands, agents })
@@ -545,6 +585,8 @@ async function backgroundInit({
 }
 
 async function run({ restart, addChannels, useWorktrees }: CliOptions) {
+  startCaffeinate()
+
   const forceSetup = Boolean(restart)
 
   intro('🤖 Discord Bot Setup')
@@ -587,7 +629,11 @@ async function run({ restart, addChannels, useWorktrees }: CliOptions) {
         try {
           fs.accessSync(p, fs.constants.F_OK)
           return true
-        } catch {
+        } catch (error) {
+          cliLogger.debug(
+            `OpenCode path not found at ${p}:`,
+            error instanceof Error ? error.message : String(error),
+          )
           return false
         }
       })
@@ -888,11 +934,23 @@ async function run({ restart, addChannels, useWorktrees }: CliOptions) {
     getClient()
       .command.list({ query: { directory: currentDir } })
       .then((r) => r.data || [])
-      .catch(() => []),
+      .catch((error) => {
+        cliLogger.warn(
+          'Failed to load user commands during setup:',
+          error instanceof Error ? error.message : String(error),
+        )
+        return []
+      }),
     getClient()
       .app.agents({ query: { directory: currentDir } })
       .then((r) => r.data || [])
-      .catch(() => []),
+      .catch((error) => {
+        cliLogger.warn(
+          'Failed to load agents during setup:',
+          error instanceof Error ? error.message : String(error),
+        )
+        return []
+      }),
   ])
 
   s.stop(`Found ${projects.length} OpenCode project(s)`)
@@ -1040,6 +1098,7 @@ cli
   .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
   .option('--install-url', 'Print the bot install URL and exit')
   .option('--use-worktrees', 'Create git worktrees for all new sessions started from channel messages')
+  .option('--verbosity <level>', 'Default verbosity for all channels (tools-and-text or text-only)')
   .action(
     async (options: {
       restart?: boolean
@@ -1047,6 +1106,7 @@ cli
       dataDir?: string
       installUrl?: boolean
       useWorktrees?: boolean
+      verbosity?: string
     }) => {
       try {
         // Set data directory early, before any database access
@@ -1055,6 +1115,15 @@ cli
           cliLogger.log(`Using data directory: ${getDataDir()}`)
         }
 
+        if (options.verbosity) {
+          if (options.verbosity !== 'tools-and-text' && options.verbosity !== 'text-only') {
+            cliLogger.error(`Invalid verbosity level: ${options.verbosity}. Use "tools-and-text" or "text-only".`)
+            process.exit(EXIT_NO_RESTART)
+          }
+          setDefaultVerbosity(options.verbosity)
+          cliLogger.log(`Default verbosity: ${options.verbosity}`)
+        }
+
         if (options.installUrl) {
           const db = getDatabase()
           const existingBot = db
@@ -1214,8 +1283,11 @@ cli
               .prepare('SELECT app_id FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
               .get() as { app_id: string } | undefined
             appId = botRow?.app_id
-          } catch {
-            // Database might not exist in CI, that's ok
+          } catch (error) {
+            cliLogger.debug(
+              'Database lookup failed while resolving app ID:',
+              error instanceof Error ? error.message : String(error),
+            )
           }
         }
       } else {
@@ -1330,8 +1402,11 @@ cli
                   if (ch && 'guild' in ch && ch.guild) {
                     return ch.guild
                   }
-                } catch {
-                  // Channel might be deleted, continue
+                } catch (error) {
+                  cliLogger.debug(
+                    'Failed to fetch existing channel while selecting guild:',
+                    error instanceof Error ? error.message : String(error),
+                  )
                 }
               }
               // Fall back to first guild the bot is in
@@ -1571,8 +1646,11 @@ cli
                 .prepare('SELECT app_id FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
                 .get() as { app_id: string } | undefined
               appId = botRow?.app_id
-            } catch {
-              // Database might not exist in CI
+            } catch (error) {
+              cliLogger.debug(
+                'Database lookup failed while resolving app ID:',
+                error instanceof Error ? error.message : String(error),
+              )
             }
           }
         } else {
@@ -1651,8 +1729,11 @@ cli
               } else {
                 throw new Error('Channel has no guild')
               }
-            } catch {
-              // Channel might be deleted, fall back to first guild
+            } catch (error) {
+              cliLogger.debug(
+                'Failed to fetch existing channel while selecting guild:',
+                error instanceof Error ? error.message : String(error),
+              )
               const firstGuild = client.guilds.cache.first()
               if (!firstGuild) {
                 s.stop('No guild found')
@@ -1696,12 +1777,18 @@ cli
                 client.destroy()
                 process.exit(0)
               }
-            } catch {
-              // Channel might be deleted, continue checking
+            } catch (error) {
+              cliLogger.debug(
+                `Failed to fetch channel ${existingChannel.channel_id} while checking existing channels:`,
+                error instanceof Error ? error.message : String(error),
+              )
             }
           }
-        } catch {
-          // Database might not exist, continue to create
+        } catch (error) {
+          cliLogger.debug(
+            'Database lookup failed while checking existing channels:',
+            error instanceof Error ? error.message : String(error),
+          )
         }
 
         s.message(`Creating channels in ${guild.name}...`)

package/src/commands/abort.ts

@@ -6,10 +6,10 @@ import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
 import { abortControllers } from '../session-handler.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import * as errore from 'errore'
 
-const logger = createLogger('ABORT')
+const logger = createLogger(LogPrefix.ABORT)
 
 export async function handleAbortCommand({ command }: CommandContext): Promise<void> {
   const channel = command.channel
@@ -67,6 +67,7 @@ export async function handleAbortCommand({ command }: CommandContext): Promise<v
 
   const existingController = abortControllers.get(sessionId)
   if (existingController) {
+    logger.log(`[ABORT] reason=user-requested sessionId=${sessionId} channelId=${channel.id} - user ran /abort command`)
     existingController.abort(new Error('User requested abort'))
     abortControllers.delete(sessionId)
   }
@@ -82,6 +83,7 @@ export async function handleAbortCommand({ command }: CommandContext): Promise<v
   }
 
   try {
+    logger.log(`[ABORT-API] reason=user-requested sessionId=${sessionId} channelId=${channel.id} - sending API abort from /abort command`)
     await getClient().session.abort({
       path: { id: sessionId },
     })

package/src/commands/add-project.ts

@@ -6,11 +6,11 @@ import type { CommandContext, AutocompleteContext } from './types.js'
 import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { createProjectChannels } from '../channel-management.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import { abbreviatePath } from '../utils.js'
 import * as errore from 'errore'
 
-const logger = createLogger('ADD-PROJECT')
+const logger = createLogger(LogPrefix.ADD_PROJECT)
 
 export async function handleAddProjectCommand({ command, appId }: CommandContext): Promise<void> {
   await command.deferReply({ ephemeral: false })

package/src/commands/agent.ts

@@ -14,10 +14,10 @@ import crypto from 'node:crypto'
 import { getDatabase, setChannelAgent, setSessionAgent, clearSessionModel, runModelMigrations } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 import * as errore from 'errore'
 
-const agentLogger = createLogger('AGENT')
+const agentLogger = createLogger(LogPrefix.AGENT)
 
 const pendingAgentContexts = new Map<
   string,
@@ -257,7 +257,7 @@ export async function handleAgentSelectMenu(
       })
     } else {
       await interaction.editReply({
-        content: `Agent preference set for this channel: **${selectedAgent}**\n\nAll new sessions in this channel will use this agent.`,
+        content: `Agent preference set for this channel: **${selectedAgent}**\nAll new sessions in this channel will use this agent.`,
         components: [],
       })
     }
@@ -331,7 +331,7 @@ export async function handleQuickAgentCommand({
       })
     } else {
       await command.editReply({
-        content: `Switched to **${matchingAgent.name}** agent for this channel\n\nAll new sessions will use this agent.`,
+        content: `Switched to **${matchingAgent.name}** agent for this channel\nAll new sessions will use this agent.`,
       })
     }
   } catch (error) {

package/src/commands/ask-question.ts

@@ -11,9 +11,9 @@ import {
 import crypto from 'node:crypto'
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js'
 import { getOpencodeClientV2 } from '../opencode.js'
-import { createLogger } from '../logger.js'
+import { createLogger, LogPrefix } from '../logger.js'
 
-const logger = createLogger('ASK_QUESTION')
+const logger = createLogger(LogPrefix.ASK_QUESTION)
 
 // Schema matching the question tool input
 export type AskUserQuestionInput = {
@@ -268,9 +268,9 @@ export function parseAskUserQuestionTool(part: {
 
 /**
  * Cancel a pending question for a thread (e.g., when user sends a new message).
- * Sends cancellation response to OpenCode so the session can continue.
+ * Sends the user's message as the answer to OpenCode so the model sees their actual response.
  */
-export async function cancelPendingQuestion(threadId: string): Promise<boolean> {
+export async function cancelPendingQuestion(threadId: string, userMessage?: string): Promise<boolean> {
   // Find pending question for this thread
   let contextHash: string | undefined
   let context: PendingQuestionContext | undefined
@@ -292,9 +292,10 @@ export async function cancelPendingQuestion(threadId: string): Promise<boolean>
       throw new Error('OpenCode server not found for directory')
     }
 
-    // Preserve already-answered questions, mark unanswered as cancelled
+    // Use user's message as answer if provided, otherwise mark as "Other"
+    const customAnswer = userMessage || 'Other'
     const answers = context.questions.map((_, i) => {
-      return context.answers[i] || ['(cancelled - user sent new message)']
+      return context.answers[i] || [customAnswer]
     })
 
     await clientV2.question.reply({
@@ -302,9 +303,9 @@ export async function cancelPendingQuestion(threadId: string): Promise<boolean>
       answers,
     })
 
-    logger.log(`Cancelled question ${context.requestId} due to new user message`)
+    logger.log(`Answered question ${context.requestId} with user message`)
   } catch (error) {
-    logger.error('Failed to cancel question:', error)
+    logger.error('Failed to answer question:', error)
   }
 
   // Clean up regardless of whether the API call succeeded