emdash-cli 0.1.67__py3-none-any.whl → 0.1.70__py3-none-any.whl

emdash_cli/commands/agent/constants.py

@@ -9,6 +9,74 @@ class AgentMode(Enum):
     CODE = "code"
 
 
+# Subcommands for slash commands that have them
+SLASH_SUBCOMMANDS = {
+    "/telegram": {
+        "setup": "Configure bot token and authorize chats",
+        "connect": "Start the Telegram bridge",
+        "status": "Show current configuration",
+        "test": "Send a test message",
+        "disconnect": "Disable Telegram integration",
+        "settings": "View/modify settings",
+    },
+    "/session": {
+        "save": "Save current session (e.g., /session save my-task)",
+        "load": "Load a saved session",
+        "list": "List all saved sessions",
+        "delete": "Delete a saved session",
+    },
+    "/agents": {
+        "create": "Create a new agent",
+        "show": "Show agent details",
+        "edit": "Edit an existing agent",
+        "delete": "Delete an agent",
+        "list": "List all agents",
+    },
+    "/hooks": {
+        "list": "List all hooks",
+        "add": "Add a new hook",
+        "remove": "Remove a hook",
+        "toggle": "Enable/disable a hook",
+    },
+    "/rules": {
+        "list": "List all rules",
+        "add": "Add a new rule",
+        "delete": "Delete a rule",
+    },
+    "/skills": {
+        "list": "List all skills",
+        "show": "Show skill details",
+        "add": "Add a new skill",
+        "delete": "Delete a skill",
+    },
+    "/index": {
+        "status": "Show index status",
+        "start": "Start indexing",
+        "hook": "Manage index hooks (install/uninstall)",
+    },
+    "/mcp": {
+        "list": "List MCP servers",
+        "edit": "Edit MCP configuration",
+    },
+    "/auth": {
+        "login": "Login to GitHub",
+        "logout": "Logout from GitHub",
+        "status": "Show auth status",
+    },
+    "/registry": {
+        "skills": "Browse skills",
+        "rules": "Browse rules",
+        "agents": "Browse agents",
+        "verifiers": "Browse verifiers",
+        "install": "Install from registry",
+    },
+    "/verify": {
+        "run": "Run verification checks",
+        "list": "List available verifiers",
+        "add": "Add a verifier",
+    },
+}
+
 # Slash commands available in interactive mode
 SLASH_COMMANDS = {
     # Mode switching

emdash_cli/commands/agent/handlers/telegram.py

@@ -47,6 +47,9 @@ def handle_telegram(args: str) -> None:
     elif subcommand == "settings":
         _handle_settings(subargs)
 
+    elif subcommand == "commands":
+        _handle_commands()
+
     else:
         console.print(f"[{Colors.WARNING}]Unknown subcommand: {subcommand}[/{Colors.WARNING}]")
         console.print(f"[{Colors.DIM}]Run /telegram help for usage[/{Colors.DIM}]")
@@ -81,6 +84,7 @@ def _show_telegram_help() -> None:
         ("/telegram connect", "Start the Telegram bridge (foreground)"),
         ("/telegram disconnect", "Disable Telegram integration"),
         ("/telegram settings", "View/modify settings"),
+        ("/telegram commands", "Show BotFather command list to copy"),
     ]
 
     console.print(f"  [{Colors.DIM}]Commands:[/{Colors.DIM}]")
@@ -473,3 +477,47 @@ def _handle_settings(args: str) -> None:
 
     save_config(config)
     console.print(f"  [{Colors.SUCCESS}]Setting updated: {key} = {value}[/{Colors.SUCCESS}]")
