OpenJarvis 1.0.4.dev1002__tar.gz → 1.0.4.dev1004__tar.gz

{openjarvis-1.0.4.dev1002 → openjarvis-1.0.4.dev1004}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: OpenJarvis
-Version: 1.0.4.dev1002
+Version: 1.0.4.dev1004
 Summary: OpenJarvis — modular AI assistant backend with composable intelligence primitives
 Project-URL: Homepage, https://github.com/open-jarvis/OpenJarvis
 Project-URL: Documentation, https://open-jarvis.github.io/OpenJarvis/

{openjarvis-1.0.4.dev1002 → openjarvis-1.0.4.dev1004}/src/openjarvis/cli/daemon_cmd.py

@@ -2,8 +2,6 @@
 
 from __future__ import annotations
 
-import os
-import signal
 import subprocess
 import sys
 import time
@@ -12,6 +10,7 @@ import click
 from rich.console import Console
 
 from openjarvis.core.config import DEFAULT_CONFIG_DIR, load_config
+from openjarvis.core.utils import process_alive, terminate_process
 
 _PID_FILE = DEFAULT_CONFIG_DIR / "server.pid"
 _LOG_FILE = DEFAULT_CONFIG_DIR / "server.log"
@@ -19,47 +18,7 @@ _LOG_FILE = DEFAULT_CONFIG_DIR / "server.log"
 
 def _pid_alive(pid: int) -> bool:
     """Return whether *pid* identifies a running process without signaling it."""
-    if pid <= 0:
-        return False
-
-    if os.name == "nt":
-        import ctypes
-        from ctypes import wintypes
-
-        error_invalid_parameter = 87
-        synchronize = 0x00100000
-        wait_object_0 = 0x00000000
-
-        kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
-        kernel32.OpenProcess.argtypes = [wintypes.DWORD, wintypes.BOOL, wintypes.DWORD]
-        kernel32.OpenProcess.restype = wintypes.HANDLE
-        kernel32.WaitForSingleObject.argtypes = [wintypes.HANDLE, wintypes.DWORD]
-        kernel32.WaitForSingleObject.restype = wintypes.DWORD
-        kernel32.CloseHandle.argtypes = [wintypes.HANDLE]
-        kernel32.CloseHandle.restype = wintypes.BOOL
-
-        handle = kernel32.OpenProcess(synchronize, False, pid)
-        if not handle:
-            # OpenProcess reports ERROR_INVALID_PARAMETER when the PID does not
-            # exist. For access-denied and other inconclusive failures, retain
-            # the PID file rather than declaring a potentially live daemon dead.
-            return ctypes.get_last_error() != error_invalid_parameter
-
-        try:
-            wait_result = kernel32.WaitForSingleObject(handle, 0)
-            # WAIT_OBJECT_0 proves the process exited. WAIT_TIMEOUT proves it
-            # is live; unexpected failures are inconclusive, so retain the PID.
-            return wait_result != wait_object_0
-        finally:
-            kernel32.CloseHandle(handle)
-
-    try:
-        os.kill(pid, 0)
-    except ProcessLookupError:
-        return False
-    except PermissionError:
-        return True
-    return True
+    return process_alive(pid)
 
 
 def _read_pid() -> int | None:
@@ -71,6 +30,7 @@ def _read_pid() -> int | None:
     except (OSError, ValueError):
         _PID_FILE.unlink(missing_ok=True)
         return None
+    # Check if process is still running (non-destructive, cross-platform).
     if not _pid_alive(pid):
         _PID_FILE.unlink(missing_ok=True)
         return None
@@ -168,22 +128,9 @@ def stop() -> None:
         console.print("[yellow]No running server found.[/yellow]")
         sys.exit(1)
 
-    try:
-        os.kill(pid, signal.SIGTERM)
-        # Wait up to 10 seconds for graceful shutdown
-        for _ in range(20):
-            time.sleep(0.5)
-            if not _pid_alive(pid):
-                break
-        else:
-            # SIGKILL is POSIX-only. On Windows SIGTERM already maps to
-            # TerminateProcess, so repeating it is the available escalation.
-            try:
-                os.kill(pid, getattr(signal, "SIGKILL", signal.SIGTERM))
-            except OSError:
-                pass
-    except OSError:
-        pass
+    # Graceful shutdown (SIGTERM / taskkill), escalating to a forced kill after
+    # 10s if still running. Cross-platform — no POSIX-only os.kill/SIGKILL.
+    terminate_process(pid, grace_seconds=10.0)
 
     _PID_FILE.unlink(missing_ok=True)
     console.print(f"[green]Server stopped[/green] (PID {pid}).")

