forgexa-cli 1.85.2__tar.gz → 1.85.4__tar.gz

{forgexa_cli-1.85.2 → forgexa_cli-1.85.4}/PKG-INFO

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

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

{forgexa_cli-1.85.2 → forgexa_cli-1.85.4}/forgexa_cli/agent_core.py

@@ -79,10 +79,114 @@ LOCAL_BIND_PRIVATE_VALIDATION_METRIC_KEYS = frozenset({
 })
 
 
-def assess_approved_plan_conformance(baseline: dict, report: object) -> dict:
+def verification_obligation_fingerprint(task: dict) -> str:
+    task_input = task.get("input") if isinstance(task.get("input"), dict) else {}
+    responsibility = {
+        "id": task.get("id"), "type": task.get("type"), "description": task.get("description") or "",
+        "items": task.get("items") or [], "depends_on": task.get("depends_on") or [],
+        "files": task_input.get("files") or task.get("files") or [],
+    }
+    return hashlib.sha256(json.dumps(responsibility, sort_keys=True, ensure_ascii=True, separators=(",", ":")).encode()).hexdigest()
+
+
+def approved_contribution_review_instructions(baseline: dict, audit_contract: dict | None) -> str:
+    task = baseline.get("task") or {}
+    obligations = baseline.get("verification_obligations") or {}
+    if (
+        not isinstance(audit_contract, dict) or audit_contract.get("version") != 2
+        or audit_contract.get("plan_id") != baseline.get("plan_id") or audit_contract.get("subject_task_id") != task.get("id")
+        or audit_contract.get("final_verification") is not False or task.get("type") not in ("coding", "fix")
+        or not isinstance(obligations, dict) or type(obligations.get("version")) is not int or obligations["version"] != 1
+    ):
+        return ""
+    verifiers = [check for check in obligations.get("checks") or [] if isinstance(check, dict)
+                 and check.get("type") in ("testing", "verify") and check.get("task_id") != task["id"]]
+    if not verifiers:
+        return ""
+    example = {"contribution_check": {"check_id": str(task["id"]) + ":assigned", "status": "unverified",
+                "evidence": ["<independent source and every assigned check evidence>"]},
+               "pending_checks": [{"check_id": verifiers[0]["check_id"], "task_id": verifiers[0]["task_id"],
+                   "status": "unverified", "evidence": ["<observed outstanding approved verification>"]}]}
+    return (
+        "\n## Assigned Contribution and Pending Verification\n"
+        "Within the bound plan_conformance object, contribution_check covers all requirements and mandatory checks of this task, "
+        "not only static source. When independently evidenced as conformant, other approved verification owners may remain pending. "
+        "Use the exact frozen check_id/task_id pairs; this does not authorize moving an own check to another owner, "
+        "inventing an owner, waiving a check or changing its phase. Keep the overall status unverified while pending_checks remain. "
+        "The score and verdict assess the assigned contribution, not unfinished work assigned elsewhere. "
+        "A real own gap stays deviation or unverified. The default example is not completion evidence.\n"
+        "Scoped contribution fields example:\n" + json.dumps(example, ensure_ascii=True, separators=(",", ":"))
+    )
+
+
+def _assess_contribution_conformance(baseline: dict, report: dict, audit_contract: dict | None, result: dict) -> dict:
+    obligations = baseline.get("verification_obligations")
+    subject = result["task_id"]
+    if (
+        not isinstance(audit_contract, dict) or audit_contract.get("version") != 2
+        or audit_contract.get("plan_id") != baseline.get("plan_id")
+        or audit_contract.get("subject_task_id") != subject or audit_contract.get("final_verification") is not False
+        or (baseline.get("task") or {}).get("type") not in ("coding", "fix")
+        or not isinstance(obligations, dict) or type(obligations.get("version")) is not int or obligations["version"] != 1
+    ):
+        return result
+    checks = obligations.get("checks")
+    if not isinstance(checks, list) or any(not isinstance(check, dict) for check in checks):
+        return result
+    by_id = {check.get("check_id"): check for check in checks if isinstance(check.get("check_id"), str)}
+    own = by_id.get(str(subject) + ":assigned")
+    tasks = audit_contract.get("tasks")
+    if not isinstance(tasks, list) or any(not isinstance(task, dict) or not isinstance(task.get("id"), str) for task in tasks):
+        return result
+    approved = {task["id"]: task for task in tasks}
+    contribution = report.get("contribution_check")
+    pending = report.get("pending_checks")
+    if (
+        len(by_id) != len(checks) or not isinstance(own, dict) or own.get("task_id") != subject
+        or subject not in approved or own.get("task_fingerprint") != verification_obligation_fingerprint(approved[subject])
+        or own.get("task_fingerprint") != verification_obligation_fingerprint(baseline["task"])
+        or own.get("required") is not True or not isinstance(contribution, dict)
+        or contribution.get("check_id") != own["check_id"] or contribution.get("status") != "conformant"
+        or contribution.get("plan_revision") is not None
+        or not isinstance(pending, list) or not pending
+    ):
+        return result
+    evidence = contribution.get("evidence")
+    if not isinstance(evidence, list) or not evidence or any(not isinstance(item, str) or not item.strip() for item in evidence):
+        return result
+    normalized = []
+    seen = set()
+    for check in pending:
+        if not isinstance(check, dict) or not isinstance(check.get("check_id"), str):
+            return result
+        binding = by_id.get(check["check_id"])
+        references = check.get("evidence")
+        reason = check.get("blocking_reason")
+        if (
+            not isinstance(binding, dict) or check["check_id"] in seen or binding.get("required") is not True
+            or check.get("task_id") == subject or binding.get("task_id") != check.get("task_id")
+            or binding.get("type") not in ("testing", "verify") or approved.get(check.get("task_id"), {}).get("type") != binding.get("type")
+            or binding.get("task_fingerprint") != verification_obligation_fingerprint(approved.get(check.get("task_id"), {}))
+            or check.get("status") not in ("blocked", "unverified") or check.get("plan_revision") is not None
+            or not isinstance(references, list) or not references
+            or any(not isinstance(item, str) or not item.strip() for item in references)
+            or reason is not None and (not isinstance(reason, str) or reason not in IMPLEMENTATION_ENVIRONMENT_BLOCKERS)
+        ):
+            return result
+        seen.add(check["check_id"])
+        normalized.append({"check_id": check["check_id"], "task_id": check["task_id"], "status": check["status"],
+                           "evidence_refs": [hashlib.sha256(item.encode()).hexdigest() for item in references],
+                           **({"blocking_reason": reason} if reason is not None else {})})
+    result.update(node_complete=True, contribution_check={"check_id": own["check_id"], "status": "conformant",
+        "evidence_refs": [hashlib.sha256(item.encode()).hexdigest() for item in evidence]}, pending_checks=normalized,
+        verification_pending=sorted({check["task_id"] for check in normalized}))
+    return result
+
+
+def assess_approved_plan_conformance(baseline: dict, report: object, *, audit_contract: dict | None = None) -> dict:
     result = {
         "status": "unverified", "baseline_fingerprint": baseline.get("fingerprint"),
-        "task_id": (baseline.get("task") or {}).get("id"), "evidence_refs": [],
+        "task_id": (baseline.get("task") or {}).get("id"), "evidence_refs": [], "node_complete": False,
     }
     expected = {key: value for key, value in baseline.items() if key != "fingerprint"}
     fingerprint = hashlib.sha256(json.dumps(
@@ -114,8 +218,20 @@ def assess_approved_plan_conformance(baseline: dict, report: object) -> dict:
         result["reason"] = "approved_plan_review_evidence_missing"
         result["diagnostic_code"] = "approved_plan_review_evidence_missing"
         return result
+    contribution = report.get("contribution_check")
+    if report["status"] == "conformant" and (
+        bool(report.get("pending_checks"))
+        or "pending_checks" in report and not isinstance(report["pending_checks"], list)
+        or contribution is not None and (not isinstance(contribution, dict) or contribution.get("status") != "conformant")
+    ):
+        result["reason"] = "approved_plan_review_missing_or_mismatched"
+        result["diagnostic_code"] = "approved_plan_review_contribution_conflict"
+        return result
     result["status"] = report["status"]
     result["evidence_refs"] = [hashlib.sha256(item.encode()).hexdigest() for item in evidence]
+    result["node_complete"] = report["status"] == "conformant"
+    if report["status"] == "unverified" and report.get("contribution_check") is not None:
+        return _assess_contribution_conformance(baseline, report, audit_contract, result)
     return result
 
 

{forgexa_cli-1.85.2 → forgexa_cli-1.85.4}/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.85.2"
+DAEMON_VERSION = "1.85.4"
 
 
 def _detect_client_type() -> str:
@@ -1663,6 +1663,8 @@ _RUNTIME_CRITIC_TIMEOUT_SECONDS = 300
 _RUNTIME_CRITIC_DIFF_MAX_CHARS = 30_000
 _RUNTIME_CRITIC_OUTPUT_MAX_CHARS = 20_000
 _RUNTIME_CRITIC_SOURCE_MAX_BYTES = 1_000_000
+_RUNTIME_CRITIC_DESIGN_MAX_FILES = 128
+_RUNTIME_CRITIC_SOURCE_TIMEOUT_SECONDS = 200
 _RUNTIME_CRITIC_SYSTEM_PROMPT = """You are the Critic Agent for a software delivery gate.
 Review only the supplied task context, code diff and committed source snapshots. You are running in an
 isolated review capsule, not the project workspace. Do not write or modify files,
@@ -1809,6 +1811,7 @@ def _build_runtime_critic_prompt(
                 "failed checks remain blocking. State the concrete missing evidence; never invent a run, "
                 "treat asset existence as proof of correctness, or claim final QA or release acceptance."
             )
+        parts.append(agent_core.approved_contribution_review_instructions(baseline, audit_contract))
     else:
         planned_context = {
             key: (task.input_data or {}).get(key)
@@ -3074,9 +3077,25 @@ def _runtime_critic_reference_candidates(
             php_context and all(re.fullmatch(r"[A-Z][A-Za-z0-9]*[A-Z][A-Za-z0-9]*", part) for part in Path(candidate).parts)
         ):
             directories.add(candidate)
+    alias_roots = {}
+    for path in [*source_paths, *explicit]:
+        parts = Path(path).parts
+        if safe_path(path) and len(parts) > 4 and parts[:2] == ("app", "code"):
+            alias_roots.setdefault(parts[2], set()).add("app/code")
+        elif safe_path(path) and len(parts) > 2 and parts[0] == "vendor":
+            alias_roots.setdefault(parts[1], set()).add("vendor")
+    for reference in tuple(explicit):
+        roots = alias_roots.get(Path(reference).parts[0], set())
+        if len(roots) == 1:
+            rooted = safe_path(next(iter(roots)) + "/" + reference)
+            if rooted is not None and (inventory is None or rooted in inventory):
+                explicit.add(rooted)
+                directories.add(Path(rooted).parent.as_posix())
+    php_context = php_context or any(Path(path).suffix.lower() == ".php" for path in explicit)
     names = set(re.findall(
         r"(?<![\w./\\:-])([A-Za-z0-9_][A-Za-z0-9_.-]*\.(?:php|py|tsx?|jsx?|xml|json|md|ya?ml|toml|html|phtml))\b", text,
     ))
+    names.update(re.findall(r"(?<![\w./\\:-])(composer\.lock)\b", text))
     if php_context:
         names.update(name + ".php" for name in re.findall(
             r"(?<![\w./\\:-])([A-Z][A-Za-z0-9_]*)::[A-Za-z_][A-Za-z0-9_]*\b", text,
@@ -3086,14 +3105,30 @@ def _runtime_critic_reference_candidates(
             r"(?<![\w.\\:-])(?=[A-Za-z0-9]*[a-z])([A-Z][A-Za-z0-9]*[A-Z][A-Za-z0-9]*)(?![\w.\\:-])", bare_text,
         ))
     module_roots = sorted({
-        "/".join(Path(path).parts[:4]) for path in source_paths
+        "/".join(Path(path).parts[:4]) for path in [*source_paths, *explicit]
         if safe_path(path) and len(Path(path).parts) > 4 and Path(path).parts[:2] == ("app", "code")
         and Path(path).suffix.lower() == ".php"
     })[:5]
     known_names = {Path(path).name for path in [*source_paths, *explicit]}
-    candidates = set(explicit)
-    for name in sorted(names - known_names)[:20]:
-        if inventory is not None and module_roots and name.endswith(".php"):
+    root_files = names & {"composer.lock", "AGENTS.md"}
+    candidates = set(explicit) | root_files
+    if any(name.endswith("Factory.php") for name in names | known_names):
+        configurations = {f"{root}/etc/di.xml" for root in module_roots}
+        if inventory is not None:
+            configurations.intersection_update(inventory)
+        if inventory is None or len(configurations) == 1:
+            candidates.update(configurations)
+    for reference in explicit:
+        if Path(reference).suffix.lower() != ".xml" or reference.startswith(("app/code/", "vendor/")):
+            continue
+        module_references = {f"{root}/{reference}" for root in module_roots}
+        if inventory is not None:
+            module_references.intersection_update(inventory)
+            if len(module_references) != 1:
+                continue
+        candidates.update(module_references)
+    for name in sorted(names - known_names - root_files)[:20]:
+        if inventory is not None and module_roots and Path(name).suffix.lower() in {".php", ".xml"}:
             matches = [path for path in inventory if Path(path).name == name
                        and any(path.startswith(root + "/") for root in module_roots)]
             if len(matches) == 1 and (path := safe_path(matches[0])) is not None:
@@ -3101,9 +3136,14 @@ def _runtime_critic_reference_candidates(
             continue
         candidates.update(path for directory in sorted(directories)[:5]
                           if (path := safe_path(f"{directory}/{name}")) is not None)
-        if name.endswith(".php"):
+        if Path(name).suffix.lower() in {".php", ".xml"}:
             candidates.update(f"{root}/{name}" for root in module_roots)
-    return sorted(candidates - set(source_paths))[:128]
+    primary = (explicit | root_files) - set(source_paths)
+    ordered = sorted(primary, key=lambda path: (
+        path not in root_files, inventory is None or path not in inventory,
+        not path.startswith(("app/code/", "vendor/", "setup/", "build/", "config/")), path,
+    ))
+    return (ordered + sorted(candidates - primary - set(source_paths)))[:128]
 
 
 def _try_acquire_local_workspace_file_lock(binding_id: str, workspace_path: Path | None = None):
@@ -4007,8 +4047,15 @@ class WorkspaceManager:
 
         if remote_branch.strip():
             try:
+                # The tracking ref is a cache of remote state and the remote is
+                # authoritative (its existence and tip were just confirmed via
+                # ls-remote). Update it even when the remote was rewritten: a
+                # fresh-analysis reset legitimately force-pushes this branch,
+                # and a non-forced refspec is rejected non-fast-forward against
+                # the stale tracking ref forever — the same cache-alignment
+                # rule every other fetch in this file already follows.
                 await self._git(
-                    "fetch", "origin", f"{target_branch}:refs/remotes/origin/{target_branch}",
+                    "fetch", "origin", f"+{target_branch}:refs/remotes/origin/{target_branch}",
                     cwd=local_path,
                 )
             except RuntimeError as exc:
@@ -4020,6 +4067,19 @@ class WorkspaceManager:
                 "rev-list", f"origin/{target_branch}..HEAD", "--count", cwd=local_path,
             )
             if ahead_output.strip() not in ("", "0"):
+                behind_output = await self._git(
+                    "rev-list", f"HEAD..origin/{target_branch}", "--count", cwd=local_path,
+                )
+                if behind_output.strip() not in ("", "0"):
+                    raise RuntimeError(
+                        f"local_binding_unavailable: local branch '{target_branch}' diverged "
+                        f"from origin/{target_branch} (ahead {ahead_output.strip()}, behind "
+                        f"{behind_output.strip()}); the remote branch was rewritten — for "
+                        "example by a fresh-analysis reset, whose retired tips are preserved "
+                        "under 'forgexa/fresh-analysis-backup/*' tags. Align your local branch "
+                        f"(git reset --hard origin/{target_branch}) after keeping anything you "
+                        "need, then retry."
+                    )
                 raise RuntimeError(
                     f"local_binding_unavailable: local branch '{target_branch}' has "
                     f"{ahead_output.strip()} unpushed commit(s) ahead of origin — push them "
@@ -4057,7 +4117,7 @@ class WorkspaceManager:
 
             try:
                 await self._git(
-                    "fetch", "origin", f"{default_branch}:refs/remotes/origin/{default_branch}",
+                    "fetch", "origin", f"+{default_branch}:refs/remotes/origin/{default_branch}",
                     cwd=local_path,
                 )
                 local_head = (await self._git("rev-parse", "HEAD", cwd=local_path)).strip()
@@ -5676,7 +5736,7 @@ class WorkspaceManager:
         try:
             await self._git(
                 "fetch", "origin",
-                f"{default_branch}:refs/remotes/origin/{default_branch}",
+                f"+{default_branch}:refs/remotes/origin/{default_branch}",
                 cwd=main_repo,
                 timeout=settings.GIT_FETCH_TIMEOUT,
                 project_key=project_key,
@@ -14017,6 +14077,7 @@ class RuntimeDaemon:
         )
         if isinstance(baseline, dict) and re.fullmatch(r"[0-9a-fA-F]{40}", after_sha):
             planned = baseline.get("task") or {}
+            source_deadline = time.monotonic() + _RUNTIME_CRITIC_SOURCE_TIMEOUT_SECONDS if planned.get("type") == "design" else None
             paths = agent_core.missing_planned_task_files({
                 "files": planned.get("files") or [], "items": planned.get("items") or [],
             }, [])
@@ -14108,17 +14169,52 @@ class RuntimeDaemon:
                     "items": related.get("items") or [],
                 }, []))
             reference_baseline = {**baseline, "related_tasks": reference_tasks}
+            document_sources = {}
+            requirement_key = str(getattr(task, "requirement_key", "") or "")
+            if source_deadline is not None and requirement_key:
+                document_paths = [path for path in dict.fromkeys([*assigned_paths, *changed_files])
+                                  if path.startswith(f"docs/requirements/{requirement_key}/implement/")
+                                  and path.endswith(".md") and ".." not in Path(path).parts
+                                  and re.fullmatch(r"[A-Za-z0-9_./-]+", path) and not _is_sensitive_local_path(path)][:8]
+                document_bytes = 0
+                for path in document_paths:
+                    seconds_left = source_deadline - time.monotonic()
+                    if seconds_left <= 0:
+                        coverage["source_collection_timed_out"] = True
+                        coverage["design_reference_documents_unavailable"] = True
+                        break
+                    try:
+                        source = await self.workspace_manager._git(
+                            "show", f"{after_sha}:{path}", cwd=workspace_path, timeout=min(10, max(1, int(seconds_left))),
+                        )
+                        encoded_size = len(source.encode("utf-8"))
+                        if document_bytes + encoded_size > _RUNTIME_CRITIC_SOURCE_MAX_BYTES:
+                            coverage["design_reference_documents_unavailable"] = True
+                            continue
+                        document_sources[path] = source
+                        document_bytes += encoded_size
+                    except Exception:
+                        coverage["design_reference_documents_unavailable"] = True
+                reference_baseline = {**reference_baseline, "task": {
+                    **planned, "description": str(planned.get("description") or "") + "\n" + "\n".join(document_sources.values()),
+                }}
             reference_candidates = _runtime_critic_reference_candidates(reference_baseline, primary_paths)
             if reference_candidates:
                 try:
                     reference_modules = sorted({
                         Path(path).parent.as_posix() for path in reference_candidates
                         if len(Path(path).parts) == 5 and Path(path).parts[:2] == ("app", "code")
-                        and Path(path).suffix.lower() == ".php"
+                        and Path(path).suffix.lower() in {".php", ".xml"}
                     })[:5]
+                    inventory_timeout = 10
+                    if source_deadline is not None:
+                        seconds_left = source_deadline - time.monotonic()
+                        if seconds_left <= 0:
+                            raise TimeoutError("Source collection deadline reached")
+                        inventory_timeout = min(10, max(1, int(seconds_left)))
                     inventory = await self.workspace_manager._git(
                         "ls-tree", "-r", "--name-only", after_sha, "--", *reference_candidates, *reference_modules,
-                        cwd=workspace_path, timeout=10,
+                        cwd=workspace_path, timeout=inventory_timeout,
                     )
                     if len(inventory.encode("utf-8")) > _RUNTIME_CRITIC_SOURCE_MAX_BYTES:
                         raise ValueError("Committed reference inventory exceeds its bounded evidence budget")
@@ -14133,15 +14229,25 @@ class RuntimeDaemon:
             coverage["candidate_files"] = len(paths)
             remaining = _RUNTIME_CRITIC_DIFF_MAX_CHARS - len(diff or "")
             source_context = []
-            for path in paths[:20]:
+            source_file_limit = _RUNTIME_CRITIC_DESIGN_MAX_FILES if planned.get("type") == "design" else 20
+            for path in paths[:source_file_limit]:
+                source_timeout = 10
+                if source_deadline is not None:
+                    seconds_left = source_deadline - time.monotonic()
+                    if seconds_left <= 0:
+                        coverage["source_collection_timed_out"] = True
+                        break
+                    source_timeout = min(10, max(1, int(seconds_left)))
                 normalized = Path(path)
                 if normalized.is_absolute() or ".." in normalized.parts or path.endswith("/"):
                     coverage["skipped_paths"] += 1
                     continue
                 try:
-                    source = await self.workspace_manager._git(
-                        "show", f"{after_sha}:{path}", cwd=workspace_path, timeout=10,
-                    )
+                    source = document_sources.get(path)
+                    if source is None:
+                        source = await self.workspace_manager._git(
+                            "show", f"{after_sha}:{path}", cwd=workspace_path, timeout=source_timeout,
+                        )
                 except Exception as error:
                     coverage["unreadable_files"] += 1
                     detail = str(error).lower()
@@ -14175,6 +14281,7 @@ class RuntimeDaemon:
         coverage["capsule_incomplete"] = (
             coverage["omitted_files"] > 0 or coverage.get("reference_inventory_unavailable", False)
             or coverage.get("verification_inventory_unavailable", False)
+            or coverage.get("design_reference_documents_unavailable", False)
         )
         result.metrics["runtime_critic_coverage"] = coverage
         if not diff:
@@ -14292,7 +14399,8 @@ class RuntimeDaemon:
                     **metadata,
                 }
             conformance = (
-                agent_core.assess_approved_plan_conformance(baseline, structured_result.get("plan_conformance"))
+                agent_core.assess_approved_plan_conformance(baseline, structured_result.get("plan_conformance"),
+                    audit_contract=(task.input_data or {}).get("implementation_audit_contract"))
                 if isinstance(baseline, dict) else None
             )
             if conformance is not None and conformance["status"] != "conformant":
@@ -14320,6 +14428,15 @@ class RuntimeDaemon:
                         "evidence": conformance["evidence_refs"],
                     },
                 }
+                if conformance.get("node_complete") and conformance["status"] == "unverified":
+                    contribution = conformance["contribution_check"]
+                    structured_result["plan_conformance"]["contribution_check"] = {
+                        "check_id": contribution["check_id"], "status": contribution["status"], "evidence": contribution["evidence_refs"],
+                    }
+                    structured_result["plan_conformance"]["pending_checks"] = [{
+                        "check_id": check["check_id"], "task_id": check["task_id"], "status": check["status"], "evidence": check["evidence_refs"],
+                        **({"blocking_reason": check["blocking_reason"]} if "blocking_reason" in check else {}),
+                    } for check in conformance["pending_checks"]]
             encoded_result = json.dumps(
                 structured_result,
                 ensure_ascii=True,
@@ -14512,6 +14629,7 @@ class RuntimeDaemon:
             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):
+                result.metrics["failure_domain"] = "delivery"
                 issues.append(_OutputValidationIssue(
                     "planned_task_incomplete",
                     f"Planned task file has no implementation evidence: {missing_path}. "
@@ -16516,7 +16634,10 @@ class RuntimeDaemon:
                 ])
 
             if (
-                agent_core.is_implementation_testing_task(task.node_type, task.input_data or {})
+                result.metrics.get("failure_domain") == "environment" and all(
+                    issue.code in {"implementation_audit_incomplete", "acceptance_criteria_uncovered"} for issue in issues
+                )
+                or agent_core.is_implementation_testing_task(task.node_type, task.input_data or {})
                 and result.metrics.get("implementation_audit_subject_blocked") is True
             ):
                 result.status = "failed"
@@ -16719,7 +16840,8 @@ class RuntimeDaemon:
                     result.failure_code = "implementation_audit_incomplete"
                     result.error = "; ".join(remaining[:3])
                     if (
-                        agent_core.is_implementation_testing_task(task.node_type, task.input_data or {})
+                        result.metrics.get("failure_domain") == "environment"
+                        or agent_core.is_implementation_testing_task(task.node_type, task.input_data or {})
                         and result.metrics.get("implementation_audit_subject_blocked") is True
                     ):
                         result.error += ". Resolve the reported verification prerequisites before retrying."

{forgexa_cli-1.85.2 → forgexa_cli-1.85.4}/forgexa_cli.egg-info/PKG-INFO

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

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