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

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

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

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

{forgexa_cli-1.76.1 → forgexa_cli-1.76.3}/forgexa_cli/agent_core.py

@@ -103,6 +103,99 @@ def missing_planned_task_files(task_input: dict, changed_files: list[str]) -> li
     )
 
 
+def assess_implementation_audit(contract: dict, report: object) -> dict:
+    """Validate implementation coverage independently of later runtime acceptance."""
+    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,
+    }
+    if (
+        not isinstance(contract.get("audit_id"), str) or not contract["audit_id"]
+        or not isinstance(report, dict) or report.get("audit_id") != contract["audit_id"]
+    ):
+        issues.append("Implementation audit is missing or belongs to another remediation task")
+        return result
+    if set(report) - {"audit_id", "task_checks", "acceptance_checks"}:
+        issues.append("Implementation audit contains unsupported fields")
+    expected = {task["id"] for task in contract.get("tasks") or []}
+    subject = contract.get("subject_task_id")
+    if not expected or subject not in expected:
+        issues.append("Implementation audit has no approved task baseline")
+    task_checks = report.get("task_checks")
+    acceptance_checks = report.get("acceptance_checks")
+    if not isinstance(task_checks, list) or not isinstance(acceptance_checks, list):
+        issues.append("Implementation audit requires task_checks and acceptance_checks lists")
+        return result
+    checked: dict[str, str] = {}
+    checked_criteria: set[int] = set()
+    criterion_count = len(contract.get("acceptance_criteria") or [])
+    for kind, rows in (("task", task_checks), ("acceptance", acceptance_checks)):
+        for row in rows:
+            if not isinstance(row, dict):
+                issues.append(f"Invalid implementation {kind} check")
+                continue
+            evidence = row.get("evidence")
+            status = row.get("status")
+            if (
+                not isinstance(status, str) or status not in {"covered", "gap", "blocked", "unverified"}
+                or not isinstance(evidence, list) or not evidence
+                or any(not isinstance(item, str) or not item.strip() for item in evidence)
+            ):
+                issues.append(f"Implementation {kind} check requires an explicit status and concrete evidence")
+                continue
+            if kind == "task":
+                task_id = row.get("task_id")
+                if not isinstance(task_id, str) or task_id not in expected or task_id in checked:
+                    issues.append("Implementation audit has unknown or duplicate task IDs")
+                    continue
+                checked[task_id] = status
+                related = [task_id]
+            else:
+                index = row.get("index")
+                related = row.get("task_ids")
+                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
+                    or any(not isinstance(task_id, str) or task_id not in expected for task_id in related)
+                ):
+                    issues.append("Implementation audit has invalid acceptance criterion or task references")
+                    continue
+                checked_criteria.add(index)
+            if status != "covered":
+                description = row.get("description")
+                paths = row.get("files") or []
+                if not isinstance(description, str) or not description.strip() or not isinstance(paths, list):
+                    issues.append("Implementation gaps require an actionable description and file list")
+                    continue
+                if any(
+                    not isinstance(path, str) or not path.strip()
+                    or PurePosixPath(path).is_absolute() or ".." in PurePosixPath(path).parts
+                    for path in paths
+                ):
+                    issues.append("Implementation gap paths must be repository-relative")
+                    continue
+                findings.extend({
+                    "task_id": task_id, "status": status, "description": description,
+                    "files": paths, "evidence": evidence,
+                } for task_id in related)
+    required = expected if contract.get("final_verification") else {subject}
+    if required - checked.keys():
+        issues.append("Implementation audit omitted required approved tasks")
+    if contract.get("final_verification") and len(checked_criteria) != criterion_count:
+        issues.append("Implementation audit omitted acceptance criteria")
+    result["report_valid"] = not issues
+    result["node_complete"] = (
+        not issues and checked.get(subject) == "covered"
+        and not any(finding["task_id"] == subject for finding in findings)
+    )
+    result["followup_task_ids"] = sorted({finding["task_id"] for finding in findings})
+    result["status"] = "complete" if not issues and not findings else "incomplete"
+    return result
+
+
 _WORKSPACE_INSTRUCTION_PATHS = (
     "AGENTS.md",
     "CLAUDE.md",

{forgexa_cli-1.76.1 → forgexa_cli-1.76.3}/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.1"
+DAEMON_VERSION = "1.76.3"
 
 
 def _detect_client_type() -> str:
@@ -13404,6 +13404,17 @@ class RuntimeDaemon:
                     result.git = {}
 
             if result.status == "success":
+                acceptance = result.metrics.get("acceptance_verification") or {}
+                if acceptance.get("status") == "pending_final_qa":
+                    await reporter.report_progress(
+                        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] No browser acceptance or release approval is claimed.",
+                        ],
+                    )
                 if is_local_bind:
                     # Restricted commit/push adapter for the user's real
                     # directory: never `git add -A` sensitive paths, never
@@ -13852,7 +13863,24 @@ class RuntimeDaemon:
         req_type = input_data.get("requirement_type", "feature")
         verification_work_item = bool(input_data.get("verification_work_item"))
 
-        if node_type == "coding":
+        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
+            result.observations = [
+                observation for observation in result.observations
+                if observation.get("type") != "implementation_audit"
+            ]
+            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 node_type == "coding" or (
+            node_type == "fix" and input_data.get("task") == "phase_remediation_fix"
+        ):
             delivered_files = list(result.files_changed)
             delivered_files.extend(input_data.get("planned_task_predecessor_files") or [])
             for missing_path in agent_core.missing_planned_task_files(input_data, delivered_files):
