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

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

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

{forgexa_cli-1.85.1 → forgexa_cli-1.85.3}/forgexa_cli/__init__.py

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

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

@@ -68,16 +68,125 @@ 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",
 })
 
 
-def assess_approved_plan_conformance(baseline: dict, report: object) -> dict:
+def verification_obligation_fingerprint(task: dict) -> str:
+    task_input = task.get("input") if isinstance(task.get("input"), dict) else {}
+    responsibility = {
+        "id": task.get("id"), "type": task.get("type"), "description": task.get("description") or "",
+        "items": task.get("items") or [], "depends_on": task.get("depends_on") or [],
+        "files": task_input.get("files") or task.get("files") or [],
+    }
+    return hashlib.sha256(json.dumps(responsibility, sort_keys=True, ensure_ascii=True, separators=(",", ":")).encode()).hexdigest()
+
+
+def approved_contribution_review_instructions(baseline: dict, audit_contract: dict | None) -> str:
+    task = baseline.get("task") or {}
+    obligations = baseline.get("verification_obligations") or {}
+    if (
+        not isinstance(audit_contract, dict) or audit_contract.get("version") != 2
+        or audit_contract.get("plan_id") != baseline.get("plan_id") or audit_contract.get("subject_task_id") != task.get("id")
+        or audit_contract.get("final_verification") is not False or task.get("type") not in ("coding", "fix")
+        or not isinstance(obligations, dict) or type(obligations.get("version")) is not int or obligations["version"] != 1
+    ):
+        return ""
+    verifiers = [check for check in obligations.get("checks") or [] if isinstance(check, dict)
+                 and check.get("type") in ("testing", "verify") and check.get("task_id") != task["id"]]
+    if not verifiers:
+        return ""
+    example = {"contribution_check": {"check_id": str(task["id"]) + ":assigned", "status": "unverified",
+                "evidence": ["<independent source and every assigned check evidence>"]},
+               "pending_checks": [{"check_id": verifiers[0]["check_id"], "task_id": verifiers[0]["task_id"],
+                   "status": "unverified", "evidence": ["<observed outstanding approved verification>"]}]}
+    return (
+        "\n## Assigned Contribution and Pending Verification\n"
+        "Within the bound plan_conformance object, contribution_check covers all requirements and mandatory checks of this task, "
+        "not only static source. When independently evidenced as conformant, other approved verification owners may remain pending. "
+        "Use the exact frozen check_id/task_id pairs; this does not authorize moving an own check to another owner, "
+        "inventing an owner, waiving a check or changing its phase. Keep the overall status unverified while pending_checks remain. "
+        "The score and verdict assess the assigned contribution, not unfinished work assigned elsewhere. "
+        "A real own gap stays deviation or unverified. The default example is not completion evidence.\n"
+        "Scoped contribution fields example:\n" + json.dumps(example, ensure_ascii=True, separators=(",", ":"))
+    )
+
+
+def _assess_contribution_conformance(baseline: dict, report: dict, audit_contract: dict | None, result: dict) -> dict:
+    obligations = baseline.get("verification_obligations")
+    subject = result["task_id"]
+    if (
+        not isinstance(audit_contract, dict) or audit_contract.get("version") != 2
+        or audit_contract.get("plan_id") != baseline.get("plan_id")
+        or audit_contract.get("subject_task_id") != subject or audit_contract.get("final_verification") is not False
+        or (baseline.get("task") or {}).get("type") not in ("coding", "fix")
+        or not isinstance(obligations, dict) or type(obligations.get("version")) is not int or obligations["version"] != 1
+    ):
+        return result
+    checks = obligations.get("checks")
+    if not isinstance(checks, list) or any(not isinstance(check, dict) for check in checks):
+        return result
+    by_id = {check.get("check_id"): check for check in checks if isinstance(check.get("check_id"), str)}
+    own = by_id.get(str(subject) + ":assigned")
+    tasks = audit_contract.get("tasks")
+    if not isinstance(tasks, list) or any(not isinstance(task, dict) or not isinstance(task.get("id"), str) for task in tasks):
+        return result
+    approved = {task["id"]: task for task in tasks}
+    contribution = report.get("contribution_check")
+    pending = report.get("pending_checks")
+    if (
+        len(by_id) != len(checks) or not isinstance(own, dict) or own.get("task_id") != subject
+        or subject not in approved or own.get("task_fingerprint") != verification_obligation_fingerprint(approved[subject])
+        or own.get("task_fingerprint") != verification_obligation_fingerprint(baseline["task"])
+        or own.get("required") is not True or not isinstance(contribution, dict)
+        or contribution.get("check_id") != own["check_id"] or contribution.get("status") != "conformant"
+        or contribution.get("plan_revision") is not None
+        or not isinstance(pending, list) or not pending
+    ):
+        return result
+    evidence = contribution.get("evidence")
+    if not isinstance(evidence, list) or not evidence or any(not isinstance(item, str) or not item.strip() for item in evidence):
+        return result
+    normalized = []
+    seen = set()
+    for check in pending:
+        if not isinstance(check, dict) or not isinstance(check.get("check_id"), str):
+            return result
+        binding = by_id.get(check["check_id"])
+        references = check.get("evidence")
+        reason = check.get("blocking_reason")
+        if (
+            not isinstance(binding, dict) or check["check_id"] in seen or binding.get("required") is not True
+            or check.get("task_id") == subject or binding.get("task_id") != check.get("task_id")
+            or binding.get("type") not in ("testing", "verify") or approved.get(check.get("task_id"), {}).get("type") != binding.get("type")
+            or binding.get("task_fingerprint") != verification_obligation_fingerprint(approved.get(check.get("task_id"), {}))
+            or check.get("status") not in ("blocked", "unverified") or check.get("plan_revision") is not None
+            or not isinstance(references, list) or not references
+            or any(not isinstance(item, str) or not item.strip() for item in references)
+            or reason is not None and (not isinstance(reason, str) or reason not in IMPLEMENTATION_ENVIRONMENT_BLOCKERS)
+        ):
+            return result
+        seen.add(check["check_id"])
+        normalized.append({"check_id": check["check_id"], "task_id": check["task_id"], "status": check["status"],
+                           "evidence_refs": [hashlib.sha256(item.encode()).hexdigest() for item in references],
+                           **({"blocking_reason": reason} if reason is not None else {})})
+    result.update(node_complete=True, contribution_check={"check_id": own["check_id"], "status": "conformant",
+        "evidence_refs": [hashlib.sha256(item.encode()).hexdigest() for item in evidence]}, pending_checks=normalized,
+        verification_pending=sorted({check["task_id"] for check in normalized}))
+    return result
+
+
+def assess_approved_plan_conformance(baseline: dict, report: object, *, audit_contract: dict | None = None) -> dict:
     result = {
         "status": "unverified", "baseline_fingerprint": baseline.get("fingerprint"),
-        "task_id": (baseline.get("task") or {}).get("id"), "evidence_refs": [],
+        "task_id": (baseline.get("task") or {}).get("id"), "evidence_refs": [], "node_complete": False,
     }
     expected = {key: value for key, value in baseline.items() if key != "fingerprint"}
     fingerprint = hashlib.sha256(json.dumps(
@@ -109,8 +218,20 @@ def assess_approved_plan_conformance(baseline: dict, report: object) -> dict:
         result["reason"] = "approved_plan_review_evidence_missing"
         result["diagnostic_code"] = "approved_plan_review_evidence_missing"
         return result
+    contribution = report.get("contribution_check")
+    if report["status"] == "conformant" and (
+        bool(report.get("pending_checks"))
+        or "pending_checks" in report and not isinstance(report["pending_checks"], list)
+        or contribution is not None and (not isinstance(contribution, dict) or contribution.get("status") != "conformant")
+    ):
+        result["reason"] = "approved_plan_review_missing_or_mismatched"
+        result["diagnostic_code"] = "approved_plan_review_contribution_conflict"
+        return result
     result["status"] = report["status"]
     result["evidence_refs"] = [hashlib.sha256(item.encode()).hexdigest() for item in evidence]
+    result["node_complete"] = report["status"] == "conformant"
+    if report["status"] == "unverified" and report.get("contribution_check") is not None:
+        return _assess_contribution_conformance(baseline, report, audit_contract, result)
     return result
 
 
@@ -238,6 +359,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 +404,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 +419,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 +487,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 +568,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 +673,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 +696,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 +2073,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 +2117,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 +2148,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 +2190,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 +5184,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.3}/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.3"
 
 
 def _detect_client_type() -> str:
@@ -1809,6 +1809,7 @@ def _build_runtime_critic_prompt(
                 "failed checks remain blocking. State the concrete missing evidence; never invent a run, "
                 "treat asset existence as proof of correctness, or claim final QA or release acceptance."
             )
+        parts.append(agent_core.approved_contribution_review_instructions(baseline, audit_contract))
     else:
         planned_context = {
             key: (task.input_data or {}).get(key)
@@ -6439,8 +6440,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 +8485,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,
                 )
@@ -14289,7 +14293,8 @@ class RuntimeDaemon:
                     **metadata,
                 }
             conformance = (
-                agent_core.assess_approved_plan_conformance(baseline, structured_result.get("plan_conformance"))
+                agent_core.assess_approved_plan_conformance(baseline, structured_result.get("plan_conformance"),
+                    audit_contract=(task.input_data or {}).get("implementation_audit_contract"))
                 if isinstance(baseline, dict) else None
             )
             if conformance is not None and conformance["status"] != "conformant":
