forgexa-cli 1.4.2__tar.gz → 1.6.1__tar.gz

{forgexa_cli-1.4.2 → forgexa_cli-1.6.1}/PKG-INFO

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

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

{forgexa_cli-1.4.2 → forgexa_cli-1.6.1}/forgexa_cli/daemon.py

@@ -279,6 +279,10 @@ except (ImportError, ModuleNotFoundError):
         def AGENT_TIMEOUT(self) -> int:
             return int(os.environ.get("AGENT_TIMEOUT", "3600"))
 
+        @property
+        def GIT_CLONE_TIMEOUT(self) -> int:
+            return int(os.environ.get("GIT_CLONE_TIMEOUT", "600"))
+
         @property
         def AGENT_MAX_OUTPUT_SIZE(self) -> int:
             return int(os.environ.get("AGENT_MAX_OUTPUT_SIZE", "100000"))
@@ -303,7 +307,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.4.2"
+DAEMON_VERSION = "1.6.1"
 
 
 def _detect_client_type() -> str:
@@ -469,9 +473,12 @@ def get_os_info() -> str:
             return f"{distro} {machine}"
         return f"Linux {platform.release().split('-')[0]} {machine}"
     elif system == "Windows":
-        # e.g. "Windows 10.0 AMD64"
-        win_ver = platform.version().split('.')[0:2]
-        return f"Windows {'.'.join(win_ver)} {machine}"
+        # platform.version() returns the NT kernel version (10.0.x) for BOTH
+        # Windows 10 and Windows 11, so it cannot distinguish them.
+        # platform.win32_ver()[0] returns the marketing release: "10" or "11".
+        win_release = platform.win32_ver()[0] or platform.version().split('.')[0]
+        build = platform.version()  # e.g. "10.0.26200"
+        return f"Windows {win_release} ({build}) {machine}"
     else:
         return f"{system} {platform.release()} {machine}"
 
@@ -865,12 +872,19 @@ class WorkspaceManager:
             branch_name = f"feature/{workspace_key}"
 
         # Determine whether this node is the "first" in a new graph that needs
-        # a fresh base from the default branch.  Analysis nodes always start
-        # fresh unless using "refine" mode which preserves the existing branch.
-        analysis_mode = task.input_data.get("analysis_mode", "fresh")
+        # a fresh base from the default branch.  Only analysis nodes with
+        # explicit analysis_mode="fresh" should start fresh.  All other modes
+        # (including the default when no mode is specified) preserve the
+        # existing branch to avoid destroying prior implementation commits.
+        #
+        # SAFETY: Defaulting to "refine" ensures that any code path which
+        # forgets to set analysis_mode will safely preserve the branch.
+        # Only the initial requirement analysis endpoint (requirements.py)
+        # explicitly passes "fresh" when creating a brand-new requirement branch.
+        analysis_mode = task.input_data.get("analysis_mode", "refine")
         is_fresh_start = (
             task.node_type == "analysis"
-            and analysis_mode != "refine"
+            and analysis_mode == "fresh"
         )
 
         if repo_url:
@@ -973,11 +987,52 @@ class WorkspaceManager:
                 logger.warning("Broken worktree detected at %s — removing and recreating", ws_path)
                 await self._remove_broken_worktree(main_repo, ws_path, workspace_key)
             else:
-                # Healthy worktree — fetch and optionally reset
+                # Healthy worktree — fetch and optionally reset.
+                # The _main repo uses --single-branch, so `git fetch origin`
+                # only fetches the default branch.  Explicitly fetch the
+                # feature branch with a full refspec so that
+                # origin/{branch_name} is available for checkout/reset.
                 try:
                     await self._git("fetch", "origin", cwd=ws_path, project_key=project_key)
                 except RuntimeError:
                     pass
+                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
+
+                if fresh_start:
+                    # Safety check: if the branch already exists on remote with
+                    # commits beyond the default branch, do NOT reset to
+                    # origin/default_branch — that would destroy prior work.
+                    # This guards against accidental branch destruction when
+                    # analysis_mode is incorrectly set to "fresh" for
+                    # verification or iterative nodes.
+                    branch_has_remote_commits = False
+                    try:
+                        result = await self._git(
+                            "rev-list", "--count",
+                            f"origin/{default_branch}..origin/{branch_name}",
+                            cwd=ws_path,
+                        )
+                        ahead_count = int(result.strip()) if result.strip() else 0
+                        branch_has_remote_commits = ahead_count > 0
+                    except (RuntimeError, ValueError):
+                        pass  # Branch may not exist on remote yet
+
+                    if branch_has_remote_commits:
+                        logger.warning(
+                            "Fresh start requested for %s but remote branch has %d commit(s) "
+                            "ahead of %s — switching to safe sync instead of resetting to "
+                            "avoid destroying prior work",
+                            branch_name, ahead_count, default_branch,
+                        )
+                        # Override: fall through to the non-fresh sync path
+                        fresh_start = False
 
                 if fresh_start:
                     logger.info("Fresh start: resetting %s to origin/%s", ws_path, default_branch)
