forgexa-cli 1.41.4__tar.gz → 1.42.0__tar.gz

{forgexa_cli-1.41.4 → forgexa_cli-1.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.41.4
+Version: 1.42.0
 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.41.4 → forgexa_cli-1.42.0}/forgexa_cli/__init__.py

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

{forgexa_cli-1.41.4 → forgexa_cli-1.42.0}/forgexa_cli/daemon.py

@@ -910,7 +910,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.41.4"
+DAEMON_VERSION = "1.42.0"
 
 
 def _detect_client_type() -> str:
@@ -1234,8 +1234,9 @@ class TaskResult:
     error: str = ""
     # failure_code is forwarded to the server to drive retry policy.
     # Key values:
-    #   "all_agents_rate_limited" — daemon tried every installed agent, all
-    #       hit rate/quota limits.  Server must NOT retry on the same runtime.
+    #   "all_agents_rate_limited" / "all_agents_unavailable" — daemon tried
+    #       every installed agent and none can currently run. Server must NOT
+    #       retry on the same runtime.
     #   "validation_retry_exhausted" — required-output validation still failed
     #       after the allowed repair agents.  Server must not auto-retry it.
     failure_code: str = ""
@@ -4728,6 +4729,7 @@ class ProcessManager:
         "rate limit",
         "rate_limit",
         "quota exceeded",
+        "quota exhausted",
         "monthly quota",        # Copilot: "You have exceeded your monthly quota"
         "too many requests",
         "overloaded",
@@ -4749,6 +4751,8 @@ class ProcessManager:
         "name or service not known",
         "no such host",
         "network is unreachable",
+        "oauth/access_token",
+        "error during sign-in",
         "websockettransporterror",
         "websocket receive failed",
         "421 misdirected request",
@@ -4881,25 +4885,43 @@ class ProcessManager:
         """Implementation lives in agent_core._copilot_called_any_tools."""
         return _copilot_called_any_tools(stdout)
 
+    @staticmethod
+    def agent_failure_kind(result: "TaskResult") -> str | None:
+        """Classify a fallback-eligible failure without conflating its cause."""
+        if result.failure_code in {"all_agents_rate_limited", "all_agents_unavailable"}:
+            return None
+        error_text = ProcessManager._failure_pattern_channels(result).lower()
+        if any(p in error_text for p in ProcessManager.RATE_LIMIT_PATTERNS):
+            return "rate_limit"
+        if any(p in error_text for p in ProcessManager.AGENT_UNAVAILABLE_PATTERNS):
+            return "agent_unavailable"
+        return None
+
     @staticmethod
     def is_rate_limited(result: "TaskResult") -> bool:
-        """Check if an agent failure warrants trying a different agent.
+        """Return whether an agent actually hit a rate or usage limit."""
+        return ProcessManager.agent_failure_kind(result) == "rate_limit"
 
-        Returns True for rate/quota limits AND API unavailability errors,
-        since a different agent (using a different API backend) may succeed.
+    @staticmethod
+    def is_agent_fallback_eligible(result: "TaskResult") -> bool:
+        """Return whether another agent may recover this agent-side failure."""
+        return ProcessManager.agent_failure_kind(result) is not None
 
-        For true success cases we still avoid scanning arbitrary stdout.
-        The one safe exception is a tiny stdout payload with no assistant/result
-        signals, which strongly indicates a pre-call CLI failure printed as
-        plain text (for example "API Error: 429 ...").
-        """
-        if result.failure_code == "all_agents_rate_limited":
-            return False
-        error_text = ProcessManager._failure_pattern_channels(result).lower()
-        return (
-            any(p in error_text for p in ProcessManager.RATE_LIMIT_PATTERNS)
-            or any(p in error_text for p in ProcessManager.AGENT_UNAVAILABLE_PATTERNS)
-        )
+    @staticmethod
+    def all_agents_failure_code(failure_kinds: list[str]) -> str:
+        """Return the terminal code for exhausted fallback-eligible agents."""
+        if failure_kinds and all(kind == "rate_limit" for kind in failure_kinds):
+            return "all_agents_rate_limited"
+        return "all_agents_unavailable"
+
+    @staticmethod
+    def all_agents_failure_label(failure_kinds: list[str]) -> str:
+        """Return an accurate human-readable summary for exhausted agents."""
+        if failure_kinds and all(kind == "rate_limit" for kind in failure_kinds):
+            return "rate-limited"
+        if failure_kinds and all(kind == "agent_unavailable" for kind in failure_kinds):
+            return "unavailable"
+        return "unable to run"
 
     @staticmethod
     def is_silent_idle_timeout(result: "TaskResult") -> bool:
