forgexa-cli 1.14.4__tar.gz → 1.14.6__tar.gz

{forgexa_cli-1.14.4 → forgexa_cli-1.14.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.14.4
+Version: 1.14.6
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License: MIT

{forgexa_cli-1.14.4 → forgexa_cli-1.14.6}/forgexa_cli/__init__.py

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

{forgexa_cli-1.14.4 → forgexa_cli-1.14.6}/forgexa_cli/daemon.py

@@ -523,7 +523,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.14.4"
+DAEMON_VERSION = "1.14.6"
 
 
 def _detect_client_type() -> str:
@@ -1709,6 +1709,35 @@ class WorkspaceManager:
         )
         return any(marker in err for marker in retry_markers)
 
+    @staticmethod
+    def _safe_rmtree(path: Path) -> None:
+        """Remove a directory tree, handling read-only files on Windows.
+
+        On Windows, git object files (.git/objects/**/*) are stored read-only
+        (mode 0444).  Plain shutil.rmtree(path, ignore_errors=True) silently
+        skips those files, leaving the directory intact.  A subsequent
+        git clone then fails with 'destination path already exists and is
+        not an empty directory'.
+
+        This method uses the onerror callback to chmod each entry writable
+        before retrying — the established pattern for handling git repos on
+        Windows.
+        """
+        import shutil
+        import stat as _stat
+
+        if not path.exists():
+            return
+
+        def _handle_readonly(func, entry_path, excinfo):
+            try:
+                os.chmod(entry_path, _stat.S_IWRITE | _stat.S_IREAD | _stat.S_IRWXU)
+                func(entry_path)
+            except Exception:
+                pass  # Best-effort: if even chmod fails, ignore
+
+        shutil.rmtree(path, onerror=_handle_readonly)
+
     async def _clone_repo(
         self,
         repo_url: str,
@@ -1718,8 +1747,6 @@ class WorkspaceManager:
         project_key: str = "default",
         max_attempts: int = 3,
     ) -> None:
-        import shutil
-
         last_exc: RuntimeError | None = None
         for attempt in range(1, max_attempts + 1):
             try:
@@ -1737,7 +1764,8 @@ class WorkspaceManager:
                     # Clean up any partial directory git may have created before giving up.
                     # If not cleaned up now, _is_healthy_worktree will detect it as broken
                     # on the next call and remove it, but cleaning here gives a faster path.
-                    shutil.rmtree(dest, ignore_errors=True)
+                    # Use _safe_rmtree to handle read-only git objects on Windows.
+                    self._safe_rmtree(dest)
                     raise
 
                 logger.warning(
@@ -1748,7 +1776,9 @@ class WorkspaceManager:
                     dest,
                     exc,
                 )
-                shutil.rmtree(dest, ignore_errors=True)
+                # Use _safe_rmtree so that read-only git objects on Windows are
+                # properly removed before the next clone attempt.
+                self._safe_rmtree(dest)
                 await asyncio.sleep(attempt * 5)
 
         if last_exc is not None:
@@ -1959,7 +1989,6 @@ 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."""
-        import shutil
         # Try to prune from main repo first
         if main_repo.exists():
             try:
@@ -1969,9 +1998,10 @@ class WorkspaceManager:
             # Also remove the worktree ref if it still exists
             wt_ref = main_repo / ".git" / "worktrees" / workspace_key
             if wt_ref.exists():
-                shutil.rmtree(wt_ref, ignore_errors=True)
-        # Remove the broken worktree directory
-        shutil.rmtree(ws_path, ignore_errors=True)
+                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.
@@ -1979,16 +2009,15 @@ class WorkspaceManager:
         A linked worktree's .git file contains «gitdir: <main>/.git/worktrees/<n>».
         Deleting _main without first removing linked worktrees leaves those
         directories with a dangling .git pointer — `_is_healthy_worktree` then
-        flags them broken and `_remove_broken_worktree` calls shutil.rmtree on
+        flags them broken and `_remove_broken_worktree` calls _safe_rmtree on
         any active workspace, silently discarding uncommitted work.
 
         Strategy:
           1. Use git worktree list --porcelain to enumerate linked worktrees.
-          2. shutil.rmtree each linked worktree directory (excluding _main itself).
-          3. shutil.rmtree _main.
+          2. _safe_rmtree each linked worktree directory (excluding _main itself).
+          3. _safe_rmtree _main.
         If git is unavailable (already corrupted), fall back to a directory scan.
         """
