forgexa-cli 1.86.4__tar.gz → 1.87.1__tar.gz

{forgexa_cli-1.86.4 → forgexa_cli-1.87.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.86.4
+Version: 1.87.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.86.4 → forgexa_cli-1.87.1}/forgexa_cli/__init__.py

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

{forgexa_cli-1.86.4 → forgexa_cli-1.87.1}/forgexa_cli/agent_core.py

@@ -782,7 +782,48 @@ def lock_provenance_projection(path: str, source: str) -> str | None:
     }, ensure_ascii=True, sort_keys=True, separators=(",", ":"))
 
 
-def implementation_delivery_contract(node_type: str, task_input: dict, *, supported: bool, graph_type: str = "execution") -> dict | None:
+EXECUTION_DELIVERY_WARNING_CODES = frozenset({
+    "partial_delivery", "dependency_authorization", "dependency_network", "dependency_unavailable",
+    "environment_unavailable", "verification_pending", "source_evidence_limited", "qa_handoff_ready",
+})
+
+
+def is_frozen_analysis_path(value: str) -> bool:
+    path = PurePosixPath(value.replace("\\", "/"))
+    if path.is_absolute() or ".." in path.parts:
+        return False
+    parts = path.parts
+    if len(parts) < 4 or parts[0] != "docs":
+        return False
+    if parts[1] == "requirements":
+        return len(parts) == 4 or parts[3] == "analysis"
+    return parts[1] == "workitems" and parts[3] == "analysis"
+
+
+def uses_necessary_execution_checks(node_type: str, task_input: dict, graph_type: str | None = None) -> bool:
+    actual_graph_type = graph_type if graph_type is not None else task_input.get("graph_type") or "execution"
+    return (
+        isinstance(node_type, str) and node_type in {"design", "coding", "testing", "review", "fix"}
+        and isinstance(actual_graph_type, str) and actual_graph_type in {"execution", "implementation", "fix"}
+        and not task_input.get("verification_work_item")
+        and task_input.get("execution_actor") != "human"
+    )
+
+
+def implementation_validation_issue_blocks(node_type: str, task_input: dict, code: str) -> bool:
+    if not uses_necessary_execution_checks(node_type, task_input):
+        return True
+    return code in {
+        "approved_plan_baseline_modified", "verification_work_item_scope_violation", "remediation_scope_violation",
+        "qa_policy.source_test_level_disabled", "qa_policy.configuration_invalid", "qa_policy.validation_unavailable",
+        "qa_policy.source_change_inventory_unavailable",
+        "uncommitted_workspace_changes", "forbidden_branch_merge",
+    }
+
+
+def implementation_delivery_contract(node_type: str, task_input: dict, *, supported: bool, graph_type: str = "execution", protocol_version: int = 1, qa_handoff_supported: bool = False) -> dict | None:
+    if type(protocol_version) is not int or protocol_version not in (1, 2):
+        return None
     if supported is not True or not isinstance(node_type, str) or not isinstance(graph_type, str) or node_type not in {"design", "coding", "testing", "review", "fix"} or graph_type not in {"execution", "implementation", "fix"}:
         return None
     if task_input.get("verification_work_item") or task_input.get("execution_actor") == "human":
