forgexa-cli 1.2.7__tar.gz → 1.3.2__tar.gz

{forgexa_cli-1.2.7 → forgexa_cli-1.3.2}/PKG-INFO

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

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

{forgexa_cli-1.2.7 → forgexa_cli-1.3.2}/forgexa_cli/daemon.py

@@ -312,6 +312,7 @@ class TaskInfo:
     requirement_workflow_id: str | None = None
     requirement_key: str | None = None
     graph_type: str = "execution"
+    analysis_branch: str | None = None
 
 
 @dataclass
@@ -640,6 +641,7 @@ class WorkspaceManager:
                 project_dir, repo_url, default_branch, workspace_key, branch_name,
                 fresh_start=is_fresh_start,
                 project_key=project_key,
+                expect_branch=bool(task.analysis_branch),
             )
             # Refine mode: ensure we're on the analysis branch with its history
             # (not reset to default_branch)
@@ -722,7 +724,7 @@ class WorkspaceManager:
     async def _create_worktree(
         self, project_dir: Path, repo_url: str, default_branch: str,
         workspace_key: str, branch_name: str, *, fresh_start: bool = False,
-        project_key: str = "default",
+        project_key: str = "default", expect_branch: bool = False,
     ) -> Path:
         main_repo = project_dir / "_main"
         ws_path = project_dir / workspace_key
@@ -773,29 +775,75 @@ class WorkspaceManager:
                     # This is critical for cross-machine execution where a previous
                     # node on another daemon pushed commits to the branch.
                     logger.info("Syncing worktree %s to latest origin/%s", ws_path, branch_name)
-                    try:
-                        await self._git("checkout", branch_name, cwd=ws_path)
-                    except RuntimeError:
-                        # Branch might not exist locally yet — create tracking branch
+                    sync_success = False
+                    for _sync_attempt in range(3):
+                        try:
+                            await self._git("checkout", branch_name, cwd=ws_path)
+                        except RuntimeError:
+                            # Branch might not exist locally yet — create tracking branch
+                            try:
+                                await self._git(
+                                    "checkout", "-B", branch_name, f"origin/{branch_name}",
+                                    cwd=ws_path,
+                                )
+                            except RuntimeError as exc:
+                                if _sync_attempt < 2:
+                                    logger.info(
+                                        "Branch %s not available yet (attempt %d/3), re-fetching...",
+                                        branch_name, _sync_attempt + 1,
+                                    )
+                                    await asyncio.sleep(2 * (_sync_attempt + 1))
+                                    try:
+                                        await self._git(
+                                            "fetch", "origin", cwd=ws_path,
+                                            project_key=project_key,
+                                        )
+                                    except RuntimeError:
+                                        pass
+                                    continue
+                                else:
+                                    logger.warning("Failed to checkout %s after retries: %s", branch_name, exc)
+                        # Reset working tree to match remote branch (fast-forward)
                         try:
                             await self._git(
-                                "checkout", "-B", branch_name, f"origin/{branch_name}",
+                                "reset", "--hard", f"origin/{branch_name}",
                                 cwd=ws_path,
                             )
+                            sync_success = True
+                            break
                         except RuntimeError as exc:
-                            logger.warning("Failed to checkout %s: %s", branch_name, exc)
-                    # Reset working tree to match remote branch (fast-forward)
-                    try:
-                        await self._git(
-                            "reset", "--hard", f"origin/{branch_name}",
-                            cwd=ws_path,
-                        )
-                    except RuntimeError as exc:
-                        # Remote branch might not exist yet (first node in graph)
-                        logger.debug(
-                            "Could not reset to origin/%s: %s — branch may not exist on remote yet",
-                            branch_name, exc,
-                        )
+                            if _sync_attempt < 2:
+                                logger.info(
+                                    "Could not reset to origin/%s (attempt %d/3), re-fetching...",
+                                    branch_name, _sync_attempt + 1,
+                                )
+                                await asyncio.sleep(2 * (_sync_attempt + 1))
+                                try:
+                                    await self._git(
+                                        "fetch", "origin", cwd=ws_path,
+                                        project_key=project_key,
+                                    )
+                                except RuntimeError:
+                                    pass
+                            else:
+                                logger.warning(
+                                    "Could not reset to origin/%s after retries: %s — "
+                                    "workspace may lack latest commits from prior phases",
+                                    branch_name, exc,
+                                )
+                    if not sync_success:
+                        if expect_branch:
+                            raise RuntimeError(
+                                f"Failed to sync branch '{branch_name}' from remote after 3 attempts. "
+                                f"The branch should exist (pushed by prior analysis/design phase). "
+                                f"This task will be retried by the orchestrator."
+                            )
+                        else:
+                            logger.warning(
+                                "Git sync to origin/%s failed — branch may not exist yet "
+                                "(no prior analysis phase). Proceeding with current state.",
+                                branch_name,
+                            )
                 return ws_path
 
         # Ensure _main repo is present and up-to-date
@@ -804,6 +852,15 @@ class WorkspaceManager:
         else:
             await self._git("fetch", "--all", cwd=main_repo, timeout=300, project_key=project_key)
 