-        import shutil as _shutil
         if not main_repo.exists():
             return
         linked: list[Path] = []
@@ -2011,8 +2040,10 @@ class WorkspaceManager:
                     linked.append(child)
         for wt in linked:
             logger.info("Evicting linked worktree %s before deleting _main", wt)
-            _shutil.rmtree(wt, ignore_errors=True)
-        _shutil.rmtree(main_repo, ignore_errors=True)
+            self._safe_rmtree(wt)
+        # Use _safe_rmtree so that read-only git objects on Windows
+        # (e.g. .git/objects/**/* stored as 0444) are properly removed.
+        self._safe_rmtree(main_repo)
 
     async def _find_existing_worktree_for_branch(
         self,
@@ -2364,13 +2395,52 @@ class WorkspaceManager:
 
                     if branch_has_impl:
                         logger.warning(
-                            "Fresh start requested for %s but remote branch has implementation "
-                            "commit(s) ahead of %s — switching to safe sync to avoid "
-                            "destroying prior implementation work",
+                            "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,
                         )
-                        # Override: fall through to the non-fresh sync path
-                        fresh_start = False
+                        # 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, 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(
@@ -2565,6 +2635,23 @@ class WorkspaceManager:
                     main_repo,
                 )
                 await self._safe_rmtree_main(main_repo)
+                # Verify deletion succeeded (on Windows, rmtree can silently fail
+                # on read-only git objects — _safe_rmtree should handle this, but
+                # add a fallback guard to provide a clear error if it still exists).
+                if main_repo.exists():
+                    logger.warning(
+                        "_main at %s still exists after rmtree (files may be locked). "
+                        "Attempting one more forced removal before re-clone.",
+                        main_repo,
+                    )
+                    self._safe_rmtree(main_repo)
+                if main_repo.exists():
+                    raise RuntimeError(
+                        f"Cannot re-clone: {main_repo} could not be fully removed "
+                        f"(files may be locked by another process on Windows). "
+                        f"Please stop the daemon, manually delete '{main_repo}', "
+                        f"then restart."
+                    )
                 try:
                     await self._clone_repo(
                         repo_url,
@@ -2573,7 +2660,7 @@ class WorkspaceManager:
                         project_key=project_key,
                     )
                 except Exception:
-                    shutil.rmtree(main_repo, ignore_errors=True)
+                    self._safe_rmtree(main_repo)
                     raise
                 # Use targeted fetch instead of --all to avoid pulling every branch/tag
                 # from potentially large repos.  Use GIT_FETCH_TIMEOUT (default 1800 s)
@@ -2607,23 +2694,26 @@ class WorkspaceManager:
                                 project_key=project_key,
                             )
                         except Exception:
-                            shutil.rmtree(main_repo, ignore_errors=True)
+                            self._safe_rmtree(main_repo)
                             raise
                     else:
                         raise
 
         # --single-branch clone only fetches the default branch.
