forgexa-cli 1.84.2__tar.gz → 1.84.4__tar.gz

{forgexa_cli-1.84.2 → forgexa_cli-1.84.4}/PKG-INFO

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

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

{forgexa_cli-1.84.2 → forgexa_cli-1.84.4}/forgexa_cli/agent_core.py

@@ -85,19 +85,29 @@ def assess_approved_plan_conformance(baseline: dict, report: object) -> dict:
     ).encode()).hexdigest()
     if baseline.get("version") != 1 or result["baseline_fingerprint"] != fingerprint:
         result["reason"] = "approved_plan_baseline_invalid"
+        result["diagnostic_code"] = "approved_plan_baseline_invalid"
         return result
-    if not isinstance(report, dict) or (
-        report.get("baseline_fingerprint") != fingerprint
-        or report.get("task_id") != result["task_id"]
-        or report.get("status") not in ("conformant", "deviation", "unverified")
-    ):
+    if not isinstance(report, dict):
+        result["reason"] = "approved_plan_review_missing_or_mismatched"
+        result["diagnostic_code"] = "approved_plan_review_missing" if report is None else "approved_plan_review_invalid_payload"
+        return result
+    diagnostic = None
+    if report.get("baseline_fingerprint") != fingerprint:
+        diagnostic = "approved_plan_review_baseline_mismatch"
+    elif report.get("task_id") != result["task_id"]:
+        diagnostic = "approved_plan_review_task_mismatch"
+    elif report.get("status") not in ("conformant", "deviation", "unverified"):
+        diagnostic = "approved_plan_review_status_invalid"
+    if diagnostic is not None:
         result["reason"] = "approved_plan_review_missing_or_mismatched"
+        result["diagnostic_code"] = diagnostic
         return result
     evidence = report.get("evidence")
     if not isinstance(evidence, list) or not evidence or any(
         not isinstance(item, str) or not item.strip() for item in evidence
     ):
         result["reason"] = "approved_plan_review_evidence_missing"
+        result["diagnostic_code"] = "approved_plan_review_evidence_missing"
         return result
     result["status"] = report["status"]
     result["evidence_refs"] = [hashlib.sha256(item.encode()).hexdigest() for item in evidence]
@@ -419,10 +429,18 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
                 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"
-                    )
+                    if criterion_count == 0:
+                        issues.append(
+                            f"Acceptance index {index} is invalid because the frozen baseline has no acceptance criteria; "
+                            "return acceptance_checks=[] and retain all approved task obligations. If approved documents "
+                            "prove criteria are missing, request an evidenced plan_revision instead of inventing or "
+                            "renumbering requirements"
+                        )
+                    else:
+                        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