@@ -1032,7 +1087,9 @@ class WorkspaceManager:
                                     await asyncio.sleep(2 * (_sync_attempt + 1))
                                     try:
                                         await self._git(
-                                            "fetch", "origin", cwd=ws_path,
+                                            "fetch", "origin",
+                                            f"{branch_name}:refs/remotes/origin/{branch_name}",
+                                            cwd=ws_path,
                                             project_key=project_key,
                                         )
                                     except RuntimeError:
@@ -1057,7 +1114,9 @@ class WorkspaceManager:
                                 await asyncio.sleep(2 * (_sync_attempt + 1))
                                 try:
                                     await self._git(
-                                        "fetch", "origin", cwd=ws_path,
+                                        "fetch", "origin",
+                                        f"{branch_name}:refs/remotes/origin/{branch_name}",
+                                        cwd=ws_path,
                                         project_key=project_key,
                                     )
                                 except RuntimeError:
@@ -1085,10 +1144,26 @@ class WorkspaceManager:
 
         # Ensure _main repo is present and up-to-date
         if not main_repo.exists():
-            await self._git("clone", repo_url, str(main_repo), timeout=600, project_key=project_key)
+            await self._git(
+                "clone", "--single-branch", "--no-tags",
+                repo_url, str(main_repo), timeout=settings.GIT_CLONE_TIMEOUT, project_key=project_key,
+            )
         else:
             await self._git("fetch", "--all", cwd=main_repo, timeout=300, project_key=project_key)
 
+        # --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)
+
         # Prune stale worktree references (e.g. directories deleted externally
         # when simulating cross-runtime or after disk cleanup).  Without this,
         # `git worktree add` refuses to create a branch that is "already checked out"
@@ -1137,7 +1212,11 @@ class WorkspaceManager:
                 )
                 await asyncio.sleep(2 * (_check_attempt + 1))
                 try:
-                    await self._git("fetch", "--all", cwd=main_repo, timeout=60, project_key=project_key)
+                    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
 
@@ -1173,7 +1252,10 @@ class WorkspaceManager:
                         )
                     except Exception:
                         ws_path.mkdir(parents=True, exist_ok=True)
-                        await self._git("clone", repo_url, str(ws_path), project_key=project_key)
+                        await self._git(
+                            "clone", "--single-branch", "--no-tags",
+                            repo_url, str(ws_path), timeout=settings.GIT_CLONE_TIMEOUT, project_key=project_key,
+                        )
                         # Ensure we're on the correct branch after clone
                         try:
                             await self._git("checkout", "-B", branch_name, cwd=ws_path)
@@ -1195,7 +1277,10 @@ class WorkspaceManager:
                 except Exception:
                     # Fallback to simple clone
                     ws_path.mkdir(parents=True, exist_ok=True)
-                    await self._git("clone", repo_url, str(ws_path), project_key=project_key)
+                    await self._git(
+                        "clone", "--single-branch", "--no-tags",
+                        repo_url, str(ws_path), timeout=settings.GIT_CLONE_TIMEOUT, project_key=project_key,
+                    )
                     # Ensure we're on the correct branch after clone
                     try:
                         await self._git("checkout", "-B", branch_name, cwd=ws_path)
@@ -1214,6 +1299,18 @@ class WorkspaceManager:
 
         If a project SSH key is registered, remote-touching commands
         (clone, fetch, pull, push) will use GIT_SSH_COMMAND.
