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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.76.3
+Version: 1.77.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.76.3 → forgexa_cli-1.77.1}/forgexa_cli/__init__.py

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

{forgexa_cli-1.76.3 → forgexa_cli-1.77.1}/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:
@@ -103,6 +112,61 @@ def missing_planned_task_files(task_input: dict, changed_files: list[str]) -> li
     )
 
 
+def extract_implementation_audit(text: str) -> dict | None:
+    """Read the last complete audit envelope from mixed assistant output."""
+    decoder = json.JSONDecoder()
+    offset = 0
+    report = None
+    report_end = 0
+    while offset < len(text):
+        start = text.find("{", offset)
+        if start < 0:
+            break
+        try:
+            value, end = decoder.raw_decode(text, start)
+        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
+            report_end = end
+        offset = end
+    if '"implementation_audit"' in text[report_end:]:
+        return None
+    return report
+
+
+def redact_implementation_audit(contract: dict, report: object) -> dict | None:
+    """Keep contract-owned status and hashed evidence without local free text."""
+    from hashlib import sha256
+
+    if not assess_implementation_audit(contract, report)["report_valid"]:
+        return None
+    summary = {"audit_id": contract["audit_id"], "task_checks": [], "acceptance_checks": []}
+    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}
+            if key == "task_checks":
+                check["task_id"] = row["task_id"]
+            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_audit(contract: dict, report: object) -> dict:
     """Validate implementation coverage independently of later runtime acceptance."""
     issues: list[str] = []
@@ -111,6 +175,7 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
         "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": [], "blocking_reasons": [],
     }
     if (
         not isinstance(contract.get("audit_id"), str) or not contract["audit_id"]
@@ -156,6 +221,12 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
             else:
                 index = row.get("index")
                 related = row.get("task_ids")
+                if type(index) is int and not 1 <= index <= criterion_count:
+                    issues.append(
+                        f"Acceptance index {index} is outside the frozen baseline 1-{criterion_count}; "
+                        "report the baseline conflict instead of dropping or renumbering requirements"
+                    )
+                    continue
                 if (
                     type(index) is not int or not 1 <= index <= criterion_count or index in checked_criteria
                     or not isinstance(related, list) or not related
@@ -164,6 +235,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 []
@@ -177,9 +252,22 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
                 ):
                     issues.append("Implementation gap paths must be repository-relative")
                     continue
+                revision = row.get("plan_revision")
+                if revision is not None:
+                    if not isinstance(revision, dict) or any(
+                        not isinstance(revision.get(key), str) or not revision[key].strip()
+                        for key in ("reason", "proposal")
+                    ):
+                        issues.append("Plan revision requests require evidence, reason and a concrete proposal")
+                        continue
+                    result["revision_requests"].extend({
+                        "task_id": task_id, "reason": revision["reason"], "proposal": revision["proposal"],
+                        "evidence": evidence, "files": paths,
+                    } for task_id in related)
                 findings.extend({
                     "task_id": task_id, "status": status, "description": description,
                     "files": paths, "evidence": evidence,
+                    **({"plan_revision": revision} if revision is not None else {}),
                 } for task_id in related)
     required = expected if contract.get("final_verification") else {subject}
     if required - checked.keys():
@@ -191,8 +279,14 @@ 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"]:
+        result["status"] = "plan_revision_required"
     return result
 
 

{forgexa_cli-1.76.3 → forgexa_cli-1.77.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.76.3"
+DAEMON_VERSION = "1.77.1"
 
 
 def _detect_client_type() -> str:
@@ -2641,6 +2641,14 @@ def _read_local_bind_shared_output_snapshot(task_id: str) -> dict | None:
 
 def _prepare_local_bind_completion(task: "TaskInfo", result: "TaskResult") -> None:
     """Attach the automatic private snapshot before stripping normal local output."""
+    result.metrics.pop("implementation_audit", None)
+    audit_contract = (task.input_data or {}).get("implementation_audit_contract")
+    if isinstance(audit_contract, dict):
+        audit_report = next((item.get("data") for item in reversed(result.observations)
+                             if item.get("type") == "implementation_audit"), None)
+        summary = agent_core.redact_implementation_audit(audit_contract, audit_report)
+        if summary is not None:
+            result.metrics["implementation_audit"] = summary
     if _MANAGED_WSL_POLICY is not None:
         result.shared_local_output = None
     if _local_bind_output_sharing_enabled(task.local_workspace_binding_id):
@@ -9904,6 +9912,9 @@ class ServerConnection:
                 "local_fresh_branch_reset": {
                     "protocol_version": _LOCAL_FRESH_BRANCH_RESET_PROTOCOL_VERSION,
                 },
+                "acceptance_verification": {
+                    "protocol_version": runtime_evidence.DEFERRED_ACCEPTANCE_VERIFICATION_PROTOCOL_VERSION,
+                },
                 "task_attachment_staging": {"protocol_version": 1, "runtime_proxy": True, "image_agents": ["claude"]},
             },
             "server_url": self.server_url,
@@ -10324,6 +10335,9 @@ class ServerConnection:
                     "local_fresh_branch_reset": {
                         "protocol_version": _LOCAL_FRESH_BRANCH_RESET_PROTOCOL_VERSION,
                     },
+                    "acceptance_verification": {
+                        "protocol_version": runtime_evidence.DEFERRED_ACCEPTANCE_VERIFICATION_PROTOCOL_VERSION,
+                    },
                     "local_evidence": {"protocol_version": 1, "structured_summary": True},
                     "task_attachment_staging": {"protocol_version": 1, "runtime_proxy": True, "image_agents": ["claude"]},
                 },
