forgexa-cli 1.56.4__tar.gz → 1.57.1__tar.gz

{forgexa_cli-1.56.4 → forgexa_cli-1.57.1}/PKG-INFO

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

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

{forgexa_cli-1.56.4 → forgexa_cli-1.57.1}/forgexa_cli/agent_core.py

@@ -2386,6 +2386,39 @@ _UNVERIFIED_AGENT_LIVE_GATE_REASONS = {
     ),
 }
 
+AGENT_LIVE_VERIFIED_FILE = Path.home() / ".forgexa" / "agent-live-verified"
+
+
+def agent_live_gate_approved(agent_id: str, env: dict[str, str] | None = None) -> bool:
+    """Whether an operator recorded a live-acceptance pass for this agent.
+
+    Fail-closed by default: the gate only opens through an explicit
+    ``forgexa agent approve-live <id>`` (persistent file, readable by
+    GUI-launched runtimes) or the FORGEXA_AGENT_LIVE_VERIFIED env var —
+    both mean a human actually ran the live start/resume/cancel/isolation
+    acceptance against a real account/build and accepted the result.
+    Agents without a live gate entry are NOT approved here: their gate is
+    the class-level ``integration_verified`` flag, and returning True
+    would silently disarm it for any driver marked unverified.
+    """
+    if agent_id.lower() not in _UNVERIFIED_AGENT_LIVE_GATE_REASONS:
+        return False
+    source_env = os.environ if env is None else env
+    verified = {
+        value.strip().lower()
+        for value in source_env.get("FORGEXA_AGENT_LIVE_VERIFIED", "").split(",")
+        if value.strip()
+    }
+    try:
+        lines = AGENT_LIVE_VERIFIED_FILE.read_text(encoding="utf-8").splitlines()
+    except OSError:
+        lines = []
+    for line in lines:
+        value = line.split("#", 1)[0].strip()
+        if value:
+            verified.add(value.lower())
+    return agent_id.lower() in verified
+
 
 def agent_execution_verification_issue(agent_id: str, binary: str) -> str | None:
     """Return a fail-closed build/live-acceptance gate for local agents."""
@@ -2393,7 +2426,15 @@ def agent_execution_verification_issue(agent_id: str, binary: str) -> str | None
         build_issue = zcode_build_verification_issue(binary)
         if build_issue:
             return build_issue
-    return _UNVERIFIED_AGENT_LIVE_GATE_REASONS.get(agent_id)
+    if agent_live_gate_approved(agent_id):
+        return None
+    reason = _UNVERIFIED_AGENT_LIVE_GATE_REASONS.get(agent_id)
+    if reason:
+        return (
+            f"{reason}; run `forgexa agent approve-live {agent_id}` after "
+            "completing the acceptance checklist"
+        )
+    return None
 
 
 _FORGEXA_CODING_AGENT_TOOLS = ("Read", "Glob", "Grep", "Edit", "Write", "Bash")

{forgexa_cli-1.56.4 → forgexa_cli-1.57.1}/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.56.4"
+DAEMON_VERSION = "1.57.1"
 
 
 def _detect_client_type() -> str:
