forgexa-cli 1.14.3__tar.gz → 1.14.5__tar.gz

{forgexa_cli-1.14.3 → forgexa_cli-1.14.5}/PKG-INFO

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

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

{forgexa_cli-1.14.3 → forgexa_cli-1.14.5}/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.3"
+DAEMON_VERSION = "1.14.5"
 
 
 def _detect_client_type() -> str:
@@ -1225,6 +1225,38 @@ def _get_analysis_outputs_for_type(req_type: str) -> list[str]:
         return _ANALYSIS_OUTPUTS_BY_TYPE.get(req_type, _ANALYSIS_OUTPUTS_BY_TYPE["feature"])
 
 
+# Mirrors type_workflow_profiles.py — maps req type to the expected design-phase output filename.
+# Most types use design.md; spike uses research.md (produced by _DESIGN_SPIKE prompt).
+_DESIGN_OUTPUT_BY_TYPE: dict[str, str] = {
+    "spike": "research.md",
+    # All other types produce design.md (the default).
+}
+
+
+def _get_design_output_for_type(req_type: str) -> str:
+    """Get the expected design-phase output filename for a requirement type.
+
+    Used by _validate_outputs and _required_deliverable_paths to avoid
+    hardcoding 'design.md' for all node_type='design' nodes — spike produces
+    'research.md' instead.
+    """
+    try:
+        from app.services.type_workflow_profiles import get_profile
+        profile = get_profile(req_type)
+        for phase in profile.execution_phases:
+            if phase.node_type == "design":
+                from app.services.type_prompts import TYPE_PROMPT_TEMPLATES
+                tmpl = TYPE_PROMPT_TEMPLATES.get(phase.prompt_key, "")
+                import re as _re
+                m = _re.search(r"{doc_dir}/([\w.-]+)", tmpl)
+                if m:
+                    return m.group(1)
+                break
+    except Exception:
+        pass
+    return _DESIGN_OUTPUT_BY_TYPE.get(req_type, "design.md")
+
+
 # ── Agent Discovery ──
 
 
@@ -3547,7 +3579,8 @@ class ProcessManager:
             req_type = (task.input_data or {}).get("requirement_type", "feature")
             required_files = _get_analysis_outputs_for_type(req_type)
         elif task.node_type == "design":
-            required_files = ["design.md"]
+            req_type = (task.input_data or {}).get("requirement_type", "feature")
+            required_files = [_get_design_output_for_type(req_type)]
         elif task.node_type == "delivery":
             # Required docs come from node input_data (set by delivery_doc_service)
             required_files = (task.input_data or {}).get("required_docs") or ["release-note.md"]
@@ -5073,28 +5106,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(
@@ -5140,6 +5192,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)
@@ -5177,10 +5231,36 @@ class ProcessManager:
 class ProgressReporter:
     """Reports task progress back to the server."""
 
+    _MIN_HEARTBEAT_INTERVAL_SECONDS = 5.0
+    _MIN_PROGRESS_DELTA = 5
+
     def __init__(self, client: httpx.AsyncClient, server_url: str, runtime_id: str):
         self.client = client
         self.server_url = server_url.rstrip("/")
         self.runtime_id = runtime_id
+        self._last_progress_sent: dict[str, dict[str, Any]] = {}
+
+    def _should_skip_progress(
+        self,
+        task_id: str,
+        progress_percent: int,
+        current_step: str,
+        output_lines: list[str],
+        files_changed: list[str],
+        lines_added: int,
+        lines_removed: int,
+    ) -> bool:
+        if output_lines or files_changed or lines_added or lines_removed:
+            return False
+
+        last = self._last_progress_sent.get(task_id)
+        if not last:
+            return False
+        if last["current_step"] != current_step:
+            return False
+        if progress_percent - int(last["progress_percent"]) >= self._MIN_PROGRESS_DELTA:
+            return False
+        return (time.monotonic() - float(last["sent_at"])) < self._MIN_HEARTBEAT_INTERVAL_SECONDS
 
     async def report_progress(
         self,
@@ -5192,24 +5272,43 @@ class ProgressReporter:
         lines_added: int = 0,
         lines_removed: int = 0,
     ):
