forgexa-cli 1.75.2__tar.gz → 1.76.1__tar.gz

{forgexa_cli-1.75.2 → forgexa_cli-1.76.1}/PKG-INFO

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

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

{forgexa_cli-1.75.2 → forgexa_cli-1.76.1}/forgexa_cli/agent_core.py

@@ -55,7 +55,7 @@ import tempfile
 import time
 from contextlib import contextmanager
 from dataclasses import dataclass, field
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import Any
 
 # fcntl is Unix-only; on Windows we use msvcrt instead (see acquire_file_lock)
@@ -67,6 +67,42 @@ except ImportError:
 logger = logging.getLogger("agent_core")
 
 
+def missing_planned_task_files(task_input: dict, changed_files: list[str]) -> list[str]:
+    """Find planned files without delivery evidence, including grouped sub-tasks."""
+    def normalize_path(value: object) -> str | None:
+        if not isinstance(value, str) or not value.strip():
+            return None
+        path = PurePosixPath(value.strip().replace("\\", "/"))
+        if path.is_absolute() or ".." in path.parts or not path.parts:
+            return None
+        return path.as_posix()
+
+    file_lists = [task_input.get("files")]
+    for item in task_input.get("items") or []:
+        if isinstance(item, dict):
+            file_lists.append(item.get("files"))
+            item_input = item.get("input")
+            if isinstance(item_input, dict):
+                file_lists.append(item_input.get("files"))
+    planned_paths = {
+        ((normalize_path(path) or path).rstrip("/") + "/")
+        if path.endswith("/") else (normalize_path(path) or path)
+        for paths in file_lists if isinstance(paths, list)
+        for path in paths if isinstance(path, str) and path.strip()
+    }
+    changed_paths = {
+        normalized for path in changed_files
+        if (normalized := normalize_path(path)) is not None
+    }
+    return sorted(
+        path for path in planned_paths
+        if not any(
+            changed == path or (path.endswith("/") and changed.startswith(path))
+            for changed in changed_paths
+        )
+    )
+
+
 _WORKSPACE_INSTRUCTION_PATHS = (
     "AGENTS.md",
     "CLAUDE.md",
@@ -1324,17 +1360,21 @@ def _kill_proc(proc: asyncio.subprocess.Process) -> None:
     Owned agents start a new session, so their PID remains the process-group
     ID even after the leader exits.
     """
+    process_id = getattr(proc, "pid", None)
+    if type(process_id) is not int or process_id <= 1:
+        return
+
     try:
         if sys.platform != "win32":
             import signal as _signal
             try:
-                os.killpg(proc.pid, _signal.SIGKILL)
+                os.killpg(process_id, _signal.SIGKILL)
             except (ProcessLookupError, PermissionError, OSError):
                 pass
         else:
             import subprocess as _subprocess
             _subprocess.run(
-                ["taskkill", "/F", "/T", "/PID", str(proc.pid)],
+                ["taskkill", "/F", "/T", "/PID", str(process_id)],
                 capture_output=True,
                 timeout=5,
                 **_agent_process_group_kwargs(),

{forgexa_cli-1.75.2 → forgexa_cli-1.76.1}/forgexa_cli/daemon.py

@@ -1234,7 +1234,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.75.2"
+DAEMON_VERSION = "1.76.1"
 
 
 def _detect_client_type() -> str:
@@ -6329,6 +6329,18 @@ class ProcessManager:
             return "unavailable"
         return "unable to run"
 
+    @staticmethod
+    def format_all_agents_failure(
+        failure_kinds: list[str], attempts: list[tuple[str, str]],
+    ) -> str:
+        label = ProcessManager.all_agents_failure_label(failure_kinds)
+        agent_order = ", ".join(agent_id for agent_id, _error in attempts)
+        details = "\n".join(
+            f"[{agent_id}] {error or 'Agent failed without an error message'}"
+            for agent_id, error in attempts
+        )
+        return f"All agents {label} (tried: {agent_order}). Agent failures:\n{details}"
+
     @staticmethod
     def is_idle_timeout_without_work(result: "TaskResult") -> bool:
         """Return whether an idle-killed agent left no work worth preserving.
@@ -7953,6 +7965,7 @@ class ProcessManager:
         disable_builtin_mcps: bool = False,
         _retry_without_effort: bool = False,
         _retry_without_token_env: bool = False,
+        _retry_model_discovery_timeout: bool = False,
         _isolated_copilot_home: str | None = None,
         _auth_state: dict[str, bool] | None = None,
     ) -> TaskResult:
@@ -8219,12 +8232,40 @@ class ProcessManager:
                     disable_builtin_mcps=True,
                     _retry_without_effort=_retry_without_effort,
                     _retry_without_token_env=_retry_without_token_env,
+                    _retry_model_discovery_timeout=_retry_model_discovery_timeout,
                     _isolated_copilot_home=_isolated_copilot_home,
                     _auth_state=_auth_state,
                 )
                 retry_result.metrics["copilot_builtin_mcp_fallback"] = True
                 return retry_result
 
