forgexa-cli 1.8.5__tar.gz → 1.8.7__tar.gz

{forgexa_cli-1.8.5 → forgexa_cli-1.8.7}/PKG-INFO

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

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

{forgexa_cli-1.8.5 → forgexa_cli-1.8.7}/forgexa_cli/daemon.py

@@ -392,7 +392,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.8.5"
+DAEMON_VERSION = "1.8.7"
 
 
 def _detect_client_type() -> str:
@@ -648,6 +648,10 @@ _ANALYSIS_OUTPUTS_BY_TYPE: dict[str, list[str]] = {
     "documentation": ["outline.md", "analysis.json"],
     "improvement": ["improvement-spec.md", "TASKS.md", "analysis.json", "test-intent.json"],
     "task": ["task-plan.md", "analysis.json"],
+    # Research / feasibility study — no PRD/SDD/TASKS, only a research plan and metadata
+    "spike": ["research.md", "analysis.json"],
+    # Customer support Q&A — lightweight answer doc + metadata only
+    "faq": ["faq-answer.md", "analysis.json"],
 }
 
 
@@ -1123,17 +1127,34 @@ class WorkspaceManager:
         )
 
         if repo_url:
+            # For non-fresh (refine/continuation) nodes, expand expect_branch to
+            # cover any node that is part of a real requirement workflow AND is not
+            # the initial analysis.  This ensures a hard error (and workspace
+            # re-clone) when the branch sync fails, rather than silently proceeding
+            # with a stale workspace that will cause a non-fast-forward push later.
+            expect_branch = bool(task.analysis_branch) or (
+                bool(task.requirement_key) and not is_fresh_start and task.node_type != "analysis"
+            )
             ws_path = await self._create_worktree(
                 project_dir, repo_url, default_branch, workspace_key, branch_name,
                 fresh_start=is_fresh_start,
                 project_key=project_key,
-                expect_branch=bool(task.analysis_branch),
+                expect_branch=expect_branch,
             )
-            # Refine mode: ensure we're on the analysis branch with its history
-            # (not reset to default_branch)
-            if analysis_mode == "refine" and task.node_type == "analysis":
+            # After workspace creation, perform a final branch-specific fetch + reset
+            # to ensure the working tree is at the absolute latest remote state.
+            # This is critical in two scenarios:
+            #   1. Analysis refine mode: must be on the analysis branch history.
+            #   2. All continuation nodes (design/coding/testing): another runtime
+            #      may have pushed commits while this runtime's agent was executing.
+            #      A final sync here keeps the workspace current so the agent works
+            #      on the latest codebase and avoids non-fast-forward push failures.
+            if not is_fresh_start:
                 try:
-                    await self._git("fetch", "origin", cwd=ws_path, project_key=project_key)
+                    await self._git(
+                        "fetch", "origin", branch_name,
+                        cwd=ws_path, project_key=project_key,
+                    )
                 except RuntimeError:
                     pass
                 try:
@@ -1141,15 +1162,28 @@ class WorkspaceManager:
                     await self._git("checkout", branch_name, cwd=ws_path)
                 except RuntimeError:
                     pass
-                # Pull latest from remote branch if it exists (preserves prior commits)
+                # Use --ff-only to keep only fast-forward changes; if the branch has
+                # diverged (force-pushed by prior phase), reset --hard is used below.
+                pulled = False
                 try:
                     await self._git(
                         "pull", "--ff-only", "origin", branch_name,
                         cwd=ws_path, project_key=project_key,
                     )
+                    pulled = True
                 except RuntimeError:
-                    # Remote branch might not exist yet or has diverged; that's OK
                     pass
+                if not pulled:
+                    # ff-only failed (diverged or remote not yet created) — try
+                    # reset --hard to force-sync to whatever the remote has.
+                    try:
+                        await self._git(
+                            "reset", "--hard", f"origin/{branch_name}",
+                            cwd=ws_path,
+                        )
+                    except RuntimeError:
+                        # Remote branch may not exist yet (first analysis on fresh repo)
+                        pass
             return ws_path
         else:
             # No repo — create a directory with git init for change tracking
@@ -1292,18 +1326,29 @@ class WorkspaceManager:
                 # only fetches the default branch.  Explicitly fetch the
                 # feature branch with a full refspec so that
                 # origin/{branch_name} is available for checkout/reset.
+                _last_sync_err: str = ""
                 try:
                     await self._git("fetch", "origin", cwd=ws_path, project_key=project_key)
-                except RuntimeError:
-                    pass
+                except RuntimeError as _pre_fe:
+                    logger.warning(
+                        "fetch origin failed for worktree %s: %s "
+                        "(likely auth/SSH issue — will retry in sync loop)",
+                        ws_path, _pre_fe,
+                    )
+                    _last_sync_err = str(_pre_fe)[:300]
                 try:
                     await self._git(
                         "fetch", "origin",
                         f"{branch_name}:refs/remotes/origin/{branch_name}",
                         cwd=ws_path, project_key=project_key,
                     )
