kimaki 0.4.46 → 0.4.48

package/dist/logger.js

@@ -1,11 +1,49 @@
-// Prefixed logging utility using @clack/prompts.
-// Creates loggers with consistent prefixes for different subsystems
-// (DISCORD, VOICE, SESSION, etc.) for easier debugging.
-import { log } from '@clack/prompts';
+// Prefixed logging utility.
+// Uses picocolors for compact frequent logs (log, info, debug).
+// Uses @clack/prompts only for important events (warn, error) with visual distinction.
+import { log as clackLog } from '@clack/prompts';
 import fs from 'node:fs';
 import path, { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import util from 'node:util';
+import pc from 'picocolors';
+// All known log prefixes - add new ones here to keep alignment consistent
+export const LogPrefix = {
+    ABORT: 'ABORT',
+    ADD_PROJECT: 'ADD_PROJ',
+    AGENT: 'AGENT',
+    ASK_QUESTION: 'QUESTION',
+    CLI: 'CLI',
+    COMPACT: 'COMPACT',
+    CREATE_PROJECT: 'NEW_PROJ',
+    DB: 'DB',
+    DISCORD: 'DISCORD',
+    FORK: 'FORK',
+    FORMATTING: 'FORMAT',
+    GENAI: 'GENAI',
+    GENAI_WORKER: 'GENAI_W',
+    INTERACTION: 'INTERACT',
+    MARKDOWN: 'MARKDOWN',
+    MODEL: 'MODEL',
+    OPENAI: 'OPENAI',
+    OPENCODE: 'OPENCODE',
+    PERMISSIONS: 'PERMS',
+    QUEUE: 'QUEUE',
+    REMOVE_PROJECT: 'RM_PROJ',
+    RESUME: 'RESUME',
+    SESSION: 'SESSION',
+    SHARE: 'SHARE',
+    TOOLS: 'TOOLS',
+    UNDO_REDO: 'UNDO',
+    USER_CMD: 'USER_CMD',
+    VERBOSITY: 'VERBOSE',
+    VOICE: 'VOICE',
+    WORKER: 'WORKER',
+    WORKTREE: 'WORKTREE',
+    XML: 'XML',
+};
+// compute max length from all known prefixes for alignment
+const MAX_PREFIX_LENGTH = Math.max(...Object.values(LogPrefix).map((p) => p.length));
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const isDev = !__dirname.includes('node_modules');
@@ -32,27 +70,37 @@ function writeToFile(level, prefix, args) {
     const message = `[${timestamp}] [${level}] [${prefix}] ${args.map(formatArg).join(' ')}\n`;
     fs.appendFileSync(logFilePath, message);
 }
+function getTimestamp() {
+    const now = new Date();
+    return `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`;
+}
+function padPrefix(prefix) {
+    return prefix.padEnd(MAX_PREFIX_LENGTH);
+}
 export function createLogger(prefix) {
+    const paddedPrefix = padPrefix(prefix);
     return {
         log: (...args) => {
             writeToFile('INFO', prefix, args);
-            log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '));
+            console.log(pc.dim(getTimestamp()), pc.cyan(paddedPrefix), ...args.map(formatArg));
         },
         error: (...args) => {
             writeToFile('ERROR', prefix, args);
-            log.error([`[${prefix}]`, ...args.map(formatArg)].join(' '));
+            // use clack for errors - visually distinct
+            clackLog.error([paddedPrefix, ...args.map(formatArg)].join(' '));
         },
         warn: (...args) => {
             writeToFile('WARN', prefix, args);
-            log.warn([`[${prefix}]`, ...args.map(formatArg)].join(' '));
+            // use clack for warnings - visually distinct
+            clackLog.warn([paddedPrefix, ...args.map(formatArg)].join(' '));
         },
         info: (...args) => {
             writeToFile('INFO', prefix, args);
-            log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '));
+            console.log(pc.dim(getTimestamp()), pc.blue(paddedPrefix), ...args.map(formatArg));
         },
         debug: (...args) => {
             writeToFile('DEBUG', prefix, args);
-            log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '));
+            console.log(pc.dim(getTimestamp()), pc.dim(paddedPrefix), ...args.map(formatArg));
         },
     };
 }

package/dist/markdown.js

@@ -7,7 +7,7 @@ import { createTaggedError } from 'errore';
 import * as yaml from 'js-yaml';
 import { formatDateTime } from './utils.js';
 import { extractNonXmlContent } from './xml.js';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { SessionNotFoundError, MessagesNotFoundError } from './errors.js';
 // Generic error for unexpected exceptions in async operations
 class UnexpectedError extends createTaggedError({
@@ -15,7 +15,7 @@ class UnexpectedError extends createTaggedError({
     message: '$message',
 }) {
 }
-const markdownLogger = createLogger('MARKDOWN');
+const markdownLogger = createLogger(LogPrefix.MARKDOWN);
 export class ShareMarkdown {
     client;
     constructor(client) {

package/dist/message-formatting.js

@@ -4,10 +4,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import * as errore from 'errore';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { FetchError } from './errors.js';
 const ATTACHMENTS_DIR = path.join(process.cwd(), 'tmp', 'discord-attachments');
-const logger = createLogger('FORMATTING');
+const logger = createLogger(LogPrefix.FORMATTING);
 /**
  * Escapes Discord inline markdown characters so dynamic content
  * doesn't break formatting when wrapped in *, _, **, etc.
@@ -15,6 +15,73 @@ const logger = createLogger('FORMATTING');
 function escapeInlineMarkdown(text) {
     return text.replace(/([*_~|`\\])/g, '\\$1');
 }
+/**
+ * Parses a patchText string (apply_patch format) and counts additions/deletions per file.
+ * Patch format uses `*** Add File:`, `*** Update File:`, `*** Delete File:` headers,
+ * with diff lines prefixed by `+` (addition) or `-` (deletion) inside `@@` hunks.
+ */
+function parsePatchCounts(patchText) {
+    const counts = new Map();
+    const lines = patchText.split('\n');
+    let currentFile = '';
+    let currentType = '';
+    let inHunk = false;
+    for (const line of lines) {
+        const addMatch = line.match(/^\*\*\* Add File:\s*(.+)/);
+        const updateMatch = line.match(/^\*\*\* Update File:\s*(.+)/);
+        const deleteMatch = line.match(/^\*\*\* Delete File:\s*(.+)/);
+        if (addMatch || updateMatch || deleteMatch) {
+            const match = addMatch || updateMatch || deleteMatch;
+            currentFile = (match?.[1] ?? '').trim();
+            currentType = addMatch ? 'add' : updateMatch ? 'update' : 'delete';
+            counts.set(currentFile, { additions: 0, deletions: 0 });
+            inHunk = false;
+            continue;
+        }
+        if (line.startsWith('@@')) {
+            inHunk = true;
+            continue;
+        }
+        if (line.startsWith('*** ')) {
+            inHunk = false;
+            continue;
+        }
+        if (!currentFile) {
+            continue;
+        }
+        const entry = counts.get(currentFile);
+        if (!entry) {
+            continue;
+        }
+        if (currentType === 'add') {
+            // all content lines in Add File are additions
+            if (line.length > 0 && !line.startsWith('*** ')) {
+                entry.additions++;
+            }
+        }
+        else if (currentType === 'delete') {
+            // all content lines in Delete File are deletions
+            if (line.length > 0 && !line.startsWith('*** ')) {
+                entry.deletions++;
+            }
+        }
+        else if (inHunk) {
+            if (line.startsWith('+')) {
+                entry.additions++;
+            }
+            else if (line.startsWith('-')) {
+                entry.deletions++;
+            }
+        }
+    }
+    return counts;
+}
+/**
+ * Normalize whitespace: convert newlines to spaces and collapse consecutive spaces.
+ */
+function normalizeWhitespace(text) {
+    return text.replace(/[\r\n]+/g, ' ').replace(/\s+/g, ' ');
+}
 /**
  * Collects and formats the last N assistant parts from session messages.
  * Used by both /resume and /fork to show recent assistant context.
@@ -125,6 +192,22 @@ export function getToolSummaryText(part) {
             ? `*${escapeInlineMarkdown(fileName)}* (+${added}-${removed})`
             : `(+${added}-${removed})`;
     }
+    if (part.tool === 'apply_patch') {
+        // Only inputs are available when parts are sent during streaming (output/metadata not yet populated)
+        const patchText = part.state.input?.patchText || '';
+        if (!patchText) {
+            return '';
+        }
+        const patchCounts = parsePatchCounts(patchText);
+        return [...patchCounts.entries()]
+            .map(([filePath, { additions, deletions }]) => {
+            const fileName = filePath.split('/').pop() || '';
+            return fileName
+                ? `*${escapeInlineMarkdown(fileName)}* (+${additions}-${deletions})`
+                : `(+${additions}-${deletions})`;
+        })
+            .join(', ');
+    }
     if (part.tool === 'write') {
         const filePath = part.state.input?.filePath || '';
         const content = part.state.input?.content || '';
@@ -175,7 +258,8 @@ export function getToolSummaryText(part) {
         if (value === null || value === undefined)
             return null;
         const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
-        const truncatedValue = stringValue.length > 50 ? stringValue.slice(0, 50) + '…' : stringValue;
+        const normalized = normalizeWhitespace(stringValue);
+        const truncatedValue = normalized.length > 50 ? normalized.slice(0, 50) + '…' : normalized;
         return `${key}: ${truncatedValue}`;
     })
         .filter(Boolean);
@@ -201,7 +285,7 @@ export function formatTodoList(part) {
     return `${num} **${escapeInlineMarkdown(content)}**`;
 }
 export function formatPart(part, prefix) {
-    const pfx = prefix ? `${prefix}: ` : '';
+    const pfx = prefix ? `${prefix} ⋅ ` : '';
     if (part.type === 'text') {
         if (!part.text?.trim())
             return '';
@@ -278,12 +362,13 @@ export function formatPart(part, prefix) {
             if (part.state.status === 'error') {
                 return '⨯';
             }
-            if (part.tool === 'edit' || part.tool === 'write') {
+            if (part.tool === 'edit' || part.tool === 'write' || part.tool === 'apply_patch') {
                 return '◼︎';
             }
             return '┣';
         })();
-        return `${icon} ${pfx}${part.tool} ${toolTitle} ${summaryText}`.trim();
+        const toolParts = [part.tool, toolTitle, summaryText].filter(Boolean).join(' ');
+        return `${icon} ${pfx}${toolParts}`;
     }
     logger.warn('Unknown part type:', part);
     return '';

package/dist/openai-realtime.js

@@ -3,8 +3,8 @@
 // @ts-nocheck
 import { RealtimeClient } from '@openai/realtime-api-beta';
 import { writeFile } from 'fs';
-import { createLogger } from './logger.js';
-const openaiLogger = createLogger('OPENAI');
+import { createLogger, LogPrefix } from './logger.js';
+const openaiLogger = createLogger(LogPrefix.OPENAI);
 const audioParts = [];
 function saveBinaryFile(fileName, content) {
     writeFile(fileName, content, 'utf8', (err) => {

package/dist/opencode.js

@@ -8,9 +8,9 @@ import net from 'node:net';
 import { createOpencodeClient } from '@opencode-ai/sdk';
 import { createOpencodeClient as createOpencodeClientV2, } from '@opencode-ai/sdk/v2';
 import * as errore from 'errore';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { DirectoryNotAccessibleError, ServerStartError, ServerNotReadyError, FetchError, } from './errors.js';
-const opencodeLogger = createLogger('OPENCODE');
+const opencodeLogger = createLogger(LogPrefix.OPENCODE);
 const opencodeServers = new Map();
 const serverRetryCount = new Map();
 async function getOpenPort() {
@@ -32,30 +32,24 @@ async function getOpenPort() {
     });
 }
 async function waitForServer(port, maxAttempts = 30) {
+    const endpoint = `http://127.0.0.1:${port}/api/health`;
     for (let i = 0; i < maxAttempts; i++) {
-        const endpoints = [
-            `http://127.0.0.1:${port}/api/health`,
-            `http://127.0.0.1:${port}/`,
-            `http://127.0.0.1:${port}/api`,
-        ];
-        for (const endpoint of endpoints) {
-            const response = await errore.tryAsync({
-                try: () => fetch(endpoint),
-                catch: (e) => new FetchError({ url: endpoint, cause: e }),
-            });
-            if (response instanceof Error) {
-                // Connection refused or other transient errors - continue polling
-                opencodeLogger.debug(`Server polling attempt failed: ${response.message}`);
-                continue;
-            }
-            if (response.status < 500) {
-                return true;
-            }
-            const body = await response.text();
-            // Fatal errors that won't resolve with retrying
-            if (body.includes('BunInstallFailedError')) {
-                return new ServerStartError({ port, reason: body.slice(0, 200) });
-            }
+        const response = await errore.tryAsync({
+            try: () => fetch(endpoint),
+            catch: (e) => new FetchError({ url: endpoint, cause: e }),
+        });
+        if (response instanceof Error) {
+            // Connection refused or other transient errors - continue polling
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            continue;
+        }
+        if (response.status < 500) {
+            return true;
+        }
+        const body = await response.text();
+        // Fatal errors that won't resolve with retrying
+        if (body.includes('BunInstallFailedError')) {
+            return new ServerStartError({ port, reason: body.slice(0, 200) });
         }
         await new Promise((resolve) => setTimeout(resolve, 1000));
     }

package/dist/session-handler.js

@@ -7,14 +7,14 @@ import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from './discord-utils.js';
 import { formatPart } from './message-formatting.js';
 import { getOpencodeSystemMessage } from './system-message.js';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { isAbortError } from './utils.js';
 import { showAskUserQuestionDropdowns, cancelPendingQuestion, pendingQuestionContexts, } from './commands/ask-question.js';
 import { showPermissionDropdown, cleanupPermissionContext, addPermissionRequestToContext, } from './commands/permissions.js';
 import * as errore from 'errore';
-const sessionLogger = createLogger('SESSION');
-const voiceLogger = createLogger('VOICE');
-const discordLogger = createLogger('DISCORD');
+const sessionLogger = createLogger(LogPrefix.SESSION);
+const voiceLogger = createLogger(LogPrefix.VOICE);
+const discordLogger = createLogger(LogPrefix.DISCORD);
 export const abortControllers = new Map();
 // Track multiple pending permissions per thread (keyed by permission ID)
 // OpenCode handles blocking/sequencing - we just need to track all pending permissions
@@ -56,18 +56,20 @@ export async function abortAndRetrySession({ sessionId, thread, projectDirectory
     }
     sessionLogger.log(`[ABORT+RETRY] Aborting session ${sessionId} for model change`);
     // Abort with special reason so we don't show "completed" message
-    controller.abort('model-change');
+    sessionLogger.log(`[ABORT] reason=model-change sessionId=${sessionId} - user changed model mid-request, will retry with new model`);
+    controller.abort(new Error('model-change'));
     // Also call the API abort endpoint
     const getClient = await initializeOpencodeForDirectory(projectDirectory);
     if (getClient instanceof Error) {
         sessionLogger.error(`[ABORT+RETRY] Failed to initialize OpenCode client:`, getClient.message);
         return false;
     }
+    sessionLogger.log(`[ABORT-API] reason=model-change sessionId=${sessionId} - sending API abort for model change retry`);
     const abortResult = await errore.tryAsync(() => {
         return getClient().session.abort({ path: { id: sessionId } });
     });
     if (abortResult instanceof Error) {
-        sessionLogger.log(`[ABORT+RETRY] API abort call failed (may already be done):`, abortResult);
+        sessionLogger.log(`[ABORT-API] API abort call failed (may already be done):`, abortResult);
     }
     // Small delay to let the abort propagate
     await new Promise((resolve) => {
@@ -176,7 +178,9 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
     const existingController = abortControllers.get(session.id);
     if (existingController) {
         voiceLogger.log(`[ABORT] Cancelling existing request for session: ${session.id}`);
+        sessionLogger.log(`[ABORT] reason=new-request sessionId=${session.id} threadId=${thread.id} - new user message arrived while previous request was still running`);
         existingController.abort(new Error('New request started'));
+        sessionLogger.log(`[ABORT-API] reason=new-request sessionId=${session.id} - sending API abort because new message arrived`);
         const abortResult = await errore.tryAsync(() => {
             return getClient().session.abort({
                 path: { id: session.id },
@@ -184,7 +188,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             });
         });
         if (abortResult instanceof Error) {
-            sessionLogger.log(`[ABORT] Server abort failed (may be already done):`, abortResult);
+            sessionLogger.log(`[ABORT-API] Server abort failed (may be already done):`, abortResult);
         }
     }
     // Auto-reject ALL pending permissions for this thread
@@ -220,10 +224,10 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             await sendThreadMessage(thread, `⚠️ ${rejectedCount} pending permission request${plural} auto-rejected due to new message`);
         }
     }
-    // Cancel any pending question tool if user sends a new message (silently, no thread message)
-    const questionCancelled = await cancelPendingQuestion(thread.id);
-    if (questionCancelled) {
-        sessionLogger.log(`[QUESTION] Cancelled pending question due to new message`);
+    // Answer any pending question tool with the user's message (silently, no thread message)
+    const questionAnswered = await cancelPendingQuestion(thread.id, prompt);
+    if (questionAnswered) {
+        sessionLogger.log(`[QUESTION] Answered pending question with user message`);
     }
     const abortController = new AbortController();
     abortControllers.set(session.id, abortController);
@@ -272,10 +276,14 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
     let usedAgent;
     let tokensUsedInSession = 0;
     let lastDisplayedContextPercentage = 0;
+    let lastRateLimitDisplayTime = 0;
     let modelContextLimit;
     let assistantMessageId;
     let handlerPromise = null;
     let typingInterval = null;
+    let hasSentParts = false;
+    let promptResolved = false;
+    let hasReceivedEvent = false;
     function startTyping() {
         if (abortController.signal.aborted) {
             discordLogger.log(`Not starting typing, already aborted`);
@@ -312,12 +320,14 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             }
         };
     }
-    // Get verbosity setting for this channel (use parent channel for threads)
+    // Read verbosity dynamically so mid-session /verbosity changes take effect immediately
     const verbosityChannelId = channelId || thread.parentId || thread.id;
-    const verbosity = getChannelVerbosity(verbosityChannelId);
+    const getVerbosity = () => {
+        return getChannelVerbosity(verbosityChannelId);
+    };
     const sendPartMessage = async (part) => {
         // In text-only mode, only send text parts (the ⬥ diamond messages)
-        if (verbosity === 'text-only' && part.type !== 'text') {
+        if (getVerbosity() === 'text-only' && part.type !== 'text') {
             return;
         }
         const content = formatPart(part) + '\n\n';
@@ -335,6 +345,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             discordLogger.error(`ERROR: Failed to send part ${part.id}:`, sendResult);
             return;
         }
+        hasSentParts = true;
         sentPartIds.add(part.id);
         getDatabase()
             .prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)')
@@ -391,6 +402,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             if (msg.sessionID !== session.id) {
                 return;
             }
+            hasReceivedEvent = true;
             if (msg.role !== 'assistant') {
                 return;
             }
@@ -476,7 +488,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                         const label = `${agent}-${agentSpawnCounts[agent]}`;
                         subtaskSessions.set(childSessionId, { label, assistantMessageId: undefined });
                         // Skip task messages in text-only mode
-                        if (verbosity !== 'text-only') {
+                        if (getVerbosity() !== 'text-only') {
                             const taskDisplay = `┣ task **${label}** _${description}_`;
                             await sendThreadMessage(thread, taskDisplay + '\n\n');
                         }
@@ -485,7 +497,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 }
                 return;
             }
-            if (part.type === 'tool' && part.state.status === 'completed') {
+            if (part.type === 'tool' && part.state.status === 'completed' && getVerbosity() !== 'text-only') {
                 const output = part.state.output || '';
                 const outputTokens = Math.ceil(output.length / 4);
                 const largeOutputThreshold = 3000;
@@ -531,7 +543,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         };
         const handleSubtaskPart = async (part, subtaskInfo) => {
             // In text-only mode, skip all subtask output (they're tool-related)
-            if (verbosity === 'text-only') {
+            if (getVerbosity() === 'text-only') {
                 return;
             }
             if (part.type === 'step-start' || part.type === 'step-finish') {
@@ -598,10 +610,15 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             }
         };
         const handlePermissionAsked = async (permission) => {
-            if (permission.sessionID !== session.id) {
-                voiceLogger.log(`[PERMISSION IGNORED] Permission for different session (expected: ${session.id}, got: ${permission.sessionID})`);
+            const isMainSession = permission.sessionID === session.id;
+            const isSubtaskSession = subtaskSessions.has(permission.sessionID);
+            if (!isMainSession && !isSubtaskSession) {
+                voiceLogger.log(`[PERMISSION IGNORED] Permission for unknown session (expected: ${session.id} or subtask, got: ${permission.sessionID})`);
                 return;
             }
+            const subtaskLabel = isSubtaskSession
+                ? subtaskSessions.get(permission.sessionID)?.label
+                : undefined;
             const dedupeKey = buildPermissionDedupeKey({ permission, directory });
             const threadPermissions = pendingPermissions.get(thread.id);
             const existingPending = threadPermissions
@@ -634,7 +651,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 }
                 return;
             }
-            sessionLogger.log(`Permission requested: permission=${permission.permission}, patterns=${permission.patterns.join(', ')}`);
+            sessionLogger.log(`Permission requested: permission=${permission.permission}, patterns=${permission.patterns.join(', ')}${subtaskLabel ? `, subtask=${subtaskLabel}` : ''}`);
             if (stopTyping) {
                 stopTyping();
                 stopTyping = null;
@@ -643,6 +660,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 thread,
                 permission,
                 directory,
+                subtaskLabel,
             });
             if (!pendingPermissions.has(thread.id)) {
                 pendingPermissions.set(thread.id, new Map());
@@ -656,7 +674,9 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             });
         };
         const handlePermissionReplied = ({ requestID, reply, sessionID, }) => {
-            if (sessionID !== session.id) {
+            const isMainSession = sessionID === session.id;
+            const isSubtaskSession = subtaskSessions.has(sessionID);
+            if (!isMainSession && !isSubtaskSession) {
                 return;
             }
             sessionLogger.log(`Permission ${requestID} replied with: ${reply}`);
@@ -706,10 +726,11 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             sessionLogger.log(`[QUEUE] Question shown but queue has messages, processing from ${nextMessage.username}`);
             await sendThreadMessage(thread, `» **${nextMessage.username}:** ${nextMessage.prompt.slice(0, 150)}${nextMessage.prompt.length > 150 ? '...' : ''}`);
             setImmediate(() => {
+                const prefixedPrompt = `<discord-user name="${nextMessage.username}" />\n${nextMessage.prompt}`;
                 void errore
                     .tryAsync(async () => {
                     return handleOpencodeSession({
-                        prompt: nextMessage.prompt,
+                        prompt: prefixedPrompt,
                         thread,
                         projectDirectory: directory,
                         images: nextMessage.images,
@@ -725,10 +746,42 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 });
             });
         };
+        const handleSessionStatus = async (properties) => {
+            if (properties.sessionID !== session.id) {
+                return;
+            }
+            if (properties.status.type !== 'retry') {
+                return;
+            }
+            // Throttle to once per 10 seconds
+            const now = Date.now();
+            if (now - lastRateLimitDisplayTime < 10_000) {
+                return;
+            }
+            lastRateLimitDisplayTime = now;
+            const { attempt, message, next } = properties.status;
+            const remainingMs = Math.max(0, next - now);
+            const remainingSec = Math.ceil(remainingMs / 1000);
+            const duration = (() => {
+                if (remainingSec < 60) {
+                    return `${remainingSec}s`;
+                }
+                const mins = Math.floor(remainingSec / 60);
+                const secs = remainingSec % 60;
+                return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
+            })();
+            const chunk = `⬦ ${message} - retrying in ${duration} (attempt #${attempt})`;
+            await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS });
+        };
         const handleSessionIdle = (idleSessionId) => {
             if (idleSessionId === session.id) {
-                sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, aborting`);
-                abortController.abort('finished');
+                if (!promptResolved || !hasReceivedEvent) {
+                    sessionLogger.log(`[SESSION IDLE] Ignoring idle event for ${session.id} (prompt not resolved or no events yet)`);
+                    return;
+                }
+                sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, ending stream`);
+                sessionLogger.log(`[ABORT] reason=finished sessionId=${session.id} threadId=${thread.id} - session completed normally, received idle event after prompt resolved`);
+                abortController.abort(new Error('finished'));
                 return;
             }
             if (!subtaskSessions.has(idleSessionId)) {
@@ -763,6 +816,9 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                     case 'session.idle':
                         handleSessionIdle(event.properties.sessionID);
                         break;
+                    case 'session.status':
+                        await handleSessionStatus(event.properties);
+                        break;
                     default:
                         break;
                 }
@@ -791,7 +847,8 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 stopTyping();
                 stopTyping = null;
             }
-            if (!abortController.signal.aborted || abortController.signal.reason === 'finished') {
+            const abortReason = abortController.signal.reason?.message;
+            if (!abortController.signal.aborted || abortReason === 'finished') {
                 const sessionDuration = prettyMilliseconds(Date.now() - sessionStartTime);
                 const attachCommand = port ? ` ⋅ ${session.id}` : '';
                 const modelInfo = usedModel ? ` ⋅ ${usedModel}` : '';
@@ -845,8 +902,9 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                     // Send the queued message as a new prompt (recursive call)
                     // Use setImmediate to avoid blocking and allow this finally to complete
                     setImmediate(() => {
+                        const prefixedPrompt = `<discord-user name="${nextMessage.username}" />\n${nextMessage.prompt}`;
                         handleOpencodeSession({
-                            prompt: nextMessage.prompt,
+                            prompt: prefixedPrompt,
                             thread,
                             projectDirectory,
                             images: nextMessage.images,
@@ -860,7 +918,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 }
             }
             else {
-                sessionLogger.log(`Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`);
+                sessionLogger.log(`Session was aborted (reason: ${abortReason}), skipping duration message`);
             }
         }
     };
@@ -921,6 +979,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 mainRepoDirectory: worktreeInfo.project_directory,
             }
             : undefined;
+        hasSentParts = false;
         const response = command
             ? await getClient().session.command({
                 path: { id: session.id },
@@ -958,7 +1017,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             })();
             throw new Error(`OpenCode API error (${response.response.status}): ${errorMessage}`);
         }
-        abortController.abort('finished');
+        promptResolved = true;
         sessionLogger.log(`Successfully sent prompt, got response`);
         if (originalMessage) {
             const reactionResult = await errore.tryAsync(async () => {
@@ -987,7 +1046,8 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         return;
     }
     sessionLogger.error(`ERROR: Failed to send prompt:`, promptError);
-    abortController.abort('error');
+    sessionLogger.log(`[ABORT] reason=error sessionId=${session.id} threadId=${thread.id} - prompt failed with error: ${promptError.message}`);
+    abortController.abort(new Error('error'));
     if (originalMessage) {
         const reactionResult = await errore.tryAsync(async () => {
             await originalMessage.reactions.removeAll();