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

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

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

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

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

@@ -103,6 +103,176 @@ 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] = []
+    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": [],
+    }
+    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 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
+                    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
+                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():
+        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"
+    if result["report_valid"] and result["revision_requests"]:
+        result["status"] = "plan_revision_required"
+    return result
+
+
 _WORKSPACE_INSTRUCTION_PATHS = (
     "AGENTS.md",
     "CLAUDE.md",

{forgexa_cli-1.76.2 → forgexa_cli-1.77.0}/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.2"
+DAEMON_VERSION = "1.77.0"
 
 
 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"]},
                 },
@@ -13404,6 +13418,18 @@ 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] 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.",
+                        ],
+                    )
                 if is_local_bind:
                     # Restricted commit/push adapter for the user's real
                     # directory: never `git add -A` sensitive paths, never
@@ -13852,6 +13878,25 @@ class RuntimeDaemon:
         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 "")
+            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"
+            ]
+            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 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 ["The selected approved task still has implementation gaps"])
+
         if node_type == "coding" or (
             node_type == "fix" and input_data.get("task") == "phase_remediation_fix"
         ):
@@ -14319,6 +14364,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"
@@ -14361,16 +14407,38 @@ 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}"
                                         )
                         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) ---
@@ -15795,6 +15863,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:
@@ -15922,6 +15992,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:

{forgexa_cli-1.76.2 → forgexa_cli-1.77.0}/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"
@@ -783,6 +784,160 @@ 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 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 (
+            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"]
+
+    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 []
+    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
+        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 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)
+        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.2 → forgexa_cli-1.77.0}/forgexa_cli.egg-info/PKG-INFO

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

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