forgexa-cli 1.83.1__tar.gz → 1.84.1__tar.gz

{forgexa_cli-1.83.1 → forgexa_cli-1.84.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.83.1
+Version: 1.84.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.83.1 → forgexa_cli-1.84.1}/forgexa_cli/__init__.py

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

{forgexa_cli-1.83.1 → forgexa_cli-1.84.1}/forgexa_cli/agent_core.py

@@ -67,6 +67,12 @@ except ImportError:
 
 logger = logging.getLogger("agent_core")
 
+IMPLEMENTATION_AUDIT_PROTOCOL_VERSION = 3
+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:
     result = {
@@ -271,8 +277,41 @@ def _assess_implementation_contributions(contract: dict, report: object) -> dict
                 "files": [], "evidence": row.get("evidence") or [],
             } 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")
+    reserved_indexes = set()
+    if (
+        isinstance(deferred_contract, dict) and type(deferred_contract.get("version")) is int
+        and deferred_contract["version"] in (1, 2, 3)
+        and deferred_contract.get("execution_phase") == "verification_final"
+        and isinstance(deferred_contract.get("workflow_id"), str) and deferred_contract["workflow_id"]
+        and isinstance(deferred_contract.get("analysis_revision_id"), str) and deferred_contract["analysis_revision_id"]
+        and re.fullmatch(r"[0-9a-f]{64}", str(deferred_contract.get("qa_test_level_policy_fingerprint", "")))
+    ):
+        reserved_ids = deferred_contract.get("acceptance_criteria_ids")
+        criteria = deferred_contract.get("criteria")
+        if (
+            isinstance(reserved_ids, list) and reserved_ids and all(isinstance(value, str) for value in reserved_ids)
+            and len(set(reserved_ids)) == len(reserved_ids) and isinstance(criteria, list)
+            and len(criteria) == len(reserved_ids)
+            and reserved_ids == [criterion.get("id") for criterion in criteria if isinstance(criterion, dict)]
+        ):
+            for criterion_id in reserved_ids:
+                match = re.fullmatch(r"AC-([0-9]+)", criterion_id)
+                if match is None or not 1 <= int(match.group(1)) <= len(contract.get("acceptance_criteria") or []):
+                    reserved_indexes.clear()
+                    break
+                reserved_indexes.add(int(match.group(1)))
+            if len(reserved_indexes) != len(reserved_ids):
+                reserved_indexes.clear()
     acceptance_checks = []
+    deferred_acceptance = []
     for row in report["acceptance_checks"]:
+        if (
+            row["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"])
+        ):
+            deferred_acceptance.append(row["index"])
+            continue
         if (
             pending_verification_ids and row["status"] in ("blocked", "unverified")
             and row.get("plan_revision") is None
@@ -285,7 +324,9 @@ def _assess_implementation_contributions(contract: dict, report: object) -> dict
                 "files": row.get("files") or [], "evidence": row["evidence"],
             } for task_id in pending_verification_ids)
         acceptance_checks.append(row)
