telegram-claude-mcp 2.0.1 → 2.0.3

package/bin/setup.js

@@ -162,7 +162,11 @@ RESPONSE=$(curl -s -X POST "$HOOK_URL" \\
 if [ $? -eq 0 ]; then
   DECISION=$(echo "$RESPONSE" | jq -r '.decision // empty')
   REASON=$(echo "$RESPONSE" | jq -r '.reason // empty')
-  [ "$DECISION" = "block" ] && [ -n "$REASON" ] && echo "$RESPONSE"
+  if [ "$DECISION" = "block" ] && [ -n "$REASON" ]; then
+    echo "$RESPONSE"
+    # Exit code 2 tells Claude Code to continue with the reason as instructions
+    exit 2
+  fi
 fi
 `;
 

package/hooks/stop-hook.sh

@@ -108,6 +108,8 @@ REASON=$(echo "$RESPONSE" | jq -r '.reason // empty')
 if [ "$DECISION" = "block" ] && [ -n "$REASON" ]; then
   # User provided instructions - continue with them
   echo "$RESPONSE"
+  # Exit code 2 tells Claude Code to continue with the reason as instructions
+  exit 2
 else
   # User said done or no response - allow stop
   exit 0

package/hooks-v2/hooks-config-example.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "_comment": "Example Claude Code hooks configuration for progress tracking. Copy relevant sections to ~/.claude/settings.json or .claude/settings.json in your project.",
+
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "*",
+        "command": "SESSION_NAME=${SESSION_NAME:-$(basename \"$PWD\")} /path/to/call-me/server/hooks-v2/progress-pre-tool.sh"
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "*",
+        "command": "SESSION_NAME=${SESSION_NAME:-$(basename \"$PWD\")} /path/to/call-me/server/hooks-v2/progress-post-tool.sh"
+      }
+    ],
+    "Stop": [
+      {
+        "command": "SESSION_NAME=${SESSION_NAME:-$(basename \"$PWD\")} /path/to/call-me/server/hooks-v2/progress-stop.sh"
+      },
+      {
+        "_comment": "Optional: Interactive stop hook (waits for user response)",
+        "command": "SESSION_NAME=${SESSION_NAME:-$(basename \"$PWD\")} /path/to/call-me/server/hooks-v2/stop-hook.sh"
+      }
+    ]
+  }
+}

package/hooks-v2/progress-post-tool.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# PostToolUse progress hook for telegram-claude-daemon
+# Sends tool completion events to update progress display
+#
+# This hook is fire-and-forget - it doesn't block Claude's execution
+
+DAEMON_PORT="${TELEGRAM_CLAUDE_PORT:-3333}"
+DAEMON_HOST="${TELEGRAM_CLAUDE_HOST:-localhost}"
+HOOK_URL="http://${DAEMON_HOST}:${DAEMON_PORT}/progress"
+
+# Read input from stdin
+INPUT=$(cat)
+
+# Extract tool info
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // .toolName // .name // empty')
+TOOL_RESULT=$(echo "$INPUT" | jq -c '.tool_result // .result // {}')
+
+# Check if tool succeeded
+IS_ERROR=$(echo "$INPUT" | jq -r '.is_error // .isError // false')
+if [ "$IS_ERROR" = "true" ]; then
+  SUCCESS="false"
+else
+  SUCCESS="true"
+fi
+
+# Skip if no tool name
+if [ -z "$TOOL_NAME" ]; then
+  exit 0
+fi
+
+# Skip progress updates for Telegram tools (would be recursive)
+case "$TOOL_NAME" in
+  mcp__telegram__*|send_message|continue_chat|notify_user|end_chat)
+    exit 0
+    ;;
+esac
+
+# Build payload
+PAYLOAD=$(jq -n \
+  --arg type "post_tool" \
+  --arg session_name "${SESSION_NAME:-default}" \
+  --arg tool_name "$TOOL_NAME" \
+  --argjson success "$SUCCESS" \
+  --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+  '{
+    type: $type,
+    session_name: $session_name,
+    tool_name: $tool_name,
+    success: $success,
+    timestamp: $timestamp
+  }')
+
+# Fire and forget - send in background and don't wait
+(curl -s -X POST "$HOOK_URL" \
+  -H "Content-Type: application/json" \
+  -H "X-Session-Name: ${SESSION_NAME:-default}" \
+  -d "$PAYLOAD" \
+  --max-time 2 2>/dev/null) &
+
+# Exit immediately - don't block Claude
+exit 0

package/hooks-v2/progress-pre-tool.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+# PreToolUse progress hook for telegram-claude-daemon
+# Sends tool start events to update progress display
+#
+# This hook is fire-and-forget - it doesn't block Claude's execution
+
+DAEMON_PORT="${TELEGRAM_CLAUDE_PORT:-3333}"
+DAEMON_HOST="${TELEGRAM_CLAUDE_HOST:-localhost}"
+HOOK_URL="http://${DAEMON_HOST}:${DAEMON_PORT}/progress"
+
+# Read input from stdin
+INPUT=$(cat)
+
+# Extract tool info
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // .toolName // .name // empty')
+TOOL_INPUT=$(echo "$INPUT" | jq -c '.tool_input // .toolInput // .input // .arguments // {}')
+
+# Skip if no tool name
+if [ -z "$TOOL_NAME" ]; then
+  exit 0
+fi
+
+# Skip progress updates for Telegram tools (would be recursive)
+case "$TOOL_NAME" in
+  mcp__telegram__*|send_message|continue_chat|notify_user|end_chat)
+    exit 0
+    ;;
+esac
+
+# Build payload
+PAYLOAD=$(jq -n \
+  --arg type "pre_tool" \
+  --arg session_name "${SESSION_NAME:-default}" \
+  --arg tool_name "$TOOL_NAME" \
+  --argjson tool_input "$TOOL_INPUT" \
+  --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+  '{
+    type: $type,
+    session_name: $session_name,
+    tool_name: $tool_name,
+    tool_input: $tool_input,
+    timestamp: $timestamp
+  }')
+
+# Fire and forget - send in background and don't wait
+(curl -s -X POST "$HOOK_URL" \
+  -H "Content-Type: application/json" \
+  -H "X-Session-Name: ${SESSION_NAME:-default}" \
+  -d "$PAYLOAD" \
+  --max-time 2 2>/dev/null) &
+
+# Exit immediately - don't block Claude
+exit 0

package/hooks-v2/progress-stop.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+# Stop progress hook for telegram-claude-daemon
+# Sends stop events to finalize progress display
+#
+# This hook is fire-and-forget - it doesn't block Claude's execution
+# Note: This is separate from stop-hook.sh which handles interactive stop
+
+DAEMON_PORT="${TELEGRAM_CLAUDE_PORT:-3333}"
+DAEMON_HOST="${TELEGRAM_CLAUDE_HOST:-localhost}"
+HOOK_URL="http://${DAEMON_HOST}:${DAEMON_PORT}/progress"
+
+# Read input from stdin (if any)
+INPUT=$(cat)
+
+# Build payload
+PAYLOAD=$(jq -n \
+  --arg type "stop" \
+  --arg session_name "${SESSION_NAME:-default}" \
+  --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+  '{
+    type: $type,
+    session_name: $session_name,
+    timestamp: $timestamp
+  }')
+
+# Fire and forget - send in background and don't wait
+(curl -s -X POST "$HOOK_URL" \
+  -H "Content-Type: application/json" \
+  -H "X-Session-Name: ${SESSION_NAME:-default}" \
+  -d "$PAYLOAD" \
+  --max-time 2 2>/dev/null) &
+
+# Exit immediately - don't block Claude
+exit 0

package/hooks-v2/stop-hook.sh

@@ -41,5 +41,7 @@ if [ $? -eq 0 ] && [ -n "$RESPONSE" ]; then
   DECISION=$(echo "$RESPONSE" | jq -r '.decision // empty')
   if [ "$DECISION" = "block" ]; then
     echo "$RESPONSE"
+    # Exit code 2 tells Claude Code to continue with the reason as instructions
+    exit 2
   fi
 fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "telegram-claude-mcp",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "MCP server that lets Claude message you on Telegram with hooks support",
   "author": "Geravant",
   "license": "MIT",

package/src/daemon/index.ts

@@ -13,6 +13,7 @@ import { existsSync, unlinkSync, writeFileSync, mkdirSync } from 'fs';
 import { dirname } from 'path';
 import { SessionManager } from './session-manager.js';
 import { MultiTelegramManager, type HookEvent } from './telegram-multi.js';
+import { ProgressTracker, type ProgressEvent } from './progress-tracker.js';
 import {
   DAEMON_SOCKET_PATH,
   DAEMON_PID_FILE,
@@ -96,6 +97,16 @@ async function main() {
 
   telegram.start();
 
+  // Create progress tracker
+  const progressTracker = new ProgressTracker(
+    telegram.getBot(),
+    telegram.getChatId(),
+    sessionManager
+  );
+
+  // Register progress tracker's callback handler for mute buttons
+  telegram.registerCallbackInterceptor((query) => progressTracker.handleCallback(query));
+
   // Track socket buffers for each connection
   const socketBuffers = new Map<net.Socket, string>();
 
@@ -223,6 +234,41 @@ async function main() {
         return;
       }
 
+      // Progress tracking endpoint
+      if (url === '/progress' || url === '/hooks/progress') {
+        const event = data as ProgressEvent;
+
+        console.error(`[HTTP] Progress: ${event.type} - ${event.tool_name || ''} (session: ${sessionName})`);
+
+        try {
+          switch (event.type) {
+            case 'start':
+              await progressTracker.handleSessionStart(sessionName);
+              break;
+            case 'pre_tool':
+              await progressTracker.handlePreTool(sessionName, event.tool_name!, event.tool_input);
+              break;
+            case 'post_tool':
+              await progressTracker.handlePostTool(sessionName, event.tool_name!, event.success ?? true);
+              break;
+            case 'stop':
+              await progressTracker.handleStop(sessionName);
+              break;
+            case 'notification':
+              await progressTracker.handleNotification(sessionName, event.tool_name || '');
+              break;
+          }
+
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: true }));
+        } catch (error) {
+          console.error('[HTTP] Progress error:', error);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: true })); // Don't fail hooks
+        }
+        return;
+      }
+
       // Status endpoint
       if (url === '/status') {
         res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -284,9 +330,10 @@ async function main() {
   process.on('SIGINT', shutdown);
   process.on('SIGTERM', shutdown);
 
-  // Periodic cleanup of dead sessions
+  // Periodic cleanup of dead sessions and progress state
   setInterval(() => {
     sessionManager.cleanup();
+    progressTracker.cleanup();
   }, 30000);
 }
 

package/src/daemon/progress-display.ts

@@ -0,0 +1,184 @@
+/**
+ * Progress Display Utilities
+ *
+ * Visual rendering for progress tracking in Telegram messages.
+ * Inspired by DnD-Books telegram-bot ProgressIndicator.
+ */
+
+export enum ProgressStage {
+  IDLE = 'idle',
+  THINKING = 'thinking',
+  TOOL_QUEUED = 'queued',
+  TOOL_RUNNING = 'running',
+  TOOL_COMPLETE = 'complete',
+  WAITING_USER = 'waiting',
+  FINISHED = 'finished',
+}
+
+interface StageDisplay {
+  emoji: string;
+  label: string;
+  progress: number;
+}
+
+export const stageDisplay: Record<ProgressStage, StageDisplay> = {
+  [ProgressStage.IDLE]: { emoji: '💤', label: 'Idle', progress: 0 },
+  [ProgressStage.THINKING]: { emoji: '🧠', label: 'Thinking', progress: 10 },
+  [ProgressStage.TOOL_QUEUED]: { emoji: '📋', label: 'Tool queued', progress: 20 },
+  [ProgressStage.TOOL_RUNNING]: { emoji: '🔧', label: 'Executing', progress: 50 },
+  [ProgressStage.TOOL_COMPLETE]: { emoji: '✅', label: 'Tool done', progress: 80 },
+  [ProgressStage.WAITING_USER]: { emoji: '💬', label: 'Waiting for you', progress: 90 },
+  [ProgressStage.FINISHED]: { emoji: '🏁', label: 'Finished', progress: 100 },
+};
+
+/**
+ * Build a visual progress bar using block characters.
+ */
+export function buildProgressBar(percent: number): string {
+  const total = 10;
+  const filled = Math.floor(percent / 10);
+  const empty = total - filled;
+
+  const filledChar = '▓';
+  const emptyChar = '░';
+
+  return `[${filledChar.repeat(filled)}${emptyChar.repeat(empty)}] ${percent}%`;
+}
+
+/**
+ * Format tool name for display.
+ */
+export function formatToolName(toolName: string): string {
+  // Shorten common tool names
+  const shortNames: Record<string, string> = {
+    'Read': 'Read',
+    'Write': 'Write',
+    'Edit': 'Edit',
+    'Bash': 'Bash',
+    'Glob': 'Glob',
+    'Grep': 'Grep',
+    'Task': 'Task',
+    'WebFetch': 'Web',
+    'WebSearch': 'Search',
+    'TodoWrite': 'Todo',
+    'AskUserQuestion': 'Ask',
+  };
+
+  return shortNames[toolName] || toolName;
+}
+
+/**
+ * Format elapsed time for display.
+ */
+export function formatElapsedTime(startTime: number): string {
+  const elapsed = Math.floor((Date.now() - startTime) / 1000);
+
+  if (elapsed < 60) {
+    return `${elapsed}s`;
+  }
+
+  const minutes = Math.floor(elapsed / 60);
+  const seconds = elapsed % 60;
+  return `${minutes}m ${seconds}s`;
+}
+
+/**
+ * Build tool statistics summary.
+ */
+export function buildToolStats(toolCounts: Map<string, number>): string {
+  if (toolCounts.size === 0) return '';
+
+  const entries = Array.from(toolCounts.entries())
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 5) // Top 5 tools
+    .map(([tool, count]) => `${formatToolName(tool)} (${count})`)
+    .join(', ');
+
+  return entries;
+}
+
+export interface ProgressMessageOptions {
+  sessionName: string;
+  stage: ProgressStage;
+  currentTool: string | null;
+  toolStack: string[];
+  startTime: number;
+  toolsExecuted: number;
+  toolCounts: Map<string, number>;
+  showDetails?: boolean;
+}
+
+/**
+ * Build the complete progress message text.
+ */
+export function buildProgressMessage(options: ProgressMessageOptions): string {
+  const {
+    sessionName,
+    stage,
+    currentTool,
+    toolStack,
+    startTime,
+    toolsExecuted,
+    toolCounts,
+    showDetails = true,
+  } = options;
+
+  const display = stageDisplay[stage];
+  const elapsed = formatElapsedTime(startTime);
+
+  let text = `[${sessionName}] Working...\n\n`;
+
+  // Current stage with emoji
+  text += `${display.emoji} *${display.label}*`;
+
+  // Current tool (if any)
+  if (currentTool) {
+    const toolDisplay = toolStack.length > 1
+      ? toolStack.map(formatToolName).join(' > ')
+      : formatToolName(currentTool);
+    text += `: \`${toolDisplay}\``;
+  }
+  text += '\n\n';
+
+  // Progress bar
+  text += buildProgressBar(display.progress) + '\n\n';
+
+  // Stats line
+  text += `⏱ ${elapsed}`;
+  if (toolsExecuted > 0) {
+    text += ` | Tools: ${toolsExecuted}`;
+  }
+
+  // Detailed tool breakdown (for finished state)
+  if (showDetails && stage === ProgressStage.FINISHED && toolCounts.size > 0) {
+    text += '\n\n---\n';
+    text += `Tools used: ${buildToolStats(toolCounts)}`;
+  }
+
+  return text;
+}
+
+/**
+ * Build a completion message.
+ */
+export function buildCompletionMessage(options: {
+  sessionName: string;
+  startTime: number;
+  toolsExecuted: number;
+  toolCounts: Map<string, number>;
+}): string {
+  const { sessionName, startTime, toolsExecuted, toolCounts } = options;
+  const elapsed = formatElapsedTime(startTime);
+
+  let text = `[${sessionName}] Task Complete\n\n`;
+  text += `🏁 *Finished*\n\n`;
+  text += buildProgressBar(100) + '\n\n';
+  text += `⏱ ${elapsed} | Tools: ${toolsExecuted}`;
+
+  if (toolCounts.size > 0) {
+    text += '\n\n---\n';
+    text += `Tools used: ${buildToolStats(toolCounts)}`;
+  }
+
+  return text;
+}

