timeout-dead 0.1.1__tar.gz → 0.2.0__tar.gz

timeout_dead-0.2.0/.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+  "cSpell.words": [
+    "creationflags",
+    "getpgid",
+    "killpg",
+    "pgid"
+  ]
+}

{timeout_dead-0.1.1 → timeout_dead-0.2.0}/AGENTS.md

@@ -37,20 +37,32 @@ If the user asks "what should the commit message be?" — **suggest a message bu
 
 ## Workflow & Verification Commands
 
+### Setup
+
+```bash
+uv tool install timeout-dead
+```
+
+Если уже установлена — убедись что работает:
+
+```bash
+time-d -h
+```
+
 ### Time limit (HARD REQUIREMENT)
 
 **Every bash command MUST complete within 60 seconds.** All commands must be invoked through the timeout wrapper:
 
 ```bash
-timeout-dead --sec 60 "<your command>"
+time-d --sec 60 "<your command>"
 ```
 
 Long-running daemons must use `nohup ... >/dev/null 2>&1 &` so the wrapper returns immediately.
 
-### Setup
+### Install dependencies
 
 ```bash
-timeout-dead --sec 60 "uv sync"
+time-d --sec 60 "uv sync"
 ```
 
 ### Verify after changes
@@ -58,16 +70,16 @@ timeout-dead --sec 60 "uv sync"
 Run **all** checks in this order — treat errors as blockers:
 
 ```bash
-timeout-dead --sec 60 "ruff check ."
-timeout-dead --sec 60 "ruff format --check ."
-timeout-dead --sec 60 "pyright ."
-timeout-dead --sec 60 "python -m pytest tests/ -v"
+time-d --sec 60 "ruff check ."
+time-d --sec 60 "ruff format --check ."
+time-d --sec 60 "pyright ."
+time-d --sec 60 "python -m pytest tests/ -v"
 ```
 
 ### Fix formatting & imports
 
 ```bash
-timeout-dead --sec 60 "ruff check --fix . && ruff format ."
+time-d --sec 60 "ruff check --fix . && ruff format ."
 ```
 
 **LSP is mandatory.** Configure `pyright-langserver` and `ruff server` in your editor. After every change, confirm lint, format, and type-check show **0 errors**. `ruff format` is the single source of truth for formatting — no `black`, no `isort`.
@@ -75,7 +87,7 @@ timeout-dead --sec 60 "ruff check --fix . && ruff format ."
 ### Run a single test
 
 ```bash
-timeout-dead --sec 60 "python -m pytest tests/test_file.py::test_name -v"
+time-d --sec 60 "python -m pytest tests/test_file.py::test_name -v"
 ```
 
 ### Mandatory testing
@@ -170,19 +182,19 @@ class ConflictError(BaseError):
 ### Unit Tests
 
 - Tests live in `tests/` mirroring the source structure.
-- Run unit tests: `timeout-dead --sec 60 "pytest tests/ -v --ignore=tests/integration"`.
+- Run unit tests: `time-d --sec 60 "pytest tests/ -v --ignore=tests/integration"`.
 
 ### Integration Tests
 
 - Place integration tests in `tests/integration/`. Use `@pytest.mark.integration` marker.
-- Run integration tests: `timeout-dead --sec 60 "pytest tests/integration/ -v -m \"integration\""`.
-- Run unit tests only: `timeout-dead --sec 60 "pytest tests/ -v -m \"not integration\""`.
+- Run integration tests: `time-d --sec 60 "pytest tests/integration/ -v -m \"integration\""`.
+- Run unit tests only: `time-d --sec 60 "pytest tests/ -v -m \"not integration\""`.
 
 ### Coverage
 
 - Aim for high coverage of core business logic. Use `pytest-cov` to measure:
   ```bash
-  timeout-dead --sec 60 "pytest tests/ --cov=src/timeout_dead --cov-report=term-missing"
+  time-d --sec 60 "pytest tests/ --cov=src/timeout_dead --cov-report=term-missing"
   ```
 
 ## Environment & Configuration