+            model_discovery_detail = "\n".join([*structured_errors, stderr]).lower()
+            if (
+                "could not retrieve the list of available models" in model_discovery_detail
+                and "timed out" in model_discovery_detail
+                and not _retry_model_discovery_timeout
+                and not (copilot_exit == 0 and returncode == 0)
+                and not signals["has_meaningful_content"]
+                and not self._copilot_called_any_tools(stdout)
+            ):
+                logger.warning(
+                    "Copilot model discovery timed out before work for task %s; "
+                    "retrying once with the same credentials and configuration",
+                    task_id,
+                )
+                retry_result = 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=_retry_without_effort,
+                    _retry_without_token_env=_retry_without_token_env,
+                    _retry_model_discovery_timeout=True,
+                    _isolated_copilot_home=_isolated_copilot_home,
+                    _auth_state=_auth_state,
+                )
+                retry_result.metrics["copilot_model_discovery_timeout_recovery"] = True
+                return retry_result
+
             model_discovery_error = agent_core.is_copilot_model_discovery_auth_error(
                 *structured_errors,
                 stderr,
@@ -8264,6 +8305,7 @@ class ProcessManager:
                         disable_builtin_mcps=disable_builtin_mcps,
                         _retry_without_effort=_retry_without_effort,
                         _retry_without_token_env=True,
+                        _retry_model_discovery_timeout=_retry_model_discovery_timeout,
                         _isolated_copilot_home=_isolated_copilot_home,
                         _auth_state=_auth_state,
                     )
@@ -8316,6 +8358,7 @@ class ProcessManager:
                         disable_builtin_mcps=disable_builtin_mcps,
                         _retry_without_effort=_retry_without_effort,
                         _retry_without_token_env=True,
+                        _retry_model_discovery_timeout=_retry_model_discovery_timeout,
                         _isolated_copilot_home=_isolated_copilot_home,
                         _auth_state=_auth_state,
                     )
@@ -8381,6 +8424,7 @@ class ProcessManager:
                         disable_builtin_mcps=disable_builtin_mcps,
                         _retry_without_effort=True,
                         _retry_without_token_env=_retry_without_token_env,
+                        _retry_model_discovery_timeout=_retry_model_discovery_timeout,
                         _isolated_copilot_home=_isolated_copilot_home,
                         _auth_state=_auth_state,
                     )
@@ -12877,6 +12921,7 @@ class RuntimeDaemon:
                 else "timed out"
             )
             fallback_failure_kinds = [agent_failure_kind or fallback_reason] if fallback_reason else []
+            fallback_attempt_errors = [(agent.agent_id, result.error)] if fallback_reason else []
             _skip_fallback = False
             if fallback_reason:
                 _pre_fallback_git = await self.process_manager._collect_git_info(workspace_path)
@@ -12949,6 +12994,7 @@ class RuntimeDaemon:
                         result = await self.process_manager.run_agent(
                             agent, task, workspace_path, on_chunk=on_output_chunk,
                         )
+                        fallback_attempt_errors.append((agent.agent_id, result.error))
                     finally:
                         progress_stop2.set()
                         ticker2.cancel()
@@ -12989,12 +13035,8 @@ class RuntimeDaemon:
                     )
 
                 if ProcessManager.is_agent_fallback_eligible(result):
