forgexa-cli 1.57.0__tar.gz → 1.57.2__tar.gz

{forgexa_cli-1.57.0 → forgexa_cli-1.57.2}/PKG-INFO

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

{forgexa_cli-1.57.0 → forgexa_cli-1.57.2}/forgexa_cli/__init__.py

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

{forgexa_cli-1.57.0 → forgexa_cli-1.57.2}/forgexa_cli/daemon.py

@@ -1150,7 +1150,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.57.0"
+DAEMON_VERSION = "1.57.2"
 
 
 def _detect_client_type() -> str:
@@ -6926,7 +6926,7 @@ class ProcessManager:
                 task_id,
                 stdin_input=agent_core.qoder_stdin_prompt(prompt),
                 on_chunk=on_chunk,
-                env=agent_core.qoder_base_env(os.environ.copy()),
+                env=await asyncio.to_thread(agent_core.qoder_base_env, os.environ.copy()),
             )
         finally:
             agent_core.release_file_lock(profile_lock)
@@ -6991,7 +6991,7 @@ class ProcessManager:
                 task_id,
                 stdin_input=prompt,
                 on_chunk=on_chunk,
-                env=agent_core.trae_code_base_env(os.environ.copy()),
+                env=await asyncio.to_thread(agent_core.trae_code_base_env, os.environ.copy()),
             )
         finally:
             agent_core.release_file_lock(profile_lock)
@@ -7052,6 +7052,9 @@ class ProcessManager:
             if on_chunk is None or event.get("type") not in {"model.streaming", "tool.updated"}:
                 return
             payload = event.get("payload") if isinstance(event.get("payload"), dict) else {}
+            # AGT-11 (audit): zcode 0.16.x never emits "model.streaming" —
+            # final text is read back from session/messages after the turn
+            # terminates. This branch is forward-compatibility only.
             if event.get("type") == "model.streaming":
                 text = payload.get("text") or payload.get("delta") or payload.get("content")
                 line = text.strip() if isinstance(text, str) else ""
@@ -7069,7 +7072,7 @@ class ProcessManager:
             client = ZCodeProtocolSession(
                 [agent.command, "app-server"],
                 cwd=cwd,
-                env=agent_core.zcode_base_env(os.environ.copy()),
+                env=await asyncio.to_thread(agent_core.zcode_base_env, os.environ.copy()),
                 on_event=on_event,
                 permission_handler=agent_core.zcode_permission_response,
             )
@@ -7127,7 +7130,10 @@ class ProcessManager:
                 stdout="",
                 stderr=client.stderr_tail[-10000:] if client is not None else "",
                 error=f"Timed out after {timeout}s (absolute limit)",
-                failure_code="agent_idle_timeout",
+                # AGT-12 (audit): this is the run_turn absolute cap, not an
+                # idle gap — a distinct code keeps retry/degrade policies
+                # from misreading a too-long task as a stuck one.
+                failure_code="zcode_turn_timeout",
             )
         except ZCodeProtocolError as exc:
             return TaskResult(
@@ -10232,6 +10238,7 @@ class RuntimeDaemon:
         self._project_execution_locks: dict[str, asyncio.Lock] = {}
         self._project_execution_locks_mu: asyncio.Lock = asyncio.Lock()
         self._shutdown = False
+        self._shutdown_event = asyncio.Event()
         self._local_runtime_instance_id = secrets.token_urlsafe(18)
         self._local_runtime_registrations: dict[str, dict[str, int | str]] = {}
         self._desktop_restart_requested = False
@@ -11182,7 +11189,16 @@ class RuntimeDaemon:
                     had_work,
                     next_delay,
                 )
-                await asyncio.sleep(next_delay)
+                # AGT-04 (audit): wake IMMEDIATELY on SIGTERM. A plain sleep
+                # kept the loop parked for the whole poll delay while the
+                # replacing process only waits 5s before SIGKILL — graceful
+                # shutdown then never ran at all.
+                try:
+                    await asyncio.wait_for(
+                        self._shutdown_event.wait(), timeout=next_delay,
+                    )
+                except asyncio.TimeoutError:
+                    pass
         except asyncio.CancelledError:
             pass
         finally:
@@ -15617,6 +15633,26 @@ class RuntimeDaemon:
                 )
                 return {"push_error": f"Would push to default branch {current_branch}"}
 
+            # AGT-10 (audit): last line of defense after a collision was
+            # manually released at gate review — the executed branch must be
+            # this requirement's canonical branch (or the workflow's recorded
+            # analysis branch), never another requirement's.
+            if task.requirement_key and current_branch and expected_branch:
+                if current_branch != expected_branch:
+                    logger.error(
+                        "CRITICAL: requirement %s is about to push branch '%s' "
+                        "which is not its canonical branch '%s' — aborting",
+                        task.requirement_key, current_branch, expected_branch,
+                    )
+                    return {
+                        "push_error": (
+                            f"Push blocked: branch '{current_branch}' does not belong to "
+                            f"requirement {task.requirement_key} (expected '{expected_branch}'). "
+                            "A cross-requirement branch collision was likely released at review; "
+                            "re-run the fix on the correct branch."
+                        ),
+                    }
+
             if task.requirement_key and current_branch:
                 forbidden_merges = await self._list_unpushed_merge_commits(
                     workspace_path, current_branch, default_branch,
@@ -17837,8 +17873,30 @@ class RuntimeDaemon:
         tasks = list(self.active_tasks.values())
         for task in tasks:
             task.cancel()
-        for process_id in list(self.process_manager.active_processes):
-            await self.process_manager.cancel(process_id)
+        # AGT-04 (audit): cancel every process CONCURRENTLY under a single
+        # 4s deadline. The serial loop spent up to 5s PER process, so with
+        # two or more active tasks the replacing process's SIGKILL truncated
+        # the drain and left orphaned agents writing into workspaces the new
+        # daemon was already re-preparing.
+        process_ids = list(self.process_manager.active_processes)
+        if process_ids:
+            try:
+                await asyncio.wait_for(
+                    asyncio.gather(
+                        *(
+                            self.process_manager.cancel(process_id)
+                            for process_id in process_ids
+                        ),
+                        return_exceptions=True,
+                    ),
+                    timeout=4.0,
+                )
+            except asyncio.TimeoutError:
+                logger.warning(
+                    "Process drain exceeded 4s deadline with %d process(es); "
+                    "continuing shutdown",
+                    len(process_ids),
+                )
         if tasks:
             await asyncio.gather(*tasks, return_exceptions=True)
         self.active_tasks.clear()
@@ -17859,6 +17917,18 @@ class RuntimeDaemon:
     def handle_signal(self, sig):
         logger.info("Received signal %s", sig)
         self._shutdown = True
+        # AGT-04: interrupt the poll-delay sleep so graceful shutdown starts
+        # within milliseconds instead of after the full poll interval. The
+        # Windows fallback invokes this from a signal handler off the loop
+        # thread, so the wake must be scheduled thread-safely there.
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+        if loop is not None and loop.is_running():
+            loop.call_soon_threadsafe(self._shutdown_event.set)
+        else:
+            self._shutdown_event.set()
 
 
 async def main():

{forgexa_cli-1.57.0 → forgexa_cli-1.57.2}/forgexa_cli.egg-info/PKG-INFO

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

{forgexa_cli-1.57.0 → forgexa_cli-1.57.2}/pyproject.toml

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