package/src/daemon/progress-tracker.ts

@@ -0,0 +1,365 @@
+/**
+ * Progress Tracker
+ *
+ * Manages per-session progress state and updates Telegram messages
+ * in-place using editMessageText.
+ */
+
+import TelegramBot from 'node-telegram-bot-api';
+import type { SessionManager } from './session-manager.js';
+import {
+  ProgressStage,
+  buildProgressMessage,
+  buildCompletionMessage,
+} from './progress-display.js';
+
+export interface SessionProgress {
+  sessionId: string;
+  sessionName: string;
+
+  // Message tracking
+  progressMessageId: number | null;
+  lastUpdateTime: number;
+
+  // Progress state
+  stage: ProgressStage;
+  currentTool: string | null;
+  toolStack: string[];
+
+  // Statistics
+  startTime: number;
+  toolsExecuted: number;
+  toolCounts: Map<string, number>;
+
+  // Settings
+  isActive: boolean;
+  showProgress: boolean;
+}
+
+export interface ProgressEvent {
+  type: 'pre_tool' | 'post_tool' | 'notification' | 'stop' | 'start';
+  session_name: string;
+  timestamp: string;
+  tool_name?: string;
+  tool_input?: Record<string, unknown>;
+  success?: boolean;
+  error?: string;
+  transcript_path?: string;
+}
+
+export class ProgressTracker {
+  private sessions: Map<string, SessionProgress> = new Map();
+  private bot: TelegramBot;
+  private chatId: number;
+  private sessionManager: SessionManager;
+
+  // Rate limiting
+  private lastUpdate: Map<string, number> = new Map();
+  private pendingUpdates: Map<string, NodeJS.Timeout> = new Map();
+  private readonly MIN_UPDATE_INTERVAL = 1000; // 1 second minimum between updates
+
+  constructor(bot: TelegramBot, chatId: number, sessionManager: SessionManager) {
+    this.bot = bot;
+    this.chatId = chatId;
+    this.sessionManager = sessionManager;
+  }
+
+  /**
+   * Get or create progress state for a session.
+   */
+  private getOrCreateProgress(sessionName: string): SessionProgress {
+    let progress = this.sessions.get(sessionName);
+
+    if (!progress) {
+      const session = this.sessionManager.getByName(sessionName);
+      progress = {
+        sessionId: session?.sessionId || sessionName,
+        sessionName,
+        progressMessageId: null,
+        lastUpdateTime: 0,
+        stage: ProgressStage.IDLE,
+        currentTool: null,
+        toolStack: [],
+        startTime: Date.now(),
+        toolsExecuted: 0,
+        toolCounts: new Map(),
+        isActive: true,
+        showProgress: true,
+      };
+      this.sessions.set(sessionName, progress);
+    }
+
+    return progress;
+  }
+
+  /**
+   * Handle session start event.
+   */
+  async handleSessionStart(sessionName: string): Promise<void> {
+    const progress = this.getOrCreateProgress(sessionName);
+    progress.startTime = Date.now();
+    progress.stage = ProgressStage.THINKING;
+    progress.isActive = true;
+    progress.toolsExecuted = 0;
+    progress.toolCounts.clear();
+    progress.toolStack = [];
+    progress.currentTool = null;
+
+    await this.sendOrUpdateProgressMessage(progress);
+  }
+
+  /**
+   * Handle PreToolUse hook event.
+   */
+  async handlePreTool(sessionName: string, toolName: string, toolInput?: Record<string, unknown>): Promise<void> {
+    const progress = this.getOrCreateProgress(sessionName);
+
+    // Reset start time if this is the first tool
+    if (progress.stage === ProgressStage.IDLE) {
+      progress.startTime = Date.now();
+    }
+
+    // Push tool onto stack (for nested tool calls)
+    progress.toolStack.push(toolName);
+    progress.currentTool = toolName;
+    progress.stage = ProgressStage.TOOL_RUNNING;
+    progress.isActive = true;
+
+    await this.sendOrUpdateProgressMessage(progress);
+  }
+
+  /**
+   * Handle PostToolUse hook event.
+   */
+  async handlePostTool(sessionName: string, toolName: string, success: boolean = true): Promise<void> {
+    const progress = this.getOrCreateProgress(sessionName);
+
+    // Pop tool from stack
+    const poppedTool = progress.toolStack.pop();
+
+    // Update statistics
+    progress.toolsExecuted++;
+    const currentCount = progress.toolCounts.get(toolName) || 0;
+    progress.toolCounts.set(toolName, currentCount + 1);
+
+    // Update state
+    if (progress.toolStack.length > 0) {
+      // Still have parent tools running
+      progress.currentTool = progress.toolStack[progress.toolStack.length - 1];
+      progress.stage = ProgressStage.TOOL_RUNNING;
+    } else {
+      // All tools complete
+      progress.currentTool = null;
+      progress.stage = ProgressStage.TOOL_COMPLETE;
+    }
+
+    await this.sendOrUpdateProgressMessage(progress);
+  }
+
+  /**
+   * Handle Stop hook event.
+   */
+  async handleStop(sessionName: string): Promise<void> {
+    const progress = this.sessions.get(sessionName);
+
+    if (!progress) {
+      return;
+    }
+
+    progress.stage = ProgressStage.FINISHED;
+    progress.currentTool = null;
+    progress.toolStack = [];
+    progress.isActive = false;
+
+    // Send final completion message
+    await this.sendCompletionMessage(progress);
+
+    // Clean up pending updates
+    const pendingTimeout = this.pendingUpdates.get(sessionName);
+    if (pendingTimeout) {
+      clearTimeout(pendingTimeout);
+      this.pendingUpdates.delete(sessionName);
+    }
+  }
+
+  /**
+   * Handle notification event.
+   */
+  async handleNotification(sessionName: string, message: string): Promise<void> {
+    const progress = this.getOrCreateProgress(sessionName);
+
+    // Just update the timestamp, don't change stage
+    progress.lastUpdateTime = Date.now();
+
+    // Optionally could update the message with notification info
+  }
+
+  /**
+   * Toggle progress display for a session.
+   */
+  setShowProgress(sessionName: string, show: boolean): void {
+    const progress = this.sessions.get(sessionName);
+    if (progress) {
+      progress.showProgress = show;
+    }
+  }
+
+  /**
+   * Send or update the progress message with rate limiting.
+   */
+  private async sendOrUpdateProgressMessage(progress: SessionProgress): Promise<void> {
+    if (!progress.showProgress) {
+      return;
+    }
+
+    const now = Date.now();
+    const lastTime = this.lastUpdate.get(progress.sessionName) || 0;
+
+    if (now - lastTime < this.MIN_UPDATE_INTERVAL) {
+      // Schedule update for later if not already scheduled
+      if (!this.pendingUpdates.has(progress.sessionName)) {
+        const timeout = setTimeout(async () => {
+          this.pendingUpdates.delete(progress.sessionName);
+          await this.doUpdateProgressMessage(progress);
+        }, this.MIN_UPDATE_INTERVAL - (now - lastTime));
+
+        this.pendingUpdates.set(progress.sessionName, timeout);
+      }
+      return;
+    }
+
+    await this.doUpdateProgressMessage(progress);
+  }
+
+  /**
+   * Actually send or update the progress message.
+   */
+  private async doUpdateProgressMessage(progress: SessionProgress): Promise<void> {
+    this.lastUpdate.set(progress.sessionName, Date.now());
+
+    const messageText = buildProgressMessage({
+      sessionName: progress.sessionName,
+      stage: progress.stage,
+      currentTool: progress.currentTool,
+      toolStack: progress.toolStack,
+      startTime: progress.startTime,
+      toolsExecuted: progress.toolsExecuted,
+      toolCounts: progress.toolCounts,
+      showDetails: false,
+    });
+
+    try {
+      if (progress.progressMessageId) {
+        // Edit existing message
+        await this.bot.editMessageText(messageText, {
+          chat_id: this.chatId,
+          message_id: progress.progressMessageId,
+          parse_mode: 'Markdown',
+        });
+      } else {
+        // Send new message with mute button
+        const sent = await this.bot.sendMessage(this.chatId, messageText, {
+          parse_mode: 'Markdown',
+          reply_markup: {
+            inline_keyboard: [[
+              { text: '🔕 Mute', callback_data: `progress_mute:${progress.sessionName}` },
+            ]],
+          },
+        });
+        progress.progressMessageId = sent.message_id;
+      }
+    } catch (error) {
+      // Message might have been deleted or content unchanged
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+      // If message was deleted or not found, create a new one
+      if (errorMessage.includes('message to edit not found') ||
+          errorMessage.includes('message is not modified')) {
+        // Content unchanged is fine, just skip
+        if (!errorMessage.includes('message is not modified')) {
+          progress.progressMessageId = null;
+          // Don't retry immediately to avoid spam
+        }
+      } else {
+        console.error('[ProgressTracker] Error updating message:', errorMessage);
+      }
+    }
+  }
+
+  /**
+   * Send final completion message.
+   */
+  private async sendCompletionMessage(progress: SessionProgress): Promise<void> {
+    const messageText = buildCompletionMessage({
+      sessionName: progress.sessionName,
+      startTime: progress.startTime,
+      toolsExecuted: progress.toolsExecuted,
+      toolCounts: progress.toolCounts,
+    });
+
+    try {
+      if (progress.progressMessageId) {
+        // Edit existing message to show completion
+        await this.bot.editMessageText(messageText, {
+          chat_id: this.chatId,
+          message_id: progress.progressMessageId,
+          parse_mode: 'Markdown',
+          reply_markup: { inline_keyboard: [] }, // Remove mute button
+        });
+      } else {
+        // Send new completion message
+        await this.bot.sendMessage(this.chatId, messageText, {
+          parse_mode: 'Markdown',
+        });
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      if (!errorMessage.includes('message is not modified')) {
+        console.error('[ProgressTracker] Error sending completion:', errorMessage);
+      }
+    }
+
+    // Clean up session progress
+    this.sessions.delete(progress.sessionName);
+  }
+
+  /**
+   * Handle callback query for mute button.
+   */
+  async handleCallback(query: TelegramBot.CallbackQuery): Promise<boolean> {
+    if (!query.data?.startsWith('progress_mute:')) {
+      return false;
+    }
+
+    const sessionName = query.data.replace('progress_mute:', '');
+    this.setShowProgress(sessionName, false);
+
+    // Remove the progress message
+    const progress = this.sessions.get(sessionName);
+    if (progress?.progressMessageId && query.message) {
+      try {
+        await this.bot.deleteMessage(this.chatId, progress.progressMessageId);
+      } catch {
+        // Ignore deletion errors
+      }
+      progress.progressMessageId = null;
+    }
+
+    await this.bot.answerCallbackQuery(query.id, { text: 'Progress muted' });
+    return true;
+  }
+
+  /**
+   * Clean up inactive sessions.
+   */
+  cleanup(): void {
+    const now = Date.now();
+    const maxAge = 30 * 60 * 1000; // 30 minutes
+
+    for (const [sessionName, progress] of this.sessions) {
+      if (!progress.isActive && now - progress.lastUpdateTime > maxAge) {
+        this.sessions.delete(sessionName);
+      }
+    }
+  }
+}

package/src/daemon/telegram-multi.ts

@@ -54,6 +54,7 @@ export class MultiTelegramManager {
   private pendingPermissions: Map<string, PendingPermission> = new Map();
   private messageToSession: Map<number, string> = new Map(); // messageId -> sessionId
   private isRunning = false;
+  private callbackInterceptors: Array<(query: TelegramBot.CallbackQuery) => Promise<boolean>> = [];
 
   constructor(config: MultiTelegramConfig, sessionManager: SessionManager) {
     this.config = {
@@ -68,6 +69,28 @@ export class MultiTelegramManager {
     this.setupCallbackHandler();
   }
 
+  /**
+   * Get the underlying bot instance for advanced operations.
+   */
+  getBot(): TelegramBot {
+    return this.bot;
+  }
+
+  /**
+   * Get the configured chat ID.
+   */
+  getChatId(): number {
+    return this.config.chatId;
+  }
+
+  /**
+   * Register a callback interceptor that handles callback queries before the default handler.
+   * Return true to indicate the query was handled and stop further processing.
+   */
+  registerCallbackInterceptor(handler: (query: TelegramBot.CallbackQuery) => Promise<boolean>): void {
+    this.callbackInterceptors.push(handler);
+  }
+
   start(): void {
     this.isRunning = true;
     console.error('[MultiTelegram] Bot started');
@@ -544,6 +567,16 @@ export class MultiTelegramManager {
     this.bot.on('callback_query', async (query) => {
       if (!query.data || !query.message) return;
 
+      // Check interceptors first
+      for (const interceptor of this.callbackInterceptors) {
+        try {
+          const handled = await interceptor(query);
+          if (handled) return;
+        } catch (error) {
+          console.error('[MultiTelegram] Callback interceptor error:', error);
+        }
+      }
+
       const [action, messageId] = query.data.split(':');
       const key = messageId;
 

package/src/telegram.ts

@@ -417,9 +417,12 @@ export class TelegramManager {
       }
 
       // User provided instructions - continue
+      // Include multiple fields for compatibility with different Claude Code versions
       return {
         decision: 'block',
         reason: response,
+        continue: true,
+        stopReason: response,
       };
     } catch (err) {
       clearInterval(reminderInterval);