-                    failure_label = ProcessManager.all_agents_failure_label(
-                        fallback_failure_kinds,
-                    )
-                    result.error = (
-                        f"All agents {failure_label} (tried: {', '.join(tried_agents)}). "
-                        f"Original error: {result.error}"
+                    result.error = ProcessManager.format_all_agents_failure(
+                        fallback_failure_kinds, fallback_attempt_errors,
                     )
                     result.status = "failed"
                     result.failure_code = ProcessManager.all_agents_failure_code(
@@ -13139,6 +13181,9 @@ class RuntimeDaemon:
             post_validation_failure_kinds = (
                 [post_validation_failure_kind] if post_validation_failure_kind else []
             )
+            post_validation_attempt_errors = (
+                [(agent.agent_id, result.error)] if post_validation_failure_kind else []
+            )
             post_validation_failure_label = (
                 "rate-limited"
                 if post_validation_failure_kind == "rate_limit"
@@ -13172,6 +13217,7 @@ class RuntimeDaemon:
                     result = await self.process_manager.run_agent(
                         agent, task, workspace_path, on_chunk=on_output_chunk,
                     )
+                    post_validation_attempt_errors.append((agent.agent_id, result.error))
                     fallback_failure_kind = ProcessManager.agent_failure_kind(result)
                     if fallback_failure_kind:
                         post_validation_failure_kinds.append(fallback_failure_kind)
@@ -13207,12 +13253,8 @@ 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 ProcessManager.is_agent_fallback_eligible(result):
-                    failure_label = ProcessManager.all_agents_failure_label(
-                        post_validation_failure_kinds,
-                    )
-                    result.error = (
-                        f"All agents {failure_label} (tried: {', '.join(tried_agents)}). "
-                        f"Original error: {result.error}"
+                    result.error = ProcessManager.format_all_agents_failure(
+                        post_validation_failure_kinds, post_validation_attempt_errors,
                     )
                     result.status = "failed"
                     result.failure_code = ProcessManager.all_agents_failure_code(
@@ -13810,6 +13852,16 @@ class RuntimeDaemon:
         req_type = input_data.get("requirement_type", "feature")
         verification_work_item = bool(input_data.get("verification_work_item"))
 
+        if node_type == "coding":
+            delivered_files = list(result.files_changed)
+            delivered_files.extend(input_data.get("planned_task_predecessor_files") or [])
+            for missing_path in agent_core.missing_planned_task_files(input_data, delivered_files):
+                issues.append(
+                    f"Planned task file has no implementation evidence: {missing_path}. "
+                    "Complete the planned change or report the task as blocked; "
+                    "documentation-only changes do not complete a source-code task."
+                )
+
         qa_policy, qa_policy_issues = _parse_frozen_qa_test_level_policy(
             input_data.get("qa_test_level_policy_snapshot")
         )
@@ -14284,11 +14336,36 @@ class RuntimeDaemon:
                                 else:
                                     result.metrics["acceptance_criteria_manual_review_required"] = True
                             else:
-                                ac_list = cm_data.get("acceptance_criteria", [])
-                                uncovered = [ac for ac in ac_list if ac.get("status") != "covered"]
-                                if uncovered:
-                                    ids = ", ".join(ac.get("id", "?") for ac in uncovered[:5])
-                                    issues.append(f"Uncovered acceptance criteria in coverage-matrix.json: {ids}")
+                                ac_list = (
+                                    cm_data.get("acceptance_criteria")
+                                    if isinstance(cm_data, dict) else None
+                                )
+                                if (
+                                    not isinstance(ac_list, list)
+                                    or not ac_list
+                                    or any(
+                                        not isinstance(ac, dict)
+                                        or not isinstance(ac.get("id"), str)
+                                        or not ac["id"].strip()
+                                        or ac.get("status") not in (
+                                            "covered", "partial", "uncovered", "unverifiable",
+                                            "not_applicable", "blocked",
+                                        )
+                                        for ac in ac_list
+                                    )
+                                ):
+                                    issues.append(
+                                        "coverage-matrix.json has invalid acceptance criteria: "
+                                        "coverage_matrix_invalid"
+                                    )
+                                else:
+                                    uncovered = [ac for ac in ac_list if ac["status"] != "covered"]
+                                    if uncovered:
+                                        ids = ", ".join(ac["id"] for ac in uncovered[:5])
+                                        issues.append(
+                                            "Uncovered acceptance criteria in "
+                                            f"coverage-matrix.json: {ids}"
+                                        )
                         except (_json.JSONDecodeError, UnicodeDecodeError) as e:
                             issues.append(f"coverage-matrix.json is not valid JSON: {e}")
                     elif _requires_structured_artifacts or _requires_e2e_artifacts:
@@ -15732,7 +15809,6 @@ class RuntimeDaemon:
 
             if (
                 task.node_type == "testing"
-                and (task.input_data or {}).get("requirement_type") == "task"
                 and all(
                     issue.startswith("Uncovered acceptance criteria in coverage-matrix.json:")
                     for issue in issues
@@ -15740,7 +15816,11 @@ class RuntimeDaemon:
             ):
                 result.status = "failed"
                 result.failure_code = "acceptance_criteria_uncovered"
-                result.error = f"Task verification is incomplete: {issues[0]}"
+                result.error = (
+                    f"Acceptance verification is incomplete: {issues[0]}. "
+                    "Resolve the unmet criteria or missing test prerequisites, "
+                    "then rerun verification."
+                )
                 result.metrics["validation_issues"] = issues
                 self._record_testing_telemetry(
                     workspace_path, task, result, retries_used=attempt
@@ -15850,7 +15930,6 @@ class RuntimeDaemon:
                 ])
             if (
                 task.node_type == "testing"
-                and (task.input_data or {}).get("requirement_type") == "task"
                 and all(
                     issue.startswith("Uncovered acceptance criteria in coverage-matrix.json:")
                     for issue in remaining
@@ -15858,7 +15937,11 @@ class RuntimeDaemon:
             ):
                 result.status = "failed"
                 result.failure_code = "acceptance_criteria_uncovered"
-                result.error = f"Task verification is incomplete: {remaining[0]}"
+                result.error = (
+                    f"Acceptance verification is incomplete: {remaining[0]}. "
+                    "Resolve the unmet criteria or missing test prerequisites, "
+                    "then rerun verification."
+                )
                 result.metrics["validation_issues"] = remaining
                 self._record_testing_telemetry(
                     workspace_path, task, result, retries_used=max_retries

{forgexa_cli-1.75.2 → forgexa_cli-1.76.1}/forgexa_cli.egg-info/PKG-INFO

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

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