{openjarvis-1.0.4.dev1002 → openjarvis-1.0.4.dev1004}/src/openjarvis/cli/init_cmd.py

@@ -230,7 +230,7 @@ def _do_download(engine: str, model: str, spec, console: Console) -> None:
 )
 @click.option(
     "--config",
-    type=click.Path(exists=True),
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
     help="Path to config file to use.",
 )
 @click.option(
@@ -445,7 +445,7 @@ def init(
             )
 
     if config:
-        toml_content = config.read_text()
+        toml_content = config.read_text(encoding="utf-8")
     else:
         if full_config:
             toml_content = generate_default_toml(hw, engine=engine, host=host)
@@ -453,10 +453,10 @@ def init(
             toml_content = generate_minimal_toml(hw, engine=engine, host=host)
 
     DEFAULT_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
-    if config:
-        config.write_text(toml_content)
-    else:
-        DEFAULT_CONFIG_PATH.write_text(toml_content)
+    # ``--config`` selects an existing file to install; it is not an alternate
+    # output path.  Always activate the selected/generated configuration at
+    # the canonical location that subsequent ``jarvis`` commands load.
+    DEFAULT_CONFIG_PATH.write_text(toml_content, encoding="utf-8")
 
     console.print()
     console.print(
@@ -493,7 +493,7 @@ sources = ["gcalendar"]
 [digest.world]
 sources = ["hackernews", "news_rss"]
 """
-        target = config if config else DEFAULT_CONFIG_PATH
+        target = DEFAULT_CONFIG_PATH
         existing = target.read_text()
         target.write_text(existing + digest_section)
         toml_content = target.read_text()

{openjarvis-1.0.4.dev1002 → openjarvis-1.0.4.dev1004}/src/openjarvis/cli/mine_cmd.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import asyncio
 import json
 import os
-import signal
 import time
 import urllib.error
 import urllib.parse
@@ -17,6 +16,7 @@ import click
 
 from openjarvis.core.config import HardwareInfo, detect_hardware, load_config
 from openjarvis.core.registry import MinerRegistry
+from openjarvis.core.utils import process_alive, terminate_process
 from openjarvis.mining._constants import (
     DEFAULT_GATEWAY_METRICS_PORT,
     DEFAULT_GATEWAY_RPC_PORT,
@@ -201,26 +201,11 @@ def _local_artifact_payload_and_paths(path: Path) -> tuple[dict[str, Any], set[s
 
 
 def _pid_alive(pid: int | None) -> bool:
-    if not pid:
-        return False
-    try:
-        os.kill(pid, 0)
-    except OSError:
-        return False
-    return True
+    return process_alive(pid)
 
 
 def _terminate_pid(pid: int | None, *, grace_seconds: float = 3.0) -> None:
-    if not pid or not _pid_alive(pid):
-        return
-    os.kill(pid, signal.SIGTERM)
-    deadline = time.monotonic() + grace_seconds
-    while time.monotonic() < deadline:
-        if not _pid_alive(pid):
-            return
-        time.sleep(0.05)
-    if _pid_alive(pid):
-        os.kill(pid, signal.SIGKILL)
+    terminate_process(pid, grace_seconds=grace_seconds)
 
 
 def _row(name: str, ok: bool, info: str) -> None:

{openjarvis-1.0.4.dev1002 → openjarvis-1.0.4.dev1004}/src/openjarvis/core/__init__.py

@@ -19,7 +19,12 @@ from openjarvis.core.types import (
     ToolCall,
     ToolResult,
 )
-from openjarvis.core.utils import get_python_executable, open_browser
+from openjarvis.core.utils import (
+    get_python_executable,
+    open_browser,
+    process_alive,
+    terminate_process,
+)
 
 __all__ = [
     "AgentRegistry",
@@ -37,4 +42,6 @@ __all__ = [
     "ToolResult",
     "get_python_executable",
     "open_browser",
+    "process_alive",
+    "terminate_process",
 ]

openjarvis-1.0.4.dev1004/src/openjarvis/core/utils.py

@@ -0,0 +1,189 @@
+"""Small cross-platform utilities used by the CLI, OAuth flow, and evals.
+
+Kept dependency-free so importing this module is cheap (the public re-export
+from ``openjarvis.core`` must not pull in heavy modules at package init).
+"""
+
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import signal
+import subprocess
+import time
+import webbrowser
+
+
+def _windows_process_alive(pid: int) -> bool:
+    """Query a Windows process handle without sending it a signal."""
+    import ctypes
+    from ctypes import wintypes
+
+    error_invalid_parameter = 87
+    synchronize = 0x00100000
+    wait_object_0 = 0x00000000
+
+    kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+    kernel32.OpenProcess.argtypes = [wintypes.DWORD, wintypes.BOOL, wintypes.DWORD]
+    kernel32.OpenProcess.restype = wintypes.HANDLE
+    kernel32.WaitForSingleObject.argtypes = [wintypes.HANDLE, wintypes.DWORD]
+    kernel32.WaitForSingleObject.restype = wintypes.DWORD
+    kernel32.CloseHandle.argtypes = [wintypes.HANDLE]
+    kernel32.CloseHandle.restype = wintypes.BOOL
+
+    handle = kernel32.OpenProcess(synchronize, False, pid)
+    if not handle:
+        # ERROR_INVALID_PARAMETER proves that the PID does not exist. Access
+        # denied is inconclusive, so do not treat a potentially live process as
+        # dead and risk starting a duplicate daemon.
+        return ctypes.get_last_error() != error_invalid_parameter
+
+    try:
+        # WAIT_OBJECT_0 means the process handle is signaled (the process has
+        # exited). WAIT_TIMEOUT and unexpected failures are conservatively live.
+        return kernel32.WaitForSingleObject(handle, 0) != wait_object_0
+    finally:
+        kernel32.CloseHandle(handle)
+
+
+def _posix_process_state(pid: int) -> str | None:
+    """Return a POSIX process state letter, or ``None`` when unavailable."""
+    proc_root = "/proc"
+    try:
+        with open(f"{proc_root}/{pid}/stat", encoding="utf-8") as stat_file:
+            # The command name is parenthesized and may itself contain ``)``.
+            return stat_file.read().rsplit(") ", 1)[1][:1]
+    except FileNotFoundError:
+        if os.path.isdir(proc_root):
+            return "X"
+    except (IndexError, OSError):
+        pass
+
+    # macOS and other POSIX hosts do not expose /proc. ``ps`` lets us
+    # distinguish a zombie (which still responds to kill(pid, 0)) from a live
+    # process without adding a runtime dependency.
+    try:
+        result = subprocess.run(
+            ["ps", "-o", "stat=", "-p", str(pid)],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except OSError:
+        return None
+    state = result.stdout.strip()
+    if result.returncode != 0 or not state:
+        return "X"
+    return state[:1]
+
+
+def get_python_executable() -> str:
+    """Return the best ``python`` interpreter name on PATH.
+
+    Prefers ``python3`` (Linux/macOS convention); falls back to ``python``
+    (Windows / some minimal Linux distros that ship only ``python``). Returns
+    the literal string ``"python3"`` when neither is found, so callers still
+    get a usable command that will fail with a clear "command not found"
+    rather than an empty string.
+
+    The result is a *command name or absolute path* that callers can hand to
+    :mod:`subprocess` directly when ``shell=False``, and must be shell-quoted
+    (:func:`shlex.quote`) before being interpolated into a ``shell=True``
+    command string — paths on Windows often contain spaces.
+    """
+    return shutil.which("python3") or shutil.which("python") or "python3"
+
+
+def open_browser(url: str) -> None:
+    """Open *url* in the user's default browser, with a Windows fast-path.
+
+    :func:`webbrowser.open` is the cross-platform default, but on Windows it
+    sometimes blocks or fails inside a console host. ``cmd /c start "" "URL"``
+    is the canonical Windows incantation that hands the URL to the OS shell
+    and returns immediately. We try that first on Windows and fall back to
+    :func:`webbrowser.open` if the subprocess spawn fails.
+    """
+    if platform.system() == "Windows":
+        try:
+            # The empty title argument after ``start`` is required: ``start``
+            # treats a single quoted argument as a window title, not a URL.
+            subprocess.run(["cmd", "/c", "start", "", url], check=False)
+            return
+        except Exception:  # noqa: BLE001 - any spawn failure -> fall back
+            pass
+    webbrowser.open(url)
+
+
+def process_alive(pid: int | None) -> bool:
+    """Return ``True`` if a process with *pid* is currently running.
+
+    Cross-platform and *non-destructive*. The common POSIX idiom
+    ``os.kill(pid, 0)`` must NOT be used on Windows: there ``os.kill`` maps any
+    signal to ``TerminateProcess``, so a "liveness probe" would actually kill
+    the process. On Windows we inspect a process handle instead.
+    """
+    if not pid or pid <= 0:
+        return False
+    if platform.system() == "Windows":
+        return _windows_process_alive(pid)
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        pass
+    except OSError:
+        return False
+
+    # A terminated child remains in the process table as a zombie until its
+    # parent reaps it. ``kill(pid, 0)`` reports that entry as present, but it can
+    # no longer execute and must not trigger force-kill waits or stale-PID reuse.
+    return _posix_process_state(pid) not in {"X", "Z"}
+
+
+def terminate_process(pid: int | None, *, grace_seconds: float = 3.0) -> None:
+    """Terminate *pid* gracefully, escalating to a forced kill (cross-platform).
+
+    POSIX sends ``SIGTERM`` then, after *grace_seconds*, ``SIGKILL``. Windows
+    has neither; it uses ``taskkill`` (graceful) then ``taskkill /F /T`` (force,
+    whole tree). ``signal.SIGKILL`` does not exist on Windows, so it is only
+    referenced inside the POSIX branch.
+    """
+    if not process_alive(pid):
+        return
+    is_windows = platform.system() == "Windows"
+
+    if is_windows:
+        subprocess.run(["taskkill", "/PID", str(pid)], capture_output=True, check=False)
+    else:
+        try:
+            os.kill(pid, signal.SIGTERM)
+        except OSError:
+            return
+
+    deadline = time.monotonic() + max(0.0, grace_seconds)
+    while time.monotonic() < deadline:
+        if not process_alive(pid):
+            return
+        time.sleep(0.05)
+
+    if is_windows:
+        subprocess.run(
+            ["taskkill", "/F", "/T", "/PID", str(pid)],
+            capture_output=True,
+            check=False,
+        )
+    else:
+        try:
+            os.kill(pid, signal.SIGKILL)
+        except OSError:
+            pass
+
+
+__all__ = [
+    "get_python_executable",
+    "open_browser",
+    "process_alive",
+    "terminate_process",
+]

openjarvis-1.0.4.dev1004/tests/cli/test_init_config.py

@@ -0,0 +1,88 @@
+"""Tests for ``jarvis init --config`` option (regression for #768).
+
+The ``--config`` option is declared with ``click.Path`` and the command body
+uses the value as a :class:`pathlib.Path` (``config.read_text()`` /
+``config.write_text()``). Without ``path_type=Path`` Click hands the callback a
+plain ``str``, so every invocation of ``--config`` crashed with
+``AttributeError: 'str' object has no attribute 'read_text'``.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest import mock
+
+from click.testing import CliRunner
+
+from openjarvis.cli import cli
+
+_NO_DL = "--no-download"
+
+
+class TestInitConfig:
+    def test_init_config_installs_provided_file(self, tmp_path: Path) -> None:
+        """jarvis init --config <file> activates it at the canonical path.
+
+        Regression for #768: the callback receives a Path and can call
+        ``read_text()`` / ``write_text()`` on it.
+        """
+        provided = tmp_path / "some-config.toml"
+        supplied_content = '[engine]\nname = "ollama"\n'
+        provided.write_text(supplied_content, encoding="utf-8")
+
+        config_dir = tmp_path / ".openjarvis"
+        config_path = config_dir / "config.toml"  # absent -> passes the exists() guard
+        with (
+            mock.patch("openjarvis.cli.init_cmd.DEFAULT_CONFIG_DIR", config_dir),
+            mock.patch("openjarvis.cli.init_cmd.DEFAULT_CONFIG_PATH", config_path),
+            mock.patch("openjarvis.cli.init_cmd.PrivacyScanner"),
+        ):
+            result = CliRunner().invoke(
+                cli, ["init", "--config", str(provided), _NO_DL]
+            )
+
+        assert result.exception is None, result.output
+        assert result.exit_code == 0
+        assert config_path.read_text(encoding="utf-8") == supplied_content
+        # Treat the supplied file as input: init must not rewrite it.
+        assert provided.read_text(encoding="utf-8") == supplied_content
+
+    def test_init_config_digest_updates_installed_copy(self, tmp_path: Path) -> None:
+        """Post-processing applies to the active copy, not the input file."""
+        provided = tmp_path / "some-config.toml"
+        supplied_content = '[engine]\nname = "ollama"\n'
+        provided.write_text(supplied_content, encoding="utf-8")
+        config_dir = tmp_path / ".openjarvis"
+        config_path = config_dir / "config.toml"
+
+        with (
+            mock.patch("openjarvis.cli.init_cmd.DEFAULT_CONFIG_DIR", config_dir),
+            mock.patch("openjarvis.cli.init_cmd.DEFAULT_CONFIG_PATH", config_path),
+            mock.patch("openjarvis.cli.init_cmd.PrivacyScanner"),
+        ):
+            result = CliRunner().invoke(
+                cli,
+                [
+                    "init",
+                    "--config",
+                    str(provided),
+                    "--digest",
+                    _NO_DL,
+                ],
+            )
+
+        assert result.exception is None, result.output
+        assert result.exit_code == 0
+        assert "[digest]" in config_path.read_text(encoding="utf-8")
+        assert provided.read_text(encoding="utf-8") == supplied_content
+
+    def test_init_config_rejects_directory(self, tmp_path: Path) -> None:
+        """A directory is rejected by Click (dir_okay=False), not by a later crash."""
+        a_dir = tmp_path / "not-a-file"
+        a_dir.mkdir()
+
+        result = CliRunner().invoke(cli, ["init", "--config", str(a_dir), _NO_DL])
+
+        # Click usage error (exit 2), and specifically NOT the AttributeError crash.
+        assert result.exit_code == 2
+        assert not isinstance(result.exception, AttributeError)

openjarvis-1.0.4.dev1004/tests/core/test_utils.py

@@ -0,0 +1,186 @@
+"""Tests for cross-platform process helpers in ``openjarvis.core.utils``."""
+
+from __future__ import annotations
+
+import os
+import platform
+import signal
+import subprocess
+import sys
+import time
+from unittest.mock import MagicMock, call, patch
+
+import pytest
+
+from openjarvis.core.utils import (
+    _windows_process_alive,
+    process_alive,
+    terminate_process,
+)
+
+
+class TestProcessAlive:
+    def test_current_process_is_alive(self) -> None:
+        assert process_alive(os.getpid()) is True
+
+    def test_bogus_pid_not_alive(self) -> None:
+        assert process_alive(999_999_999) is False
+
+    def test_none_pid_not_alive(self) -> None:
+        assert process_alive(None) is False
+
+    def test_nonpositive_pid_not_alive(self) -> None:
+        assert process_alive(0) is False
+        assert process_alive(-1) is False
+
+    @pytest.mark.skipif(platform.system() == "Windows", reason="POSIX-only")
+    def test_unreaped_zombie_is_not_alive(self) -> None:
+        proc = subprocess.Popen([sys.executable, "-c", "pass"])
+        try:
+            for _ in range(100):
+                if not process_alive(proc.pid):
+                    break
+                time.sleep(0.01)
+            assert process_alive(proc.pid) is False
+        finally:
+            proc.wait(timeout=5)
+
+    def test_permission_error_is_conservatively_alive(self) -> None:
+        with (
+            patch("openjarvis.core.utils.platform.system", return_value="Linux"),
+            patch("openjarvis.core.utils.os.kill", side_effect=PermissionError),
+            patch("openjarvis.core.utils._posix_process_state", return_value=None),
+        ):
+            assert process_alive(1234) is True
+
+    def test_windows_path_never_calls_os_kill(self) -> None:
+        with (
+            patch("openjarvis.core.utils.platform.system", return_value="Windows"),
+            patch(
+                "openjarvis.core.utils._windows_process_alive", return_value=True
+            ) as win_alive,
+            patch("openjarvis.core.utils.os.kill") as os_kill,
+        ):
+            assert process_alive(4321) is True
+        win_alive.assert_called_once_with(4321)
+        os_kill.assert_not_called()
+
+
+class TestWindowsProcessAlive:
+    @staticmethod
+    def _kernel(open_result: int, wait_result: int = 0) -> MagicMock:
+        kernel32 = MagicMock()
+        kernel32.OpenProcess.return_value = open_result
+        kernel32.WaitForSingleObject.return_value = wait_result
+        return kernel32
+
+    def test_missing_pid(self) -> None:
+        import ctypes
+
+        kernel32 = self._kernel(0)
+        with (
+            patch.object(ctypes, "WinDLL", return_value=kernel32, create=True),
+            patch.object(ctypes, "get_last_error", return_value=87, create=True),
+        ):
+            assert _windows_process_alive(1234) is False
+
+    def test_access_denied_is_conservatively_alive(self) -> None:
+        import ctypes
+
+        kernel32 = self._kernel(0)
+        with (
+            patch.object(ctypes, "WinDLL", return_value=kernel32, create=True),
+            patch.object(ctypes, "get_last_error", return_value=5, create=True),
+        ):
+            assert _windows_process_alive(1234) is True
+
+    @pytest.mark.parametrize(
+        ("wait_result", "expected"), [(0x00000000, False), (0x00000102, True)]
+    )
+    def test_process_handle_state(self, wait_result: int, expected: bool) -> None:
+        import ctypes
+
+        kernel32 = self._kernel(99, wait_result)
+        with patch.object(ctypes, "WinDLL", return_value=kernel32, create=True):
+            assert _windows_process_alive(1234) is expected
+        kernel32.CloseHandle.assert_called_once_with(99)
+
+
+class TestTerminateProcess:
+    def _spawn_sleeper(self) -> subprocess.Popen:
+        # Portable long-running child: sleeps well beyond the test's lifetime.
+        return subprocess.Popen([sys.executable, "-c", "import time; time.sleep(60)"])
+
+    def test_terminates_running_process(self) -> None:
+        proc = self._spawn_sleeper()
+        try:
+            # Give the interpreter a moment to come up.
+            for _ in range(20):
+                if process_alive(proc.pid):
+                    break
+                time.sleep(0.05)
+            assert process_alive(proc.pid) is True
+
+            terminate_process(proc.pid, grace_seconds=5.0)
+
+            # Should be gone shortly after terminate returns.
+            for _ in range(20):
+                if not process_alive(proc.pid):
+                    break
+                time.sleep(0.05)
+            assert process_alive(proc.pid) is False
+        finally:
+            try:
+                proc.wait(timeout=5)
+            except Exception:
+                proc.kill()
+
+    def test_terminate_bogus_pid_no_crash(self) -> None:
+        # Must be a no-op, never raise, on any platform.
+        terminate_process(999_999_999)
+
+    def test_terminate_none_no_crash(self) -> None:
+        terminate_process(None)
+
+    def test_posix_escalates_to_sigkill(self) -> None:
+        with (
+            patch("openjarvis.core.utils.platform.system", return_value="Linux"),
+            patch("openjarvis.core.utils.process_alive", return_value=True),
+            patch("openjarvis.core.utils.os.kill") as os_kill,
+        ):
+            terminate_process(1234, grace_seconds=0)
+        assert os_kill.call_args_list == [
+            call(1234, signal.SIGTERM),
+            call(1234, signal.SIGKILL),
+        ]
+
+    def test_windows_graceful_taskkill(self) -> None:
+        with (
+            patch("openjarvis.core.utils.platform.system", return_value="Windows"),
+            patch("openjarvis.core.utils.process_alive", side_effect=[True, False]),
+            patch("openjarvis.core.utils.subprocess.run") as run,
+        ):
+            terminate_process(1234, grace_seconds=1)
+        run.assert_called_once_with(
+            ["taskkill", "/PID", "1234"], capture_output=True, check=False
+        )
+
+    def test_windows_escalates_to_forced_tree_kill(self) -> None:
+        with (
+            patch("openjarvis.core.utils.platform.system", return_value="Windows"),
+            patch("openjarvis.core.utils.process_alive", return_value=True),
+            patch("openjarvis.core.utils.subprocess.run") as run,
+        ):
+            terminate_process(1234, grace_seconds=0)
+        assert run.call_args_list == [
+            call(
+                ["taskkill", "/PID", "1234"],
+                capture_output=True,
+                check=False,
+            ),
+            call(
+                ["taskkill", "/F", "/T", "/PID", "1234"],
+                capture_output=True,
+                check=False,
+            ),
+        ]