+        # Prune stale worktree references (e.g. directories deleted externally
+        # when simulating cross-runtime or after disk cleanup).  Without this,
+        # `git worktree add` refuses to create a branch that is "already checked out"
+        # in the now-missing worktree directory.
+        try:
+            await self._git("worktree", "prune", cwd=main_repo)
+        except RuntimeError:
+            pass
+
         # Fast-forward _main's local default branch to match origin so
         # that `git worktree add ... {default_branch}` uses latest code.
         # We fetch first, then update the local ref directly (avoids
@@ -818,22 +875,46 @@ class WorkspaceManager:
             logger.warning("Could not fast-forward _main/%s: %s", default_branch, exc)
 
         # branch_name is passed in (feature/{requirement_key} or feature/{workspace_key})
-        # First check if the branch already exists on remote (for refine/continuation)
+        # First check if the branch already exists on remote (for refine/continuation).
+        # Retry up to 2 times with short delay for cross-runtime timing issues
+        # (analysis daemon may have just pushed the branch).
         branch_exists_remote = False
-        try:
-            check_proc = await asyncio.create_subprocess_exec(
-                "git", "rev-parse", "--verify", f"refs/remotes/origin/{branch_name}",
-                cwd=str(main_repo),
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
-            )
-            await check_proc.communicate()
-            branch_exists_remote = check_proc.returncode == 0
-        except Exception:
-            pass
+        for _check_attempt in range(3 if not fresh_start else 1):
+            try:
+                check_proc = await asyncio.create_subprocess_exec(
+                    "git", "rev-parse", "--verify", f"refs/remotes/origin/{branch_name}",
+                    cwd=str(main_repo),
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                await check_proc.communicate()
+                branch_exists_remote = check_proc.returncode == 0
+            except Exception:
+                pass
+            if branch_exists_remote or fresh_start:
+                break
+            if _check_attempt < 2:
+                logger.info(
+                    "Branch %s not found on remote (attempt %d/3), re-fetching...",
+                    branch_name, _check_attempt + 1,
+                )
+                await asyncio.sleep(2 * (_check_attempt + 1))
+                try:
+                    await self._git("fetch", "--all", cwd=main_repo, timeout=60, project_key=project_key)
+                except RuntimeError:
+                    pass
 
         if branch_exists_remote and not fresh_start:
             # Branch exists on remote and we want to preserve it (refine mode)
+            # First, update local branch ref to match remote (in case it's stale)
+            try:
+                await self._git(
+                    "update-ref", f"refs/heads/{branch_name}",
+                    f"refs/remotes/origin/{branch_name}",
+                    cwd=main_repo,
+                )
+            except RuntimeError:
+                pass
             try:
                 await self._git(
                     "worktree", "add", "--track", "-b", branch_name,
@@ -967,7 +1048,8 @@ class WorkspaceManager:
 class ProcessManager:
     """Manages Agent CLI subprocess lifecycle."""
 
-    # Patterns that indicate an agent hit its rate/usage limit
+    # Patterns that indicate an agent hit its rate/usage limit or its API is
+    # unavailable — triggers fallback to a different agent
     RATE_LIMIT_PATTERNS = [
         "usage limit",
         "rate limit",
@@ -979,18 +1061,194 @@ class ProcessManager:
         "capacity",
         "try again",
         "credit",
+        "insufficient_quota",
+        "billing",
+    ]
+
+    # Patterns indicating the agent's API is unreachable/misconfigured —
+    # a different agent (using a different API backend) may succeed.
+    AGENT_UNAVAILABLE_PATTERNS = [
+        "404 not found",
+        "503 service unavailable",
+        "502 bad gateway",
+        "connection refused",
+        "connection reset",
+        "connection timed out",
+        "name or service not known",
+        "no such host",
+        "network is unreachable",
     ]
 
     def __init__(self):
         self.active_processes: dict[str, asyncio.subprocess.Process] = {}
 
+    @staticmethod
+    def _has_failure_pattern(text: str) -> str | None:
+        lower = (text or "").lower()
+        if any(p in lower for p in ProcessManager.RATE_LIMIT_PATTERNS):
+            return "Agent hit rate/usage limit or quota exhaustion"
+        if any(p in lower for p in ProcessManager.AGENT_UNAVAILABLE_PATTERNS):
+            return "Agent backend unavailable or unreachable"
+        return None
+
+    @staticmethod
+    def _extract_output_signals(text: str) -> dict[str, Any]:
+        """Parse stdout/stderr-like streams for success and failure signals."""
+        has_turn_completed = False
+        has_turn_failed = False
+        has_result = False
+        has_meaningful_content = False
+        error_messages: list[str] = []
+        json_line_count = 0
+
+        for raw_line in (text or "").split("\n"):
+            raw_line = raw_line.strip()
+            if not raw_line:
+                continue
+            try:
+                data = json.loads(raw_line)
+            except json.JSONDecodeError:
+                has_meaningful_content = True
+                continue
+
+            if not isinstance(data, dict):
+                continue
+
+            json_line_count += 1
+            ev_type = str(data.get("type", ""))
+
+            if ev_type == "turn.completed":
+                has_turn_completed = True
+            elif ev_type == "turn.failed":
+                has_turn_failed = True
+                err = data.get("error") or {}
+                if isinstance(err, dict):
+                    error_messages.append(err.get("message", "turn failed"))
+                elif isinstance(err, str):
+                    error_messages.append(err)
+            elif ev_type == "result":
+                has_result = True
+                has_meaningful_content = True
+            elif ev_type == "error":
+                msg = data.get("message", "")
+                if msg:
+                    error_messages.append(msg)
+            elif ev_type in (
+                "assistant",
+                "content_block_delta",
+                "message_delta",
+                "step_finish",
+                "message",
+            ):
+                has_meaningful_content = True
+            elif isinstance(data.get("content"), str) and data.get("content", "").strip():
+                has_meaningful_content = True
+
+        return {
+            "has_turn_completed": has_turn_completed,
+            "has_turn_failed": has_turn_failed,
+            "has_result": has_result,
+            "has_meaningful_content": has_meaningful_content,
+            "error_messages": error_messages,
+            "json_line_count": json_line_count,
+        }
+
+    @staticmethod
+    def has_meaningful_agent_output(result: "TaskResult") -> bool:
+        """Return True when the agent emitted real user-meaningful output."""
+        combined = "\n".join(part for part in (result.stdout, result.stderr) if part)
+        signals = ProcessManager._extract_output_signals(combined)
+        return bool(
+            signals["has_result"]
+            or signals["has_turn_completed"]
+            or signals["has_meaningful_content"]
+        )
+
     @staticmethod
     def is_rate_limited(result: "TaskResult") -> bool:
-        """Check if an agent failure was caused by a rate/usage limit."""
+        """Check if an agent failure warrants trying a different agent.
+
+        Returns True for rate/quota limits AND API unavailability errors,
+        since a different agent (using a different API backend) may succeed.
+        """
         if result.status == "success":
             return False
         combined = (result.stdout + result.stderr + result.error).lower()
-        return any(p in combined for p in ProcessManager.RATE_LIMIT_PATTERNS)
+        return (
+            any(p in combined for p in ProcessManager.RATE_LIMIT_PATTERNS)
+            or any(p in combined for p in ProcessManager.AGENT_UNAVAILABLE_PATTERNS)
+        )
+
+    @staticmethod
+    def _detect_agent_output_failure(result: "TaskResult", agent_id: str) -> str | None:
+        """Detect agent-level failures despite exit code 0.
+
+        Some agents (particularly Codex/OpenAI) exit with code 0 even when:
+        - The API returned errors (404, 500, connection refused)
+        - The turn failed (turn.failed event in JSONL)
+        - No actual work was performed
+
+        Returns error description if failure detected, None if result seems valid.
+        """
+        if result.status != "success":
+            return None
+
+        combined = "\n".join(part for part in (result.stdout, result.stderr, result.error) if part)
+        pattern_failure = ProcessManager._has_failure_pattern(combined)
+        if pattern_failure:
+            return pattern_failure
+
+        stdout = result.stdout or ""
+        stderr = result.stderr or ""
+        if not stdout.strip() and not stderr.strip():
+            return None  # Empty output handled separately by server-side check
+
+        signals = ProcessManager._extract_output_signals(
+            "\n".join(part for part in (stdout, stderr) if part)
+        )
+        has_turn_completed = signals["has_turn_completed"]
+        has_turn_failed = signals["has_turn_failed"]
+        has_result = signals["has_result"]
+        has_meaningful_content = signals["has_meaningful_content"]
+        error_messages = signals["error_messages"]
+        json_line_count = signals["json_line_count"]
+
+        stderr_lower = stderr.lower()
+        if (
+            stderr.strip()
+            and not stdout.strip()
+            and any(
+                marker in stderr_lower
+                for marker in (
+                    "error",
+                    "failed",
+                    "exception",
+                    "unauthorized",
+                    "forbidden",
+                    "invalid api key",
+                    "authentication",
+                    "permission denied",
+                )
+            )
+        ):
+            return stderr.strip().splitlines()[-1][:300]
+
+        # ── Codex/OpenAI: turn.failed without any turn.completed ──
+        if has_turn_failed and not has_turn_completed:
+            err_detail = error_messages[-1] if error_messages else "Agent turn failed"
+            return f"Agent turn failed: {err_detail}"
+
+        # ── All-errors pattern: only errors, no success indicators ──
+        if (error_messages and not has_turn_completed and not has_result
+                and not has_meaningful_content and json_line_count > 0):
+            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 not has_result and not has_meaningful_content:
+                return "Claude produced no result output"
+
+        return None
 
     async def run_agent(
         self,
@@ -1022,6 +1280,16 @@ class ProcessManager:
         elapsed = time.monotonic() - start_time
         result.metrics["duration_seconds"] = round(elapsed, 2)
 
+        # Detect agent-level failures despite exit code 0
+        output_failure = self._detect_agent_output_failure(result, agent.agent_id)
+        if output_failure:
+            logger.warning(
+                "Agent '%s' exited 0 but output indicates failure: %s",
+                agent.agent_id, output_failure,
+            )
+            result.status = "failed"
+            result.error = output_failure
+
         # Collect git changes
         result.git = await self._collect_git_info(workspace_path)
         result.files_changed = result.git.get("files_changed", [])
@@ -1030,6 +1298,45 @@ class ProcessManager:
 
         return result
 
+    @staticmethod
+    def _normalize_repo_paths(paths: list[str] | None) -> set[str]:
+        normalized: set[str] = set()
+        for path in paths or []:
+            path_str = str(path or "").replace("\\", "/").lstrip("./")
+            if path_str:
+                normalized.add(path_str)
+        return normalized
+
+    def _required_deliverable_paths(self, task: TaskInfo) -> set[str]:
+        output_dir = str((task.input_data or {}).get("output_dir", "") or "")
+        output_dir = output_dir.replace("\\", "/").lstrip("./").rstrip("/")
+        if not output_dir:
+            return set()
+
+        if task.node_type == "analysis":
+            req_type = (task.input_data or {}).get("requirement_type", "feature")
+            try:
+                from app.services.type_workflow_profiles import get_profile
+                required_files = list(get_profile(req_type).analysis_outputs)
+            except Exception:
+                required_files = ["PRD.md", "SDD.md", "TASKS.md", "analysis.json", "test-intent.json"]
+        elif task.node_type == "design":
+            required_files = ["design.md"]
+        else:
+            return set()
+
+        return {f"{output_dir}/{fname}" for fname in required_files}
+
+    def _has_required_deliverable_updates(self, task: TaskInfo, *path_lists: list[str] | None) -> bool:
+        required_paths = self._required_deliverable_paths(task)
+        if not required_paths:
+            return False
+
+        changed_paths: set[str] = set()
+        for paths in path_lists:
+            changed_paths.update(self._normalize_repo_paths(paths))
+        return bool(required_paths & changed_paths)
+
     def _build_prompt(self, task: TaskInfo) -> str:
         """Build the prompt to send to the agent.
 
@@ -1914,6 +2221,7 @@ class TaskPoller:
                     requirement_workflow_id=t.get("requirement_workflow_id"),
                     requirement_key=t.get("requirement_key"),
                     graph_type=t.get("graph_type", "execution"),
+                    analysis_branch=t.get("analysis_branch"),
                 ))
             return tasks
         except Exception as e:
@@ -2190,14 +2498,48 @@ class RuntimeDaemon:
         This handles orphaned processes from crashed desktop apps, duplicate
         CLI starts, etc.
         """
+        lock_path = Path.home() / ".forgexa" / "daemon" / "daemon.lock"
+        lock_path.parent.mkdir(parents=True, exist_ok=True)
+
+        if sys.platform == "win32":
+            # Windows: use msvcrt file locking
+            import msvcrt
+
+            self._lock_file = open(lock_path, "w")
+            try:
+                msvcrt.locking(self._lock_file.fileno(), msvcrt.LK_NBLCK, 1)
+            except (IOError, OSError):
+                # Lock held — try to kill old process via PID file
+                try:
+                    old_pid = int(lock_path.read_text().strip())
+                    logger.warning("Another daemon is running (PID %d). Terminating...", old_pid)
+                    import subprocess as _sp
+                    _sp.run(["taskkill", "/PID", str(old_pid), "/F"],
+                            capture_output=True)
+                    time.sleep(1)
+                except (ValueError, FileNotFoundError, PermissionError, OSError):
+                    pass
+
+                # Retry
+                self._lock_file.close()
+                self._lock_file = open(lock_path, "w")
+                try:
+                    msvcrt.locking(self._lock_file.fileno(), msvcrt.LK_NBLCK, 1)
+                except (IOError, OSError):
+                    logger.error("Cannot acquire daemon lock — another instance may still be running")
+                    raise SystemExit(1)
+
+            self._lock_file.seek(0)
+            self._lock_file.truncate()
+            self._lock_file.write(str(os.getpid()))
+            self._lock_file.flush()
+            logger.info("Acquired exclusive daemon lock (pid=%d)", os.getpid())
+            return
+
         if fcntl is None:
-            # Windows: skip file locking (fcntl not available)
             logger.info("File locking not available on this platform; skipping")
             return
 
-        lock_path = Path.home() / ".forgexa" / "daemon" / "daemon.lock"
-        lock_path.parent.mkdir(parents=True, exist_ok=True)
-
         self._lock_file = open(lock_path, "w")
 
         try:
@@ -2432,10 +2774,10 @@ class RuntimeDaemon:
 
             tried_agents.add(agent.agent_id)
 
-            # ── Rate-limit fallback: if agent hit usage/rate limit, try next agent ──
+            # ── Agent fallback: if agent hit rate limit or API is unavailable, try next agent ──
             if self.process_manager.is_rate_limited(result):
                 logger.warning(
-                    "Agent '%s' hit rate/usage limit for task %s, attempting fallback",
+                    "Agent '%s' unavailable/rate-limited for task %s, attempting fallback",
                     agent.agent_id, task.task_id,
                 )
                 fallback_agent = self._select_fallback_agent(
@@ -2443,16 +2785,17 @@ class RuntimeDaemon:
                 )
                 while fallback_agent:
                     logger.info(
-                        "Rate-limit fallback: switching from '%s' to '%s' for task %s",
+                        "Agent fallback: switching from '%s' to '%s' for task %s (reason: %s)",
                         agent.agent_id, fallback_agent.agent_id, task.task_id,
+                        result.error[:100] if result.error else "rate-limited/unavailable",
                     )
                     agent = fallback_agent
                     tried_agents.add(agent.agent_id)
 
                     await reporter.report_progress(
                         task.task_id, 10,
-                        f"rate_limit_fallback: retrying with {agent.agent_id}",
-                        output_lines=[f"[daemon] Agent rate-limited, switching to {agent.agent_id}"],
+                        f"agent_fallback: retrying with {agent.agent_id}",
+                        output_lines=[f"[daemon] Agent unavailable/rate-limited, switching to {agent.agent_id}"],
                     )
 
                     # Re-run with fallback agent
@@ -2497,10 +2840,10 @@ class RuntimeDaemon:
                             _line_buffer.clear()
 
                     if not self.process_manager.is_rate_limited(result):
-                        break  # Success or non-rate-limit failure
+                        break  # Success or non-retriable failure
 
                     logger.warning(
-                        "Fallback agent '%s' also rate-limited for task %s",
+                        "Fallback agent '%s' also unavailable/rate-limited for task %s",
                         agent.agent_id, task.task_id,
                     )
                     fallback_agent = self._select_fallback_agent(
@@ -2509,20 +2852,50 @@ class RuntimeDaemon:
 
                 if self.process_manager.is_rate_limited(result):
                     result.error = (
-                        f"All agents rate-limited (tried: {', '.join(tried_agents)}). "
+                        f"All agents unavailable/rate-limited (tried: {', '.join(tried_agents)}). "
                         f"Original error: {result.error}"
                     )
+                    result.status = "failed"
 
             # 4. Collect git info BEFORE commit (shows uncommitted changes)
             pre_commit_git = await self.process_manager._collect_git_info(workspace_path)
 
+            # 4.05 Sanity check: "success" but no evidence of work for node types
+            # that MUST produce changes.
+            # This catches agents that exit 0 without doing anything useful
+            # (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)
+                has_committed = bool(committed_git.get("files_changed"))
+                has_tokens = (
+                    int(result.metrics.get("token_input", 0) or 0)
+                    + int(result.metrics.get("token_output", 0) or 0)
+                ) > 0
+                if not has_uncommitted and not has_committed and not has_tokens:
+                    logger.warning(
+                        "Task %s (%s) agent reported success but produced no file changes "
+                        "and no token usage — marking as failed",
+                        task.task_id, task.node_type,
+                    )
+                    result.status = "failed"
+                    result.error = (
+                        f"Agent reported success but produced no code changes "
+                        f"(node_type={task.node_type}, agent={agent.agent_id})"
+                    )
+
             # 4.1 Recovery: agent exited non-zero but already committed code
             # (e.g. OpenCode EBADF crash on exit after successful work)
             if result.status == "failed" and result.exit_code not in (None, -1):
                 committed_git = await self.process_manager._collect_git_info_vs_parent(workspace_path)
                 has_committed_changes = bool(committed_git.get("files_changed"))
                 has_no_uncommitted = not pre_commit_git.get("files_changed")
-                if has_committed_changes and has_no_uncommitted:
+                has_tokens = (
+                    int(result.metrics.get("token_input", 0) or 0)
+                    + int(result.metrics.get("token_output", 0) or 0)
+                ) > 0
+                has_meaningful_output = self.process_manager.has_meaningful_agent_output(result)
+                if has_committed_changes and has_no_uncommitted and (has_tokens or has_meaningful_output):
                     logger.warning(
                         "Task %s agent exited with code %s but has committed changes — "
                         "recovering as success (agent likely crashed during cleanup)",
@@ -2545,11 +2918,37 @@ class RuntimeDaemon:
                 except Exception:
                     logger.exception("Validation gate error for task %s (proceeding anyway)", task.task_id)
 
+            # 4.55 Analysis/design 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"):
+                committed_git = await self.process_manager._collect_git_info_vs_parent(workspace_path)
+                if not self._has_required_deliverable_updates(
+                    task,
+                    pre_commit_git.get("files_changed"),
+                    committed_git.get("files_changed"),
+                    result.files_changed,
+                    (result.git or {}).get("files_changed"),
+                ):
+                    logger.warning(
+                        "Task %s (%s) reported success but did not update required deliverables",
+                        task.task_id, task.node_type,
+                    )
+                    result.status = "failed"
+                    result.error = (
+                        f"Agent reported success but did not update required {task.node_type} deliverables "
+                        f"(agent={agent.agent_id})"
+                    )
+
             # 4.6 For analysis nodes: attach output file contents as inline artifacts
             # so the backend always has the documents even if git push fails later.
             if result.status == "success" and task.node_type == "analysis":
                 await self._collect_analysis_artifacts(workspace_path, task, result)
 
+            # 4.7 For design nodes: attach design.md as inline artifact so that
+            # downstream nodes (coding/testing) can access it even if git sync lags.
+            if result.status == "success" and task.node_type == "design":
+                await self._collect_design_artifacts(workspace_path, task, result)
+
             # 5. Auto-commit and push if changes exist
             if result.status == "success":
                 commit_result = await self._auto_commit(workspace_path, task)
@@ -2647,48 +3046,63 @@ class RuntimeDaemon:
         """Run deterministic validations on agent output.
 
         Returns a list of issue descriptions.  Empty list = all OK.
+        Type-aware: uses the requirement type from task.input_data to determine
+        which files are required (via type_workflow_profiles).
         """
         import json as _json
 
         issues: list[str] = []
         node_type = task.node_type
+        req_type = (task.input_data or {}).get("requirement_type", "feature")
 
         if node_type == "analysis":
-            # Check required files exist
+            # Use type profile to determine required analysis outputs
+            try:
+                from app.services.type_workflow_profiles import get_profile
+                profile = get_profile(req_type)
+                required_files = profile.analysis_outputs
+            except Exception:
+                # Fallback to full set if profile import fails
+                required_files = ["PRD.md", "SDD.md", "TASKS.md", "analysis.json", "test-intent.json"]
+
             doc_dir = (task.input_data or {}).get("output_dir", "")
             if doc_dir:
                 base = workspace_path / doc_dir
             else:
                 base = workspace_path
-            for fname in ("PRD.md", "SDD.md", "TASKS.md", "analysis.json", "test-intent.json"):
+
+            # Check required files based on type profile
+            for fname in required_files:
                 fpath = base / fname
                 if not fpath.exists():
                     issues.append(f"Required file missing: {doc_dir}/{fname}")
                 elif fpath.stat().st_size == 0:
                     issues.append(f"Required file is empty: {doc_dir}/{fname}")
 
-            # Validate analysis.json
-            json_path = base / "analysis.json"
-            if json_path.exists() and json_path.stat().st_size > 0:
-                try:
-                    _json.loads(json_path.read_text(encoding="utf-8"))
-                except _json.JSONDecodeError as e:
-                    issues.append(f"analysis.json is not valid JSON: {e}")
-
-            # Validate test-intent.json
-            ti_path = base / "test-intent.json"
-            if ti_path.exists() and ti_path.stat().st_size > 0:
-                try:
-                    ti_data = _json.loads(ti_path.read_text(encoding="utf-8"))
-                    intents = ti_data.get("intents", [])
-                    if not intents:
-                        issues.append("test-intent.json contains no test intents")
-                    for ti in intents[:20]:
-                        if not ti.get("id") or not ti.get("title"):
-                            issues.append(f"Test intent missing 'id' or 'title': {ti.get('id', '?')}")
-                            break
-                except _json.JSONDecodeError as e:
-                    issues.append(f"test-intent.json is not valid JSON: {e}")
+            # Validate analysis.json if required by this type
+            if "analysis.json" in required_files:
+                json_path = base / "analysis.json"
+                if json_path.exists() and json_path.stat().st_size > 0:
+                    try:
+                        _json.loads(json_path.read_text(encoding="utf-8"))
+                    except _json.JSONDecodeError as e:
+                        issues.append(f"analysis.json is not valid JSON: {e}")
+
+            # Validate test-intent.json if required by this type
+            if "test-intent.json" in required_files:
+                ti_path = base / "test-intent.json"
+                if ti_path.exists() and ti_path.stat().st_size > 0:
+                    try:
+                        ti_data = _json.loads(ti_path.read_text(encoding="utf-8"))
+                        intents = ti_data.get("intents", [])
+                        if not intents:
+                            issues.append("test-intent.json contains no test intents")
+                        for ti in intents[:20]:
+                            if not ti.get("id") or not ti.get("title"):
+                                issues.append(f"Test intent missing 'id' or 'title': {ti.get('id', '?')}")
+                                break
+                    except _json.JSONDecodeError as e:
+                        issues.append(f"test-intent.json is not valid JSON: {e}")
 
         elif node_type == "design":
             doc_dir = (task.input_data or {}).get("output_dir", "")
@@ -2699,7 +3113,7 @@ class RuntimeDaemon:
                 elif design_path.stat().st_size == 0:
                     issues.append(f"Design document is empty: {doc_dir}/design.md")
 
-        elif node_type in ("coding", "testing"):
+        elif node_type in ("coding", "testing", "fix"):
             # Syntax-check modified Python and JS/TS files
             for f in result.files_changed:
                 fpath = workspace_path / f
@@ -2724,55 +3138,65 @@ class RuntimeDaemon:
 
             # Testing-specific: validate structured test assets
             if node_type == "testing":
-                doc_dir = (task.input_data or {}).get("output_dir", "")
-                if doc_dir:
-                    base = workspace_path / doc_dir
-                else:
-                    base = workspace_path
-
-                # --- test-cases.json validation ---
-                tc_path = base / "test-cases.json"
-                if tc_path.exists():
-                    try:
-                        tc_data = _json.loads(tc_path.read_text(encoding="utf-8"))
-                        cases = tc_data.get("test_cases", [])
-                        if not cases:
-                            issues.append("test-cases.json exists but contains no test cases")
-                        else:
-                            for tc in cases[:20]:
-                                if not tc.get("id") or not tc.get("title"):
-                                    issues.append(f"Test case missing 'id' or 'title': {tc.get('id', '?')}")
-                                    break
-                                if not tc.get("steps"):
-                                    issues.append(f"Test case {tc['id']} has no 'steps'")
-                                    break
-                            p0_cases = [c for c in cases if c.get("priority") == "P0"]
-                            if not p0_cases:
-                                issues.append("No P0 priority test cases found in test-cases.json")
-                    except (_json.JSONDecodeError, UnicodeDecodeError) as e:
-                        issues.append(f"test-cases.json is not valid JSON: {e}")
-                else:
-                    issues.append(f"test-cases.json not found in {doc_dir or 'workspace root'}")
+                # Check if this type requires full test artifacts
+                _skip_test_artifacts = False
+                try:
+                    from app.services.type_workflow_profiles import get_profile
+                    _profile = get_profile(req_type)
+                    _skip_test_artifacts = "test_coverage" in _profile.skip_dimensions
+                except Exception:
+                    pass
 
-                # --- coverage-matrix.json validation ---
-                cm_path = base / "coverage-matrix.json"
-                if cm_path.exists():
-                    try:
-                        cm_data = _json.loads(cm_path.read_text(encoding="utf-8"))
-                        ac_list = cm_data.get("acceptance_criteria", [])
-                        uncovered = [ac for ac in ac_list if ac.get("status") != "covered"]
-                        if uncovered:
-                            ids = ", ".join(ac.get("id", "?") for ac in uncovered[:5])
-                            issues.append(f"Uncovered acceptance criteria in coverage-matrix.json: {ids}")
-                    except (_json.JSONDecodeError, UnicodeDecodeError) as e:
-                        issues.append(f"coverage-matrix.json is not valid JSON: {e}")
-                else:
-                    issues.append(f"coverage-matrix.json not found in {doc_dir or 'workspace root'}")
+                if not _skip_test_artifacts:
+                    doc_dir = (task.input_data or {}).get("output_dir", "")
+                    if doc_dir:
+                        base = workspace_path / doc_dir
+                    else:
+                        base = workspace_path
 
-                # --- test-report.md validation ---
-                report_path = base / "test-report.md"
-                if not report_path.exists():
-                    issues.append(f"test-report.md not found in {doc_dir or 'workspace root'}")
+                    # --- test-cases.json validation ---
+                    tc_path = base / "test-cases.json"
+                    if tc_path.exists():
+                        try:
+                            tc_data = _json.loads(tc_path.read_text(encoding="utf-8"))
+                            cases = tc_data.get("test_cases", [])
+                            if not cases:
+                                issues.append("test-cases.json exists but contains no test cases")
+                            else:
+                                for tc in cases[:20]:
+                                    if not tc.get("id") or not tc.get("title"):
+                                        issues.append(f"Test case missing 'id' or 'title': {tc.get('id', '?')}")
+                                        break
+                                    if not tc.get("steps"):
+                                        issues.append(f"Test case {tc['id']} has no 'steps'")
+                                        break
+                                p0_cases = [c for c in cases if c.get("priority") == "P0"]
+                                if not p0_cases:
+                                    issues.append("No P0 priority test cases found in test-cases.json")
+                        except (_json.JSONDecodeError, UnicodeDecodeError) as e:
+                            issues.append(f"test-cases.json is not valid JSON: {e}")
+                    else:
+                        issues.append(f"test-cases.json not found in {doc_dir or 'workspace root'}")
+
+                    # --- coverage-matrix.json validation ---
+                    cm_path = base / "coverage-matrix.json"
+                    if cm_path.exists():
+                        try:
+                            cm_data = _json.loads(cm_path.read_text(encoding="utf-8"))
+                            ac_list = cm_data.get("acceptance_criteria", [])
+                            uncovered = [ac for ac in ac_list if ac.get("status") != "covered"]
+                            if uncovered:
+                                ids = ", ".join(ac.get("id", "?") for ac in uncovered[:5])
+                                issues.append(f"Uncovered acceptance criteria in coverage-matrix.json: {ids}")
+                        except (_json.JSONDecodeError, UnicodeDecodeError) as e:
+                            issues.append(f"coverage-matrix.json is not valid JSON: {e}")
+                    else:
+                        issues.append(f"coverage-matrix.json not found in {doc_dir or 'workspace root'}")
+
+                    # --- test-report.md validation ---
+                    report_path = base / "test-report.md"
+                    if not report_path.exists():
+                        issues.append(f"test-report.md not found in {doc_dir or 'workspace root'}")
 
         return issues
 
@@ -2838,10 +3262,32 @@ class RuntimeDaemon:
         # Final check after all retries
         remaining = self._validate_outputs(workspace_path, task, result)
         if remaining:
-            logger.warning(
-                "Validation gate: %d issues remain after %d retries for task %s (proceeding anyway)",
-                len(remaining), max_retries, task.task_id,
-            )
+            # Distinguish critical issues (no output produced) from minor ones (syntax)
+            critical_patterns = ("missing", "not found", "is empty")
+            critical_issues = [
+                iss for iss in remaining
+                if any(p in iss.lower() for p in critical_patterns)
+            ]
+            if critical_issues:
+                # Agent didn't produce required output — mark as failed
+                logger.warning(
+                    "Validation gate: %d critical issues remain after %d retries for task %s — "
+                    "marking as failed:\n%s",
+                    len(critical_issues), max_retries, task.task_id,
+                    "\n".join(f"  - {iss}" for iss in critical_issues),
+                )
+                result.status = "failed"
+                result.error = (
+                    f"Agent failed to produce required output after {max_retries} retries: "
+                    + "; ".join(critical_issues[:3])
+                )
+            else:
+                # Non-critical issues (syntax warnings) — proceed with warning
+                logger.warning(
+                    "Validation gate: %d non-critical issues remain after %d retries for task %s "
+                    "(proceeding anyway)",
+                    len(remaining), max_retries, task.task_id,
+                )
             result.metrics["validation_issues"] = remaining
         return result
 
@@ -2883,6 +3329,39 @@ class RuntimeDaemon:
             except Exception as e:
                 logger.warning("Failed to read analysis artifact %s: %s", fname, e)
 
+    async def _collect_design_artifacts(
+        self, workspace_path: Path, task: TaskInfo, result: TaskResult
+    ) -> None:
+        """Attach design.md as inline artifact for downstream node access.
+
+        Similar to _collect_analysis_artifacts but for the design phase output.
+        Ensures coding/testing nodes can access design documents even when
+        running on a different runtime where git sync may lag.
+        """
+        doc_dir = (task.input_data or {}).get("output_dir", "")
+        if not doc_dir:
+            return
+
+        base = workspace_path / doc_dir.lstrip("./")
+        existing_artifact_paths = {a.get("path", "") for a in result.artifacts}
+
+        design_path = base / "design.md"
+        if not design_path.exists() or design_path.stat().st_size == 0:
+            return
+        try:
+            rel_path = str(design_path.relative_to(workspace_path))
+            if rel_path in existing_artifact_paths:
+                return
+            content = design_path.read_text(encoding="utf-8", errors="replace")
+            result.artifacts.append({
+                "path": rel_path,
+                "content": content,
+                "type": "text/markdown",
+            })
+            logger.debug("Attached design artifact inline: %s (%d bytes)", rel_path, len(content))
+        except Exception as e:
+            logger.warning("Failed to read design artifact: %s", e)
+
     async def _auto_commit(self, workspace_path: Path, task: TaskInfo) -> dict:
         """Auto-commit and push agent changes.
 
@@ -3528,8 +4007,13 @@ async def main():
     daemon = RuntimeDaemon()
 
     loop = asyncio.get_event_loop()
-    for sig in (signal.SIGINT, signal.SIGTERM):
-        loop.add_signal_handler(sig, daemon.handle_signal, sig)
+    if sys.platform != "win32":
+        for sig in (signal.SIGINT, signal.SIGTERM):
+            loop.add_signal_handler(sig, daemon.handle_signal, sig)
+    else:
+        # Windows: asyncio loop doesn't support add_signal_handler.
+        # Use traditional signal handler for Ctrl+C (SIGINT).
+        signal.signal(signal.SIGINT, lambda s, _f: daemon.handle_signal(s))
 
     await daemon.start()
 

{forgexa_cli-1.2.7 → forgexa_cli-1.3.2}/forgexa_cli/main.py

@@ -208,8 +208,15 @@ def cmd_daemon_stop(_args: argparse.Namespace) -> None:
         sys.exit(1)
     pid = int(pid_file.read_text().strip())
     try:
-        os.kill(pid, signal.SIGTERM)
-        print(f"Sent SIGTERM to daemon (PID {pid})")
+        if sys.platform == "win32":
+            # Windows: SIGTERM calls TerminateProcess (no graceful shutdown).
+            # Use taskkill for cleaner UX; fall back to os.kill.
+            import subprocess as sp
+            sp.run(["taskkill", "/PID", str(pid), "/F"], capture_output=True)
+            print(f"Terminated daemon (PID {pid})")
+        else:
+            os.kill(pid, signal.SIGTERM)
+            print(f"Sent SIGTERM to daemon (PID {pid})")
         pid_file.unlink()
     except ProcessLookupError:
         print(f"Daemon process {pid} not found (already stopped?)")
@@ -239,12 +246,15 @@ def cmd_daemon_start(args: argparse.Namespace) -> None:
 
         cmd = [sys.executable, "-m", "forgexa_cli.daemon"]
         with open(log_path, "a", encoding="utf-8") as log_fh:
-            proc = sp.Popen(
-                cmd,
-                stdout=sp.DEVNULL,
-                stderr=log_fh,
-                start_new_session=True,
-            )
+            popen_kwargs: dict = dict(stdout=sp.DEVNULL, stderr=log_fh)
+            if sys.platform == "win32":
+                # Windows: use creation flags to detach the process
+                popen_kwargs["creationflags"] = (
+                    sp.CREATE_NEW_PROCESS_GROUP | sp.DETACHED_PROCESS
+                )
+            else:
+                popen_kwargs["start_new_session"] = True
+            proc = sp.Popen(cmd, **popen_kwargs)
         pid_file = Path.home() / ".forgexa-daemon.pid"
         pid_file.write_text(str(proc.pid))
         print(f"Daemon started in background (PID {proc.pid})")

{forgexa_cli-1.2.7 → forgexa_cli-1.3.2}/forgexa_cli.egg-info/PKG-INFO

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

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