-    result = assess_implementation_audit({**contract, "version": 1}, {
+    result = assess_implementation_audit({
+        **contract, "version": 1, "final_verification": contract.get("final_verification") and not deferred_acceptance,
+    }, {
         **report, "task_checks": checks, "acceptance_checks": acceptance_checks,
     })
     result["report"] = report
@@ -293,6 +334,7 @@ def _assess_implementation_contributions(contract: dict, report: object) -> dict
     result["report_valid"] = not result["issues"]
     result["node_complete"] = result["node_complete"] and not issues
     result["verification_pending"] = sorted({item["task_id"] for item in pending})
+    result["deferred_acceptance"] = sorted(deferred_acceptance)
     result["findings"].extend(pending)
     for request in original["revision_requests"]:
         if request not in result["revision_requests"]:
@@ -302,7 +344,7 @@ def _assess_implementation_contributions(contract: dict, report: object) -> dict
         if contract.get("final_verification") or request["task_id"] == contract.get("subject_task_id")
     ]
     result["followup_task_ids"] = sorted({finding["task_id"] for finding in result["findings"]})
-    if issues or pending or result["revision_requests"]:
+    if issues or pending or result["revision_requests"] or deferred_acceptance:
         result["status"] = "incomplete"
     if result["report_valid"] and result["blocking_revision_requests"]:
         result["status"] = "plan_revision_required"
@@ -312,7 +354,8 @@ def _assess_implementation_contributions(contract: dict, report: object) -> dict
 
 def assess_implementation_audit(contract: dict, report: object) -> dict:
     """Validate implementation coverage independently of later runtime acceptance."""
-    if contract.get("version") == 2:
+    version = contract.get("version", 1)
+    if type(version) is int and version == 2:
         return _assess_implementation_contributions(contract, report)
     issues: list[str] = []
     findings: list[dict] = []
@@ -322,6 +365,9 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
         "findings": findings, "followup_task_ids": [], "report": report,
         "revision_requests": [], "blocking_reasons": [],
     }
