kimaki 0.4.49 → 0.4.50

package/dist/cli.js

@@ -299,7 +299,7 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
                 .setName('level')
                 .setDescription('Verbosity level')
                 .setRequired(true)
-                .addChoices({ name: 'tools-and-text (default)', value: 'tools-and-text' }, { name: 'text-only', value: 'text-only' });
+                .addChoices({ name: 'tools-and-text (default)', value: 'tools-and-text' }, { name: 'text-and-essential-tools', value: 'text-and-essential-tools' }, { name: 'text-only', value: 'text-only' });
             return option;
         })
             .toJSON(),
@@ -823,7 +823,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)')
+    .option('--verbosity <level>', 'Default verbosity for all channels (tools-and-text, text-and-essential-tools, or text-only)')
     .action(async (options) => {
     try {
         // Set data directory early, before any database access
@@ -832,8 +832,9 @@ 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".`);
+            const validLevels = ['tools-and-text', 'text-and-essential-tools', 'text-only'];
+            if (!validLevels.includes(options.verbosity)) {
+                cliLogger.error(`Invalid verbosity level: ${options.verbosity}. Use one of: ${validLevels.join(', ')}`);
                 process.exit(EXIT_NO_RESTART);
             }
             setDefaultVerbosity(options.verbosity);

package/dist/commands/verbosity.js

@@ -43,9 +43,15 @@ export async function handleVerbosityCommand({ command, appId, }) {
     }
     setChannelVerbosity(channelId, level);
     verbosityLogger.log(`[VERBOSITY] Set channel ${channelId} to ${level}`);
-    const description = level === 'text-only'
-        ? 'Only text responses will be shown. Tool executions, status messages, and thinking will be hidden.'
-        : 'All output will be shown, including tool executions and status messages.';
+    const description = (() => {
+        if (level === 'text-only') {
+            return 'Only text responses will be shown. Tool executions, status messages, and thinking will be hidden.';
+        }
+        if (level === 'text-and-essential-tools') {
+            return 'Text responses and essential tools (edits, custom MCP tools) will be shown. Read, search, and navigation tools will be hidden.';
+        }
+        return 'All output will be shown, including tool executions and status messages.';
+    })();
     await command.reply({
         content: `Verbosity set to **${level}** for this channel.\n${description}\nThis is a per-channel setting and applies immediately, including any active sessions.`,
         ephemeral: true,

package/dist/image-utils.js

@@ -0,0 +1,107 @@
+// Image processing utilities for Discord attachments.
+// Uses sharp (optional) to resize large images and heic-convert (optional) for HEIC support.
+// Falls back gracefully if dependencies are not available.
+import { createLogger, LogPrefix } from './logger.js';
+const logger = createLogger(LogPrefix.FORMATTING);
+const MAX_DIMENSION = 1500;
+const HEIC_MIME_TYPES = ['image/heic', 'image/heif', 'image/heic-sequence', 'image/heif-sequence'];
+let sharpModule = undefined;
+let heicConvertModule = undefined;
+async function tryLoadSharp() {
+    if (sharpModule !== undefined) {
+        return sharpModule;
+    }
+    try {
+        sharpModule = (await import('sharp')).default;
+        logger.log('sharp loaded successfully');
+        return sharpModule;
+    }
+    catch {
+        logger.log('sharp not available, images will be sent at original size');
+        sharpModule = null;
+        return null;
+    }
+}
+async function tryLoadHeicConvert() {
+    if (heicConvertModule !== undefined) {
+        return heicConvertModule;
+    }
+    try {
+        const mod = await import('heic-convert');
+        heicConvertModule = mod.default;
+        logger.log('heic-convert loaded successfully');
+        return heicConvertModule;
+    }
+    catch {
+        logger.log('heic-convert not available, HEIC images will be sent as-is');
+        heicConvertModule = null;
+        return null;
+    }
+}
+function isHeicMime(mime) {
+    return HEIC_MIME_TYPES.includes(mime.toLowerCase());
+}
+export async function processImage(buffer, mime) {
+    // Skip non-images (PDFs, etc.)
+    if (!mime.startsWith('image/')) {
+        return { buffer, mime };
+    }
+    let workingBuffer = buffer;
+    let workingMime = mime;
+    // Handle HEIC conversion first (before sharp, since sharp doesn't support HEIC)
+    if (isHeicMime(mime)) {
+        const heicConvert = await tryLoadHeicConvert();
+        if (heicConvert) {
+            try {
+                const outputArrayBuffer = await heicConvert({
+                    buffer: workingBuffer.buffer.slice(workingBuffer.byteOffset, workingBuffer.byteOffset + workingBuffer.byteLength),
+                    format: 'JPEG',
+                    quality: 0.85,
+                });
+                workingBuffer = Buffer.from(outputArrayBuffer);
+                workingMime = 'image/jpeg';
+                logger.log(`Converted HEIC to JPEG (${buffer.length} → ${workingBuffer.length} bytes)`);
+            }
+            catch (error) {
+                logger.error('Failed to convert HEIC, sending original:', error);
+                return { buffer, mime };
+            }
+        }
+        else {
+            // No heic-convert available, return original (LLM might not support it)
+            logger.log('HEIC image detected but heic-convert not available, sending as-is');
+            return { buffer, mime };
+        }
+    }
+    // Now process with sharp (resize + ensure JPEG output)
+    const sharp = await tryLoadSharp();
+    if (!sharp) {
+        return { buffer: workingBuffer, mime: workingMime };
+    }
+    try {
+        const image = sharp(workingBuffer);
+        const metadata = await image.metadata();
+        const { width, height } = metadata;
+        const needsResize = width && height && (width > MAX_DIMENSION || height > MAX_DIMENSION);
+        if (!needsResize) {
+            // Still convert to JPEG for consistency (unless already JPEG from HEIC conversion)
+            const outputBuffer = await image.jpeg({ quality: 85 }).toBuffer();
+            logger.log(`Converted image to JPEG: ${width}x${height} (${outputBuffer.length} bytes)`);
+            return { buffer: outputBuffer, mime: 'image/jpeg' };
+        }
+        // Resize and convert to JPEG
+        const outputBuffer = await image
+            .resize(MAX_DIMENSION, MAX_DIMENSION, {
+            fit: 'inside',
+            withoutEnlargement: true,
+        })
+            .jpeg({ quality: 85 })
+            .toBuffer();
+        logger.log(`Resized image: ${width}x${height} → max ${MAX_DIMENSION}px (${outputBuffer.length} bytes)`);
+        return { buffer: outputBuffer, mime: 'image/jpeg' };
+    }
+    catch (error) {
+        logger.error('Failed to process image with sharp, using working buffer:', error);
+        return { buffer: workingBuffer, mime: workingMime };
+    }
+}

package/dist/message-formatting.js

@@ -1,12 +1,10 @@
 // OpenCode message part formatting for Discord.
 // Converts SDK message parts (text, tools, reasoning) to Discord-friendly format,
 // handles file attachments, and provides tool summary generation.
-import fs from 'node:fs';
-import path from 'node:path';
 import * as errore from 'errore';
 import { createLogger, LogPrefix } from './logger.js';
 import { FetchError } from './errors.js';
-const ATTACHMENTS_DIR = path.join(process.cwd(), 'tmp', 'discord-attachments');
+import { processImage } from './image-utils.js';
 const logger = createLogger(LogPrefix.FORMATTING);
 /**
  * Escapes Discord inline markdown characters so dynamic content
@@ -148,10 +146,6 @@ export async function getFileAttachments(message) {
     if (fileAttachments.length === 0) {
         return [];
     }
-    // ensure tmp directory exists
-    if (!fs.existsSync(ATTACHMENTS_DIR)) {
-        fs.mkdirSync(ATTACHMENTS_DIR, { recursive: true });
-    }
     const results = await Promise.all(fileAttachments.map(async (attachment) => {
         const response = await errore.tryAsync({
             try: () => fetch(attachment.url),
@@ -165,15 +159,18 @@ export async function getFileAttachments(message) {
             logger.error(`Failed to fetch attachment ${attachment.name}: ${response.status}`);
             return null;
         }
-        const buffer = Buffer.from(await response.arrayBuffer());
-        const localPath = path.join(ATTACHMENTS_DIR, `${message.id}-${attachment.name}`);
-        fs.writeFileSync(localPath, buffer);
-        logger.log(`Downloaded attachment to ${localPath}`);
+        const rawBuffer = Buffer.from(await response.arrayBuffer());
+        const originalMime = attachment.contentType || 'application/octet-stream';
+        // Process image (resize if needed, convert to JPEG)
+        const { buffer, mime } = await processImage(rawBuffer, originalMime);
+        const base64 = buffer.toString('base64');
+        const dataUrl = `data:${mime};base64,${base64}`;
+        logger.log(`Attachment ${attachment.name}: ${rawBuffer.length} → ${buffer.length} bytes, ${mime}`);
         return {
             type: 'file',
-            mime: attachment.contentType || 'application/octet-stream',
+            mime,
             filename: attachment.name,
-            url: localPath,
+            url: dataUrl,
         };
     }));
     return results.filter((r) => r !== null);

package/dist/session-handler.js

@@ -16,6 +16,21 @@ const sessionLogger = createLogger(LogPrefix.SESSION);
 const voiceLogger = createLogger(LogPrefix.VOICE);
 const discordLogger = createLogger(LogPrefix.DISCORD);
 export const abortControllers = new Map();
+// Built-in tools that are hidden in text-and-essential-tools verbosity mode.
+// Essential tools (edits, bash, todos, tasks, custom MCP tools) are shown; these navigation/read tools are hidden.
+const NON_ESSENTIAL_TOOLS = new Set([
+    'read',
+    'list',
+    'glob',
+    'grep',
+    'todoread',
+    'skill',
+    'question',
+    'webfetch',
+]);
+function isEssentialTool(toolName) {
+    return !NON_ESSENTIAL_TOOLS.has(toolName);
+}
 // Track multiple pending permissions per thread (keyed by permission ID)
 // OpenCode handles blocking/sequencing - we just need to track all pending permissions
 // to avoid duplicates and properly clean up on auto-reject
@@ -326,10 +341,23 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         return getChannelVerbosity(verbosityChannelId);
     };
     const sendPartMessage = async (part) => {
+        const verbosity = getVerbosity();
         // In text-only mode, only send text parts (the ⬥ diamond messages)
-        if (getVerbosity() === 'text-only' && part.type !== 'text') {
+        if (verbosity === 'text-only' && part.type !== 'text') {
             return;
         }
+        // In text-and-essential-tools mode, show text + essential tools (edits, custom MCP tools)
+        if (verbosity === 'text-and-essential-tools') {
+            if (part.type === 'text') {
+                // text is always shown
+            }
+            else if (part.type === 'tool' && isEssentialTool(part.tool)) {
+                // essential tools are shown
+            }
+            else {
+                return;
+            }
+        }
         const content = formatPart(part) + '\n\n';
         if (!content.trim() || content.length === 0) {
             // discordLogger.log(`SKIP: Part ${part.id} has no content`)
@@ -487,7 +515,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                         agentSpawnCounts[agent] = (agentSpawnCounts[agent] || 0) + 1;
                         const label = `${agent}-${agentSpawnCounts[agent]}`;
                         subtaskSessions.set(childSessionId, { label, assistantMessageId: undefined });
-                        // Skip task messages in text-only mode
+                        // Show task messages in tools-and-text and text-and-essential-tools modes
                         if (getVerbosity() !== 'text-only') {
                             const taskDisplay = `┣ task **${label}** _${description}_`;
                             await sendThreadMessage(thread, taskDisplay + '\n\n');
@@ -497,24 +525,37 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 }
                 return;
             }
-            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;
-                if (outputTokens >= largeOutputThreshold) {
-                    const formattedTokens = outputTokens >= 1000 ? `${(outputTokens / 1000).toFixed(1)}k` : String(outputTokens);
-                    const percentageSuffix = (() => {
-                        if (!modelContextLimit) {
-                            return '';
-                        }
-                        const pct = (outputTokens / modelContextLimit) * 100;
-                        if (pct < 1) {
-                            return '';
-                        }
-                        return ` (${pct.toFixed(1)}%)`;
-                    })();
-                    const chunk = `⬦ ${part.tool} returned ${formattedTokens} tokens${percentageSuffix}`;
-                    await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS });
+            // Show large output notifications for tools that are visible in current verbosity mode
+            if (part.type === 'tool' && part.state.status === 'completed') {
+                const showLargeOutput = (() => {
+                    const verbosity = getVerbosity();
+                    if (verbosity === 'text-only') {
+                        return false;
+                    }
+                    if (verbosity === 'text-and-essential-tools') {
+                        return isEssentialTool(part.tool);
+                    }
+                    return true;
+                })();
+                if (showLargeOutput) {
+                    const output = part.state.output || '';
+                    const outputTokens = Math.ceil(output.length / 4);
+                    const largeOutputThreshold = 3000;
+                    if (outputTokens >= largeOutputThreshold) {
+                        const formattedTokens = outputTokens >= 1000 ? `${(outputTokens / 1000).toFixed(1)}k` : String(outputTokens);
+                        const percentageSuffix = (() => {
+                            if (!modelContextLimit) {
+                                return '';
+                            }
+                            const pct = (outputTokens / modelContextLimit) * 100;
+                            if (pct < 1) {
+                                return '';
+                            }
+                            return ` (${pct.toFixed(1)}%)`;
+                        })();
+                        const chunk = `⬦ ${part.tool} returned ${formattedTokens} tokens${percentageSuffix}`;
+                        await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS });
+                    }
                 }
             }
             if (part.type === 'reasoning') {
@@ -542,10 +583,17 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             }
         };
         const handleSubtaskPart = async (part, subtaskInfo) => {
+            const verbosity = getVerbosity();
             // In text-only mode, skip all subtask output (they're tool-related)
-            if (getVerbosity() === 'text-only') {
+            if (verbosity === 'text-only') {
                 return;
             }
+            // In text-and-essential-tools mode, only show essential tools from subtasks
+            if (verbosity === 'text-and-essential-tools') {
+                if (part.type !== 'tool' || !isEssentialTool(part.tool)) {
+                    return;
+                }
+            }
             if (part.type === 'step-start' || part.type === 'step-finish') {
                 return;
             }
@@ -943,10 +991,11 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({
                 mime: img.mime,
                 filename: img.filename,
-                url: img.url.slice(0, 100),
+                urlPreview: img.url.slice(0, 50) + '...',
             })));
-            const imagePathsList = images.map((img) => `- ${img.filename}: ${img.url}`).join('\n');
-            return `${prompt}\n\n**attached images:**\n${imagePathsList}`;
+            // Just list filenames, not the full base64 URLs (images are passed as separate parts)
+            const imageList = images.map((img) => `- ${img.filename}`).join('\n');
+            return `${prompt}\n\n**attached images:**\n${imageList}`;
         })();
         const parts = [{ type: 'text', text: promptWithImagePaths }, ...images];
         sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.49",
+  "version": "0.4.50",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -14,6 +14,7 @@
     "@opencode-ai/plugin": "^1.1.12",
     "@types/better-sqlite3": "^7.6.13",
     "@types/bun": "latest",
+    "@types/heic-convert": "^2.1.0",
     "@types/js-yaml": "^4.0.9",
     "@types/ms": "^2.1.0",
     "@types/node": "^24.3.0",
@@ -45,7 +46,9 @@
   },
   "optionalDependencies": {
     "@discordjs/opus": "^0.10.0",
-    "prism-media": "^1.3.5"
+    "heic-convert": "^2.1.0",
+    "prism-media": "^1.3.5",
+    "sharp": "^0.34.5"
   },
   "scripts": {
     "dev": "tsx --env-file .env src/cli.ts",

package/src/cli.ts

@@ -390,6 +390,7 @@ async function registerCommands({
           .setRequired(true)
           .addChoices(
             { name: 'tools-and-text (default)', value: 'tools-and-text' },
+            { name: 'text-and-essential-tools', value: 'text-and-essential-tools' },
             { name: 'text-only', value: 'text-only' },
           )
         return option
@@ -1122,7 +1123,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)')
+  .option('--verbosity <level>', 'Default verbosity for all channels (tools-and-text, text-and-essential-tools, or text-only)')
   .action(
     async (options: {
       restart?: boolean
@@ -1140,11 +1141,12 @@ cli
         }
 
         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".`)
+          const validLevels = ['tools-and-text', 'text-and-essential-tools', 'text-only']
+          if (!validLevels.includes(options.verbosity)) {
+            cliLogger.error(`Invalid verbosity level: ${options.verbosity}. Use one of: ${validLevels.join(', ')}`)
             process.exit(EXIT_NO_RESTART)
           }
-          setDefaultVerbosity(options.verbosity)
+          setDefaultVerbosity(options.verbosity as 'tools-and-text' | 'text-and-essential-tools' | 'text-only')
           cliLogger.log(`Default verbosity: ${options.verbosity}`)
         }
 

package/src/commands/verbosity.ts

@@ -60,9 +60,15 @@ export async function handleVerbosityCommand({
   setChannelVerbosity(channelId, level)
   verbosityLogger.log(`[VERBOSITY] Set channel ${channelId} to ${level}`)
 
-  const description = level === 'text-only'
-    ? 'Only text responses will be shown. Tool executions, status messages, and thinking will be hidden.'
-    : 'All output will be shown, including tool executions and status messages.'
+  const description = (() => {
+    if (level === 'text-only') {
+      return 'Only text responses will be shown. Tool executions, status messages, and thinking will be hidden.'
+    }
+    if (level === 'text-and-essential-tools') {
+      return 'Text responses and essential tools (edits, custom MCP tools) will be shown. Read, search, and navigation tools will be hidden.'
+    }
+    return 'All output will be shown, including tool executions and status messages.'
+  })()
 
   await command.reply({
     content: `Verbosity set to **${level}** for this channel.\n${description}\nThis is a per-channel setting and applies immediately, including any active sessions.`,

package/src/database.ts

@@ -363,7 +363,10 @@ export function runWorktreeSettingsMigrations(database?: Database.Database): voi
 }
 
 // Verbosity levels for controlling output detail
-export type VerbosityLevel = 'tools-and-text' | 'text-only'
+// - tools-and-text: shows all output including tool executions
+// - text-and-essential-tools: shows text + edits + custom MCP tools, hides read/search/navigation tools
+// - text-only: only shows text responses (⬥ diamond parts)
+export type VerbosityLevel = 'tools-and-text' | 'text-and-essential-tools' | 'text-only'
 
 export function runVerbosityMigrations(database?: Database.Database): void {
   const targetDb = database || getDatabase()

package/src/image-utils.ts

@@ -0,0 +1,132 @@
+// Image processing utilities for Discord attachments.
+// Uses sharp (optional) to resize large images and heic-convert (optional) for HEIC support.
+// Falls back gracefully if dependencies are not available.
+
+import { createLogger, LogPrefix } from './logger.js'
+
+const logger = createLogger(LogPrefix.FORMATTING)
+
+const MAX_DIMENSION = 1500
+const HEIC_MIME_TYPES = ['image/heic', 'image/heif', 'image/heic-sequence', 'image/heif-sequence']
+
+type SharpModule = typeof import('sharp')
+type HeicConvertFn = (options: {
+  buffer: ArrayBufferLike
+  format: 'JPEG' | 'PNG'
+  quality?: number
+}) => Promise<ArrayBuffer>
+
+let sharpModule: SharpModule | null | undefined = undefined
+let heicConvertModule: HeicConvertFn | null | undefined = undefined
+
+async function tryLoadSharp(): Promise<SharpModule | null> {
+  if (sharpModule !== undefined) {
+    return sharpModule
+  }
+  try {
+    sharpModule = (await import('sharp')).default as unknown as SharpModule
+    logger.log('sharp loaded successfully')
+    return sharpModule
+  } catch {
+    logger.log('sharp not available, images will be sent at original size')
+    sharpModule = null
+    return null
+  }
+}
+
+async function tryLoadHeicConvert(): Promise<HeicConvertFn | null> {
+  if (heicConvertModule !== undefined) {
+    return heicConvertModule
+  }
+  try {
+    const mod = await import('heic-convert')
+    heicConvertModule = mod.default as HeicConvertFn
+    logger.log('heic-convert loaded successfully')
+    return heicConvertModule
+  } catch {
+    logger.log('heic-convert not available, HEIC images will be sent as-is')
+    heicConvertModule = null
+    return null
+  }
+}
+
+function isHeicMime(mime: string): boolean {
+  return HEIC_MIME_TYPES.includes(mime.toLowerCase())
+}
+
+export async function processImage(
+  buffer: Buffer,
+  mime: string,
+): Promise<{ buffer: Buffer; mime: string }> {
+  // Skip non-images (PDFs, etc.)
+  if (!mime.startsWith('image/')) {
+    return { buffer, mime }
+  }
+
+  let workingBuffer = buffer
+  let workingMime = mime
+
+  // Handle HEIC conversion first (before sharp, since sharp doesn't support HEIC)
+  if (isHeicMime(mime)) {
+    const heicConvert = await tryLoadHeicConvert()
+    if (heicConvert) {
+      try {
+        const outputArrayBuffer = await heicConvert({
+          buffer: workingBuffer.buffer.slice(
+            workingBuffer.byteOffset,
+            workingBuffer.byteOffset + workingBuffer.byteLength,
+          ),
+          format: 'JPEG',
+          quality: 0.85,
+        })
+        workingBuffer = Buffer.from(outputArrayBuffer)
+        workingMime = 'image/jpeg'
+        logger.log(`Converted HEIC to JPEG (${buffer.length} → ${workingBuffer.length} bytes)`)
+      } catch (error) {
+        logger.error('Failed to convert HEIC, sending original:', error)
+        return { buffer, mime }
+      }
+    } else {
+      // No heic-convert available, return original (LLM might not support it)
+      logger.log('HEIC image detected but heic-convert not available, sending as-is')
+      return { buffer, mime }
+    }
+  }
+
+  // Now process with sharp (resize + ensure JPEG output)
+  const sharp = await tryLoadSharp()
+  if (!sharp) {
+    return { buffer: workingBuffer, mime: workingMime }
+  }
+
+  try {
+    const image = sharp(workingBuffer)
+    const metadata = await image.metadata()
+    const { width, height } = metadata
+
+    const needsResize = width && height && (width > MAX_DIMENSION || height > MAX_DIMENSION)
+
+    if (!needsResize) {
+      // Still convert to JPEG for consistency (unless already JPEG from HEIC conversion)
+      const outputBuffer = await image.jpeg({ quality: 85 }).toBuffer()
+      logger.log(`Converted image to JPEG: ${width}x${height} (${outputBuffer.length} bytes)`)
+      return { buffer: outputBuffer, mime: 'image/jpeg' }
+    }
+
+    // Resize and convert to JPEG
+    const outputBuffer = await image
+      .resize(MAX_DIMENSION, MAX_DIMENSION, {
+        fit: 'inside',
+        withoutEnlargement: true,
+      })
+      .jpeg({ quality: 85 })
+      .toBuffer()
+
+    logger.log(`Resized image: ${width}x${height} → max ${MAX_DIMENSION}px (${outputBuffer.length} bytes)`)
+
+    return { buffer: outputBuffer, mime: 'image/jpeg' }
+  } catch (error) {
+    logger.error('Failed to process image with sharp, using working buffer:', error)
+    return { buffer: workingBuffer, mime: workingMime }
+  }
+}

package/src/message-formatting.ts

@@ -5,11 +5,10 @@
 import type { Part } from '@opencode-ai/sdk/v2'
 import type { FilePartInput } from '@opencode-ai/sdk'
 import type { Message } from 'discord.js'
-import fs from 'node:fs'
-import path from 'node:path'
 import * as errore from 'errore'
 import { createLogger, LogPrefix } from './logger.js'
 import { FetchError } from './errors.js'
+import { processImage } from './image-utils.js'
 
 // Generic message type compatible with both v1 and v2 SDK
 type GenericSessionMessage = {
@@ -17,8 +16,6 @@ type GenericSessionMessage = {
   parts: Part[]
 }
 
-const ATTACHMENTS_DIR = path.join(process.cwd(), 'tmp', 'discord-attachments')
-
 const logger = createLogger(LogPrefix.FORMATTING)
 
 /**
@@ -192,11 +189,6 @@ export async function getFileAttachments(message: Message): Promise<FilePartInpu
     return []
   }
 
-  // ensure tmp directory exists
-  if (!fs.existsSync(ATTACHMENTS_DIR)) {
-    fs.mkdirSync(ATTACHMENTS_DIR, { recursive: true })
-  }
-
   const results = await Promise.all(
     fileAttachments.map(async (attachment) => {
       const response = await errore.tryAsync({
@@ -212,17 +204,22 @@ export async function getFileAttachments(message: Message): Promise<FilePartInpu
         return null
       }
 
-      const buffer = Buffer.from(await response.arrayBuffer())
-      const localPath = path.join(ATTACHMENTS_DIR, `${message.id}-${attachment.name}`)
-      fs.writeFileSync(localPath, buffer)
+      const rawBuffer = Buffer.from(await response.arrayBuffer())
+      const originalMime = attachment.contentType || 'application/octet-stream'
+
+      // Process image (resize if needed, convert to JPEG)
+      const { buffer, mime } = await processImage(rawBuffer, originalMime)
+
+      const base64 = buffer.toString('base64')
+      const dataUrl = `data:${mime};base64,${base64}`
 
-      logger.log(`Downloaded attachment to ${localPath}`)
+      logger.log(`Attachment ${attachment.name}: ${rawBuffer.length} → ${buffer.length} bytes, ${mime}`)
 
       return {
         type: 'file' as const,
-        mime: attachment.contentType || 'application/octet-stream',
+        mime,
         filename: attachment.name,
-        url: localPath,
+        url: dataUrl,
       }
     }),
   )

package/src/session-handler.ts

@@ -44,6 +44,23 @@ const discordLogger = createLogger(LogPrefix.DISCORD)
 
 export const abortControllers = new Map<string, AbortController>()
 
+// Built-in tools that are hidden in text-and-essential-tools verbosity mode.
+// Essential tools (edits, bash, todos, tasks, custom MCP tools) are shown; these navigation/read tools are hidden.
+const NON_ESSENTIAL_TOOLS = new Set([
+  'read',
+  'list',
+  'glob',
+  'grep',
+  'todoread',
+  'skill',
+  'question',
+  'webfetch',
+])
+
+function isEssentialTool(toolName: string): boolean {
+  return !NON_ESSENTIAL_TOOLS.has(toolName)
+}
+
 // Track multiple pending permissions per thread (keyed by permission ID)
 // OpenCode handles blocking/sequencing - we just need to track all pending permissions
 // to avoid duplicates and properly clean up on auto-reject
@@ -484,10 +501,21 @@ export async function handleOpencodeSession({
   }
 
   const sendPartMessage = async (part: Part) => {
+    const verbosity = getVerbosity()
     // In text-only mode, only send text parts (the ⬥ diamond messages)
-    if (getVerbosity() === 'text-only' && part.type !== 'text') {
+    if (verbosity === 'text-only' && part.type !== 'text') {
       return
     }
+    // In text-and-essential-tools mode, show text + essential tools (edits, custom MCP tools)
+    if (verbosity === 'text-and-essential-tools') {
+      if (part.type === 'text') {
+        // text is always shown
+      } else if (part.type === 'tool' && isEssentialTool(part.tool)) {
+        // essential tools are shown
+      } else {
+        return
+      }
+    }
 
     const content = formatPart(part) + '\n\n'
     if (!content.trim() || content.length === 0) {
@@ -697,7 +725,7 @@ export async function handleOpencodeSession({
             agentSpawnCounts[agent] = (agentSpawnCounts[agent] || 0) + 1
             const label = `${agent}-${agentSpawnCounts[agent]}`
             subtaskSessions.set(childSessionId, { label, assistantMessageId: undefined })
-            // Skip task messages in text-only mode
+            // Show task messages in tools-and-text and text-and-essential-tools modes
             if (getVerbosity() !== 'text-only') {
               const taskDisplay = `┣ task **${label}** _${description}_`
               await sendThreadMessage(thread, taskDisplay + '\n\n')
@@ -708,25 +736,38 @@ export async function handleOpencodeSession({
         return
       }
 
-      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
-        if (outputTokens >= largeOutputThreshold) {
-          const formattedTokens =
-            outputTokens >= 1000 ? `${(outputTokens / 1000).toFixed(1)}k` : String(outputTokens)
-          const percentageSuffix = (() => {
-            if (!modelContextLimit) {
-              return ''
-            }
-            const pct = (outputTokens / modelContextLimit) * 100
-            if (pct < 1) {
-              return ''
-            }
-            return ` (${pct.toFixed(1)}%)`
-          })()
-          const chunk = `⬦ ${part.tool} returned ${formattedTokens} tokens${percentageSuffix}`
-          await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
+      // Show large output notifications for tools that are visible in current verbosity mode
+      if (part.type === 'tool' && part.state.status === 'completed') {
+        const showLargeOutput = (() => {
+          const verbosity = getVerbosity()
+          if (verbosity === 'text-only') {
+            return false
+          }
+          if (verbosity === 'text-and-essential-tools') {
+            return isEssentialTool(part.tool)
+          }
+          return true
+        })()
+        if (showLargeOutput) {
+          const output = part.state.output || ''
+          const outputTokens = Math.ceil(output.length / 4)
+          const largeOutputThreshold = 3000
+          if (outputTokens >= largeOutputThreshold) {
+            const formattedTokens =
+              outputTokens >= 1000 ? `${(outputTokens / 1000).toFixed(1)}k` : String(outputTokens)
+            const percentageSuffix = (() => {
+              if (!modelContextLimit) {
+                return ''
+              }
+              const pct = (outputTokens / modelContextLimit) * 100
+              if (pct < 1) {
+                return ''
+              }
+              return ` (${pct.toFixed(1)}%)`
+            })()
+            const chunk = `⬦ ${part.tool} returned ${formattedTokens} tokens${percentageSuffix}`
+            await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
+          }
         }
       }
 
@@ -761,10 +802,17 @@ export async function handleOpencodeSession({
       part: Part,
       subtaskInfo: { label: string; assistantMessageId?: string },
     ) => {
+      const verbosity = getVerbosity()
       // In text-only mode, skip all subtask output (they're tool-related)
-      if (getVerbosity() === 'text-only') {
+      if (verbosity === 'text-only') {
         return
       }
+      // In text-and-essential-tools mode, only show essential tools from subtasks
+      if (verbosity === 'text-and-essential-tools') {
+        if (part.type !== 'tool' || !isEssentialTool(part.tool)) {
+          return
+        }
+      }
       if (part.type === 'step-start' || part.type === 'step-finish') {
         return
       }
@@ -1275,11 +1323,12 @@ export async function handleOpencodeSession({
         images.map((img) => ({
           mime: img.mime,
           filename: img.filename,
-          url: img.url.slice(0, 100),
+          urlPreview: img.url.slice(0, 50) + '...',
         })),
       )
-      const imagePathsList = images.map((img) => `- ${img.filename}: ${img.url}`).join('\n')
-      return `${prompt}\n\n**attached images:**\n${imagePathsList}`
+      // Just list filenames, not the full base64 URLs (images are passed as separate parts)
+      const imageList = images.map((img) => `- ${img.filename}`).join('\n')
+      return `${prompt}\n\n**attached images:**\n${imageList}`
     })()
 
     const parts = [{ type: 'text' as const, text: promptWithImagePaths }, ...images]