@@ -14317,6 +14322,15 @@ class RuntimeDaemon:
                         "evidence": conformance["evidence_refs"],
                     },
                 }
+                if conformance.get("node_complete") and conformance["status"] == "unverified":
+                    contribution = conformance["contribution_check"]
+                    structured_result["plan_conformance"]["contribution_check"] = {
+                        "check_id": contribution["check_id"], "status": contribution["status"], "evidence": contribution["evidence_refs"],
+                    }
+                    structured_result["plan_conformance"]["pending_checks"] = [{
+                        "check_id": check["check_id"], "task_id": check["task_id"], "status": check["status"], "evidence": check["evidence_refs"],
+                        **({"blocking_reason": check["blocking_reason"]} if "blocking_reason" in check else {}),
+                    } for check in conformance["pending_checks"]]
             encoded_result = json.dumps(
                 structured_result,
                 ensure_ascii=True,
@@ -14466,6 +14480,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 +14491,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"
@@ -14504,6 +14523,7 @@ class RuntimeDaemon:
             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):
+                result.metrics["failure_domain"] = "delivery"
                 issues.append(_OutputValidationIssue(
                     "planned_task_incomplete",
                     f"Planned task file has no implementation evidence: {missing_path}. "
@@ -16508,7 +16528,10 @@ class RuntimeDaemon:
                 ])
 
             if (
-                agent_core.is_implementation_testing_task(task.node_type, task.input_data or {})
+                result.metrics.get("failure_domain") == "environment" and all(
+                    issue.code in {"implementation_audit_incomplete", "acceptance_criteria_uncovered"} for issue in issues
+                )
+                or agent_core.is_implementation_testing_task(task.node_type, task.input_data or {})
                 and result.metrics.get("implementation_audit_subject_blocked") is True
             ):
                 result.status = "failed"
@@ -16711,7 +16734,8 @@ class RuntimeDaemon:
                     result.failure_code = "implementation_audit_incomplete"
                     result.error = "; ".join(remaining[:3])
                     if (
-                        agent_core.is_implementation_testing_task(task.node_type, task.input_data or {})
+                        result.metrics.get("failure_domain") == "environment"
+                        or agent_core.is_implementation_testing_task(task.node_type, task.input_data or {})
                         and result.metrics.get("implementation_audit_subject_blocked") is True
                     ):
                         result.error += ". Resolve the reported verification prerequisites before retrying."

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

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

{forgexa_cli-1.85.1 → forgexa_cli-1.85.3}/pyproject.toml

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