claude-dev-env 1.25.1 → 1.26.0

package/hooks/lifecycle/{config-change-guard.py → config_change_guard.py}

@@ -1,11 +1,17 @@
 #!/usr/bin/env python3
+# pragma: no-tdd-gate
 from datetime import datetime
 import json
 import os
 import sys
 
 AUDIT_LOG = os.path.expanduser("~/.claude/cache/config-change-audit.log")
-KNOWN_HOOK_COUNT_FILE = os.path.expanduser("~/.claude/cache/known-hook-count.txt")
+# pragma: no-tdd-gate
+DEFAULT_KNOWN_HOOK_COUNT_FILE = os.path.expanduser("~/.claude/cache/known-hook-count.txt")
+
+
+def get_known_hook_count_file() -> str:
+    return os.environ.get("KNOWN_HOOK_COUNT_FILE", DEFAULT_KNOWN_HOOK_COUNT_FILE)
 
 
 def count_hooks_in_settings(file_path: str) -> int:
@@ -32,36 +38,45 @@ def write_audit_entry(source: str, file_path: str) -> None:
         pass
 
 
+# pragma: no-tdd-gate
 def guard_hook_injection(file_path: str) -> None:
     current_count = count_hooks_in_settings(file_path)
+    known_hook_count_file = get_known_hook_count_file()
 
-    if not os.path.exists(KNOWN_HOOK_COUNT_FILE):
+    if not os.path.exists(known_hook_count_file):
         try:
-            with open(KNOWN_HOOK_COUNT_FILE, "w") as count_file:
+            with open(known_hook_count_file, "w") as count_file:
                 count_file.write(str(current_count))
         except OSError:
             pass
         return
 
     try:
-        with open(KNOWN_HOOK_COUNT_FILE) as count_file:
+        with open(known_hook_count_file) as count_file:
             stored_count = int(count_file.read().strip())
     except (OSError, ValueError):
         stored_count = current_count
 
+    # pragma: no-tdd-gate
+    if current_count > stored_count:
+        block_reason = (
+            f"Hook count increased from {stored_count} to {current_count}. "
+            f"Review the added hook entries before proceeding. "
+            f"Delete known-hook-count.txt to reset."
+        )
+        block_payload = {
+            "decision": "block",
+            "reason": block_reason,
+        }
+        print(json.dumps(block_payload))
+        return
+
     try:
-        with open(KNOWN_HOOK_COUNT_FILE, "w") as count_file:
+        with open(known_hook_count_file, "w") as count_file:
             count_file.write(str(current_count))
     except OSError:
         pass
 
-    if current_count > stored_count:
-        block_decision = {
-            "decision": "block",
-            "reason": f"Hook count changed {stored_count} -> {current_count}. Delete known-hook-count.txt to reset.",
-        }
-        print(json.dumps(block_decision))
-
 
 def main() -> None:
     try:

package/hooks/lifecycle/test_config_change_guard.py

@@ -5,7 +5,7 @@ import sys
 from pathlib import Path
 
 
