forgexa-cli 1.47.2__tar.gz → 1.47.4__tar.gz

{forgexa_cli-1.47.2 → forgexa_cli-1.47.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.47.2
+Version: 1.47.4
 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
@@ -132,10 +132,16 @@ forgexa upgrade --target-version 1.12.3
 
 The command detects how `forgexa-cli` was installed:
 
-- `pipx` install: uses `pipx upgrade forgexa-cli`, or `pipx install --force forgexa-cli==<version>` for a pinned version
-- `pip` install: uses `python -m pip install --upgrade forgexa-cli`
+- `pipx` install: uses `pipx upgrade --index-url https://pypi.org/simple forgexa-cli`, or `pipx install --force --index-url https://pypi.org/simple forgexa-cli==<version>` for a pinned version
+- `pip` install: uses `python -m pip install --upgrade --index-url https://pypi.org/simple forgexa-cli`
 - non-editable local path install (`pip install /path/to/cli`): follows the same `pip` upgrade path and switches to the published PyPI release
 
+Self-upgrades pass `--index-url https://pypi.org/simple` to pip or pipx, matching the official PyPI release check and avoiding a configured mirror that has not yet synchronized a new release. A direct `pip install --upgrade forgexa-cli` command always follows that Python environment's pip configuration. When its mirror is behind, upgrade manually with:
+
+```bash
+python -m pip install --upgrade --index-url https://pypi.org/simple forgexa-cli==1.12.3
+```
+
 For safety, `forgexa upgrade` stops any running local daemon before upgrading. If the daemon was previously started in background mode, the CLI starts it again automatically after a successful upgrade; otherwise it prints a manual restart hint.
 
 `forgexa upgrade` supports standard PyPI / pipx installs and non-editable local path installs. Editable installs, VCS installs, and other direct URL installs are rejected with a manual upgrade hint.

{forgexa_cli-1.47.2 → forgexa_cli-1.47.4}/README.md

@@ -100,10 +100,16 @@ forgexa upgrade --target-version 1.12.3
 
 The command detects how `forgexa-cli` was installed:
 
-- `pipx` install: uses `pipx upgrade forgexa-cli`, or `pipx install --force forgexa-cli==<version>` for a pinned version
-- `pip` install: uses `python -m pip install --upgrade forgexa-cli`
+- `pipx` install: uses `pipx upgrade --index-url https://pypi.org/simple forgexa-cli`, or `pipx install --force --index-url https://pypi.org/simple forgexa-cli==<version>` for a pinned version
+- `pip` install: uses `python -m pip install --upgrade --index-url https://pypi.org/simple forgexa-cli`
 - non-editable local path install (`pip install /path/to/cli`): follows the same `pip` upgrade path and switches to the published PyPI release
 
+Self-upgrades pass `--index-url https://pypi.org/simple` to pip or pipx, matching the official PyPI release check and avoiding a configured mirror that has not yet synchronized a new release. A direct `pip install --upgrade forgexa-cli` command always follows that Python environment's pip configuration. When its mirror is behind, upgrade manually with:
+
+```bash
+python -m pip install --upgrade --index-url https://pypi.org/simple forgexa-cli==1.12.3
+```
+
 For safety, `forgexa upgrade` stops any running local daemon before upgrading. If the daemon was previously started in background mode, the CLI starts it again automatically after a successful upgrade; otherwise it prints a manual restart hint.
 
 `forgexa upgrade` supports standard PyPI / pipx installs and non-editable local path installs. Editable installs, VCS installs, and other direct URL installs are rejected with a manual upgrade hint.

{forgexa_cli-1.47.2 → forgexa_cli-1.47.4}/forgexa_cli/__init__.py

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

{forgexa_cli-1.47.2 → forgexa_cli-1.47.4}/forgexa_cli/daemon.py

@@ -197,6 +197,7 @@ def _windows_daemon_process_query(exclude_pid: int) -> str:
 
 
 _LOCAL_RUNTIME_REGISTRATION_SCHEMA_VERSION = 1
+_DESKTOP_DAEMON_RESTART_REQUEST_SCHEMA_VERSION = 1
 
 
 def _local_runtime_registration_path() -> Path:
@@ -210,6 +211,47 @@ def _local_runtime_registration_path() -> Path:
     return Path.home() / ".forgexa" / "daemon" / "runtime-registrations.json"
 
 
+def _desktop_daemon_restart_request_path(instance_id: str) -> Path:
+    return (
+        Path.home()
+        / ".forgexa"
+        / "daemon"
+        / "restart-requests"
+        / f"{instance_id}.json"
+    )
+
+
+def _desktop_daemon_restart_target_version(instance_id: str) -> str | None:
+    """Return a restart target only when the request belongs to this daemon."""
+    try:
+        request = json.loads(
+            _desktop_daemon_restart_request_path(instance_id).read_text(encoding="utf-8")
+        )
+    except (OSError, ValueError):
+        return None
+    if not isinstance(request, dict):
+        return None
+    if request.get("schema_version") != _DESKTOP_DAEMON_RESTART_REQUEST_SCHEMA_VERSION:
+        return None
+    if request.get("instance_id") != instance_id:
+        return None
+    target_version = request.get("target_version")
+    return target_version.strip() if isinstance(target_version, str) and target_version.strip() else None
+
+
+def _clear_desktop_daemon_restart_request(instance_id: str) -> None:
+    path = _desktop_daemon_restart_request_path(instance_id)
+    try:
+        request = json.loads(path.read_text(encoding="utf-8"))
+        if not isinstance(request, dict) or request.get("instance_id") != instance_id:
+            return
+        path.unlink(missing_ok=True)
+    except FileNotFoundError:
+        return
+    except (OSError, ValueError):
+        logger.warning("Failed to clear desktop daemon restart request")
+
+
 def _write_local_runtime_registration_snapshot(
     instance_id: str,
     state: str,
@@ -221,13 +263,16 @@ def _write_local_runtime_registration_snapshot(
         "schema_version": _LOCAL_RUNTIME_REGISTRATION_SCHEMA_VERSION,
         "pid": os.getpid(),
         "instance_id": instance_id,
+        "daemon_version": DAEMON_VERSION,
+        "client_type": _CLIENT_TYPE,
+        "desktop_restart_protocol_version": _DESKTOP_DAEMON_RESTART_REQUEST_SCHEMA_VERSION,
         "updated_at": int(time.time()),
         "state": state,
         "registrations": registrations,
     }
     try:
         path.parent.mkdir(parents=True, exist_ok=True)
-        tmp_path = path.with_name(path.name + ".tmp")
+        tmp_path = path.with_name(f"{path.name}.{os.getpid()}.tmp")
         tmp_path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
         if os.name != "nt":
             os.chmod(tmp_path, 0o600)
@@ -1075,7 +1120,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.47.2"
+DAEMON_VERSION = "1.47.4"
 
 
 def _detect_client_type() -> str:
@@ -1508,14 +1553,19 @@ def _filter_local_bind_task_result(result: "TaskResult") -> None:
     agent observations are classified as data that must NEVER leave the
     user's machine by default for workspace_resolution="local_bind" tasks —
     only Git-tracked artifacts (already pushed) and status/metrics/Git
-    metadata sync. error/failure_code/metrics/git/artifacts/evidence_summary are left as-is
-    (status metadata, not raw output) — only stdout/stderr tail and raw
-    agent observations are cleared. Mutates `result` in place; call this
-    right before ProgressReporter.report_complete().
+    metadata sync. Failure codes, metrics, Git metadata, artifacts, and
+    evidence summaries are preserved; free-text errors are replaced because
+    they can contain local paths or Agent output. Mutates `result` in place;
+    call this right before ProgressReporter.report_complete().
     """
     result.stdout = ""
     result.stderr = ""
     result.observations = []
+    if result.error:
+        result.error = (
+            "Local task failed. Review this task in Forgexa Desktop on the "
+            "running device."
+        )
 
 def _prepare_ai_job_output(
     *,
@@ -2212,6 +2262,99 @@ def _append_local_bind_output_log(task_id: str, lines: list[str]) -> None:
         logger.warning("Failed to append local-bind output log for task %s: %s", task_id, e)
 
 
+def _local_bind_tool_activity(tool_name: object, completed: bool = False) -> str:
+    """Return a content-free activity label for a local Agent tool event."""
+    normalized = tool_name.lower() if isinstance(tool_name, str) else ""
+    if normalized in {
+        "read", "read_file", "file_read", "file_search", "grep_search",
+        "semantic_search", "search", "list_dir", "glob",
+    }:
+        return "agent.inspecting_files"
+    if normalized in {
+        "write", "create_file", "apply_patch", "str_replace", "str_replace_editor",
+        "file_edit", "file_change", "edit",
+    }:
+        return "agent.updating_files"
+    if normalized in {
+        "bash", "run_in_terminal", "execute_command", "command_execution", "terminal",
+    }:
+        return "agent.completed_command" if completed else "agent.running_command"
+    if normalized in {"get_errors", "lint", "test"}:
+        return "agent.checking_diagnostics"
+    return "agent.using_workspace_tool"
+
+
+def _summarize_local_bind_output(lines: list[str]) -> list[str]:
+    """Derive Web-safe activity labels without returning Agent output content."""
+    activity_lines: list[str] = []
+    seen: set[str] = set()
+
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            continue
+        try:
+            event = json.loads(stripped)
+        except json.JSONDecodeError:
+            activity = "agent.producing_output"
+        else:
+            if not isinstance(event, dict):
+                continue
+            event_type = event.get("type")
+            data = event.get("data") if isinstance(event.get("data"), dict) else event
+            activity = None
+
+            if event_type == "tool.execution_start":
+                activity = _local_bind_tool_activity(data.get("toolName"))
+            elif event_type == "assistant.message":
+                activity = (
+                    "agent.planning_next_action"
+                    if data.get("toolRequests")
+                    else "agent.wrote_update"
+                )
+            elif event_type == "assistant":
+                message = event.get("message")
+                content = message.get("content") if isinstance(message, dict) else None
+                if isinstance(content, list):
+                    for item in content:
+                        if not isinstance(item, dict):
+                            continue
+                        if item.get("type") == "tool_use":
+                            activity = _local_bind_tool_activity(item.get("name"))
+                            break
+                        if item.get("type") == "text":
+                            activity = "agent.wrote_update"
+                            break
+            elif event_type in {"item.started", "item.completed"}:
+                item = event.get("item")
+                item_type = item.get("type") if isinstance(item, dict) else None
+                if item_type == "agent_message":
+                    activity = "agent.wrote_update"
+                elif item_type:
+                    activity = _local_bind_tool_activity(
+                        item_type,
+                        completed=event_type == "item.completed",
+                    )
+            elif event_type == "tool_use":
+                part = event.get("part")
+                tool_name = part.get("tool") if isinstance(part, dict) else None
+                activity = _local_bind_tool_activity(tool_name)
+            elif event_type == "text":
+                activity = "agent.wrote_update"
+            elif event_type == "result":
+                activity = (
+                    "agent.reported_error"
+                    if event.get("is_error")
+                    else "agent.completed_response"
+                )
+
+        if activity and activity not in seen:
+            activity_lines.append(activity)
+            seen.add(activity)
+
+    return activity_lines
+
+
 _LOCAL_BIND_SSH_SCHEME_RE = re.compile(r"^ssh://(?:[^@/]+@)?([^/:]+)(?::\d+)?/(.+?)(?:\.git)?/?$")
 _LOCAL_BIND_HTTP_SCHEME_RE = re.compile(r"^https?://(?:[^@/]+@)?([^/:]+)(?::\d+)?/(.+?)(?:\.git)?/?$")
 _LOCAL_BIND_SCP_LIKE_RE = re.compile(r"^[^@/]+@([^:/]+):(.+?)(?:\.git)?/?$")
@@ -5382,6 +5525,7 @@ class ProcessManager:
                 timeout,
                 task.task_id,
                 on_chunk,
+                stream_stderr=task.workspace_resolution == "local_bind",
                 disable_builtin_mcps=task.input_data.get("task_type") in {
                     "test_script_generate",
                     "qa_scenario_preview",
@@ -6274,6 +6418,7 @@ class ProcessManager:
         self, agent: DiscoveredAgent, prompt: str, cwd: Path, timeout: int, task_id: str,
         on_chunk: Any = None,
         *,
+        stream_stderr: bool = False,
         disable_builtin_mcps: bool = False,
         _retry_without_effort: bool = False,
         _retry_without_token_env: bool = False,
@@ -6454,6 +6599,7 @@ class ProcessManager:
             stdout, stderr, returncode = await self._stream_process(
                 proc, None, timeout, task_id, on_chunk,
                 workspace_path=cwd,
+                stream_stderr=stream_stderr,
             )
 
             # Parse copilot JSONL output for metrics
@@ -6515,6 +6661,7 @@ class ProcessManager:
                     timeout,
                     task_id,
                     on_chunk,
+                    stream_stderr=stream_stderr,
                     disable_builtin_mcps=True,
                     _retry_without_effort=_retry_without_effort,
                     _retry_without_token_env=_retry_without_token_env,
@@ -6559,6 +6706,7 @@ class ProcessManager:
                         timeout,
                         task_id,
                         on_chunk,
+                        stream_stderr=stream_stderr,
                         disable_builtin_mcps=disable_builtin_mcps,
                         _retry_without_effort=_retry_without_effort,
                         _retry_without_token_env=True,
@@ -6622,6 +6770,7 @@ class ProcessManager:
                     )
                     return await self._run_copilot(
                         agent, prompt, cwd, timeout, task_id, on_chunk,
+                        stream_stderr=stream_stderr,
                         disable_builtin_mcps=disable_builtin_mcps,
                         _retry_without_effort=True,
                         _retry_without_token_env=_retry_without_token_env,
@@ -7056,6 +7205,7 @@ class ProgressReporter:
         self.server_url = server_url.rstrip("/")
         self.runtime_id = runtime_id
         self._last_progress_sent: dict[str, dict[str, Any]] = {}
+        self._pending_output_lines: dict[str, list[str]] = {}
 
     def _should_skip_progress(
         self,
@@ -7063,11 +7213,12 @@ class ProgressReporter:
         progress_percent: int,
         current_step: str,
         output_lines: list[str],
+        activity_lines: list[str],
         files_changed: list[str],
         lines_added: int,
         lines_removed: int,
     ) -> bool:
-        if output_lines or files_changed or lines_added or lines_removed:
+        if output_lines or activity_lines or files_changed or lines_added or lines_removed:
             return False
 
         last = self._last_progress_sent.get(task_id)
@@ -7085,47 +7236,68 @@ class ProgressReporter:
         progress_percent: int,
         current_step: str,
         output_lines: list[str] | None = None,
+        activity_lines: list[str] | None = None,
         files_changed: list[str] | None = None,
         lines_added: int = 0,
         lines_removed: int = 0,
-    ):
-        output_lines = output_lines or []
+    ) -> bool:
+        output_lines = [
+            *self._pending_output_lines.get(task_id, []),
+            *(output_lines or []),
+        ]
+        activity_lines = activity_lines or []
         files_changed = files_changed or []
         if self._should_skip_progress(
             task_id,
             progress_percent,
             current_step,
             output_lines,
+            activity_lines,
             files_changed,
             lines_added,
             lines_removed,
         ):
-            return
+            return True
 
         try:
-            await self.client.post(
+            response = await self.client.post(
                 f"{self.server_url}/api/v1/runtimes/{self.runtime_id}/tasks/{task_id}/progress",
                 json={
                     "progress_percent": progress_percent,
                     "current_step": current_step,
                     "output_lines": output_lines,
+                    "activity_lines": activity_lines,
                     "files_changed": files_changed,
                     "lines_added": lines_added,
                     "lines_removed": lines_removed,
                 },
                 timeout=10,
             )
-            self._last_progress_sent[task_id] = {
-                "progress_percent": progress_percent,
-                "current_step": current_step,
-                "sent_at": time.monotonic(),
-            }
+            if 200 <= response.status_code < 300:
+                self._pending_output_lines.pop(task_id, None)
+                self._last_progress_sent[task_id] = {
+                    "progress_percent": progress_percent,
+                    "current_step": current_step,
+                    "sent_at": time.monotonic(),
+                }
+                return True
+            logger.warning(
+                "Failed to report progress for task %s: server returned %s %s",
+                task_id,
+                response.status_code,
+                response.text[:500],
+            )
         except Exception as e:
-            logger.warning("Failed to report progress for task %s: %s", task_id, e)
+            logger.warning("Failed to report progress for task %s: %s", task_id, _format_exc(e))
+
+        if output_lines:
+            self._pending_output_lines[task_id] = output_lines[-5000:]
+        return False
 
     async def report_complete(self, task_id: str, result: TaskResult):
         """Report task completion with retry."""
         self._last_progress_sent.pop(task_id, None)
+        self._pending_output_lines.pop(task_id, None)
         payload = {
             "status": result.status,
             "exit_code": result.exit_code,
@@ -7717,6 +7889,7 @@ class TaskPoller:
                 self._on_auth_failure()
                 return []
             else:
+                logger.warning("Task poll failed: %s %s", resp.status_code, resp.text[:500])
                 return []
 
             data = resp.json()
@@ -7775,10 +7948,12 @@ class TaskPoller:
                 return data.get("ai_jobs", [])
             elif resp.status_code in (401, 403):
                 self._on_auth_failure()
+            else:
+                logger.warning("AIJob poll failed: %s %s", resp.status_code, resp.text[:500])
             self.cancelled_ai_job_ids = []
             return []
         except Exception as e:
-            logger.debug("AIJob poll error: %s", _format_exc(e))
+            logger.warning("AIJob poll error: %s", _format_exc(e))
             self.cancelled_ai_job_ids = []
             return []
 
@@ -7908,7 +8083,7 @@ class ServerConnection:
             "capabilities": {
                 "platform": platform.platform(),
                 "python_version": platform.python_version(),
-                "local_workspace_bindings": {"protocol_version": 2},
+                "local_workspace_bindings": {"protocol_version": 3},
             },
             "server_url": self.server_url,
             "expires_in_days": 90,
@@ -8306,7 +8481,7 @@ class ServerConnection:
                 "capabilities": {
                     "platform": platform.platform(),
                     "python_version": platform.python_version(),
-                    "local_workspace_bindings": {"protocol_version": 2},
+                    "local_workspace_bindings": {"protocol_version": 3},
                     "local_evidence": {"protocol_version": 1, "structured_summary": True},
                     "local_evidence": {"protocol_version": 1, "structured_summary": True},
                 },
@@ -8715,6 +8890,7 @@ class RuntimeDaemon:
         self._shutdown = False
         self._local_runtime_instance_id = secrets.token_urlsafe(18)
         self._local_runtime_registrations: dict[str, dict[str, int | str]] = {}
+        self._desktop_restart_requested = False
 
         # Deployment merge worktree GC: runs at most every 6 hours.
         self._last_merge_gc: float = 0.0
@@ -8801,10 +8977,32 @@ class RuntimeDaemon:
         }
         _write_local_runtime_registration_snapshot(
             self._local_runtime_instance_id,
-            "ready",
+            "draining" if getattr(self, "_desktop_restart_requested", False) else "ready",
             self._local_runtime_registrations,
         )
 
+    def _begin_desktop_restart_drain_if_requested(self) -> bool:
+        target_version = _desktop_daemon_restart_target_version(
+            self._local_runtime_instance_id
+        )
+        if not target_version:
+            return self._desktop_restart_requested
+        if target_version == DAEMON_VERSION:
+            _clear_desktop_daemon_restart_request(self._local_runtime_instance_id)
+            return self._desktop_restart_requested
+        if not self._desktop_restart_requested:
+            self._desktop_restart_requested = True
+            _write_local_runtime_registration_snapshot(
+                self._local_runtime_instance_id,
+                "draining",
+                self._local_runtime_registrations,
+            )
+            logger.info(
+                "Desktop requested daemon restart for version %s; draining active tasks",
+                target_version,
+            )
+        return True
+
     @staticmethod
     def _resolve_task_output_dir(task: TaskInfo) -> str:
         input_data = task.input_data or {}
@@ -9270,7 +9468,16 @@ class RuntimeDaemon:
         # 3. Main loop
         try:
             while not self._shutdown:
-                had_work = await self._poll_and_execute()
+                draining_for_desktop_restart = self._begin_desktop_restart_drain_if_requested()
+                had_work = await self._poll_and_execute(
+                    accept_new_tasks=not draining_for_desktop_restart,
+                )
+                if draining_for_desktop_restart and not self.active_tasks:
+                    logger.info("Desktop daemon drain complete; restarting through the updated client")
+                    self._shutdown = True
+                    continue
+                if self._shutdown:
+                    break
                 next_delay = self.poll_interval
                 if self.connections:
                     next_delay = min(
@@ -9289,7 +9496,7 @@ class RuntimeDaemon:
         finally:
             await self._shutdown_gracefully()
 
-    async def _poll_and_execute(self) -> bool:
+    async def _poll_and_execute(self, *, accept_new_tasks: bool = True) -> bool:
         """Poll for tasks from all connected servers and execute them."""
         had_work = False
 
@@ -9327,11 +9534,11 @@ class RuntimeDaemon:
 
         # Poll from all connected servers
         for conn in self.connections:
-            has_capacity = total_active < self.max_concurrent
+            has_capacity = accept_new_tasks and total_active < self.max_concurrent
             tasks = await conn.poller.poll() if has_capacity else []
             # Always poll AI jobs so server-requested cancellations can stop a
             # process that is itself consuming the last available slot.
-            ai_jobs = await conn.poller.poll_ai_jobs()
+            ai_jobs = await conn.poller.poll_ai_jobs() if accept_new_tasks else []
             _cancel_server_requested_ai_jobs(conn)
             total_active = len(self.active_tasks)
             has_capacity = total_active < self.max_concurrent
@@ -9665,6 +9872,11 @@ class RuntimeDaemon:
         # skipped for a node bound to the user's own real directory. See
         # docs/designs/forgexa-ide-design.md §6.2.
         is_local_bind = task.workspace_resolution == "local_bind"
+        async def report_task_complete(result: TaskResult) -> None:
+            if is_local_bind:
+                _filter_local_bind_task_result(result)
+            await reporter.report_complete(task.task_id, result)
+
         default_branch = str((task.project or {}).get("default_branch") or "").strip()
         node_before_sha = ""
         # Use workspace-level granularity (requirement_workflow_id or graph_id) so that
@@ -9697,7 +9909,7 @@ class RuntimeDaemon:
             )
             if local_bind_file_lock is None:
                 project_lock.release()
-                await reporter.report_complete(task.task_id, TaskResult(
+                await report_task_complete(TaskResult(
                     status="failed", exit_code=-1, stdout="", stderr="",
                     error=(
                         "local_binding_unavailable: another process on this "
@@ -9724,7 +9936,7 @@ class RuntimeDaemon:
                 }
                 hint = _INSTALL_HINTS.get(task.agent_type, f"install the '{task.agent_type}' CLI tool")
                 logger.error("No agent found for type '%s' on this runtime", task.agent_type)
-                await reporter.report_complete(task.task_id, TaskResult(
+                await report_task_complete(TaskResult(
                     status="failed", exit_code=-1, stdout="", stderr="",
                     error=(
                         f"Agent '{task.agent_type}' is not available on this runtime. "
@@ -9758,7 +9970,7 @@ class RuntimeDaemon:
                 _pf_checks = project_preflight.get("checks", [])
                 _pf_detail = _pf_checks[0].get("detail", "Project preflight failed") if _pf_checks else "Project preflight failed"
                 logger.warning("Project preflight failed for task %s: %s", task.task_id, _pf_detail)
-                await reporter.report_complete(task.task_id, TaskResult(
+                await report_task_complete(TaskResult(
                     status="failed", exit_code=-1, stdout="", stderr="",
                     error=_pf_detail,
                     failure_code="project_preflight_failed",
@@ -9810,9 +10022,10 @@ class RuntimeDaemon:
             # 3. Run agent with real-time output streaming + periodic progress heartbeat
             await reporter.report_progress(task.task_id, 10, "running_agent")
 
-            # Buffer agent output lines between ticks; the ticker flushes them
-            # every 10 seconds so the server accumulates a real-time log.
+            # Buffer cloud output or local-bind activity summaries between
+            # ticks so the server accumulates a real-time, safe display log.
             _line_buffer: list[str] = []
+            last_local_activity: str | None = None
             _task_start = time.monotonic()
             progress_stop = asyncio.Event()
 
@@ -9821,18 +10034,43 @@ class RuntimeDaemon:
 
                 Forgexa IDE local-bind (design doc §6.6/§12.6.2): raw agent
                 terminal output must never leave the user's machine by
-                default — skip buffering into the server-bound progress
-                report entirely (every report_progress() flush below sends
-                an empty output_lines list, not live stdout content).
+                default. A content-free activity summary is sent through the
+                dedicated activity_lines field so Web users can follow task
+                progress without receiving stdout, commands, paths, or text.
                 Instead, append to a local-only, OS-user-private log file so
                 the IDE can still tail it on THIS machine (never sent over
                 HTTP by this module).
                 """
+                nonlocal last_local_activity
                 if is_local_bind:
                     _append_local_bind_output_log(task.task_id, lines)
+                    for activity in _summarize_local_bind_output(lines):
+                        if activity != last_local_activity:
+                            _line_buffer.append(activity)
+                            last_local_activity = activity
                     return
                 _line_buffer.extend(lines)
 
+            async def report_stream_progress(
+                progress_percent: int,
+                current_step: str,
+                output_lines: list[str],
+            ) -> None:
+                if is_local_bind:
+                    await reporter.report_progress(
+                        task.task_id,
+                        progress_percent,
+                        current_step,
+                        activity_lines=output_lines,
+                    )
+                else:
+                    await reporter.report_progress(
+                        task.task_id,
+                        progress_percent,
+                        current_step,
+                        output_lines=output_lines,
+                    )
+
             async def _progress_ticker():
                 """Flush buffered output lines + update progress % every 1 s.
 
@@ -9856,9 +10094,7 @@ class RuntimeDaemon:
                     # Grab and clear the buffer atomically
                     lines_to_send = _line_buffer[:]
                     _line_buffer.clear()
-                    await reporter.report_progress(
-                        task.task_id, pct, step, output_lines=lines_to_send
-                    )
+                    await report_stream_progress(pct, step, lines_to_send)
 
             ticker_task = asyncio.create_task(_progress_ticker())
 
@@ -9877,9 +10113,7 @@ class RuntimeDaemon:
                 if _line_buffer:
                     pid = self.process_manager.active_processes.get(task.task_id)
                     step = f"running_agent (pid={pid.pid})" if pid else "running_agent"
-                    await reporter.report_progress(
-                        task.task_id, 90, step, output_lines=_line_buffer[:]
-                    )
+                    await report_stream_progress(90, step, _line_buffer[:])
                     _line_buffer.clear()
 
             tried_agents.add(agent.agent_id)
@@ -9978,9 +10212,7 @@ class RuntimeDaemon:
                                 step += f" (pid={pid.pid})"
                             lines_to_send = _line_buffer[:]
                             _line_buffer.clear()
-                            await reporter.report_progress(
-                                task.task_id, pct, step, output_lines=lines_to_send
-                            )
+                            await report_stream_progress(pct, step, lines_to_send)
 
                     ticker2 = asyncio.create_task(_progress_ticker2())
                     try:
@@ -9995,9 +10227,10 @@ class RuntimeDaemon:
                         except asyncio.CancelledError:
                             pass
                         if _line_buffer:
-                            await reporter.report_progress(
-                                task.task_id, 90, f"running_agent:{agent.agent_id}",
-                                output_lines=_line_buffer[:],
+                            await report_stream_progress(
+                                90,
+                                f"running_agent:{agent.agent_id}",
+                                _line_buffer[:],
                             )
                             _line_buffer.clear()
 
@@ -10480,19 +10713,14 @@ class RuntimeDaemon:
                     or "validation_retry_exhausted"
                 )
             result.execution_attempt_id = task.execution_attempt_id
-            if is_local_bind:
-                # See docs/designs/forgexa-ide-design.md §6.6 — full terminal
-                # output and raw agent observations must never leave the
-                # user's machine by default.
-                _filter_local_bind_task_result(result)
             await reporter.report_progress(task.task_id, 100, "completed" if result.status == "success" else "failed")
-            await reporter.report_complete(task.task_id, result)
+            await report_task_complete(result)
 
             logger.info("Task %s completed: %s (agent=%s)", task.task_id, result.status, agent.agent_id)
 
         except Exception as e:
             logger.exception("Task %s failed with exception", task.task_id)
-            await reporter.report_complete(task.task_id, TaskResult(
+            await report_task_complete(TaskResult(
                 status="failed", exit_code=-1, stdout="", stderr="",
                 error=str(e),
                 execution_attempt_id=task.execution_attempt_id,
@@ -15394,7 +15622,9 @@ class RuntimeDaemon:
         for conn in self.connections:
             await conn.stop()
 
-        _clear_local_runtime_registration_snapshot(self._local_runtime_instance_id)
+        if not getattr(self, "_desktop_restart_requested", False):
+            _clear_local_runtime_registration_snapshot(self._local_runtime_instance_id)
+        _clear_desktop_daemon_restart_request(self._local_runtime_instance_id)
         logger.info("Daemon stopped.")
 
     def handle_signal(self, sig):

{forgexa_cli-1.47.2 → forgexa_cli-1.47.4}/forgexa_cli/main.py

@@ -79,6 +79,8 @@ except ImportError:
 
 # Module-level override applied by main() when --server-url is passed.
 _SERVER_URL_OVERRIDE: str | None = None
+_OFFICIAL_PYPI_BASE_URL = "https://pypi.org"
+_OFFICIAL_PYPI_SIMPLE_INDEX_URL = f"{_OFFICIAL_PYPI_BASE_URL}/simple"
 
 
 # ── Banner ────────────────────────────────────────────────────────────────────
@@ -924,9 +926,22 @@ def _build_upgrade_plan(target_version: str | None) -> UpgradePlan:
                 "Use `pipx upgrade forgexa-cli` manually after restoring your pipx installation."
             )
         if target_version:
-            command = [pipx, "install", "--force", _package_spec_for_version(target_version)]
+            command = [
+                pipx,
+                "install",
+                "--force",
+                "--index-url",
+                _OFFICIAL_PYPI_SIMPLE_INDEX_URL,
+                _package_spec_for_version(target_version),
+            ]
         else:
-            command = [pipx, "upgrade", "forgexa-cli"]
+            command = [
+                pipx,
+                "upgrade",
+                "--index-url",
+                _OFFICIAL_PYPI_SIMPLE_INDEX_URL,
+                "forgexa-cli",
+            ]
         return UpgradePlan(
             installer="pipx",
             command=command,
@@ -940,7 +955,15 @@ def _build_upgrade_plan(target_version: str | None) -> UpgradePlan:
             "Reinstall forgexa-cli with pipx or a Python environment that includes pip."
         )
 
-    command = [python, "-m", "pip", "install", "--upgrade"]
+    command = [
+        python,
+        "-m",
+        "pip",
+        "install",
+        "--upgrade",
+        "--index-url",
+        _OFFICIAL_PYPI_SIMPLE_INDEX_URL,
+    ]
     if _is_user_site_install(dist_root) and not _is_virtualenv():
         command.append("--user")
     if _is_pep668_environment():
@@ -1017,16 +1040,29 @@ def _version_is_newer(candidate: str, reference: str) -> bool:
         return False
 
 
-def _run_update_check() -> None:
-    """Fetch the latest published CLI version and refresh the local cache."""
+def _latest_published_cli_version() -> str:
+    """Return the current forgexa-cli version from the official PyPI API."""
     try:
         import httpx
 
         with httpx.Client(timeout=5) as client:
-            resp = client.get("https://pypi.org/pypi/forgexa-cli/json")
-            resp.raise_for_status()
-            latest = str(resp.json()["info"]["version"])
-        _write_update_cache(latest)
+            response = client.get(f"{_OFFICIAL_PYPI_BASE_URL}/pypi/forgexa-cli/json")
+            response.raise_for_status()
+            version = _normalize_target_version(str(response.json()["info"]["version"]))
+    except Exception as exc:
+        raise RuntimeError(
+            "Could not determine the latest forgexa-cli release from PyPI. "
+            "Check access to pypi.org or specify --target-version."
+        ) from exc
+    if version is None:
+        raise RuntimeError("PyPI did not return a forgexa-cli version.")
+    return version
+
+
+def _run_update_check() -> None:
+    """Fetch the latest published CLI version and refresh the local cache."""
+    try:
+        _write_update_cache(_latest_published_cli_version())
     except Exception:
         pass  # Network errors are silently ignored
 
@@ -1581,13 +1617,15 @@ def _run_windows_upgrade_worker(payload: str) -> None:
         parent_pid = int(data["parent_pid"])
         launcher_paths = data.get("launcher_paths", [])
         daemon_stopped = bool(data.get("daemon_stopped"))
-        target_version = str(data.get("target_version") or "latest")
+        target_version = str(data.get("target_version") or "").strip()
     except (KeyError, TypeError, ValueError, json.JSONDecodeError):
         return
     if not isinstance(command, list) or not all(isinstance(part, str) for part in command):
         return
     if not isinstance(launcher_paths, list) or not all(isinstance(path, str) for path in launcher_paths):
         return
+    if not target_version:
+        return
 
     try:
         log_path = _upgrade_log_path()
@@ -1608,6 +1646,13 @@ def _run_windows_upgrade_worker(payload: str) -> None:
             if result.returncode != 0:
                 log_file.write(f"Upgrade failed (returncode={result.returncode}).\n")
                 return
+            installed_version = _installed_cli_version()
+            if installed_version != target_version:
+                log_file.write(
+                    f"Upgrade failed: expected {target_version}, "
+                    f"installed {installed_version or 'unknown'}.\n"
+                )
+                return
             log_file.write("Upgrade complete.\n")
             if daemon_stopped:
                 restarted, server_url = _start_daemon_after_upgrade()
@@ -3446,12 +3491,14 @@ def cmd_version(args: argparse.Namespace) -> None:
 def cmd_upgrade(args: argparse.Namespace) -> None:
     try:
         target_version = _normalize_target_version(getattr(args, "target_version", None))
+        if target_version is None:
+            target_version = _latest_published_cli_version()
         plan = _build_upgrade_plan(target_version)
     except (RuntimeError, ValueError) as exc:
         print(str(exc), file=sys.stderr)
         sys.exit(1)
 
-    if target_version and target_version == plan.current_version:
+    if target_version == plan.current_version:
         print(f"forgexa-cli {plan.current_version} is already installed.")
         return
 
@@ -3470,7 +3517,7 @@ def cmd_upgrade(args: argparse.Namespace) -> None:
         print(f"Stopped local daemon (PID {daemon_pid}) before upgrade.")
 
     print(f"Current version : {plan.current_version}")
-    print(f"Target version  : {target_version or 'latest'}")
+    print(f"Target version  : {target_version}")
     print(f"Upgrade mode    : {plan.installer}")
     print(f"Running         : {shlex.join(plan.command)}")
 
@@ -3494,6 +3541,20 @@ def cmd_upgrade(args: argparse.Namespace) -> None:
         sys.exit(result.returncode or 1)
 
     installed_version = _installed_cli_version() or "unknown"
+    if installed_version != target_version:
+        print(
+            f"Upgrade did not install the requested version {target_version}; "
+            f"installed version is {installed_version}. "
+            "The configured package index, proxy, or constraint may be stale.",
+            file=sys.stderr,
+        )
+        if daemon_stopped:
+            print(
+                "The local daemon was stopped before the upgrade attempt. "
+                "Restart it manually after resolving the package source issue.",
+                file=sys.stderr,
+            )
+        sys.exit(1)
     print(f"Upgrade complete. Installed version: {installed_version}")
     if daemon_stopped:
         restarted, server_url = _start_daemon_after_upgrade()

{forgexa_cli-1.47.2 → forgexa_cli-1.47.4}/forgexa_cli/runtime_evidence.py

@@ -14,7 +14,6 @@ import xml.etree.ElementTree as ElementTree
 from pathlib import Path
 from typing import Any
 
-
 RUNTIME_EVIDENCE_PLAN_VERSION = 1
 TEST_COVERAGE_CHECK_KIND = "test_coverage"
 STATIC_CHECK_KIND = "static_check"
@@ -25,6 +24,7 @@ LOCAL_EVIDENCE_SUMMARY_VERSION = 1
 _DEFAULT_TIMEOUT_SECONDS = 600
 _MAX_FAILED_TESTS = 20
 _MAX_LINT_ISSUES = 50
+_MAX_ACCEPTANCE_CRITERIA_COVERAGE_ITEMS = 200
 _MAX_OUTPUT_CHARS = 100_000
 _MAX_TEST_CASE_RESULTS = 200
 _SHELL_METACHARACTERS = (";", "`", "$", ">", "<", "&", "|", "\n", "\r", "\x00")
@@ -53,6 +53,13 @@ _SAFE_ACCEPTANCE_REFERENCE = re.compile(r"^AC-(\d+)$", re.IGNORECASE)
 _CANONICAL_TEST_CASE_ID = re.compile(r"^TC-(?:00[1-9]|0[1-9]\d|[1-9]\d{2})$", re.IGNORECASE)
 _TEST_CASE_MARKER = re.compile(r"(?<![A-Za-z0-9_-])TC-(\d+)(?![A-Za-z0-9_-])", re.IGNORECASE)
 _SAFE_PYTHON_IDENTIFIER = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+_COVERAGE_DECLARED_OUTCOMES = frozenset({
+    "covered",
+    "partial",
+    "uncovered",
+    "unverifiable",
+    "not_applicable",
+})
 _MYPY_DIAGNOSTIC = re.compile(
     r"^(?P<file>[^:\n]+):(?P<line>[1-9]\d*)(?::(?P<column>[1-9]\d*))?: "
     r"error: (?P<message>.+?)(?:\s+\[(?P<code>[A-Za-z0-9_-]+)\])?\s*$"
@@ -711,7 +718,7 @@ def parse_acceptance_criteria_coverage_artifacts(
         return _acceptance_criteria_coverage_failure("acceptance_criteria_json_invalid_shape")
 
     test_case_intents: dict[str, str] = {}
-    for raw_test_case in test_cases_document["test_cases"][:_MAX_LINT_ISSUES]:
+    for raw_test_case in test_cases_document["test_cases"][:_MAX_ACCEPTANCE_CRITERIA_COVERAGE_ITEMS]:
         if not isinstance(raw_test_case, dict):
             return _acceptance_criteria_coverage_failure("test_case_invalid")
         test_case_id = raw_test_case.get("id")
@@ -725,24 +732,28 @@ def parse_acceptance_criteria_coverage_artifacts(
         ):
             return _acceptance_criteria_coverage_failure("test_case_invalid")
         test_case_intents[test_case_id.strip()] = intent_id.strip()
-    if len(test_cases_document["test_cases"]) > _MAX_LINT_ISSUES:
+    if len(test_cases_document["test_cases"]) > _MAX_ACCEPTANCE_CRITERIA_COVERAGE_ITEMS:
         return _acceptance_criteria_coverage_failure("test_case_limit_exceeded")
 
     coverage_links: list[dict[str, Any]] = []
     seen_acceptance_ids: set[str] = set()
-    for raw_criterion in coverage_matrix_document["acceptance_criteria"][:_MAX_LINT_ISSUES]:
+    for raw_criterion in coverage_matrix_document["acceptance_criteria"][:_MAX_ACCEPTANCE_CRITERIA_COVERAGE_ITEMS]:
         if not isinstance(raw_criterion, dict):
             return _acceptance_criteria_coverage_failure("coverage_matrix_invalid")
         acceptance_id = _canonical_acceptance_criteria_reference(raw_criterion.get("id"))
-        status = raw_criterion.get("status")
-        covered_by = raw_criterion.get("covered_by")
+        raw_status = raw_criterion.get("status")
+        declared_outcome = raw_status.strip().lower() if isinstance(raw_status, str) else ""
+        covered_by = raw_criterion.get("covered_by", [])
         if (
             acceptance_id is None
             or acceptance_id in seen_acceptance_ids
-            or not isinstance(status, str)
-            or status.strip().lower() != "covered"
             or not isinstance(covered_by, list)
-            or not covered_by
+            or declared_outcome not in _COVERAGE_DECLARED_OUTCOMES
+            or (declared_outcome == "covered" and not covered_by)
+            or (
+                declared_outcome in {"uncovered", "unverifiable", "not_applicable"}
+                and covered_by
+            )
         ):
             return _acceptance_criteria_coverage_failure("coverage_matrix_invalid")
         test_case_ids: list[str] = []
@@ -760,8 +771,9 @@ def parse_acceptance_criteria_coverage_artifacts(
             "acceptance_criteria_ref": acceptance_id,
             "test_case_ids": test_case_ids,
             "test_intent_ids": [test_case_intents[test_case_id] for test_case_id in test_case_ids],
+            "declared_outcome": declared_outcome,
         })
-    if len(coverage_matrix_document["acceptance_criteria"]) > _MAX_LINT_ISSUES:
+    if len(coverage_matrix_document["acceptance_criteria"]) > _MAX_ACCEPTANCE_CRITERIA_COVERAGE_ITEMS:
         return _acceptance_criteria_coverage_failure("coverage_matrix_limit_exceeded")
     return {
         "status": "completed",
@@ -1449,4 +1461,4 @@ def _security_score(high: int, medium: int, low: int) -> float:
         return 0.8
     if low > 0:
         return max(0.85, 1.0 - low * 0.03)
-    return 1.0
+    return 1.0

{forgexa_cli-1.47.2 → forgexa_cli-1.47.4}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.47.2
+Version: 1.47.4
 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
@@ -132,10 +132,16 @@ forgexa upgrade --target-version 1.12.3
 
 The command detects how `forgexa-cli` was installed:
 
-- `pipx` install: uses `pipx upgrade forgexa-cli`, or `pipx install --force forgexa-cli==<version>` for a pinned version
-- `pip` install: uses `python -m pip install --upgrade forgexa-cli`
+- `pipx` install: uses `pipx upgrade --index-url https://pypi.org/simple forgexa-cli`, or `pipx install --force --index-url https://pypi.org/simple forgexa-cli==<version>` for a pinned version
+- `pip` install: uses `python -m pip install --upgrade --index-url https://pypi.org/simple forgexa-cli`
 - non-editable local path install (`pip install /path/to/cli`): follows the same `pip` upgrade path and switches to the published PyPI release
 
+Self-upgrades pass `--index-url https://pypi.org/simple` to pip or pipx, matching the official PyPI release check and avoiding a configured mirror that has not yet synchronized a new release. A direct `pip install --upgrade forgexa-cli` command always follows that Python environment's pip configuration. When its mirror is behind, upgrade manually with:
+
+```bash
+python -m pip install --upgrade --index-url https://pypi.org/simple forgexa-cli==1.12.3
+```
+
 For safety, `forgexa upgrade` stops any running local daemon before upgrading. If the daemon was previously started in background mode, the CLI starts it again automatically after a successful upgrade; otherwise it prints a manual restart hint.
 
 `forgexa upgrade` supports standard PyPI / pipx installs and non-editable local path installs. Editable installs, VCS installs, and other direct URL installs are rejected with a manual upgrade hint.

{forgexa_cli-1.47.2 → forgexa_cli-1.47.4}/pyproject.toml

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

{forgexa_cli-1.47.2 → forgexa_cli-1.47.4}/tests/test_auth_and_runtime_commands.py

@@ -575,7 +575,13 @@ def test_build_upgrade_plan_for_pipx_latest(monkeypatch: pytest.MonkeyPatch) ->
     plan = main._build_upgrade_plan(None)
 
     assert plan.installer == "pipx"
-    assert plan.command == ["/usr/local/bin/pipx", "upgrade", "forgexa-cli"]
+    assert plan.command == [
+        "/usr/local/bin/pipx",
+        "upgrade",
+        "--index-url",
+        "https://pypi.org/simple",
+        "forgexa-cli",
+    ]
 
 
 def test_build_upgrade_plan_for_pipx_pinned_version(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -589,7 +595,14 @@ def test_build_upgrade_plan_for_pipx_pinned_version(monkeypatch: pytest.MonkeyPa
     plan = main._build_upgrade_plan("1.12.3")
 
     assert plan.installer == "pipx"
-    assert plan.command == ["/usr/local/bin/pipx", "install", "--force", "forgexa-cli==1.12.3"]
+    assert plan.command == [
+        "/usr/local/bin/pipx",
+        "install",
+        "--force",
+        "--index-url",
+        "https://pypi.org/simple",
+        "forgexa-cli==1.12.3",
+    ]
 
 
 def test_build_upgrade_plan_for_pip_user_site(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -613,6 +626,8 @@ def test_build_upgrade_plan_for_pip_user_site(monkeypatch: pytest.MonkeyPatch) -
         "pip",
         "install",
         "--upgrade",
+        "--index-url",
+        "https://pypi.org/simple",
         "--user",
         "forgexa-cli==1.12.3",
     ]
@@ -634,6 +649,8 @@ def test_build_upgrade_plan_adds_break_system_packages_on_pep668(monkeypatch: py
 
     assert "--break-system-packages" in plan.command
     assert "--user" in plan.command
+    assert "--index-url" in plan.command
+    assert plan.command[plan.command.index("--index-url") + 1] == "https://pypi.org/simple"
     assert plan.command[-1] == "forgexa-cli"
 
 
@@ -666,6 +683,8 @@ def test_build_upgrade_plan_allows_non_editable_local_path_installs(monkeypatch:
         "pip",
         "install",
         "--upgrade",
+        "--index-url",
+        "https://pypi.org/simple",
         "--user",
         "--break-system-packages",
         "forgexa-cli",
@@ -730,6 +749,66 @@ def test_cmd_upgrade_runs_planned_command(monkeypatch: pytest.MonkeyPatch) -> No
     assert "Upgrade complete. Installed version: 1.12.3" in output
 
 
+def test_cmd_upgrade_resolves_latest_to_an_explicit_pypi_version(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    plan = main.UpgradePlan(
+        installer="pipx",
+        command=["pipx", "install", "--force", "forgexa-cli==1.12.3"],
+        current_version="1.12.2",
+        target_version="1.12.3",
+    )
+    calls: list[list[str]] = []
+
+    def build_upgrade_plan(target_version: str | None) -> main.UpgradePlan:
+        assert target_version == "1.12.3"
+        return plan
+
+    monkeypatch.setattr(main, "_latest_published_cli_version", lambda: "1.12.3")
+    monkeypatch.setattr(main, "_build_upgrade_plan", build_upgrade_plan)
+    monkeypatch.setattr(main, "_stop_daemon_if_running", lambda: (False, None))
+    monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.12.3")
+    monkeypatch.setattr(main, "_start_daemon_after_upgrade", lambda: (False, None))
+    monkeypatch.setattr(
+        main.subprocess,
+        "run",
+        lambda command: calls.append(command) or SimpleNamespace(returncode=0),
+    )
+
+    buffer = io.StringIO()
+    with contextlib.redirect_stdout(buffer):
+        main.cmd_upgrade(SimpleNamespace(target_version=None))
+
+    assert calls == [["pipx", "install", "--force", "forgexa-cli==1.12.3"]]
+    assert "Target version  : 1.12.3" in buffer.getvalue()
+
+
+def test_cmd_upgrade_rejects_success_when_target_version_is_not_installed(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    plan = main.UpgradePlan(
+        installer="pipx",
+        command=["pipx", "install", "--force", "forgexa-cli==1.12.3"],
+        current_version="1.12.2",
+        target_version="1.12.3",
+    )
+    restart_calls: list[bool] = []
+
+    monkeypatch.setattr(main, "_build_upgrade_plan", lambda target: plan)
+    monkeypatch.setattr(main, "_normalize_target_version", lambda value: value)
+    monkeypatch.setattr(main, "_stop_daemon_if_running", lambda: (True, 4242))
+    monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.12.2")
+    monkeypatch.setattr(main, "_start_daemon_after_upgrade", lambda: restart_calls.append(True))
+    monkeypatch.setattr(main.subprocess, "run", lambda command: SimpleNamespace(returncode=0))
+
+    with pytest.raises(SystemExit, match="1"):
+        main.cmd_upgrade(SimpleNamespace(target_version="1.12.3"))
+
+    assert restart_calls == []
+    assert "did not install the requested version 1.12.3" in capsys.readouterr().err
+
+
 def test_cmd_upgrade_defers_windows_install_until_cli_exits(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -812,6 +891,7 @@ def test_windows_upgrade_worker_waits_before_running_pip(
         "run",
         lambda command, **kwargs: events.append("run") or SimpleNamespace(returncode=0),
     )
+    monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.12.3")
 
     main._run_windows_upgrade_worker(
         json.dumps(
@@ -838,6 +918,7 @@ def test_windows_upgrade_worker_restarts_stopped_daemon_after_success(
     monkeypatch.setattr(main, "_upgrade_log_path", lambda: log_path)
     monkeypatch.setattr(main, "_wait_for_windows_upgrade_release", lambda *args: True)
     monkeypatch.setattr(main.subprocess, "run", lambda *args, **kwargs: SimpleNamespace(returncode=0))
+    monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.12.3")
     monkeypatch.setattr(
         main,
         "_start_daemon_after_upgrade",
@@ -860,6 +941,38 @@ def test_windows_upgrade_worker_restarts_stopped_daemon_after_success(
     assert "Daemon restarted in background (server=https://api.example.com)." in log_path.read_text()
 
 
+def test_windows_upgrade_worker_does_not_restart_when_version_is_not_installed(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    log_path = tmp_path / "upgrade.log"
+    restart_calls: list[bool] = []
+    monkeypatch.setattr(main, "_upgrade_log_path", lambda: log_path)
+    monkeypatch.setattr(main, "_wait_for_windows_upgrade_release", lambda *args: True)
+    monkeypatch.setattr(main.subprocess, "run", lambda *args, **kwargs: SimpleNamespace(returncode=0))
+    monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.12.2")
+    monkeypatch.setattr(
+        main,
+        "_start_daemon_after_upgrade",
+        lambda: restart_calls.append(True) or (True, "https://api.example.com"),
+    )
+
+    main._run_windows_upgrade_worker(
+        json.dumps(
+            {
+                "command": ["python", "-m", "pip", "install", "--upgrade", "forgexa-cli"],
+                "parent_pid": 4242,
+                "launcher_paths": [],
+                "daemon_stopped": True,
+                "target_version": "1.12.3",
+            }
+        )
+    )
+
+    assert restart_calls == []
+    assert "Upgrade failed: expected 1.12.3, installed 1.12.2." in log_path.read_text()
+
+
 def test_cmd_upgrade_restarts_background_daemon_after_success(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -873,6 +986,7 @@ def test_cmd_upgrade_restarts_background_daemon_after_success(
 
     monkeypatch.setattr(main, "_build_upgrade_plan", lambda target: plan)
     monkeypatch.setattr(main, "_normalize_target_version", lambda value: value)
+    monkeypatch.setattr(main, "_latest_published_cli_version", lambda: "1.16.4")
     monkeypatch.setattr(main, "_stop_daemon_if_running", lambda: (True, 4242))
     monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.16.4")
     monkeypatch.setattr(main.subprocess, "run", lambda cmd: SimpleNamespace(returncode=0))
@@ -905,6 +1019,7 @@ def test_cmd_upgrade_keeps_manual_restart_hint_when_auto_restart_skips(
 
     monkeypatch.setattr(main, "_build_upgrade_plan", lambda target: plan)
     monkeypatch.setattr(main, "_normalize_target_version", lambda value: value)
+    monkeypatch.setattr(main, "_latest_published_cli_version", lambda: "1.16.4")
     monkeypatch.setattr(main, "_stop_daemon_if_running", lambda: (True, 4242))
     monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.16.4")
     monkeypatch.setattr(main.subprocess, "run", lambda cmd: SimpleNamespace(returncode=0))