feat: show per-container memory on kill buttons + memory freed on stop (v0.17.0)

Memory-pressure warning/critical alerts now show each killable container's
RAM usage on its Stop button and in the alert text. Stopping a container
(button or auto-kill) reports how much it was using and the system memory
level afterwards. MemoryMonitor reads stats itself for just the killable
containers (get_killable_memory, bounded by stats_timeout), so it works
even when resource monitoring is disabled; kill_container returns KillResult.

Claude-Session: https://claude.ai/code/session_013fuQC7uuGuYTK8M3Jp5FpS

Author: dervish666

.claude/structure/monitors.yaml

@@ -174,6 +174,10 @@ files:
         kind: enum
         description: System memory pressure state (NORMAL, WARNING, CRITICAL, KILLING, RECOVERING)
 
+      - name: KillResult
+        kind: dataclass
+        description: Outcome of stopping a container (success, name, freed_bytes, system_percent, system_available_bytes) for user feedback
+
       - name: MemoryMonitor
         kind: class
         description: Monitors system memory, sends escalated alerts, kills/restarts containers to manage memory pressure
@@ -184,9 +188,12 @@ files:
           - name: get_memory_percent
             params: []
             returns: float
+          - name: get_killable_memory
+            params: []
+            returns: Awaitable[list[tuple[str, int | None]]]
           - name: kill_container
             params: [{name: name, type: str}]
-            returns: Awaitable[bool]
+            returns: Awaitable[KillResult]
           - name: cancel_pending_kill
             params: []
             returns: bool

CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to UnraidMonitor will be documented in this file.
 
+## [0.17.0] - 2026-06-28
+
+### Added
+- **Per-container memory on the kill buttons** — the memory-pressure warning/critical alerts now show how much RAM each killable container is using right on its "⏹ Stop" button (and in the alert text), so you can free the most memory first. `MemoryMonitor` now reads this itself for just the killable containers (`get_killable_memory`), so it works even when resource monitoring is disabled and is robust if Docker is slow under pressure (bounded by `stats_timeout`, falls back to names-only).
+- **Memory feedback when a container is stopped** — stopping a container (via button or the auto-kill countdown) now reports how much memory it was using and the system memory level afterwards (e.g. "It was using ~1.8GB. System memory now 78% (6.2GB free)."). `kill_container` returns a new `KillResult` carrying this context.
+
+### Changed
+- The memory alert handler no longer depends on the resource monitor for button labels — memory figures are supplied by `MemoryMonitor` through the alert itself.
+- The auto-kill confirmation reads system memory *after* the stop (it previously reported the pre-kill figure).
+
 ## [0.16.1] - 2026-06-25
 
 ### Fixed

CLAUDE.md

@@ -93,7 +93,7 @@ src/utils/version_store.py - read/write data/announced_version.json for startup
 
 ## Project Overview
 