-        # Explicitly fetch the feature branch so origin/{branch_name}
-        # is available for worktree creation and checkout.
-        if not fresh_start:
-            try:
-                await self._git(
-                    "fetch", "origin",
-                    f"{branch_name}:refs/remotes/origin/{branch_name}",
-                    cwd=main_repo, timeout=60, project_key=project_key,
-                )
-            except RuntimeError:
-                pass  # Branch may not exist on remote yet (first analysis)
+        # Always explicitly fetch the feature branch so origin/{branch_name}
+        # is available for:
+        #   - refine mode: we need the existing commits to check out
+        #   - fresh mode: we need to detect if the branch exists and has
+        #     implementation commits (to delete it before recreating)
+        # A missing branch (first-ever analysis) is silently ignored.
+        try:
+            await self._git(
+                "fetch", "origin",
+                f"{branch_name}:refs/remotes/origin/{branch_name}",
+                cwd=main_repo, timeout=60, project_key=project_key,
+            )
+        except RuntimeError:
+            pass  # Branch may not exist on remote yet (first analysis)
 
         # Prune stale worktree references (e.g. directories deleted externally
         # when simulating cross-runtime or after disk cleanup).  Without this,
@@ -2681,6 +2771,67 @@ class WorkspaceManager:
                 except RuntimeError:
                     pass
 
+        # 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).
+        if fresh_start and branch_exists_remote:
+            # Check for implementation commits — same logic as in the existing worktree path.
+            _new_branch_has_impl = False
+            try:
+                _new_ahead_count_raw = await self._git(
+                    "rev-list", "--count",
+                    f"origin/{default_branch}..origin/{branch_name}",
+                    cwd=main_repo,
+                )
+                _new_ahead_count = int(_new_ahead_count_raw.strip()) if _new_ahead_count_raw.strip() else 0
+            except (RuntimeError, ValueError):
+                _new_ahead_count = 0
+
+            if _new_ahead_count > 0:
+                _new_branch_has_impl = await self._branch_has_impl_commits(
+                    main_repo, branch_name, default_branch,
+                )
+
+            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,
+                )
+                try:
+                    await self._git(
+                        "push", "origin", "--delete", branch_name,
+                        cwd=main_repo, 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 branch_exists_remote and not fresh_start:
             # Branch exists on remote and we want to preserve it (refine mode)
             # First, update local branch ref to match remote (in case it's stale)
@@ -2835,9 +2986,18 @@ class WorkspaceManager:
                     # passing -o StrictModes=no to the SSH client is invalid and causes:
                     #   "command-line: line 0: Bad configuration option: strictmodes"
                     # RC2 (Windows): /dev/null doesn't exist on Windows native OpenSSH
-                    # (C:\Windows\System32\OpenSSH\ssh.exe). Use NUL instead.
+                    # (C:\Windows\System32\OpenSSH\ssh.exe). Use a temp file next
+                    # to the SSH key instead of bare "NUL": git-for-windows MSYS2
+                    # SSH treats "NUL" as a relative path and may write accepted
+                    # host keys to a file named NUL in the git worktree CWD,
+                    # which pollutes `git status` output and confuses agents.
                     if sys.platform == "win32":
-                        _known_hosts_null = "NUL"
+                        _kh_temp = key_path + ".known_hosts"
+                        try:
+                            open(_kh_temp, "a").close()
+                            _known_hosts_null = _kh_temp.replace("\\", "/")
+                        except OSError:
+                            _known_hosts_null = "NUL"  # fallback to null device
                         try:
                             import subprocess as _subp
                             _username = (
@@ -2969,6 +3129,11 @@ class WorkspaceManager:
                         os.unlink(key_file)
                     except OSError:
                         pass
+                    # Clean up the known_hosts temp file created alongside the key
+                    try:
+                        os.unlink(key_file + ".known_hosts")
+                    except OSError:
+                        pass
         if proc.returncode != 0:
             raise RuntimeError(f"git {' '.join(args)} failed:\n{stderr.decode()}")
         return stdout.decode()
@@ -4362,6 +4527,7 @@ class ProcessManager:
         on_chunk: Any = None,
         *,
         _retry_without_effort: bool = False,
+        _isolated_copilot_home: str | None = None,
     ) -> TaskResult:
         """Run GitHub Copilot CLI in non-interactive JSON-streaming mode.
 
@@ -4383,10 +4549,41 @@ class ProcessManager:
           makes the CLI return exitCode=1 in the JSONL result event immediately
           without calling any tools.  Making it opt-in avoids this incompatibility
           while still allowing operators to tune effort on supported versions.
+
+        Session isolation:
+          Each invocation creates a fresh per-task COPILOT_HOME (temp dir) so
+          the coding agent always starts with an empty session-state database.
+          Without this, a retry for the same workspace finds the completed todos
+          from the prior attempt and reports "no tracked work items", producing
+          no output files.  Mirrors the _run_opencode XDG_DATA_HOME pattern.
         """
+        # Create per-task isolated COPILOT_HOME to prevent stale session state
+        # from a previous run causing "no tracked work items" on retry.
+        # The Copilot coding agent keys sessions by workspace path; if
+        # session-state persists from the prior attempt all todos are already
+        # "done" and the agent exits immediately without producing any output.
+        _is_outer_call = _isolated_copilot_home is None
+        if _is_outer_call:
+            master_home = self._prepare_copilot_home()
+            _isolated_copilot_home = tempfile.mkdtemp(prefix=f"copilot-{task_id[:8]}-")
+            try:
+                for child in Path(master_home).iterdir():
+                    if child.name in {"session-state", "logs"}:
+                        continue
+                    dest = Path(_isolated_copilot_home) / child.name
+                    try:
+                        if child.is_dir():
+                            shutil.copytree(str(child), str(dest), dirs_exist_ok=True)
+                        elif child.is_file():
+                            shutil.copy2(str(child), str(dest))
+                    except Exception as _cp_exc:
+                        logger.debug("Copilot home copy %s -> %s: %s", child, dest, _cp_exc)
+            except Exception as _iter_exc:
+                logger.debug("Copilot home isolation warning: %s", _iter_exc)
+
         env = os.environ.copy()
         env["TERM"] = "dumb"  # suppress TTY-detection that suspends the process
-        env["COPILOT_HOME"] = self._prepare_copilot_home()
+        env["COPILOT_HOME"] = _isolated_copilot_home
 
         model_override = os.environ.get("FACTORY_COPILOT_MODEL")
         # FACTORY_COPILOT_REASONING is opt-in: only pass --effort when the env
@@ -4510,6 +4707,7 @@ class ProcessManager:
                     return await self._run_copilot(
                         agent, prompt, cwd, timeout, task_id, on_chunk,
                         _retry_without_effort=True,
+                        _isolated_copilot_home=_isolated_copilot_home,
                     )
                 # Exhausted retries — emit an actionable diagnostic hint
                 if effective_rc == 1 and _no_tools and not copilot_specific_error:
@@ -4555,6 +4753,8 @@ class ProcessManager:
             )
         finally:
             self.active_processes.pop(task_id, None)