-                except RuntimeError:
-                    pass  # Branch may not exist on remote yet
+                except RuntimeError as _pre_fe2:
+                    logger.warning(
+                        "fetch branch %s failed for worktree %s: %s "
+                        "(likely auth/SSH issue — will retry in sync loop)",
+                        branch_name, ws_path, _pre_fe2,
+                    )
+                    _last_sync_err = str(_pre_fe2)[:300]
 
                 if fresh_start:
                     # Safety check: if the branch already exists on remote with
@@ -1392,8 +1437,12 @@ class WorkspaceManager:
                                             cwd=ws_path,
                                             project_key=project_key,
                                         )
-                                    except RuntimeError:
-                                        pass
+                                    except RuntimeError as _sf:
+                                        logger.warning(
+                                            "Re-fetch %s failed (attempt %d): %s",
+                                            branch_name, _sync_attempt + 1, _sf,
+                                        )
+                                        _last_sync_err = str(_sf)[:300]
                                     continue
                                 else:
                                     logger.warning("Failed to checkout %s after retries: %s", branch_name, exc)
@@ -1419,8 +1468,12 @@ class WorkspaceManager:
                                         cwd=ws_path,
                                         project_key=project_key,
                                     )
-                                except RuntimeError:
-                                    pass
+                                except RuntimeError as _sf2:
+                                    logger.warning(
+                                        "Re-fetch %s failed (attempt %d): %s",
+                                        branch_name, _sync_attempt + 1, _sf2,
+                                    )
+                                    _last_sync_err = str(_sf2)[:300]
                             else:
                                 logger.warning(
                                     "Could not reset to origin/%s after retries: %s — "
@@ -1448,10 +1501,28 @@ class WorkspaceManager:
                                     f"Stale local clone discarded. "
                                     f"The task will be retried with a fresh clone."
                                 )