+    if type(version) is not int or version not in (1, 2):
+        issues.append("Implementation audit contract version is unsupported")
+        return result
     if (
         not isinstance(contract.get("audit_id"), str) or not contract["audit_id"]
         or not isinstance(report, dict) or report.get("audit_id") != contract["audit_id"]

{forgexa_cli-1.83.1 → forgexa_cli-1.84.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.83.1"
+DAEMON_VERSION = "1.84.1"
 
 
 def _detect_client_type() -> str:
@@ -1885,6 +1885,56 @@ def _format_reflection_findings(findings: object) -> str:
     return "\n".join(lines)
 
 
+class _OutputValidationIssue(str):
+    code: str
+    severity: str
+
+    def __new__(cls, code: str, message: str, severity: str = "error") -> "_OutputValidationIssue":
+        issue = super().__new__(cls, message)
+        issue.code = code
+        issue.severity = severity
+        return issue
+
+
+def _output_validation_issue(issue: str) -> _OutputValidationIssue:
+    if isinstance(issue, _OutputValidationIssue):
+        return issue
+    for prefix, code in (
+        ("Planned task file has no implementation evidence:", "planned_task_incomplete"),
+        ("Verification work item modified requirement analysis assets:", "verification_work_item_scope_violation"),
+        ("Uncovered acceptance criteria in coverage-matrix.json:", "acceptance_criteria_uncovered"),
+    ):
+        if issue.startswith(prefix):
+            return _OutputValidationIssue(code, issue)
+    if issue.startswith("qa_policy."):
+        return _OutputValidationIssue(issue.partition(":")[0], issue)
+    if issue.startswith("Possible syntax issue in "):
+        return _OutputValidationIssue("syntax_advisory", issue, "warning")
+    return _OutputValidationIssue("output_validation_failed", issue)
+
+
+def _record_output_validation_issues(result: "TaskResult", issues: list[str]) -> None:
+    result.metrics["validation_issues"] = [str(issue) for issue in issues]
+    result.metrics["validation_issue_details"] = [
+        {"code": normalized.code, "severity": normalized.severity, "message": str(normalized)}
+        for issue in issues for normalized in [_output_validation_issue(issue)]
+    ]
+
+
+def _mark_output_validation_unavailable(result: "TaskResult", snapshot: object = None) -> None:
+    if result.status == "failed" and result.failure_code:
+        return
+    if _qa_source_test_validation_required(snapshot):
+        _mark_qa_source_validation_unavailable(result)
+        return
+    result.status = "failed"
+    result.failure_code = "validation_unavailable"
+    result.error = "Output validation could not complete; inspect the runtime validation log before retrying."
+    _record_output_validation_issues(result, [
+        _OutputValidationIssue("validation_unavailable", result.error),
+    ])
+
+
 def _filter_local_bind_task_result(result: "TaskResult") -> None:
     """Strip raw local-environment output from ordinary completion fields.
 
@@ -1898,7 +1948,8 @@ def _filter_local_bind_task_result(result: "TaskResult") -> None:
     result.stdout = ""
     result.stderr = ""
     result.observations = []
-    result.metrics.pop("validation_issues", None)
+    for key in agent_core.LOCAL_BIND_PRIVATE_VALIDATION_METRIC_KEYS:
+        result.metrics.pop(key, None)
     critic_review = result.critic_review
     if isinstance(critic_review, dict) and isinstance(critic_review.get("result"), dict):
         result.critic_review = {
@@ -6698,6 +6749,7 @@ class ProcessManager:
 
         elapsed = time.monotonic() - start_time
         result.metrics["duration_seconds"] = round(elapsed, 2)
+        result.metrics["actual_agent"] = agent.agent_id
 
         # Detect agent-level failures despite exit code 0
         output_failure = None if agent_core.canonical_agent_id(agent.agent_id) in {"deepseek", "minimax"} else self._detect_agent_output_failure(result, agent.agent_id)
@@ -10028,7 +10080,7 @@ class ServerConnection:
                 "acceptance_verification": {
                     "protocol_version": runtime_evidence.DEFERRED_ACCEPTANCE_VERIFICATION_PROTOCOL_VERSION,
                 },
-                "implementation_audit": {"protocol_version": 3},
+                "implementation_audit": {"protocol_version": agent_core.IMPLEMENTATION_AUDIT_PROTOCOL_VERSION},
                 "task_delivery": {"protocol_version": 1},
                 "recording_suggestions": {"protocol_version": 1, "isolated_workspace": True},
                 "task_attachment_staging": {"protocol_version": 1, "runtime_proxy": True, "image_agents": ["claude"]},
@@ -10454,7 +10506,7 @@ class ServerConnection:
                     "acceptance_verification": {
                         "protocol_version": runtime_evidence.DEFERRED_ACCEPTANCE_VERIFICATION_PROTOCOL_VERSION,
                     },
-                    "implementation_audit": {"protocol_version": 3},
+                    "implementation_audit": {"protocol_version": agent_core.IMPLEMENTATION_AUDIT_PROTOCOL_VERSION},
                     "task_delivery": {"protocol_version": 1},
                     "recording_suggestions": {"protocol_version": 1, "isolated_workspace": True},
                     "local_evidence": {"protocol_version": 1, "structured_summary": True},
@@ -12486,6 +12538,9 @@ class RuntimeDaemon:
         ):
             return False
 
+        result.metrics["timeout_recovery_original_failure"] = {
+            "status": result.status, "failure_code": result.failure_code, "error": result.error,
+        }
         validation_issues = self._validate_outputs(workspace_path, task, result)
         if validation_issues:
             result.metrics["timeout_recovery_validation_issues"] = validation_issues
@@ -13371,17 +13426,14 @@ class RuntimeDaemon:
                         reporter, on_output_chunk, tried_agents=tried_agents,
                         default_branch=default_branch, before_sha=delivery_before_sha,
                     )
-                    # Re-collect git info if validation triggered retries
-                    if result.metrics.get("validation_issues") is not None or True:
-                        pre_commit_git = await self.process_manager._collect_git_info(workspace_path)
+                    # Re-collect after validation, including a successful repair.
+                    pre_commit_git = await self.process_manager._collect_git_info(workspace_path)
                 except Exception:
-                    if _qa_source_test_validation_required(
+                    _mark_output_validation_unavailable(
+                        result,
                         (task.input_data or {}).get("qa_test_level_policy_snapshot")
-                    ):
-                        _mark_qa_source_validation_unavailable(result)
-                        logger.exception("Validation gate error for task %s (refusing to proceed)", task.task_id)
-                    else:
-                        logger.exception("Validation gate error for task %s (proceeding anyway)", task.task_id)
+                    )
+                    logger.exception("Validation gate error for task %s (refusing to proceed)", task.task_id)
 
             if result.failure_code == "verification_work_item_scope_violation" and not is_local_bind:
                 await self._discard_verification_scope_changes(
@@ -13455,8 +13507,11 @@ class RuntimeDaemon:
                                 )
                                 pre_commit_git = await self.process_manager._collect_git_info(workspace_path)
                             except Exception:
+                                _mark_output_validation_unavailable(
+                                    result, (task.input_data or {}).get("qa_test_level_policy_snapshot"),
+                                )
                                 logger.exception(
-                                    "Post-validation gate error for task %s (proceeding anyway)",
+                                    "Post-validation gate error for task %s (refusing to proceed)",
                                     task.task_id,
                                 )
                         break
@@ -14216,9 +14271,10 @@ class RuntimeDaemon:
                 result.status = "failed"
                 result.failure_code = "approved_plan_baseline_modified"
                 result.error = "Implementation modified frozen analysis assets: " + ", ".join(forbidden_paths[:5])
-                issues.append(result.error)
+                issues.append(_OutputValidationIssue(result.failure_code, result.error))
 
         audit_contract = input_data.get("implementation_audit_contract")
+        result.metrics.pop("implementation_audit_node_complete", 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))
@@ -14229,6 +14285,9 @@ 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)
+            result.metrics["implementation_audit_node_complete"] = bool(
+                audit_result["report_valid"] and audit_result["node_complete"]
+            )
             if audit_result["report_valid"] and audit_result["status"] == "plan_revision_required":
                 result.status = "failed"
                 result.failure_code = "implementation_plan_revision_required"
@@ -14236,11 +14295,12 @@ class RuntimeDaemon:
                 result.error = "Approved analysis and task plan require revision before implementation can continue: " + "; ".join(
                     f"{request['task_id']}: {request['reason']}" for request in requests[:3]
                 )
-                issues.append(result.error)
+                issues.append(_OutputValidationIssue(result.failure_code, result.error))
             elif not audit_result["report_valid"] or not audit_result["node_complete"]:
-                issues.extend(audit_result["issues"] or audit_result.get("blocking_reasons") or [
+                issues.extend(_OutputValidationIssue("implementation_audit_incomplete", issue) for issue in (
+                    audit_result["issues"] or audit_result.get("blocking_reasons") or [
                     "The selected approved task still has implementation gaps",
-                ])
+                ]))
 
         if node_type == "coding" or (
             node_type == "fix" and input_data.get("task") == "phase_remediation_fix"
@@ -14248,11 +14308,12 @@ 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):
-                issues.append(
+                issues.append(_OutputValidationIssue(
+                    "planned_task_incomplete",
                     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")
@@ -14272,10 +14333,11 @@ class RuntimeDaemon:
                 if _is_requirement_analysis_path(path)
             )
             if forbidden_paths:
-                issues.append(
+                issues.append(_OutputValidationIssue(
+                    "verification_work_item_scope_violation",
                     "Verification work item modified requirement analysis assets: "
                     + ", ".join(forbidden_paths[:5])
-                )
+                ))
 
         if verification_work_item and node_type == "analysis":
             analysis_doc_path = str(input_data.get("verification_analysis_doc_path", "") or "")
@@ -14431,24 +14493,29 @@ class RuntimeDaemon:
             # Syntax-check modified Python and JS/TS files
             for f in result.files_changed:
                 fpath = workspace_path / f
-                if not fpath.exists():
-                    continue
-                if f.endswith(".py"):
-                    try:
+                try:
+                    if not fpath.exists():
+                        continue
+                    if f.endswith(".py"):
                         import ast
-                        ast.parse(fpath.read_text(encoding="utf-8"), filename=f)
-                    except SyntaxError as e:
-                        issues.append(f"Python syntax error in {f}: {e.msg} (line {e.lineno})")
-                elif f.endswith((".js", ".ts", ".jsx", ".tsx")):
-                    # Basic bracket/brace balance check
-                    content = fpath.read_text(encoding="utf-8")
-                    opens = content.count("{") + content.count("(") + content.count("[")
-                    closes = content.count("}") + content.count(")") + content.count("]")
-                    if abs(opens - closes) > 2:
-                        issues.append(
-                            f"Possible syntax issue in {f}: "
-                            f"bracket imbalance (open={opens}, close={closes})"
-                        )
+                        ast.parse(fpath.read_bytes(), filename=f)
+                    elif f.endswith((".js", ".ts", ".jsx", ".tsx")):
+                        content = fpath.read_text(encoding="utf-8")
+                        opens = content.count("{") + content.count("(") + content.count("[")
+                        closes = content.count("}") + content.count(")") + content.count("]")
+                        if abs(opens - closes) > 2:
+                            issues.append(_OutputValidationIssue(
+                                "syntax_advisory", f"Possible syntax issue in {f}: "
+                                f"bracket imbalance (open={opens}, close={closes})", "warning",
+                            ))
+                except SyntaxError as error:
+                    issues.append(_OutputValidationIssue(
+                        "source_syntax_invalid", f"Python syntax error in {f}: {error.msg} (line {error.lineno})",
+                    ))
+                except (OSError, UnicodeError):
+                    issues.append(_OutputValidationIssue(
+                        "validation_unavailable", f"Output validation could not read source file: {f}",
+                    ))
 
             # Task 6 (P6 fix): warning-level phase_handoffs check for non-analysis
             # nodes. These nodes SHOULD append a phase_handoffs entry to analysis.json
@@ -14773,10 +14840,11 @@ class RuntimeDaemon:
                                         ids = ", ".join(ac["id"] for ac in uncovered[:20])
                                         if len(uncovered) > 20:
                                             ids += f" (+{len(uncovered) - 20} more)"
-                                        issues.append(
+                                        issues.append(_OutputValidationIssue(
+                                            "acceptance_criteria_uncovered",
                                             "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 (
@@ -16220,12 +16288,18 @@ class RuntimeDaemon:
                 before_sha=before_sha,
                 preserved_paths=preserved_paths,
             )
-            issues = self._validate_outputs(workspace_path, task, result)
+            issues = [_output_validation_issue(issue) for issue in self._validate_outputs(workspace_path, task, result)]
             if result.failure_code in ("implementation_plan_revision_required", "approved_plan_baseline_modified"):
+                _record_output_validation_issues(result, issues)
+                logger.warning("Output validation stopped task %s (%s)", task.task_id, result.failure_code)
                 return result
             if require_source_inventory:
-                issues.extend(inventory_issues)
+                issues.extend(_output_validation_issue(issue) for issue in inventory_issues)
+            advisory_issues = [issue for issue in issues if issue.severity == "warning"]
+            issues = [issue for issue in issues if issue.severity != "warning"]
             if not issues:
+                if advisory_issues:
+                    _record_output_validation_issues(result, advisory_issues)
                 self._record_testing_telemetry(
                     workspace_path, task, result, retries_used=attempt
                 )
@@ -16240,7 +16314,7 @@ class RuntimeDaemon:
             if (
                 agent_core.is_implementation_testing_task(task.node_type, task.input_data or {})
                 and all(
-                    issue.startswith("Uncovered acceptance criteria in coverage-matrix.json:")
+                    issue.code == "acceptance_criteria_uncovered"
                     for issue in issues
                 )
             ):
@@ -16251,7 +16325,7 @@ class RuntimeDaemon:
                     "Resolve the unmet criteria or missing test prerequisites, "
                     "then rerun verification."
                 )
-                result.metrics["validation_issues"] = issues
+                _record_output_validation_issues(result, issues)
                 self._record_testing_telemetry(
                     workspace_path, task, result, retries_used=attempt
                 )
@@ -16349,11 +16423,13 @@ class RuntimeDaemon:
             before_sha=before_sha,
             preserved_paths=preserved_paths,
         )
-        remaining = self._validate_outputs(workspace_path, task, result)
+        remaining = [_output_validation_issue(issue) for issue in self._validate_outputs(workspace_path, task, result)]
         if result.failure_code in ("implementation_plan_revision_required", "approved_plan_baseline_modified"):
+            _record_output_validation_issues(result, remaining)
+            logger.warning("Output validation stopped task %s (%s)", task.task_id, result.failure_code)
             return result
         if require_source_inventory:
-            remaining.extend(inventory_issues)
+            remaining.extend(_output_validation_issue(issue) for issue in inventory_issues)
         if remaining:
             if getattr(task, "workspace_resolution", None) == "local_bind":
                 _append_local_bind_output_log(task.task_id, [
@@ -16363,7 +16439,7 @@ class RuntimeDaemon:
             if (
                 agent_core.is_implementation_testing_task(task.node_type, task.input_data or {})
                 and all(
-                    issue.startswith("Uncovered acceptance criteria in coverage-matrix.json:")
+                    issue.code == "acceptance_criteria_uncovered"
                     for issue in remaining
                 )
             ):
@@ -16374,7 +16450,7 @@ class RuntimeDaemon:
                     "Resolve the unmet criteria or missing test prerequisites, "
                     "then rerun verification."
                 )
-                result.metrics["validation_issues"] = remaining
+                _record_output_validation_issues(result, remaining)
                 self._record_testing_telemetry(
                     workspace_path, task, result, retries_used=max_retries
                 )
@@ -16385,35 +16461,22 @@ class RuntimeDaemon:
             scope_violations = [
                 issue
                 for issue in remaining
-                if issue.startswith("Verification work item modified requirement analysis assets:")
+                if issue.code == "verification_work_item_scope_violation"
             ]
-            critical_patterns = (
-                "missing",
-                "not found",
-                "is empty",
-                "not valid json",
-                "invalid acceptance criteria",
-                "case_evidence",
-                "test-evidence.json has no",
-                "evidence item",
-                "anchor not found",
-                "uncovered acceptance criteria",
-                "no p0 priority test cases",
-                "contains no test cases",
-            )
             critical_issues = [
-                iss for iss in remaining
-                if any(p in iss.lower() for p in critical_patterns)
+                issue for issue in remaining if issue.severity != "warning"
             ]
             qa_policy_violations = [
-                issue for issue in remaining if issue.startswith("qa_policy.")
+                issue for issue in remaining if issue.code.startswith("qa_policy.")
             ]
             planned_delivery_issues = [
                 issue for issue in remaining
-                if issue.startswith("Planned task file has no implementation evidence:")
+                if issue.code == "planned_task_incomplete"
             ]
+            audit_incomplete = result.metrics.get("implementation_audit_node_complete") is False
             blocking_issues = list(dict.fromkeys(
                 critical_issues + scope_violations + qa_policy_violations + planned_delivery_issues
+                + (remaining if audit_incomplete else [])
             ))
             if blocking_issues:
                 # Agent didn't produce required output — mark as failed
@@ -16430,6 +16493,12 @@ class RuntimeDaemon:
                 elif planned_delivery_issues:
                     result.failure_code = "planned_task_incomplete"
                     result.error = "; ".join(planned_delivery_issues[:3])
+                elif any(issue.code == "validation_unavailable" for issue in remaining):
+                    result.failure_code = "validation_unavailable"
+                    result.error = "; ".join(critical_issues[:3])
+                elif audit_incomplete:
+                    result.failure_code = "implementation_audit_incomplete"
+                    result.error = "; ".join(remaining[:3])
                 else:
                     result.failure_code = "validation_retry_exhausted"
                     result.error = (
@@ -16443,7 +16512,7 @@ class RuntimeDaemon:
                     "(proceeding anyway)",
                     len(remaining), max_retries, task.task_id,
                 )
-            result.metrics["validation_issues"] = remaining
+            _record_output_validation_issues(result, remaining)
         self._record_testing_telemetry(workspace_path, task, result, retries_used=max_retries)
         return result
 

{forgexa_cli-1.83.1 → forgexa_cli-1.84.1}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.83.1
+Version: 1.84.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.83.1 → forgexa_cli-1.84.1}/pyproject.toml

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