forgexa-cli 1.83.0__tar.gz → 1.84.0__tar.gz

{forgexa_cli-1.83.0 → forgexa_cli-1.84.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.83.0
+Version: 1.84.0
 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
@@ -37,9 +37,9 @@ Requires-Dist: socksio>=1.0.0; extra == "daemon"
 Command-line client and agent runtime for the [Forgexa](https://forgexa.net) platform.
 
 Communicates with the Forgexa server via REST API.
-Includes a built-in **daemon** with thirteen integrations: Claude Code, Codex, GitHub Copilot, Gemini CLI, OpenCode, Kimi Code, MiMo Code, Qwen Code, CodeBuddy, Qoder CLI, TraeCode CLI, ZCode, and DeepSeek Harness. Six standard candidates are automatically routed; seven require explicit selection. Harness (`deepseek`) is a developer preview for personal Runtimes/Desktop, pinned to 0.2.0-rc.2 and Node 22.19+ within 22.x or 24+. It owns a managed runtime profile with read-only external credentials, without copying personal settings. Shared pools/native Windows are blocked. After exact-build live acceptance, `forgexa agent approve-live deepseek` records an attestation; `forgexa check --agent deepseek --quick` avoids model calls, while normal `check` runs a potentially billable minimal task. See [global/local installation and limits](../documentation/guide/agent-installation.md#deepseek-harness-developer-preview).
+Includes a built-in **daemon** with fourteen integrations: Claude Code, Codex, GitHub Copilot, Gemini CLI, OpenCode, Kimi Code, MiMo Code, Qwen Code, CodeBuddy, Qoder CLI, TraeCode CLI, ZCode, DeepSeek Harness, and MiniMax Code. Six standard candidates are automatically routed; eight require explicit selection. MiniMax Code and Harness require owned personal Runtimes/Desktop and local build/profile acceptance. Harness retains its exact 0.2.0-rc.2 and read-only external credential requirements. See [installation and limits](../documentation/guide/agent-installation.md).
 
-MiniMax Code is an additional acceptance-pending personal preview, not part of the supported count above. Run `forgexa agent minimax-init` to create an empty private profile, authenticate in that profile, then use `forgexa agent minimax-status` and `forgexa agent approve-live minimax --evidence PATH` after real safety acceptance. Personal credentials are never copied; Agent-only approval is refused. See [MiniMax setup, evidence and recovery](../documentation/guide/agent-installation.md#minimax-code).
+MiniMax Code is included in that count, supporting reviewed 0.7.0 with 0.6.13 compatibility. Run `forgexa agent minimax-init` to create an empty private profile, authenticate there, then use `forgexa agent minimax-status` and `forgexa agent approve-live minimax --evidence PATH` after real local acceptance. Personal credentials are never copied; Agent-only approval is refused. `forgexa check --agent minimax --quick` is non-billable; normal `check` runs a potentially billable task. See [MiniMax setup, evidence and recovery](../documentation/guide/agent-installation.md#minimax-code).
 
 ## Installation
 

{forgexa_cli-1.83.0 → forgexa_cli-1.84.0}/README.md

@@ -3,9 +3,9 @@
 Command-line client and agent runtime for the [Forgexa](https://forgexa.net) platform.
 
 Communicates with the Forgexa server via REST API.
-Includes a built-in **daemon** with thirteen integrations: Claude Code, Codex, GitHub Copilot, Gemini CLI, OpenCode, Kimi Code, MiMo Code, Qwen Code, CodeBuddy, Qoder CLI, TraeCode CLI, ZCode, and DeepSeek Harness. Six standard candidates are automatically routed; seven require explicit selection. Harness (`deepseek`) is a developer preview for personal Runtimes/Desktop, pinned to 0.2.0-rc.2 and Node 22.19+ within 22.x or 24+. It owns a managed runtime profile with read-only external credentials, without copying personal settings. Shared pools/native Windows are blocked. After exact-build live acceptance, `forgexa agent approve-live deepseek` records an attestation; `forgexa check --agent deepseek --quick` avoids model calls, while normal `check` runs a potentially billable minimal task. See [global/local installation and limits](../documentation/guide/agent-installation.md#deepseek-harness-developer-preview).
+Includes a built-in **daemon** with fourteen integrations: Claude Code, Codex, GitHub Copilot, Gemini CLI, OpenCode, Kimi Code, MiMo Code, Qwen Code, CodeBuddy, Qoder CLI, TraeCode CLI, ZCode, DeepSeek Harness, and MiniMax Code. Six standard candidates are automatically routed; eight require explicit selection. MiniMax Code and Harness require owned personal Runtimes/Desktop and local build/profile acceptance. Harness retains its exact 0.2.0-rc.2 and read-only external credential requirements. See [installation and limits](../documentation/guide/agent-installation.md).
 
-MiniMax Code is an additional acceptance-pending personal preview, not part of the supported count above. Run `forgexa agent minimax-init` to create an empty private profile, authenticate in that profile, then use `forgexa agent minimax-status` and `forgexa agent approve-live minimax --evidence PATH` after real safety acceptance. Personal credentials are never copied; Agent-only approval is refused. See [MiniMax setup, evidence and recovery](../documentation/guide/agent-installation.md#minimax-code).
+MiniMax Code is included in that count, supporting reviewed 0.7.0 with 0.6.13 compatibility. Run `forgexa agent minimax-init` to create an empty private profile, authenticate there, then use `forgexa agent minimax-status` and `forgexa agent approve-live minimax --evidence PATH` after real local acceptance. Personal credentials are never copied; Agent-only approval is refused. `forgexa check --agent minimax --quick` is non-billable; normal `check` runs a potentially billable task. See [MiniMax setup, evidence and recovery](../documentation/guide/agent-installation.md#minimax-code).
 
 ## Installation
 

{forgexa_cli-1.83.0 → forgexa_cli-1.84.0}/forgexa_cli/__init__.py

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

{forgexa_cli-1.83.0 → forgexa_cli-1.84.0}/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"]
@@ -2681,6 +2727,7 @@ def _reject_nonfinite_json(value: str) -> None:
 
 
 MINIMAX_MAX_OUTPUT_BYTES = 4 * 1024 * 1024
+MINIMAX_SUPPORTED_VERSIONS = ("0.6.13", "0.7.0")
 MINIMAX_POLICY_VERSION = 1
 MINIMAX_ACCEPTANCE_CHECKS = (
     "start", "resume", "cancel", "timeout", "permissions", "filesystem",
@@ -2790,8 +2837,12 @@ def minimax_build_info(binary: str) -> dict:
     if root is None or node is None or not Path(node).is_file():
         raise RuntimeError("MiniMax requires a verifiable official package and Node installation")
     metadata = json.loads((root / "package.json").read_text(encoding="utf-8"))
-    if metadata.get("version") != "0.6.13":
-        raise RuntimeError("MiniMax requires the fixed 0.6.13 candidate; other builds need protocol review")
+    if metadata.get("version") not in MINIMAX_SUPPORTED_VERSIONS:
+        raise RuntimeError(
+            "MiniMax Code requires a protocol-reviewed version ("
+            + ", ".join(MINIMAX_SUPPORTED_VERSIONS)
+            + "); review other builds before use"
+        )
     env = deepseek_harness_probe_env()
     version = subprocess.run([node, "-p", "process.versions.node"], capture_output=True,
                              text=True, timeout=10, env=env)

{forgexa_cli-1.83.0 → forgexa_cli-1.84.0}/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.0"
+DAEMON_VERSION = "1.84.0"
 
 
 def _detect_client_type() -> str:
@@ -1772,11 +1772,17 @@ def _build_runtime_critic_prompt(
             ]
             parts.extend((
                 "## Approved Responsibility Boundaries", json.dumps(responsibilities, ensure_ascii=True, sort_keys=True),
+                "This is the designated final completeness review: recheck every approved task and criterion "
+                "assigned to this phase, including other contributors' unresolved source obligations. Only an "
+                "explicit server-owned deferred verification contract reserves later execution; required "
+                "prepared assets and in-scope checks remain mandatory."
+                if audit_contract.get("final_verification") else
                 "The feature's acceptance criteria remain mandatory, but they are not all obligations of this node. "
                 "Assess this task's approved responsibility and required in-scope checks. Execution and sign-off "
                 "assigned to other approved tasks stay pending under those owners; their absence alone does not "
                 "invalidate a complete source contribution. A task that owns runtime verification still requires "
-                "that evidence. Independently inspect committed source and checks; implementer claims are not "
+                "that evidence.",
+                "Independently inspect committed source and checks; implementer claims are not "
                 "independent proof. Missing assigned source, actual failed checks and genuine deviations remain blocking. "
                 "For unverified, name the exact assigned obligation and the unavailable source or check evidence, "
                 "rather than substituting the entire feature's unexecuted acceptance for this task's review.",
@@ -1879,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.
 
@@ -1892,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 = {
@@ -6692,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)
@@ -10022,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"]},
@@ -10448,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},
@@ -12480,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
@@ -13365,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(
@@ -13449,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
@@ -14210,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))
@@ -14223,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"
@@ -14230,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"
@@ -14242,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")
@@ -14266,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 "")
@@ -14425,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
@@ -14767,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 (
@@ -16214,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
                 )
@@ -16234,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
                 )
             ):
@@ -16245,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
                 )
@@ -16343,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, [
@@ -16357,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
                 )
             ):
@@ -16368,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
                 )
@@ -16379,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
@@ -16424,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 = (
@@ -16437,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.0 → forgexa_cli-1.84.0}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.83.0
+Version: 1.84.0
 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
@@ -37,9 +37,9 @@ Requires-Dist: socksio>=1.0.0; extra == "daemon"
 Command-line client and agent runtime for the [Forgexa](https://forgexa.net) platform.
 
 Communicates with the Forgexa server via REST API.
-Includes a built-in **daemon** with thirteen integrations: Claude Code, Codex, GitHub Copilot, Gemini CLI, OpenCode, Kimi Code, MiMo Code, Qwen Code, CodeBuddy, Qoder CLI, TraeCode CLI, ZCode, and DeepSeek Harness. Six standard candidates are automatically routed; seven require explicit selection. Harness (`deepseek`) is a developer preview for personal Runtimes/Desktop, pinned to 0.2.0-rc.2 and Node 22.19+ within 22.x or 24+. It owns a managed runtime profile with read-only external credentials, without copying personal settings. Shared pools/native Windows are blocked. After exact-build live acceptance, `forgexa agent approve-live deepseek` records an attestation; `forgexa check --agent deepseek --quick` avoids model calls, while normal `check` runs a potentially billable minimal task. See [global/local installation and limits](../documentation/guide/agent-installation.md#deepseek-harness-developer-preview).
+Includes a built-in **daemon** with fourteen integrations: Claude Code, Codex, GitHub Copilot, Gemini CLI, OpenCode, Kimi Code, MiMo Code, Qwen Code, CodeBuddy, Qoder CLI, TraeCode CLI, ZCode, DeepSeek Harness, and MiniMax Code. Six standard candidates are automatically routed; eight require explicit selection. MiniMax Code and Harness require owned personal Runtimes/Desktop and local build/profile acceptance. Harness retains its exact 0.2.0-rc.2 and read-only external credential requirements. See [installation and limits](../documentation/guide/agent-installation.md).
 
-MiniMax Code is an additional acceptance-pending personal preview, not part of the supported count above. Run `forgexa agent minimax-init` to create an empty private profile, authenticate in that profile, then use `forgexa agent minimax-status` and `forgexa agent approve-live minimax --evidence PATH` after real safety acceptance. Personal credentials are never copied; Agent-only approval is refused. See [MiniMax setup, evidence and recovery](../documentation/guide/agent-installation.md#minimax-code).
+MiniMax Code is included in that count, supporting reviewed 0.7.0 with 0.6.13 compatibility. Run `forgexa agent minimax-init` to create an empty private profile, authenticate there, then use `forgexa agent minimax-status` and `forgexa agent approve-live minimax --evidence PATH` after real local acceptance. Personal credentials are never copied; Agent-only approval is refused. `forgexa check --agent minimax --quick` is non-billable; normal `check` runs a potentially billable task. See [MiniMax setup, evidence and recovery](../documentation/guide/agent-installation.md#minimax-code).
 
 ## Installation
 

{forgexa_cli-1.83.0 → forgexa_cli-1.84.0}/pyproject.toml

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

{forgexa_cli-1.83.0 → forgexa_cli-1.84.0}/tests/test_check_command.py

@@ -67,7 +67,7 @@ def test_minimax_live_approval_forwards_bound_evidence(tmp_path, monkeypatch, ca
 
     def approve(binary, document):
         captured.append((binary, document))
-        return {"fingerprint": "bound-build", "version": "0.6.13"}
+        return {"fingerprint": "bound-build", "version": "0.7.0"}
 
     monkeypatch.setattr(agent_core, "approve_minimax_build", approve)
     main.cmd_agent_approve_live(SimpleNamespace(agent_id="minimax", binary="/fake/mcode", evidence=str(path)))
@@ -77,7 +77,7 @@ def test_minimax_live_approval_forwards_bound_evidence(tmp_path, monkeypatch, ca
 
 def test_minimax_quick_check_reports_pending_without_live_calls(monkeypatch, capsys):
     monkeypatch.setattr(daemon.AgentDiscovery, "AGENT_REGISTRY", {"minimax": {"commands": ["mcode"], "detect": "mcode --version"}})
-    agent = _agent("minimax", "0.6.13")
+    agent = _agent("minimax", "0.7.0")
     agent.min_version_ok = False
     agent.version_warning = "MiniMax build/profile acceptance missing"
     monkeypatch.setattr(daemon.AgentDiscovery, "discover", AsyncMock(return_value=[agent]))
@@ -97,7 +97,7 @@ async def test_minimax_live_check_discloses_profile_provider_and_budget(tmp_path
         "root": tmp_path / "profile", "policy": {"provider": "dedicated", "region": "cn"},
     })
     manager = SimpleNamespace(run_agent=AsyncMock(return_value=SimpleNamespace(status="success")))
-    assert await main._live_check_agent(manager, _agent("minimax", "0.6.13"), 15) == (True, "")
+    assert await main._live_check_agent(manager, _agent("minimax", "0.7.0"), 15) == (True, "")
     output = capsys.readouterr().err
     assert "profile=profile" in output and "provider=dedicated" in output
     assert "timeout=15s" in output and "max_steps=60" in output and "charges" in output