+
+        Process-group isolation: git is started in its own session so that
+        SIGKILL on timeout propagates to all of git's children (especially
+        the ssh subprocess that git forks for remote operations).  Without
+        this, killing git leaves orphaned ssh processes that hold the stderr
+        pipe open — preventing asyncio from detecting EOF and causing the
+        parent to hang until the GIT_CLONE_TIMEOUT fires.
+
+        SSH keepalives: GIT_SSH_COMMAND now includes ServerAliveInterval=30
+        and ServerAliveCountMax=3 so that a stalled TCP connection (server
+        accepts but never sends the git protocol banner) is detected within
+        ~90 s rather than waiting forever.
         """
         env = None
         git_prefix_args: list[str] = []
@@ -1242,6 +1339,14 @@ class WorkspaceManager:
                             f" -o StrictHostKeyChecking=accept-new"
                             f" -o UserKnownHostsFile=/dev/null"
                             f" -o IdentitiesOnly=yes"
+                            # Detect a stalled TCP connection (server accepts but
+                            # never sends the git protocol banner).  After 30 s of
+                            # silence the client sends a keepalive; after 3 missed
+                            # responses (≤ 90 s total) SSH exits, closes the pipes,
+                            # and lets asyncio's communicate() return.
+                            f" -o ConnectTimeout=30"
+                            f" -o ServerAliveInterval=30"
+                            f" -o ServerAliveCountMax=3"
                         ),
                     }
                 except Exception:
@@ -1261,18 +1366,53 @@ class WorkspaceManager:
                 if git_prefix_args:
                     env = {**(env or os.environ), "GIT_TERMINAL_PROMPT": "0"}
 
+        # start_new_session=True puts git in its own process group.
+        # On timeout we send SIGKILL to the entire group, which includes
+        # any ssh/gpg/credential-helper children that git forked — preventing
+        # orphaned processes from keeping pipes alive.
+        # Windows note: start_new_session creates a new console process group;
+        # we use taskkill /T there instead of killpg.
         proc = await asyncio.create_subprocess_exec(
             "git", *git_prefix_args, *args,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
             cwd=str(cwd) if cwd else None,
             env=env,
+            start_new_session=True,
         )
         try:
             stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
         except (TimeoutError, asyncio.TimeoutError):
-            proc.kill()
-            await proc.wait()
+            # Kill the entire process group so that SSH (and any other
+            # child processes git may have spawned) are also terminated.
+            # A plain proc.kill() only kills the direct child (git); the
+            # ssh grandchild becomes orphaned, keeps the stderr pipe open,
+            # and proc.communicate() can never return EOF.
+            try:
+                if sys.platform != "win32":
+                    import signal as _signal
+                    try:
+                        os.killpg(os.getpgid(proc.pid), _signal.SIGKILL)
+                    except (ProcessLookupError, PermissionError, OSError):
+                        pass
+                else:
+                    # Windows: taskkill /F /T kills the process tree
+                    import subprocess as _subprocess
+                    _subprocess.run(
+                        ["taskkill", "/F", "/T", "/PID", str(proc.pid)],
+                        capture_output=True,
+                    )
+            except Exception:
+                pass
+            finally:
+                try:
+                    proc.kill()
+                except Exception:
+                    pass
+            try:
+                await asyncio.wait_for(proc.wait(), timeout=5.0)
+            except Exception:
+                pass
             raise RuntimeError(f"git {' '.join(args)} timed out after {timeout}s")
         finally:
             # Clean up temp SSH key file if created
@@ -1340,11 +1480,27 @@ class ProcessManager:
 
     @staticmethod
     def _extract_output_signals(text: str) -> dict[str, Any]:
-        """Parse stdout/stderr-like streams for success and failure signals."""
+        """Parse stdout/stderr-like streams for success and failure signals.
+
+        Uses structural signal detection — NOT keyword matching on result text.
+
+        The key invariant for Claude stream-json:
+        - A genuine execution always emits at least one 'assistant' event AND
+          has total_input_tokens > 0 in the result event, because the CLI made
+          a real API call.
+        - A pre-call failure (API Error, Connection error, auth failure) exits
+          immediately: no 'assistant' events, and total_input_tokens == 0 in
+          the result event. The result text contains the CLI error message.
+
+        This avoids false positives from agent work output that legitimately
+        contains words like 'rate limit', 'connection error', 'API error', etc.
+        (e.g. implementing a rate-limiter feature, or documenting error codes).
+        """
         has_turn_completed = False
         has_turn_failed = False
         has_result = False
         has_meaningful_content = False
+        has_assistant_events = False  # True once any 'assistant' event is seen
         error_messages: list[str] = []
         json_line_count = 0
 
@@ -1374,18 +1530,31 @@ class ProcessManager:
                 elif isinstance(err, str):
                     error_messages.append(err)
             elif ev_type == "result":
+                result_text = str(data.get("result", "") or "")
                 if data.get("is_error"):
-                    err_text = str(data.get("result", "") or data.get("error", "") or "result marked as error")
+                    err_text = result_text or str(data.get("error", "") or "result marked as error")
                     error_messages.append(err_text)
                 else:
-                    has_result = True
-                    has_meaningful_content = True
+                    # Structural check: if no tokens were consumed AND no assistant
+                    # events appeared, the CLI never made an API call. The result
+                    # text is a CLI-level error (e.g. "API Error: Connection error.")
+                    # rather than the agent's actual work output.
+                    tok_in = int(data.get("total_input_tokens", 0) or 0)
+                    tok_out = int(data.get("total_output_tokens", 0) or 0)
+                    no_api_call = (tok_in + tok_out == 0) and not has_assistant_events
+                    if no_api_call and result_text:
+                        error_messages.append(result_text)
+                    else:
+                        has_result = True
+                        has_meaningful_content = True
             elif ev_type == "error":
                 msg = data.get("message", "")
                 if msg:
                     error_messages.append(msg)
+            elif ev_type == "assistant":
+                has_meaningful_content = True
+                has_assistant_events = True
             elif ev_type in (
-                "assistant",
                 "content_block_delta",
                 "message_delta",
                 "step_finish",
@@ -1422,21 +1591,29 @@ class ProcessManager:
         Returns True for rate/quota limits AND API unavailability errors,
         since a different agent (using a different API backend) may succeed.
 
-        IMPORTANT: Only checks stderr, error message, and the tail of stdout.
-        The full stdout contains the agent's work output (e.g., analysis text
-        about APIs, retry logic, HTTP status codes) which naturally contains
-        patterns like "429", "try again", "capacity" — these are NOT indicators
-        of the agent CLI itself being rate-limited.
+        IMPORTANT: Only checks stderr and error message.  When exit code is
+        non-zero, also checks the tail of stdout (last 3000 chars) since the
+        error is likely at the end.  When exit code is 0 (agent reported
+        success but _detect_agent_output_failure set status to failed), do
+        NOT scan stdout — it contains the agent's work output (configs, code)
+        which naturally has terms like "rate_limit", "API_RATE_LIMIT_PER_MINUTE"
+        that trigger false positives.
         """
         if result.status == "success":
             return False
