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

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

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

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

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

@@ -309,6 +309,14 @@ def requires_task_delivery_baseline(node_type: str, task_input: dict) -> bool:
 
 
 def extract_implementation_audit(text: str) -> dict | None:
+    return extract_agent_report(text, "implementation_audit")
+
+
+def extract_execution_delivery(text: str) -> dict | None:
+    return extract_agent_report(text, "execution_delivery")
+
+
+def extract_agent_report(text: str, field: str) -> dict | None:
     """Read the last complete audit envelope from mixed assistant output."""
     decoder = json.JSONDecoder()
     offset = 0
@@ -323,11 +331,11 @@ def extract_implementation_audit(text: str) -> dict | None:
         except json.JSONDecodeError:
             offset = start + 1
             continue
-        if isinstance(value, dict) and "implementation_audit" in value:
-            report = value["implementation_audit"] if isinstance(value["implementation_audit"], dict) else None
+        if isinstance(value, dict) and field in value:
+            report = value[field] if isinstance(value[field], dict) else None
             report_end = end
         offset = end
-    if '"implementation_audit"' in text[report_end:]:
+    if json.dumps(field) in text[report_end:]:
         return None
     return report
 
@@ -774,6 +782,51 @@ 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:
+    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":
+        return None
+    recovery = task_input.get("verification_recovery")
+    if isinstance(recovery, dict) and recovery.get("mode") == "review_only" and not task_input.get("implementation_delivery"):
+        return None
+    baseline = task_input.get("approved_plan_baseline")
+    if not isinstance(baseline, dict) or assess_approved_plan_conformance(baseline, None).get("reason") == "approved_plan_baseline_invalid":
+        return None
+    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,
+                "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")}
+    contract["fingerprint"] = hashlib.sha256(json.dumps(contract, sort_keys=True, ensure_ascii=True, separators=(",", ":")).encode()).hexdigest()
+    return contract
+
+
+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"))
+    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:
+        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"}:
+        return {"report_valid": False, "status": "unknown", "issues": ["Execution delivery declaration does not match the current contract"]}
+    return {"report_valid": True, "status": report["status"], "issues": []}
+
+
+def redact_execution_delivery(report: object) -> dict | None:
+    if not isinstance(report, dict):
+        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"}
+
+
 def task_review_policy(node_type: str, task_input: dict, *, changed_files: list[str] | None = None, policy_supported: bool = True) -> dict:
     baseline = task_input.get("approved_plan_baseline")
     reasons = []