@@ -5654,6 +5676,22 @@ class ProcessManager:
         result.metrics.update(parsed_metrics)
         return result
 
+    @staticmethod
+    def _opencode_suggested_model(output: str) -> str | None:
+        """Extract OpenCode's first replacement model from a missing-model error."""
+        match = re.search(
+            r"model not found\s*:\s*(.+?)(?:[.?!]\s+|\s+)did you mean:\s*"
+            r"([A-Za-z0-9][A-Za-z0-9._:/-]*)",
+            output or "",
+            re.IGNORECASE,
+        )
+        if not match:
+            return None
+        missing_model, suggested_model = match.groups()
+        if missing_model.strip().lower() == suggested_model.lower():
+            return None
+        return suggested_model
+
     async def _run_opencode(
         self, agent: DiscoveredAgent, prompt: str, cwd: Path, timeout: int, task_id: str,
         on_chunk: Any = None,
@@ -5678,7 +5716,7 @@ class ProcessManager:
         No need to re-check it here.
         """
         # Apply model override if configured (e.g. FACTORY_OPENCODE_MODEL=copilot/gpt-4.1)
-        model_override = os.environ.get("FACTORY_OPENCODE_MODEL")
+        model_override = os.environ.get("FACTORY_OPENCODE_MODEL", "").strip() or None
         # Isolate each opencode run in its own data directory to prevent
         # concurrent processes from racing on the shared SQLite WAL file.
         tmp_data_root = tempfile.mkdtemp(prefix=f"opencode-{task_id[:8]}-")
@@ -5702,23 +5740,43 @@ class ProcessManager:
             output = "\n".join(
                 part for part in (result.stdout, result.stderr, result.error) if part
             ).lower()
-            if model_override and "model not found" in output and model_override.lower() in output:
+            suggested_model = self._opencode_suggested_model(output)
+            retry_model: str | None = None
+            recovery_metric = ""
+            if (
+                result.status == "failed"
+                and model_override
+                and "model not found" in output
+                and model_override.lower() in output
+            ):
+                recovery_metric = "opencode_model_override_fallback"
                 logger.warning(
                     "OpenCode model override %r is unavailable for task %s; retrying without it",
                     model_override,
                     task_id,
                 )
+            elif result.status == "failed" and suggested_model:
+                retry_model = suggested_model
+                recovery_metric = "opencode_default_model_fallback"
+                logger.warning(
+                    "OpenCode configured model is unavailable for task %s; retrying with %r",
+                    task_id,
+                    suggested_model,
+                )
+
+            if recovery_metric:
                 retry_env = dict(env)
                 retry_env.pop("FACTORY_OPENCODE_MODEL", None)
                 cmd = agent_core.build_opencode_command(
                     agent.command,
                     cwd=cwd,
+                    model=retry_model,
                     prompt_file=prompt_file,
                 )
                 result = await self._run_cli(
                     cmd, cwd, timeout, task_id, on_chunk=on_chunk, env=retry_env,
                 )
-                result.metrics["opencode_model_override_fallback"] = True
+                result.metrics[recovery_metric] = True
         finally:
             shutil.rmtree(tmp_data_root, ignore_errors=True)
 
@@ -5882,6 +5940,27 @@ class ProcessManager:
         """Implementation lives in agent_core.prepare_copilot_home."""
         return agent_core.prepare_copilot_home()
 
+    @staticmethod
+    def _copilot_builtin_mcp_failure(stdout: str) -> str | None:
+        """Return a startup failure from Copilot's built-in GitHub MCP server."""
+        for line in (stdout or "").splitlines():
+            try:
+                event = json.loads(line)
+            except (TypeError, ValueError):
+                continue
+            if not isinstance(event, dict):
+                continue
+            if event.get("type") != "session.mcp_server_status_changed":
+                continue
+            data = event.get("data") or {}
+            if not isinstance(data, dict):
+                continue
+            if data.get("serverName") != "github-mcp-server" or data.get("status") != "failed":
+                continue
+            message = data.get("error") or data.get("message") or ""
+            return str(message).strip() or "GitHub MCP server failed to initialize"
+        return None
+
     async def _run_copilot(
         self, agent: DiscoveredAgent, prompt: str, cwd: Path, timeout: int, task_id: str,
         on_chunk: Any = None,
@@ -6097,6 +6176,36 @@ class ProcessManager:
                     break
             effective_rc = copilot_exit if copilot_exit is not None else returncode
 
+            builtin_mcp_error = (
+                self._copilot_builtin_mcp_failure(stdout)
+                if not disable_builtin_mcps
+                else None
+            )
+            if (
+                builtin_mcp_error
+                and not signals["has_meaningful_content"]
+                and not self._copilot_called_any_tools(stdout)
+            ):
+                logger.warning(
+                    "Copilot built-in GitHub MCP failed before work for task %s; "
+                    "retrying with built-in MCPs disabled: %s",
+                    task_id,
+                    builtin_mcp_error[:300],
+                )
+                retry_result = await self._run_copilot(
+                    agent,
+                    prompt,
+                    cwd,
+                    timeout,
+                    task_id,
+                    on_chunk,
+                    disable_builtin_mcps=True,
+                    _retry_without_effort=_retry_without_effort,
+                    _isolated_copilot_home=_isolated_copilot_home,
+                )
+                retry_result.metrics["copilot_builtin_mcp_fallback"] = True
+                return retry_result
+
             if copilot_exit == 0 and returncode == 0:
                 return TaskResult(
                     status="success",
@@ -9111,15 +9220,24 @@ class RuntimeDaemon:
             # Guard: if the agent already produced file changes in the workspace, it DID
             # meaningful work — don't trigger fallback even if it crashed after completing.
             # Let the recovery logic (step 4.1) handle non-zero exit with committed work.
-            is_rate_limited = self.process_manager.is_rate_limited(result)
+            agent_failure_kind = ProcessManager.agent_failure_kind(result)
+            is_agent_fallback_eligible = agent_failure_kind is not None
             is_silent_idle_timeout = self.process_manager.is_silent_idle_timeout(result)
             fallback_reason = (
-                "rate_limit"
-                if is_rate_limited
+                agent_failure_kind
+                if is_agent_fallback_eligible
                 else "agent_idle_timeout"
                 if is_silent_idle_timeout
                 else ""
             )
+            fallback_label = (
+                "rate-limited"
+                if agent_failure_kind == "rate_limit"
+                else "unavailable"
+                if agent_failure_kind == "agent_unavailable"
+                else "timed out"
+            )
+            fallback_failure_kinds = [agent_failure_kind or fallback_reason] if fallback_reason else []
             _skip_fallback = False
             if fallback_reason:
                 _pre_fallback_git = await self.process_manager._collect_git_info(workspace_path)
@@ -9160,7 +9278,7 @@ class RuntimeDaemon:
                     await reporter.report_progress(
                         task.task_id, 10,
                         f"agent_fallback: retrying with {agent.agent_id}",
-                        output_lines=[f"[daemon] Agent {fallback_reason}, switching to {agent.agent_id}"],
+                        output_lines=[f"[daemon] Agent {fallback_label}, switching to {agent.agent_id}"],
                     )
 
                     # Re-run with fallback agent
@@ -9210,27 +9328,39 @@ class RuntimeDaemon:
                     # A silent hang gets exactly one alternate-agent attempt.
                     # Unlike quota failures, do not serially spend the full idle
                     # timeout on every installed CLI when the host is offline.
-                    if not self.process_manager.is_rate_limited(result):
+                    fallback_failure_kind = ProcessManager.agent_failure_kind(result)
+                    if fallback_failure_kind:
+                        fallback_failure_kinds.append(fallback_failure_kind)
+                        fallback_label = (
+                            "rate-limited"
+                            if fallback_failure_kind == "rate_limit"
+                            else "unavailable"
+                        )
+                    if not ProcessManager.is_agent_fallback_eligible(result):
                         break  # Success or non-retriable failure
 
                     logger.warning(
-                        "Fallback agent '%s' also unavailable/rate-limited for task %s",
-                        agent.agent_id, task.task_id,
+                        "Fallback agent '%s' also %s for task %s",
+                        agent.agent_id,
+                        "rate-limited" if fallback_failure_kind == "rate_limit" else "unavailable",
+                        task.task_id,
                     )
                     fallback_agent = self._select_fallback_agent(
                         agent.agent_id, task.fallback_chain, tried_agents
                     )
 
-                if self.process_manager.is_rate_limited(result):
+                if ProcessManager.is_agent_fallback_eligible(result):
+                    failure_label = ProcessManager.all_agents_failure_label(
+                        fallback_failure_kinds,
+                    )
                     result.error = (
-                        f"All agents unavailable/rate-limited (tried: {', '.join(tried_agents)}). "
+                        f"All agents {failure_label} (tried: {', '.join(tried_agents)}). "
                         f"Original error: {result.error}"
                     )
                     result.status = "failed"
-                    # Signal to the server that ALL installed agents were tried and
-                    # all are rate/quota limited.  The server must NOT re-enqueue on
-                    # the same runtime — that would hit the same quota wall.
-                    result.failure_code = "all_agents_rate_limited"
+                    result.failure_code = ProcessManager.all_agents_failure_code(
+                        fallback_failure_kinds,
+                    )
 
             # 4. Collect git info BEFORE commit (shows uncommitted changes)
             pre_commit_git = await self.process_manager._collect_git_info(workspace_path)
@@ -9360,11 +9490,20 @@ class RuntimeDaemon:
             # block (step 3) only checked the *initial* run; if that succeeded but
             # the agent became rate-limited during a validation retry, we need a
             # second fallback pass here so the task is attempted on a fresh agent.
-            if result.status == "failed" and self.process_manager.is_rate_limited(result) and not _skip_fallback:
+            post_validation_failure_kind = ProcessManager.agent_failure_kind(result)
+            post_validation_failure_kinds = (
+                [post_validation_failure_kind] if post_validation_failure_kind else []
+            )
+            post_validation_failure_label = (
+                "rate-limited"
+                if post_validation_failure_kind == "rate_limit"
+                else "unavailable"
+            )
+            if result.status == "failed" and post_validation_failure_kind and not _skip_fallback:
                 logger.warning(
-                    "Agent '%s' rate-limited during validation retry for task %s — "
+                    "Agent '%s' failed during validation retry for task %s (%s) — "
                     "attempting post-validation agent fallback",
-                    agent.agent_id, task.task_id,
+                    agent.agent_id, task.task_id, post_validation_failure_kind,
                 )
                 _pv_fallback = self._select_fallback_agent(
                     agent.agent_id, task.fallback_chain, tried_agents
@@ -9380,14 +9519,22 @@ class RuntimeDaemon:
                         task.task_id, 10,
                         f"agent_fallback: retrying with {agent.agent_id}",
                         output_lines=[
-                            f"[daemon] Agent rate-limited during validation, "
+                            f"[daemon] Agent {post_validation_failure_label} during validation, "
                             f"switching to {agent.agent_id}",
                         ],
                     )
                     result = await self.process_manager.run_agent(
                         agent, task, workspace_path, on_chunk=on_output_chunk,
                     )
-                    if not self.process_manager.is_rate_limited(result):
+                    fallback_failure_kind = ProcessManager.agent_failure_kind(result)
+                    if fallback_failure_kind:
+                        post_validation_failure_kinds.append(fallback_failure_kind)
+                        post_validation_failure_label = (
+                            "rate-limited"
+                            if fallback_failure_kind == "rate_limit"
+                            else "unavailable"
+                        )
+                    if not ProcessManager.is_agent_fallback_eligible(result):
                         # Fallback agent ran successfully (or hit a non-rate-limit
                         # failure) — re-run the validation gate and update git state.
                         if result.status == "success":
@@ -9413,13 +9560,18 @@ class RuntimeDaemon:
                     )
                 # If every agent we tried is still rate-limited, signal the server
                 # NOT to re-enqueue — it would hit the same quota wall immediately.
-                if self.process_manager.is_rate_limited(result):
+                if ProcessManager.is_agent_fallback_eligible(result):
+                    failure_label = ProcessManager.all_agents_failure_label(
+                        post_validation_failure_kinds,
+                    )
                     result.error = (
-                        f"All agents unavailable/rate-limited (tried: {', '.join(tried_agents)}). "
+                        f"All agents {failure_label} (tried: {', '.join(tried_agents)}). "
                         f"Original error: {result.error}"
                     )
                     result.status = "failed"
-                    result.failure_code = "all_agents_rate_limited"
+                    result.failure_code = ProcessManager.all_agents_failure_code(
+                        post_validation_failure_kinds,
+                    )
 
             # 4.55 Analysis/design/fix nodes must update their deliverables in THIS run.
             # Existing files from a prior iteration are not sufficient evidence.
@@ -10742,19 +10894,19 @@ class RuntimeDaemon:
                         cr_result = await self.process_manager.run_agent(
                             cr_agent, _cr_task, workspace_path,
                         )
-                        # Rate-limit fallback loop.
-                        while self.process_manager.is_rate_limited(cr_result):
+                        # Try an alternate agent after a recoverable agent-side failure.
+                        while ProcessManager.is_agent_fallback_eligible(cr_result):
                             _cr_fallback = self._select_fallback_agent(
                                 cr_agent.agent_id, fallback_chain, _cr_tried,
                             )
                             if not _cr_fallback:
                                 logger.warning(
-                                    "deployment_merge: all agents rate-limited for job %s",
+                                    "deployment_merge: all agents unavailable/rate-limited for job %s",
                                     job_id,
                                 )
                                 break
                             logger.warning(
-                                "deployment_merge: agent '%s' rate-limited, falling back to '%s'",
+                                "deployment_merge: agent '%s' unavailable/rate-limited, falling back to '%s'",
                                 cr_agent.agent_id, _cr_fallback.agent_id,
                             )
                             cr_agent = _cr_fallback
@@ -10763,7 +10915,7 @@ class RuntimeDaemon:
                             cr_result = await self.process_manager.run_agent(
                                 cr_agent, _cr_task, workspace_path,
                             )
-                        if not self.process_manager.is_rate_limited(cr_result):
+                        if not ProcessManager.is_agent_fallback_eligible(cr_result):
                             # Remember the last agent that actually ran to completion.
                             resolved_agent_id = cr_agent.agent_id
                     except Exception as exc:
@@ -11175,12 +11327,14 @@ class RuntimeDaemon:
                 agent_id: str,
                 task_result: TaskResult,
                 *,
-                rate_limited: bool,
+                agent_failure_kind: str | None,
             ) -> dict:
                 if task_result.status == "success":
                     outcome = "success"
-                elif rate_limited:
+                elif agent_failure_kind == "rate_limit":
                     outcome = "rate_limited"
+                elif agent_failure_kind == "agent_unavailable":
+                    outcome = "agent_unavailable"
                 elif task_result.failure_code == "agent_idle_timeout":
                     outcome = "timeout"
                 elif isinstance(task_result.exit_code, int) and task_result.exit_code != 0:
@@ -11196,37 +11350,48 @@ class RuntimeDaemon:
                     entry["detail"] = f"rc={task_result.exit_code}"
                 return entry
 
-            # 3.5 Agent fallback: if the chosen agent hit a rate/quota limit,
+            # 3.5 Agent fallback: if the chosen agent has a recoverable failure,
             # try the next available agent before giving up. An explicit
             # override is deliberately a single-agent attempt.
             fallback_scope = "override" if agent_override else "auto"
             allow_fallback = not bool(agent_override)
             generation_attempts: list[dict] = []
-            is_rate_limited = self.process_manager.is_rate_limited(result)
+            agent_failure_kind = ProcessManager.agent_failure_kind(result)
+            agent_failure_label = (
+                "rate-limited"
+                if agent_failure_kind == "rate_limit"
+                else "unavailable"
+            )
             generation_attempts.append(_generation_attempt(
                 agent.agent_id,
                 result,
-                rate_limited=is_rate_limited,
+                agent_failure_kind=agent_failure_kind,
             ))
+            generation_failure_kinds = [agent_failure_kind] if agent_failure_kind else []
             _aj_tried: set[str] = {agent.agent_id}
-            if is_rate_limited and not allow_fallback and not result.failure_code:
-                result.failure_code = "agent_rate_limited"
-            while is_rate_limited and allow_fallback:
+            if agent_failure_kind and not allow_fallback and not result.failure_code:
+                result.failure_code = (
+                    "agent_rate_limited"
+                    if agent_failure_kind == "rate_limit"
+                    else "agent_unavailable"
+                )
+            while agent_failure_kind and allow_fallback:
                 _aj_fallback = self._select_fallback_agent(agent.agent_id, [], _aj_tried)
                 if not _aj_fallback:
-                    # All agents exhausted — signal server not to re-enqueue.
-                    result.failure_code = "all_agents_rate_limited"
+                    result.failure_code = ProcessManager.all_agents_failure_code(
+                        generation_failure_kinds,
+                    )
                     break
                 logger.warning(
-                    "AIJob %s: agent '%s' rate-limited, falling back to '%s'",
-                    job_id, agent.agent_id, _aj_fallback.agent_id,
+                    "AIJob %s: agent '%s' failed (%s), falling back to '%s'",
+                    job_id, agent.agent_id, agent_failure_kind, _aj_fallback.agent_id,
                 )
                 await conn.client.post(
                     f"{reporter_url}/progress",
                     json={
                         "current_step": f"agent_fallback: retrying with {_aj_fallback.agent_id}",
                         "output_lines": [
-                            f"[daemon] Agent rate-limited, switching to {_aj_fallback.agent_id}",
+                            f"[daemon] Agent {agent_failure_label}, switching to {_aj_fallback.agent_id}",
                         ],
                         "progress_pct": 15,
                     },
@@ -11265,11 +11430,18 @@ class RuntimeDaemon:
                     except asyncio.CancelledError:
                         pass
                 await _flush_output_to_server()
-                is_rate_limited = self.process_manager.is_rate_limited(result)
+                agent_failure_kind = ProcessManager.agent_failure_kind(result)
+                if agent_failure_kind:
+                    generation_failure_kinds.append(agent_failure_kind)
+                    agent_failure_label = (
+                        "rate-limited"
+                        if agent_failure_kind == "rate_limit"
+                        else "unavailable"
+                    )
                 generation_attempts.append(_generation_attempt(
                     agent.agent_id,
                     result,
-                    rate_limited=is_rate_limited,
+                    agent_failure_kind=agent_failure_kind,
                 ))
 
             generation_attempt_count = len(generation_attempts)
@@ -11313,7 +11485,7 @@ class RuntimeDaemon:
                     max_content=max_content,
                 )
 
-            # Preserve all_agents_rate_limited so the server does NOT re-enqueue.
+            # Preserve all-agent terminal failures so the server does NOT re-enqueue.
             _failure_code = result.failure_code if result.failure_code else (
                 "agent_error" if result.status != "success" else ""
             )
@@ -11577,17 +11749,18 @@ class RuntimeDaemon:
             finally:
                 task.input_prompt = original_prompt
 
-            # If the agent hit a rate/quota limit during this validation retry,
+            # If the agent had a fallback-eligible failure during this validation retry,
             # bail out immediately so the outer execution loop can trigger agent
             # fallback.  Continuing to retry with the same rate-limited agent is
             # pointless; it will hit the same wall every time.
-            # Returning early also preserves the rate-limit error in result.error
-            # so that is_rate_limited() can detect it in the caller.
-            if ProcessManager.is_rate_limited(result):
+            # Returning early also preserves the failure in result.error so the
+            # outer execution loop can select an alternate agent.
+            if ProcessManager.is_agent_fallback_eligible(result):
                 logger.warning(
-                    "Agent '%s' rate-limited during validation retry for task %s "
+                    "Agent '%s' failed during validation retry for task %s (%s) "
                     "(attempt %d/%d) — aborting validation retries for agent fallback",
-                    agent.agent_id, task.task_id, attempt + 1, max_retries,
+                    agent.agent_id, task.task_id,
+                    ProcessManager.agent_failure_kind(result), attempt + 1, max_retries,
                 )
                 return result
 
@@ -13400,13 +13573,13 @@ class RuntimeDaemon:
                 workspace_path,
             )
 
