forgexa-cli 1.21.2__tar.gz → 1.21.3__tar.gz

{forgexa_cli-1.21.2 → forgexa_cli-1.21.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.21.2
+Version: 1.21.3
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License-Expression: MIT

{forgexa_cli-1.21.2 → forgexa_cli-1.21.3}/forgexa_cli/__init__.py

@@ -1,2 +1,2 @@
 """forgexa-cli — Forgexa command-line client."""
-__version__ = "1.21.2"
+__version__ = "1.21.3"

{forgexa_cli-1.21.2 → forgexa_cli-1.21.3}/forgexa_cli/autoupgrade.py

@@ -78,7 +78,7 @@ def _state_path() -> Path:
 
 
 def empty_state() -> dict:
-    return {"active": None, "last_failure": None, "last_success": None}
+    return {"active": None, "last_failure": None, "last_success": None, "last_skip": None}
 
 
 def read_state() -> dict:

{forgexa_cli-1.21.2 → forgexa_cli-1.21.3}/forgexa_cli/daemon.py

@@ -555,7 +555,7 @@ except (ImportError, ModuleNotFoundError):
 # DAEMON_VERSION is the protocol/logic version of the daemon code.
 # Kept in sync with pyproject.toml version via bump-version.sh.
 # CLIENT_TYPE identifies which packaging/distribution this daemon runs in.
-DAEMON_VERSION = "1.21.2"
+DAEMON_VERSION = "1.21.3"
 
 
 def _detect_client_type() -> str:

{forgexa_cli-1.21.2 → forgexa_cli-1.21.3}/forgexa_cli/main.py

@@ -557,6 +557,18 @@ def _upgrade_log_path() -> Path:
     return Path.home() / ".forgexa" / "upgrade.log"
 
 
+def _record_install_skip(target_version: str, reason: str) -> None:
+    """Record why a silent install attempt was skipped, for `forgexa version --status`.
+
+    Covers the two "surprising" skip reasons (unsupported install source, a
+    running daemon) so `active`/`last_success`/`last_failure` all being "none"
+    isn't a silent mystery — see docs/designs/cli-auto-upgrade-design.md Appendix C.
+    """
+    state = autoupgrade.read_state()
+    state["last_skip"] = {"version": target_version, "reason": reason, "at": time.time()}
+    autoupgrade.write_state(state)
+
+
 def _maybe_install_update() -> None:
     """Attempt a single silent background install, if all safety conditions hold.
 
@@ -580,10 +592,14 @@ def _maybe_install_update() -> None:
     try:
         plan = _build_upgrade_plan(latest)
     except RuntimeError:
-        return  # Unsupported/unsafe install source — leave it to the passive notice.
+        # Unsupported/unsafe install source — leave it to the passive notice.
+        _record_install_skip(latest, "unsupported_source")
+        return
 
     if _find_running_daemon_pid() is not None:
-        return  # Don't touch a running daemon; retry on a later invocation.
+        # Don't touch a running daemon; retry on a later invocation.
+        _record_install_skip(latest, "daemon_running")
+        return
 
     state = autoupgrade.read_state()
     target_version = latest
@@ -596,6 +612,7 @@ def _maybe_install_update() -> None:
 
     try:
         state["active"] = {"version": target_version, "started_at": time.time()}
+        state["last_skip"] = None
         autoupgrade.write_state(state)
 
         log_path = _upgrade_log_path()
@@ -639,14 +656,23 @@ def _maybe_install_update() -> None:
         autoupgrade.release_lock()
 
 
-def _run_update_check_and_maybe_install(allow_install: bool) -> None:
-    """Refresh the update cache and, if allowed, attempt a silent background install.
+def _run_update_check_and_maybe_install(allow_install: bool, refresh_cache: bool = True) -> None:
+    """Refresh the update cache (if `refresh_cache`) and, if allowed, attempt
+    a silent background install.
 
     `allow_install` reflects the parent process's interactive-session judgment
     (TTY / CI / --format) at launch time — this worker's own stdio is redirected
     to DEVNULL, so it can never determine that for itself.
+
+    `refresh_cache=False` supports retrying an install using the already-cached
+    latest version, without an extra PyPI round-trip — see
+    `_launch_update_check_process`'s "retry-only" path, which exists precisely
+    so an install attempt isn't stuck waiting for the network-check TTL to
+    expire just because *something else* (interactivity, a running daemon)
+    blocked the previous attempt.
     """
-    _run_update_check()
+    if refresh_cache:
+        _run_update_check()
     if not allow_install:
         return
     try:
@@ -666,22 +692,56 @@ def _is_interactive_session() -> bool:
     return bool(sys.stderr.isatty()) and not os.environ.get("CI") and _output_format != "json"
 
 
+def _has_pending_silent_install(current_version: str) -> bool:
+    """Whether a known newer version exists that hasn't been installed yet,
+    isn't already exhausted on failure backoff, and isn't already being
+    installed by a still-fresh `active` install right now.
+
+    Purely local (no network) — used so an install can be *retried* on a
+    later invocation even while the network-check cache is still fresh,
+    since whatever blocked the earlier attempt (a running daemon, a
+    momentarily non-interactive session) can resolve well within the
+    network check's 24h TTL, and there's no reason to make the user wait
+    that long for a retry.
+    """
+    if not current_version:
+        return False
+    latest, _ = _read_update_cache()
+    if not latest or not _version_is_newer(latest, current_version):
+        return False
+    state = autoupgrade.read_state()
+    if autoupgrade.failure_attempts_for(state, latest) >= autoupgrade.FAILURE_BACKOFF_LIMIT:
+        return False
+    if autoupgrade.has_fresh_active_install(state, latest):
+        return False
+    return True
+
+
 def _launch_update_check_process(allow_install: bool) -> None:
-    """Start a detached worker process that refreshes the update cache and,
+    """Start a detached worker process that refreshes the update cache and/or,
     if `allow_install`, attempts a silent background install.
 
     Short-lived commands like `forgexa version` can exit before a daemon thread
     finishes its PyPI request. A separate Python process survives long enough to
     populate the cache without blocking the foreground command.
 
+    The network check itself is rate-limited to once per `_UPDATE_CHECK_TTL` to
+    avoid hammering PyPI. Install *retries* are deliberately NOT tied to that
+    same window: when the cache is still fresh but a known newer version is
+    still pending (see `_has_pending_silent_install`), this launches a
+    network-free worker that just retries the local install steps.
+
     The worker is launched fully detached (new session on POSIX, no console
     window on Windows) so a Ctrl+C / signal aimed at the foreground command's
     process group can't take an in-progress install down with it and leave a
     half-installed package.
     """
     _, checked_at = _read_update_cache()
-    if time.time() - checked_at <= _UPDATE_CHECK_TTL:
-        return  # Cache is fresh — nothing to do
+    cache_stale = time.time() - checked_at > _UPDATE_CHECK_TTL
+
+    if not cache_stale:
+        if not allow_install or not _has_pending_silent_install(_installed_cli_version() or ""):
+            return  # Cache is fresh and there's nothing pending to retry.
 
     popen_kwargs: dict = {}
     if sys.platform == "win32":
@@ -697,7 +757,7 @@ def _launch_update_check_process(allow_install: bool) -> None:
                 sys.executable,
                 "-c",
                 "from forgexa_cli.main import _run_update_check_and_maybe_install; "
-                f"_run_update_check_and_maybe_install({bool(allow_install)!r})",
+                f"_run_update_check_and_maybe_install({bool(allow_install)!r}, {bool(cache_stale)!r})",
             ],
             stdin=subprocess.DEVNULL,
             stdout=subprocess.DEVNULL,
@@ -1683,11 +1743,15 @@ def _print_check_report(results: list[dict], quick: bool) -> None:
         print("Gemini CLI, Kimi Code, or GitHub Copilot CLI), then re-run: forgexa check")
 
 
-def _run_environment_checks(narrate: bool) -> bool:
+def _run_environment_checks(narrate: bool) -> tuple[bool, list[dict]]:
     """Run environment checks (git, workspace, disk) using the daemon's check logic.
 
-    Returns True if any blocking check failed.
-    Prints a flutter-doctor-style listing in table mode.
+    Always runs regardless of --quick/--environment/default mode: these checks
+    are free (no network, no LLM tokens), so there is no cost reason to hide
+    them behind a flag.
+
+    Returns (blocking_failed, checks). Prints a flutter-doctor-style listing
+    in table mode.
     """
     import asyncio
     from forgexa_cli.daemon import RuntimePreflightMonitor, settings
@@ -1705,7 +1769,7 @@ def _run_environment_checks(narrate: bool) -> bool:
     except Exception as exc:
         if narrate:
             print(f"  [ERROR] Environment check failed: {exc}")
-        return True
+        return True, []
 
     blocking_failed = False
     for check in checks:
@@ -1739,7 +1803,7 @@ def _run_environment_checks(narrate: bool) -> bool:
             print("All environment checks passed.")
         print()
 
-    return blocking_failed
+    return blocking_failed, checks
 
 
 def cmd_check(args: argparse.Namespace) -> None:
@@ -1761,19 +1825,23 @@ def cmd_check(args: argparse.Namespace) -> None:
     timeout = getattr(args, "timeout", None) or 90
 
     narrate = _fmt() == "table"
-    env_failed = False
 
     # ── Environment checks (shared with daemon's RuntimePreflightMonitor) ──
-    # Run when --environment or --quick is set. These are free (no API calls,
-    # no network, no LLM tokens) and reuse the exact same check logic the
-    # daemon uses for its periodic preflight.
-    if environment_only or quick:
-        env_failed = _run_environment_checks(narrate)
-        if environment_only:
-            # --environment: only env checks, then exit
-            if env_failed:
-                sys.exit(1)
-            return
+    # Always run, in every mode (default/--quick/--environment): these are
+    # free (no API calls, no network, no LLM tokens) and reuse the exact same
+    # check logic the daemon uses for its periodic preflight, so there is no
+    # cost reason to hide them behind a flag.
+    env_failed, env_checks = _run_environment_checks(narrate)
+    if environment_only:
+        fmt = _fmt()
+        if fmt == "json":
+            print(json.dumps(env_checks, indent=2, ensure_ascii=False))
+        elif fmt == "quiet":
+            for c in env_checks:
+                print(f"{c.get('id', '?')}\t{c.get('status', 'unknown')}")
+        if env_failed:
+            sys.exit(1)
+        return
 
     known_ids = list(AgentDiscovery.AGENT_REGISTRY.keys())
     if only_agent:
@@ -2023,6 +2091,15 @@ def _print_auto_upgrade_status() -> None:
     else:
         print("Last failure      : none")
 
+    skip = state.get("last_skip")
+    if skip:
+        print(
+            f"Last skip         : {skip.get('version')} "
+            f"(reason={skip.get('reason')}, at {_format_epoch(skip.get('at'))})"
+        )
+    else:
+        print("Last skip         : none")
+
     print(f"Upgrade log       : {_upgrade_log_path()}")
 
 
@@ -2277,7 +2354,7 @@ def main() -> None:
     check_p.add_argument("--agent", default=None, help="Check only this agent (e.g. claude, codex, kimi)")
     check_p.add_argument(
         "--quick", action="store_true",
-        help="Discovery + environment checks — skip the live task execution test (no API calls)",
+        help="Skip the live task execution test (agent discovery + environment checks only, no API calls)",
     )
     check_p.add_argument(
         "--environment", action="store_true",

{forgexa_cli-1.21.2 → forgexa_cli-1.21.3}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.21.2
+Version: 1.21.3
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License-Expression: MIT

{forgexa_cli-1.21.2 → forgexa_cli-1.21.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "forgexa-cli"
-version = "1.21.2"
+version = "1.21.3"
 description = "Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform"
 requires-python = ">=3.9"
 license = "MIT"

{forgexa_cli-1.21.2 → forgexa_cli-1.21.3}/tests/test_auth_and_runtime_commands.py

@@ -325,7 +325,7 @@ def test_launch_update_check_process_spawns_background_python_when_cache_is_stal
     assert cmd[:2] == ["/usr/bin/python3", "-c"]
     assert cmd[2] == (
         "from forgexa_cli.main import _run_update_check_and_maybe_install; "
-        "_run_update_check_and_maybe_install(True)"
+        "_run_update_check_and_maybe_install(True, True)"
     )
     assert kwargs["stdin"] is main.subprocess.DEVNULL
     assert kwargs["stdout"] is main.subprocess.DEVNULL

{forgexa_cli-1.21.2 → forgexa_cli-1.21.3}/tests/test_check_command.py

@@ -140,3 +140,67 @@ def test_check_json_output_is_parseable(
         "available": True,
         "reason": "",
     }]
+
+
+def _mock_environment_checks(monkeypatch: pytest.MonkeyPatch, checks: list[dict]) -> None:
+    monkeypatch.setattr(
+        daemon.RuntimePreflightMonitor, "_run_checks",
+        AsyncMock(return_value=checks),
+    )
+
+
+def test_check_default_mode_also_shows_environment_checks(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],
+) -> None:
+    """Environment checks (git/workspace/disk) are free (no network, no LLM
+    tokens) and must be visible by default, not just behind --quick/--environment.
+    """
+    monkeypatch.setattr(daemon.AgentDiscovery, "AGENT_REGISTRY", _small_registry())
+    monkeypatch.setattr(
+        daemon.AgentDiscovery, "discover",
+        AsyncMock(return_value=[_agent("claude")]),
+    )
+    monkeypatch.setattr(
+        daemon.ProcessManager, "run_agent",
+        AsyncMock(return_value=daemon.TaskResult(status="success", exit_code=0, stdout="OK", stderr="")),
+    )
+    _mock_environment_checks(monkeypatch, [
+        {"id": "git_executable", "status": "pass", "blocking": True, "detail": "git 2.50", "remediation": ""},
+    ])
+
+    main.cmd_check(SimpleNamespace(agent="claude", quick=False, environment=False, timeout=5))
+
+    out = capsys.readouterr().out
+    assert "Environment Checks" in out
+    assert "git_executable" in out
+
+
+def test_check_environment_only_json_output_lists_checks(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],
+) -> None:
+    """--environment previously printed nothing at all under --format json;
+    it must return the structured checks array like every other subcommand."""
+    monkeypatch.setattr(main, "_output_format", "json")
+    _mock_environment_checks(monkeypatch, [
+        {"id": "git_executable", "status": "pass", "blocking": True, "detail": "git 2.50", "remediation": ""},
+        {"id": "workspace_root", "status": "pass", "blocking": True, "detail": "/tmp/ws", "remediation": ""},
+    ])
+
+    main.cmd_check(SimpleNamespace(agent=None, quick=False, environment=True, timeout=90))
+
+    out = capsys.readouterr().out
+    payload = json.loads(out)
+    assert [c["id"] for c in payload] == ["git_executable", "workspace_root"]
+
+
+def test_check_environment_only_exits_nonzero_on_blocking_failure(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],
+) -> None:
+    _mock_environment_checks(monkeypatch, [
+        {"id": "git_executable", "status": "fail", "blocking": True, "detail": "not found", "remediation": "install git"},
+    ])
+
+    with pytest.raises(SystemExit) as exc_info:
+        main.cmd_check(SimpleNamespace(agent=None, quick=False, environment=True, timeout=90))
+
+    assert exc_info.value.code == 1

{forgexa_cli-1.21.2 → forgexa_cli-1.21.3}/tests/test_silent_install.py

@@ -60,6 +60,9 @@ def test_skips_when_upgrade_plan_unsupported(monkeypatch: pytest.MonkeyPatch) ->
     main._maybe_install_update()  # must not raise
 
     assert run_mock.called is False
+    state = autoupgrade.read_state()
+    assert state["last_skip"]["reason"] == "unsupported_source"
+    assert state["last_skip"]["version"] == "1.1.0"
 
 
 def test_skips_when_daemon_is_running(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -73,8 +76,14 @@ def test_skips_when_daemon_is_running(monkeypatch: pytest.MonkeyPatch) -> None:
     main._maybe_install_update()
 
     assert run_mock.called is False
-    # Must not touch the daemon or leave any install-in-progress state behind.
-    assert autoupgrade.read_state() == autoupgrade.empty_state()
+    # Must not touch the daemon or leave any install-in-progress state behind,
+    # but the skip reason IS recorded (see docs/designs/cli-auto-upgrade-design.md
+    # Appendix C) so `forgexa version --status` can explain what happened.
+    state = autoupgrade.read_state()
+    assert state["active"] is None
+    assert state["last_success"] is None
+    assert state["last_failure"] is None
+    assert state["last_skip"] == {"version": "1.1.0", "reason": "daemon_running", "at": state["last_skip"]["at"]}
 
 
 def test_skips_when_failure_backoff_exhausted(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -156,6 +165,27 @@ def test_success_writes_last_success_and_releases_lock(monkeypatch: pytest.Monke
     assert (Path.home() / ".forgexa" / "upgrade.lock").exists() is False
 
 
+def test_success_clears_a_previously_recorded_skip(monkeypatch: pytest.MonkeyPatch) -> None:
+    """A stale 'skipped: daemon running' note shouldn't linger once an install actually runs."""
+    _versions(monkeypatch, ["1.0.0", "1.1.0"])
+    monkeypatch.setattr(main, "_read_update_cache", lambda: ("1.1.0", 0.0))
+    monkeypatch.setattr(main, "_build_upgrade_plan", lambda target: _fake_plan(target))
+    _no_daemon(monkeypatch)
+    monkeypatch.setattr(main.subprocess, "run", lambda cmd, **k: SimpleNamespace(returncode=0))
+    autoupgrade.write_state(
+        {
+            "active": None,
+            "last_failure": None,
+            "last_success": None,
+            "last_skip": {"version": "1.1.0", "reason": "daemon_running", "at": 0},
+        }
+    )
+
+    main._maybe_install_update()
+
+    assert autoupgrade.read_state()["last_skip"] is None
+
+
 def test_returncode_zero_but_wrong_version_counts_as_failure(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -247,6 +277,20 @@ def test_run_update_check_and_maybe_install_swallows_unexpected_errors(
     main._run_update_check_and_maybe_install(True)  # must not raise
 
 
+def test_run_update_check_and_maybe_install_skips_network_refresh_when_retrying(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    refresh_called = SimpleNamespace(value=False)
+    monkeypatch.setattr(main, "_run_update_check", lambda: refresh_called.__setattr__("value", True))
+    install_called = SimpleNamespace(value=False)
+    monkeypatch.setattr(main, "_maybe_install_update", lambda: install_called.__setattr__("value", True))
+
+    main._run_update_check_and_maybe_install(True, refresh_cache=False)
+
+    assert refresh_called.value is False
+    assert install_called.value is True
+
+
 # ── _is_interactive_session ─────────────────────────────────────────────────
 
 def test_is_interactive_session_true_when_tty_and_no_ci_and_not_json(
@@ -330,3 +374,127 @@ def test_main_skips_worker_entirely_when_auto_upgrade_off(
 
     assert launched.value is False
     assert notified.value is False
+
+
+# ── _has_pending_silent_install ─────────────────────────────────────────────
+
+def test_pending_install_true_when_newer_cached_and_not_backed_off(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(main, "_read_update_cache", lambda: ("1.1.0", 0.0))
+    assert main._has_pending_silent_install("1.0.0") is True
+
+
+def test_pending_install_false_when_no_current_version() -> None:
+    assert main._has_pending_silent_install("") is False
+
+
+def test_pending_install_false_when_cache_has_no_newer_version(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(main, "_read_update_cache", lambda: ("1.0.0", 0.0))
+    assert main._has_pending_silent_install("1.0.0") is False
+
+
+def test_pending_install_false_when_backoff_exhausted(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(main, "_read_update_cache", lambda: ("1.1.0", 0.0))
+    autoupgrade.write_state(
+        {
+            "active": None,
+            "last_failure": {"version": "1.1.0", "failed_at": 0, "attempts": 2},
+            "last_success": None,
+        }
+    )
+    assert main._has_pending_silent_install("1.0.0") is False
+
+
+def test_pending_install_false_when_already_actively_installing(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import time as time_module
+
+    monkeypatch.setattr(main, "_read_update_cache", lambda: ("1.1.0", 0.0))
+    autoupgrade.write_state(
+        {
+            "active": {"version": "1.1.0", "started_at": time_module.time()},
+            "last_failure": None,
+            "last_success": None,
+        }
+    )
+    assert main._has_pending_silent_install("1.0.0") is False
+
+
+# ── _launch_update_check_process: retry an install even when the cache is fresh ──
+#
+# Regression coverage for a real bug found via manual testing (2026-07-23):
+# the install retry was tied to the same 24h TTL as the network check, so once
+# an install attempt was blocked for any reason (daemon running, a momentarily
+# non-interactive session, ...), the CLI would keep showing the same cached
+# "update available" notice without ever retrying the install until the cache
+# went stale up to 24h later.
+
+def test_launch_process_retries_install_when_cache_fresh_and_install_pending(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(main, "_read_update_cache", lambda: ("1.1.0", main.time.time()))
+    monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.0.0")
+    monkeypatch.setattr(main.sys, "executable", "/usr/bin/python3")
+
+    calls: list[tuple[list[str], dict]] = []
+    monkeypatch.setattr(main.subprocess, "Popen", lambda cmd, **kwargs: calls.append((cmd, kwargs)))
+
+    main._launch_update_check_process(True)
+
+    assert len(calls) == 1
+    cmd, _kwargs = calls[0]
+    # refresh_cache must be False: retry the install without hitting PyPI again.
+    assert cmd[2] == (
+        "from forgexa_cli.main import _run_update_check_and_maybe_install; "
+        "_run_update_check_and_maybe_install(True, False)"
+    )
+
+
+def test_launch_process_does_nothing_when_cache_fresh_and_not_allowed_to_install(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(main, "_read_update_cache", lambda: ("1.1.0", main.time.time()))
+    monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.0.0")
+    calls: list[tuple[list[str], dict]] = []
+    monkeypatch.setattr(main.subprocess, "Popen", lambda cmd, **kwargs: calls.append((cmd, kwargs)))
+
+    main._launch_update_check_process(False)  # e.g. notify mode
+
+    assert calls == []
+
+
+def test_launch_process_does_nothing_when_cache_fresh_and_nothing_pending(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(main, "_read_update_cache", lambda: ("1.0.0", main.time.time()))
+    monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.0.0")  # already up to date
+    calls: list[tuple[list[str], dict]] = []
+    monkeypatch.setattr(main.subprocess, "Popen", lambda cmd, **kwargs: calls.append((cmd, kwargs)))
+
+    main._launch_update_check_process(True)
+
+    assert calls == []
+
+
+def test_launch_process_does_not_retry_once_backoff_exhausted(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(main, "_read_update_cache", lambda: ("1.1.0", main.time.time()))
+    monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.0.0")
+    autoupgrade.write_state(
+        {
+            "active": None,
+            "last_failure": {"version": "1.1.0", "failed_at": 0, "attempts": 2},
+            "last_success": None,
+        }
+    )
+    calls: list[tuple[list[str], dict]] = []
+    monkeypatch.setattr(main.subprocess, "Popen", lambda cmd, **kwargs: calls.append((cmd, kwargs)))
+
+    main._launch_update_check_process(True)
+
+    assert calls == []

{forgexa_cli-1.21.2 → forgexa_cli-1.21.3}/tests/test_upgrade_observability.py

@@ -116,6 +116,7 @@ def test_version_status_shows_full_state(
             "active": {"version": "1.22.0", "started_at": 0},
             "last_failure": {"version": "1.21.0", "failed_at": 0, "attempts": 1},
             "last_success": {"version": "1.20.0", "installed_at": 0, "notified": True},
+            "last_skip": {"version": "1.22.0", "reason": "daemon_running", "at": 0},
         }
     )
 
@@ -126,4 +127,5 @@ def test_version_status_shows_full_state(
     assert "Active install    : 1.22.0" in out
     assert "Last success      : 1.20.0" in out
     assert "Last failure      : 1.21.0" in out
+    assert "Last skip         : 1.22.0 (reason=daemon_running" in out
     assert "Upgrade log       :" in out