@@ -14317,6 +14345,7 @@ class RuntimeDaemon:
                         ))
 
                     # --- coverage-matrix.json validation ---
+                    result.metrics.pop("acceptance_verification", None)
                     if req_type == "task":
                         result.metrics.pop("acceptance_criteria_manual_review_required", None)
                     cm_path = base / "coverage-matrix.json"
@@ -14359,9 +14388,27 @@ class RuntimeDaemon:
                                         "coverage_matrix_invalid"
                                     )
                                 else:
-                                    uncovered = [ac for ac in ac_list if ac["status"] != "covered"]
+                                    pending, contract_issues = (
+                                        runtime_evidence.validate_deferred_acceptance_criteria(
+                                            _input, cm_data, _tc_data,
+                                        )
+                                    )
+                                    issues.extend(contract_issues)
+                                    if pending:
+                                        contract = _input["deferred_acceptance_verification"]
+                                        result.metrics["acceptance_verification"] = {
+                                            "status": "pending_final_qa",
+                                            "analysis_revision_id": contract["analysis_revision_id"],
+                                            "criteria": [ac["id"] for ac in ac_list if ac["id"] in pending],
+                                        }
+                                    uncovered = [
+                                        ac for ac in ac_list
+                                        if ac["status"] != "covered" and ac["id"] not in pending
+                                    ]
                                     if uncovered:
-                                        ids = ", ".join(ac["id"] for ac in uncovered[:5])
+                                        ids = ", ".join(ac["id"] for ac in uncovered[:20])
+                                        if len(uncovered) > 20:
+                                            ids += f" (+{len(uncovered) - 20} more)"
                                         issues.append(
                                             "Uncovered acceptance criteria in "
                                             f"coverage-matrix.json: {ids}"

{forgexa_cli-1.76.1 → forgexa_cli-1.76.3}/forgexa_cli/runtime_evidence.py

@@ -783,6 +783,86 @@ def parse_acceptance_criteria_coverage_artifacts(
     }
 
 
+def validate_deferred_acceptance_criteria(
+    input_data: dict[str, Any],
+    coverage_matrix: dict[str, Any],
+    test_cases: dict[str, Any] | None,
+) -> tuple[set[str], list[str]]:
+    """Validate a server-owned final-QA handoff without claiming test success."""
+    contract = input_data.get("deferred_acceptance_verification")
+    if contract is None:
+        return set(), []
+    snapshot = input_data.get("qa_test_level_policy_snapshot") or {}
+    policy = snapshot.get("policy") if isinstance(snapshot, dict) else None
+    levels = policy.get("levels") if isinstance(policy, dict) else None
+    e2e_policy = levels.get("e2e") if isinstance(levels, dict) else None
+    if (
+        not isinstance(contract, dict)
+        or not isinstance(snapshot, dict)
+        or not isinstance(policy, dict)
+        or policy.get("enforcement") != "enforce"
+        or not isinstance(e2e_policy, dict)
+        or contract.get("version") != 1
+        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
+    ):
+        return set(), ["Final QA acceptance contract does not match the frozen testing policy"]
+
+    raw_expected = contract.get("acceptance_criteria_ids")
+    raw_deferred = contract.get("criteria")
+    if (
+        not isinstance(raw_expected, list)
+        or not raw_expected
+        or not isinstance(raw_deferred, list)
+        or not raw_deferred
+    ):
+        return set(), ["Final QA acceptance contract has no frozen acceptance criteria"]
+    expected = {_canonical_acceptance_criteria_reference(value) for value in raw_expected}
+    criteria = coverage_matrix["acceptance_criteria"]
+    identifiers = [_canonical_acceptance_criteria_reference(item["id"]) for item in criteria]
+    if None in expected or None in identifiers or len(set(identifiers)) != len(identifiers):
+        return set(), ["coverage-matrix.json has invalid or duplicate acceptance criterion IDs"]
+    if set(identifiers) != expected:
+        return set(), ["coverage-matrix.json does not match the frozen acceptance criteria"]
+
+    cases = (test_cases or {}).get("test_cases") or []
+    prepared_intents = {
+        case.get("intent_id") or case.get("test_intent_id")
+        for case in cases
+        if isinstance(case, dict)
+        and case.get("test_type") == "e2e"
+        and isinstance(case.get("intent_id") or case.get("test_intent_id"), str)
+        and case.get("id")
+        and case.get("script_path")
+        and case.get("script_content")
+    }
+    eligible = set()
+    for item in raw_deferred:
+        if not isinstance(item, dict):
+            return set(), ["Final QA acceptance contract has an invalid criterion mapping"]
+        identifier = _canonical_acceptance_criteria_reference(item.get("id"))
+        intent_ids = item.get("test_intent_ids")
+        if (
+            identifier not in expected
+            or not isinstance(intent_ids, list)
+            or not intent_ids
+            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"]
+        eligible.add(identifier)
+    return {
+        item["id"] for item, identifier in zip(criteria, identifiers)
+        if identifier in eligible
+        and item["status"] == "unverifiable"
+        and item.get("covered_by", []) == []
+    }, []
+
+
 async def run_acceptance_criteria_coverage_evidence(
     workspace_path: str | Path,
     check: object,

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

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

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