+
+
+def _handle_commands() -> None:
+    """Show BotFather command list for easy copy-paste."""
+    from ..constants import SLASH_COMMANDS
+
+    console.print()
+    console.print(f"[{Colors.MUTED}]{header('BotFather Commands', SEPARATOR_WIDTH)}[/{Colors.MUTED}]")
+    console.print()
+    console.print(f"  [{Colors.DIM}]Copy the following and paste to @BotFather after /setcommands:[/{Colors.DIM}]")
+    console.print()
+    console.print(f"  [{Colors.MUTED}]{'─' * 60}[/{Colors.MUTED}]")
+
+    # Generate command list in BotFather format
+    # Format: command - description (no leading slash, underscores instead of hyphens)
+    for cmd, desc in SLASH_COMMANDS.items():
+        # Skip telegram and quit commands (not useful via Telegram)
+        if cmd in ("/telegram", "/quit", "/paste"):
+            continue
+
+        # Convert /cmd-name to cmd_name (BotFather format)
+        botfather_cmd = cmd.lstrip("/").replace("-", "_")
+
+        # Remove any argument placeholders from command
+        if " " in botfather_cmd:
+            botfather_cmd = botfather_cmd.split()[0]
+
+        # Truncate description if too long (BotFather has limits)
+        short_desc = desc.split("(")[0].strip()  # Remove parenthetical notes
+        if len(short_desc) > 50:
+            short_desc = short_desc[:47] + "..."
+
+        console.print(f"  {botfather_cmd} - {short_desc}")
+
+    console.print(f"  [{Colors.MUTED}]{'─' * 60}[/{Colors.MUTED}]")
+    console.print()
+    console.print(f"  [{Colors.DIM}]Steps:[/{Colors.DIM}]")
+    console.print(f"  [{Colors.SUBTLE}]1. Open @BotFather in Telegram[/{Colors.SUBTLE}]")
+    console.print(f"  [{Colors.SUBTLE}]2. Send /setcommands[/{Colors.SUBTLE}]")
+    console.print(f"  [{Colors.SUBTLE}]3. Select your bot[/{Colors.SUBTLE}]")
+    console.print(f"  [{Colors.SUBTLE}]4. Paste the command list above[/{Colors.SUBTLE}]")
+    console.print()
+    console.print(f"[{Colors.MUTED}]{footer(SEPARATOR_WIDTH)}[/{Colors.MUTED}]")
+    console.print()

emdash_cli/commands/agent/interactive.py

@@ -10,7 +10,7 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.markdown import Markdown
 
-from .constants import AgentMode, SLASH_COMMANDS
+from .constants import AgentMode, SLASH_COMMANDS, SLASH_SUBCOMMANDS
 from .onboarding import is_first_run, run_onboarding
 from .help import show_command_help
 from .session_restore import get_recent_session, show_session_restore_prompt
