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

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

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

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

{forgexa_cli-1.85.0 → 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",
@@ -211,6 +216,17 @@ def extract_implementation_audit(text: str) -> dict | None:
     return report
 
 
+def _implementation_acceptance_index(row: dict) -> int | None:
+    index = row.get("index", row.get("acceptance_index"))
+    if type(index) is not int:
+        return None
+    if "index" in row and "acceptance_index" in row and (
+        type(row["acceptance_index"]) is not int or row["acceptance_index"] != index
+    ):
+        return None
+    return index
+
+
 def redact_implementation_audit(contract: dict, report: object) -> dict | None:
     """Keep contract-owned status and hashed evidence without local free text."""
     from hashlib import sha256
@@ -227,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",
@@ -244,7 +262,7 @@ def redact_implementation_audit(contract: dict, report: object) -> dict | None:
                 if contract.get("version") == 2 and row["task_id"] in coding_ids and isinstance(row.get("implementation_check"), dict):
                     check["implementation_check"] = redact_check(row["implementation_check"])
             else:
-                check.update(index=row["index"], task_ids=row["task_ids"])
+                check.update(index=_implementation_acceptance_index(row), task_ids=row["task_ids"])
             summary[key].append(check)
     return summary
 
@@ -270,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":
@@ -285,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")
@@ -328,8 +347,9 @@ def _assess_implementation_contributions(contract: dict, report: object) -> dict
         and implementation_statuses.get(subject) == "covered"
     )
     for row in report["acceptance_checks"]:
+        index = _implementation_acceptance_index(row)
         if (
-            row["index"] in reserved_indexes and row["status"] == "unverified" and row.get("plan_revision") is None
+            index in reserved_indexes and row["status"] == "unverified" and row.get("plan_revision") is None
             and (
                 all(implementation_statuses.get(task_id) == "covered" for task_id in row["task_ids"])
                 or prepared_verifier and subject in row["task_ids"] and all(
@@ -339,7 +359,7 @@ def _assess_implementation_contributions(contract: dict, report: object) -> dict
                 )
             )
         ):