@@ -13410,8 +13424,9 @@ class RuntimeDaemon:
                         task.task_id, 94, "acceptance_pending_final_qa",
                         execution_attempt_id=task.execution_attempt_id,
                         output_lines=[
-                            "[daemon] E2E test assets are prepared; acceptance remains pending "
-                            "post-deployment final QA: " + ", ".join(acceptance["criteria"]),
+                            "[daemon] Verification assets are prepared; acceptance remains pending "
+                            "post-deployment automated or human verification: "
+                            + ", ".join(acceptance["criteria"]),
                             "[daemon] No browser acceptance or release approval is claimed.",
                         ],
                     )
@@ -13860,14 +13875,15 @@ 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):
+            node_type = "testing"
         req_type = input_data.get("requirement_type", "feature")
         verification_work_item = bool(input_data.get("verification_work_item"))
 
         audit_contract = input_data.get("implementation_audit_contract")
         if isinstance(audit_contract, dict):
             agent_id = str(result.metrics.get("actual_agent") or getattr(task, "agent_type", "") or "")
-            parsed = _daemon_extract_json(_daemon_extract_agent_output(agent_id, result.stdout))
-            audit_report = parsed.get("implementation_audit") if isinstance(parsed, dict) else None
+            audit_report = agent_core.extract_implementation_audit(_daemon_extract_agent_output(agent_id, result.stdout))
             result.observations = [
                 observation for observation in result.observations
                 if observation.get("type") != "implementation_audit"
@@ -13875,8 +13891,15 @@ 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)
-            if 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"])
+            if audit_result["report_valid"] and audit_result["revision_requests"]:
+                result.status = "failed"
+                result.failure_code = "implementation_plan_revision_required"
+                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 [
+                    "The selected approved task still has implementation gaps",
+                ])
 
         if node_type == "coding" or (
             node_type == "fix" and input_data.get("task") == "phase_remediation_fix"
@@ -14415,7 +14438,11 @@ class RuntimeDaemon:
                                         )
                         except (_json.JSONDecodeError, UnicodeDecodeError) as e:
                             issues.append(f"coverage-matrix.json is not valid JSON: {e}")
-                    elif _requires_structured_artifacts or _requires_e2e_artifacts:
+                    elif (
+                        _requires_structured_artifacts
+                        or _requires_e2e_artifacts
+                        or _input.get("deferred_acceptance_verification") is not None
+                    ):
                         issues.append(f"coverage-matrix.json not found in {doc_dir or 'workspace root'}")
 
                     # --- test-evidence.json validation (M1 evidence bundle) ---
@@ -15840,6 +15867,8 @@ class RuntimeDaemon:
                 preserved_paths=preserved_paths,
             )
             issues = self._validate_outputs(workspace_path, task, result)
+            if result.failure_code == "implementation_plan_revision_required":
+                return result
             if require_source_inventory:
                 issues.extend(inventory_issues)
             if not issues:
@@ -15855,7 +15884,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
@@ -15967,6 +15996,8 @@ class RuntimeDaemon:
             preserved_paths=preserved_paths,
         )
         remaining = self._validate_outputs(workspace_path, task, result)
+        if result.failure_code == "implementation_plan_revision_required":
+            return result
         if require_source_inventory:
             remaining.extend(inventory_issues)
         if remaining:
@@ -15976,7 +16007,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
@@ -16135,7 +16166,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 {}
@@ -17589,7 +17620,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.76.3 → forgexa_cli-1.77.1}/forgexa_cli/runtime_evidence.py

@@ -15,6 +15,7 @@ from pathlib import Path
 from typing import Any
 
 RUNTIME_EVIDENCE_PLAN_VERSION = 1
+DEFERRED_ACCEPTANCE_VERIFICATION_PROTOCOL_VERSION = 2
 TEST_COVERAGE_CHECK_KIND = "test_coverage"
 STATIC_CHECK_KIND = "static_check"
 TYPE_CHECK_KIND = "type_check"