-HOOK_PATH = Path(__file__).parent / "config-change-guard.py"
+HOOK_PATH = Path(__file__).parent / "config_change_guard.py"
 
 
 def _run_hook(
@@ -52,8 +52,8 @@ def test_hook_count_increase_emits_user_visible_output(tmp_path: Path) -> None:
     block_payload = json.loads(hook_run.stdout)
     assert block_payload["decision"] == "block"
     assert "2" in block_payload["reason"] and "5" in block_payload["reason"]
-    assert block_payload["hookSpecificOutput"]["hookEventName"] == "ConfigChange"
-    assert "hook" in block_payload["hookSpecificOutput"]["additionalContext"].lower()
+    assert "hook" in block_payload["reason"].lower()
+    assert "hookSpecificOutput" not in block_payload
 
 
 def test_hook_count_stable_produces_no_output(tmp_path: Path) -> None:

package/hooks/notification/{attention-needed-notify.py → attention_needed_notify.py}

@@ -12,6 +12,7 @@ import sys
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from notification_utils import (
     notify_ntfy,
+    notify_discord,
     is_wsl,
     notify_windows,
     notify_wsl,
@@ -23,6 +24,7 @@ from notification_utils import (
 )
 
 DEFAULT_MESSAGE = "Input needed"
+ATTENTION_WEBHOOK_SECRET_ID = os.environ.get("BWS_DISCORD_ATTENTION_SECRET_ID", "")
 
 
 def get_question_from_stdin() -> str:
@@ -46,6 +48,11 @@ def main() -> None:
     question_text = get_question_from_stdin()
 
     notify_ntfy(title=project_name, message=question_text)
+    notify_discord(
+        title=project_name,
+        message=question_text,
+        webhook_secret_id=ATTENTION_WEBHOOK_SECRET_ID,
+    )
 
     if system == "Windows":
         sound_windows()

package/hooks/notification/{claude-notification-handler.py → claude_notification_handler.py}

@@ -8,6 +8,7 @@ import sys
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from notification_utils import (
     notify_ntfy,
+    notify_discord,
     is_wsl,
     notify_windows,
     notify_wsl,
@@ -16,6 +17,8 @@ from notification_utils import (
     get_project_name,
 )
 
+ATTENTION_WEBHOOK_SECRET_ID = os.environ.get("BWS_DISCORD_ATTENTION_SECRET_ID", "")
+
 
 def send_desktop_and_push_notification(
     project_name: str,
@@ -23,6 +26,11 @@ def send_desktop_and_push_notification(
     ntfy_priority: str,
 ) -> None:
     notify_ntfy(title=project_name, message=notification_message, priority=ntfy_priority)
+    notify_discord(
+        title=project_name,
+        message=notification_message,
+        webhook_secret_id=ATTENTION_WEBHOOK_SECRET_ID,
+    )
     system = platform.system()
     if system == "Windows":
         sound_windows()

package/hooks/notification/notification_utils.py

@@ -1,11 +1,19 @@
 #!/usr/bin/env python3
 
+import json
 import os
 import platform
 import subprocess
+from typing import Optional
 
-NTFY_TOPIC = os.environ.get("NTFY_TOPIC", "claude-notifications")
-NTFY_BASE_URL = f"https://ntfy.sh/{NTFY_TOPIC}"
+NTFY_TOPIC = os.environ.get("NTFY_TOPIC", "")
+BWS_FETCH_TIMEOUT_SECONDS = 10
+BWS_EXECUTABLE_NAME = "bws"
+BWS_SECRET_GET_OUTPUT_FORMAT = "json"
+BWS_SECRET_JSON_VALUE_FIELD = "value"
+DISCORD_WEBHOOK_CONTENT_TYPE_HEADER = "Content-Type: application/json"
+DISCORD_WEBHOOK_USERNAME = "Claude Code"
+NTFY_BASE_URL = f"https://ntfy.sh/{NTFY_TOPIC}" if NTFY_TOPIC else ""
 WINDOWS_CHIMES_PATH = os.path.join(os.environ.get("SYSTEMROOT", r"C:\Windows"), "Media", "Windows Battery Critical.wav")
 LINUX_NOTIFICATION_SOUND = os.environ.get("NOTIFICATION_SOUND", "/usr/share/sounds/freedesktop/stereo/message.oga")
 LINUX_NOTIFICATION_TIMEOUT_MS = "3000"
@@ -138,6 +146,8 @@ def notify_windows(title: str, message: str) -> None:
 
 
 def notify_ntfy(title: str, message: str, priority: str = "high") -> None:
+    if not NTFY_TOPIC:
+        return
     try:
         subprocess.Popen(
             [
@@ -155,6 +165,54 @@ def notify_ntfy(title: str, message: str, priority: str = "high") -> None:
         pass
 
 
+def fetch_bws_secret(secret_id: str) -> Optional[str]:
+    if not secret_id:
+        return None
+    try:
+        completed_bws_process = subprocess.run(
+            [BWS_EXECUTABLE_NAME, "secret", "get", secret_id, "--output", BWS_SECRET_GET_OUTPUT_FORMAT],
+            capture_output=True,
+            text=True,
+            timeout=BWS_FETCH_TIMEOUT_SECONDS,
+            check=True,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired, subprocess.CalledProcessError):
+        return None
+    try:
+        parsed_payload = json.loads(completed_bws_process.stdout)
+    except json.JSONDecodeError:
+        return None
+    secret_value = parsed_payload.get(BWS_SECRET_JSON_VALUE_FIELD)
+    if isinstance(secret_value, str):
+        return secret_value
+    return None
+
+
+def notify_discord(title: str, message: str, webhook_secret_id: str) -> None:
+    if not webhook_secret_id:
+        return
+    webhook_url = fetch_bws_secret(webhook_secret_id)
+    if not webhook_url:
+        return
+    discord_payload = json.dumps({
+        "username": DISCORD_WEBHOOK_USERNAME,
+        "content": f"**{title}**\n{message}",
+    })
+    try:
+        subprocess.Popen(
+            [
+                "curl", "-s",
+                "-H", DISCORD_WEBHOOK_CONTENT_TYPE_HEADER,
+                "-d", discord_payload,
+                webhook_url,
+            ],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    except FileNotFoundError:
+        pass
+
+
 def notify_linux() -> None:
     try:
         subprocess.Popen(

package/hooks/notification/subagent_complete_notify.py

@@ -0,0 +1,381 @@
+#!/usr/bin/env python3
+"""
+SubagentStop notification hook - cross-platform (Windows/Linux/WSL)
+Plays subtle sound + shows desktop notification when subagent completes.
+"""
+
+import json
+import subprocess
+import sys
+import platform
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from notification_utils import notify_discord
+
+NTFY_TOPIC = "claude-02633f9d93ea8794"
+DEFAULT_MESSAGE = "Task completed"
+ACTIVITY_WEBHOOK_SECRET_ID = os.environ.get("BWS_DISCORD_ACTIVITY_SECRET_ID", "")
+
+
+CACHE_DIR = os.path.join(os.path.expanduser("~"), ".claude", "cache")
+LOG_FILE = os.path.join(CACHE_DIR, "subagent-notify-debug.log")
+
+
+def log_debug(message: str) -> None:
+    """Append debug message to log file."""
+    try:
+        from datetime import datetime
+
+        with open(LOG_FILE, "a") as f:
+            f.write(f"{datetime.now().isoformat()} - {message}\n")
+    except Exception:
+        pass
+
+
+def get_task_info_from_stdin() -> str:
+    """Extract agent type and description from session transcript."""
+    try:
+        stdin_data = sys.stdin.read()
+        hook_input = json.loads(stdin_data)
+
+        agent_id = hook_input.get("agent_id", "")
+        transcript_path = hook_input.get("transcript_path", "")
+        agent_transcript_path = hook_input.get("agent_transcript_path", "")
+
+        log_debug(f"agent_id={agent_id}")
+
+        # Check if this is a prompt_suggestion agent (internal, skip notification)
+        if agent_transcript_path and "prompt_suggestion" in agent_transcript_path:
+            log_debug("skipping prompt_suggestion agent")
+            return ""  # Empty string signals to skip notification
+
+        # Skip if agent transcript doesn't exist (ephemeral/internal agent)
+        if not agent_transcript_path or not os.path.exists(agent_transcript_path):
+            log_debug(f"no agent transcript file, skipping")
+            return ""
+
+        if not transcript_path or not os.path.exists(transcript_path):
+            log_debug(f"transcript not found or empty path")
+            return f"Agent {agent_id} completed" if agent_id else DEFAULT_MESSAGE
+
+        # Find the Task tool call that spawned this agent (with retry for race condition)
+        import time
+
+        tool_use_id = None
+        for attempt in range(3):
+            with open(transcript_path, "r") as f:
+                for line in f:
+                    if agent_id in line and "agent_progress" in line:
+                        entry = json.loads(line)
+                        tool_use_id = entry.get("parentToolUseID", "")
+                        log_debug(f"found agent_progress, tool_use_id={tool_use_id}")
+                        break
+            if tool_use_id:
+                break
+            log_debug(f"attempt {attempt + 1}: no agent_progress yet, waiting...")
+            time.sleep(0.1)
+
+        if not tool_use_id:
+            log_debug(f"no tool_use_id found for agent {agent_id} after retries")
+            return f"Agent {agent_id} completed" if agent_id else DEFAULT_MESSAGE
+
+        # Find the Task tool input with description and subagent_type
+        with open(transcript_path, "r") as f:
+            for line in f:
+                if tool_use_id in line and '"name":"Task"' in line:
+                    entry = json.loads(line)
+                    message = entry.get("message", {})
+                    content = message.get("content", [])
+                    for item in content:
+                        if item.get("id") == tool_use_id:
+                            task_input = item.get("input", {})
+                            agent_type = task_input.get("subagent_type", "")
+                            description = task_input.get("description", "")
+                            log_debug(
+                                f"found Task input: type={agent_type}, desc={description}"
+                            )
+                            if agent_type and description:
+                                return f"{agent_type}: {description}"
+                            elif description:
+                                return description
+                            elif agent_type:
+                                return f"{agent_type} completed"
+                    break
+
+        log_debug(f"no Task tool found with id {tool_use_id}")
+        return f"Agent {agent_id} completed" if agent_id else DEFAULT_MESSAGE
+
+    except Exception as e:
+        log_debug(f"exception: {type(e).__name__}: {e}")
+    return DEFAULT_MESSAGE
+
+
+def get_project_name() -> str:
+    """Get project name from working directory."""
+    return os.path.basename(os.getcwd())
+
+
+def notify_ntfy(title: str, message: str, priority: str = "default") -> None:
+    """Send push notification via ntfy.sh with title and message."""
+    try:
+        subprocess.Popen(
+            [
+                "curl",
+                "-s",
+                "-H",
+                f"Priority: {priority}",
+                "-H",
+                "Tags: bell",
+                "-H",
+                f"Title: {title}",
+                "-d",
+                message,
+                f"https://ntfy.sh/{NTFY_TOPIC}",
+            ],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    except FileNotFoundError:
+        pass
+
+
+def is_wsl() -> bool:
+    """Detect if running in Windows Subsystem for Linux."""
+    if platform.system() != "Linux":
+        return False
+    try:
+        with open("/proc/version", "r") as f:
+            return "microsoft" in f.read().lower()
+    except FileNotFoundError:
+        return False
+
+
+TOAST_SCRIPT_TEMPLATE = r"""
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+public class Win32 {{
+    [DllImport("user32.dll")]
+    public static extern bool SetProcessDPIAware();
+    [DllImport("user32.dll")]
+    public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);
+    [DllImport("user32.dll")]
+    public static extern int GetWindowLong(IntPtr hWnd, int nIndex);
+    [DllImport("user32.dll")]
+    public static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);
+    [DllImport("user32.dll")]
+    public static extern bool SetLayeredWindowAttributes(IntPtr hwnd, uint crKey, byte bAlpha, uint dwFlags);
+    public static readonly IntPtr HWND_TOPMOST = new IntPtr(-1);
+    public const uint SWP_NOACTIVATE = 0x0010;
+    public const uint SWP_SHOWWINDOW = 0x0040;
+    public const int GWL_EXSTYLE = -20;
+    public const int WS_EX_LAYERED = 0x80000;
+    public const int WS_EX_TRANSPARENT = 0x20;
+    public const uint LWA_ALPHA = 0x2;
+}}
+"@
+
+# Enable DPI awareness for sharp text
+[Win32]::SetProcessDPIAware() | Out-Null
+
+$form = New-Object System.Windows.Forms.Form
+$form.FormBorderStyle = [System.Windows.Forms.FormBorderStyle]::None
+$form.Size = New-Object System.Drawing.Size(520, 110)
+$form.ShowInTaskbar = $false
+$form.BackColor = [System.Drawing.Color]::FromArgb(66, 135, 245)
+$form.StartPosition = [System.Windows.Forms.FormStartPosition]::Manual
+
+# Position at bottom center of primary screen
+$screen = [System.Windows.Forms.Screen]::PrimaryScreen.WorkingArea
+$x = [int]($screen.Left + ($screen.Width - 520) / 2)
+$y = [int]($screen.Bottom - 110 - 50)
+$form.Location = New-Object System.Drawing.Point($x, $y)
+
+# Inner panel for dark background (creates border effect)
+$inner = New-Object System.Windows.Forms.Panel
+$inner.Size = New-Object System.Drawing.Size(514, 104)
+$inner.Location = New-Object System.Drawing.Point(3, 3)
+$inner.BackColor = [System.Drawing.Color]::FromArgb(45, 45, 45)
+$form.Controls.Add($inner)
+
+# Title label (project name)
+$titleLabel = New-Object System.Windows.Forms.Label
+$titleLabel.Text = "{title}"
+$titleLabel.Font = New-Object System.Drawing.Font("Segoe UI", 12, [System.Drawing.FontStyle]::Bold)
+$titleLabel.ForeColor = [System.Drawing.Color]::FromArgb(120, 180, 255)
+$titleLabel.AutoSize = $false
+$titleLabel.Size = New-Object System.Drawing.Size(514, 30)
+$titleLabel.Location = New-Object System.Drawing.Point(0, 8)
+$titleLabel.TextAlign = [System.Drawing.ContentAlignment]::MiddleCenter
+$inner.Controls.Add($titleLabel)
+
+# Message label
+$messageLabel = New-Object System.Windows.Forms.Label
+$messageLabel.Text = "{message}"
+$messageLabel.Font = New-Object System.Drawing.Font("Segoe UI", 11)
+$messageLabel.ForeColor = [System.Drawing.Color]::White
+$messageLabel.AutoSize = $false
+$messageLabel.Size = New-Object System.Drawing.Size(500, 58)
+$messageLabel.Location = New-Object System.Drawing.Point(7, 40)
+$messageLabel.TextAlign = [System.Drawing.ContentAlignment]::TopCenter
+$inner.Controls.Add($messageLabel)
+
+$timer = New-Object System.Windows.Forms.Timer
+$timer.Interval = 6000
+$timer.Add_Tick({{ $form.Close() }})
+$timer.Start()
+
+# Make click-through and show without stealing focus
+$exStyle = [Win32]::GetWindowLong($form.Handle, [Win32]::GWL_EXSTYLE)
+[Win32]::SetWindowLong($form.Handle, [Win32]::GWL_EXSTYLE, $exStyle -bor [Win32]::WS_EX_LAYERED -bor [Win32]::WS_EX_TRANSPARENT)
+[Win32]::SetLayeredWindowAttributes($form.Handle, 0, 230, [Win32]::LWA_ALPHA)
+[Win32]::SetWindowPos($form.Handle, [Win32]::HWND_TOPMOST, $x, $y, 520, 110, [Win32]::SWP_NOACTIVATE -bor [Win32]::SWP_SHOWWINDOW)
+$form.Show()
+[System.Windows.Forms.Application]::Run($form)
+"""
+
+
+def build_toast_script(title: str, message: str) -> str:
+    """Build PowerShell toast script with dynamic title and message."""
+    safe_title = title.replace('"', '`"').replace("'", "`'")
+    safe_message = message.replace('"', '`"').replace("'", "`'")
+    return TOAST_SCRIPT_TEMPLATE.format(title=safe_title, message=safe_message)
+
+
+def notify_windows(title: str, message: str) -> None:
+    """Windows bottom-center toast notification - non-blocking, no title bar."""
+    script = build_toast_script(title, message)
+    subprocess.Popen(
+        ["powershell", "-ExecutionPolicy", "Bypass", "-Command", script],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        creationflags=subprocess.CREATE_NO_WINDOW
+        if hasattr(subprocess, "CREATE_NO_WINDOW")
+        else 0,
+    )
+
+
+def notify_wsl(title: str, message: str) -> None:
+    """WSL bottom-center toast notification - non-blocking, no title bar."""
+    script = build_toast_script(title, message)
+    try:
+        subprocess.Popen(
+            ["powershell.exe", "-ExecutionPolicy", "Bypass", "-Command", script],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+    except FileNotFoundError:
+        pass
+
+
+def notify_linux() -> None:
+    """Linux notification using notify-send."""
+    subprocess.Popen(
+        [
+            "notify-send",
+            "-t",
+            "3000",
+            "-i",
+            "dialog-information",
+            "Claude Code",
+            "Subagent task completed",
+        ],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+
+def sound_windows() -> None:
+    """Windows sound - play notification wav file."""
+    subprocess.Popen(
+        [
+            "powershell",
+            "-WindowStyle",
+            "Hidden",
+            "-Command",
+            "(New-Object Media.SoundPlayer 'C:\\Windows\\Media\\Windows Battery Critical.wav').PlaySync()",
+        ],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        creationflags=subprocess.CREATE_NO_WINDOW
+        if hasattr(subprocess, "CREATE_NO_WINDOW")
+        else 0,
+    )
+
+
+def sound_wsl() -> None:
+    """WSL sound - plays Windows notification wav via powershell.exe."""
+    try:
+        subprocess.Popen(
+            [
+                "powershell.exe",
+                "-WindowStyle",
+                "Hidden",
+                "-Command",
+                "(New-Object Media.SoundPlayer 'C:\\Windows\\Media\\Windows Battery Critical.wav').PlaySync()",
+            ],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    except FileNotFoundError:
+        pass
+
+
+def sound_linux() -> None:
+    """Linux sound - try multiple methods."""
+    sound_file = "/usr/share/sounds/freedesktop/stereo/message.oga"
+
+    if os.path.exists(sound_file):
+        for player in ["paplay", "aplay", "play"]:
+            try:
+                subprocess.Popen(
+                    [player, sound_file],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                )
+                return
+            except FileNotFoundError:
+                continue
+
+    # Fallback: terminal bell
+    print("\a", end="", flush=True)
+
+
+def main() -> None:
+    system = platform.system()
+
+    project_name = get_project_name()
+    task_description = get_task_info_from_stdin()
+
+    # Skip notification for internal agents (empty description)
+    if not task_description:
+        return
+
+    # Always send to phone with project context
+    notify_ntfy(title=project_name, message=task_description)
+    notify_discord(
+        title=project_name,
+        message=task_description,
+        webhook_secret_id=ACTIVITY_WEBHOOK_SECRET_ID,
+    )
+
+    if system == "Windows":
+        sound_windows()
+        notify_windows(project_name, task_description)
+    elif is_wsl():
+        sound_wsl()
+        notify_wsl(project_name, task_description)
+    elif system == "Linux":
+        sound_linux()
+        notify_linux()
+    else:
+        # macOS or other - just print bell
+        print("\a", end="", flush=True)
+
+
+if __name__ == "__main__":
+    main()

package/hooks/notification/test_attention_needed_notify.py

@@ -0,0 +1,47 @@
+"""Unit tests for attention-needed-notify Discord wiring."""
+
+import importlib.util
+import io
+import pathlib
+import types
+from unittest.mock import patch
+
+HOOK_DIRECTORY = pathlib.Path(__file__).parent
+MODULE_PATH = HOOK_DIRECTORY / "attention_needed_notify.py"
+
+FIXTURE_ATTENTION_SECRET_ID = "fixture-attention-id-0002"
+NON_WINDOWS_NON_WSL_PLATFORM = "Darwin"
+EMPTY_HOOK_INPUT_JSON = "{}"
+
+
+def load_hook_with_environment(
+    environment_overrides: dict[str, str],
+) -> types.ModuleType:
+    module_specification = importlib.util.spec_from_file_location(
+        "attention_needed_notify_under_test",
+        MODULE_PATH,
+    )
+    assert module_specification is not None
+    assert module_specification.loader is not None
+    module_under_test = importlib.util.module_from_spec(module_specification)
+    with patch.dict("os.environ", environment_overrides, clear=False):
+        module_specification.loader.exec_module(module_under_test)
+    return module_under_test
+
+
+def test_main_forwards_attention_secret_id_to_notify_discord() -> None:
+    module_under_test = load_hook_with_environment(
+        {"BWS_DISCORD_ATTENTION_SECRET_ID": FIXTURE_ATTENTION_SECRET_ID}
+    )
+    with (
+        patch.object(module_under_test, "notify_ntfy"),
+        patch.object(module_under_test, "notify_discord") as discord_spy,
+        patch.object(module_under_test, "is_wsl", return_value=False),
+        patch.object(module_under_test, "platform") as platform_stub,
+        patch("sys.stdin", io.StringIO(EMPTY_HOOK_INPUT_JSON)),
+    ):
+        platform_stub.system.return_value = NON_WINDOWS_NON_WSL_PLATFORM
+        module_under_test.main()
+    assert discord_spy.call_count == 1
+    call_kwargs = discord_spy.call_args.kwargs
+    assert call_kwargs["webhook_secret_id"] == FIXTURE_ATTENTION_SECRET_ID