-            deferred_acceptance.append(row["index"])
+            deferred_acceptance.append(index)
             continue
         if (
             pending_verification_ids and row["status"] in ("blocked", "unverified")
@@ -351,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({
@@ -418,7 +439,7 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
     checked_criteria: set[int] = set()
     criterion_count = len(contract.get("acceptance_criteria") or [])
     for kind, rows in (("task", task_checks), ("acceptance", acceptance_checks)):
-        for row in rows:
+        for position, row in enumerate(rows, 1):
             if not isinstance(row, dict):
                 issues.append(f"Invalid implementation {kind} check")
                 continue
@@ -431,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; "
@@ -445,8 +473,19 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
                 checked[task_id] = status
                 related = [task_id]
             else:
-                index = row.get("index")
+                index = _implementation_acceptance_index(row)
                 related = row.get("task_ids")
+                if index is None:
+                    detail = (
+                        "index and acceptance_index must be identical integers"
+                        if "index" in row and "acceptance_index" in row else
+                        "index must be a one-based integer; acceptance_index is an exact alias, but id is not an index"
+                    )
+                    issues.append(
+                        f"Implementation audit has invalid acceptance criterion or task references; "
+                        f"acceptance row {position}: {detail}"
+                    )
+                    continue
                 if type(index) is int and not 1 <= index <= criterion_count:
                     if criterion_count == 0:
                         issues.append(
@@ -462,11 +501,18 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
                         )
                     continue
                 if (
-                    type(index) is not int or not 1 <= index <= criterion_count or index in checked_criteria
+                    index in checked_criteria
                     or not isinstance(related, list) or not related
                     or any(not isinstance(task_id, str) or task_id not in expected for task_id in related)
                 ):
-                    issues.append("Implementation audit has invalid acceptance criterion or task references")
+                    detail = (
+                        "duplicate index" if index in checked_criteria else
+                        "task_ids must be a non-empty list of approved top-level task IDs"
+                    )
+                    issues.append(
+                        f"Implementation audit has invalid acceptance criterion or task references; "
+                        f"acceptance index {index}: {detail}"
+                    )
                     continue
                 checked_criteria.add(index)
                 if len(related) > 1:
@@ -477,7 +523,7 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
                 description = row.get("description")
                 paths = row.get("files") or []
                 if not isinstance(description, str) or not description.strip() or not isinstance(paths, list):
-                    reference = f"task '{row['task_id']}'" if kind == "task" else f"acceptance index {row['index']}"
+                    reference = f"task '{row['task_id']}'" if kind == "task" else f"acceptance index {index}"
                     invalid_fields = []
                     if not isinstance(description, str) or not description.strip():
                         invalid_fields.append("description must be non-empty text")
@@ -511,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():
@@ -533,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",
@@ -1859,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.
@@ -1903,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 {}
@@ -1932,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:
@@ -1966,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):
@@ -4958,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.0 → 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.0"
+DAEMON_VERSION = "1.85.2"
 
 
 def _detect_client_type() -> str:
@@ -3040,7 +3040,7 @@ def _runtime_critic_reference_candidates(
             if isinstance(related, dict):
                 texts.append(str(related.get("description") or ""))
                 texts.extend(str(item.get("description") or "") for item in related.get("items") or [] if isinstance(item, dict))
-    if planned.get("type") == "design":
+    if planned.get("type") in ("design", "testing", "review"):
         texts.append(json.dumps({"analysis": baseline.get("approved_analysis"),
                                  "documents": baseline.get("analysis_documents")}, ensure_ascii=True)[:200_000])
     text = re.sub(r"https?://\S+", " ", "\n".join(texts))
@@ -3063,7 +3063,7 @@ def _runtime_critic_reference_candidates(
     php_context = any(Path(path).suffix.lower() == ".php" for path in source_paths)
     directories = {Path(path).parent.as_posix() for path in source_paths if safe_path(path)} - {"."}
     explicit = set()
-    for token in re.findall(r"(?<![\w./\\:-])[A-Za-z0-9_.-]+(?:/[A-Za-z0-9_.-]+)+", text):
+    for token in re.findall(r"(?<![A-Za-z0-9_./\\:-])[A-Za-z0-9_.-]+(?:/[A-Za-z0-9_.-]+)+", text):
         candidate = safe_path(token)
         if candidate is None:
             continue
@@ -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,
                 )
@@ -13998,6 +14001,7 @@ class RuntimeDaemon:
 
         after_sha = str((result.git or {}).get("commit_sha") or before_sha or "").strip()
         committed_sources: dict[str, str] = {}
+        unavailable_sources: list[dict[str, str]] = []
         source_bytes = 0
         coverage = {
             "candidate_files": 0, "full_source_files": 0, "unreadable_files": 0,
@@ -14026,6 +14030,27 @@ class RuntimeDaemon:
                         "test-cases.json", "coverage-matrix.json", "test-evidence.json", "test-report.md",
                     }
                 ))
+                if output_dir.startswith(f"docs/requirements/{task.requirement_key}/") and ".." not in Path(output_dir).parts:
+                    verification_dir = output_dir + "/verification"
+                    try:
+                        verification_paths = await self.workspace_manager._git(
+                            "ls-tree", "-r", "--name-only", "-z", after_sha, "--", *asset_paths, verification_dir,
+                            cwd=workspace_path, timeout=10,
+                        )
+                        if len(verification_paths.encode("utf-8")) > _RUNTIME_CRITIC_SOURCE_MAX_BYTES:
+                            raise ValueError("Committed verification inventory exceeds its bounded evidence budget")
+                        existing_artifacts = set(verification_paths.split("\0"))
+                        asset_paths = [path for path in asset_paths if path in existing_artifacts]
+                        paths.extend(path for path in verification_paths.split("\0") if (
+                            path.startswith(verification_dir + "/") and ".." not in Path(path).parts
+                            and re.fullmatch(r"[A-Za-z0-9_./-]+", path)
+                            and Path(path).suffix.lower() in {".php", ".py", ".ts", ".js", ".json", ".md", ".txt"}
+                            and not _is_sensitive_local_path(path)
+                            and Path(path).name.lower() not in {"env.php", "auth.json", "credentials.json", "secrets.json", "service-account.json"}
+                            and not any(part in {".git", ".forgexa", ".aws", ".ssh", ".env"} or part.startswith(".env.") for part in Path(path).parts)
+                        ))
+                    except Exception:
+                        coverage["verification_inventory_unavailable"] = True
                 paths.extend(asset_paths)
                 support_dirs = sorted({(Path(path).parent / "support").as_posix() for path in asset_paths if path.startswith("tests/")})
                 for directory in support_dirs[:5]:
@@ -14117,8 +14142,19 @@ class RuntimeDaemon:
                     source = await self.workspace_manager._git(
                         "show", f"{after_sha}:{path}", cwd=workspace_path, timeout=10,
                     )
-                except Exception:
+                except Exception as error:
                     coverage["unreadable_files"] += 1
+                    detail = str(error).lower()
+                    reason = "source_git_read_failed"
+                    if isinstance(error, UnicodeDecodeError):
+                        reason = "source_encoding_unavailable"
+                    elif isinstance(error, TimeoutError) or "timed out after" in detail:
+                        reason = "source_read_timeout"
+                    elif "cannot be mapped" in detail or "cannot allocate memory" in detail:
+                        reason = "source_memory_unavailable"
+                    elif "does not exist in" in detail or "exists on disk, but not in" in detail:
+                        reason = "source_path_unavailable"
+                    unavailable_sources.append({"path": path, "reason": reason})
                     continue
                 encoded_size = len(source.encode("utf-8"))
                 if source_bytes + encoded_size <= _RUNTIME_CRITIC_SOURCE_MAX_BYTES:
@@ -14136,7 +14172,10 @@ class RuntimeDaemon:
                 diff = (diff or "No new changes; review committed delivery instead.") + "".join(source_context)
         coverage["full_source_files"] = len(committed_sources)
         coverage["omitted_files"] = coverage["candidate_files"] - coverage["full_source_files"]
-        coverage["capsule_incomplete"] = coverage["omitted_files"] > 0 or coverage.get("reference_inventory_unavailable", False)
+        coverage["capsule_incomplete"] = (
+            coverage["omitted_files"] > 0 or coverage.get("reference_inventory_unavailable", False)
+            or coverage.get("verification_inventory_unavailable", False)
+        )
         result.metrics["runtime_critic_coverage"] = coverage
         if not diff:
             return {
@@ -14164,6 +14203,8 @@ class RuntimeDaemon:
             work_item={},
         )
         review_task.input_prompt += "\n## Review Evidence Coverage\n" + json.dumps(coverage, sort_keys=True)
+        if unavailable_sources:
+            review_task.input_prompt += "\n## Unavailable Committed Sources\n" + json.dumps(unavailable_sources, sort_keys=True)
         if coverage["capsule_incomplete"]:
             review_task.input_prompt += (
                 "\nSome candidate files were not available as complete source. Assess the evidence you can inspect; "
@@ -14183,6 +14224,7 @@ class RuntimeDaemon:
                 "reviewed_commit_sha": after_sha,
                 "baseline_fingerprint": baseline.get("fingerprint") if isinstance(baseline, dict) else None,
                 "input_sha256": hashlib.sha256(review_task.input_prompt.encode("utf-8")).hexdigest(),
+                "unavailable_sources": unavailable_sources,
                 "snapshots": [
                     {"path": path, "sha256": hashlib.sha256(source.encode("utf-8")).hexdigest(),
                      "bytes": len(source.encode("utf-8"))}
@@ -14427,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))
@@ -14437,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.0 → 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.0
+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.0 → forgexa_cli-1.85.2}/pyproject.toml

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