forgexa-cli 1.7.8__tar.gz → 1.8.4__tar.gz

{forgexa_cli-1.7.8 → forgexa_cli-1.8.4}/PKG-INFO

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

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

{forgexa_cli-1.7.8 → forgexa_cli-1.8.4}/forgexa_cli/daemon.py

@@ -332,7 +332,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.7.8"
+DAEMON_VERSION = "1.8.4"
 
 
 def _detect_client_type() -> str:
@@ -611,7 +611,7 @@ class AgentDiscovery:
     """Scans for locally installed Agent CLI tools."""
 
     AGENT_REGISTRY = {
-        "claude-code": {
+        "claude": {
             "commands": ["claude"],
             "detect": "claude --version",
             "invoke_modes": ["print", "app-server"],
@@ -642,19 +642,19 @@ class AgentDiscovery:
             "env_path_override": "FACTORY_GEMINI_PATH",
             "compatibility_level": "L1",
         },
-        "kimi-code": {
+        "kimi": {
             "commands": ["kimi"],
             "detect": "kimi --version",
             "invoke_modes": ["cli"],
             "env_path_override": "FACTORY_KIMI_PATH",
             "compatibility_level": "L2",
         },
-        "hermes": {
-            "commands": ["hermes"],
-            "detect": "hermes --version",
+        "copilot": {
+            "commands": ["copilot"],
+            "detect": "copilot --version",
             "invoke_modes": ["cli"],
-            "env_path_override": "FACTORY_HERMES_PATH",
-            "compatibility_level": "L1",
+            "env_path_override": "FACTORY_COPILOT_PATH",
+            "compatibility_level": "L3",
         },
     }
 
@@ -711,6 +711,24 @@ class AgentDiscovery:
                     Path("/usr/local/bin"),
                     Path("/opt/homebrew/bin"),
                 ]
+                # GitHub Copilot CLI — installed via VS Code extension into globalStorage
+                vscode_copilot = (
+                    home / "Library" / "Application Support" / "Code" / "User"
+                    / "globalStorage" / "github.copilot-chat" / "copilotCli"
+                )
+                extra_dirs.append(vscode_copilot)
+                for vs_variant in ("Code - Insiders", "VSCodium"):
+                    extra_dirs.append(
+                        home / "Library" / "Application Support" / vs_variant / "User"
+                        / "globalStorage" / "github.copilot-chat" / "copilotCli"
+                    )
+            if sys.platform == "linux":
+                # GitHub Copilot CLI on Linux VSCode
+                for config_dir in (
+                    home / ".config" / "Code" / "User" / "globalStorage" / "github.copilot-chat" / "copilotCli",
+                    home / ".config" / "Code - Insiders" / "User" / "globalStorage" / "github.copilot-chat" / "copilotCli",
+                ):
+                    extra_dirs.append(config_dir)
             # nvm (macOS + Linux)
             nvm_dir = os.environ.get("NVM_DIR", str(home / ".nvm"))
             nvm_path = Path(nvm_dir)
@@ -738,6 +756,14 @@ class AgentDiscovery:
             resolved = shutil.which(cmd)
             if resolved:
                 version = await self._get_version(spec["detect"])
+                if version is None:
+                    # Binary found but version check failed — it is a stub or
+                    # not properly installed (e.g. copilot prompts to install).
+                    logger.warning(
+                        "Agent %s found at %s but version check failed — skipping",
+                        agent_id, resolved,
+                    )
+                    continue
                 available.append(DiscoveredAgent(
                     agent_id=agent_id,
                     command=resolved,
@@ -748,18 +774,43 @@ class AgentDiscovery:
                 logger.info("Discovered agent: %s v%s (%s)", agent_id, version, resolved)
         return available
 
-    async def _get_version(self, detect_cmd: str) -> str:
+    async def _get_version(self, detect_cmd: str) -> str | None:
+        """Run <detect_cmd> and return the first line of output as a version string.
+
+        Returns ``None`` if the command exits with a non-zero code, times out,
+        or produces output that doesn't look like a version number (e.g. an
+        interactive install prompt).  Callers should treat ``None`` as
+        "binary found but not functional".
+        """
+        import re
         try:
             parts = detect_cmd.split()
             proc = await asyncio.create_subprocess_exec(
                 *parts,
+                stdin=asyncio.subprocess.DEVNULL,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
             )
-            stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=10)
-            return stdout.decode().strip().split("\n")[0][:100]
+            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=10)
+            if proc.returncode != 0:
+                return None
+            output = stdout.decode().strip().split("\n")[0][:100]
+            if not output:
+                # Some tools write their version to stderr (e.g. some Node CLIs)
+                output = stderr.decode().strip().split("\n")[0][:100]
+            # Reject non-version output such as interactive install prompts.
+            # A valid version string contains a digit sequence like 1.2.3 or v1.2.
+            # Use re.search so we match versions embedded in text like:
+            #   'Kimi Code 1.0.0', '@openai/codex 0.1.x', 'GitHub Copilot 1.2.3'
+            if not re.search(r'v?\d+[.\d]', output):
+                logger.warning(
+                    "Version check for %r returned unexpected output: %r — treating as not available",
+                    detect_cmd, output,
+                )
+                return None
+            return output
         except Exception:
-            return "unknown"
+            return None
 
     @staticmethod
     async def _probe_bwrap_support() -> None:
@@ -1732,24 +1783,49 @@ class ProcessManager:
                     error_messages.append(err.get("message", "turn failed"))
                 elif isinstance(err, str):
                     error_messages.append(err)
+            # ── GitHub Copilot CLI event types ──────────────────────────────
+            elif ev_type == "assistant.turn_end":
+                has_turn_completed = True
+            elif ev_type == "assistant.turn_start":
+                has_assistant_events = True
+            elif ev_type == "assistant.message":
+                has_meaningful_content = True
+                has_assistant_events = True
+                msg_data = data.get("data") or {}
+                if isinstance(msg_data.get("content"), str) and msg_data["content"].strip():
+                    has_result = True
+            elif ev_type == "assistant.message_delta":
+                has_meaningful_content = True
+            # ── Generic / Claude "result" event ────────────────────────────
             elif ev_type == "result":
-                result_text = str(data.get("result", "") or "")
-                if data.get("is_error"):
-                    err_text = result_text or str(data.get("error", "") or "result marked as error")
-                    error_messages.append(err_text)
-                else:
-                    # 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:
+                # Copilot result format: {"type":"result","exitCode":0,"usage":{...}}
+                # Claude result format:  {"type":"result","result":"...","is_error":false,...}
+                if "exitCode" in data:
+                    # Copilot JSONL result
+                    exit_code = int(data.get("exitCode") or 0)
+                    if exit_code == 0:
                         has_result = True
                         has_meaningful_content = True
+                    else:
+                        error_messages.append(f"Copilot exited with code {exit_code}")
+                else:
+                    result_text = str(data.get("result", "") or "")
+                    if data.get("is_error"):
+                        err_text = result_text or str(data.get("error", "") or "result marked as error")
+                        error_messages.append(err_text)
+                    else:
+                        # 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:
@@ -1895,10 +1971,15 @@ class ProcessManager:
             return f"Agent encountered errors without producing output: {error_messages[0]}"
 
         # ── Claude: JSON output mode but no result object and no content ──
-        if agent_id == "claude-code" and json_line_count > 0:
+        if agent_id == "claude" and json_line_count > 0:
             if not has_result and not has_meaningful_content:
                 return "Claude produced no result output"
 
+        # ── Copilot: JSONL mode but no turn completion and no content ──
+        if agent_id == "copilot" and json_line_count > 0:
+            if not has_result and not has_meaningful_content:
+                return "Copilot produced no result output (check GitHub authentication: run 'gh auth login')"
+
         return None
 
     async def run_agent(
@@ -1915,7 +1996,7 @@ class ProcessManager:
 
         start_time = time.monotonic()
 
-        if agent.agent_id == "claude-code":
+        if agent.agent_id == "claude":
             result = await self._run_claude(
                 agent, prompt, workspace_path, timeout, task.task_id, on_chunk,
                 node_type=task.node_type,
@@ -1926,8 +2007,10 @@ class ProcessManager:
             result = await self._run_opencode(agent, prompt, workspace_path, timeout, task.task_id, on_chunk)
         elif agent.agent_id == "gemini":
             result = await self._run_gemini(agent, prompt, workspace_path, timeout, task.task_id, on_chunk)
-        elif agent.agent_id == "kimi-code":
+        elif agent.agent_id == "kimi":
             result = await self._run_kimi_code(agent, prompt, workspace_path, timeout, task.task_id, on_chunk)
+        elif agent.agent_id == "copilot":
+            result = await self._run_copilot(agent, prompt, workspace_path, timeout, task.task_id, on_chunk)
         else:
             result = await self._run_generic(agent, prompt, workspace_path, timeout, task.task_id, on_chunk)
 
@@ -2386,6 +2469,101 @@ class ProcessManager:
         result.metrics.update(parsed_metrics)
         return result
 
+    async def _run_copilot(
+        self, agent: DiscoveredAgent, prompt: str, cwd: Path, timeout: int, task_id: str,
+        on_chunk: Any = None,
+    ) -> TaskResult:
+        """Run GitHub Copilot CLI in non-interactive JSON-streaming mode.
+
+        Uses TERM=dumb to suppress TTY-detection (copilot suspends when it
+        can't acquire a pseudo-terminal).  Requires GitHub login:
+        ``gh auth login`` or GITHUB_TOKEN env var must be set.
+
+        Flags:
+          -p / --prompt     Non-interactive prompt (exits after completion).
+          --output-format json   JSONL stream of session events.
+          --allow-all       Grant all tool + path + URL permissions required
+                            for autonomous file-editing tasks.
+          -C <dir>          Change working directory before execution.
+        """
+        env = os.environ.copy()
+        env["TERM"] = "dumb"  # suppress TTY-detection that suspends the process
+
+        model_override = os.environ.get("FACTORY_COPILOT_MODEL")
+        reasoning = os.environ.get("FACTORY_COPILOT_REASONING", "medium")
+
+        cmd = [
+            agent.command,
+            "--output-format", "json",
+            "--allow-all",
+            "--effort", reasoning,
+            "-C", str(cwd),
+            "-p", prompt,
+        ]
+        if model_override:
+            cmd = [agent.command, "--model", model_override] + cmd[1:]
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=str(cwd),
+                env=env,
+                limit=100 * 1024 * 1024,
+                start_new_session=True,
+            )
+            self.active_processes[task_id] = proc
+            stdout, stderr, returncode = await self._stream_process(
+                proc, None, timeout, task_id, on_chunk
+            )
+
+            # Parse copilot JSONL output for metrics
+            metrics = self._parse_copilot_output(stdout)
+
+            # Copilot always exits 0 on normal completion; check result.exitCode
+            # from the JSONL "result" event for a true success signal.
+            copilot_exit = self._extract_copilot_exit_code(stdout)
+            effective_rc = copilot_exit if copilot_exit is not None else returncode
+
+            if effective_rc == 0 and returncode == 0:
+                return TaskResult(
+                    status="success",
+                    exit_code=0,
+                    stdout=stdout[-settings.AGENT_MAX_OUTPUT_SIZE:],
+                    stderr=stderr[-10000:],
+                    metrics=metrics,
+                )
+            else:
+                return TaskResult(
+                    status="failed",
+                    exit_code=effective_rc,
+                    stdout=stdout[-settings.AGENT_MAX_OUTPUT_SIZE:],
+                    stderr=stderr[-10000:],
+                    error=f"Copilot exited with code {effective_rc}: {stderr[-500:]}",
+                    metrics=metrics,
+                )
+        except asyncio.TimeoutError:
+            if task_id in self.active_processes:
+                self.active_processes[task_id].kill()
+            return TaskResult(
+                status="failed", exit_code=-1, stdout="", stderr="",
+                error=f"Timed out after {timeout}s",
+            )
+        except Exception as exc:
+            logger.exception("Copilot stream error for task %s", task_id)
+            if task_id in self.active_processes:
+                try:
+                    self.active_processes[task_id].kill()
+                except Exception:
+                    pass
+            return TaskResult(
+                status="failed", exit_code=-1, stdout="", stderr="",
+                error=f"Stream processing error: {exc}",
+            )
+        finally:
+            self.active_processes.pop(task_id, None)
+
     async def _run_generic(
         self, agent: DiscoveredAgent, prompt: str, cwd: Path, timeout: int, task_id: str,
         on_chunk: Any = None,
@@ -2702,6 +2880,79 @@ class ProcessManager:
             metrics["token_output"] = output
         return metrics
 
+    def _parse_copilot_output(self, stdout: str) -> dict:
+        """Extract metrics from GitHub Copilot CLI JSONL output.
+
+        Copilot CLI (--output-format json) emits one JSON object per line.
+        The key event types:
+          - ``assistant.message``  -> content + model + outputTokens per turn
+          - ``result``             -> exitCode + usage (premiumRequests,
+                                     totalApiDurationMs, codeChanges)
+
+        Copilot is subscription-based and does NOT report USD cost or input
+        tokens, so those fields are intentionally omitted.
+        """
+        metrics: dict[str, Any] = {}
+        total_output_tokens = 0
+        model_seen: str | None = None
+
+        for raw in stdout.strip().split("\n"):
+            raw = raw.strip()
+            if not raw:
+                continue
+            try:
+                data = json.loads(raw)
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(data, dict):
+                continue
+
+            ev_type = str(data.get("type", ""))
+
+            if ev_type == "assistant.message":
+                msg_data = data.get("data") or {}
+                out_tokens = msg_data.get("outputTokens")
+                if out_tokens:
+                    total_output_tokens += int(out_tokens)
+                if not model_seen and isinstance(msg_data.get("model"), str):
+                    model_seen = msg_data["model"]
+
+            elif ev_type == "result":
+                usage = data.get("usage") or {}
+                premium_reqs = usage.get("premiumRequests")
+                if premium_reqs is not None:
+                    metrics["premium_requests"] = int(premium_reqs)
+                api_ms = usage.get("totalApiDurationMs")
+                if api_ms:
+                    metrics["api_duration_ms"] = int(api_ms)
+                changes = usage.get("codeChanges") or {}
+                if changes.get("linesAdded") or changes.get("linesRemoved"):
+                    metrics["lines_added"] = int(changes.get("linesAdded") or 0)
+                    metrics["lines_removed"] = int(changes.get("linesRemoved") or 0)
+
+        if total_output_tokens:
+            metrics["token_output"] = total_output_tokens
+        if model_seen:
+            metrics["model"] = model_seen
+        return metrics
+
+    @staticmethod
+    def _extract_copilot_exit_code(stdout: str) -> int | None:
+        """Extract the exitCode from Copilot JSONL ``result`` event."""
+        for raw in reversed(stdout.strip().split("\n")):
+            raw = raw.strip()
+            if not raw:
+                continue
+            try:
+                data = json.loads(raw)
+            except json.JSONDecodeError:
+                continue
+            if isinstance(data, dict) and data.get("type") == "result":
+                ec = data.get("exitCode")
+                if ec is not None:
+                    return int(ec)
+        return None
+
     async def _collect_git_info(self, cwd: Path) -> dict:
         """Collect git diff stats from workspace."""
         info: dict[str, Any] = {}
@@ -2779,7 +3030,7 @@ class ProcessManager:
         """Collect git diff stats comparing HEAD vs merge-base with default branch.
 
         Uses merge-base to capture ALL changes on the feature branch, not just
-        the last commit (agents like claude-code may create multiple commits).
+        the last commit (agents like claude may create multiple commits).
         Falls back to HEAD~1 if merge-base detection fails.
         """
         info: dict[str, Any] = {}
@@ -3140,7 +3391,7 @@ class TaskPoller:
                     task_id=t["task_id"],
                     graph_id=t["graph_id"],
                     node_type=t["node_type"],
-                    agent_type=t.get("agent_type", "claude-code"),
+                    agent_type=t.get("agent_type", "claude"),
                     input_prompt=t.get("input_prompt", ""),
                     input_data=t.get("input_data", {}),
                     timeout_seconds=t.get("timeout_seconds", settings.AGENT_TIMEOUT),
@@ -3787,10 +4038,22 @@ class RuntimeDaemon:
             # 1. Find the right agent
             agent = self._select_agent(task.agent_type, task.fallback_chain)
             if not agent:
-                logger.error("No agent found for type '%s'", task.agent_type)
+                _INSTALL_HINTS = {
+                    "claude": "npm install -g @anthropic-ai/claude-code",
+                    "codex": "npm install -g @openai/codex",
+                    "opencode": "curl -sSL https://opencode.ai/install | sh",
+                    "gemini": "npm install -g @google/gemini-cli",
+                    "kimi": "curl -LsSf https://code.kimi.com/install.sh | bash",
+                    "copilot": "Install VS Code GitHub Copilot Chat extension, or run: gh copilot. Then: gh auth login",
+                }
+                hint = _INSTALL_HINTS.get(task.agent_type, f"install the '{task.agent_type}' CLI tool")
+                logger.error("No agent found for type '%s' on this runtime", task.agent_type)
                 await reporter.report_complete(task.task_id, TaskResult(
                     status="failed", exit_code=-1, stdout="", stderr="",
-                    error=f"No agent CLI available for type '{task.agent_type}'",
+                    error=(
+                        f"Agent '{task.agent_type}' is not available on this runtime. "
+                        f"Install it: {hint}"
+                    ),
                 ))
                 return
 
@@ -3818,15 +4081,22 @@ class RuntimeDaemon:
                 _line_buffer.extend(lines)
 
             async def _progress_ticker():
-                """Flush buffered output lines + update progress % every 5 s."""
+                """Flush buffered output lines + update progress % every 1 s.
+
+                Using 1-second ticks keeps the UI responsive without flooding
+                the backend. Empty ticks are skipped to reduce HTTP traffic.
+                """
                 import math as _math
                 tick = 0
                 while not progress_stop.is_set():
-                    await asyncio.sleep(5)
+                    await asyncio.sleep(1)
                     if progress_stop.is_set():
                         break
+                    if not _line_buffer and tick < 3:
+                        tick += 1
+                        continue
                     tick += 1
-                    pct = min(int(10 + 80 * (1 - 1 / (1 + tick / 16))), 90)
+                    pct = min(int(10 + 80 * (1 - 1 / (1 + tick / 80))), 90)
                     pid = self.process_manager.active_processes.get(task.task_id)
                     step = "running_agent"
                     if pid:
@@ -3912,11 +4182,14 @@ class RuntimeDaemon:
                     async def _progress_ticker2():
                         tick = 0
                         while not progress_stop2.is_set():
-                            await asyncio.sleep(5)
+                            await asyncio.sleep(1)
                             if progress_stop2.is_set():
                                 break
+                            if not _line_buffer and tick < 3:
+                                tick += 1
+                                continue
                             tick += 1
-                            pct = min(int(10 + 80 * (1 - 1 / (1 + tick / 16))), 90)
+                            pct = min(int(10 + 80 * (1 - 1 / (1 + tick / 80))), 90)
                             pid = self.process_manager.active_processes.get(task.task_id)
                             step = f"running_agent:{agent.agent_id}"
                             if pid:
@@ -4136,8 +4409,8 @@ class RuntimeDaemon:
                     if agent.agent_id == fallback_id:
                         return agent
 
-        # 2. Try any available agent not yet tried (prefer opencode > gemini > claude-code)
-        preferred_order = ["opencode", "gemini", "claude-code"]
+        # 2. Try any available agent not yet tried (prefer opencode > copilot > gemini > claude)
+        preferred_order = ["opencode", "copilot", "gemini", "claude"]
         for preferred_id in preferred_order:
             if preferred_id in tried:
                 continue
@@ -4152,7 +4425,17 @@ class RuntimeDaemon:
         return None
 
     def _select_agent(self, agent_type: str, fallback_chain: list[str] | None = None) -> DiscoveredAgent | None:
-        """Find best matching agent for the requested type with fallback chain support."""
+        """Find best matching agent for the requested type with fallback chain support.
+
+        Returns ``None`` when the requested agent is a known canonical ID but is not
+        currently installed/discovered on this machine — callers should report a clear
+        error rather than silently running a different agent.
+
+        The "any available agent" fallbacks (steps 3–4) only apply when ``agent_type``
+        is NOT a recognized canonical ID (e.g. empty string, "auto", or an unknown
+        custom identifier).  This prevents silent substitution when the user explicitly
+        selected an agent that is just not installed locally.
+        """
         # 1. Exact match
         for agent in self.agents:
             if agent.agent_id == agent_type:
@@ -4168,11 +4451,18 @@ class RuntimeDaemon:
                         logger.info("Using fallback agent '%s' (requested '%s')", fallback_id, agent_type)
                         return agent
 
-        # 3. Fallback: first available L3 agent
+        # 3. If the requested agent_type is a KNOWN canonical ID (registered in
+        #    AGENT_REGISTRY) but not discovered locally, return None so the caller
+        #    can surface a clear "agent not installed" error instead of silently
+        #    using whatever L3 agent happens to be available.
+        if agent_type in AgentDiscovery.AGENT_REGISTRY:
+            return None
+
+        # 4. Fallback: first available L3 agent (only for unrecognized/generic types)
         for agent in self.agents:
             if agent.compatibility_level == "L3":
                 return agent
-        # 4. Any agent
+        # 5. Any agent (last resort for unrecognized types)
         return self.agents[0] if self.agents else None
 
     # ── Layer 2: Validation Gate ──
@@ -4390,13 +4680,33 @@ class RuntimeDaemon:
                 timeout=10,
             )
 
-            # 1. Select agent
-            agent_type = agent_override or "claude-code"
+            # 1. Select agent — normalize legacy aliases to canonical IDs.
+            # When no agent_override is specified (empty/None), pass an empty
+            # string so _select_agent falls through to its "any available L3
+            # agent" logic instead of hard-failing on the 'claude' default.
+            _AGENT_ALIASES = {"claude": "claude", "kimi": "kimi"}
+            agent_type = _AGENT_ALIASES.get(agent_override or "", agent_override or "")
             agent = self._select_agent(agent_type, [])
             if not agent:
+                _INSTALL_HINTS = {
+                    "claude": "npm install -g @anthropic-ai/claude-code",
+                    "codex": "npm install -g @openai/codex",
+                    "opencode": "curl -sSL https://opencode.ai/install | sh",
+                    "gemini": "npm install -g @google/gemini-cli",
+                    "kimi": "curl -LsSf https://code.kimi.com/install.sh | bash",
+                    "copilot": "Install VS Code GitHub Copilot Chat extension, or run: gh copilot. Then: gh auth login",
+                }
+                hint = _INSTALL_HINTS.get(agent_type, f"install the '{agent_type}' CLI tool")
                 await conn.client.post(
                     f"{reporter_url}/complete",
-                    json={"status": "failed", "error": f"No agent CLI for '{agent_type}'", "failure_code": "no_agent"},
+                    json={
+                        "status": "failed",
+                        "error": (
+                            f"Agent '{agent_type}' is not available on this runtime. "
+                            f"Install it: {hint}"
+                        ),
+                        "failure_code": "no_agent",
+                    },
                     timeout=10,
                 )
                 return
@@ -4405,7 +4715,11 @@ class RuntimeDaemon:
             full_prompt = f"{system_prompt}\n\n{user_prompt}" if system_prompt else user_prompt
             fake_task = TaskInfo(
                 task_id=job_id,
-                graph_id="",
+                # Use job_id as graph_id so workspace_key is non-empty.
+                # If graph_id="" then workspace_key="" and ws_path == project_dir
+                # (Python: Path("x") / "" == Path("x")), causing git clone to
+                # fail with "destination path already exists" on the second run.
+                graph_id=job_id,
                 node_type="ai_job",
                 agent_type=agent_type,
                 input_prompt=full_prompt,
@@ -4430,40 +4744,86 @@ class RuntimeDaemon:
                 timeout=10,
             )
 
-            # 3. Run agent with prompt
+            # 3. Run agent with prompt — stream output lines back to server in
+            # real-time so the UI black box shows agent activity instead of
+            # staying empty for the entire (potentially long) run.
             _line_buffer: list[str] = []
+            _chunk_state = {"sent_count": 0, "last_flush": time.monotonic()}
+
+            async def _flush_output_to_server():
+                pending = _line_buffer[_chunk_state["sent_count"]:]
+                if not pending:
+                    return
+                try:
+                    await conn.client.post(
+                        f"{reporter_url}/progress",
+                        json={"output_lines": pending, "agent_id": agent.agent_id},
+                        timeout=5,
+                    )
+                except Exception:
+                    pass  # never let streaming errors affect agent execution
+                _chunk_state["sent_count"] += len(pending)
+                _chunk_state["last_flush"] = time.monotonic()
 
             async def on_chunk(lines: list[str]):
                 _line_buffer.extend(lines)
+                now = time.monotonic()
+                pending_count = len(_line_buffer) - _chunk_state["sent_count"]
+                # Flush every 10 new lines or every 8 seconds, whichever first
+                if pending_count >= 10 or (now - _chunk_state["last_flush"]) >= 8.0:
+                    await _flush_output_to_server()
 
             result = await self.process_manager.run_agent(
                 agent, fake_task, workspace_path, on_chunk=on_chunk,
             )
+            # Flush any remaining buffered lines after agent finishes
+            await _flush_output_to_server()
 
             # 4. Auto-commit if successful
+            input_ctx = aj.get("input_context", {})
             git_info = {}
             if result.status == "success" and result.files_changed:
                 git_info = await self._auto_commit(workspace_path, fake_task)
 
             # 5. Report completion
-            output_content = result.stdout[-20000:] if result.stdout else ""
+            # For deliverables: allow up to 200K chars (full document); others: last 20K
+            max_content = 200000 if task_type == "deliverable_generate" else 20000
+            output_content = (result.stdout or "")[-max_content:] if result.stdout else ""
             scripts: dict = {}
 
-            # Try to extract per-scenario scripts from output
-            scenario_ids = aj.get("input_context", {}).get("scenario_ids", [])
+            scenario_ids = input_ctx.get("scenario_ids", [])
             if scenario_ids and output_content:
-                # Simple heuristic: if output is a single script, map it to first scenario
-                # Daemon-generated scripts may be multiple files in workspace
+                # Primary: extract scripts using structured SCRIPT_START/END markers
+                # inserted by poll_ai_jobs into the multi-scenario prompt.
+                import re as _re
                 for sid in scenario_ids:
-                    # Check if daemon wrote test files to workspace
-                    import glob
-                    test_files = glob.glob(str(workspace_path / "tests" / "**" / f"*{sid[:8]}*"), recursive=True)
-                    if test_files:
-                        try:
-                            with open(test_files[0], "r") as f:
-                                scripts[sid] = f.read()
-                        except Exception:
-                            pass
+                    pattern = (
+                        r"##\s*SCRIPT_START::" + _re.escape(sid)
+                        + r"\s*\n(.*?)\n##\s*SCRIPT_END::" + _re.escape(sid)
+                    )
+                    m = _re.search(pattern, output_content, _re.DOTALL)
+                    if m:
+                        scripts[sid] = m.group(1).strip()
+
+                # Fallback: if no markers found but only one scenario, treat
+                # the entire output as that scenario's script.
+                if not scripts and len(scenario_ids) == 1:
+                    scripts[scenario_ids[0]] = output_content.strip()
+
+                # Fallback: check workspace for test files named after scenario
+                if not scripts:
+                    import glob as _glob
+                    for sid in scenario_ids:
+                        test_files = _glob.glob(
+                            str(workspace_path / "tests" / "**" / f"*{sid[:8]}*"),
+                            recursive=True,
+                        )
+                        if test_files:
+                            try:
+                                with open(test_files[0], "r") as f:
+                                    scripts[sid] = f.read()
+                            except Exception:
+                                pass
 
             complete_payload = {
                 "status": "success" if result.status == "success" else "failed",
@@ -4683,7 +5043,7 @@ class RuntimeDaemon:
     async def _auto_commit(self, workspace_path: Path, task: TaskInfo) -> dict:
         """Auto-commit and push agent changes.
 
-        Some agents (e.g. claude-code) commit changes internally, so we must
+        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}``
@@ -5075,12 +5435,18 @@ class RuntimeDaemon:
         self, workspace_path: Path, default_branch: str, task: TaskInfo,
         project_key: str = "default",
     ):
-        """Rebase the current branch onto ``origin/{default_branch}``.
-
-        Strategy (3-tier):
-          1. ``git rebase origin/{default_branch}`` — cleanest; linear history.
-          2. If rebase conflicts → abort, try ``git merge`` instead.
-          3. If merge conflicts → use the AI agent to auto-resolve.
+        """Integrate the current branch with ``origin/{default_branch}``.
+
+        Strategy:
+          - If the current branch already exists on remote (was previously pushed):
+            Skip rebase entirely and use merge only.  Rebase rewrites commit
+            SHAs of already-published commits, which creates divergence and
+            requires a force-push.  Many servers (e.g. Bitbucket Server with
+            branch protection) forbid force-push, so we must preserve the
+            existing remote history by using merge instead.
+          - If the branch is new (first push): try rebase first for a clean
+            linear history; fall back to merge on conflicts.
+          - 3-tier merge fallback: merge → AI-assisted conflict resolution.
         """
         git = self.workspace_manager._git
         target = f"origin/{default_branch}"
@@ -5089,10 +5455,10 @@ class RuntimeDaemon:
         try:
             await git("fetch", "origin", cwd=workspace_path, timeout=300, project_key=project_key)
         except RuntimeError as exc:
-            logger.warning("Pre-push fetch failed: %s — skipping rebase", exc)
+            logger.warning("Pre-push fetch failed: %s — skipping integration", exc)
             return
 
-        # Check if rebase is needed (any commits on origin/default ahead of us?)
+        # Check if integration is needed (any commits on origin/default ahead of us?)
         try:
             behind = await git(
                 "rev-list", "--count", f"HEAD..{target}", cwd=workspace_path,
@@ -5100,27 +5466,56 @@ class RuntimeDaemon:
             if behind.strip() == "0":
                 logger.info("Branch is already up-to-date with %s", target)
                 return
-            logger.info("Branch is %s commit(s) behind %s — rebasing", behind.strip(), target)
+            logger.info("Branch is %s commit(s) behind %s — integrating", behind.strip(), target)
         except RuntimeError:
-            # Can't determine — proceed with rebase anyway
+            # Can't determine — proceed anyway
             pass
 
-        # ── Tier 1: rebase ──
+        # Determine if the current branch already exists on remote.
+        # If it does, a rebase would rewrite the SHAs of already-pushed commits,
+        # causing divergence that requires a force-push (often blocked by server
+        # branch-protection rules).  Use merge-only in that case.
+        current_branch = ""
+        remote_branch_exists = False
         try:
-            await git(
-                "-c", "user.name=Forgexa Agent",
-                "-c", "user.email=agent@forgexa.net",
-                "rebase", target,
-                cwd=workspace_path, timeout=120,
-            )
-            logger.info("Rebase onto %s succeeded", target)
-            return  # done — clean linear history
+            current_branch = (await git(
+                "rev-parse", "--abbrev-ref", "HEAD", cwd=workspace_path,
+            )).strip()
         except RuntimeError:
-            logger.info("Rebase onto %s had conflicts — aborting rebase", target)
+            pass
+        if current_branch and current_branch != "HEAD":
             try:
-                await git("rebase", "--abort", cwd=workspace_path)
+                await git(
+                    "rev-parse", "--verify", f"origin/{current_branch}",
+                    cwd=workspace_path,
+                )
+                remote_branch_exists = True
             except RuntimeError:
-                pass  # already aborted or not in rebase state
+                remote_branch_exists = False
+
+        if not remote_branch_exists:
+            # ── Tier 1: rebase (safe — branch not yet on remote) ──
+            try:
+                await git(
+                    "-c", "user.name=Forgexa Agent",
+                    "-c", "user.email=agent@forgexa.net",
+                    "rebase", target,
+                    cwd=workspace_path, timeout=120,
+                )
+                logger.info("Rebase onto %s succeeded", target)
+                return  # done — clean linear history
+            except RuntimeError:
+                logger.info("Rebase onto %s had conflicts — aborting rebase", target)
+                try:
+                    await git("rebase", "--abort", cwd=workspace_path)
+                except RuntimeError:
+                    pass  # already aborted or not in rebase state
+        else:
+            logger.info(
+                "Branch %s already exists on remote — skipping rebase to preserve "
+                "published commit SHAs (force-push not required)",
+                current_branch,
+            )
 
         # ── Tier 2: merge ──
         try:
@@ -5354,6 +5749,79 @@ class RuntimeDaemon:
                                 return None
                             except RuntimeError as exc:
                                 logger.error("Force-push (with lease) failed for %s: %s", branch, exc)
+                                exc_str = str(exc).lower()
+                                # Detect permanent server-side force-push prohibition
+                                # (e.g. Bitbucket Server branch-protection pre-receive hook).
+                                # In this case we must NOT retry with force — instead, recover
+                                # by resetting to the remote HEAD and cherry-picking only the
+                                # truly new commits, then doing a regular (non-force) push.
+                                force_push_blocked = (
+                                    "force-pushing" in exc_str
+                                    or "force pushing" in exc_str
+                                    or "pre-receive hook declined" in exc_str
+                                )
+                                if force_push_blocked:
+                                    logger.warning(
+                                        "Remote has force-push disabled for branch %s — "
+                                        "attempting cherry-pick recovery to avoid force-push",
+                                        branch,
+                                    )
+                                    try:
+                                        # Identify commits that are genuinely new (not
+                                        # equivalent to any remote commit).  git-cherry
+                                        # lines prefixed with '+' are truly missing from
+                                        # origin; '-' lines are already incorporated (same
+                                        # patch, different SHA — result of prior rebase).
+                                        cherry_out = (await git(
+                                            "cherry", "HEAD", f"origin/{branch}",
+                                            cwd=workspace_path,
+                                        )).strip()
+                                        new_shas = [
+                                            line.split()[1]
+                                            for line in cherry_out.splitlines()
+                                            if line.startswith("+ ")
+                                        ]
+                                        if not new_shas:
+                                            # Nothing genuinely new — remote is already
+                                            # up-to-date, treat as success.
+                                            logger.info(
+                                                "Recovery: no truly new commits on %s — "
+                                                "remote already has equivalent content",
+                                                branch,
+                                            )
+                                            return None
+                                        # Reset local branch to match remote exactly,
+                                        # then replay only the new commits on top.
+                                        await git(
+                                            "reset", "--hard", f"origin/{branch}",
+                                            cwd=workspace_path,
+                                        )
+                                        await git(
+                                            "-c", "user.name=Forgexa Agent",
+                                            "-c", "user.email=agent@forgexa.net",
+                                            "cherry-pick", *new_shas,
+                                            cwd=workspace_path,
+                                        )
+                                        # Now a regular push should succeed.
+                                        await git(
+                                            "push", "-u", "origin", branch,
+                                            cwd=workspace_path, project_key=project_key,
+                                        )
+                                        logger.info(
+                                            "Recovery push succeeded for branch %s "
+                                            "(%d new commit(s) cherry-picked)",
+                                            branch, len(new_shas),
+                                        )
+                                        return None
+                                    except RuntimeError as recovery_exc:
+                                        logger.error(
+                                            "Cherry-pick recovery also failed for %s: %s",
+                                            branch, recovery_exc,
+                                        )
+                                        return (
+                                            f"Push failed: remote has force-push disabled "
+                                            f"and cherry-pick recovery failed: {recovery_exc}"
+                                        )
                                 return f"Push failed: {exc}"
                         else:
                             logger.error(

{forgexa_cli-1.7.8 → forgexa_cli-1.8.4}/forgexa_cli.egg-info/PKG-INFO

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

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