@@ -177,6 +177,7 @@ def run_interactive(
     from prompt_toolkit.completion import Completer, Completion
     from prompt_toolkit.styles import Style
     from prompt_toolkit.key_binding import KeyBindings
+    from prompt_toolkit.formatted_text import FormattedText
 
     # Current mode
     current_mode = AgentMode(options.get("mode", "code"))
@@ -206,6 +207,10 @@ def run_interactive(
         "completion-menu.meta.completion": f"bg:#1a1a2e {Colors.MUTED}",
         "completion-menu.meta.completion.current": f"bg:#2a2a3e {Colors.SUBTLE}",
         "command": f"{Colors.PRIMARY} bold",
+        # Styled completion text
+        "slash-cmd": f"{Colors.ACCENT} bold",
+        "sub-cmd": f"{Colors.SUCCESS}",
+        "file-ref": f"{Colors.WARNING}",
         # Zen bottom toolbar styles
         "bottom-toolbar": f"bg:#1a1a1a {Colors.DIM}",
         "bottom-toolbar.brand": f"bg:#1a1a1a {Colors.PRIMARY}",
@@ -238,11 +243,14 @@ def run_interactive(
                             rel_path = match.relative_to(cwd)
                         except ValueError:
                             rel_path = match
-                        # Replace from @ onwards
+                        # Replace from @ onwards - styled display
+                        styled_display = FormattedText([
+                            ("class:file-ref", f"@{rel_path}")
+                        ])
                         yield Completion(
                             f"@{rel_path}",
                             start_position=-(len(query) + 1),  # +1 for @
-                            display=str(rel_path),
+                            display=styled_display,
                             display_meta="file",
                         )
                     return
@@ -250,14 +258,45 @@ def run_interactive(
             # Handle slash commands
             if not text.startswith("/"):
                 return
+
+            # Check if we're completing a subcommand (e.g., "/telegram " or "/telegram c")
+            parts = text.split(maxsplit=1)
+            base_cmd = parts[0]
+
+            # If we have a space after base command, show subcommands
+            if len(parts) > 1 or text.endswith(" "):
+                subcommand_prefix = parts[1] if len(parts) > 1 else ""
+                if base_cmd in SLASH_SUBCOMMANDS:
+                    subcommands = SLASH_SUBCOMMANDS[base_cmd]
+                    for subcmd, description in subcommands.items():
+                        if subcmd.startswith(subcommand_prefix):
+                            # Styled display for subcommand
+                            styled_display = FormattedText([
+                                ("class:sub-cmd", subcmd)
+                            ])
+                            yield Completion(
+                                subcmd,
+                                start_position=-len(subcommand_prefix),
+                                display=styled_display,
+                                display_meta=description,
+                            )
+                return
+
+            # Otherwise show main slash commands
             for cmd, description in SLASH_COMMANDS.items():
                 # Extract base command (e.g., "/pr" from "/pr [url]")
-                base_cmd = cmd.split()[0]
-                if base_cmd.startswith(text):
+                cmd_base = cmd.split()[0]
+                if cmd_base.startswith(text):
+                    # Add space suffix for commands with subcommands to trigger subcommand completion
+                    completion_text = cmd_base + " " if cmd_base in SLASH_SUBCOMMANDS else cmd_base
+                    # Styled display for slash command
+                    styled_display = FormattedText([
+                        ("class:slash-cmd", cmd)
+                    ])
                     yield Completion(
-                        base_cmd,
+                        completion_text,
                         start_position=-len(text),
-                        display=cmd,
+                        display=styled_display,
                         display_meta=description,
                     )
 
@@ -269,10 +308,17 @@ def run_interactive(
     # Key bindings: Enter submits, Alt+Enter inserts newline
     kb = KeyBindings()
 
-    @kb.add("enter", eager=True)
+    @kb.add("enter")
     def submit_on_enter(event):
-        """Submit on Enter."""
-        event.current_buffer.validate_and_handle()
+        """Submit on Enter, or select completion if menu is open."""
+        buffer = event.current_buffer
+        # If completion menu is open, accept the selected completion
+        if buffer.complete_state and buffer.complete_state.current_completion:
+            completion = buffer.complete_state.current_completion
+            buffer.apply_completion(completion)
+            return
+        # Otherwise submit the input
+        buffer.validate_and_handle()
 
     @kb.add("escape", "enter")  # Alt+Enter (Escape then Enter)
     @kb.add("c-j")  # Ctrl+J as alternative for newline

emdash_cli/integrations/telegram/bridge.py

@@ -21,6 +21,30 @@ from .formatter import SSEEventFormatter, TelegramMessage as FormattedMessage
 # Default EmDash server URL
 DEFAULT_SERVER_URL = "http://localhost:8765"
 
+# Telegram-only commands (not forwarded to agent)
+# All other /commands are forwarded to the EmDash agent
+TELEGRAM_COMMANDS = {
+    "/start",      # Telegram welcome message
+    "/stop",       # Cancel current operation
+    "/cancel",     # Cancel pending interaction
+    "/tgstatus",   # Telegram bot status
+    "/tgsettings", # Telegram display settings
+    "/tghelp",     # Telegram help
+    "/thinking",   # Toggle thinking display
+    "/tools",      # Toggle tool calls display
+    "/plan",       # Switch to plan mode
+    "/code",       # Switch to code mode
+    "/mode",       # Show current mode
+    "/reset",      # Reset session
+}
+
+# Map BotFather command format (underscores) to EmDash format (hyphens)
+# BotFather doesn't allow hyphens in command names
+COMMAND_ALIASES = {
+    "/todo_add": "/todo-add",
+    "/verify_loop": "/verify-loop",
+}
+
 
 @dataclass
 class PendingInteraction:
@@ -50,6 +74,9 @@ class BridgeState:
     # Pending interactions requiring user response (per chat)
     pending: dict[int, PendingInteraction] = field(default_factory=dict)
 
+    # Current mode per chat (code or plan)
+    modes: dict[int, str] = field(default_factory=dict)
+
 
 class TelegramBridge:
     """Bridge between Telegram and EmDash agent.
@@ -175,40 +202,71 @@ class TelegramBridge:
         await self._process_agent_message(chat_id, text)
 
     async def _handle_command(self, chat_id: int, text: str) -> None:
-        """Handle Telegram bot commands.
+        """Handle slash commands.
+
+        Telegram-specific commands (in TELEGRAM_COMMANDS) are handled locally.
+        All other slash commands are forwarded to the EmDash agent.
 
         Args:
             chat_id: Chat ID
-            text: Command text
+            text: Command text (e.g., "/plan" or "/todo_add Fix tests")
         """
         parts = text.split(maxsplit=1)
         command = parts[0].lower()
         args = parts[1] if len(parts) > 1 else ""
 
+        # Handle Telegram-specific commands locally
+        if command in TELEGRAM_COMMANDS:
+            await self._handle_telegram_command(chat_id, command, args)
+            return
+
+        # Apply command aliases (BotFather format -> EmDash format)
+        if command in COMMAND_ALIASES:
+            command = COMMAND_ALIASES[command]
+
+        # Forward to agent as a slash command
+        message = f"{command} {args}".strip() if args else command
+        await self._process_agent_message(chat_id, message)
+
+    async def _handle_telegram_command(self, chat_id: int, command: str, args: str) -> None:
+        """Handle Telegram-specific commands.
+
+        Args:
+            chat_id: Chat ID
+            command: Command name (e.g., "/start")
+            args: Command arguments
+        """
         if command == "/start":
             await self._send_message(
                 chat_id,
                 "*EmDash Bot*\n\n"
                 "Send me a message and I'll process it with the EmDash agent.\n\n"
-                "*Commands:*\n"
-                "/status - Show connection status\n"
+                "*Mode commands:*\n"
+                "/plan - Switch to plan mode\n"
+                "/code - Switch to code mode\n"
+                "/mode - Show current mode\n"
+                "/reset - Reset session\n\n"
+                "*Telegram-only commands:*\n"
                 "/stop - Cancel current operation\n"
                 "/cancel - Cancel pending interaction\n"
-                "/compact - Toggle compact mode\n"
+                "/tgstatus - Show bot connection status\n"
+                "/tgsettings - Show display settings\n"
                 "/thinking - Toggle showing agent thinking\n"
                 "/tools - Toggle showing tool calls\n"
-                "/settings - Show current settings\n"
-                "/help - Show this help",
+                "/tghelp - Show this help",
             )
 
-        elif command == "/status":
+        elif command == "/tgstatus":
             session_id = self.state.sessions.get(chat_id)
             pending = self.state.pending.get(chat_id)
+            current_mode = self.state.modes.get(chat_id, "code")
             status = "Connected" if session_id else "No active session"
             pending_status = f"\n*Pending:* {pending.type}" if pending else ""
+            mode_emoji = "📋" if current_mode == "plan" else "💻"
             await self._send_message(
                 chat_id,
                 f"*Status:* {status}\n"
+                f"*Mode:* {mode_emoji} {current_mode}\n"
                 f"*Server:* `{self.server_url}`"
                 f"{pending_status}",
             )
@@ -227,11 +285,6 @@ class TelegramBridge:
             else:
                 await self._send_message(chat_id, "No pending interaction.")
 
-        elif command == "/compact":
-            self.config.settings.compact_mode = not self.config.settings.compact_mode
-            status = "enabled" if self.config.settings.compact_mode else "disabled"
-            await self._send_message(chat_id, f"Compact mode {status}.")
-
         elif command == "/thinking":
             self.config.settings.show_thinking = not self.config.settings.show_thinking
             status = "enabled" if self.config.settings.show_thinking else "disabled"
@@ -242,42 +295,98 @@ class TelegramBridge:
             status = "enabled" if self.config.settings.show_tool_calls else "disabled"
             await self._send_message(chat_id, f"Show tool calls {status}.")
 
-        elif command == "/settings":
+        elif command == "/tgsettings":
             await self._send_message(
                 chat_id,
-                "*Current Settings:*\n\n"
-                f"Compact mode: `{self.config.settings.compact_mode}`\n"
+                "*Telegram Display Settings:*\n\n"
                 f"Show thinking: `{self.config.settings.show_thinking}`\n"
                 f"Show tools: `{self.config.settings.show_tool_calls}`\n"
+                f"Compact mode: `{self.config.settings.compact_mode}`\n"
                 f"Update interval: `{self.config.settings.update_interval_ms}ms`",
             )
 
-        elif command == "/help":
+        elif command == "/tghelp":
             await self._send_message(
                 chat_id,
-                "*EmDash Bot Help*\n\n"
-                "Send any message to interact with the EmDash agent.\n\n"
-                "*Commands:*\n"
-                "/start - Welcome message\n"
-                "/status - Show connection status\n"
+                "*EmDash Telegram Bot*\n\n"
+                "Send any message or slash command to interact with the EmDash agent.\n\n"
+                "*Mode commands:*\n"
+                "/plan - Switch to plan mode (read-only exploration)\n"
+                "/code - Switch to code mode (execute changes)\n"
+                "/mode - Show current mode\n"
+                "/reset - Reset session\n\n"
+                "*Agent commands (forwarded):*\n"
+                "/todos - Show todo list\n"
+                "/status - Show project status\n"
+                "/help - Show all agent commands\n\n"
+                "*Telegram-only commands:*\n"
                 "/stop - Cancel current operation\n"
                 "/cancel - Cancel pending interaction\n"
-                "/compact - Toggle compact mode\n"
-                "/thinking - Toggle showing agent thinking\n"
-                "/tools - Toggle showing tool calls\n"
-                "/settings - Show current settings\n"
-                "/help - This help message\n\n"
+                "/tgstatus - Bot connection status\n"
+                "/tgsettings - Display settings\n"
+                "/thinking - Toggle thinking display\n"
+                "/tools - Toggle tool calls display\n"
+                "/tghelp - This help message\n\n"
                 "*Responding to questions:*\n"
-                "When the agent asks a question with options, reply with the option number (1, 2, 3...) "
-                "or type your answer directly.\n\n"
+                "Reply with option number (1, 2, 3...) or type your answer.\n\n"
                 "*Plan approval:*\n"
-                'Reply "approve", "yes", or "y" to approve a plan.\n'
-                'Reply "reject", "no", or "n" to reject.\n'
-                "Or type feedback to request changes.",
+                'Reply "yes" to approve, "no" to reject, or type feedback.',
             )
 
-        else:
-            await self._send_message(chat_id, f"Unknown command: {command}")
+        elif command == "/plan":
+            # Switch to plan mode and reset session
+            self.state.modes[chat_id] = "plan"
+            if chat_id in self.state.sessions:
+                del self.state.sessions[chat_id]
+                await self._send_message(
+                    chat_id,
+                    "✅ Switched to *plan mode* (session reset)\n\n"
+                    "_Plan mode explores the codebase and creates plans without making changes._",
+                )
+            else:
+                await self._send_message(
+                    chat_id,
+                    "✅ Switched to *plan mode*\n\n"
+                    "_Plan mode explores the codebase and creates plans without making changes._",
+                )
+
+        elif command == "/code":
+            # Switch to code mode and reset session
+            self.state.modes[chat_id] = "code"
+            if chat_id in self.state.sessions:
+                del self.state.sessions[chat_id]
+                await self._send_message(
+                    chat_id,
+                    "✅ Switched to *code mode* (session reset)\n\n"
+                    "_Code mode can execute changes and modify files._",
+                )
+            else:
+                await self._send_message(
+                    chat_id,
+                    "✅ Switched to *code mode*\n\n"
+                    "_Code mode can execute changes and modify files._",
+                )
+
+        elif command == "/mode":
+            current_mode = self.state.modes.get(chat_id, "code")
+            if current_mode == "plan":
+                await self._send_message(
+                    chat_id,
+                    "📋 Current mode: *plan*\n\n"
+                    "_Use /code to switch to code mode._",
+                )
+            else:
+                await self._send_message(
+                    chat_id,
+                    "💻 Current mode: *code*\n\n"
+                    "_Use /plan to switch to plan mode._",
+                )
+
+        elif command == "/reset":
+            # Reset session for this chat
+            if chat_id in self.state.sessions:
+                del self.state.sessions[chat_id]
+            await self._send_message(chat_id, "🔄 Session reset.")
 
     async def _process_agent_message(self, chat_id: int, message: str) -> None:
         """Process a message through the EmDash agent.
@@ -311,7 +420,10 @@ class TelegramBridge:
             update_interval = self.config.settings.update_interval_ms / 1000.0
             has_sent_response = False
 
-            async for event_type, data in self._stream_agent_chat(message, session_id):
+            # Get current mode for this chat (default to code)
+            current_mode = self.state.modes.get(chat_id, "code")
+
+            async for event_type, data in self._stream_agent_chat(message, session_id, current_mode):
                 # Check if cancelled
                 if not self.state.processing.get(chat_id):
                     break
@@ -388,12 +500,14 @@ class TelegramBridge:
         self,
         message: str,
         session_id: str | None = None,
+        mode: str = "code",
     ) -> AsyncIterator[tuple[str, dict]]:
         """Stream agent chat response via SSE.
 
         Args:
             message: User message
             session_id: Optional session ID for continuity
+            mode: Agent mode (code or plan)
 
         Yields:
             Tuples of (event_type, data)
@@ -406,6 +520,7 @@ class TelegramBridge:
             "options": {
                 "max_iterations": 50,
                 "verbose": True,
+                "mode": mode,
             },
         }
 

emdash_cli/integrations/telegram/formatter.py

@@ -279,14 +279,21 @@ class SSEEventFormatter:
         """Format final response event."""
         content = data.get("content", "")
 
+        # Check if we were streaming partial content (should update existing message)
+        was_streaming = bool(self.aggregator.content)
+
         # Reset aggregator
         self.aggregator.reset()
 
         # Format response with icon
         if self.compact:
-            return TelegramMessage(text=content, parse_mode="Markdown")
+            return TelegramMessage(text=content, parse_mode="Markdown", is_update=was_streaming)
 
-        return TelegramMessage(text=f"{ICON_RESPONSE}\n\n{content}", parse_mode="Markdown")
+        return TelegramMessage(
+            text=f"{ICON_RESPONSE}\n\n{content}",
+            parse_mode="Markdown",
+            is_update=was_streaming,
+        )
 
     def _format_error(self, data: dict) -> TelegramMessage:
         """Format error event."""

{emdash_cli-0.1.67.dist-info → emdash_cli-0.1.70.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emdash-cli
-Version: 0.1.67
+Version: 0.1.70
 Summary: EmDash CLI - Command-line interface for code intelligence
 Author: Em Dash Team
 Requires-Python: >=3.10,<4.0
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: click (>=8.1.7,<9.0.0)
-Requires-Dist: emdash-core (>=0.1.67)
+Requires-Dist: emdash-core (>=0.1.70)
 Requires-Dist: httpx (>=0.25.0)
 Requires-Dist: prompt_toolkit (>=3.0.43,<4.0.0)
 Requires-Dist: rich (>=13.7.0)

{emdash_cli-0.1.67.dist-info → emdash_cli-0.1.70.dist-info}/RECORD

@@ -4,7 +4,7 @@ emdash_cli/clipboard.py,sha256=3iwkfj4Od1gPSsMbIBc6sx9XH2XCNgvc5Uu2pPRGcpw,2371
 emdash_cli/commands/__init__.py,sha256=kApebp8AegR0ULBvRVSu36RpMrVluvKq1oN2W0f1onQ,721
 emdash_cli/commands/agent/__init__.py,sha256=Q02HtlODcid-YS_HDqBjbW6V8Xg9pYy0gWvrxn1EB9E,410
 emdash_cli/commands/agent/cli.py,sha256=bfRSRAo6exy3llBoHS81AgGKP36xJ3MyL9eoLBtnJW4,2975
-emdash_cli/commands/agent/constants.py,sha256=9v5WCV66wK0WYKfrFX4T-9LAT3be1QYtMdYRniH7qIU,2409
+emdash_cli/commands/agent/constants.py,sha256=R67iPmrXXXG0qJgwKdgDxEWPd86lqDrxhfm_Zj_I91s,4446
 emdash_cli/commands/agent/file_utils.py,sha256=2YOKybPVGyjmImbqLHQOIL7zDKeVjQMWssAh9ZX1_Vc,5257
 emdash_cli/commands/agent/handlers/__init__.py,sha256=GxVjekZX-H0QaUs0t0-7mO9AVHOJhNzv4MdkuqvyHqc,1210
 emdash_cli/commands/agent/handlers/agents.py,sha256=T0f0qqYedHX80JCgCPTvHAuyYiLldZlXu7ICjsMnOOM,16002
@@ -19,11 +19,11 @@ emdash_cli/commands/agent/handlers/rules.py,sha256=N84ngO9yGIEMFIGlyd8Ga2pHpTKAY
 emdash_cli/commands/agent/handlers/sessions.py,sha256=hx4Mri4pGu0sb6xkotBYG8SkuhDbg40JntjbW8qQp9Y,6610
 emdash_cli/commands/agent/handlers/setup.py,sha256=i9k3WMSIcFlB2JdxWto5bW5C3Q93iK_qS5QKPV2f5qA,20840
 emdash_cli/commands/agent/handlers/skills.py,sha256=yL2GkChl9WG4fvs1-Ep3JnZfqBH2ZsCcPKkrrPyTPPM,15864
-emdash_cli/commands/agent/handlers/telegram.py,sha256=aDpgHEa2Zm6d8ngNGY28_gnuIihfCq5qcXJ3tBaydp4,18239
+emdash_cli/commands/agent/handlers/telegram.py,sha256=vQq__-PkTd67PlZBkm3XB9gwmcpAij_H1Lo_cWOn7E0,20340
 emdash_cli/commands/agent/handlers/todos.py,sha256=otvtDKetsqcXKWRL82Ja8-FrpwTd-3iNRhAWCXboYqQ,4931
 emdash_cli/commands/agent/handlers/verify.py,sha256=5i4qbRbisRcFau8_Btpi-SbZDEyFb-pY9w8_WbE-qyQ,20919
 emdash_cli/commands/agent/help.py,sha256=-3L--ja02ikS163k4jUa7yvSAH6N7T1lZgY3ad8olrc,8730
-emdash_cli/commands/agent/interactive.py,sha256=aSkqCXozIICRLl-r3gtHAbtJiSo3mM-vWEXn6AUzP_M,32076
+emdash_cli/commands/agent/interactive.py,sha256=VlXprjFVqYW0ym_jPiX3mS9CuUK_kofzMQfADnoInps,34440
 emdash_cli/commands/agent/menus.py,sha256=S6AylgFuAWmZHr-ix43sp_Y1U627Ltz2eyX6we5amhE,22865
 emdash_cli/commands/agent/onboarding.py,sha256=fAqY9zR1gGCnwT0o0h3QmWLRg-PQpiQ_SyulUKBsX78,21617
 emdash_cli/commands/agent/session_restore.py,sha256=cbGVlkNtcZFahFuCBWpDY0FIYBGnUaIxX2i_CxmP-xo,6231
@@ -49,15 +49,15 @@ emdash_cli/diff_renderer.py,sha256=OrYsKcYZZob6nQ-z7xB_jseGYLoK8czTDJrOiriWlOo,1
 emdash_cli/integrations/__init__.py,sha256=9SFXQiGeuVpLw21_kKBZgToAHC_9gQ31xDMffUaGo70,31
 emdash_cli/integrations/telegram/__init__.py,sha256=mULT7y1k1CTvBLeuckBh_nBS_gCzU_t9r0U0AIT1lrY,369
 emdash_cli/integrations/telegram/bot.py,sha256=3qTYPue9XJeZi3sqlu4B9WQ1lxwXaWIOaE2O9hDAKTI,11032
-emdash_cli/integrations/telegram/bridge.py,sha256=dTT3wQxXhLMUCxLbAvSjaDDsFb3ovPUu2jUolHo8IXU,31420
+emdash_cli/integrations/telegram/bridge.py,sha256=i74f5Gb2PiqpDuybBRmEoFVvDQTYsCTQLQ7W93P7VNM,36080
 emdash_cli/integrations/telegram/config.py,sha256=RQxm3Qw9L7mepRm6YgbndVy35rc_RBaE7th_XjFtKoI,4546
-emdash_cli/integrations/telegram/formatter.py,sha256=RkW24K6pef57Ogx8M_9NdUVI8sk1Xa1rzZjqPtwr3g0,12197
+emdash_cli/integrations/telegram/formatter.py,sha256=emh6ggnL2fa2GOm8xjkIL7LnUFv9pdNWtABbda2gIpc,12435
 emdash_cli/keyboard.py,sha256=haYYAuhYGtdjomzhIFy_3Z3eN3BXfMdb4uRQjwB0tbk,4593
 emdash_cli/main.py,sha256=ZtESOZsr9ocljiIjijaRnz-9IiepNbwhJZOj-7MhLzA,4111
 emdash_cli/server_manager.py,sha256=saSxTaCu-b2n2-cIA3VzUe-Tj8ABpeZ39TPOdqjBzVI,9397
 emdash_cli/session_store.py,sha256=GjS73GLSZ3oTNtrFHMcyiP6GnH0Dvfvs6r4s3-bfEaM,9424
 emdash_cli/sse_renderer.py,sha256=6kDiL2otmZYy--WRI8X0FuDYtW-hY4UAqvqVCoexCOg,48864
-emdash_cli-0.1.67.dist-info/METADATA,sha256=xTKZmM1ushcb-PDdI0AfBvzvRwUqW4RdNRutTHeR0cI,662
-emdash_cli-0.1.67.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-emdash_cli-0.1.67.dist-info/entry_points.txt,sha256=31CuYD0k-tM8csFWDunc-JoZTxXaifj3oIXz4V0p6F0,122
-emdash_cli-0.1.67.dist-info/RECORD,,
+emdash_cli-0.1.70.dist-info/METADATA,sha256=d0gsrSNwIWRSKepGCzD8oH5zhV5gQ_ZWBDS8A1bnRPQ,662
+emdash_cli-0.1.70.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+emdash_cli-0.1.70.dist-info/entry_points.txt,sha256=31CuYD0k-tM8csFWDunc-JoZTxXaifj3oIXz4V0p6F0,122
+emdash_cli-0.1.70.dist-info/RECORD,,