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

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

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

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

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

@@ -67,6 +67,15 @@ except ImportError:
 logger = logging.getLogger("agent_core")
 
 
+def is_implementation_testing_task(node_type: str, input_data: dict) -> bool:
+    """Retain the testing responsibility of a phase-remediation wrapper."""
+    fix_context = input_data.get("fix_context")
+    return 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"
+    )
+
+
 def missing_planned_task_files(task_input: dict, changed_files: list[str]) -> list[str]:
     """Find planned files without delivery evidence, including grouped sub-tasks."""
     def normalize_path(value: object) -> str | None:
@@ -133,40 +142,104 @@ 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 = {
         "audit_id": contract.get("audit_id"), "report_valid": False,
         "node_complete": False, "status": "incomplete", "issues": issues,
         "findings": findings, "followup_task_ids": [], "report": report,
-        "revision_requests": [],
+        "revision_requests": [], "blocking_reasons": [],
     }
     if (
         not isinstance(contract.get("audit_id"), str) or not contract["audit_id"]
@@ -226,6 +299,10 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
                     issues.append("Implementation audit has invalid acceptance criterion or task references")
                     continue
                 checked_criteria.add(index)
+                if len(related) > 1:
+                    unresolved_contributors = [task_id for task_id in related if checked.get(task_id) != "covered"]
+                    if unresolved_contributors:
+                        related = unresolved_contributors
             if status != "covered":
                 description = row.get("description")
                 paths = row.get("files") or []
@@ -266,6 +343,10 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
         not issues and checked.get(subject) == "covered"
         and not any(finding["task_id"] == subject for finding in findings)
     )
+    result["blocking_reasons"] = list(dict.fromkeys(
+        f"Approved task '{subject}' is {finding['status']}: {finding['description']}"
+        for finding in findings if finding["task_id"] == subject
+    ))
     result["followup_task_ids"] = sorted({finding["task_id"] for finding in findings})
     result["status"] = "complete" if not issues and not findings else "incomplete"
     if result["report_valid"] and result["revision_requests"]:

{forgexa_cli-1.77.0 → 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.0"
+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,6 +13877,12 @@ class RuntimeDaemon:
         issues: list[str] = []
         node_type = task.node_type
         input_data = task.input_data or {}
+        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"))
 
@@ -13895,7 +13903,9 @@ 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 ["The selected approved task still has implementation gaps"])
+                issues.extend(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"
@@ -15880,7 +15890,7 @@ class RuntimeDaemon:
                 ])
 
             if (
-                task.node_type == "testing"
+                agent_core.is_implementation_testing_task(task.node_type, task.input_data or {})
                 and all(
                     issue.startswith("Uncovered acceptance criteria in coverage-matrix.json:")
                     for issue in issues
@@ -16003,7 +16013,7 @@ class RuntimeDaemon:
                     *[f"[daemon] {issue}" for issue in remaining],
                 ])
             if (
-                task.node_type == "testing"
+                agent_core.is_implementation_testing_task(task.node_type, task.input_data or {})
                 and all(
                     issue.startswith("Uncovered acceptance criteria in coverage-matrix.json:")
                     for issue in remaining
@@ -16162,7 +16172,7 @@ class RuntimeDaemon:
                 result.metrics["validation_issue_categories"] = sorted(
                     {_categorize_validation_issue(str(issue)) for issue in issues}
                 )
-            if task.node_type != "testing":
+            if not agent_core.is_implementation_testing_task(task.node_type, task.input_data or {}):
                 return
             input_data = task.input_data or {}
             context = input_data.get("context") or {}
@@ -17616,7 +17626,9 @@ class RuntimeDaemon:
         before_sha: str,
     ) -> None:
         """Bind generated testing artifacts to the committed testing attempt."""
-        if task.workspace_resolution != "cloud_worktree" or task.node_type != "testing":
+        if task.workspace_resolution != "cloud_worktree" or not agent_core.is_implementation_testing_task(
+            task.node_type, task.input_data or {},
+        ):
             return
 
         after_sha = str((result.git or {}).get("commit_sha") or "").strip()

{forgexa_cli-1.77.0 → 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.0 → 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.0
+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.0 → forgexa_cli-1.77.2}/pyproject.toml

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