@@ -1215,6 +1215,38 @@ logging.basicConfig(
 # Routine poll/heartbeat requests otherwise consume the entire 500-line remote
 # log tail in about 20 minutes, hiding the task failure operators need to see.
 logging.getLogger("httpx").setLevel(logging.WARNING)
+
+
+def _pid_looks_like_forgexa_daemon(pid: int) -> bool:
+    """Best-effort identity check before signalling a lock-file PID.
+
+    Reads the process cmdline (Linux /proc, macOS `ps`) and accepts the PID
+    only when it mentions this daemon. Unknown/unreadable identity returns
+    False — the conservative direction is leaving the stale lock to the
+    operator, never killing an unrelated reused PID (audit AGT-05).
+    """
+    if pid <= 0:
+        return False
+    if pid == os.getpid():
+        return True
+    try:
+        cmdline = ""
+        try:
+            with open(f"/proc/{pid}/cmdline", "rb") as fh:
+                cmdline = fh.read().replace(b"\0", b" ").decode("utf-8", "replace")
+        except OSError:
+            import subprocess as _sp
+
+            result = _sp.run(
+                ["ps", "-p", str(pid), "-o", "command="],
+                capture_output=True, text=True, timeout=5,
+            )
+            cmdline = result.stdout or ""
+        lowered = cmdline.lower()
+        return "forgexa" in lowered or "daemon.py" in lowered
+    except Exception:
+        return False
+
 logger = logging.getLogger("daemon")
 logger.info("Daemon log: %s", DAEMON_LOG_PATH)
 
@@ -6894,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)
@@ -6959,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)
@@ -7020,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 ""
@@ -7037,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,
             )
@@ -7095,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(
@@ -10916,8 +10954,22 @@ class RuntimeDaemon:
             # Lock held by another process — try to read its PID and kill it
             try:
                 old_pid = int(lock_path.read_text().strip())
-                logger.warning("Another daemon is running (PID %d). Sending SIGTERM...", old_pid)
-                os.kill(old_pid, signal.SIGTERM)
+                if not _pid_looks_like_forgexa_daemon(old_pid):
+                    # AGT-05 (audit): a stale PID reused by an unrelated
+                    # process must never be signalled — verify identity from
+                    # the process cmdline before killing (mirrors the Rust
+                    # daemon manager's check).
+                    logger.error(
+                        "Lock file names PID %d but it is not a Forgexa daemon — "
+                        "refusing to signal it; remove the stale lock manually",
+                        old_pid,
+                    )
+                    old_pid = 0
+                if old_pid:
+                    logger.warning("Another daemon is running (PID %d). Sending SIGTERM...", old_pid)
+                    os.kill(old_pid, signal.SIGTERM)
+                if not old_pid:
+                    raise ValueError("no verified daemon PID")
                 # Wait up to 5 seconds for it to exit
                 for _ in range(50):
                     try:
@@ -15571,6 +15623,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,

{forgexa_cli-1.56.4 → forgexa_cli-1.57.1}/forgexa_cli/main.py

@@ -3612,6 +3612,48 @@ def cmd_zcode_approve_build(args: argparse.Namespace) -> None:
     print("running daemons and desktop sidecars pick this up on their next probe (no restart needed)")
 
 
+def cmd_agent_approve_live(args: argparse.Namespace) -> None:
+    from datetime import datetime, timezone
+
+    from . import agent_core
+
+    agent_id = args.agent_id.strip().lower()
+    gated = set(agent_core._UNVERIFIED_AGENT_LIVE_GATE_REASONS)
+    if agent_id not in gated:
+        print(
+            f"error: unknown gated agent '{agent_id}'; gated agents: {', '.join(sorted(gated))}",
+            file=sys.stderr,
+        )
+        return
+    path = agent_core.AGENT_LIVE_VERIFIED_FILE
+    existing = ""
+    try:
+        existing = path.read_text(encoding="utf-8")
+    except OSError:
+        pass
+    approved = {
+        line.split("#", 1)[0].strip().lower()
+        for line in existing.splitlines() if line.split("#", 1)[0].strip()
+    }
+    if agent_id in approved:
+        print(f"already live-verified: {agent_id}")
+        print(f"allowlist file: {path}")
+        return
+    who = getpass.getuser()
+    when = datetime.now(timezone.utc).isoformat(timespec="seconds")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    suffix = "" if (not existing or existing.endswith("\n")) else "\n"
+    path.write_text(
+        existing + suffix
+        + f"{agent_id}  # live gate accepted by {who} at {when} via `forgexa agent approve-live`\n",
+        encoding="utf-8",
+    )
+    print(f"live gate approved for agent: {agent_id}")
+    print(f"accepted by: {who} at {when}")
+    print(f"written to: {path}")
+    print("only do this after completing the live start/resume/cancel/isolation acceptance checklist")
+
+
 def main() -> None:
     global _SERVER_URL_OVERRIDE, _output_format
 
@@ -3841,6 +3883,19 @@ def main() -> None:
         help="Path to the zcode binary (default: $FACTORY_ZCODE_PATH or `zcode` on PATH)",
     )
 