-            # Agent fallback: if the primary agent is rate-limited, try others.
+            # Agent fallback: try another CLI after a recoverable agent-side failure.
             _cr_tried: set[str] = {agent.agent_id}
-            while self.process_manager.is_rate_limited(resolve_result):
+            while ProcessManager.is_agent_fallback_eligible(resolve_result):
                 _cr_fallback = self._select_fallback_agent(agent.agent_id, task.fallback_chain, _cr_tried)
                 if not _cr_fallback:
                     logger.warning(
-                        "All agents rate-limited for conflict resolution of task %s — aborting merge",
+                        "All agents unavailable/rate-limited for conflict resolution of task %s — aborting merge",
                         task.task_id,
                     )
                     try:
@@ -13415,7 +13588,7 @@ class RuntimeDaemon:
                         pass
                     return
                 logger.warning(
-                    "Conflict resolution: agent '%s' rate-limited for task %s, "
+                    "Conflict resolution: agent '%s' unavailable/rate-limited for task %s, "
                     "falling back to '%s'",
                     agent.agent_id, task.task_id, _cr_fallback.agent_id,
                 )

{forgexa_cli-1.41.4 → forgexa_cli-1.42.0}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.41.4
+Version: 1.42.0
 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.41.4 → forgexa_cli-1.42.0}/pyproject.toml

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