+        output_lines = output_lines or []
+        files_changed = files_changed or []
+        if self._should_skip_progress(
+            task_id,
+            progress_percent,
+            current_step,
+            output_lines,
+            files_changed,
+            lines_added,
+            lines_removed,
+        ):
+            return
+
         try:
             await self.client.post(
                 f"{self.server_url}/api/v1/runtimes/{self.runtime_id}/tasks/{task_id}/progress",
                 json={
                     "progress_percent": progress_percent,
                     "current_step": current_step,
-                    "output_lines": output_lines or [],
-                    "files_changed": files_changed or [],
+                    "output_lines": output_lines,
+                    "files_changed": files_changed,
                     "lines_added": lines_added,
                     "lines_removed": lines_removed,
                 },
                 timeout=10,
             )
+            self._last_progress_sent[task_id] = {
+                "progress_percent": progress_percent,
+                "current_step": current_step,
+                "sent_at": time.monotonic(),
+            }
         except Exception as e:
             logger.warning("Failed to report progress for task %s: %s", task_id, e)
 
     async def report_complete(self, task_id: str, result: TaskResult):
         """Report task completion with retry."""
+        self._last_progress_sent.pop(task_id, None)
         payload = {
             "status": result.status,
             "exit_code": result.exit_code,
@@ -5403,6 +5502,8 @@ class LogUploader:
 class TaskPoller:
     """Polls the server for assigned tasks."""
 
+    _EMPTY_BACKOFF_STEPS = (0, 0, 1, 2, 3, 5)
+
     def __init__(
         self,
         client: httpx.AsyncClient,
@@ -5416,6 +5517,16 @@ class TaskPoller:
         self.interval = interval
         self._on_success = lambda: None  # Callbacks set by ServerConnection
         self._on_auth_failure = lambda: None
+        self._empty_cycles = 0
+
+    def note_activity(self, *, had_work: bool) -> None:
+        if had_work:
+            self._empty_cycles = 0
+            return
+        self._empty_cycles = min(self._empty_cycles + 1, len(self._EMPTY_BACKOFF_STEPS) - 1)
+
+    def next_delay_seconds(self) -> int:
+        return self.interval + self._EMPTY_BACKOFF_STEPS[self._empty_cycles]
 
     async def poll(self) -> list[TaskInfo]:
         """Poll for tasks assigned to this daemon."""
@@ -6146,15 +6257,28 @@ class RuntimeDaemon:
         # 3. Main loop
         try:
             while not self._shutdown:
-                await self._poll_and_execute()
-                await asyncio.sleep(self.poll_interval)
+                had_work = await self._poll_and_execute()
+                next_delay = self.poll_interval
+                if self.connections:
+                    next_delay = min(
+                        conn.poller.next_delay_seconds()
+                        for conn in self.connections
+                        if conn.poller is not None
+                    )
+                logger.debug(
+                    "Daemon poll cycle complete (had_work=%s, next_delay=%ss)",
+                    had_work,
+                    next_delay,
+                )
+                await asyncio.sleep(next_delay)
         except asyncio.CancelledError:
             pass
         finally:
             await self._shutdown_gracefully()
 
-    async def _poll_and_execute(self):
+    async def _poll_and_execute(self) -> bool:
         """Poll for tasks from all connected servers and execute them."""
+        had_work = False
         # Clean up completed tasks
         for task_id in list(self.active_tasks):
             if self.active_tasks[task_id].done():
@@ -6169,7 +6293,7 @@ class RuntimeDaemon:
 
         # Check capacity
         if total_active >= self.max_concurrent:
-            return
+            return True
 
         # Poll from all connected servers
         for conn in self.connections:
@@ -6177,6 +6301,12 @@ class RuntimeDaemon:
                 break
 
             tasks = await conn.poller.poll()
+            ai_jobs: list[dict] = []
+            if len(self.active_tasks) < self.max_concurrent:
+                ai_jobs = await conn.poller.poll_ai_jobs()
+
+            conn.poller.note_activity(had_work=bool(tasks or ai_jobs))
+            had_work = had_work or bool(tasks or ai_jobs)
 
             for task in tasks:
                 if task.task_id in self.active_tasks:
@@ -6194,21 +6324,21 @@ class RuntimeDaemon:
                 )
 
             # Poll for AIJobs (workspace-mode tasks)
-            if len(self.active_tasks) < self.max_concurrent:
-                ai_jobs = await conn.poller.poll_ai_jobs()
-                for aj in ai_jobs:
-                    job_id = aj.get("job_id", "")
-                    ai_task_key = f"aijob_{job_id}"
-                    if ai_task_key in self.active_tasks:
-                        continue
-                    if len(self.active_tasks) >= self.max_concurrent:
-                        break
-                    logger.info("[%s] Starting AIJob %s (type=%s)",
-                               conn.label, job_id, aj.get("task_type"))
-                    self._task_connections[ai_task_key] = conn
-                    self.active_tasks[ai_task_key] = asyncio.create_task(
-                        self._execute_ai_job(aj, conn)
-                    )
+            for aj in ai_jobs:
+                job_id = aj.get("job_id", "")
+                ai_task_key = f"aijob_{job_id}"
+                if ai_task_key in self.active_tasks:
+                    continue
+                if len(self.active_tasks) >= self.max_concurrent:
+                    break
+                logger.info("[%s] Starting AIJob %s (type=%s)",
+                           conn.label, job_id, aj.get("task_type"))
+                self._task_connections[ai_task_key] = conn
+                self.active_tasks[ai_task_key] = asyncio.create_task(
+                    self._execute_ai_job(aj, conn)
+                )
+
+        return had_work
 
     def _recover_timeout_from_workspace_changes(
         self,
@@ -6255,6 +6385,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
@@ -6434,6 +6566,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")
 
@@ -6506,7 +6651,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"))
@@ -6617,7 +6766,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)
@@ -6655,7 +6808,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
@@ -6779,7 +6936,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"),
@@ -6875,14 +7036,29 @@ class RuntimeDaemon:
                     # as failed so the orchestrator can retry (transient network).
                     if commit_result.get("push_error"):
                         push_err = commit_result["push_error"]
-                        logger.error(
-                            "Task %s: push failed, marking as failed so retry can attempt push again: %s",
-                            task.task_id, push_err,
-                        )
                         result.status = "failed"
-                        result.error = f"Git push failed: {push_err}"
+                        if commit_result.get("push_error_code") == "forbidden_branch_merge":
+                            logger.error(
+                                "Task %s: push blocked by requirement-branch merge protection: %s",
+                                task.task_id, push_err,
+                            )
+                            result.failure_code = "forbidden_branch_merge"
+                            result.error = (
+                                commit_result.get("push_error_display")
+                                or f"Push blocked: {push_err}"
+                            )
+                        else:
+                            logger.error(
+                                "Task %s: push failed, marking as failed so retry can attempt push again: %s",
+                                task.task_id, push_err,
+                            )
+                            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"):
@@ -7117,12 +7293,14 @@ class RuntimeDaemon:
 
         elif node_type == "design":
             doc_dir = (task.input_data or {}).get("output_dir", "")
+            req_type = (task.input_data or {}).get("requirement_type", "feature")
             if doc_dir:
-                design_path = workspace_path / doc_dir / "design.md"
+                design_filename = _get_design_output_for_type(req_type)
+                design_path = workspace_path / doc_dir / design_filename
                 if not design_path.exists():
-                    issues.append(f"Design document missing: {doc_dir}/design.md")
+                    issues.append(f"Design document missing: {doc_dir}/{design_filename}")
                 elif design_path.stat().st_size == 0:
-                    issues.append(f"Design document is empty: {doc_dir}/design.md")
+                    issues.append(f"Design document is empty: {doc_dir}/{design_filename}")
 
         elif node_type in ("coding", "testing", "fix", "review"):
             # Syntax-check modified Python and JS/TS files
@@ -7860,11 +8038,11 @@ class RuntimeDaemon:
         Some agents (e.g. claude) commit changes internally, so we must
         also push even when the working directory is clean.
 
-        Before pushing, we rebase onto the latest ``origin/{default_branch}``
-        so that the PR is based on up-to-date code and avoids unnecessary
-        merge conflicts.  If rebase fails (true conflict), we fall back to a
-        merge.  If the merge also fails, we invoke the same AI agent to
-        resolve the remaining conflicts automatically.
+        For non-requirement branches, we may integrate the latest
+        ``origin/{default_branch}`` before push. Requirement branches are
+        explicitly excluded because silently rebasing/merging the default
+        branch into a requirement branch widens the change scope, pollutes gate
+        review diffs, and can import unrelated requirements into the fix.
 
         Returns a dict with commit/push status info (empty on success).
         """
@@ -7979,6 +8157,35 @@ class RuntimeDaemon:
                 )
                 return {"push_error": f"Would push to default branch {current_branch}"}
 
+            if task.requirement_key and current_branch:
+                forbidden_merges = await self._list_unpushed_merge_commits(
+                    workspace_path, current_branch, default_branch,
+                )
+                if forbidden_merges:
+                    short_merges = ", ".join(sha[:12] for sha in forbidden_merges[:5])
+                    logger.error(
+                        "Requirement branch %s has %d new merge commit(s) pending push [%s] — "
+                        "aborting push to prevent cross-requirement contamination",
+                        current_branch, len(forbidden_merges), short_merges,
+                    )
+                    display_error = (
+                        f"Push blocked: requirement branch '{current_branch}' contains "
+                        f"merge commit(s) pending push ({short_merges}). "
+                        "This would import default-branch or unrelated requirement changes "
+                        "into the current execution scope. Roll back or recreate this fix "
+                        "on a clean requirement branch. Do not merge, rebase, or pull the "
+                        "default branch into requirement branches."
+                    )
+                    return {
+                        "push_error_code": "forbidden_branch_merge",
+                        "push_error": (
+                            "Requirement branch contains merge commit(s) pending push: "
+                            f"{short_merges}. Merging default/other branches into "
+                            "requirement branches is forbidden."
+                        ),
+                        "push_error_display": display_error,
+                    }
+
             # ── Push ──
             push_error = await self._push_branch(workspace_path, project_key, task=task)
             if push_error:
@@ -8792,6 +8999,11 @@ class RuntimeDaemon:
     ):
         """Integrate the current branch with ``origin/{default_branch}``.
 
+                Requirement branches are intentionally excluded. They already sync to the
+                latest remote requirement branch during workspace preparation, so pulling
+                in ``origin/{default_branch}`` here only risks importing unrelated work
+                into the requirement/fix scope.
+
         Strategy:
           - If the current branch already exists on remote (was previously pushed):
             Skip rebase entirely and use merge only.  Rebase rewrites commit
@@ -8807,6 +9019,15 @@ class RuntimeDaemon:
         target = f"origin/{default_branch}"
         _git_name, _git_email = _resolve_git_author(task.project)
 
+        if task.requirement_key:
+            logger.info(
+                "Skipping automatic integration of %s into requirement branch %s "
+                "to preserve task scope and avoid cross-requirement contamination",
+                target,
+                task.requirement_key,
+            )
+            return
+
         # Fetch latest remote state
         try:
             await git("fetch", "origin", cwd=workspace_path,
@@ -8890,6 +9111,38 @@ class RuntimeDaemon:
         # ── Tier 3: AI-assisted conflict resolution ──
         await self._ai_resolve_conflicts(workspace_path, default_branch, task)
 
+    async def _list_unpushed_merge_commits(
+        self,
+        workspace_path: Path,
+        current_branch: str,
+        default_branch: str,
+    ) -> list[str]:
+        """Return merge commits introduced locally and not yet on the remote branch.
+
+        Requirement branches must stay linear and requirement-scoped. Any new
+        merge commit pending push indicates an explicit merge/rebase workflow that
+        can import unrelated changes (for example, merging origin/develop into a
+        fix branch). Those pushes are rejected by the caller.
+        """
+        git = self.workspace_manager._git
+
+        try:
+            await git("rev-parse", "--verify", f"origin/{current_branch}", cwd=workspace_path)
+            out = await git(
+                "rev-list", "--min-parents=2", f"origin/{current_branch}..HEAD",
+                cwd=workspace_path,
+            )
+        except RuntimeError:
+            try:
+                out = await git(
+                    "rev-list", "--min-parents=2", "HEAD", "--not", f"origin/{default_branch}",
+                    cwd=workspace_path,
+                )
+            except RuntimeError:
+                return []
+
+        return [line.strip() for line in out.splitlines() if line.strip()]
+
     async def _ai_resolve_conflicts(
         self, workspace_path: Path, default_branch: str, task: TaskInfo,
     ):

{forgexa_cli-1.14.3 → forgexa_cli-1.14.5}/forgexa_cli.egg-info/PKG-INFO

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

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