@@ -796,9 +837,11 @@ def implementation_delivery_contract(node_type: str, task_input: dict, *, suppor
     task_id = (baseline.get("task") or {}).get("id")
     if not isinstance(task_id, str) or not task_id:
         return None
-    contract = {"version": 1, "mode": "execution_and_artifacts", "node_type": node_type, "graph_type": graph_type,
+    contract = {"version": protocol_version, "mode": "execution_and_artifacts", "node_type": node_type, "graph_type": graph_type,
                 "task_id": task_id, "baseline_fingerprint": baseline.get("fingerprint"),
                 "qa_policy": task_input.get("qa_test_level_policy_snapshot"), "change_scope": task_input.get("change_scope")}
+    if protocol_version == 2 and qa_handoff_supported is True and node_type in {"testing", "review"}:
+        contract["qa_handoff"] = True
     contract["fingerprint"] = hashlib.sha256(json.dumps(contract, sort_keys=True, ensure_ascii=True, separators=(",", ":")).encode()).hexdigest()
     return contract
 
@@ -807,27 +850,73 @@ def uses_controlled_delivery(task_input: dict) -> bool:
     contract = task_input.get("implementation_delivery")
     if not isinstance(contract, dict):
         return False
-    expected = implementation_delivery_contract(contract.get("node_type"), task_input, supported=True, graph_type=contract.get("graph_type"))
+    if not uses_necessary_execution_checks(contract.get("node_type"), task_input):
+        return False
+    expected = implementation_delivery_contract(contract.get("node_type"), task_input, supported=True,
+        graph_type=contract.get("graph_type"), protocol_version=contract.get("version"),
+        qa_handoff_supported=contract.get("qa_handoff") is True)
     return expected is not None and contract == expected
 
 
 def assess_execution_delivery(contract: dict, report: object) -> dict:
-    if not isinstance(report, dict) or type(report.get("version")) is not int or report["version"] != 1:
+    if not isinstance(report, dict) or type(report.get("version")) is not int or report["version"] not in (1, 2):
         return {"report_valid": False, "status": "unknown", "issues": ["Execution delivery declaration is missing or invalid"]}
-    if set(report) != {"version", "contract_fingerprint", "status"} or report.get("contract_fingerprint") != contract.get("fingerprint") or not isinstance(report.get("status"), str) or report["status"] not in {"complete", "partial", "blocked"}:
+    if report["version"] != contract.get("version") or report.get("contract_fingerprint") != contract.get("fingerprint") or redact_execution_delivery(report) is None:
         return {"report_valid": False, "status": "unknown", "issues": ["Execution delivery declaration does not match the current contract"]}
-    return {"report_valid": True, "status": report["status"], "issues": []}
+    assessment = {"report_valid": True, "status": report["status"], "issues": []}
+    if "handoff" in report:
+        if contract.get("qa_handoff") is not True or contract.get("node_type") not in {"testing", "review"}:
+            return {"report_valid": False, "status": "unknown", "issues": ["QA handoff is not enabled for this execution contract"]}
+        assessment["handoff_ready"] = True
+    return assessment
+
+
+def execution_delivery_allows_progress(contract: dict, assessment: dict) -> bool:
+    return assessment.get("report_valid") is True and (
+        assessment.get("status") == "complete" or contract.get("version") == 2 and (
+            assessment.get("status") == "partial" or contract.get("qa_handoff") is True and assessment.get("handoff_ready") is True
+        )
+    )
+
+
+def execution_delivery_warnings(contract: dict, report: object) -> list[str]:
+    if not isinstance(report, dict) or contract.get("version") != 2 or not assess_execution_delivery(contract, report)["report_valid"]:
+        return []
+    warnings = list(report.get("warnings") or (["partial_delivery"] if report["status"] == "partial" else []))
+    if "handoff" in report and "verification_pending" not in warnings:
+        warnings.append("verification_pending")
+    if "handoff" in report and "qa_handoff_ready" not in warnings:
+        warnings.append("qa_handoff_ready")
+    return warnings
 
 
 def redact_execution_delivery(report: object) -> dict | None:
-    if not isinstance(report, dict):
+    if not isinstance(report, dict) or type(report.get("version")) is not int or report["version"] not in (1, 2):
+        return None
+    required = {"version", "contract_fingerprint", "status"}
+    allowed = required | ({"warnings", "handoff"} if report["version"] == 2 else set())
+    if not required <= set(report) <= allowed or not isinstance(report.get("contract_fingerprint"), str) or not re.fullmatch(r"[0-9a-f]{64}", report["contract_fingerprint"]):
+        return None
+    if not isinstance(report.get("status"), str) or report["status"] not in {"complete", "partial", "blocked"}:
         return None
-    return {"version": report.get("version") if type(report.get("version")) is int else 0,
-            "contract_fingerprint": report.get("contract_fingerprint") if isinstance(report.get("contract_fingerprint"), str) and re.fullmatch(r"[0-9a-f]{64}", report["contract_fingerprint"]) else "",
-            "status": report.get("status") if report.get("status") in ("complete", "partial", "blocked") else "unknown"}
+    warnings = report.get("warnings", [])
+    if not isinstance(warnings, list) or len(warnings) > len(EXECUTION_DELIVERY_WARNING_CODES) or any(
+        not isinstance(code, str) or code not in EXECUTION_DELIVERY_WARNING_CODES for code in warnings
+    ) or len(set(warnings)) != len(warnings):
+        return None
+    if "qa_handoff_ready" in warnings and "handoff" not in report:
+        return None
+    redacted = {key: report[key] for key in ("version", "contract_fingerprint", "status")}
+    if "warnings" in report:
+        redacted["warnings"] = list(warnings)
+    if "handoff" in report:
+        if not isinstance(report["handoff"], dict) or report["handoff"] != {"target": "human_qa", "status": "ready"}:
+            return None
+        redacted["handoff"] = dict(report["handoff"])
+    return redacted
 
 
-def task_review_policy(node_type: str, task_input: dict, *, changed_files: list[str] | None = None, policy_supported: bool = True) -> dict:
+def task_review_policy(node_type: str, task_input: dict, *, changed_files: list[str] | None = None, policy_supported: bool = True, graph_type: str | None = None) -> dict:
     baseline = task_input.get("approved_plan_baseline")
     reasons = []
     if policy_supported is not True:
@@ -863,8 +952,8 @@ def task_review_policy(node_type: str, task_input: dict, *, changed_files: list[
     if node_type in {"coding", "fix"} and files and all(path.startswith("docs/") for path in files):
         reasons.append("scope_unknown")
     decision = {"version": 1, "mode": "required" if reasons else "advisory", "reasons": sorted(set(reasons))}
-    if uses_controlled_delivery(task_input):
-        decision.update(mode="advisory", decision_scope="controlled_delivery", delivery_contract=task_input["implementation_delivery"]["fingerprint"])
+    if uses_necessary_execution_checks(node_type, task_input, graph_type):
+        decision.update(mode="advisory", decision_scope="necessary_execution")
     decision["fingerprint"] = hashlib.sha256(json.dumps({
         **decision, "baseline_fingerprint": fingerprint,
         "qa_policy": str(task_input.get("qa_test_level_policy_fingerprint") or ""),
@@ -874,7 +963,7 @@ def task_review_policy(node_type: str, task_input: dict, *, changed_files: list[
 
 
 def review_blocks_completion(policy: dict, assessment: dict) -> bool:
-    if policy.get("decision_scope") == "controlled_delivery":
+    if policy.get("decision_scope") in {"controlled_delivery", "necessary_execution"}:
         return False
     return not assessment.get("node_complete", assessment.get("status") == "conformant") and (
         policy.get("mode") != "advisory" or assessment.get("status") == "deviation"

{forgexa_cli-1.86.4 → forgexa_cli-1.87.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.86.4"
+DAEMON_VERSION = "1.87.1"
 
 
 def _detect_client_type() -> str:
@@ -1927,6 +1927,22 @@ def _output_validation_issue(issue: str) -> _OutputValidationIssue:
     return _OutputValidationIssue("output_validation_failed", issue)
 
 
+def _implementation_validation_issues(task: "TaskInfo", result: "TaskResult", issues: list[str]) -> list[_OutputValidationIssue]:
+    normalized = [_output_validation_issue(issue) for issue in issues]
+    if not agent_core.uses_necessary_execution_checks(task.node_type, task.input_data or {}):
+        return normalized
+    normalized = [issue if agent_core.implementation_validation_issue_blocks(task.node_type, task.input_data or {}, issue.code)
+        else _OutputValidationIssue(issue.code, str(issue), "warning") for issue in normalized]
+    if any(issue.severity == "warning" for issue in normalized):
+        warnings = list(result.metrics.get("completion_warnings") or [])
+        if "partial_delivery" not in warnings:
+            warnings.append("partial_delivery")
+        result.metrics["completion_warnings"] = warnings
+    if result.status in {"success", "partial"} and all(issue.severity == "warning" for issue in normalized):
+        result.metrics.pop("failure_domain", None)
+    return normalized
+
+
 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"] = [
@@ -2601,14 +2617,8 @@ def _get_analysis_outputs_for_type(req_type: str, change_scope: str = "standard"
 
 
 def _is_requirement_analysis_path(path: str) -> bool:
-    """Recognize v1 and v2 requirement analysis paths without backend imports."""
-    normalized = str(path or "").replace("\\", "/").lstrip("./")
-    return (
-        normalized.startswith("docs/requirements/")
-        and "/implement/" not in normalized
-        and "/bugfix/" not in normalized
-        and "/delivery/" not in normalized
-    )
+    """Recognize frozen analysis assets in both supported layouts."""
+    return agent_core.is_frozen_analysis_path(str(path or ""))
 
 
 # Mirrors type_workflow_profiles.py — maps req type to the expected design-phase output filename.
@@ -6489,7 +6499,7 @@ class ProcessManager:
         stderr = result.stderr or ""
         error = result.error or ""
 
-        if result.status != "success":
+        if result.status not in {"success", "partial"}:
             if result.exit_code == 0:
                 return "\n".join(part for part in (stderr, error) if part)
             return "\n".join(part for part in (stderr, error, stdout[-3000:]) if part)
@@ -10223,7 +10233,8 @@ class ServerConnection:
                 "task_delivery": {"protocol_version": 1},
                 "verification_recovery": {"protocol_version": 1},
                 "task_review_policy": {"protocol_version": 1},
-                "implementation_delivery": {"protocol_version": 1},
+                "implementation_delivery": {"protocol_version": 2, "qa_handoff_version": 1},
+                "execution_validation": {"protocol_version": 1, "mode": "necessary"},
                 "recording_suggestions": {"protocol_version": 1, "isolated_workspace": True},
                 "task_attachment_staging": {"protocol_version": 1, "runtime_proxy": True, "image_agents": ["claude"]},
             },
@@ -10652,7 +10663,8 @@ class ServerConnection:
                     "task_delivery": {"protocol_version": 1},
                     "verification_recovery": {"protocol_version": 1},
                     "task_review_policy": {"protocol_version": 1},
-                    "implementation_delivery": {"protocol_version": 1},
+                    "implementation_delivery": {"protocol_version": 2, "qa_handoff_version": 1},
+                    "execution_validation": {"protocol_version": 1, "mode": "necessary"},
                     "recording_suggestions": {"protocol_version": 1, "isolated_workspace": True},
                     "local_evidence": {"protocol_version": 1, "structured_summary": True},
                     "task_attachment_staging": {"protocol_version": 1, "runtime_proxy": True, "image_agents": ["claude"]},
@@ -13814,7 +13826,7 @@ class RuntimeDaemon:
                     logger.exception("Final QA source-test validation error for task %s", task.task_id)
                 result.metrics["validation_retries_used"] = previous_validation_retries
 
-            if result.failure_code == "validation_retry_exhausted" and not is_local_bind and any(
+            if result.failure_code in {"validation_retry_exhausted", "qa_policy.source_test_level_disabled", "qa_policy.source_change_inventory_unavailable", "qa_policy.validation_unavailable"} and not is_local_bind and any(
                 str(issue).startswith((
                     "qa_policy.source_test_level_disabled",
                     "qa_policy.source_change_inventory_unavailable",
@@ -13966,7 +13978,7 @@ class RuntimeDaemon:
 
             review_policy = agent_core.task_review_policy(task.node_type, task.input_data or {}, changed_files=result.files_changed)
             result.metrics["task_review_policy"] = review_policy
-            if result.status == "success" and (task.critic_review_required or review_policy["mode"] == "required" and isinstance((task.input_data or {}).get("approved_plan_baseline"), dict)):
+            if result.status == "success" and not agent_core.uses_necessary_execution_checks(task.node_type, task.input_data or {}) and (task.critic_review_required or review_policy["mode"] == "required" and isinstance((task.input_data or {}).get("approved_plan_baseline"), dict)):
                 await self._collect_task_delivery_git(
                     task, workspace_path, result, attempt_before_sha=node_before_sha,
                 )
@@ -14637,16 +14649,23 @@ class RuntimeDaemon:
         issues: list[str] = []
         node_type = task.node_type
         input_data = task.input_data or {}
+        necessary_checks = agent_core.uses_necessary_execution_checks(node_type, input_data)
+        original_execution = (result.status, result.failure_code, result.error)
         controlled_delivery = agent_core.uses_controlled_delivery(input_data)
         if controlled_delivery:
             report = agent_core.extract_execution_delivery(_daemon_extract_agent_output(str(result.metrics.get("actual_agent") or getattr(task, "agent_type", "") or ""), result.stdout))
             delivery = agent_core.assess_execution_delivery(input_data["implementation_delivery"], report)
             result.metrics["execution_delivery"] = agent_core.redact_execution_delivery(report)
             result.metrics["execution_delivery_valid"] = delivery["report_valid"]
-            if not delivery["report_valid"]:
+            result.metrics.pop("completion_warnings", None)
+            if not delivery["report_valid"] and (report is not None or not necessary_checks):
                 issues.extend(_OutputValidationIssue("validation_unavailable", message) for message in delivery["issues"])
-            elif delivery["status"] != "complete":
+            elif delivery["report_valid"] and not agent_core.execution_delivery_allows_progress(input_data["implementation_delivery"], delivery):
                 issues.append(_OutputValidationIssue("planned_task_incomplete", "Agent explicitly reported incomplete execution delivery"))
+            else:
+                warnings = agent_core.execution_delivery_warnings(input_data["implementation_delivery"], report)
+                if warnings:
+                    result.metrics["completion_warnings"] = warnings
         fix_context = input_data.get("fix_context")
         if node_type == "testing" or (
             node_type == "fix" and input_data.get("task") == "phase_remediation_fix"
@@ -14682,7 +14701,7 @@ class RuntimeDaemon:
             if failure_domain is not None and not controlled_delivery:
                 result.metrics["failure_domain"] = failure_domain
             result.metrics["implementation_audit_node_complete"] = bool(
-                controlled_delivery or audit_result["report_valid"] and audit_result["node_complete"]
+                audit_result["report_valid"] and audit_result["node_complete"]
             )
             result.metrics["implementation_audit_subject_blocked"] = bool(
                 not controlled_delivery and audit_result["report_valid"] and not audit_result["node_complete"]
@@ -14698,7 +14717,7 @@ class RuntimeDaemon:
                     f"{request['task_id']}: {request['reason']}" for request in requests[:3]
                 )
                 issues.append(_OutputValidationIssue(result.failure_code, result.error))
-            elif not controlled_delivery and (not audit_result["report_valid"] or not audit_result["node_complete"]):
+            elif not controlled_delivery and (audit_report is not None or not necessary_checks) and (not audit_result["report_valid"] or not audit_result["node_complete"]):
                 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",
@@ -15239,8 +15258,12 @@ class RuntimeDaemon:
                                         ac for ac in ac_list
                                         if ac["status"] != "covered" and ac["id"] not in pending
                                     ]
-                                    if uncovered and controlled_delivery:
+                                    if uncovered and (controlled_delivery or necessary_checks):
                                         result.metrics["business_acceptance"] = {"status": "pending_human_qa", "criteria": [ac["id"] for ac in uncovered]}
+                                        warnings = list(result.metrics.get("completion_warnings") or [])
+                                        if "verification_pending" not in warnings:
+                                            warnings.append("verification_pending")
+                                        result.metrics["completion_warnings"] = warnings
                                     elif uncovered:
                                         ids = ", ".join(ac["id"] for ac in uncovered[:20])
                                         if len(uncovered) > 20:
@@ -15273,7 +15296,9 @@ class RuntimeDaemon:
                     if not report_path.exists():
                         issues.append(f"test-report.md not found in {doc_dir or 'workspace root'}")
 
-        return issues
+        if necessary_checks and result.failure_code == "implementation_plan_revision_required" and original_execution[0] in {"success", "partial"}:
+            result.status, result.failure_code, result.error = original_execution
+        return _implementation_validation_issues(task, result, issues)
 
     def _merge_job_index_path(self) -> Path:
         return Path(self.workspaces_root) / "deploy-merge-jobs.json"
@@ -16693,13 +16718,24 @@ class RuntimeDaemon:
                 before_sha=before_sha,
                 preserved_paths=preserved_paths,
             )
-            issues = [_output_validation_issue(issue) for issue in self._validate_outputs(workspace_path, task, result)]
+            issues = _implementation_validation_issues(task, result, 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(_output_validation_issue(issue) for issue in inventory_issues)
+            if agent_core.uses_necessary_execution_checks(task.node_type, task.input_data or {}):
+                issues = _implementation_validation_issues(task, result, issues)
+                blocking = [issue for issue in issues if issue.severity != "warning"]
+                if blocking and result.status in {"success", "partial"}:
+                    result.status = "failed"
+                    result.failure_code = blocking[0].code
+                    result.error = "; ".join(blocking[:3])
+                _record_output_validation_issues(result, issues)
+                result.metrics["execution_validation_mode"] = "necessary"
+                self._record_testing_telemetry(workspace_path, task, result, retries_used=attempt)
+                return result
             advisory_issues = [issue for issue in issues if issue.severity == "warning"]
             issues = [issue for issue in issues if issue.severity != "warning"]
             if not issues:
@@ -16719,7 +16755,8 @@ class RuntimeDaemon:
             if (
                 agent_core.uses_controlled_delivery(task.input_data or {})
                 and result.metrics.get("execution_delivery_valid") is True
-                and (result.metrics.get("execution_delivery") or {}).get("status") in {"partial", "blocked"}
+                and not agent_core.execution_delivery_allows_progress(task.input_data["implementation_delivery"],
+                    agent_core.assess_execution_delivery(task.input_data["implementation_delivery"], result.metrics.get("execution_delivery")))
             ):
                 result.status = "failed"
                 result.failure_code = "planned_task_incomplete"
@@ -16858,13 +16895,24 @@ class RuntimeDaemon:
             before_sha=before_sha,
             preserved_paths=preserved_paths,
         )
-        remaining = [_output_validation_issue(issue) for issue in self._validate_outputs(workspace_path, task, result)]
+        remaining = _implementation_validation_issues(task, result, 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(_output_validation_issue(issue) for issue in inventory_issues)
+        if agent_core.uses_necessary_execution_checks(task.node_type, task.input_data or {}):
+            remaining = _implementation_validation_issues(task, result, remaining)
+            blocking = [issue for issue in remaining if issue.severity != "warning"]
+            if blocking and result.status in {"success", "partial"}:
+                result.status = "failed"
+                result.failure_code = blocking[0].code
+                result.error = "; ".join(blocking[:3])
+            _record_output_validation_issues(result, remaining)
+            result.metrics["execution_validation_mode"] = "necessary"
+            self._record_testing_telemetry(workspace_path, task, result, retries_used=max_retries)
+            return result
         if remaining:
             if getattr(task, "workspace_resolution", None) == "local_bind":
                 _append_local_bind_output_log(task.task_id, [

{forgexa_cli-1.86.4 → forgexa_cli-1.87.1}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.86.4
+Version: 1.87.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.86.4 → forgexa_cli-1.87.1}/pyproject.toml

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