forgexa-cli 1.85.1__tar.gz → 1.85.2__tar.gz

{forgexa_cli-1.85.1 → forgexa_cli-1.85.2}/PKG-INFO

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

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

{forgexa_cli-1.85.1 → forgexa_cli-1.85.2}/forgexa_cli/agent_core.py

@@ -68,6 +68,11 @@ except ImportError:
 logger = logging.getLogger("agent_core")
 
 IMPLEMENTATION_AUDIT_PROTOCOL_VERSION = 3
+IMPLEMENTATION_ENVIRONMENT_BLOCKERS = frozenset({
+    "environment_unavailable", "service_not_running", "dependency_unavailable",
+    "permission_required", "test_data_unavailable", "target_mismatch",
+})
+TASK_FAILURE_DOMAINS = frozenset({"code_quality", "execution", "environment", "evidence", "delivery", "plan", "verification"})
 LOCAL_BIND_PRIVATE_VALIDATION_METRIC_KEYS = frozenset({
     "validation_issues", "validation_issue_details", "timeout_recovery_validation_issues",
     "timeout_recovery_original_failure", "task_delivery_issue",
@@ -238,6 +243,8 @@ def redact_implementation_audit(contract: dict, report: object) -> dict | None:
         check = {"status": row["status"], "evidence": evidence}
         if row["status"] != "covered":
             check.update(description="Local implementation issue remains unresolved; inspect local task evidence.", files=[])
+            if row.get("blocking_reason") in IMPLEMENTATION_ENVIRONMENT_BLOCKERS:
+                check["blocking_reason"] = row["blocking_reason"]
             if row.get("plan_revision"):
                 check["plan_revision"] = {
                     "reason": "Local evidence conflicts with the approved plan",
@@ -281,7 +288,7 @@ def _assess_implementation_contributions(contract: dict, report: object) -> dict
             checks.append(row)
             continue
         check = {"task_id": row.get("task_id"), **{
-            key: implementation[key] for key in ("status", "evidence", "description", "files", "plan_revision")
+            key: implementation[key] for key in ("status", "evidence", "description", "files", "plan_revision", "blocking_reason")
             if key in implementation
         }}
         if row.get("plan_revision") is not None and implementation.get("status") != "covered":
@@ -296,6 +303,7 @@ def _assess_implementation_contributions(contract: dict, report: object) -> dict
                 "task_id": task_id, "status": row.get("status"),
                 "description": row.get("description") or "Runtime acceptance remains pending",
                 "files": [], "evidence": row.get("evidence") or [],
+                **({"blocking_reason": row["blocking_reason"]} if row.get("blocking_reason") else {}),
             } for task_id in pending_verification_ids)
     implementation_statuses = {row["task_id"]: row["status"] for row in checks}
     deferred_contract = contract.get("deferred_acceptance_verification")
@@ -363,6 +371,7 @@ def _assess_implementation_contributions(contract: dict, report: object) -> dict
             pending.extend({
                 "task_id": task_id, "status": row["status"], "description": row["description"],
                 "files": row.get("files") or [], "evidence": row["evidence"],
+                **({"blocking_reason": row["blocking_reason"]} if row.get("blocking_reason") else {}),
             } for task_id in pending_verification_ids)
         acceptance_checks.append(row)
     result = assess_implementation_audit({
@@ -443,6 +452,13 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
             ):
                 issues.append(f"Implementation {kind} check requires an explicit status and concrete evidence")
                 continue
+            blocking_reason = row.get("blocking_reason")
+            if blocking_reason is not None and (
+                not isinstance(blocking_reason, str) or blocking_reason not in IMPLEMENTATION_ENVIRONMENT_BLOCKERS
+                or status not in ("blocked", "unverified") or row.get("plan_revision") is not None
+            ):
+                issues.append("Implementation blocking_reason must identify an allowed unmet environment prerequisite on a blocked or unverified check")
+                continue
             if status == "covered" and row.get("plan_revision") is not None:
                 issues.append(
                     "A covered implementation check cannot request a plan revision; "
@@ -541,6 +557,7 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
                     "task_id": task_id, "status": status, "description": description,
                     "files": paths, "evidence": evidence,
                     **({"plan_revision": revision} if revision is not None else {}),
+                    **({"blocking_reason": blocking_reason} if blocking_reason is not None else {}),
                 } for task_id in related)
     required = expected if contract.get("final_verification") else {subject}
     if required - checked.keys():
@@ -563,6 +580,57 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
     return result
 
 
+def implementation_audit_failure_domain(contract: dict, assessment: dict) -> str | None:
+    if not assessment.get("report_valid"):
+        return "evidence"
+    if assessment.get("node_complete"):
+        return None
+    if assessment.get("status") == "plan_revision_required":
+        return "plan"
+    subject = contract.get("subject_task_id")
+    findings = [finding for finding in assessment.get("findings") or [] if finding.get("task_id") == subject]
+    if findings and all(
+        finding.get("status") in ("blocked", "unverified")
+        and finding.get("blocking_reason") in IMPLEMENTATION_ENVIRONMENT_BLOCKERS for finding in findings
+    ):
+        return "environment"
+    role = next((task.get("type") for task in contract.get("tasks") or [] if task.get("id") == subject), None)
+    if role in ("coding", "fix") and any(finding.get("status") == "gap" for finding in findings):
+        return "code_quality"
+    return "verification"
+
+
+def task_failure_domain(
+    failure_code: str | None, *, audit_contract: dict | None = None,
+    audit_assessment: dict | None = None, conformance: dict | None = None,
+    payload_failed: bool = False,
+) -> str:
+    if failure_code in {
+        "planned_task_incomplete", "planned_task_baseline_invalid", "approved_plan_baseline_modified",
+        "remediation_scope_violation", "verification_work_item_scope_violation", "uncommitted_workspace_changes",
+        "forbidden_branch_merge",
+    }:
+        return "delivery"
+    if failure_code == "implementation_plan_revision_required":
+        return "plan"
+    if payload_failed:
+        return "execution"
+    if failure_code == "implementation_audit_incomplete":
+        return implementation_audit_failure_domain(audit_contract or {}, audit_assessment or {}) or "verification"
+    if failure_code in {"approved_plan_deviation", "approved_plan_conformance_unverified"}:
+        assessment = conformance or {}
+        if assessment.get("reason") == "approved_plan_review_unavailable":
+            return "execution"
+        if assessment.get("reason") or assessment.get("diagnostic_code"):
+            return "evidence"
+        return "code_quality" if assessment.get("status") == "deviation" else "verification"
+    if failure_code == "acceptance_criteria_uncovered":
+        return "verification"
+    if failure_code in {"validation_unavailable", "validation_retry_exhausted"}:
+        return "evidence"
+    return "execution"
+
+
 _WORKSPACE_INSTRUCTION_PATHS = (
     "AGENTS.md",
     "CLAUDE.md",
@@ -1889,7 +1957,7 @@ def has_agent_token_usage(*sources: object) -> bool:
     return False
 
 
-def _extract_output_signals(text: str) -> dict[str, Any]:
+def _extract_output_signals(text: str, usage_source: object = None) -> dict[str, Any]:
     """Parse stdout/stderr-like streams for success and failure signals.
 
     Uses structural signal detection — NOT keyword matching on result text.
@@ -1933,6 +2001,8 @@ def _extract_output_signals(text: str) -> dict[str, Any]:
 
         if ev_type == "turn.completed":
             has_turn_completed = True
+            has_turn_failed = False
+            error_messages.clear()
         elif ev_type == "turn.failed":
             has_turn_failed = True
             err = data.get("error") or {}
@@ -1962,10 +2032,18 @@ def _extract_output_signals(text: str) -> dict[str, Any]:
             # Claude result format:  {"type":"result","result":"...","is_error":false,...}
             if "exitCode" in data:
                 # Copilot JSONL result
-                exit_code = int(data.get("exitCode") or 0)
+                raw_exit_code = data["exitCode"]
+                if type(raw_exit_code) is not int and not (
+                    isinstance(raw_exit_code, str) and re.fullmatch(r"[+-]?[0-9]+", raw_exit_code)
+                ):
+                    error_messages.append("Agent result has an invalid exitCode")
+                    continue
+                exit_code = int(raw_exit_code)
                 if exit_code == 0:
                     has_result = True
                     has_meaningful_content = True
+                    has_turn_failed = False
+                    error_messages.clear()
                 else:
                     error_messages.append(f"Copilot exited with code {exit_code}")
             else:
@@ -1996,12 +2074,14 @@ def _extract_output_signals(text: str) -> dict[str, Any]:
                     # events appeared, the CLI never made an API call. The result
                     # text is a CLI-level error (e.g. "API Error: Connection error.")
                     # rather than the agent's actual work output.
-                    no_api_call = not has_agent_token_usage(data) and not has_assistant_events
+                    no_api_call = not has_agent_token_usage(data, usage_source) and not has_assistant_events
                     if no_api_call and result_text:
                         error_messages.append(result_text)
                     else:
                         has_result = True
                         has_meaningful_content = True
+                        has_turn_failed = False
+                        error_messages.clear()
         elif ev_type == "session.error":
             err = data.get("data") or {}
             if isinstance(err, dict):
@@ -4988,6 +5068,62 @@ def is_copilot_model_discovery_auth_error(*messages: str | None) -> bool:
     )
 
 
+# Transport failures a plain re-run can recover from. 421 Misdirected Request
+# is deliberately absent: it keeps its own recovery (retry without token env
+# vars) because it has historically indicated a credential-routing mismatch,
+# not a network blip.
+COPILOT_TRANSIENT_TRANSPORT_ERROR_PATTERNS = (
+    "timed out",
+    "timeout",
+    "unexpected eof",
+    "error sending request",
+    "connection reset",
+    "connection refused",
+    "connection timed out",
+    "connection error",
+    "connection closed",
+    "connection terminated",
+    "network is unreachable",
+    "no such host",
+    "temporary failure in name resolution",
+)
+
+COPILOT_STABLE_AUTH_ERROR_PATTERNS = (
+    "unauthorized",
+    "forbidden",
+    "http 401",
+    "http 403",
+    "not logged in",
+    "authentication required",
+    "invalid api key",
+    "your github token may be invalid",
+    "rejected the cli github credential",
+)
+
+
+def is_copilot_model_discovery_transient_transport_error(*messages: str | None) -> bool:
+    """Return whether Copilot failed model discovery on a transient transport error.
+
+    Matches connect timeouts, unexpected EOF, resets and DNS hiccups during
+    model discovery — the class of failures observed as intermittent on
+    unstable routes (a daemon-side rerun typically succeeds, and the same
+    login works interactively), as opposed to stable auth/config breakage.
+    Copilot appends its remediation boilerplate ("To resolve this, ... run
+    '/login' ...") to every discovery failure, so auth patterns are only
+    trusted when they appear before that boilerplate.
+    """
+    detail = " ".join(str(message or "").lower() for message in messages)
+    detail = detail.partition("to resolve this")[0]
+    if not (
+        "retrieve the list of available models" in detail
+        or "failed to load models" in detail
+    ):
+        return False
+    if any(pattern in detail for pattern in COPILOT_STABLE_AUTH_ERROR_PATTERNS):
+        return False
+    return any(pattern in detail for pattern in COPILOT_TRANSIENT_TRANSPORT_ERROR_PATTERNS)
+
+
 def is_runtime_resource_exhaustion_error(*messages: str | None) -> bool:
     """Return whether the OS refused an agent process, thread, or file watch."""
     detail = " ".join(str(message or "").lower() for message in messages)

{forgexa_cli-1.85.1 → forgexa_cli-1.85.2}/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.85.1"
+DAEMON_VERSION = "1.85.2"
 
 
 def _detect_client_type() -> str:
@@ -6439,8 +6439,8 @@ class ProcessManager:
             int(result.metrics.get("token_input", 0) or 0)
             + int(result.metrics.get("token_output", 0) or 0)
         ) > 0
-        signals = ProcessManager._extract_output_signals(
-            "\n".join(part for part in (stdout, stderr) if part)
+        signals = agent_core._extract_output_signals(
+            "\n".join(part for part in (stdout, stderr) if part), result.metrics,
         )
         if not has_token_usage and ProcessManager._should_scan_short_success_stdout(stdout, signals):
             error_channels = "\n".join(filter(None, [error_channels, stdout.strip()]))
@@ -8484,15 +8484,18 @@ class ProcessManager:
 
             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
+                agent_core.is_copilot_model_discovery_transient_transport_error(
+                    *structured_errors, stderr,
+                )
+                and "misdirected request" not 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; "
+                    "Copilot model discovery hit a transient transport error "
+                    "(timeout / connect reset) before work for task %s; "
                     "retrying once with the same credentials and configuration",
                     task_id,
                 )
@@ -14466,6 +14469,7 @@ class RuntimeDaemon:
         audit_contract = input_data.get("implementation_audit_contract")
         result.metrics.pop("implementation_audit_node_complete", None)
         result.metrics.pop("implementation_audit_subject_blocked", None)
+        result.metrics.pop("failure_domain", None)
         if isinstance(audit_contract, dict):
             agent_id = str(result.metrics.get("actual_agent") or getattr(task, "agent_type", "") or "")
             audit_report = agent_core.extract_implementation_audit(_daemon_extract_agent_output(agent_id, result.stdout))
@@ -14476,13 +14480,17 @@ class RuntimeDaemon:
             if isinstance(audit_report, dict):
                 result.observations.append({"type": "implementation_audit", "data": audit_report})
             audit_result = agent_core.assess_implementation_audit(audit_contract, audit_report)
+            failure_domain = agent_core.implementation_audit_failure_domain(audit_contract, audit_result)
+            if failure_domain is not None:
+                result.metrics["failure_domain"] = failure_domain
             result.metrics["implementation_audit_node_complete"] = bool(
                 audit_result["report_valid"] and audit_result["node_complete"]
             )
             result.metrics["implementation_audit_subject_blocked"] = bool(
                 audit_result["report_valid"] and not audit_result["node_complete"]
-                and any(finding.get("task_id") == audit_contract.get("subject_task_id") and finding.get("status") == "blocked"
-                        for finding in audit_result.get("findings") or [])
+                and (failure_domain == "environment" or any(
+                    finding.get("task_id") == audit_contract.get("subject_task_id") and finding.get("status") == "blocked"
+                    for finding in audit_result.get("findings") or []))
             )
             if audit_result["report_valid"] and audit_result["status"] == "plan_revision_required":
                 result.status = "failed"

{forgexa_cli-1.85.1 → forgexa_cli-1.85.2}/forgexa_cli.egg-info/PKG-INFO

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

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