+                            # Destroy the stale worktree before raising so the
+                            # next retry can re-create it fresh from origin.
+                            # Without this, every retry hits the same broken state.
+                            try:
+                                await self._remove_broken_worktree(
+                                    main_repo, ws_path, workspace_key
+                                )
+                                logger.info(
+                                    "Removed stale worktree %s — retry will re-clone from origin",
+                                    ws_path,
+                                )
+                            except Exception as _rm_exc:
+                                logger.warning("Could not remove stale worktree %s: %s", ws_path, _rm_exc)
+                            _err_detail = (
+                                f"Git error: {_last_sync_err}" if _last_sync_err
+                                else "fetch timed out or credentials missing/invalid"
+                            )
                             raise RuntimeError(
-                                f"Failed to sync branch '{branch_name}' from remote after 3 attempts. "
+                                f"Failed to sync branch '{branch_name}' from remote after 3 attempts "
+                                f"({_err_detail}). "
                                 f"The branch should exist (pushed by prior analysis/design phase). "
-                                f"This task will be retried by the orchestrator."
+                                f"Stale local workspace discarded — this task will be retried by the orchestrator."
                             )
                         else:
                             logger.warning(
@@ -1680,12 +1751,23 @@ class WorkspaceManager:
                     # interprets backslashes as escape sequences, corrupting the
                     # path (e.g. C:\Users → C:Users).
                     key_path_safe = key_path.replace("\\", "/") if sys.platform == "win32" else key_path
+                    # RC1 (Windows): os.chmod(S_IRUSR) does not set proper NTFS ACLs.
+                    # Windows OpenSSH rejects keys that aren't exclusively owner-readable
+                    # ("UNPROTECTED PRIVATE KEY FILE").  StrictModes=no bypasses this.
+                    # RC2 (Windows): /dev/null doesn't exist on Windows native OpenSSH
+                    # (C:\Windows\System32\OpenSSH\ssh.exe). Use NUL instead.
+                    if sys.platform == "win32":
+                        _known_hosts_null = "NUL"
+                        _strict_modes_opt = " -o StrictModes=no"
+                    else:
+                        _known_hosts_null = "/dev/null"
+                        _strict_modes_opt = ""
                     env = {
                         **os.environ,
                         "GIT_SSH_COMMAND": (
                             f'ssh -i "{key_path_safe}"'
                             f" -o StrictHostKeyChecking=accept-new"
-                            f" -o UserKnownHostsFile=/dev/null"
+                            f" -o UserKnownHostsFile={_known_hosts_null}"
                             f" -o IdentitiesOnly=yes"
                             # Detect a stalled TCP connection (server accepts but
                             # never sends the git protocol banner).  After 30 s of
@@ -1695,6 +1777,7 @@ class WorkspaceManager:
                             f" -o ConnectTimeout=30"
                             f" -o ServerAliveInterval=30"
                             f" -o ServerAliveCountMax=3"
+                            f"{_strict_modes_opt}"
                         ),
                     }
                 except Exception:
@@ -5784,6 +5867,24 @@ class RuntimeDaemon:
             branch = (await git("rev-parse", "--abbrev-ref", "HEAD", cwd=workspace_path)).strip()
 
             if branch and branch != "HEAD":
+                # Always refresh the remote tracking ref before any divergence
+                # checks.  Without this, origin/{branch} may be stale if another
+                # runtime pushed commits while our agent was executing, causing
+                # the remote_ahead check to return empty and the naive push to
+                # fail with "non-fast-forward".  This is the single most reliable
+                # guard for cross-runtime / cross-machine collaboration scenarios.
+                try:
+                    await git(
+                        "fetch", "origin", branch,
+                        cwd=workspace_path, project_key=project_key,
+                    )
+                except RuntimeError as _pre_push_fetch_exc:
+                    logger.warning(
+                        "Pre-push fetch of branch '%s' failed: %s — "
+                        "divergence check will use possibly stale tracking ref",
+                        branch, _pre_push_fetch_exc,
+                    )
+
                 # Check if there are unpushed commits
                 try:
                     unpushed = (await git(
@@ -5939,11 +6040,16 @@ class RuntimeDaemon:
                                     "fetch", "origin", branch,
                                     cwd=workspace_path,
                                 )
-                                # 2. Rebase local commits onto the updated remote HEAD
+                                # 2. Rebase local commits onto the updated remote HEAD.
+                                #    Use -X theirs so that when the same file was modified by
+                                #    a previous agent run AND the current run (e.g. analysis
+                                #    docs, PRD), git automatically accepts the current run's
+                                #    version.  This is correct: on an agent-managed feature
+                                #    branch the latest agent output is always authoritative.
                                 await git(
                                     "-c", "user.name=Forgexa Agent",
                                     "-c", "user.email=agent@forgexa.net",
-                                    "rebase", f"origin/{branch}",
+                                    "rebase", "-X", "theirs", f"origin/{branch}",
                                     cwd=workspace_path,
                                 )
                                 # 3. Push normally (no force needed — we're ahead of origin now)
@@ -5953,7 +6059,7 @@ class RuntimeDaemon:
                                 )
                                 logger.info(
                                     "Fetch+rebase recovery succeeded for branch %s "
-                                    "(%d remote commit(s) incorporated)",
+                                    "(%d remote commit(s) incorporated via rebase -X theirs)",
                                     branch, remote_count,
                                 )
                                 return None
@@ -5964,17 +6070,38 @@ class RuntimeDaemon:
                                     await git("rebase", "--abort", cwd=workspace_path)
                                 except RuntimeError:
                                     pass
-                                logger.error(
-                                    "Fetch+rebase recovery failed for branch %s: %s — "
-                                    "refusing push to protect remote work",
+                                logger.warning(
+                                    "Fetch+rebase (-X theirs) recovery failed for branch %s: %s — "
+                                    "falling back to --force-with-lease (we just fetched, safe)",
                                     branch, rebase_exc_str,
                                 )
-                                return (
-                                    f"Push refused: remote branch '{branch}' has {remote_count} "
-                                    f"commit(s) not in local history, and automatic rebase failed "
-                                    f"(likely a merge conflict). Manual resolution required. "
-                                    f"Details: {rebase_exc_str[:300]}"
-                                )
+                                # Fallback: --force-with-lease is safe here because we just ran
+                                # `git fetch origin {branch}`, so our lease ref is current.
+                                # Agent-managed feature branches have no concurrent human writers,
+                                # so the latest agent run always wins.
+                                try:
+                                    await git(
+                                        "push", "--force-with-lease", "-u", "origin", branch,
+                                        cwd=workspace_path, project_key=project_key,
+                                    )
+                                    logger.info(
+                                        "Force-with-lease fallback push succeeded for branch %s",
+                                        branch,
+                                    )
+                                    return None
+                                except RuntimeError as force_exc:
+                                    force_exc_str = str(force_exc)
+                                    logger.error(
+                                        "Force-with-lease fallback also failed for branch %s: %s",
+                                        branch, force_exc_str,
+                                    )
+                                    return (
+                                        f"Push refused: remote branch '{branch}' has {remote_count} "
+                                        f"commit(s) not in local history, rebase (-X theirs) failed, "
+                                        f"and force-with-lease fallback also failed. "
+                                        f"Rebase error: {rebase_exc_str[:200]} | "
+                                        f"Force error: {force_exc_str[:200]}"
+                                    )
 
                     logger.info("Found unpushed commits on %s, pushing...", branch)
                     last_push_exc: Exception | None = None

{forgexa_cli-1.8.5 → forgexa_cli-1.8.7}/forgexa_cli.egg-info/PKG-INFO

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

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