-        # Search error channels: stderr (CLI errors) + error message + tail of stdout
-        # (last 3000 chars catches any CLI-level error at the end of output)
-        error_text = (
-            (result.stderr or "")
-            + "\n" + (result.error or "")
-            + "\n" + (result.stdout or "")[-3000:]
-        ).lower()
+        # When exit code is 0, _detect_agent_output_failure already checked
+        # stderr+error for rate-limit patterns.  Don't re-scan stdout here.
+        if result.exit_code == 0:
+            error_text = (
+                (result.stderr or "")
+                + "\n" + (result.error or "")
+            ).lower()
+        else:
+            error_text = (
+                (result.stderr or "")
+                + "\n" + (result.error or "")
+                + "\n" + (result.stdout or "")[-3000:]
+            ).lower()
         return (
             any(p in error_text for p in ProcessManager.RATE_LIMIT_PATTERNS)
             or any(p in error_text for p in ProcessManager.AGENT_UNAVAILABLE_PATTERNS)
@@ -1456,16 +1633,16 @@ class ProcessManager:
         if result.status != "success":
             return None
 
-        # For rate/unavailability pattern detection, only check error channels
-        # (stderr, error field) plus the TAIL of stdout.  The full stdout contains
-        # the agent's work output (analysis text, generated docs) which naturally
-        # mentions terms like "rate limit", "429", "capacity", "credit" etc.
-        error_channels = (
-            (result.stderr or "")
-            + "\n" + (result.error or "")
-            + "\n" + (result.stdout or "")[-3000:]
-        )
-        pattern_failure = ProcessManager._has_failure_pattern(error_channels)
+        # For exit-code-0 (success) cases, only scan stderr and the error field
+        # for rate-limit / unavailability patterns.  Stdout contains the agent's
+        # actual task output (code, configs, analysis docs) which may legitimately
+        # contain substrings like "rate_limit", "429", "quota", etc. — e.g. writing
+        # a config file with API_RATE_LIMIT_PER_MINUTE=1000 would previously trigger
+        # a false "quota exhaustion" failure even though the agent succeeded.
+        # stdout[-N:] is only safe to scan when the agent already failed (exit != 0),
+        # which is handled by is_rate_limited() called at the orchestrator level.
+        error_only_channels = (result.stderr or "") + "\n" + (result.error or "")
+        pattern_failure = ProcessManager._has_failure_pattern(error_only_channels)
         if pattern_failure:
             return pattern_failure
 
@@ -1536,7 +1713,10 @@ class ProcessManager:
         start_time = time.monotonic()
 
         if agent.agent_id == "claude-code":
-            result = await self._run_claude(agent, prompt, workspace_path, timeout, task.task_id, on_chunk)
+            result = await self._run_claude(
+                agent, prompt, workspace_path, timeout, task.task_id, on_chunk,
+                node_type=task.node_type,
+            )
         elif agent.agent_id == "codex":
             result = await self._run_codex(agent, prompt, workspace_path, timeout, task.task_id, on_chunk)
         elif agent.agent_id == "opencode":
@@ -1757,18 +1937,37 @@ class ProcessManager:
 
     async def _run_claude(
         self, agent: DiscoveredAgent, prompt: str, cwd: Path, timeout: int, task_id: str,
-        on_chunk: Any = None,
+        on_chunk: Any = None, node_type: str = "",
     ) -> TaskResult:
         """Run Claude Code CLI in print mode with auto-approve permissions.
 
         Uses stdin pipe for prompt delivery to avoid ARG_MAX limits.
         Uses --dangerously-skip-permissions for autonomous file operations.
+        Uses --max-turns to prevent context window overflow during long sessions.
         """
+        # Determine max turns based on node type.
+        # Analysis/coding nodes need more turns (read many files, write multiple outputs).
+        # Review/testing nodes are typically shorter.
+        # This prevents runaway context accumulation that leads to "Prompt is too long".
+        max_turns_map = {
+            "analysis": 80,
+            "coding": 80,
+            "design": 50,
+            "testing": 60,
+            "review": 40,
+            "fix": 60,
+        }
+        max_turns = int(os.environ.get(
+            "FACTORY_CLAUDE_MAX_TURNS",
+            str(max_turns_map.get(node_type, 60)),
+        ))
+
         cmd = [
             agent.command,
             "-p",
             "--output-format", "stream-json",
             "--verbose",
+            "--max-turns", str(max_turns),
             "--dangerously-skip-permissions",
         ]
 
@@ -1804,6 +2003,24 @@ class ProcessManager:
                     metrics=metrics,
                 )
             else:
+                # Detect context overflow: Claude exits 1 with "Prompt is too long" in output
+                _combined_output = stdout[-20000:] + stderr[-500:]
+                if "Prompt is too long" in _combined_output or "prompt is too long" in _combined_output:
+                    logger.error(
+                        "Context overflow for task %s: Claude context window exceeded "
+                        "(%d stdout chars). Consider reducing prompt size.",
+                        task_id, len(stdout),
+                    )
+                    return TaskResult(
+                        status="failed",
+                        exit_code=returncode,
+                        stdout=stdout[-settings.AGENT_MAX_OUTPUT_SIZE:],
+                        stderr=stderr[-10000:],
+                        error="context_overflow: Claude's context window was exceeded during execution. "
+                              "The accumulated conversation history (initial prompt + tool call results) "
+                              "exceeded the model's limit. Reduce prompt size or shorten file reads.",
+                        metrics=metrics,
+                    )
                 return TaskResult(
                     status="failed",
                     exit_code=returncode,
@@ -1849,7 +2066,13 @@ class ProcessManager:
         on_chunk: Any = None,
     ) -> TaskResult:
         """Run OpenCode CLI in non-interactive mode."""
-        cmd = [agent.command, "run", "--format", "json", "--dangerously-skip-permissions", prompt]
+        cmd = [
+            agent.command, "run",
+            "--format", "json",
+            "--dangerously-skip-permissions",
+            "--cwd", str(cwd),
+            prompt,
+        ]
         result = await self._run_cli(cmd, cwd, timeout, task_id, on_chunk=on_chunk)
         parsed_metrics = self._parse_agent_jsonl_output(result.stdout)
         result.metrics.update(parsed_metrics)
@@ -3605,9 +3828,13 @@ class RuntimeDaemon:
             required_files = _get_analysis_outputs_for_type(req_type)
 
             # Analysis deliverables live in analysis_output_dir (docs/requirements/...)
+            _input = task.input_data or {}
             doc_dir = (
-                (task.input_data or {}).get("analysis_output_dir", "")
-                or (task.input_data or {}).get("output_dir", "")
+                _input.get("analysis_output_dir")
+                or _input.get("context", {}).get("analysis_output_dir")
+                or _input.get("output_dir")
+                or _input.get("context", {}).get("output_dir")
+                or ""
             )
             if doc_dir:
                 base = workspace_path / doc_dir
@@ -3691,7 +3918,12 @@ class RuntimeDaemon:
                     pass
 
                 if not _skip_test_artifacts:
-                    doc_dir = (task.input_data or {}).get("output_dir", "")
+                    _input = task.input_data or {}
+                    doc_dir = (
+                        _input.get("output_dir")
+                        or _input.get("context", {}).get("output_dir")
+                        or ""
+                    )
                     if doc_dir:
                         base = workspace_path / doc_dir
                     else:
@@ -3782,11 +4014,25 @@ class RuntimeDaemon:
                 ],
             )
 
-            # Build a targeted fix prompt
+            # Build a targeted fix prompt with output directory context
+            _input = task.input_data or {}
+            _fix_doc_dir = (
+                _input.get("output_dir")
+                or _input.get("context", {}).get("output_dir")
+                or ""
+            )
             fix_prompt = (
                 "The previous execution produced output with validation errors.\n"
                 "Please fix ALL of the following issues:\n\n"
                 f"{issues_text}\n\n"
+            )
+            if _fix_doc_dir:
+                fix_prompt += (
+                    f"IMPORTANT: All deliverable files (test-cases.json, coverage-matrix.json, "
+                    f"test-report.md, design.md, etc.) MUST be written to the `{_fix_doc_dir}/` "
+                    f"directory, NOT the workspace root.\n\n"
+                )
+            fix_prompt += (
                 "Fix the issues in-place. Do NOT recreate files that are already correct.\n"
                 "Only fix the specific problems listed above."
             )