{timeout_dead-0.1.1 → timeout_dead-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: timeout-dead
-Version: 0.1.1
+Version: 0.2.0
 Summary: Lightweight command timeout utility with zero runtime dependencies
 Author-email: Dmitry Krivoruchko <umbrella.leaf.for.work@gmail.com>
 License-Expression: Unlicense
@@ -67,6 +67,9 @@ time-d "echo hello"
 # Specify a custom timeout
 timeout-dead --sec 120 "npm run build"
 
+# Sub-second timeouts work too
+timeout-dead --sec 0.5 "potentially-hanging-tool"
+
 # Use SIGINT instead of default SIGTERM
 timeout-dead --signal INT --sec 30 "long-running-server"
 
@@ -77,7 +80,7 @@ timeout-dead --no-output "curl -s https://example.com"
 ## Usage
 
 ```
-usage: timeout-dead [-h] [--sec SECONDS] [--signal SIGNAL] [--no-output] COMMAND ...
+usage: timeout-dead [-h] [-v] [--sec SECONDS] [--signal SIGNAL] [--no-output] COMMAND ...
 
 Lightweight command timeout utility.
 
@@ -86,7 +89,8 @@ positional arguments:
 
 options:
   -h, --help            show this help message and exit
-  --sec SECONDS         timeout in seconds (default: 60)
+  -v, --version         show version and exit
+  --sec SECONDS         timeout in seconds (default: 60.0, accepts floats)
   --signal SIGNAL       signal to send on timeout (TERM, KILL, HUP, INT)
   --no-output           suppress normal output (stdout, stderr, header, footer)
 ```
@@ -103,12 +107,41 @@ options:
 
 ## Signal reference
 
-| Signal | Unix | Windows |
-|--------|------|---------|
+| Signal | Unix                                  | Windows                            |
+| ------ | ------------------------------------- | ---------------------------------- |
 | `TERM` | `SIGTERM` (15) — terminate gracefully | `CTRL_BREAK_EVENT` — console break |
-| `KILL` | `SIGKILL` (9) — force kill | Falls back to `TerminateProcess` |
-| `HUP`  | `SIGHUP` (1) — hangup | Falls back to `TerminateProcess` |
-| `INT`  | `SIGINT` (2) — interrupt (Ctrl+C) | `CTRL_C_EVENT` — console interrupt |
+| `KILL` | `SIGKILL` (9) — force kill            | Falls back to `TerminateProcess`   |
+| `HUP`  | `SIGHUP` (1) — hangup                 | Falls back to `TerminateProcess`   |
+| `INT`  | `SIGINT` (2) — interrupt (Ctrl+C)     | `CTRL_C_EVENT` — console interrupt |
+
+## Why `subprocess` timeout is not enough
+
+Python's built-in `subprocess` timeout only kills the direct child, not its entire process tree. If your command spawns subprocesses (`npm install`, `make`, `docker build`), children survive the parent kill.
+
+`timeout-dead` uses **process groups** to terminate everything — every subprocess, pipeline, and child.
+
+## Real-world scenarios
+
+| Scenario         | Command                   | Why it hangs                                            | `timeout-dead`                                           |
+| ---------------- | ------------------------- | ------------------------------------------------------- | -------------------------------------------------------- |
+| Gradle build     | `./gradlew build`         | 20+ min fresh build, agent generates duplicate commands | `timeout-dead --sec 600 "./gradlew build"`               |
+| CMake build      | `cmake --build .`         | Locks waiting for dependency resolution                 | `timeout-dead --sec 180 "cmake --build ."`               |
+| Spring Boot      | `./gradlew bootRun`       | Server never exits, agent won't proceed                 | `timeout-dead --sec 30 --signal INT "./gradlew bootRun"` |
+| Docker build     | `docker build -t myapp .` | Network timeout, internal retries, no progress          | `timeout-dead --sec 600 "docker build -t myapp ."`       |
+| npm install      | `npm install`             | Corrupted cache or registry auth hang                   | `timeout-dead --sec 300 "npm install"`                   |
+| Interactive REPL | `python` / `node` / `irb` | Waits for input, agent doesn't know                     | `timeout-dead --sec 5 "python"`                          |
+
+## For AI agents
+
+If you build agents that execute shell commands, `timeout-dead` is essential infrastructure. Agents frequently generate commands that hang — waiting for input, entering infinite loops, or starting interactive programs.
+
+Instead of agents freezing indefinitely, wrap every command:
+
+```bash
+timeout-dead --sec <timeout> --signal <signal> "<command>"
+```
+
+No dependencies, no code changes. Agent always gets a response — exit code + output — and can implement retry, fallback, or user notification.
 
 ## Development
 

{timeout_dead-0.1.1 → timeout_dead-0.2.0}/README.md

@@ -41,6 +41,9 @@ time-d "echo hello"
 # Specify a custom timeout
 timeout-dead --sec 120 "npm run build"
 
+# Sub-second timeouts work too
+timeout-dead --sec 0.5 "potentially-hanging-tool"
+
 # Use SIGINT instead of default SIGTERM
 timeout-dead --signal INT --sec 30 "long-running-server"
 
@@ -51,7 +54,7 @@ timeout-dead --no-output "curl -s https://example.com"
 ## Usage
 
 ```
-usage: timeout-dead [-h] [--sec SECONDS] [--signal SIGNAL] [--no-output] COMMAND ...
+usage: timeout-dead [-h] [-v] [--sec SECONDS] [--signal SIGNAL] [--no-output] COMMAND ...
 
 Lightweight command timeout utility.
 
@@ -60,7 +63,8 @@ positional arguments:
 
 options:
   -h, --help            show this help message and exit
-  --sec SECONDS         timeout in seconds (default: 60)
+  -v, --version         show version and exit
+  --sec SECONDS         timeout in seconds (default: 60.0, accepts floats)
   --signal SIGNAL       signal to send on timeout (TERM, KILL, HUP, INT)
   --no-output           suppress normal output (stdout, stderr, header, footer)
 ```
@@ -77,12 +81,41 @@ options:
 
 ## Signal reference
 
-| Signal | Unix | Windows |
-|--------|------|---------|
+| Signal | Unix                                  | Windows                            |
+| ------ | ------------------------------------- | ---------------------------------- |
 | `TERM` | `SIGTERM` (15) — terminate gracefully | `CTRL_BREAK_EVENT` — console break |
-| `KILL` | `SIGKILL` (9) — force kill | Falls back to `TerminateProcess` |
-| `HUP`  | `SIGHUP` (1) — hangup | Falls back to `TerminateProcess` |
-| `INT`  | `SIGINT` (2) — interrupt (Ctrl+C) | `CTRL_C_EVENT` — console interrupt |
+| `KILL` | `SIGKILL` (9) — force kill            | Falls back to `TerminateProcess`   |
+| `HUP`  | `SIGHUP` (1) — hangup                 | Falls back to `TerminateProcess`   |
+| `INT`  | `SIGINT` (2) — interrupt (Ctrl+C)     | `CTRL_C_EVENT` — console interrupt |
+
+## Why `subprocess` timeout is not enough
+
+Python's built-in `subprocess` timeout only kills the direct child, not its entire process tree. If your command spawns subprocesses (`npm install`, `make`, `docker build`), children survive the parent kill.
+
+`timeout-dead` uses **process groups** to terminate everything — every subprocess, pipeline, and child.
+
+## Real-world scenarios
+
+| Scenario         | Command                   | Why it hangs                                            | `timeout-dead`                                           |
+| ---------------- | ------------------------- | ------------------------------------------------------- | -------------------------------------------------------- |
+| Gradle build     | `./gradlew build`         | 20+ min fresh build, agent generates duplicate commands | `timeout-dead --sec 600 "./gradlew build"`               |
+| CMake build      | `cmake --build .`         | Locks waiting for dependency resolution                 | `timeout-dead --sec 180 "cmake --build ."`               |
+| Spring Boot      | `./gradlew bootRun`       | Server never exits, agent won't proceed                 | `timeout-dead --sec 30 --signal INT "./gradlew bootRun"` |
+| Docker build     | `docker build -t myapp .` | Network timeout, internal retries, no progress          | `timeout-dead --sec 600 "docker build -t myapp ."`       |
+| npm install      | `npm install`             | Corrupted cache or registry auth hang                   | `timeout-dead --sec 300 "npm install"`                   |
+| Interactive REPL | `python` / `node` / `irb` | Waits for input, agent doesn't know                     | `timeout-dead --sec 5 "python"`                          |
+
+## For AI agents
+
+If you build agents that execute shell commands, `timeout-dead` is essential infrastructure. Agents frequently generate commands that hang — waiting for input, entering infinite loops, or starting interactive programs.
+
+Instead of agents freezing indefinitely, wrap every command:
+
+```bash
+timeout-dead --sec <timeout> --signal <signal> "<command>"
+```
+
+No dependencies, no code changes. Agent always gets a response — exit code + output — and can implement retry, fallback, or user notification.
 
 ## Development
 

{timeout_dead-0.1.1 → timeout_dead-0.2.0}/src/timeout_dead/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.1'
-__version_tuple__ = version_tuple = (0, 1, 1)
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)
 
