forgexa-cli 1.77.1__tar.gz → 1.77.2__tar.gz

{forgexa_cli-1.77.1 → forgexa_cli-1.77.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.77.1
+Version: 1.77.2
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License-Expression: MIT

{forgexa_cli-1.77.1 → forgexa_cli-1.77.2}/forgexa_cli/__init__.py

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

{forgexa_cli-1.77.1 → forgexa_cli-1.77.2}/forgexa_cli/agent_core.py

@@ -142,33 +142,97 @@ def redact_implementation_audit(contract: dict, report: object) -> dict | None:
 
     if not assess_implementation_audit(contract, report)["report_valid"]:
         return None
+    def redact_check(row: dict) -> dict:
+        evidence = []
+        for reference in row["evidence"][:20]:
+            digest = reference.removeprefix("local-evidence-sha256:")
+            evidence.append(reference if digest != reference and len(digest) == 64
+                            and all(character in "0123456789abcdef" for character in digest)
+                            else "local-evidence-sha256:" + sha256(reference.encode()).hexdigest())
+        check = {"status": row["status"], "evidence": evidence}
+        if row["status"] != "covered":
+            check.update(description="Local implementation issue remains unresolved; inspect local task evidence.", files=[])
+            if row.get("plan_revision"):
+                check["plan_revision"] = {
+                    "reason": "Local evidence conflicts with the approved plan",
+                    "proposal": "Inspect the source in the requirement workspace and revise analysis and tasks together",
+                }
+        return check
+
     summary = {"audit_id": contract["audit_id"], "task_checks": [], "acceptance_checks": []}
+    coding_ids = {task["id"] for task in contract.get("tasks") or [] if task.get("type") in ("coding", "fix")}
     for key in ("task_checks", "acceptance_checks"):
         for row in report[key]:
-            evidence = []
-            for reference in row["evidence"][:20]:
-                digest = reference.removeprefix("local-evidence-sha256:")
-                evidence.append(reference if digest != reference and len(digest) == 64
-                                and all(character in "0123456789abcdef" for character in digest)
-                                else "local-evidence-sha256:" + sha256(reference.encode()).hexdigest())
-            check = {"status": row["status"], "evidence": evidence}
+            check = redact_check(row)
             if key == "task_checks":
                 check["task_id"] = row["task_id"]
+                if contract.get("version") == 2 and row["task_id"] in coding_ids and isinstance(row.get("implementation_check"), dict):
+                    check["implementation_check"] = redact_check(row["implementation_check"])
             else:
                 check.update(index=row["index"], task_ids=row["task_ids"])
-            if row["status"] != "covered":
-                check.update(description="Local implementation issue remains unresolved; inspect local task evidence.", files=[])
-                if row.get("plan_revision"):
-                    check["plan_revision"] = {
-                        "reason": "Local evidence conflicts with the approved plan",
-                        "proposal": "Inspect the source in the requirement workspace and revise analysis and tasks together",
-                    }
             summary[key].append(check)
     return summary
 
 
+def _assess_implementation_contributions(contract: dict, report: object) -> dict:
+    original = assess_implementation_audit({**contract, "version": 1}, report)
+    if not original["report_valid"]:
+        return original
+    task_types = {task["id"]: task.get("type") for task in contract.get("tasks") or []}
+    verification_ids = [task_id for task_id, task_type in task_types.items() if task_type in ("testing", "verify")]
+    verification_statuses = {row["task_id"]: row["status"] for row in report["task_checks"]}
+    checks = []
+    issues = []
+    pending = []
+    for row in report["task_checks"]:
+        if not isinstance(row, dict) or task_types.get(row.get("task_id")) not in ("coding", "fix"):
+            checks.append(row)
+            continue
+        implementation = row.get("implementation_check")
+        if not isinstance(implementation, dict):
+            issues.append(f"Approved coding task '{row.get('task_id')}' requires an evidenced implementation_check")
+            checks.append(row)
+            continue
+        check = {"task_id": row.get("task_id"), **{
+            key: implementation[key] for key in ("status", "evidence", "description", "files", "plan_revision")
+            if key in implementation
+        }}
+        if row.get("plan_revision") is not None:
+            check["plan_revision"] = row["plan_revision"]
+        checks.append(check)
+        if implementation.get("status") == "covered" and row.get("status") == "gap":
+            issues.append(f"Approved task '{row.get('task_id')}' reports a gap despite claiming implementation coverage")
+        if implementation.get("status") == "covered" and row.get("status") in ("blocked", "unverified"):
+            if not verification_ids:
+                issues.append("Runtime acceptance is pending but the approved plan has no verification task")
+            pending.extend({
+                "task_id": task_id, "status": row.get("status"),
+                "description": row.get("description") or "Runtime acceptance remains pending",
+                "files": [], "evidence": row.get("evidence") or [],
+            } for task_id in verification_ids if verification_statuses.get(task_id) != "covered")
+    result = assess_implementation_audit({**contract, "version": 1}, {**report, "task_checks": checks})
+    result["report"] = report
+    result["issues"].extend(issues)
+    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["findings"].extend(pending)
+    for request in original["revision_requests"]:
+        if request not in result["revision_requests"]:
+            result["revision_requests"].append(request)
+    result["followup_task_ids"] = sorted({finding["task_id"] for finding in result["findings"]})
+    if issues or pending:
+        result["status"] = "incomplete"
+    if result["report_valid"] and result["revision_requests"]:
+        result["status"] = "plan_revision_required"
+        result["node_complete"] = False
+    return result
+
+
 def assess_implementation_audit(contract: dict, report: object) -> dict:
     """Validate implementation coverage independently of later runtime acceptance."""
+    if contract.get("version") == 2:
+        return _assess_implementation_contributions(contract, report)
     issues: list[str] = []
     findings: list[dict] = []
     result = {

{forgexa_cli-1.77.1 → forgexa_cli-1.77.2}/forgexa_cli/daemon.py

@@ -1234,7 +1234,7 @@ except (ImportError, ModuleNotFoundError):
 # DAEMON_VERSION is the protocol/logic version of the daemon code.
 # Kept in sync with pyproject.toml version via bump-version.sh.
 # CLIENT_TYPE identifies which packaging/distribution this daemon runs in.
-DAEMON_VERSION = "1.77.1"
+DAEMON_VERSION = "1.77.2"
 
 
 def _detect_client_type() -> str:
@@ -9915,6 +9915,7 @@ class ServerConnection:
                 "acceptance_verification": {
                     "protocol_version": runtime_evidence.DEFERRED_ACCEPTANCE_VERIFICATION_PROTOCOL_VERSION,
                 },
+                "implementation_audit": {"protocol_version": 2},
                 "task_attachment_staging": {"protocol_version": 1, "runtime_proxy": True, "image_agents": ["claude"]},
             },
             "server_url": self.server_url,
@@ -10338,6 +10339,7 @@ class ServerConnection:
                     "acceptance_verification": {
                         "protocol_version": runtime_evidence.DEFERRED_ACCEPTANCE_VERIFICATION_PROTOCOL_VERSION,
                     },
+                    "implementation_audit": {"protocol_version": 2},
                     "local_evidence": {"protocol_version": 1, "structured_summary": True},
                     "task_attachment_staging": {"protocol_version": 1, "runtime_proxy": True, "image_agents": ["claude"]},
                 },