{forgexa_cli-1.84.2 → forgexa_cli-1.84.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.84.2"
+DAEMON_VERSION = "1.84.4"
 
 
 def _detect_client_type() -> str:
@@ -1668,7 +1668,8 @@ Review only the supplied task context, code diff and committed source snapshots.
 isolated review capsule, not the project workspace. Do not write or modify files,
 run mutating commands, create commits, or make network changes.
 
-Return exactly one JSON object with this schema:
+Return exactly one JSON object. This base schema must be extended with the task-bound
+plan_conformance field when a frozen approved baseline is supplied:
 {
   "verdict": "approve" | "request_changes" | "reject",
   "score": 0.0 to 1.0,
@@ -1741,9 +1742,19 @@ def _build_runtime_critic_prompt(
             "Implementation details may refine it but cannot silently replace its responsibilities, "
             "interfaces, required files or acceptance criteria. Report insufficient evidence honestly.",
             json.dumps(baseline, ensure_ascii=True, sort_keys=True),
-            'Also return "plan_conformance":{"baseline_fingerprint":"<frozen fingerprint>",'
-            '"task_id":"<frozen task id>","status":"conformant|deviation|unverified",'
-            '"evidence":["concrete supplied source/test reference"]}. '
+            "Bound review response example:\n" + json.dumps({
+                "verdict": "request_changes", "score": 0.5,
+                "summary": "<independent assessment of the supplied source and required checks>",
+                "dimension_scores": {}, "issues": [], "plan_conformance": {
+                    "baseline_fingerprint": baseline.get("fingerprint"),
+                    "task_id": (baseline.get("task") or {}).get("id"), "status": "unverified",
+                    "evidence": ["<concrete independently inspected source or check evidence>"],
+                },
+            }, ensure_ascii=True, separators=(",", ":")),
+            "The task-bound field is mandatory, including when issues is empty. Preserve its exact task_id "
+            "and baseline_fingerprint; do not substitute a requirement key, node UUID or your own digest. "
+            "Replace placeholder evidence with observed facts. Choose conformant, deviation or unverified "
+            "honestly; the example defaults to unverified and is not completion evidence. "
             "Assess every assigned obligation, including behavior omitted from the diff. "
             "Use deviation for an actual conflict or omission; use unverified when supplied evidence "
             "cannot establish conformance. A high quality score never replaces this conclusion. "
@@ -3018,10 +3029,17 @@ def _is_sensitive_local_path(path: str) -> bool:
     return any(pattern.search(normalized) for pattern in _LOCAL_BIND_SENSITIVE_PATH_PATTERNS)
 
 
-def _runtime_critic_reference_candidates(baseline: dict, source_paths: list[str]) -> list[str]:
+def _runtime_critic_reference_candidates(
+    baseline: dict, source_paths: list[str], *, inventory: list[str] | None = None,
+) -> list[str]:
     planned = baseline.get("task") or {}
     texts = [str(planned.get("description") or "")]
     texts.extend(str(item.get("description") or "") for item in planned.get("items") or [] if isinstance(item, dict))
+    if planned.get("type") in ("testing", "review"):
+        for related in baseline.get("related_tasks") or []:
+            if isinstance(related, dict):
+                texts.append(str(related.get("description") or ""))
+                texts.extend(str(item.get("description") or "") for item in related.get("items") or [] if isinstance(item, dict))
     if planned.get("type") == "design":
         texts.append(json.dumps({"analysis": baseline.get("approved_analysis"),
                                  "documents": baseline.get("analysis_documents")}, ensure_ascii=True)[:200_000])
@@ -3042,6 +3060,7 @@ def _runtime_critic_reference_candidates(baseline: dict, source_paths: list[str]
             return None
         return normalized
 
+    php_context = any(Path(path).suffix.lower() == ".php" for path in source_paths)
     directories = {Path(path).parent.as_posix() for path in source_paths if safe_path(path)} - {"."}
     explicit = set()
     for token in re.findall(r"(?<![\w./\\:-])[A-Za-z0-9_.-]+(?:/[A-Za-z0-9_.-]+)+", text):
@@ -3051,16 +3070,39 @@ def _runtime_critic_reference_candidates(baseline: dict, source_paths: list[str]
         if Path(candidate).suffix.lower() in suffixes:
             explicit.add(candidate)
             directories.add(Path(candidate).parent.as_posix())
-        elif not Path(candidate).suffix:
+        elif not Path(candidate).suffix and not (
+            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)
     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,
     ))
+    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,
+        ))
+        bare_text = re.sub(r"(?<!\w)(?:[A-Za-z]:[\\/]|/|\.\.?/)[^\s,;()]+", " ", text)
+        names.update(name + ".php" for name in re.findall(
+            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
+        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"):
+            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:
+                candidates.add(path)
+            continue
         candidates.update(path for directory in sorted(directories)[:5]
                           if (path := safe_path(f"{directory}/{name}")) is not None)
+        if name.endswith(".php"):
+            candidates.update(f"{root}/{name}" for root in module_roots)
     return sorted(candidates - set(source_paths))[:128]
 
 
@@ -3158,6 +3200,10 @@ class _WorkspaceFileLock:
             handle.close()
 
 
+class _FreshAnalysisBranchError(RuntimeError):
+    code = "fresh_analysis_branch_reset_blocked"
+
+
 class WorkspaceManager:
     """Manages isolated workspaces per task using git worktrees."""
 
@@ -4787,6 +4833,55 @@ class WorkspaceManager:
             pass
         return False
 
+    async def _prepare_cloud_fresh_branch(
+        self, repository: Path, branch_name: str, default_branch: str, *, project_key: str,
+    ) -> None:
+        branch_ref = f"refs/heads/{branch_name}"
+        backup_ref = None
+        backup_ready = False
+        try:
+            if branch_name == default_branch:
+                raise RuntimeError("Fresh analysis cannot reset the project default branch")
+            await self._git("check-ref-format", branch_ref, cwd=repository)
+            for name in (default_branch, branch_name):
+                await self._git(
+                    "fetch", "origin", f"+{name}:refs/remotes/origin/{name}", cwd=repository,
+                    timeout=settings.GIT_FETCH_TIMEOUT, project_key=project_key,
+                )
+            old_sha = (await self._git("rev-parse", "--verify", f"refs/remotes/origin/{branch_name}", cwd=repository)).strip()
+            default_sha = (await self._git("rev-parse", "--verify", f"refs/remotes/origin/{default_branch}", cwd=repository)).strip()
+            if not all(re.fullmatch(r"[0-9a-fA-F]{40}", value) for value in (old_sha, default_sha)):
+                raise RuntimeError("Fresh analysis requires verified remote branch commits")
+            if old_sha == default_sha:
+                return
+            backup_ref = f"refs/tags/forgexa/fresh-analysis-backup/{branch_name}/{old_sha}"
+            await self._git("check-ref-format", backup_ref, cwd=repository)
+            existing = (await self._git(
+                "ls-remote", "--tags", "origin", backup_ref, cwd=repository,
+                timeout=settings.GIT_FETCH_TIMEOUT, project_key=project_key,
+            )).strip()
+            if existing:
+                if existing.split()[0] != old_sha:
+                    raise RuntimeError("Fresh analysis recovery reference has a different commit")
+            else:
+                await self._git(
+                    "push", "origin", f"{old_sha}:{backup_ref}", cwd=repository,
+                    timeout=settings.GIT_PUSH_TIMEOUT, project_key=project_key,
+                )
+            backup_ready = True
+            await self._git(
+                "push", f"--force-with-lease={branch_ref}:{old_sha}", "origin", f"{default_sha}:{branch_ref}",
+                cwd=repository, timeout=settings.GIT_PUSH_TIMEOUT, project_key=project_key,
+            )
+            await self._git("update-ref", f"refs/remotes/origin/{branch_name}", default_sha, cwd=repository)
+            logger.info("Prepared fresh analysis branch %s after preserving %s", branch_name, backup_ref)
+        except RuntimeError as error:
+            recovery = f" Recovery reference: {backup_ref}." if backup_ready else ""
+            raise _FreshAnalysisBranchError(
+                "Fresh analysis branch preparation failed; do not run the Agent or delete the remote branch."
+                + recovery + " " + self._git_push_diagnostic(error)
+            ) from error
+
     async def _branch_has_impl_commits(
         self, ws_path: Path, branch_name: str, default_branch: str,
     ) -> bool:
@@ -5208,19 +5303,8 @@ class WorkspaceManager:
                         fresh_start = False
 
                 if fresh_start:
-                    # Safety check: if the branch already has IMPLEMENTATION commits
-                    # beyond the default branch, do NOT reset to origin/default_branch
-                    # — that would destroy prior design/coding/testing work.
-                    #
-                    # Previous behaviour blocked the reset whenever *any* remote commit
-                    # existed, including analysis-only commits (PRD.md, cleanup wipes).
-                    # That was overly conservative: a branch whose only commits are
-                    # analysis documents is safe to reset for a fresh re-analysis
-                    # because no code has been written yet.
-                    #
-                    # The new check distinguishes:
-                    #   • analysis-only commits → safe to reset → allow fresh start
-                    #   • implementation commits (design/coding/testing) → block reset
+                    # Preserve existing implementation history before preparing a
+                    # confirmed fresh baseline; a failed preparation must stop here.
                     branch_has_impl = False
                     ahead_count = 0
                     try:
@@ -5239,55 +5323,9 @@ class WorkspaceManager:
                         )
 
                     if branch_has_impl:
-                        logger.warning(
-                            "Fresh start requested for %s: remote branch has implementation "
-                            "commit(s) ahead of %s — deleting remote branch to ensure "
-                            "a clean analysis environment (user explicitly chose fresh analysis)",
-                            branch_name, default_branch,
+                        await self._prepare_cloud_fresh_branch(
+                            ws_path, branch_name, default_branch, project_key=project_key,
                         )
-                        # When the user explicitly chooses "fresh analysis", they want a clean
-                        # slate.  Deleting the remote branch achieves this: the agent runs on
-                        # a new branch forked from default, completely free of prior
-                        # implementation commits that may have been wrong or irrelevant.
-                        # This is intentional and safe because:
-                        #   1. The user selected fresh analysis (not refine) — they accept
-                        #      that prior work on this branch will be discarded.
-                        #   2. Keeping the old implementation commits would contaminate the
-                        #      fresh analysis with incorrect context (the original bug report).
-                        #   3. "Refine" mode preserves the branch — fresh mode does not.
-                        try:
-                            await self._git(
-                                "push", "origin", "--delete", branch_name,
-                                cwd=ws_path,
-                                timeout=settings.GIT_PUSH_TIMEOUT,
-                                project_key=project_key,
-                            )
-                            logger.info(
-                                "Deleted remote branch %s for fresh analysis restart",
-                                branch_name,
-                            )
-                            # Also remove local branch reference so checkout -B below starts clean
-                            try:
-                                await self._git("branch", "-D", branch_name, cwd=ws_path)
-                            except RuntimeError:
-                                pass  # Local branch may not exist; not an error
-                            # Remove the remote-tracking ref so git doesn't think the
-                            # branch still exists on the remote
-                            try:
-                                await self._git(
-                                    "update-ref", "-d", f"refs/remotes/origin/{branch_name}",
-                                    cwd=ws_path,
-                                )
-                            except RuntimeError:
-                                pass
-                        except RuntimeError as _del_err:
-                            logger.warning(
-                                "Failed to delete remote branch %s: %s — "
-                                "proceeding with reset to origin/%s instead",
-                                branch_name, _del_err, default_branch,
-                            )
-                        # fresh_start remains True: checkout -B below will recreate
-                        # the branch from origin/default_branch
                     elif ahead_count > 0:
                         # Branch has commits but they are all analysis-only (safe to reset).
                         logger.info(
@@ -5667,11 +5705,8 @@ class WorkspaceManager:
                 except RuntimeError as exc:
                     last_branch_fetch_error = self._summarize_git_error(exc)
 
-        # Fresh analysis with an existing remote branch that has implementation commits:
-        # delete the remote branch so the agent starts from a clean slate.
-        # We must do this check here (new worktree path) as well as in the existing
-        # worktree path above, because the daemon that runs a fresh re-analysis may
-        # never have processed this requirement before (no ws_path yet).
+        # Prepare the same recoverable fresh baseline on runtimes without a
+        # previous worktree for this requirement.
         if fresh_start and branch_exists_remote:
             # Check for implementation commits — same logic as in the existing worktree path.
             _new_branch_has_impl = False
@@ -5691,44 +5726,9 @@ class WorkspaceManager:
                 )
 
             if _new_branch_has_impl:
-                logger.warning(
-                    "Fresh analysis (new worktree) for %s: remote branch has implementation "
-                    "commit(s) — deleting remote branch for a clean analysis environment",
-                    branch_name,
+                await self._prepare_cloud_fresh_branch(
+                    main_repo, branch_name, default_branch, project_key=project_key,
                 )
-                try:
-                    await self._git(
-                        "push", "origin", "--delete", branch_name,
-                        cwd=main_repo,
-                        timeout=settings.GIT_PUSH_TIMEOUT,
-                        project_key=project_key,
-                    )
-                    logger.info(
-                        "Deleted remote branch %s for fresh analysis restart (new worktree path)",
-                        branch_name,
-                    )
-                    # Remove local branch ref and remote-tracking ref
-                    try:
-                        await self._git("branch", "-D", branch_name, cwd=main_repo)
-                    except RuntimeError:
-                        pass
-                    try:
-                        await self._git(
-                            "update-ref", "-d", f"refs/remotes/origin/{branch_name}",
-                            cwd=main_repo,
-                        )
-                    except RuntimeError:
-                        pass
-                    # Branch no longer exists on remote
-                    branch_exists_remote = False
-                except RuntimeError as _del_err2:
-                    logger.warning(
-                        "Failed to delete remote branch %s (new worktree path): %s — "
-                        "proceeding with worktree add from default branch",
-                        branch_name, _del_err2,
-                    )
-                    # Treat as if branch doesn't exist to force fresh worktree
-                    branch_exists_remote = False
 
         if expect_branch and not fresh_start and not branch_exists_remote:
             self._safe_rmtree(ws_path)
@@ -13988,6 +13988,7 @@ class RuntimeDaemon:
             paths = agent_core.missing_planned_task_files({
                 "files": planned.get("files") or [], "items": planned.get("items") or [],
             }, [])
+            assigned_paths = list(paths)
             primary_paths = list(paths)
             if planned.get("type") in ("testing", "review") and getattr(task, "requirement_key", ""):
                 output_dir = str((task.input_data or {}).get("output_dir") or "").replace("\\", "/").rstrip("/")
@@ -14011,6 +14012,7 @@ class RuntimeDaemon:
                         path for path in support_paths.splitlines()[:20]
                         if path.startswith(directory + "/") and path.endswith((".ts", ".js", ".py"))
                     )
+            reference_tasks = []
             audit_contract = (task.input_data or {}).get("implementation_audit_contract")
             if isinstance(audit_contract, dict) and baseline.get("plan_id") is not None and audit_contract.get("plan_id") == baseline["plan_id"]:
                 approved_tasks = {entry["id"]: entry for entry in audit_contract.get("tasks") or [] if isinstance(entry, dict) and isinstance(entry.get("id"), str)}
@@ -14038,6 +14040,8 @@ class RuntimeDaemon:
                     visited.add(dependency_id)
                     dependency = approved_tasks.get(dependency_id)
                     if dependency is not None:
+                        if audit_contract.get("subject_task_id") == planned.get("id"):
+                            reference_tasks.append(dependency)
                         dependency_paths = agent_core.missing_planned_task_files({
                             "files": (dependency.get("input") or {}).get("files") or [],
                             "items": dependency.get("items") or [],
@@ -14050,19 +14054,29 @@ class RuntimeDaemon:
                     "files": (related.get("input") or {}).get("files") or [],
                     "items": related.get("items") or [],
                 }, []))
-            reference_candidates = _runtime_critic_reference_candidates(baseline, primary_paths)
+            reference_baseline = {**baseline, "related_tasks": reference_tasks}
+            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"
+                    })[:5]
                     inventory = await self.workspace_manager._git(
-                        "ls-tree", "-r", "--name-only", after_sha, "--", *reference_candidates,
+                        "ls-tree", "-r", "--name-only", after_sha, "--", *reference_candidates, *reference_modules,
                         cwd=workspace_path, timeout=10,
                     )
-                    confirmed = [path for path in inventory.splitlines() if path in reference_candidates]
+                    if len(inventory.encode("utf-8")) > _RUNTIME_CRITIC_SOURCE_MAX_BYTES:
+                        raise ValueError("Committed reference inventory exceeds its bounded evidence budget")
+                    inventory_paths = inventory.splitlines()
+                    inventory_set = set(inventory_paths)
+                    reference_candidates = _runtime_critic_reference_candidates(reference_baseline, primary_paths, inventory=inventory_paths)
+                    confirmed = [path for path in reference_candidates if path in inventory_set]
                     paths = [*primary_paths, *confirmed, *paths]
                 except Exception:
                     coverage["reference_inventory_unavailable"] = True
-            paths.extend(changed_files)
-            paths = list(dict.fromkeys(paths))
+            paths = list(dict.fromkeys([*assigned_paths, *changed_files, *paths]))
             coverage["candidate_files"] = len(paths)
             remaining = _RUNTIME_CRITIC_DIFF_MAX_CHARS - len(diff or "")
             source_context = []
@@ -14094,7 +14108,7 @@ class RuntimeDaemon:
                 diff = (diff or "No new changes; review committed delivery instead.") + "".join(source_context)
         coverage["full_source_files"] = len(committed_sources)
         coverage["omitted_files"] = coverage["candidate_files"] - coverage["full_source_files"]
-        coverage["capsule_incomplete"] = coverage["omitted_files"] > 0
+        coverage["capsule_incomplete"] = coverage["omitted_files"] > 0 or coverage.get("reference_inventory_unavailable", False)
         result.metrics["runtime_critic_coverage"] = coverage
         if not diff:
             return {
@@ -14207,8 +14221,23 @@ class RuntimeDaemon:
                     "agent_attempts": [attempt],
                     **metadata,
                 }
-            if not task.local_evidence_upload and isinstance(baseline, dict):
-                conformance = agent_core.assess_approved_plan_conformance(baseline, structured_result.get("plan_conformance"))
+            conformance = (
+                agent_core.assess_approved_plan_conformance(baseline, structured_result.get("plan_conformance"))
+                if isinstance(baseline, dict) else None
+            )
+            if conformance is not None and conformance["status"] != "conformant":
+                diagnostic_lines = [f"[daemon] Local independent review: {conformance['status']}."]
+                if conformance.get("reason"):
+                    diagnostic_lines.append(
+                        "[daemon] Review contract diagnostic: " + conformance.get("diagnostic_code", conformance["reason"])
+                    )
+                else:
+                    diagnostic_lines.extend(
+                        "[daemon] Review evidence: " + re.sub(r"https?://\S+", "[redacted-url]", item.replace("\x00", ""))[:600]
+                        for item in structured_result["plan_conformance"]["evidence"][:10]
+                    )
+                _append_local_bind_output_log(task.task_id, diagnostic_lines)
+            if not task.local_evidence_upload and conformance is not None:
                 score = structured_result.get("score")
                 verdict = structured_result.get("verdict")
                 structured_result = {
@@ -14369,6 +14398,7 @@ class RuntimeDaemon:
 
         audit_contract = input_data.get("implementation_audit_contract")
         result.metrics.pop("implementation_audit_node_complete", None)
+        result.metrics.pop("implementation_audit_subject_blocked", None)
         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))
@@ -14382,6 +14412,11 @@ class RuntimeDaemon:
             result.metrics["implementation_audit_node_complete"] = bool(
                 audit_result["report_valid"] and audit_result["node_complete"]
             )
+            result.metrics["implementation_audit_subject_blocked"] = bool(
+                audit_result["report_valid"] and not audit_result["node_complete"]
+                and any(finding.get("task_id") == audit_contract.get("subject_task_id") and finding.get("status") == "blocked"
+                        for finding in audit_result.get("findings") or [])
+            )
             if audit_result["report_valid"] and audit_result["status"] == "plan_revision_required":
                 result.status = "failed"
                 result.failure_code = "implementation_plan_revision_required"
@@ -16405,6 +16440,21 @@ class RuntimeDaemon:
                     *[f"[daemon] {issue}" for issue in issues],
                 ])
 
+            if (
+                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"
+                result.failure_code = "implementation_audit_incomplete"
+                result.error = (
+                    str(next((issue for issue in issues if issue.code == "implementation_audit_incomplete"), issues[0]))
+                    + ". Resolve the reported verification prerequisites before retrying; "
+                    "rewriting artifacts does not execute blocked acceptance checks."
+                )
+                _record_output_validation_issues(result, issues)
+                self._record_testing_telemetry(workspace_path, task, result, retries_used=attempt)
+                return result
+
             if (
                 agent_core.is_implementation_testing_task(task.node_type, task.input_data or {})
                 and all(
@@ -16593,6 +16643,11 @@ class RuntimeDaemon:
                 elif audit_incomplete:
                     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 {})
+                        and result.metrics.get("implementation_audit_subject_blocked") is True
+                    ):
+                        result.error += ". Resolve the reported verification prerequisites before retrying."
                 else:
                     result.failure_code = "validation_retry_exhausted"
                     result.error = (

{forgexa_cli-1.84.2 → forgexa_cli-1.84.4}/forgexa_cli.egg-info/PKG-INFO

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

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