-__commit_id__ = commit_id = 'g86f511007'
+__commit_id__ = commit_id = 'gd1dae1c5b'

{timeout_dead-0.1.1 → timeout_dead-0.2.0}/src/timeout_dead/cli.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 
-"""Легковесная утилита для запуска команд с таймаутом."""
+"""Lightweight command timeout utility."""
 
 import argparse
 import os
@@ -10,6 +10,8 @@ import subprocess
 import sys
 import threading
 import time
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _get_version
 
 
 # MARK: Constants
@@ -17,13 +19,13 @@ import time
 
 
 class _Const:
-  DEFAULT_TIMEOUT_S: int = 60
+  DEFAULT_TIMEOUT_S: float = 60.0
   GRACE_PERIOD_S: float = 1.0
-  HEADER_SEPARATOR: str = "-" * 60
+  HEADER_SEPARATOR: str = "-" * 50
 
   MSG_NO_COMMAND: str = "Error: no command specified"
-  MSG_BASH_NOT_FOUND: str = "bash not found in PATH — Git Bash is required"
-  MSG_TIMEOUT: str = "Timeout exceeded {} seconds"
+  MSG_BASH_NOT_FOUND: str = "bash not found in PATH"
+  MSG_TIMEOUT: str = "Timeout exceeded {}s"
   MSG_EXEC_ERROR: str = "Execution error: {}"
 
   SIGNAL_NAMES: tuple[str, ...] = ("TERM", "KILL", "HUP", "INT")