@@ -13875,7 +13877,11 @@ class RuntimeDaemon:
         issues: list[str] = []
         node_type = task.node_type
         input_data = task.input_data or {}
-        if agent_core.is_implementation_testing_task(node_type, input_data):
+        fix_context = input_data.get("fix_context")
+        if node_type == "testing" or (
+            node_type == "fix" and input_data.get("task") == "phase_remediation_fix"
+            and isinstance(fix_context, dict) and fix_context.get("failed_node_type") == "testing"
+        ):
             node_type = "testing"
         req_type = input_data.get("requirement_type", "feature")
         verification_work_item = bool(input_data.get("verification_work_item"))
@@ -13897,7 +13903,7 @@ class RuntimeDaemon:
                 result.error = "Approved analysis and task plan require revision before implementation can continue"
                 issues.append(result.error)
             elif not audit_result["report_valid"] or not audit_result["node_complete"]:
-                issues.extend(audit_result["issues"] or audit_result["blocking_reasons"] or [
+                issues.extend(audit_result["issues"] or audit_result.get("blocking_reasons") or [
                     "The selected approved task still has implementation gaps",
                 ])
 

{forgexa_cli-1.77.1 → forgexa_cli-1.77.2}/forgexa_cli/runtime_evidence.py

@@ -15,7 +15,7 @@ from pathlib import Path
 from typing import Any
 
 RUNTIME_EVIDENCE_PLAN_VERSION = 1
-DEFERRED_ACCEPTANCE_VERIFICATION_PROTOCOL_VERSION = 2
+DEFERRED_ACCEPTANCE_VERIFICATION_PROTOCOL_VERSION = 3
 TEST_COVERAGE_CHECK_KIND = "test_coverage"
 STATIC_CHECK_KIND = "static_check"
 TYPE_CHECK_KIND = "type_check"
@@ -804,7 +804,7 @@ def validate_deferred_acceptance_criteria(
         or policy.get("enforcement") != "enforce"
         or not isinstance(e2e_policy, dict)
         or type(contract.get("version")) is not int
-        or contract["version"] not in (1, DEFERRED_ACCEPTANCE_VERIFICATION_PROTOCOL_VERSION)
+        or contract["version"] not in (1, 2, DEFERRED_ACCEPTANCE_VERIFICATION_PROTOCOL_VERSION)
         or contract.get("execution_phase") != "verification_final"
         or not isinstance(snapshot.get("fingerprint"), str)
         or contract.get("qa_test_level_policy_fingerprint") != snapshot["fingerprint"]

{forgexa_cli-1.77.1 → forgexa_cli-1.77.2}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.77.1
+Version: 1.77.2
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License-Expression: MIT

{forgexa_cli-1.77.1 → forgexa_cli-1.77.2}/pyproject.toml

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