+    # agent
+    agent_p = sub.add_parser("agent", help="Agent gate management")
+    agent_sub = agent_p.add_subparsers(dest="agent_cmd")
+    agent_approve_live_p = agent_sub.add_parser(
+        "approve-live",
+        help="Record that an agent passed its live acceptance gate "
+             "(opens the fail-closed live gate for daemon dispatch and desktop probes)",
+    )
+    agent_approve_live_p.add_argument(
+        "agent_id", metavar="AGENT_ID",
+        help="Gated agent id (e.g. trae, zcode)",
+    )
+
     # runtimes
     rt_p = sub.add_parser("runtimes", help="Runtime management")
     rt_sub = rt_p.add_subparsers(dest="rt_cmd")
@@ -3973,6 +4028,9 @@ def main() -> None:
         "zcode": lambda a: {
             "approve-build": cmd_zcode_approve_build,
         }.get(a.zcode_cmd, lambda _: zcode_p.print_help())(a),
+        "agent": lambda a: {
+            "approve-live": cmd_agent_approve_live,
+        }.get(a.agent_cmd, lambda _: agent_p.print_help())(a),
         "runtimes": lambda a: {
             "list": cmd_runtimes_list,
         }.get(a.rt_cmd, lambda _: rt_p.print_help())(a),

{forgexa_cli-1.56.4 → forgexa_cli-1.57.1}/forgexa_cli/zcode_protocol.py

@@ -278,7 +278,18 @@ class ZCodeProtocolSession:
         text = ""
         usage: dict[str, int] = {}
         if terminal.status == "success":
-            text, usage = await self._fetch_turn_transcript(terminal.turn_id)
+            try:
+                text, usage = await self._fetch_turn_transcript(terminal.turn_id)
+            except ZCodeProtocolError as exc:
+                # AGT-06 (audit): the work already landed on disk — a
+                # transcript read-back failure must not flip a terminal
+                # success into a protocol failure (and a pointless re-run).
+                # Degrade to empty text with the reason surfaced.
+                logger.warning(
+                    "zcode transcript read-back failed for session %s: %s",
+                    self.session_id, exc,
+                )
+                text = ""
         return ZCodeTurnResult(
             status=terminal.status,
             session_id=self.session_id or "",
@@ -297,6 +308,7 @@ class ZCodeProtocolSession:
             return "", {}
         texts: list[str] = []
         totals = {"input_tokens": 0, "output_tokens": 0}
+        turn_known = isinstance(turn_id, str) and bool(turn_id)
         for message in messages:
             if not isinstance(message, dict):
                 continue
@@ -305,7 +317,14 @@ class ZCodeProtocolSession:
                 continue
             anchor = info.get("anchor") if isinstance(info.get("anchor"), dict) else {}
             message_turn = anchor.get("turnId")
-            if turn_id and isinstance(message_turn, str) and message_turn != turn_id:
+            if turn_known and isinstance(message_turn, str) and message_turn != turn_id:
+                continue
+            if not turn_known and message_turn is not None:
+                # AGT-06 (audit): the ack/op-event channel never yielded a
+                # turnId — attributing the whole resumed session's assistant
+                # history to this turn would pollute the answer. Only
+                # un-anchored messages (the current in-flight exchange) may
+                # be attributed; anchored history belongs to earlier turns.
                 continue
             parts = message.get("parts") if isinstance(message.get("parts"), list) else []
             for part in parts:

{forgexa_cli-1.56.4 → forgexa_cli-1.57.1}/forgexa_cli.egg-info/PKG-INFO

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

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