@@ -802,12 +803,18 @@ def validate_deferred_acceptance_criteria(
         or not isinstance(policy, dict)
         or policy.get("enforcement") != "enforce"
         or not isinstance(e2e_policy, dict)
-        or contract.get("version") != 1
+        or type(contract.get("version")) is not int
+        or contract["version"] not in (1, 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"]
-        or e2e_policy.get("enabled") is not True
-        or e2e_policy.get("workflow_auto_run") is not True
+        or (
+            contract["version"] == 1
+            and (
+                e2e_policy.get("enabled") is not True
+                or e2e_policy.get("workflow_auto_run") is not True
+            )
+        )
     ):
         return set(), ["Final QA acceptance contract does not match the frozen testing policy"]
 
@@ -829,6 +836,8 @@ def validate_deferred_acceptance_criteria(
         return set(), ["coverage-matrix.json does not match the frozen acceptance criteria"]
 
     cases = (test_cases or {}).get("test_cases") or []
+    if not isinstance(cases, list):
+        return set(), ["Final QA acceptance requires a test_cases array"]
     prepared_intents = {
         case.get("intent_id") or case.get("test_intent_id")
         for case in cases
@@ -852,8 +861,74 @@ def validate_deferred_acceptance_criteria(
             or any(not isinstance(value, str) or not value for value in intent_ids)
         ):
             return set(), ["Final QA acceptance contract has an invalid test intent mapping"]
-        if not set(intent_ids).issubset(prepared_intents):
-            return set(), [f"Final QA acceptance criterion {identifier} has no prepared E2E test case"]
+        if contract["version"] == 1:
+            if not set(intent_ids).issubset(prepared_intents):
+                return set(), [f"Final QA acceptance criterion {identifier} has no prepared E2E test case"]
+        else:
+            requirements = item.get("test_intents")
+            if (
+                not isinstance(requirements, list)
+                or len(requirements) != len(intent_ids)
+                or any(not isinstance(requirement, dict) for requirement in requirements)
+                or any(
+                    not isinstance(requirement.get("id"), str)
+                    for requirement in requirements
+                )
+                or len(set(intent_ids)) != len(intent_ids)
+                or {requirement.get("id") for requirement in requirements} != set(intent_ids)
+            ):
+                return set(), ["Final QA acceptance contract has invalid verification obligations"]
+            for requirement in requirements:
+                target = requirement.get("automation_target")
+                expected_refs = requirement.get("acceptance_criteria_refs")
+                if (
+                    not isinstance(expected_refs, list)
+                    or any(not isinstance(reference, str) for reference in expected_refs)
+                    or identifier not in expected_refs
+                    or not set(expected_refs).issubset(expected)
+                ):
+                    return set(), ["Final QA acceptance contract has invalid verification references"]
+                if target == "e2e":
+                    prepared = (
+                        e2e_policy.get("enabled") is True
+                        and e2e_policy.get("workflow_auto_run") is True
+                        and requirement["id"] in prepared_intents
+                    )
+                elif target == "manual":
+                    reason = requirement.get("manual_reason_code")
+                    if not isinstance(reason, str) or not reason.strip():
+                        return set(), ["Final QA acceptance contract has invalid manual obligations"]
+                    prepared = any(
+                        isinstance(case, dict)
+                        and isinstance(case.get("id"), str)
+                        and bool(case["id"].strip())
+                        and (case.get("intent_id") or case.get("test_intent_id")) == requirement["id"]
+                        and case.get("test_type") == "manual"
+                        and case.get("manual_reason_code") == reason
+                        and isinstance(case.get("acceptance_criteria_refs"), list)
+                        and {
+                            _canonical_acceptance_criteria_reference(reference)
+                            for reference in case["acceptance_criteria_refs"]
+                        } == set(expected_refs)
+                        and isinstance(case.get("steps"), list)
+                        and bool(case["steps"])
+                        and all(
+                            isinstance(step, dict)
+                            and isinstance(step.get("action"), str)
+                            and bool(step["action"].strip())
+                            for step in case["steps"]
+                        )
+                        and not case.get("script_path")
+                        and not case.get("script_content")
+                        for case in cases
+                    )
+                else:
+                    return set(), ["Final QA acceptance contract has an unsupported verification target"]
+                if not prepared:
+                    return set(), [
+                        f"Final QA acceptance criterion {identifier} has no prepared "
+                        f"{target} test case for intent {requirement['id']}"
+                    ]
         eligible.add(identifier)
     return {
         item["id"] for item, identifier in zip(criteria, identifiers)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.76.3
+Version: 1.77.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.76.3 → forgexa_cli-1.77.1}/pyproject.toml

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