@@ -35,6 +37,17 @@ class _Const:
     "INT": signal.SIGINT,
   }
 
+  @staticmethod
+  def _resolve_version() -> str:
+    try:
+      return _get_version("timeout-dead")
+
+    except PackageNotFoundError:
+      return "unknown"
+
+
+_PROJECT_VERSION: str = _Const._resolve_version()
+
 
 # MARK: Private Helpers
 # ------------------------------------------------
@@ -49,13 +62,13 @@ def _is_windows() -> bool:
 
 def _find_bash() -> str:
   """
-  Ищет bash в PATH.
+  Locate bash executable in PATH.
 
   Returns:
-    str: путь к исполняемому файлу bash
+    str: path to the bash executable
 
   Raises:
-    SystemExit: если bash не найден
+    SystemExit: if bash is not found
   """
 
   bash_path = shutil.which("bash")
@@ -77,7 +90,7 @@ def _terminate_process(
   force: bool = False,
   signal_num: int = signal.SIGTERM,
 ) -> None:
-  """Завершает процесс — мягко (выбранным сигналом) или жёстко."""
+  """Terminate the process — gracefully (chosen signal) or forcefully."""
 
   if process.poll() is not None:
     return
@@ -112,10 +125,10 @@ def _terminate_process(
 
 def _kill_with_timeout(
   process: subprocess.Popen[bytes] | subprocess.Popen[str],
-  timeout: int,
+  timeout: float,
   signal_num: int = signal.SIGTERM,
 ) -> None:
-  """Убивает процесс по таймауту с двухэтапной логикой."""
+  """Kill the process after timeout with two-stage logic."""
 
   if process.poll() is not None:
     return
@@ -135,21 +148,21 @@ def _kill_with_timeout(
 
 def run_command(
   command_string: str,
-  timeout: int = _Const.DEFAULT_TIMEOUT_S,
+  timeout: float = _Const.DEFAULT_TIMEOUT_S,
   signal_name: str = "TERM",
   no_output: bool = False,
 ) -> int:
   """
-  Запускает команду с таймаутом через bash.
+  Run a command with timeout via bash.
 
   Args:
-    command_string (str): команда для выполнения
-    timeout (int): таймаут в секундах
-    signal_name (str): имя сигнала для мягкого завершения
-    no_output (bool): подавлять ли обычный вывод
+    command_string (str): command to execute
+    timeout (float): timeout in seconds
+    signal_name (str): signal name for graceful termination
+    no_output (bool): suppress normal output
 
   Returns:
-    int: код возврата процесса (-1 при ошибке запуска)
+    int: process return code (-1 on launch error)
   """
 
   signal_num = _Const.SIGNAL_MAP.get(signal_name, signal.SIGTERM)
@@ -157,7 +170,10 @@ def run_command(
   timer: threading.Timer | None = None
 
   try:
-    creationflags = getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0) if _is_windows() else 0
+    creationflags = (
+      getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0) if _is_windows() else 0
+    )
+
     start_new_session = not _is_windows()
 
     process = subprocess.Popen(
@@ -190,6 +206,7 @@ def run_command(
   except Exception as e:
     if timer:
       timer.cancel()
+
     if process and process.poll() is None:
       try:
         _terminate_process(process, force=True)
@@ -206,16 +223,23 @@ def run_command(
 
 
 def parse_arguments(argv: list[str] | None = None) -> argparse.Namespace:
-  """Разбирает аргументы командной строки."""
+  """Parse command-line arguments."""
 
   parser = argparse.ArgumentParser(
     description="Lightweight command timeout utility.",
     formatter_class=argparse.RawDescriptionHelpFormatter,
   )
 
+  parser.add_argument(
+    "-v",
+    "--version",
+    action="version",
+    version=f"timeout-dead {_PROJECT_VERSION}",
+  )
+
   parser.add_argument(
     "--sec",
-    type=int,
+    type=float,
     default=_Const.DEFAULT_TIMEOUT_S,
     help=f"timeout in seconds (default: {_Const.DEFAULT_TIMEOUT_S})",
     metavar="SECONDS",
@@ -250,8 +274,8 @@ def parse_arguments(argv: list[str] | None = None) -> argparse.Namespace:
 # ------------------------------------------------
 
 
-def print_header(command: str, timeout: int) -> None:
-  """Выводит заголовок выполнения."""
+def print_header(command: str, timeout: float) -> None:
+  """Print execution header."""
 
   print(f"Running: {command}")
   print(f"Timeout: {timeout} seconds")
@@ -262,7 +286,7 @@ def print_header(command: str, timeout: int) -> None:
 
 
 def print_footer(return_code: int) -> None:
-  """Выводит футер выполнения."""
+  """Print execution footer."""
 
   print(_Const.HEADER_SEPARATOR)
   print(f"Exit code: {return_code}")
@@ -272,7 +296,7 @@ def print_footer(return_code: int) -> None:
 
 
 def main(argv: list[str] | None = None) -> None:
-  """Главная точка входа."""
+  """Main entry point."""
 
   args = parse_arguments(argv)
 

{timeout_dead-0.1.1 → timeout_dead-0.2.0}/src/timeout_dead.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ uv.lock
 .github/workflows/pyright.yml
 .github/workflows/ruff.yml
 .github/workflows/tests.yml
+.vscode/settings.json
 src/timeout_dead/__init__.py
 src/timeout_dead/_version.py
 src/timeout_dead/cli.py

{timeout_dead-0.1.1 → timeout_dead-0.2.0}/tests/conftest.py

@@ -9,7 +9,7 @@ import pytest
 
 @pytest.fixture
 def temp_dir() -> Iterator[Path]:
-  """Временная директория для тестов."""
+  """Temporary directory for tests."""
 
   with tempfile.TemporaryDirectory() as tmp:
     yield Path(tmp)

{timeout_dead-0.1.1 → timeout_dead-0.2.0}/tests/test_cli.py

@@ -1,4 +1,4 @@
-"""Тесты CLI утилиты timeout-dead."""
+"""Tests for timeout-dead CLI utility."""
 
 import os
 import signal
@@ -30,7 +30,7 @@ def _run_cli(
   *args: str,
   timeout: int = 10,
 ) -> subprocess.CompletedProcess[str]:
-  """Запускает timeout-dead как subprocess."""
+  """Run timeout-dead as a subprocess."""
 
   return subprocess.run(
     [sys.executable, "-m", "timeout_dead.cli", *args],
@@ -48,7 +48,7 @@ def _run_cli(
 class TestParseArguments:
   def test_defaults(self) -> None:
     args = parse_arguments(["echo", "hello"])
-    assert args.sec == 60
+    assert args.sec == 60.0
     assert args.signal == "TERM"
     assert args.no_output is False
     assert args.command == ["echo", "hello"]
@@ -57,7 +57,25 @@ class TestParseArguments:
 
   def test_custom_timeout(self) -> None:
     args = parse_arguments(["--sec", "120", "echo", "hello"])
-    assert args.sec == 120
+    assert args.sec == 120.0
+
+  # ------------------------------------------------
+
+  def test_float_timeout(self) -> None:
+    args = parse_arguments(["--sec", "2.5", "echo", "hello"])
+    assert args.sec == 2.5
+
+  # ------------------------------------------------
+
+  def test_subsecond_timeout(self) -> None:
+    args = parse_arguments(["--sec", "0.3", "sleep", "1"])
+    assert args.sec == 0.3
+
+  # ------------------------------------------------
+
+  def test_zero_timeout(self) -> None:
+    args = parse_arguments(["--sec", "0", "echo", "hello"])
+    assert args.sec == 0.0
 
   # ------------------------------------------------
 
@@ -217,6 +235,58 @@ class TestRunCommand:
     assert rc != 0
 
 
+# MARK: Float timeout tests
+# ------------------------------------------------
+
+
+class TestFloatTimeout:
+  def test_float_parsed_correctly(self) -> None:
+    rc = run_command("echo ok", timeout=2.5)
+    assert rc == 0
+
+  # ------------------------------------------------
+
+  def test_subsecond_timeout_triggers(self) -> None:
+    rc = run_command("sleep 10", timeout=0.3)
+    assert rc != 0
+
+  # ------------------------------------------------
+
+  def test_millisecond_timeout(self) -> None:
+    start = time.monotonic()
+    rc = run_command("sleep 10", timeout=0.5)
+    elapsed = time.monotonic() - start
+    assert rc != 0
+    assert elapsed < 4.0
+
+  # ------------------------------------------------
+
+  def test_float_in_message(self, capsys: pytest.CaptureFixture[str]) -> None:
+    run_command("sleep 10", timeout=1.5)
+    captured = capsys.readouterr()
+    assert "Timeout exceeded" in captured.err
+
+  # ------------------------------------------------
+
+  def test_cli_float_arg(self) -> None:
+    result = _run_cli("--sec", "0.3", "sleep", "10")
+    assert result.returncode != 0
+    assert "Timeout exceeded" in result.stderr
+
+  # ------------------------------------------------
+
+  def test_cli_float_with_signal(self) -> None:
+    result = _run_cli("--sec", "0.5", "--signal", "KILL", "sleep", "10")
+    assert result.returncode != 0
+
+  # ------------------------------------------------
+
+  def test_cli_float_no_output(self) -> None:
+    result = _run_cli("--no-output", "--sec", "0.3", "sleep", "10")
+    assert "Timeout exceeded" in result.stderr
+    assert "Running:" not in result.stdout
+
+
 # MARK: Signal selection tests
 # ------------------------------------------------
 
@@ -245,7 +315,7 @@ class TestSignalSelection:
     reason="SIGINT file-based test requires Unix signal handling",
   )
   def test_signal_int_handling(self, tmp_path: Path) -> None:
-    """Python-скрипт ловит SIGINT и записывает номер сигнала в файл."""
+    """Python script catches SIGINT and writes signal number to file."""
 
     marker = tmp_path / "signal.txt"
     script_path = tmp_path / "handler.py"
@@ -395,6 +465,21 @@ class TestIntegration:
     assert "--sec" in result.stdout
     assert "--signal" in result.stdout
     assert "--no-output" in result.stdout
+    assert "--version" in result.stdout
+
+  # ------------------------------------------------
+
+  def test_cli_version_long(self) -> None:
+    result = _run_cli("--version")
+    assert result.returncode == 0
+    assert "timeout-dead" in result.stdout
+
+  # ------------------------------------------------
+
+  def test_cli_version_short(self) -> None:
+    result = _run_cli("-v")
+    assert result.returncode == 0
+    assert "timeout-dead" in result.stdout
 
   # ------------------------------------------------
 
@@ -445,8 +530,8 @@ class TestIntegration:
 
 class TestConstants:
   def test_default_timeout(self) -> None:
-    assert _Const.DEFAULT_TIMEOUT_S == 60
-    assert isinstance(_Const.DEFAULT_TIMEOUT_S, int)
+    assert _Const.DEFAULT_TIMEOUT_S == 60.0
+    assert isinstance(_Const.DEFAULT_TIMEOUT_S, float)
 
   # ------------------------------------------------