@@ -3997,7 +4243,13 @@ class RuntimeDaemon:
             # ── Pre-push rebase onto latest default branch ──
             # This ensures the AI's branch incorporates the latest remote
             # changes, dramatically reducing PR merge conflicts.
-            await self._rebase_onto_latest(workspace_path, default_branch, task, project_key)
+            # SKIP for analysis nodes: analysis produces documentation files
+            # (PRD.md, SDD.md, etc.) that are independent of codebase changes.
+            # Rebasing analysis commits onto default_branch is unnecessary
+            # overhead and rewrites commit SHAs, which complicates pushes
+            # on subsequent iterations of the same requirement.
+            if task.node_type != "analysis":
+                await self._rebase_onto_latest(workspace_path, default_branch, task, project_key)
 
             # ── Verify we're on the correct branch before pushing ──
             current_branch = ""
@@ -4523,10 +4775,79 @@ class RuntimeDaemon:
                     unpushed = "first-push"
 
                 if unpushed:
+                    # Check if remote has commits not in local history (diverged).
+                    try:
+                        remote_ahead = (await git(
+                            "log", f"HEAD..origin/{branch}", "--oneline", cwd=workspace_path,
+                        )).strip()
+                    except RuntimeError:
+                        remote_ahead = ""  # Remote branch doesn't exist yet
+
+                    if remote_ahead:
+                        remote_count = len(remote_ahead.splitlines())
+                        # Divergence detected — but this is expected after rebase.
+                        # Check if the remote commits are already incorporated
+                        # (i.e., their patches are empty against our branch, meaning
+                        # the rebase already applied them with new SHAs).
+                        # `git cherry HEAD origin/branch` lists commits from
+                        # origin/branch not in HEAD; lines starting with "-" are
+                        # already incorporated (equivalent patch exists).
+                        rebase_divergence = False
+                        try:
+                            cherry_out = (await git(
+                                "cherry", "HEAD", f"origin/{branch}",
+                                cwd=workspace_path,
+                            )).strip()
+                            if cherry_out:
+                                # All lines starting with "-" means all remote
+                                # commits are already in our branch (rebased).
+                                # Lines starting with "+" are truly missing.
+                                truly_missing = [
+                                    line for line in cherry_out.splitlines()
+                                    if line.startswith("+ ")
+                                ]
+                                rebase_divergence = len(truly_missing) == 0
+                            else:
+                                # No cherry output — remote commits are empty or
+                                # fully equivalent
+                                rebase_divergence = True
+                        except RuntimeError:
+                            pass
+
+                        if rebase_divergence:
+                            logger.info(
+                                "Branch %s diverged from origin (%d remote commit(s)) "
+                                "but all are already incorporated (rebase). "
+                                "Using --force-with-lease to push safely.",
+                                branch, remote_count,
+                            )
+                            try:
+                                await git(
+                                    "push", "--force-with-lease", "-u", "origin", branch,
+                                    cwd=workspace_path, project_key=project_key,
+                                )
+                                logger.info("Force-pushed (with lease) branch %s to origin", branch)
+                                return None
+                            except RuntimeError as exc:
+                                logger.error("Force-push (with lease) failed for %s: %s", branch, exc)
+                                return f"Push failed: {exc}"
+                        else:
+                            logger.error(
+                                "SAFETY: Refusing to push %s — remote has %d commit(s) "
+                                "not in local branch. This would destroy prior work. "
+                                "Remote-only commits:\n%s",
+                                branch, remote_count, remote_ahead,
+                            )
+                            return (
+                                f"Push refused: remote branch '{branch}' has {remote_count} "
+                                f"commit(s) not in local history. Force-pushing would "
+                                f"destroy prior implementation work."
+                            )
+
                     logger.info("Found unpushed commits on %s, pushing...", branch)
                     try:
                         await git(
-                            "push", "--force-with-lease", "-u", "origin", branch,
+                            "push", "-u", "origin", branch,
                             cwd=workspace_path, project_key=project_key,
                         )
                         logger.info("Pushed branch %s to origin", branch)

{forgexa_cli-1.4.2 → forgexa_cli-1.6.1}/forgexa_cli/main.py

@@ -4,17 +4,20 @@ Forgexa CLI — command-line client for the Forgexa platform.
 A lightweight, standalone CLI that communicates with the Forgexa server via REST API.
 Zero external dependencies — uses only Python stdlib.
 