-Unraid Server Monitor Bot (v0.16.1) - A Docker-based Telegram bot for monitoring Unraid servers. Monitors Docker containers (events, logs, resources) and Unraid server health (CPU, memory, disks, array, UPS). Uses multi-provider LLM support (Anthropic, OpenAI, Ollama) for AI-powered diagnostics and natural language interaction. Sends alerts via Telegram with quick-action buttons.
+Unraid Server Monitor Bot (v0.17.0) - A Docker-based Telegram bot for monitoring Unraid servers. Monitors Docker containers (events, logs, resources) and Unraid server health (CPU, memory, disks, array, UPS). Uses multi-provider LLM support (Anthropic, OpenAI, Ollama) for AI-powered diagnostics and natural language interaction. Sends alerts via Telegram with quick-action buttons.
 
 **Version string lives in TWO places** — `pyproject.toml` (`version`) and `src/__init__.py` (`__version__`). Both must be bumped together on release; `tests/test_version.py` guards against drift. `BOT_VERSION` (in `src/bot/health_command.py`) resolves from installed package metadata when available, else falls back to `src.__version__` — the package is not installed in the Docker image, so the `__version__` fallback is what runs in production.
 

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unraid-monitor-bot"
-version = "0.16.1"
+version = "0.17.0"
 requires-python = ">=3.11"
 dependencies = [
     "docker>=7.0.0,<8.0.0",

src/__init__.py

@@ -1 +1 @@
-__version__ = "0.16.1"
+__version__ = "0.17.0"

src/bot/alert_callbacks.py

@@ -26,7 +26,7 @@
 from src.state import ContainerStateManager
 from src.services.container_control import ContainerController
 from src.services.diagnostic import DiagnosticService
-from src.utils.formatting import validate_container_name, escape_markdown, truncate_callback_data, format_duration_minutes
+from src.utils.formatting import validate_container_name, escape_markdown, truncate_callback_data, format_duration_minutes, format_bytes
 from src.utils.sanitize import sanitize_logs_for_display
 from src.utils.telegram_format import markdown_to_telegram_html
 
@@ -384,13 +384,23 @@ async def handler(callback: CallbackQuery) -> None:
 
         await callback.answer(f"Stopping {container_name}...")
 
-        success = await memory_monitor.kill_container(container_name)
+        result = await memory_monitor.kill_container(container_name)
 
         if callback.message:
-            if success:
-                await callback.message.answer(
-                    f"⏹ Stopped *{escape_markdown(container_name)}* to free memory.", parse_mode="Markdown"
-                )
+            if result.success:
+                lines = [f"⏹ Stopped *{escape_markdown(container_name)}* to free memory."]
+                if result.freed_bytes:
+                    lines.append(f"It was using ~{format_bytes(result.freed_bytes)}.")
+                if result.system_percent is not None:
+                    free = (
+                        format_bytes(result.system_available_bytes)
+                        if result.system_available_bytes is not None
+                        else "?"
+                    )
+                    lines.append(
+                        f"System memory now {result.system_percent:.0f}% ({free} free)."
+                    )
+                await callback.message.answer(" ".join(lines), parse_mode="Markdown")
             else:
                 await callback.message.answer(
                     f"❌ Failed to stop {container_name}. It may already be stopped."

src/constants.py

@@ -111,6 +111,10 @@
 # Shown once when BOT_VERSION first differs from data/announced_version.json.
 ANNOUNCED_VERSION_PATH = "data/announced_version.json"
 WHATS_NEW: dict[str, list[str]] = {
+    "0.17.0": [
+        "Memory pressure alerts now show how much RAM each container is using right on the Stop buttons, so you can free the most memory first",
+        "When a container is stopped to free memory, the bot tells you how much it was using and how much system memory is now free",
+    ],
     "0.16.0": [
         "Health check in the Unraid dashboard - the container now reports healthy/unhealthy in docker ps and the Unraid UI, no setup needed",
         "No more lost boot alerts - alerts queued before your first /start are retried if Telegram is flaky during delivery, instead of vanishing",

src/monitor_callbacks.py

@@ -15,6 +15,7 @@
 from src.alerts.rate_limiter import RateLimiter
 from src.alert_proxy import AlertManagerProxy
 from src.monitors.resource_monitor import ResourceMonitor
+from src.utils.formatting import format_bytes
 from src.utils.telegram_retry import send_with_retry
 
 
@@ -155,11 +156,13 @@ async def on_server_alert(title: str, message: str, alert_type: str) -> None:
 def make_memory_alert_handler(
     chat_id_store: ChatIdStore,
     bot: Bot,
-    resource_monitor: ResourceMonitor | None,
     escape_markdown_fn: Callable[[str], str],
-) -> Callable[[str, str, str, list[str]], Awaitable[None]]:
+) -> Callable[[str, str, str, list[tuple[str, int | None]]], Awaitable[None]]:
     async def on_memory_alert(
-        title: str, message: str, alert_type: str, killable_names: list[str]
+        title: str,
+        message: str,
+        alert_type: str,
+        killable: list[tuple[str, int | None]],
     ) -> None:
         chat_ids = chat_id_store.get_all_chat_ids()
         if not chat_ids:
@@ -169,37 +172,25 @@ async def on_memory_alert(
         alert_text = f"{emoji} *{escape_markdown_fn(title)}*\n\n{message}"
         keyboard = None
 
-        if alert_type in ("warning", "critical") and killable_names:
-            # Try to get per-container memory stats for button labels
-            stats_by_name: dict[str, str] = {}
-            if resource_monitor is not None:
-                try:
-                    all_stats = await asyncio.wait_for(
-                        resource_monitor.get_all_stats(), timeout=5.0
-                    )
-                    stats_by_name = {s.name: s.memory_display for s in all_stats}
-                except Exception:
-                    pass  # Graceful degradation -- buttons without memory info
-
-            if alert_type == "warning":
-                buttons = []
-                for name in killable_names:
-                    mem = stats_by_name.get(name, "")
-                    label = f"⏹ Stop {name}" + (f" ({mem})" if mem else "")
-                    buttons.append(
-                        [InlineKeyboardButton(text=label, callback_data=f"mem_kill:{name}")]
-                    )
-                if buttons:
-                    keyboard = InlineKeyboardMarkup(inline_keyboard=buttons)
-
-            elif alert_type == "critical":
-                target = killable_names[0]
-                mem = stats_by_name.get(target, "")
-                kill_label = f"⏹ Kill {target} Now" + (f" ({mem})" if mem else "")
-                keyboard = InlineKeyboardMarkup(inline_keyboard=[
-                    [InlineKeyboardButton(text=kill_label, callback_data=f"mem_kill:{target}")],
-                    [InlineKeyboardButton(text="❌ Cancel Auto-Kill", callback_data="mem_cancel_kill")],
-                ])
+        # Memory usage per container is supplied by the MemoryMonitor (it only
+        # queries the killable containers, so this is robust even when the
+        # resource monitor is disabled or Docker is slow under pressure).
+        if alert_type == "warning" and killable:
+            buttons = []
+            for name, mem in killable:
+                label = f"⏹ Stop {name}" + (f" ({format_bytes(mem)})" if mem else "")
+                buttons.append(
+                    [InlineKeyboardButton(text=label, callback_data=f"mem_kill:{name}")]
+                )
+            keyboard = InlineKeyboardMarkup(inline_keyboard=buttons)
+
+        elif alert_type == "critical" and killable:
+            target, mem = killable[0]
+            kill_label = f"⏹ Kill {target} Now" + (f" ({format_bytes(mem)})" if mem else "")
+            keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                [InlineKeyboardButton(text=kill_label, callback_data=f"mem_kill:{target}")],
+                [InlineKeyboardButton(text="❌ Cancel Auto-Kill", callback_data="mem_cancel_kill")],
+            ])
 
         for cid in chat_ids:
             try: