forgexa-cli 1.22.2__tar.gz → 1.22.4__tar.gz

{forgexa_cli-1.22.2 → forgexa_cli-1.22.4}/PKG-INFO

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

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

{forgexa_cli-1.22.2 → forgexa_cli-1.22.4}/forgexa_cli/daemon.py

@@ -555,7 +555,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.22.2"
+DAEMON_VERSION = "1.22.4"
 
 
 def _detect_client_type() -> str:
@@ -1012,6 +1012,8 @@ class TaskResult:
     # Key values:
     #   "all_agents_rate_limited" — daemon tried every installed agent, all
     #       hit rate/quota limits.  Server must NOT retry on the same runtime.
+    #   "validation_retry_exhausted" — required-output validation still failed
+    #       after the allowed repair agents.  Server must not auto-retry it.
     failure_code: str = ""
     # Optional structured preflight result for project/runtime preflight failures.
     preflight: dict | None = None
@@ -2615,7 +2617,10 @@ class WorkspaceManager:
 
     async def _remove_broken_worktree(self, main_repo: Path, ws_path: Path, workspace_key: str):
         """Remove a broken worktree directory and clean up stale worktree refs."""
-        # Try to prune from main repo first
+        # `git worktree prune` keeps an entry while its directory exists, even
+        # when that directory's .git pointer is corrupt.
+        self._safe_rmtree(ws_path)
+
         if main_repo.exists():
             try:
                 await self._git("worktree", "prune", cwd=main_repo)
@@ -2625,9 +2630,6 @@ class WorkspaceManager:
             wt_ref = main_repo / ".git" / "worktrees" / workspace_key
             if wt_ref.exists():
                 self._safe_rmtree(wt_ref)
-        # Remove the broken worktree directory using _safe_rmtree so that
-        # read-only git objects on Windows are properly handled.
-        self._safe_rmtree(ws_path)
 
     async def _safe_rmtree_main(self, main_repo: Path) -> None:
         """Remove _main repo, first evicting all linked worktrees to prevent orphans.
@@ -2675,8 +2677,10 @@ class WorkspaceManager:
         self,
         main_repo: Path,
         branch_name: str,
+        *,
+        healthy_only: bool = True,
     ) -> Path | None:
-        """Return an existing healthy linked worktree already on branch_name."""
+        """Return a linked worktree already on branch_name."""
         try:
             raw = await self._git("worktree", "list", "--porcelain", cwd=main_repo)
         except RuntimeError:
@@ -2702,7 +2706,9 @@ class WorkspaceManager:
         for candidate_path, candidate_branch in entries:
             if candidate_path == main_repo or candidate_branch != target_ref:
                 continue
-            if candidate_path.exists() and await self._is_healthy_worktree(candidate_path, main_repo=main_repo):
+            if not candidate_path.exists():
+                continue
+            if not healthy_only or await self._is_healthy_worktree(candidate_path, main_repo=main_repo):
                 return candidate_path
 
         return None
@@ -3825,6 +3831,43 @@ class WorkspaceManager:
                     cwd=main_repo,
                 )
             except Exception as exc:
+                existing_branch_worktree = await self._find_existing_worktree_for_branch(
+                    main_repo, branch_name,
+                )
+                if existing_branch_worktree is not None:
+                    logger.info(
+                        "Fresh start reusing worktree %s after resetting %s to origin/%s",
+                        existing_branch_worktree, branch_name, default_branch,
+                    )
+                    await self._git(
+                        "checkout", "-B", branch_name, f"origin/{default_branch}",
+                        cwd=existing_branch_worktree,
+                    )
+                    return existing_branch_worktree
+
+                stale_branch_worktree = await self._find_existing_worktree_for_branch(
+                    main_repo, branch_name, healthy_only=False,
+                )
+                if stale_branch_worktree is not None:
+                    logger.warning(
+                        "Fresh start found broken worktree %s holding branch %s; removing it before retrying",
+                        stale_branch_worktree, branch_name,
+                    )
+                    try:
+                        await self._remove_broken_worktree(
+                            main_repo, stale_branch_worktree, stale_branch_worktree.name,
+                        )
+                        await self._git(
+                            "branch", "-f", branch_name, f"origin/{default_branch}",
+                            cwd=main_repo,
+                        )
+                        await self._git(
+                            "worktree", "add", str(ws_path), branch_name,
+                            cwd=main_repo,
+                        )
+                        return ws_path
+                    except Exception as recovery_exc:
+                        exc = recovery_exc
                 self._safe_rmtree(ws_path)
                 raise RuntimeError(
                     f"Failed to create clean fresh worktree for branch '{branch_name}'. "
@@ -7692,6 +7735,22 @@ def _extract_testing_artifacts(workspace_path: Path, output_dir: str) -> dict |
         return None
 
 
+def _case_evidence_entries(value: Any) -> list[dict[str, Any]]:
+    """Normalize list and keyed-object case_evidence forms into entries."""
+    if isinstance(value, list):
+        return [entry for entry in value if isinstance(entry, dict)]
+    if isinstance(value, dict):
+        entries: list[dict[str, Any]] = []
+        for case_id, entry in value.items():
+            if not isinstance(entry, dict):
+                continue
+            normalized = dict(entry)
+            normalized.setdefault("test_case_id", str(case_id))
+            entries.append(normalized)
+        return entries
+    return []
+
+
 def _validate_test_evidence(
     base: Path, workspace_path: Path, e2e_case_ids: list[str], max_anchor_checks: int = 50
 ) -> list[str]:
@@ -7725,12 +7784,13 @@ def _validate_test_evidence(
             "must ground their selectors/routes in source-file evidence."
         )
 
-    case_evidence = ev.get("case_evidence") or []
-    covered_ids = {
-        str(entry.get("test_case_id"))
-        for entry in case_evidence
-        if isinstance(entry, dict) and entry.get("test_case_id")
-    }
+    case_evidence = _case_evidence_entries(ev.get("case_evidence"))
+    entries_by_case_id: dict[str, list[dict[str, Any]]] = {}
+    for entry in case_evidence:
+        case_id = str(entry.get("test_case_id") or "").strip()
+        if case_id:
+            entries_by_case_id.setdefault(case_id, []).append(entry)
+    covered_ids = set(entries_by_case_id)
     missing_cases = [cid for cid in e2e_case_ids if cid not in covered_ids]
     if missing_cases:
         issues.append(
@@ -7739,6 +7799,54 @@ def _validate_test_evidence(
             f"with route_refs/locator_refs."
         )
 
+    route_ids = {
+        str(route.get("id"))
+        for route in routes
+        if isinstance(route, dict) and route.get("id")
+    }
+    locator_ids = {
+        str(locator.get("id"))
+        for locator in locators
+        if isinstance(locator, dict) and locator.get("id")
+    }
+    for case_id in e2e_case_ids:
+        entries = entries_by_case_id.get(case_id, [])
+        if not entries:
+            continue
+        if len(entries) > 1:
+            issues.append(
+                f"test-evidence.json has multiple case_evidence entries for e2e test case "
+                f"{case_id}. Keep exactly one entry per test case."
+            )
+            continue
+        entry = entries[0]
+        route_refs = entry.get("route_refs")
+        locator_refs = entry.get("locator_refs")
+        if not isinstance(route_refs, list) or not isinstance(locator_refs, list):
+            issues.append(
+                f"test-evidence.json case_evidence for {case_id} must define "
+                "route_refs and locator_refs as arrays."
+            )
+            continue
+        if not route_refs and not locator_refs:
+            issues.append(
+                f"test-evidence.json case_evidence for {case_id} must reference at least "
+                "one route or locator."
+            )
+            continue
+        unknown_routes = [str(ref) for ref in route_refs if str(ref) not in route_ids]
+        unknown_locators = [str(ref) for ref in locator_refs if str(ref) not in locator_ids]
+        if unknown_routes:
+            issues.append(
+                f"test-evidence.json case_evidence for {case_id} references unknown "
+                f"route_refs: {unknown_routes[:10]}."
+            )
+        if unknown_locators:
+            issues.append(
+                f"test-evidence.json case_evidence for {case_id} references unknown "
+                f"locator_refs: {unknown_locators[:10]}."
+            )
+
     checked = 0
     for item in list(locators) + list(routes):
         if checked >= max_anchor_checks:
@@ -8969,9 +9077,9 @@ class RuntimeDaemon:
             # 4.5 Layer 2: Validation gate — check outputs before committing
             if result.status == "success":
                 try:
-                    result = await self._validate_and_retry(
+                    result, agent = await self._validate_with_agent_fallback(
                         agent, task, workspace_path, result,
-                        reporter, on_output_chunk, max_retries=2,
+                        reporter, on_output_chunk, tried_agents=tried_agents,
                         default_branch=default_branch, before_sha=node_before_sha,
                     )
                     # Re-collect git info if validation triggered retries
@@ -9023,9 +9131,9 @@ class RuntimeDaemon:
                         # failure) — re-run the validation gate and update git state.
                         if result.status == "success":
                             try:
-                                result = await self._validate_and_retry(
+                                result, agent = await self._validate_with_agent_fallback(
                                     agent, task, workspace_path, result,
-                                    reporter, on_output_chunk, max_retries=2,
+                                    reporter, on_output_chunk, tried_agents=tried_agents,
                                     default_branch=default_branch, before_sha=node_before_sha,
                                 )
                                 pre_commit_git = await self.process_manager._collect_git_info(workspace_path)
@@ -9230,7 +9338,11 @@ class RuntimeDaemon:
             result.metrics["actual_agent"] = agent.agent_id
             if agent.agent_id != task.agent_type:
                 result.metrics["original_agent"] = task.agent_type
-                result.metrics["fallback_reason"] = fallback_reason
+                result.metrics["fallback_reason"] = (
+                    result.metrics.get("fallback_reason")
+                    or fallback_reason
+                    or "validation_retry_exhausted"
+                )
             await reporter.report_progress(task.task_id, 100, "completed" if result.status == "success" else "failed")
             await reporter.report_complete(task.task_id, result)
 
@@ -10069,6 +10181,78 @@ class RuntimeDaemon:
 
         return info
 
+    async def _validate_with_agent_fallback(
+        self,
+        agent: "DiscoveredAgent",
+        task: TaskInfo,
+        workspace_path: Path,
+        result: TaskResult,
+        reporter: "ProgressReporter",
+        on_chunk: Any,
+        tried_agents: set[str],
+        default_branch: str = "",
+        before_sha: str = "",
+    ) -> tuple[TaskResult, "DiscoveredAgent"]:
+        """Repair blocking validation failures without repeating an agent blindly."""
+        tried_agents.add(agent.agent_id)
+        result = await self._validate_and_retry(
+            agent,
+            task,
+            workspace_path,
+            result,
+            reporter,
+            on_chunk,
+            max_retries=1,
+            default_branch=default_branch,
+            before_sha=before_sha,
+        )
+        if result.status != "failed" or result.failure_code != "validation_retry_exhausted":
+            return result, agent
+
+        fallback_agent = self._select_fallback_agent(
+            agent.agent_id,
+            task.fallback_chain,
+            tried_agents,
+        )
+        if not fallback_agent:
+            result.metrics["validation_agents_tried"] = sorted(tried_agents)
+            result.metrics["validation_agent_fallback_available"] = False
+            result.error = (
+                f"{result.error} No alternate agent is available on this runtime; "
+                "retry after selecting a different agent or runtime."
+            )
+            return result, agent
+
+        tried_agents.add(fallback_agent.agent_id)
+        await reporter.report_progress(
+            task.task_id,
+            92,
+            f"validation_agent_fallback:{fallback_agent.agent_id}",
+            output_lines=[
+                "[daemon] Required-output validation still failed after the first repair, "
+                f"switching from {agent.agent_id} to {fallback_agent.agent_id}.",
+            ],
+        )
+        previous_retries = int(result.metrics.get("validation_retries_used", 0) or 0)
+        result = await self._validate_and_retry(
+            fallback_agent,
+            task,
+            workspace_path,
+            result,
+            reporter,
+            on_chunk,
+            max_retries=1,
+            default_branch=default_branch,
+            before_sha=before_sha,
+        )
+        result.metrics["validation_agents_tried"] = sorted(tried_agents)
+        result.metrics["validation_agent_fallback_available"] = True
+        result.metrics["validation_retries_used"] = previous_retries + int(
+            result.metrics.get("validation_retries_used", 0) or 0
+        )
+        result.metrics["fallback_reason"] = "validation_retry_exhausted"
+        return result, fallback_agent
+
     async def _validate_and_retry(
         self,
         agent: "DiscoveredAgent",
@@ -10085,8 +10269,10 @@ class RuntimeDaemon:
 
         Layer 2 of the reflection mechanism.  Runs deterministic checks
         (file existence, syntax, JSON validity) after agent completion but
-        before git commit.  If issues are found, builds a fix prompt listing
-        all problems and re-invokes the same agent.
+        before git commit. If issues are found, builds a fix prompt listing all
+        problems and gives the current agent one focused repair attempt. The
+        caller routes a still-blocking failure to a different agent when one is
+        available.
 
         Returns the (possibly updated) TaskResult.
         """
@@ -10204,13 +10390,27 @@ class RuntimeDaemon:
             )
         remaining = self._validate_outputs(workspace_path, task, result)
         if remaining:
-            # Distinguish critical issues (no output produced) from minor ones (syntax)
+            # Distinguish blocking artifact-contract failures from advisory syntax
+            # warnings. Evidence coverage and references are release-blocking even
+            # when the file itself exists.
             scope_violations = [
                 issue
                 for issue in remaining
                 if issue.startswith("Verification work item modified requirement analysis assets:")
             ]
-            critical_patterns = ("missing", "not found", "is empty")
+            critical_patterns = (
+                "missing",
+                "not found",
+                "is empty",
+                "not valid json",
+                "case_evidence",
+                "test-evidence.json has no",
+                "evidence item",
+                "anchor not found",
+                "uncovered acceptance criteria",
+                "no p0 priority test cases",
+                "contains no test cases",
+            )
             critical_issues = [
                 iss for iss in remaining
                 if any(p in iss.lower() for p in critical_patterns)
@@ -10228,8 +10428,9 @@ class RuntimeDaemon:
                     result.failure_code = "verification_work_item_scope_violation"
                     result.error = "; ".join(scope_violations[:3])
                 else:
+                    result.failure_code = "validation_retry_exhausted"
                     result.error = (
-                        f"Agent failed to produce required output after {max_retries} retries: "
+                        "Agent failed to satisfy required output validation: "
                         + "; ".join(critical_issues[:3])
                     )
             else:

{forgexa_cli-1.22.2 → forgexa_cli-1.22.4}/forgexa_cli.egg-info/PKG-INFO

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

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