obol-ai 0.2.9 → 0.2.11

package/.claude/settings.local.json

@@ -15,7 +15,8 @@
       "Bash(git -C /Users/jovinkenroye/Sites/obol add:*)",
       "Bash(git -C:*)",
       "Bash(pass ls:*)",
-      "mcp__context7__query-docs"
+      "mcp__context7__query-docs",
+      "Bash(git stash pop:*)"
     ]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obol-ai",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Self-evolving AI assistant that learns, remembers, and acts on its own. Persistent vector memory, self-rewriting personality, proactive heartbeats.",
   "main": "src/index.js",
   "bin": {
@@ -30,6 +30,7 @@
     "inquirer": "^8.2.6",
     "node-cron": "^3.0.3",
     "open": "^8.4.2",
+    "pdf-parse": "^2.4.5",
     "pdfkit": "^0.17.2"
   },
   "engines": {

package/src/claude.js

@@ -8,7 +8,7 @@ const { execAsync, isAllowedUrl } = require('./sanitize');
 const { ChatHistory } = require('./history');
 
 const MAX_EXEC_TIMEOUT = 120;
-let MAX_TOOL_ITERATIONS = 100;
+let MAX_TOOL_ITERATIONS = 10;
 
 const BLOCKED_EXEC_PATTERNS = [
   /\brm\s+(-[a-zA-Z]*f|-[a-zA-Z]*r|--force|--recursive)\b/,
@@ -204,6 +204,12 @@ Model: Default to "sonnet". Use "haiku" for: greetings, brief acknowledgments (t
 
         vlog(`[router] model=${decision.model || 'sonnet'} memory=${decision.need_memory || false}${decision.search_query ? ` query="${decision.search_query}"` : ''}`);
 
+        context._onRouteDecision?.({
+          model: decision.model || 'sonnet',
+          needMemory: decision.need_memory || false,
+          memoryCount: 0,
+        });
+
         if (decision.model === 'opus') {
           context._model = 'claude-opus-4-6';
         } else if (decision.model === 'haiku') {
@@ -227,6 +233,8 @@ Model: Default to "sonnet". Use "haiku" for: greetings, brief acknowledgments (t
 
           vlog(`[memory] ${combined.length} memories found (${todayMemories.length} today, ${semanticMemories.length} semantic)`);
 
+          context._onRouteUpdate?.({ memoryCount: combined.length });
+
           if (combined.length > 0) {
             memoryContext = '\n\n[Relevant memories]\n' +
               combined.map(m => `- [${m.category}] ${m.content}`).join('\n');
@@ -298,7 +306,22 @@ Model: Default to "sonnet". Use "haiku" for: greetings, brief acknowledgments (t
       return { text, usage: totalUsage, model };
     }
 
-    const text = finalMessage.content.filter(b => b.type === 'text').map(b => b.text).join('\n');
+    let text = finalMessage.content.filter(b => b.type === 'text').map(b => b.text).join('\n');
+
+    if (!text.trim() && newMessages.length > 1) {
+      vlog('[claude] No text in final response after tool use — forcing summary');
+      histories.pushUser(chatId, 'Provide a concise response to the user based on the tool results above.');
+      const summaryResponse = await client.messages.create({
+        model, max_tokens: 4096, system: systemPrompt, messages: [...histories.get(chatId)],
+      }, { signal: abortController.signal });
+      histories.pushAssistant(chatId, summaryResponse.content);
+      if (summaryResponse.usage) {
+        totalUsage.input_tokens += summaryResponse.usage.input_tokens || 0;
+        totalUsage.output_tokens += summaryResponse.usage.output_tokens || 0;
+      }
+      text = summaryResponse.content.filter(b => b.type === 'text').map(b => b.text).join('\n');
+    }
+
     return { text, usage: totalUsage, model };
 
     } catch (e) {
@@ -537,26 +560,39 @@ Only available if bridge is enabled. Communicate with partner's AI agent.
   parts.push(`
 ## Telegram Formatting
 
-You communicate via Telegram. Format responses for mobile readability.
-
-**Never use markdown tables** — pipe-syntax tables do not render in Telegram. Use numbered lists instead.
-
-**Email/inbox lists** — use this pattern:
-\`\`\`
+You communicate via Telegram. Use ONLY Telegram Markdown syntax — never GitHub-flavored Markdown.
+
+ALLOWED formatting:
+- *bold* (single asterisks)
+- _italic_ (underscores)
+- \`inline code\` (backticks)
+- \`\`\`code blocks\`\`\` (triple backticks)
+
+FORBIDDEN formatting — these do NOT render in Telegram:
+- **double asterisks** — use *single asterisks* instead
+- ## headings — use *bold text* on its own line instead
+- --- horizontal rules — use a blank line instead
+- [text](url) links — just paste the raw URL
+- > blockquotes — not supported
+
+Structure tips:
+- Break content into short paragraphs with blank lines
+- Use *bold* sparingly for section titles on their own line
+- Use numbered lists (1. 2. 3.) or bullet dashes (- item)
+- Keep lines short — Telegram wraps poorly on mobile
+- Never use markdown tables — use numbered lists instead
+
+*Email/inbox lists* — use this pattern:
 📬 *Inbox (10)*
 
 1\\. *Google* — Security alert \`22:58\`
 2\\. *LinkedIn* — Matthew Chittle wants to connect \`21:31\`
 3\\. *DeepLearning\\.AI* — AI Dev 26 × SF speakers \`13:20\`
-4\\. *LinkedIn Jobs* — Project Manager / TPM roles \`17:32\`
-\`\`\`
 
-**Copyable values** (email addresses, URLs, API keys, commands) — wrap in backtick code spans:
+*Copyable values* (email addresses, URLs, API keys, commands) — wrap in backtick code spans:
 \`user@example.com\`, \`https://example.com\`, \`npm install foo\`
 
-**Human-in-the-loop** — after listing emails or before acting, use \`telegram_ask\` to offer inline buttons rather than asking the user to type a reply.
-
-**Keep lines short** — Telegram wraps long lines poorly on mobile. Break at natural points.
+*Human-in-the-loop* — after listing emails or before acting, use \`telegram_ask\` to offer inline buttons rather than asking the user to type a reply.
 `);
 
   // Safety rules (hardcoded — never drifts)
@@ -579,6 +615,7 @@ You communicate via Telegram. Format responses for mobile readability.
 - Search memory before claiming you don't know something
 - Use \`store_secret\`/\`read_secret\` for all credential operations
 - If a user sends what appears to be an API key, token, or credential in conversation, immediately warn them that it's visible in chat history, tell them to revoke/rotate it, and direct them to use \`/secret set <key> <value>\` instead
+- After executing tools (exec, web_fetch, read_secret, etc.), ALWAYS provide a text response summarizing what you found or did. Never end your turn with only tool calls and no text reply — the user cannot see tool results directly, they only see your text responses
 `);
 
   return parts.join('\n');
@@ -702,7 +739,7 @@ function buildTools(memory, opts = {}) {
   // Read/write files
   tools.push({
     name: 'read_file',
-    description: 'Read contents of a file.',
+    description: 'Read contents of a file. Supports text files and PDFs (extracts text from PDF automatically).',
     input_schema: {
       type: 'object',
       properties: {
@@ -848,6 +885,8 @@ function buildRunnableTools(tools, memory, context, vlog) {
         tool.name === 'cancel_event' ? input.event_id :
         JSON.stringify(input).substring(0, 80);
       vlog(`[tool] ${tool.name}: ${inputSummary}`);
+
+      context._onToolStart?.(tool.name, inputSummary);
       return await executeToolCall({ name: tool.name, input }, memory, context);
     },
   }));
@@ -1014,6 +1053,13 @@ async function executeToolCall(toolUse, memory, context = {}) {
 
       case 'read_file': {
         const filePath = userDir ? resolveUserPath(input.path, userDir) : input.path;
+        if (filePath.toLowerCase().endsWith('.pdf')) {
+          const pdfParse = require('pdf-parse');
+          const pdfBuffer = fs.readFileSync(filePath);
+          const { text } = await pdfParse(pdfBuffer);
+          const truncatedPdf = text.substring(0, 50000);
+          return text.length > 50000 ? truncatedPdf + '\n...(truncated)' : truncatedPdf;
+        }
         const fileContent = fs.readFileSync(filePath, 'utf-8');
         const truncatedFile = fileContent.substring(0, 50000);
         return fileContent.length > 50000 ? truncatedFile + '\n...(truncated)' : truncatedFile;

package/src/history.js

@@ -119,6 +119,7 @@ function validate(messages) {
 
   const allToolUseIds = new Set();
   const allToolResultIds = new Set();
+  const duplicateToolResultIds = [];
 
   for (const msg of messages) {
     if (msg.role === 'assistant' && Array.isArray(msg.content)) {
@@ -128,11 +129,20 @@ function validate(messages) {
     }
     if (msg.role === 'user' && Array.isArray(msg.content)) {
       for (const b of msg.content) {
-        if (b.type === 'tool_result') allToolResultIds.add(b.tool_use_id);
+        if (b.type === 'tool_result') {
+          if (allToolResultIds.has(b.tool_use_id)) {
+            duplicateToolResultIds.push(b.tool_use_id);
+          }
+          allToolResultIds.add(b.tool_use_id);
+        }
       }
     }
   }
 
+  for (const id of duplicateToolResultIds) {
+    errors.push(`duplicate tool_result for tool_use_id=${id}`);
+  }
+
   for (const id of allToolResultIds) {
     if (!allToolUseIds.has(id)) {
       errors.push(`orphaned tool_result for tool_use_id=${id}`);
@@ -150,12 +160,18 @@ function validate(messages) {
 
 function repair(messages) {
   const allToolUseIds = new Set();
+  const allToolResultIds = new Set();
   for (const msg of messages) {
     if (msg.role === 'assistant' && Array.isArray(msg.content)) {
       for (const b of msg.content) {
         if (b.type === 'tool_use') allToolUseIds.add(b.id);
       }
     }
+    if (msg.role === 'user' && Array.isArray(msg.content)) {
+      for (const b of msg.content) {
+        if (b.type === 'tool_result') allToolResultIds.add(b.tool_use_id);
+      }
+    }
   }
 
   for (let i = messages.length - 1; i >= 0; i--) {
@@ -183,7 +199,7 @@ function repair(messages) {
     if (next?.role === 'user' && Array.isArray(next.content)) {
       const existingIds = new Set(
         next.content.filter(b => b.type === 'tool_result').map(b => b.tool_use_id));
-      const missingIds = toolUseIds.filter(id => !existingIds.has(id));
+      const missingIds = toolUseIds.filter(id => !existingIds.has(id) && !allToolResultIds.has(id));
       if (missingIds.length > 0) {
         next.content = [
           ...next.content,
@@ -193,10 +209,14 @@ function repair(messages) {
         ];
       }
     } else {
-      const fakeResults = toolUseIds.map(id => ({
-        type: 'tool_result', tool_use_id: id, content: '[interrupted]',
-      }));
-      messages.splice(i + 1, 0, { role: 'user', content: fakeResults });
+      const existingElsewhere = toolUseIds.filter(id => allToolResultIds.has(id));
+      const trulyMissing = toolUseIds.filter(id => !allToolResultIds.has(id));
+      if (trulyMissing.length > 0) {
+        const fakeResults = trulyMissing.map(id => ({
+          type: 'tool_result', tool_use_id: id, content: '[interrupted]',
+        }));
+        messages.splice(i + 1, 0, { role: 'user', content: fakeResults });
+      }
     }
   }
 
@@ -212,6 +232,17 @@ function repair(messages) {
       messages.splice(i, 1);
     }
   }
+
+  for (const msg of messages) {
+    if (msg.role !== 'user' || !Array.isArray(msg.content)) continue;
+    const seen = new Set();
+    msg.content = msg.content.filter(b => {
+      if (b.type !== 'tool_result') return true;
+      if (seen.has(b.tool_use_id)) return false;
+      seen.add(b.tool_use_id);
+      return true;
+    });
+  }
 }
 
 class ChatHistory {

package/src/telegram.js

@@ -14,8 +14,87 @@ const RATE_LIMIT_MS = 3000;
 const SPAM_THRESHOLD = 5;
 const SPAM_COOLDOWN_MS = 30000;
 const EVOLUTION_IDLE_MS = 15 * 60 * 1000;
+const DEDUP_TTL_MS = 5 * 60 * 1000;
+const DEDUP_MAX_SIZE = 2000;
+const TEXT_BUFFER_GAP_MS = 1500;
+const TEXT_BUFFER_MAX_PARTS = 12;
+const TEXT_BUFFER_MAX_CHARS = 50000;
+const TEXT_BUFFER_THRESHOLD = 4000;
+const MEDIA_GROUP_DELAY_MS = 500;
+const TERM_WIDTH = 25;
+const TERM_SEP = '━'.repeat(TERM_WIDTH);
 
 const _evolutionTimers = new Map();
+const _toolDescriptionCache = new Map();
+
+function termBar(pct, width = 20) {
+  const filled = Math.round((pct / 100) * width);
+  return '━'.repeat(filled) + '╌'.repeat(width - filled);
+}
+
+function buildStatusHtml({ route, elapsed, toolStatus }) {
+  const lines = [`◈ OBOL ${'━'.repeat(TERM_WIDTH - 7)}`];
+  if (route) {
+    lines.push(`⬡ ROUTE  ${(route.model || 'sonnet').toUpperCase()}`);
+    if (route.memoryCount > 0) {
+      lines.push(`⬡ MEMORY ${route.memoryCount} recalled`);
+    } else if (route.needMemory) {
+      lines.push(`⬡ MEMORY scanning`);
+    }
+  }
+  if (toolStatus) {
+    lines.push(`▸ ${toolStatus}`);
+  } else {
+    lines.push(`▸ Processing`);
+  }
+  const es = elapsed > 0 ? ` ${elapsed}s ` : '';
+  const padLen = Math.max(0, TERM_WIDTH - es.length);
+  const left = Math.floor(padLen / 2);
+  const right = padLen - left;
+  lines.push(`${'━'.repeat(left)}${es}${'━'.repeat(right)}`);
+  return `<pre>${lines.join('\n')}</pre>`;
+}
+
+function markdownToTelegramHtml(text) {
+  const codeBlocks = [];
+  let result = text.replace(/```(\w*)\n?([\s\S]*?)```/g, (_, lang, code) => {
+    const idx = codeBlocks.length;
+    const escaped = code.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    codeBlocks.push(`<pre>${escaped}</pre>`);
+    return `\x00CB${idx}\x00`;
+  });
+
+  const inlineCode = [];
+  result = result.replace(/`([^`\n]+)`/g, (_, code) => {
+    const idx = inlineCode.length;
+    const escaped = code.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    inlineCode.push(`<code>${escaped}</code>`);
+    return `\x00IC${idx}\x00`;
+  });
+
+  result = result.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+  result = result.replace(/\*\*(.+?)\*\*/g, '<b>$1</b>');
+  result = result.replace(/~~(.+?)~~/g, '<s>$1</s>');
+  result = result.replace(/(?<!\w)\*([^\s*](?:.*?[^\s*])?)\*(?!\w)/g, '<i>$1</i>');
+  result = result.replace(/(?<!\w)_([^\s_](?:.*?[^\s_])?)_(?!\w)/g, '<i>$1</i>');
+
+  result = result.replace(/\x00CB(\d+)\x00/g, (_, idx) => codeBlocks[parseInt(idx)]);
+  result = result.replace(/\x00IC(\d+)\x00/g, (_, idx) => inlineCode[parseInt(idx)]);
+
+  return result;
+}
+
+function sendHtml(ctx, text, extra = {}) {
+  const html = markdownToTelegramHtml(text);
+  return ctx.reply(html, { parse_mode: 'HTML', ...extra }).catch(() => ctx.reply(text, extra));
+}
+
+function editHtml(ctx, chatId, messageId, text, extra = {}) {
+  const html = markdownToTelegramHtml(text);
+  return ctx.api.editMessageText(chatId, messageId, html, { parse_mode: 'HTML', ...extra })
+    .catch(() => ctx.api.editMessageText(chatId, messageId, text, extra));
+}
 
 function startTyping(ctx) {
   ctx.replyWithChatAction('typing').catch(() => {});
@@ -30,8 +109,32 @@ function createBot(telegramConfig, config) {
   const allowedUsers = new Set(telegramConfig.allowedUsers || []);
   const rateLimits = new Map();
   const pendingAsks = new Map();
+  const processedUpdates = new Map();
+  const textBuffers = new Map();
+  const mediaGroups = new Map();
   let askIdCounter = 0;
 
+  function describeToolCall(client, toolName, inputSummary) {
+    const key = `${toolName}:${inputSummary}`;
+    const cached = _toolDescriptionCache.get(key);
+    if (cached) return Promise.resolve(cached);
+
+    return client.messages.create({
+      model: 'claude-haiku-4-5',
+      max_tokens: 30,
+      system: 'Describe this tool call in 3-8 words from the user\'s perspective. Present participle. No quotes, period, or emoji.',
+      messages: [{ role: 'user', content: `${toolName}: ${inputSummary}` }],
+    }).then(r => {
+      const desc = r.content[0]?.text?.trim() || null;
+      if (desc) _toolDescriptionCache.set(key, desc);
+      if (_toolDescriptionCache.size > 200) {
+        const first = _toolDescriptionCache.keys().next().value;
+        _toolDescriptionCache.delete(first);
+      }
+      return desc;
+    }).catch(() => null);
+  }
+
   function createAsk(ctx, message, options, timeoutSecs = 60) {
     return new Promise((resolve) => {
       const askId = ++askIdCounter;
@@ -47,7 +150,7 @@ function createBot(telegramConfig, config) {
         }
       }, timeoutSecs * 1000);
       pendingAsks.set(askId, { resolve, options, timer });
-      ctx.reply(message, { parse_mode: 'Markdown', reply_markup: keyboard }).catch(() => {
+      sendHtml(ctx, message, { reply_markup: keyboard }).catch(() => {
         clearTimeout(timer);
         pendingAsks.delete(askId);
         resolve('error');
@@ -63,6 +166,21 @@ function createBot(telegramConfig, config) {
   }, 600000);
   _rateLimitCleanup.unref();
 
+  bot.use(async (ctx, next) => {
+    const updateId = ctx.update?.update_id;
+    if (updateId != null) {
+      if (processedUpdates.has(updateId)) return;
+      processedUpdates.set(updateId, Date.now());
+      if (processedUpdates.size > DEDUP_MAX_SIZE) {
+        const now = Date.now();
+        for (const [id, ts] of processedUpdates) {
+          if (now - ts > DEDUP_TTL_MS) processedUpdates.delete(id);
+        }
+      }
+    }
+    await next();
+  });
+
   bot.use(async (ctx, next) => {
     if (allowedUsers.size > 0 && !allowedUsers.has(ctx.from?.id)) {
       return;
@@ -91,7 +209,7 @@ function createBot(telegramConfig, config) {
   ]).catch(() => {});
 
   bot.command('start', async (ctx) => {
-    await ctx.reply('🪙 OBOL is ready. Just send me a message.');
+    await ctx.reply(`<pre>◈ OBOL v${pkg.version}\n${TERM_SEP}\nSYSTEM ONLINE\n${TERM_SEP}</pre>`, { parse_mode: 'HTML' });
   });
 
   bot.command('memory', async (ctx) => {
@@ -122,7 +240,7 @@ function createBot(telegramConfig, config) {
     if (!ctx.from) return;
     const tenant = await getTenant(ctx.from.id, config);
     tenant.claude.clearHistory(ctx.chat.id);
-    await ctx.reply('🪙 Fresh start. What\'s up?');
+    await ctx.reply(`<pre>◈ CONTEXT CLEARED\n${TERM_SEP}</pre>`, { parse_mode: 'HTML' });
   });
 
   bot.command('status', async (ctx) => {
@@ -134,35 +252,49 @@ function createBot(telegramConfig, config) {
     const m = Math.floor((uptime % 3600) / 60);
     const running = tenant.bg.getStatus();
 
-    let text = `🪙 OBOL Status\n\n`;
-    text += `⏱️ Uptime: ${h}h ${m}m\n`;
-    text += `💾 Memory: ${mem}MB\n`;
-    text += `⚡ Tasks: ${running.length} running\n`;
-    text += `🔧 Tool limit: ${getMaxToolIterations()}\n`;
+    const lines = [
+      `◈ OBOL SYSTEM STATUS`,
+      TERM_SEP,
+      ``,
+      `RUNTIME`,
+      `  uptime   ${h}h ${m}m`,
+      `  memory   ${mem}MB`,
+      `  tasks    ${running.length} active`,
+      `  tools    ${getMaxToolIterations()} max iter`,
+    ];
 
     if (tenant.memory) {
       const stats = await tenant.memory.stats().catch(() => null);
-      if (stats) text += `🧠 Memories: ${stats.total}\n`;
+      lines.push(``, `MEMORY BANK`);
+      lines.push(`  stored   ${stats ? stats.total : '?'} memories`);
     }
 
     const ctxStats = tenant.claude.getContextStats(ctx.chat.id);
-    const ctxBar = '█'.repeat(Math.floor(ctxStats.pct / 5)) + '░'.repeat(20 - Math.floor(ctxStats.pct / 5));
-    text += `\n📐 Context: ${ctxBar} ${ctxStats.pct}%\n`;
-    text += `   ${(ctxStats.estimatedTokens / 1000).toFixed(1)}k / ${(ctxStats.maxTokens / 1000).toFixed(0)}k tokens (${ctxStats.messages} msgs)\n`;
+    lines.push(
+      ``, `CONTEXT`,
+      `  ${termBar(ctxStats.pct)} ${ctxStats.pct}%`,
+      `  ${(ctxStats.estimatedTokens / 1000).toFixed(1)}k / ${(ctxStats.maxTokens / 1000).toFixed(0)}k tokens`,
+      `  ${ctxStats.messages} messages`,
+    );
 
     const evoState = loadEvolutionState(tenant.userDir);
     const cfg = loadConfig();
     const threshold = cfg?.evolution?.exchanges || 100;
     const evoCount = evoState.exchangesSinceLastEvolution || 0;
     const evoPct = Math.min(100, Math.round((evoCount / threshold) * 100));
-    const evoBar = '█'.repeat(Math.floor(evoPct / 5)) + '░'.repeat(20 - Math.floor(evoPct / 5));
-    text += `\n🧬 Evolution: ${evoBar} ${evoPct}% (${evoState.evolutionCount || 0} completed)\n`;
+    lines.push(
+      ``, `EVOLUTION`,
+      `  ${termBar(evoPct)} ${evoPct}%`,
+      `  ${evoCount}/${threshold} exchanges ▪ ${evoState.evolutionCount || 0} completed`,
+    );
 
     const personalityDir = path.join(tenant.userDir, 'personality');
     const traits = loadTraits(personalityDir);
-    text += `\n🎛 Traits\n${formatTraits(traits)}`;
+    lines.push(``, `TRAITS`);
+    lines.push(formatTraits(traits));
+    lines.push(TERM_SEP);
 
-    await ctx.reply(text);
+    await ctx.reply(`<pre>${lines.join('\n')}</pre>`, { parse_mode: 'HTML' });
   });
 
   bot.command('backup', async (ctx) => {
@@ -250,7 +382,8 @@ function createBot(telegramConfig, config) {
       saveTraits(personalityDir, { ...DEFAULT_TRAITS });
       tenant.claude.reloadPersonality();
       const traits = { ...DEFAULT_TRAITS };
-      await ctx.reply(`🎛 Traits reset to defaults\n\n${formatTraits(traits)}`);
+      const lines = [`◈ OBOL PERSONALITY MATRIX`, TERM_SEP, `RESET TO DEFAULTS`, ``, formatTraits(traits), TERM_SEP];
+      await ctx.reply(`<pre>${lines.join('\n')}</pre>`, { parse_mode: 'HTML' });
       return;
     }
 
@@ -269,12 +402,14 @@ function createBot(telegramConfig, config) {
       traits[traitName] = value;
       saveTraits(personalityDir, traits);
       tenant.claude.reloadPersonality();
-      await ctx.reply(`🎛 Updated ${traitName} → ${value}\n\n${formatTraits(traits)}`);
+      const lines = [`◈ OBOL PERSONALITY MATRIX`, TERM_SEP, `UPDATED ${traitName} → ${value}`, ``, formatTraits(traits), TERM_SEP];
+      await ctx.reply(`<pre>${lines.join('\n')}</pre>`, { parse_mode: 'HTML' });
       return;
     }
 
     const traits = loadTraits(personalityDir);
-    await ctx.reply(`🎛 Personality Traits\n\n${formatTraits(traits)}\n\nAdjust: /traits <name> <0-100>\nReset: /traits reset`);
+    const lines = [`◈ OBOL PERSONALITY MATRIX`, TERM_SEP, ``, formatTraits(traits), ``, `/traits &lt;name&gt; &lt;0-100&gt;`, `/traits reset`, TERM_SEP];
+    await ctx.reply(`<pre>${lines.join('\n')}</pre>`, { parse_mode: 'HTML' });
   });
 
   bot.command('secret', async (ctx) => {
@@ -339,16 +474,20 @@ Your message is deleted immediately when using /secret set to keep credentials o
     const threshold = cfg?.evolution?.exchanges || 100;
     const count = state.exchangesSinceLastEvolution || 0;
     const pct = Math.min(100, Math.round((count / threshold) * 100));
-    const bar = '█'.repeat(Math.floor(pct / 5)) + '░'.repeat(20 - Math.floor(pct / 5));
 
-    let text = `🧬 Evolution Progress\n\n`;
-    text += `${bar} ${pct}%\n`;
-    text += `${count}/${threshold} exchanges\n`;
-    text += `Evolutions completed: ${state.evolutionCount || 0}\n`;
+    const lines = [
+      `◈ OBOL EVOLUTION CYCLE`,
+      TERM_SEP,
+      ``,
+      `  ${termBar(pct)} ${pct}%`,
+      `  ${count}/${threshold} exchanges`,
+      `  ${state.evolutionCount || 0} completed`,
+    ];
     if (state.lastEvolution) {
-      text += `Last evolution: ${new Date(state.lastEvolution).toLocaleDateString()}`;
+      lines.push(`  last ${new Date(state.lastEvolution).toLocaleDateString()}`);
     }
-    await ctx.reply(text);
+    lines.push(TERM_SEP);
+    await ctx.reply(`<pre>${lines.join('\n')}</pre>`, { parse_mode: 'HTML' });
   });
 
   bot.command('events', async (ctx) => {
@@ -363,9 +502,7 @@ Your message is deleted immediately when using /secret set to keep credentials o
         const dueLocal = new Date(e.due_at).toLocaleString('en-US', { timeZone: tz, dateStyle: 'medium', timeStyle: 'short' });
         return `${i + 1}. *${e.title}*\n   ${dueLocal} (${tz})\n   \`${e.id}\``;
       }).join('\n\n');
-      await ctx.reply(`📅 *Upcoming Events*\n\n${text}`, { parse_mode: 'Markdown' }).catch(() =>
-        ctx.reply(`📅 Upcoming Events\n\n${text.replace(/\*/g, '')}`)
-      );
+      await sendHtml(ctx, `📅 **Upcoming Events**\n\n${text}`);
     } catch (e) {
       await ctx.reply(`⚠️ ${e.message}`);
     }
@@ -375,13 +512,18 @@ Your message is deleted immediately when using /secret set to keep credentials o
     if (!ctx.from) return;
     const tenant = await getTenant(ctx.from.id, config);
     const running = tenant.bg.getStatus();
+    const lines = [`◈ OBOL ACTIVE TASKS`, TERM_SEP];
     if (running.length === 0) {
-      return ctx.reply('No background tasks running.');
+      lines.push(``, `  (none)`);
+    } else {
+      lines.push(``);
+      for (const t of running) {
+        lines.push(`  ▸ #${t.id} ${t.task}`);
+        lines.push(`    ${t.elapsed}`);
+      }
     }
-    const text = running.map(t =>
-      `⏳ #${t.id}: ${t.task}... (${t.elapsed})`
-    ).join('\n');
-    return ctx.reply(`Running tasks:\n\n${text}`);
+    lines.push(TERM_SEP);
+    return ctx.reply(`<pre>${lines.join('\n')}</pre>`, { parse_mode: 'HTML' });
   });
 
   bot.command('help', async (ctx) => {
@@ -412,14 +554,19 @@ Your message is deleted immediately when using /secret set to keep credentials o
     if (!ctx.from) return;
     const tenant = await getTenant(ctx.from.id, config);
     const stopped = tenant.claude.stopChat(ctx.chat.id);
-    await ctx.reply(stopped ? '⏹ Stopped.' : 'Nothing running to stop.');
+    if (stopped) {
+      await ctx.reply(`<pre>◈ PROCESS TERMINATED\n${TERM_SEP}</pre>`, { parse_mode: 'HTML' });
+    } else {
+      await ctx.reply('Nothing running to stop.');
+    }
   });
 
   bot.command('verbose', async (ctx) => {
     if (!ctx.from) return;
     const tenant = await getTenant(ctx.from.id, config);
     tenant.verbose = !tenant.verbose;
-    await ctx.reply(tenant.verbose ? '🔍 Verbose mode ON' : '🔇 Verbose mode OFF');
+    const state = tenant.verbose ? '◉ ACTIVE' : '○ INACTIVE';
+    await ctx.reply(`<pre>◈ VERBOSE ${state}\n${TERM_SEP}</pre>`, { parse_mode: 'HTML' });
   });
 
   bot.command('upgrade', async (ctx) => {
@@ -509,37 +656,9 @@ Your message is deleted immediately when using /secret set to keep credentials o
     return API_KEY_PATTERNS.some(pattern => pattern.test(text));
   }
 
-  bot.on('message:text', async (ctx) => {
-    if (!ctx.from) return;
-    const userMessage = ctx.message.text;
-    if (!userMessage || !userMessage.trim()) return;
+  async function processTextMessage(ctx, fullMessage) {
     const userId = ctx.from.id;
     const userName = ctx.from.first_name || 'User';
-
-    if (ctx.chat.type === 'group' || ctx.chat.type === 'supergroup') {
-      const me = await bot.api.getMe();
-      if (!userMessage.includes(`@${me.username}`)) return;
-    }
-
-    if (!userMessage.startsWith('/secret') && containsApiKey(userMessage)) {
-      ctx.api.deleteMessage(ctx.chat.id, ctx.message.message_id).catch(() => {});
-      await ctx.reply(
-        '⚠️ That message contained what looks like an API key or token. I deleted it, but it may have been seen already — consider rotating it.\n\nUse `/secret set <name> <value>` to store credentials safely.'
-      ).catch(() => {});
-      return;
-    }
-
-    const rateResult = checkRateLimit(userId);
-    if (rateResult === 'cooldown' || rateResult === 'skip') return;
-    if (rateResult === 'spam') {
-      await ctx.reply('Spam detected. Cooling down for 30 seconds.').catch(() => {});
-      return;
-    }
-    if (rateResult === 'slow') {
-      await ctx.reply('Slow down a bit — I\'m still processing.').catch(() => {});
-      return;
-    }
-
     const tenant = await getTenant(userId, config);
 
     if (_evolutionTimers.has(userId)) {
@@ -548,10 +667,47 @@ Your message is deleted immediately when using /secret set to keep credentials o
       if (tenant.messageLog) tenant.messageLog._evolutionPending = false;
     }
 
+    let replyContext = '';
+    const reply = ctx.message?.reply_to_message;
+    if (reply) {
+      const quote = (reply.text || reply.caption || '').substring(0, 500);
+      const sender = reply.from
+        ? (reply.from.first_name || '') + (reply.from.last_name ? ` ${reply.from.last_name}` : '')
+        : reply.forward_origin?.sender_user?.first_name || 'someone';
+      if (quote) replyContext = `[Replying to "${quote}" from ${sender}]\n\n`;
+    }
+
+    const chatMessage = replyContext + fullMessage;
     const stopTyping = startTyping(ctx);
 
+    let statusMsgId = null;
+    let statusText = 'Processing';
+    let statusTimer = null;
+    let statusStart = null;
+    let routeInfo = null;
+
+    const clearStatus = () => {
+      if (statusTimer) { clearInterval(statusTimer); statusTimer = null; }
+      if (statusMsgId) { ctx.api.deleteMessage(ctx.chat.id, statusMsgId).catch(() => {}); statusMsgId = null; }
+    };
+
+    const startStatusTimer = () => {
+      if (statusTimer) return;
+      statusStart = Date.now();
+      const html = buildStatusHtml({ route: routeInfo, elapsed: 0, toolStatus: statusText });
+      ctx.reply(html, { parse_mode: 'HTML' }).then(sent => {
+        if (sent) statusMsgId = sent.message_id;
+      }).catch(() => {});
+      statusTimer = setInterval(() => {
+        if (!statusMsgId) return;
+        const elapsed = Math.round((Date.now() - statusStart) / 1000);
+        const html = buildStatusHtml({ route: routeInfo, elapsed, toolStatus: statusText });
+        ctx.api.editMessageText(ctx.chat.id, statusMsgId, html, { parse_mode: 'HTML' }).catch(() => {});
+      }, 1000);
+    };
+
     try {
-      tenant.messageLog?.log(ctx.chat.id, 'user', userMessage);
+      tenant.messageLog?.log(ctx.chat.id, 'user', chatMessage);
 
       const chatContext = {
         userId,
@@ -564,25 +720,48 @@ Your message is deleted immediately when using /secret set to keep credentials o
         config,
         verbose: tenant.verbose,
         _verboseNotify: tenant.verbose ? (msg) => {
-          const safe = msg.replace(/`/g, "'");
-          ctx.reply(`\`${safe}\``, { parse_mode: 'Markdown' }).catch(() => {});
+          sendHtml(ctx, `\`${msg}\``).catch(() => {});
         } : undefined,
         telegramAsk: (message, options, timeout) => createAsk(ctx, message, options, timeout),
         _notifyFn: (targetUserId, message) => {
           if (!allowedUsers.has(targetUserId)) throw new Error('Cannot notify user outside allowed list');
           return bot.api.sendMessage(targetUserId, message);
         },
+        _onRouteDecision: (info) => {
+          routeInfo = info;
+          startStatusTimer();
+        },
+        _onRouteUpdate: (update) => {
+          if (routeInfo) routeInfo.memoryCount = update.memoryCount;
+        },
+        _onToolStart: (toolName, inputSummary) => {
+          statusText = 'Processing';
+          describeToolCall(tenant.claude.client, toolName, inputSummary).then(desc => {
+            if (desc) statusText = desc;
+          });
+          startStatusTimer();
+        },
       };
-      const { text: response, usage, model } = await tenant.claude.chat(userMessage, chatContext);
+      const { text: response, usage, model } = await tenant.claude.chat(chatMessage, chatContext);
+
+      if (statusTimer) {
+        clearInterval(statusTimer);
+        statusTimer = null;
+        if (statusMsgId) {
+          const elapsed = statusStart ? Math.round((Date.now() - statusStart) / 1000) : 0;
+          const html = buildStatusHtml({ route: routeInfo, elapsed, toolStatus: 'Formatting output' });
+          ctx.api.editMessageText(ctx.chat.id, statusMsgId, html, { parse_mode: 'HTML' }).catch(() => {});
+        }
+      }
 
       if (!response?.trim()) {
         stopTyping();
+        clearStatus();
         return;
       }
 
       tenant.messageLog?.log(ctx.chat.id, 'assistant', response, { model, tokensIn: usage?.input_tokens, tokensOut: usage?.output_tokens });
 
-
       if (tenant.messageLog?._evolutionReady && !_evolutionTimers.has(userId)) {
         tenant.messageLog._evolutionReady = false;
         tenant.messageLog._evolutionPending = true;
@@ -622,9 +801,7 @@ Your message is deleted immediately when using /secret set to keep credentials o
               msg += `\n\n_${result.changelog}_`;
             }
 
-            await ctx.reply(msg, { parse_mode: 'Markdown' }).catch(() =>
-              ctx.reply(msg).catch(() => {})
-            );
+            await sendHtml(ctx, msg).catch(() => {});
           } catch (e) {
             console.error('Evolution failed:', e.message);
           } finally {
@@ -639,164 +816,325 @@ Your message is deleted immediately when using /secret set to keep credentials o
       if (response.length > 4096) {
         const chunks = splitMessage(response, 4096);
         for (const chunk of chunks) {
-          await ctx.reply(chunk, { parse_mode: 'Markdown' }).catch(() =>
-            ctx.reply(chunk)
-          );
+          await sendHtml(ctx, chunk).catch(() => {});
         }
       } else {
-        await ctx.reply(response, { parse_mode: 'Markdown' }).catch(() =>
-          ctx.reply(response)
-        );
+        await sendHtml(ctx, response).catch(() => {});
+      }
+
+      if (usage && model) {
+        const tag = model.includes('opus') ? 'opus' : model.includes('haiku') ? 'haiku' : 'sonnet';
+        const tokIn = usage.input_tokens >= 1000 ? `${(usage.input_tokens/1000).toFixed(1)}k` : usage.input_tokens;
+        const tokOut = usage.output_tokens >= 1000 ? `${(usage.output_tokens/1000).toFixed(1)}k` : usage.output_tokens;
+        const dur = statusStart ? ((Date.now() - statusStart)/1000).toFixed(1) : null;
+        const parts = [`◈ ${tag}`, `${tokIn} in`, `${tokOut} out`];
+        if (dur) parts.push(`${dur}s`);
+        await ctx.reply(`<code>${parts.join(' ▪ ')}</code>`, { parse_mode: 'HTML' }).catch(() => {});
       }
+
+      if (statusMsgId) ctx.api.deleteMessage(ctx.chat.id, statusMsgId).catch(() => {});
     } catch (e) {
+      clearStatus();
       stopTyping();
       console.error('Message handling error:', e.message);
-      if (e.isOAuthExpiry) {
-        console.error('[oauth] Full error:', e.stack || e.message);
-        await ctx.reply(`OAuth error: ${e.message}\n\nRun \`obol config\` → Anthropic → re-authenticate OAuth.`).catch(() => {});
-      } else if (e.status === 401 || e.message?.includes('401')) {
-        await ctx.reply('API key invalid or expired. Run `obol config` to update.').catch(() => {});
-      } else if (e.status === 429 || e.message?.includes('rate')) {
-        await ctx.reply('Rate limited. Wait a moment and try again.').catch(() => {});
-      } else {
-        await ctx.reply('Something went wrong. Check logs with `obol logs`.').catch(() => {});
-      }
+      const errMsg = e.isOAuthExpiry
+        ? `OAuth error: ${e.message}\n\nRun \`obol config\` → Anthropic → re-authenticate OAuth.`
+        : (e.status === 401 || e.message?.includes('401'))
+          ? 'API key invalid or expired. Run `obol config` to update.'
+          : (e.status === 429 || e.message?.includes('rate'))
+            ? 'Rate limited. Wait a moment and try again.'
+            : 'Something went wrong. Check logs with `obol logs`.';
+      if (e.isOAuthExpiry) console.error('[oauth] Full error:', e.stack || e.message);
+      await ctx.reply(errMsg).catch(() => {});
     }
-  });
+  }
 
-  const MAX_MEDIA_SIZE = 50 * 1024 * 1024; // 50MB
+  function flushTextBuffer(chatId, ctx) {
+    const buf = textBuffers.get(chatId);
+    if (!buf) return;
+    clearTimeout(buf.timer);
+    textBuffers.delete(chatId);
+    const combined = buf.parts.join('');
+    processTextMessage(ctx, combined).catch(e => console.error('Buffer flush error:', e.message));
+  }
 
-  async function handleMedia(ctx) {
+  bot.on('message:text', async (ctx) => {
     if (!ctx.from) return;
+    const userMessage = ctx.message.text;
+    if (!userMessage || !userMessage.trim()) return;
     const userId = ctx.from.id;
+
+    if (ctx.chat.type === 'group' || ctx.chat.type === 'supergroup') {
+      const me = await bot.api.getMe();
+      if (!userMessage.includes(`@${me.username}`)) return;
+    }
+
+    if (!userMessage.startsWith('/secret') && containsApiKey(userMessage)) {
+      ctx.api.deleteMessage(ctx.chat.id, ctx.message.message_id).catch(() => {});
+      await ctx.reply(
+        '⚠️ That message contained what looks like an API key or token. I deleted it, but it may have been seen already — consider rotating it.\n\nUse `/secret set <name> <value>` to store credentials safely.'
+      ).catch(() => {});
+      return;
+    }
+
     const rateResult = checkRateLimit(userId);
-    if (rateResult) return;
-    const fileInfo = media.getFileInfo(ctx);
-    if (!fileInfo) return;
+    if (rateResult === 'cooldown' || rateResult === 'skip') return;
+    if (rateResult === 'spam') {
+      await ctx.reply('Spam detected. Cooling down for 30 seconds.').catch(() => {});
+      return;
+    }
+    if (rateResult === 'slow') {
+      await ctx.reply('Slow down a bit — I\'m still processing.').catch(() => {});
+      return;
+    }
 
-    if (fileInfo.fileSize > MAX_MEDIA_SIZE) {
-      await ctx.reply(`File too large (${(fileInfo.fileSize / 1024 / 1024).toFixed(1)}MB). Max is 50MB.`).catch(() => {});
+    const chatId = ctx.chat.id;
+    const existingBuf = textBuffers.get(chatId);
+
+    if (userMessage.length >= TEXT_BUFFER_THRESHOLD) {
+      if (existingBuf) {
+        clearTimeout(existingBuf.timer);
+        if (existingBuf.parts.length < TEXT_BUFFER_MAX_PARTS &&
+            existingBuf.totalLength + userMessage.length <= TEXT_BUFFER_MAX_CHARS) {
+          existingBuf.parts.push(userMessage);
+          existingBuf.totalLength += userMessage.length;
+          existingBuf.ctx = ctx;
+          existingBuf.timer = setTimeout(() => flushTextBuffer(chatId, ctx), TEXT_BUFFER_GAP_MS);
+          return;
+        }
+        flushTextBuffer(chatId, ctx);
+      }
+      const buf = {
+        parts: [userMessage],
+        totalLength: userMessage.length,
+        ctx,
+        timer: setTimeout(() => flushTextBuffer(chatId, ctx), TEXT_BUFFER_GAP_MS),
+      };
+      textBuffers.set(chatId, buf);
       return;
     }
 
-    const stopTyping = startTyping(ctx);
+    if (existingBuf) {
+      flushTextBuffer(chatId, existingBuf.ctx);
+    }
 
-    try {
-      const tenant = await getTenant(userId, config);
-      const file = await ctx.getFile();
-      const buffer = await media.downloadFile(telegramConfig.token, file.file_path);
+    await processTextMessage(ctx, userMessage);
+  });
 
-      const filename = media.generateFilename(fileInfo, file.file_path);
-      const assetsDir = path.join(tenant.userDir, 'assets');
-      const savedPath = media.saveFile(buffer, assetsDir, filename);
+  const MAX_MEDIA_SIZE = 50 * 1024 * 1024;
 
-      const caption = ctx.message.caption || '';
+  async function downloadMediaItem(ctx, fileInfo) {
+    const file = await ctx.getFile();
+    const buffer = await media.downloadFile(telegramConfig.token, file.file_path);
+    const filename = media.generateFilename(fileInfo, file.file_path);
+    return { buffer, filename, fileInfo, caption: ctx.message.caption || '' };
+  }
 
-      if (tenant.memory && !media.isImage(fileInfo)) {
-        const memContent = media.buildMemoryContent(fileInfo, filename, savedPath, caption);
-        await tenant.memory.add(memContent, {
-          category: 'resource',
-          importance: 0.6,
-          source: 'telegram-media',
-          tags: [fileInfo.mediaType],
-        }).catch(() => {});
-      }
+  async function processMediaItems(ctx, items) {
+    if (!ctx.from) return;
+    const userId = ctx.from.id;
+    const stopTyping = startTyping(ctx);
+    let statusMsgId = null;
+    let statusText = 'Processing';
+    let statusTimer = null;
+    let statusStart = null;
+    let routeInfo = null;
+
+    const clearStatus = () => {
+      if (statusTimer) { clearInterval(statusTimer); statusTimer = null; }
+      if (statusMsgId) { ctx.api.deleteMessage(ctx.chat.id, statusMsgId).catch(() => {}); statusMsgId = null; }
+    };
 
-      if (media.isImage(fileInfo)) {
-        const imageBlock = media.bufferToImageBlock(buffer, fileInfo.mimeType);
-        const prompt = caption || 'The user sent this image. Describe what you see and respond naturally.';
-        const mediaChatCtx = {
-          userId,
-          userName: ctx.from.first_name || 'User',
-          chatId: ctx.chat.id,
-          bg: tenant.bg,
-          ctx,
-          claude: tenant.claude,
-          scheduler: tenant.scheduler,
-          config,
-          verbose: tenant.verbose,
-          _verboseNotify: tenant.verbose ? (msg) => {
-            const safe = msg.replace(/`/g, "'");
-            ctx.reply(`\`${safe}\``, { parse_mode: 'Markdown' }).catch(() => {});
-          } : undefined,
-          images: [imageBlock],
-          _notifyFn: (targetUserId, message) => {
-            if (!allowedUsers.has(targetUserId)) throw new Error('Cannot notify user outside allowed list');
-            return bot.api.sendMessage(targetUserId, message);
-          },
-        };
-        const { text: response, usage, model } = await tenant.claude.chat(prompt, mediaChatCtx);
+    const startStatusTimer = () => {
+      if (statusTimer) return;
+      statusStart = Date.now();
+      const html = buildStatusHtml({ route: routeInfo, elapsed: 0, toolStatus: statusText });
+      ctx.reply(html, { parse_mode: 'HTML' }).then(sent => {
+        if (sent) statusMsgId = sent.message_id;
+      }).catch(() => {});
+      statusTimer = setInterval(() => {
+        if (!statusMsgId) return;
+        const elapsed = Math.round((Date.now() - statusStart) / 1000);
+        const html = buildStatusHtml({ route: routeInfo, elapsed, toolStatus: statusText });
+        ctx.api.editMessageText(ctx.chat.id, statusMsgId, html, { parse_mode: 'HTML' }).catch(() => {});
+      }, 1000);
+    };
 
-        stopTyping();
-        if (!response?.trim()) return;
-
-        tenant.messageLog?.log(ctx.chat.id, 'user', `[${fileInfo.mediaType}] ${caption || filename}`);
-        tenant.messageLog?.log(ctx.chat.id, 'assistant', response, { model, tokensIn: usage?.input_tokens, tokensOut: usage?.output_tokens });
-
-        if (tenant.memory) {
-          const analysisMemory = `Image: ${filename} (saved at ${savedPath})${caption ? `. Caption: "${caption}"` : ''}. Analysis: ${response.substring(0, 1500)}`;
-          await tenant.memory.add(analysisMemory, {
-            category: 'resource',
-            importance: 0.7,
-            source: 'image-analysis',
-            tags: ['image', ...(caption ? caption.toLowerCase().split(/\s+/).slice(0, 3) : [])],
+    try {
+      const tenant = await getTenant(userId, config);
+      const assetsDir = path.join(tenant.userDir, 'assets');
+      const imageBlocks = [];
+      const nonImageParts = [];
+      const caption = items.map(i => i.caption).filter(Boolean).join('\n') || '';
+
+      for (const item of items) {
+        const savedPath = media.saveFile(item.buffer, assetsDir, item.filename);
+
+        if (tenant.memory && !media.isImage(item.fileInfo)) {
+          const memContent = media.buildMemoryContent(item.fileInfo, item.filename, savedPath, item.caption);
+          await tenant.memory.add(memContent, {
+            category: 'resource', importance: 0.6,
+            source: 'telegram-media', tags: [item.fileInfo.mediaType],
           }).catch(() => {});
         }
 
-        if (response.length > 4096) {
-          for (const chunk of splitMessage(response, 4096)) {
-            await ctx.reply(chunk, { parse_mode: 'Markdown' }).catch(() => ctx.reply(chunk));
-          }
+        if (media.isImage(item.fileInfo)) {
+          imageBlocks.push(media.bufferToImageBlock(item.buffer, item.fileInfo.mimeType));
         } else {
-          await ctx.reply(response, { parse_mode: 'Markdown' }).catch(() => ctx.reply(response));
+          nonImageParts.push(item.caption
+            ? `[User sent a ${item.fileInfo.mediaType}: ${item.filename}, saved at ${savedPath}] ${item.caption}`
+            : `[User sent a ${item.fileInfo.mediaType}: ${item.filename}, saved at ${savedPath}. Use read_file to read its contents if needed.]`);
         }
-      } else if (caption) {
-        const contextMsg = `[User sent a ${fileInfo.mediaType}: ${filename}] ${caption}`;
-        const mediaCaptionCtx = {
-          userId,
-          userName: ctx.from.first_name || 'User',
-          chatId: ctx.chat.id,
-          bg: tenant.bg,
-          ctx,
-          claude: tenant.claude,
-          scheduler: tenant.scheduler,
-          config,
-          verbose: tenant.verbose,
-          _verboseNotify: tenant.verbose ? (msg) => {
-            const safe = msg.replace(/`/g, "'");
-            ctx.reply(`\`${safe}\``, { parse_mode: 'Markdown' }).catch(() => {});
-          } : undefined,
-          _notifyFn: (targetUserId, message) => {
-            if (!allowedUsers.has(targetUserId)) throw new Error('Cannot notify user outside allowed list');
-            return bot.api.sendMessage(targetUserId, message);
-          },
-        };
-        const { text: response, usage, model } = await tenant.claude.chat(contextMsg, mediaCaptionCtx);
-
-        stopTyping();
-        if (!response?.trim()) return;
+      }
 
-        tenant.messageLog?.log(ctx.chat.id, 'user', contextMsg);
-        tenant.messageLog?.log(ctx.chat.id, 'assistant', response, { model, tokensIn: usage?.input_tokens, tokensOut: usage?.output_tokens });
+      let prompt, chatImages;
+      if (imageBlocks.length > 0) {
+        prompt = caption || `The user sent ${imageBlocks.length} image(s). Describe what you see and respond naturally.`;
+        if (nonImageParts.length > 0) prompt += '\n\n' + nonImageParts.join('\n');
+        chatImages = imageBlocks;
+      } else {
+        prompt = nonImageParts.join('\n');
+      }
 
-        if (response.length > 4096) {
-          for (const chunk of splitMessage(response, 4096)) {
-            await ctx.reply(chunk, { parse_mode: 'Markdown' }).catch(() => ctx.reply(chunk));
-          }
-        } else {
-          await ctx.reply(response, { parse_mode: 'Markdown' }).catch(() => ctx.reply(response));
+      const mediaChatCtx = {
+        userId,
+        userName: ctx.from.first_name || 'User',
+        chatId: ctx.chat.id,
+        bg: tenant.bg, ctx, claude: tenant.claude,
+        scheduler: tenant.scheduler, config,
+        verbose: tenant.verbose,
+        _verboseNotify: tenant.verbose ? (msg) => {
+          sendHtml(ctx, `\`${msg}\``).catch(() => {});
+        } : undefined,
+        ...(chatImages ? { images: chatImages } : {}),
+        _notifyFn: (targetUserId, message) => {
+          if (!allowedUsers.has(targetUserId)) throw new Error('Cannot notify user outside allowed list');
+          return bot.api.sendMessage(targetUserId, message);
+        },
+        _onRouteDecision: (info) => {
+          routeInfo = info;
+          startStatusTimer();
+        },
+        _onRouteUpdate: (update) => {
+          if (routeInfo) routeInfo.memoryCount = update.memoryCount;
+        },
+        _onToolStart: (toolName, inputSummary) => {
+          statusText = 'Processing';
+          describeToolCall(tenant.claude.client, toolName, inputSummary).then(desc => {
+            if (desc) statusText = desc;
+          });
+          startStatusTimer();
+        },
+      };
+      const { text: response, usage, model } = await tenant.claude.chat(prompt, mediaChatCtx);
+
+      if (statusTimer) {
+        clearInterval(statusTimer);
+        statusTimer = null;
+        if (statusMsgId) {
+          const elapsed = statusStart ? Math.round((Date.now() - statusStart) / 1000) : 0;
+          const html = buildStatusHtml({ route: routeInfo, elapsed, toolStatus: 'Formatting output' });
+          ctx.api.editMessageText(ctx.chat.id, statusMsgId, html, { parse_mode: 'HTML' }).catch(() => {});
         }
+      }
+
+      stopTyping();
+      if (!response?.trim()) {
+        clearStatus();
+        return;
+      }
+
+      const logLabel = items.map(i => `[${i.fileInfo.mediaType}] ${i.caption || i.filename}`).join(', ');
+      tenant.messageLog?.log(ctx.chat.id, 'user', logLabel);
+      tenant.messageLog?.log(ctx.chat.id, 'assistant', response, { model, tokensIn: usage?.input_tokens, tokensOut: usage?.output_tokens });
+
+      if (tenant.memory && imageBlocks.length > 0) {
+        const filenames = items.filter(i => media.isImage(i.fileInfo)).map(i => i.filename).join(', ');
+        const analysisMemory = `Images: ${filenames}${caption ? `. Caption: "${caption}"` : ''}. Analysis: ${response.substring(0, 1500)}`;
+        await tenant.memory.add(analysisMemory, {
+          category: 'resource', importance: 0.7,
+          source: 'image-analysis',
+          tags: ['image', ...(caption ? caption.toLowerCase().split(/\s+/).slice(0, 3) : [])],
+        }).catch(() => {});
+      }
+
+      if (response.length > 4096) {
+        const chunks = splitMessage(response, 4096);
+        for (const chunk of chunks) await sendHtml(ctx, chunk).catch(() => {});
       } else {
-        stopTyping();
-        await ctx.reply(`Got it — saved ${filename}`);
+        await sendHtml(ctx, response).catch(() => {});
+      }
+
+      if (usage && model) {
+        const tag = model.includes('opus') ? 'opus' : model.includes('haiku') ? 'haiku' : 'sonnet';
+        const tokIn = usage.input_tokens >= 1000 ? `${(usage.input_tokens/1000).toFixed(1)}k` : usage.input_tokens;
+        const tokOut = usage.output_tokens >= 1000 ? `${(usage.output_tokens/1000).toFixed(1)}k` : usage.output_tokens;
+        const dur = statusStart ? ((Date.now() - statusStart)/1000).toFixed(1) : null;
+        const parts = [`◈ ${tag}`, `${tokIn} in`, `${tokOut} out`];
+        if (dur) parts.push(`${dur}s`);
+        await ctx.reply(`<code>${parts.join(' ▪ ')}</code>`, { parse_mode: 'HTML' }).catch(() => {});
       }
+
+      if (statusMsgId) ctx.api.deleteMessage(ctx.chat.id, statusMsgId).catch(() => {});
     } catch (e) {
+      clearStatus();
       stopTyping();
       console.error('Media handling error:', e.message);
       await ctx.reply('Failed to process that file. Check logs.').catch(() => {});
     }
   }
 
+  async function handleMedia(ctx) {
+    if (!ctx.from) return;
+    const userId = ctx.from.id;
+    const rateResult = checkRateLimit(userId);
+    if (rateResult) return;
+    const fileInfo = media.getFileInfo(ctx);
+    if (!fileInfo) return;
+
+    if (fileInfo.fileSize > MAX_MEDIA_SIZE) {
+      await ctx.reply(`File too large (${(fileInfo.fileSize / 1024 / 1024).toFixed(1)}MB). Max is 50MB.`).catch(() => {});
+      return;
+    }
+
+    const item = await downloadMediaItem(ctx, fileInfo).catch(e => {
+      console.error('Media download error:', e.message);
+      return null;
+    });
+    if (!item) return;
+
+    const groupId = ctx.message.media_group_id;
+    if (groupId) {
+      const existing = mediaGroups.get(groupId);
+      if (existing) {
+        clearTimeout(existing.timer);
+        existing.items.push(item);
+        existing.ctx = ctx;
+        existing.timer = setTimeout(() => {
+          mediaGroups.delete(groupId);
+          processMediaItems(existing.ctx, existing.items).catch(e =>
+            console.error('Media group error:', e.message)
+          );
+        }, MEDIA_GROUP_DELAY_MS);
+      } else {
+        const group = {
+          items: [item],
+          ctx,
+          timer: setTimeout(() => {
+            mediaGroups.delete(groupId);
+            processMediaItems(ctx, [item]).catch(e =>
+              console.error('Media group error:', e.message)
+            );
+          }, MEDIA_GROUP_DELAY_MS),
+        };
+        mediaGroups.set(groupId, group);
+      }
+      return;
+    }
+
+    await processMediaItems(ctx, [item]);
+  }
+
   bot.on('message:photo', handleMedia);
   bot.on('message:document', handleMedia);
   bot.on('message:voice', handleMedia);
@@ -808,17 +1146,19 @@ Your message is deleted immediately when using /secret set to keep credentials o
 
   bot.on('callback_query:data', async (ctx) => {
     const data = ctx.callbackQuery.data;
-    if (!data.startsWith('ask:')) return ctx.answerCallbackQuery();
+    const answer = (opts) => ctx.answerCallbackQuery(opts).catch(() => {});
+    if (!data.startsWith('ask:')) return answer();
     const parts = data.split(':');
     const askId = parseInt(parts[1]);
     const optIdx = parseInt(parts[2]);
     const pending = pendingAsks.get(askId);
-    if (!pending) return ctx.answerCallbackQuery({ text: 'Expired' });
+    if (!pending) return answer({ text: 'Expired' });
     const selected = pending.options[optIdx];
-    await ctx.answerCallbackQuery({ text: selected });
+    await answer({ text: selected });
     clearTimeout(pending.timer);
     pendingAsks.delete(askId);
-    ctx.editMessageText(`${ctx.callbackQuery.message.text}\n\n✓ _${selected}_`, { parse_mode: 'Markdown' }).catch(() => {});
+    const confirmHtml = markdownToTelegramHtml(`${ctx.callbackQuery.message.text}\n\n✓ _${selected}_`);
+    ctx.editMessageText(confirmHtml, { parse_mode: 'HTML' }).catch(() => {});
     pending.resolve(selected);
   });
 
@@ -877,9 +1217,8 @@ Your message is deleted immediately when using /secret set to keep credentials o
 function formatTraits(traits) {
   const maxLen = Math.max(...Object.keys(traits).map(k => k.length));
   return Object.entries(traits).map(([name, val]) => {
-    const filled = Math.round(val / 5);
-    const bar = '█'.repeat(filled) + '░'.repeat(20 - filled);
-    return `${name.charAt(0).toUpperCase() + name.slice(1).padEnd(maxLen)} ${bar} ${val}`;
+    const label = (name.charAt(0).toUpperCase() + name.slice(1)).padEnd(maxLen + 1);
+    return `  ${label}${termBar(val)} ${val}`;
   }).join('\n');
 }