+            if _is_outer_call:
+                shutil.rmtree(_isolated_copilot_home, ignore_errors=True)
 
     async def _run_generic(
         self, agent: DiscoveredAgent, prompt: str, cwd: Path, timeout: int, task_id: str,
@@ -5106,28 +5306,47 @@ class ProcessManager:
 
         return info
 
-    async def _collect_git_info_vs_parent(self, cwd: Path) -> dict:
-        """Collect git diff stats comparing HEAD vs merge-base with default branch.
+    async def _collect_git_info_vs_parent(
+        self,
+        cwd: Path,
+        *,
+        default_branch: str = "",
+        before_sha: str = "",
+    ) -> dict:
+        """Collect git diff stats comparing HEAD vs merge-base with the base branch.
 
-        Uses merge-base to capture ALL changes on the feature branch, not just
+        Uses merge-base to capture ALL changes on the current branch, not just
         the last commit (agents like claude may create multiple commits).
-        Falls back to HEAD~1 if merge-base detection fails.
+        Prefers the project's configured default branch, then falls back to the
+        conventional `main` / `master` refs. Falls back to HEAD~1 if merge-base
+        detection fails.
         """
         info: dict[str, Any] = {}
         try:
-            # Try to find merge-base with origin's default branch
-            base_ref = "HEAD~1"
-            for candidate in ("origin/master", "origin/main"):
-                proc_mb = await asyncio.create_subprocess_exec(
-                    "git", "merge-base", candidate, "HEAD",
-                    stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE,
-                    cwd=str(cwd),
-                )
-                mb_stdout, _ = await asyncio.wait_for(proc_mb.communicate(), timeout=10)
-                if proc_mb.returncode == 0 and mb_stdout.strip():
-                    base_ref = mb_stdout.decode().strip()
-                    break
+            # Prefer the exact pre-node HEAD when available so the diff is
+            # scoped to this node's work, not the whole requirement branch.
+            base_ref = str(before_sha or "").strip() or "HEAD~1"
+            if not str(before_sha or "").strip():
+                candidate_refs: list[str] = []
+                for candidate in (default_branch, "main", "master"):
+                    candidate = str(candidate or "").strip()
+                    if not candidate:
+                        continue
+                    ref = candidate if candidate.startswith("origin/") else f"origin/{candidate}"
+                    if ref not in candidate_refs:
+                        candidate_refs.append(ref)
+
+                for candidate in candidate_refs:
+                    proc_mb = await asyncio.create_subprocess_exec(
+                        "git", "merge-base", candidate, "HEAD",
+                        stdout=asyncio.subprocess.PIPE,
+                        stderr=asyncio.subprocess.PIPE,
+                        cwd=str(cwd),
+                    )
+                    mb_stdout, _ = await asyncio.wait_for(proc_mb.communicate(), timeout=10)
+                    if proc_mb.returncode == 0 and mb_stdout.strip():
+                        base_ref = mb_stdout.decode().strip()
+                        break
 
             # Changed files since branch point
             proc = await asyncio.create_subprocess_exec(
@@ -5173,6 +5392,8 @@ class ProcessManager:
             )
             stdout4, _ = await asyncio.wait_for(proc4.communicate(), timeout=10)
             info["commit_sha"] = stdout4.decode().strip()
+            info["before_sha"] = base_ref
+            info["after_sha"] = info["commit_sha"]
 
         except Exception as e:
             logger.debug("Git info (vs parent) collection failed: %s", e)
@@ -6364,6 +6585,8 @@ class RuntimeDaemon:
     async def _execute_task(self, task: TaskInfo, conn: ServerConnection):
         """Execute a single task, reporting to the originating server connection."""
         reporter = conn.reporter
+        default_branch = str((task.project or {}).get("default_branch") or "").strip()
+        node_before_sha = ""
         # Use workspace-level granularity (requirement_workflow_id or graph_id) so that
         # tasks for DIFFERENT requirements can run in parallel on the same daemon, while
         # tasks for the SAME requirement (e.g. analysis + retry) are still serialized to
@@ -6543,6 +6766,19 @@ class RuntimeDaemon:
                                 output_dir_norm, task.task_id,
                             )
 
+            try:
+                node_before_sha = (
+                    await self.workspace_manager._git(
+                        "rev-parse", "HEAD", cwd=workspace_path, timeout=30,
+                    )
+                ).strip()
+            except Exception as _before_sha_err:
+                logger.debug(
+                    "Could not resolve pre-node HEAD for task %s: %s",
+                    task.task_id,
+                    _before_sha_err,
+                )
+
             # 3. Run agent with real-time output streaming + periodic progress heartbeat
             await reporter.report_progress(task.task_id, 10, "running_agent")
 
@@ -6615,7 +6851,11 @@ class RuntimeDaemon:
             _skip_fallback = False
             if self.process_manager.is_rate_limited(result):
                 _pre_fallback_git = await self.process_manager._collect_git_info(workspace_path)
-                _pre_fallback_committed = await self.process_manager._collect_git_info_vs_parent(workspace_path)
+                _pre_fallback_committed = await self.process_manager._collect_git_info_vs_parent(
+                    workspace_path,
+                    default_branch=default_branch,
+                    before_sha=node_before_sha,
+                )
                 has_workspace_changes = (
                     bool(_pre_fallback_git.get("files_changed"))
                     or bool(_pre_fallback_committed.get("files_changed"))
@@ -6726,7 +6966,11 @@ class RuntimeDaemon:
             # (e.g., after rate-limit fallback, or API errors not caught by output parsing).
             if result.status == "success" and task.node_type in ("coding", "fix", "testing"):
                 has_uncommitted = bool(pre_commit_git.get("files_changed"))
-                committed_git = await self.process_manager._collect_git_info_vs_parent(workspace_path)
+                committed_git = await self.process_manager._collect_git_info_vs_parent(
+                    workspace_path,
+                    default_branch=default_branch,
+                    before_sha=node_before_sha,
+                )
                 has_committed = bool(committed_git.get("files_changed"))
                 has_tokens = (
                     int(result.metrics.get("token_input", 0) or 0)
@@ -6764,7 +7008,11 @@ class RuntimeDaemon:
                 )
                 if can_attempt_recovery:
                     original_exit_code = result.exit_code
-                    committed_git = await self.process_manager._collect_git_info_vs_parent(workspace_path)
+                    committed_git = await self.process_manager._collect_git_info_vs_parent(
+                        workspace_path,
+                        default_branch=default_branch,
+                        before_sha=node_before_sha,
+                    )
                     has_committed_changes = bool(committed_git.get("files_changed"))
                     has_uncommitted_changes = bool(pre_commit_git.get("files_changed"))
                     has_no_uncommitted = not has_uncommitted_changes
@@ -6888,7 +7136,11 @@ class RuntimeDaemon:
             # 4.55 Analysis/design/fix nodes must update their deliverables in THIS run.
             # Existing files from a prior iteration are not sufficient evidence.
             if result.status == "success" and task.node_type in ("analysis", "design", "fix"):
-                committed_git = await self.process_manager._collect_git_info_vs_parent(workspace_path)
+                committed_git = await self.process_manager._collect_git_info_vs_parent(
+                    workspace_path,
+                    default_branch=default_branch,
+                    before_sha=node_before_sha,
+                )
                 git_check_passed = self.process_manager._has_required_deliverable_updates(
                     task,
                     pre_commit_git.get("files_changed"),
@@ -7002,7 +7254,11 @@ class RuntimeDaemon:
                             )
                             result.error = f"Git push failed: {push_err}"
                 # Re-collect git info after commit (compare with parent)
-                post_commit_git = await self.process_manager._collect_git_info_vs_parent(workspace_path)
+                post_commit_git = await self.process_manager._collect_git_info_vs_parent(
+                    workspace_path,
+                    default_branch=default_branch,
+                    before_sha=node_before_sha,
+                )
                 # Merge: use the pre-commit file list if post-commit is empty
                 result.git = post_commit_git
                 if not result.git.get("files_changed") and pre_commit_git.get("files_changed"):
@@ -9385,12 +9641,20 @@ class RuntimeDaemon:
                                             if line.startswith("+ ")
                                         ]
                                         if not new_shas:
-                                            # Nothing genuinely new — remote is already
-                                            # up-to-date, treat as success.
+                                            # Remote already has equivalent content under
+                                            # different SHAs. Align local HEAD to the
+                                            # canonical remote tip before reporting
+                                            # success so later git metadata does not point
+                                            # at a local-only commit.
+                                            await git(
+                                                "reset", "--hard", f"origin/{branch}",
+                                                cwd=workspace_path,
+                                            )
                                             logger.info(
                                                 "Recovery: no truly new commits on %s — "
-                                                "remote already has equivalent content",
-                                                branch,
+                                                "remote already has equivalent content; "
+                                                "reset local branch to origin/%s",
+                                                branch, branch,
                                             )
                                             return None
                                         # Reset local branch to match remote exactly,

{forgexa_cli-1.14.4 → forgexa_cli-1.14.6}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.14.4
+Version: 1.14.6
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License: MIT

{forgexa_cli-1.14.4 → forgexa_cli-1.14.6}/pyproject.toml

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