@@ -810,6 +863,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"])
     decision["fingerprint"] = hashlib.sha256(json.dumps({
         **decision, "baseline_fingerprint": fingerprint,
         "qa_policy": str(task_input.get("qa_test_level_policy_fingerprint") or ""),
@@ -819,6 +874,8 @@ 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":
+        return False
     return not assessment.get("node_complete", assessment.get("status") == "conformant") and (
         policy.get("mode") != "advisory" or assessment.get("status") == "deviation"
     )
@@ -2168,6 +2225,7 @@ def _extract_output_signals(text: str, usage_source: object = None) -> dict[str,
     contains words like 'rate limit', 'connection error', 'API error', etc.
     (e.g. implementing a rate-limiter feature, or documenting error codes).
     """
+    terminal_status = None
     has_turn_completed = False
     has_turn_failed = False
     has_result = False
@@ -2193,10 +2251,12 @@ def _extract_output_signals(text: str, usage_source: object = None) -> dict[str,
         ev_type = str(data.get("type", ""))
 
         if ev_type == "turn.completed":
+            terminal_status = "success"
             has_turn_completed = True
             has_turn_failed = False
             error_messages.clear()
         elif ev_type == "turn.failed":
+            terminal_status = "failed"
             has_turn_failed = True
             err = data.get("error") or {}
             if isinstance(err, dict):
@@ -2229,19 +2289,23 @@ def _extract_output_signals(text: str, usage_source: object = None) -> dict[str,
                 if type(raw_exit_code) is not int and not (
                     isinstance(raw_exit_code, str) and re.fullmatch(r"[+-]?[0-9]+", raw_exit_code)
                 ):
+                    terminal_status = "failed"
                     error_messages.append("Agent result has an invalid exitCode")
                     continue
                 exit_code = int(raw_exit_code)
                 if exit_code == 0:
+                    terminal_status = "success"
                     has_result = True
                     has_meaningful_content = True
                     has_turn_failed = False
                     error_messages.clear()
                 else:
+                    terminal_status = "failed"
                     error_messages.append(f"Copilot exited with code {exit_code}")
             else:
                 result_text = str(data.get("result", "") or "")
                 if data.get("is_error"):
+                    terminal_status = "failed"
                     raw_errors = data.get("errors")
                     if isinstance(raw_errors, list):
                         err_text = "; ".join(
@@ -2269,8 +2333,10 @@ def _extract_output_signals(text: str, usage_source: object = None) -> dict[str,
                     # rather than the agent's actual work output.
                     no_api_call = not has_agent_token_usage(data, usage_source) and not has_assistant_events
                     if no_api_call and result_text:
+                        terminal_status = "failed"
                         error_messages.append(result_text)
                     else:
+                        terminal_status = "success"
                         has_result = True
                         has_meaningful_content = True
                         has_turn_failed = False
@@ -2314,6 +2380,7 @@ def _extract_output_signals(text: str, usage_source: object = None) -> dict[str,
             has_meaningful_content = True
 
     return {
+        "terminal_status": "failed" if error_messages or has_turn_failed else terminal_status,
         "has_turn_completed": has_turn_completed,
         "has_turn_failed": has_turn_failed,
         "has_result": has_result,

{forgexa_cli-1.86.2 → forgexa_cli-1.86.4}/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.2"
+DAEMON_VERSION = "1.86.4"
 
 
 def _detect_client_type() -> str:
@@ -6502,6 +6502,8 @@ class ProcessManager:
         signals = agent_core._extract_output_signals(
             "\n".join(part for part in (stdout, stderr) if part), result.metrics,
         )
+        if result.exit_code == 0 and not error and (signals.get("terminal_status") == "success" or result.has_verified_completion is True and signals.get("terminal_status") != "failed"):
+            error_channels = ""
         if not has_token_usage and ProcessManager._should_scan_short_success_stdout(stdout, signals):
             error_channels = "\n".join(filter(None, [error_channels, stdout.strip()]))
         # Always include structured error messages parsed from JSONL stream events
@@ -10221,6 +10223,7 @@ class ServerConnection:
                 "task_delivery": {"protocol_version": 1},
                 "verification_recovery": {"protocol_version": 1},
                 "task_review_policy": {"protocol_version": 1},
+                "implementation_delivery": {"protocol_version": 1},
                 "recording_suggestions": {"protocol_version": 1, "isolated_workspace": True},
                 "task_attachment_staging": {"protocol_version": 1, "runtime_proxy": True, "image_agents": ["claude"]},
             },
@@ -10649,6 +10652,7 @@ class ServerConnection:
                     "task_delivery": {"protocol_version": 1},
                     "verification_recovery": {"protocol_version": 1},
                     "task_review_policy": {"protocol_version": 1},
+                    "implementation_delivery": {"protocol_version": 1},
                     "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"]},
@@ -11438,6 +11442,20 @@ class RuntimeDaemon:
         if managed_policy is not _MANAGED_WSL_POLICY:
             raise ValueError("wsl_runtime_entry_not_admitted")
         self.managed_policy = managed_policy
+        # Ops-tunable staging budget. Keep aligned with the server's
+        # MAX_ANALYSIS_ATTACHMENT_COUNT: the server only admits analysis
+        # selections within its own budget, so a lower value here would
+        # reject tasks the server considered valid.
+        try:
+            self._TASK_ATTACHMENT_MAX_COUNT = max(
+                1, int(os.environ.get("DAEMON_TASK_ATTACHMENT_MAX_COUNT", self._TASK_ATTACHMENT_MAX_COUNT))
+            )
+        except ValueError:
+            logger.warning(
+                "Ignoring invalid DAEMON_TASK_ATTACHMENT_MAX_COUNT=%r; using %d",
+                os.environ.get("DAEMON_TASK_ATTACHMENT_MAX_COUNT"),
+                self._TASK_ATTACHMENT_MAX_COUNT,
+            )
         # Compute stable hardware fingerprint from machine-id / MAC address.
         # This allows the server to identify the same physical machine even when
         # its IP address changes (e.g., DHCP reassignment, home vs. office).
@@ -14619,6 +14637,16 @@ class RuntimeDaemon:
         issues: list[str] = []
         node_type = task.node_type
         input_data = task.input_data or {}
+        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"]:
+                issues.extend(_OutputValidationIssue("validation_unavailable", message) for message in delivery["issues"])
+            elif delivery["status"] != "complete":
+                issues.append(_OutputValidationIssue("planned_task_incomplete", "Agent explicitly reported incomplete execution delivery"))
         fix_context = input_data.get("fix_context")
         if node_type == "testing" or (
             node_type == "fix" and input_data.get("task") == "phase_remediation_fix"
@@ -14651,18 +14679,18 @@ class RuntimeDaemon:
                 result.observations.append({"type": "implementation_audit", "data": audit_report})
             audit_result = agent_core.assess_implementation_audit(audit_contract, audit_report)
             failure_domain = agent_core.implementation_audit_failure_domain(audit_contract, audit_result)
-            if failure_domain is not None:
+            if failure_domain is not None and not controlled_delivery:
                 result.metrics["failure_domain"] = failure_domain
             result.metrics["implementation_audit_node_complete"] = bool(
-                audit_result["report_valid"] and audit_result["node_complete"]
+                controlled_delivery or audit_result["report_valid"] and audit_result["node_complete"]
             )
             result.metrics["implementation_audit_subject_blocked"] = bool(
-                audit_result["report_valid"] and not audit_result["node_complete"]
+                not controlled_delivery and audit_result["report_valid"] and not audit_result["node_complete"]
                 and (failure_domain == "environment" or any(
                     finding.get("task_id") == audit_contract.get("subject_task_id") and finding.get("status") == "blocked"
                     for finding in audit_result.get("findings") or []))
             )
-            if audit_result["report_valid"] and audit_result["status"] == "plan_revision_required":
+            if not controlled_delivery and audit_result["report_valid"] and audit_result["status"] == "plan_revision_required":
                 result.status = "failed"
                 result.failure_code = "implementation_plan_revision_required"
                 requests = audit_result.get("blocking_revision_requests", audit_result["revision_requests"])
@@ -14670,7 +14698,7 @@ class RuntimeDaemon:
                     f"{request['task_id']}: {request['reason']}" for request in requests[:3]
                 )
                 issues.append(_OutputValidationIssue(result.failure_code, result.error))
-            elif not audit_result["report_valid"] or not audit_result["node_complete"]:
+            elif not controlled_delivery 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",
@@ -15211,7 +15239,9 @@ class RuntimeDaemon:
                                         ac for ac in ac_list
                                         if ac["status"] != "covered" and ac["id"] not in pending
                                     ]
-                                    if uncovered:
+                                    if uncovered and controlled_delivery:
+                                        result.metrics["business_acceptance"] = {"status": "pending_human_qa", "criteria": [ac["id"] for ac in uncovered]}
+                                    elif uncovered:
                                         ids = ", ".join(ac["id"] for ac in uncovered[:20])
                                         if len(uncovered) > 20:
                                             ids += f" (+{len(uncovered) - 20} more)"
@@ -16686,6 +16716,18 @@ class RuntimeDaemon:
                     *[f"[daemon] {issue}" for issue in issues],
                 ])
 
+            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"}
+            ):
+                result.status = "failed"
+                result.failure_code = "planned_task_incomplete"
+                result.error = "Agent explicitly reported incomplete execution delivery; preserve work and resolve prerequisites before an authorized retry"
+                _record_output_validation_issues(result, issues)
+                self._record_testing_telemetry(workspace_path, task, result, retries_used=attempt)
+                return result
+
             if (
                 result.metrics.get("failure_domain") == "environment" and all(
                     issue.code in {"implementation_audit_incomplete", "acceptance_criteria_uncovered"} for issue in issues

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

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

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