-Configuration:
-    FORGEXA_SERVER_URL   Server URL (default: https://api.forgexa.net)
-    FORGEXA_TOKEN        Bearer token (obtain via `forgexa login`)
+Configuration (in priority order):
+    1. --server-url flag          Per-command override
+    2. FORGEXA_SERVER_URL env var  Session-level override
+    3. ~/.forgexa/config          Saved via `forgexa login --server <url>`
+    4. Build default              https://api.forgexa.net
 
 Usage:
-    forgexa login
+    forgexa login --server https://your-server.com
     forgexa workspace list
     forgexa project list --workspace <id>
     forgexa requirement list --project <id>
     forgexa daemon status
     forgexa gates pending
+    forgexa config show
     forgexa --help
 """
 from __future__ import annotations
@@ -27,23 +30,56 @@ import signal
 import sys
 from pathlib import Path
 
-# ── HTTP helpers (stdlib only) ──
+# ── Build-time default ──
+# Resolved in priority order at runtime (see _api_url()):
+#   1. --server-url flag
+#   2. FORGEXA_SERVER_URL environment variable
+#   3. ~/.forgexa/config  (saved by `forgexa login --server <url>`)
+#   4. This build default
 
-
-# Default server URL — resolved in priority order:
-#   1. FORGEXA_SERVER_URL environment variable (runtime override)
-#   2. _build_config.py   — generated by publish.sh at wheel-build time
-#   3. Hardcoded fallback — https://api.forgexa.net
-#
-# For local development use: FORGEXA_SERVER_URL=http://localhost:8000 forgexa ...
 try:
-    from forgexa_cli._build_config import BUILD_SERVER_URL as _DEFAULT_SERVER_URL
+    from forgexa_cli._build_config import BUILD_SERVER_URL as _BUILD_DEFAULT
 except ImportError:
-    _DEFAULT_SERVER_URL = "https://api.forgexa.net"
+    _BUILD_DEFAULT = "https://api.forgexa.net"
+
+# Module-level override applied by main() when --server-url is passed.
+_SERVER_URL_OVERRIDE: str | None = None
+
+
+# ── Config file helpers (~/.forgexa/config) ──
+
+def _config_path() -> Path:
+    return Path.home() / ".forgexa" / "config"
+
+
+def _load_config() -> dict:
+    p = _config_path()
+    if p.exists():
+        try:
+            return json.loads(p.read_text())
+        except Exception:
+            return {}
+    return {}
+
+
+def _save_config(data: dict) -> None:
+    p = _config_path()
+    p.parent.mkdir(exist_ok=True)
+    p.write_text(json.dumps(data, indent=2))
+    p.chmod(0o600)
 
 
 def _api_url() -> str:
-    return os.environ.get("FORGEXA_SERVER_URL", _DEFAULT_SERVER_URL)
+    """Resolve the server URL using priority chain."""
+    if _SERVER_URL_OVERRIDE:
+        return _SERVER_URL_OVERRIDE
+    env = os.environ.get("FORGEXA_SERVER_URL")
+    if env:
+        return env
+    cfg = _load_config()
+    if cfg.get("server_url"):
+        return cfg["server_url"]
+    return _BUILD_DEFAULT
 
 
 def _token() -> str | None:
@@ -53,7 +89,8 @@ def _token() -> str | None:
     token_file = Path.home() / ".forgexa" / "token"
     if token_file.exists():
         return token_file.read_text().strip()
-    return None
+    cfg = _load_config()
+    return cfg.get("token") or None
 
 
 def _headers() -> dict[str, str]:
@@ -157,26 +194,83 @@ def _print_table(headers: list[str], rows: list[list[str]], fmt: str | None = No
 
 
 def cmd_login(args: argparse.Namespace) -> None:
+    # If --server was given, apply it for this login request and save it.
+    server = getattr(args, "server", None)
+    if server:
+        global _SERVER_URL_OVERRIDE
+        _SERVER_URL_OVERRIDE = server.rstrip("/")
+
     email = args.email or input("Email: ")
     password = args.password or getpass.getpass("Password: ")
     result = _post("/auth/login", {"email": email, "password": password})
     token = result.get("access_token", "")
-    # Save token to file
+
+    # Save to config file (server_url + token in one place)
+    cfg = _load_config()
+    if server:
+        cfg["server_url"] = _SERVER_URL_OVERRIDE
+    cfg["token"] = token
+    _save_config(cfg)
+
+    # Also keep the legacy token file for backwards compatibility
     token_dir = Path.home() / ".forgexa"
     token_dir.mkdir(exist_ok=True)
     (token_dir / "token").write_text(token)
     (token_dir / "token").chmod(0o600)
-    print(f"Login successful. Token saved to ~/.forgexa/token")
-    print(f"Or set manually: export FORGEXA_TOKEN={token}")
+
+    active_server = _api_url()
+    print(f"Login successful.")
+    print(f"  Server : {active_server}")
+    print(f"  Config : ~/.forgexa/config")
 
 
 def cmd_logout(_args: argparse.Namespace) -> None:
+    cleared = False
     token_file = Path.home() / ".forgexa" / "token"
     if token_file.exists():
         token_file.unlink()
+        cleared = True
+    cfg = _load_config()
+    if "token" in cfg:
+        del cfg["token"]
+        _save_config(cfg)
+        cleared = True
+    if cleared:
         print("Logged out. Token removed.")
     else:
-        print("No token file found.")
+        print("No token found.")
+
+
+def cmd_config_show(_args: argparse.Namespace) -> None:
+    """Show current CLI configuration."""
+    cfg = _load_config()
+    token = _token()
+    active_url = _api_url()
+    source = "build default"
+    if _SERVER_URL_OVERRIDE:
+        source = "--server-url flag"
+    elif os.environ.get("FORGEXA_SERVER_URL"):
+        source = "FORGEXA_SERVER_URL env var"
+    elif cfg.get("server_url"):
+        source = f"~/.forgexa/config"
+    print(f"Server URL : {active_url}  (source: {source})")
+    print(f"Auth token : {'set' if token else 'not set'}")
+    print(f"Config file: {_config_path()}")
+
+
+def cmd_config_set(args: argparse.Namespace) -> None:
+    """Set a configuration value."""
+    cfg = _load_config()
+    if args.key == "server-url":
+        url = args.value.rstrip("/")
+        cfg["server_url"] = url
+        _save_config(cfg)
+        print(f"Server URL set to: {url}")
+        print(f"Saved to: {_config_path()}")
+    else:
+        print(f"Unknown config key: {args.key}", file=sys.stderr)
+        print("Available keys: server-url", file=sys.stderr)
+        sys.exit(1)
 
 
 def cmd_daemon_status(_args: argparse.Namespace) -> None:
@@ -467,20 +561,28 @@ def cmd_version(_args: argparse.Namespace) -> None:
 
 
 def main() -> None:
+    global _SERVER_URL_OVERRIDE, _output_format
+
+    active_url = _api_url()  # resolved before parsing (for help text)
+
     parser = argparse.ArgumentParser(
         prog="forgexa",
         description="Forgexa CLI — communicates with the Forgexa server via REST API.",
         epilog=(
             "Configuration:\n"
-            f"  FORGEXA_SERVER_URL   Server URL (default: {_DEFAULT_SERVER_URL})\n"
-            "  FORGEXA_TOKEN        Bearer token (or use `forgexa login`)\n"
+            f"  Current server : {active_url}\n"
+            "  Change server  : forgexa login --server <url>\n"
+            "                   forgexa config set server-url <url>\n"
+            "                   export FORGEXA_SERVER_URL=<url>\n"
+            "  Auth token     : forgexa login  (saved to ~/.forgexa/config)\n"
         ),
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
     parser.add_argument(
         "--server-url",
         default=None,
-        help=f"Server URL (default: $FORGEXA_SERVER_URL or {_DEFAULT_SERVER_URL})",
+        metavar="URL",
+        help="Server URL override for this command (also: $FORGEXA_SERVER_URL or ~/.forgexa/config)",
     )
     parser.add_argument(
         "--format",
@@ -495,10 +597,19 @@ def main() -> None:
 
     # auth
     login_p = sub.add_parser("login", help="Login and save access token")
+    login_p.add_argument("--server", metavar="URL", help="Server URL to connect to (saved to ~/.forgexa/config)")
     login_p.add_argument("--email", help="Email address")
     login_p.add_argument("--password", help="Password")
     sub.add_parser("logout", help="Remove saved access token")
 
+    # config
+    config_p = sub.add_parser("config", help="View or change CLI configuration")
+    config_sub = config_p.add_subparsers(dest="config_cmd")
+    config_sub.add_parser("show", help="Show current configuration")
+    cfg_set = config_sub.add_parser("set", help="Set a configuration value")
+    cfg_set.add_argument("key", choices=["server-url"], help="Config key")
+    cfg_set.add_argument("value", help="Config value")
+
     # daemon (remote API only — use forgexa-daemon for local daemon management)
     daemon_p = sub.add_parser("daemon", help="Daemon management")
     daemon_sub = daemon_p.add_subparsers(dest="daemon_cmd")
@@ -583,9 +694,8 @@ def main() -> None:
     args = parser.parse_args()
 
     if args.server_url:
-        os.environ["FORGEXA_SERVER_URL"] = args.server_url
+        _SERVER_URL_OVERRIDE = args.server_url.rstrip("/")
 
-    global _output_format
     _output_format = args.format or "table"
 
     cmd = args.command
@@ -597,6 +707,10 @@ def main() -> None:
         "version": cmd_version,
         "login": cmd_login,
         "logout": cmd_logout,
+        "config": lambda a: {
+            "show": cmd_config_show,
+            "set": cmd_config_set,
+        }.get(a.config_cmd, lambda _: config_p.print_help())(a),
         "daemon": lambda a: {
             "start": cmd_daemon_start,
             "status": cmd_daemon_status,

{forgexa_cli-1.4.2 → forgexa_cli-1.6.1}/forgexa_cli.egg-info/PKG-INFO

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

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