forgexa-cli 1.14.2__tar.gz → 1.14.4__tar.gz

{forgexa_cli-1.14.2 → forgexa_cli-1.14.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.14.2
+Version: 1.14.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.14.2 → forgexa_cli-1.14.4}/forgexa_cli/__init__.py

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

{forgexa_cli-1.14.2 → forgexa_cli-1.14.4}/forgexa_cli/daemon.py

@@ -523,7 +523,7 @@ except (ImportError, ModuleNotFoundError):
 # DAEMON_VERSION is the protocol/logic version of the daemon code.
 # Kept in sync with pyproject.toml version via bump-version.sh.
 # CLIENT_TYPE identifies which packaging/distribution this daemon runs in.
-DAEMON_VERSION = "1.14.2"
+DAEMON_VERSION = "1.14.4"
 
 
 def _detect_client_type() -> str:
@@ -1074,6 +1074,85 @@ def _extract_ai_job_scripts(
     return scripts
 
 
+def _resolve_ai_job_workspace_scope(ai_job: dict) -> str | None:
+    workspace_key = str(ai_job.get("workspace_key") or "").strip()
+    if workspace_key:
+        return workspace_key
+
+    input_ctx = ai_job.get("input_context") or {}
+
+    explicit_key = str(input_ctx.get("workspace_key") or "").strip()
+    if explicit_key:
+        return explicit_key
+
+    suite_id = str(input_ctx.get("suite_id") or "").strip()
+    if suite_id:
+        return f"qa-suite-{suite_id}"
+
+    requirement_id = str(input_ctx.get("requirement_id") or "").strip()
+    if requirement_id:
+        return f"requirement-{requirement_id}"
+
+    requirement_key = str(ai_job.get("requirement_key") or "").strip()
+    if requirement_key:
+        return f"requirement-{requirement_key}"
+
+    return None
+
+
+def _summarize_workspace_source(workspace_path: Path) -> str | None:
+    """Extract a lightweight local workspace summary for prompt grounding."""
+    import os
+
+    if not workspace_path.exists():
+        return None
+
+    file_list: list[str] = []
+    for root, dirs, files in os.walk(workspace_path):
+        dirs[:] = [
+            d for d in dirs
+            if not d.startswith(".") and d not in (
+                "node_modules", "__pycache__", ".git", "dist", "build", "venv", ".venv",
+            )
+        ]
+        rel = os.path.relpath(root, workspace_path)
+        for file_name in files:
+            if file_name.startswith("."):
+                continue
+            path = f"{rel}/{file_name}" if rel != "." else file_name
+            file_list.append(path)
+            if len(file_list) >= 250:
+                break
+        if len(file_list) >= 250:
+            break
+
+    if not file_list:
+        return None
+
+    lines: list[str] = ["## Project Structure", "```", *file_list[:250], "```"]
+    priority_patterns = [
+        "routes", "router", "api", "endpoints", "views",
+        "models", "schema", "types", "entities",
+        "package.json", "pyproject.toml", "requirements.txt",
+        "dockerfile", "docker-compose", "nginx.conf",
+        "readme",
+    ]
+    key_files = [
+        path for path in file_list
+        if any(pattern in path.lower() for pattern in priority_patterns)
+    ][:8]
+
+    for key_file in key_files:
+        full_path = workspace_path / key_file
+        try:
+            content = full_path.read_text(encoding="utf-8", errors="ignore")[:3000]
+        except Exception:
+            continue
+        lines.append(f"\n### {key_file}\n```\n{content}\n```")
+
+    return "\n".join(lines)[:8000]
+
+
 def _resolve_git_author(project: dict) -> tuple[str, str]:
     """Resolve git commit author (name, email) using a 5-tier fallback chain.
 
@@ -1146,6 +1225,38 @@ def _get_analysis_outputs_for_type(req_type: str) -> list[str]:
         return _ANALYSIS_OUTPUTS_BY_TYPE.get(req_type, _ANALYSIS_OUTPUTS_BY_TYPE["feature"])
 
 
+# Mirrors type_workflow_profiles.py — maps req type to the expected design-phase output filename.
+# Most types use design.md; spike uses research.md (produced by _DESIGN_SPIKE prompt).
+_DESIGN_OUTPUT_BY_TYPE: dict[str, str] = {
+    "spike": "research.md",
+    # All other types produce design.md (the default).
+}
+
+
+def _get_design_output_for_type(req_type: str) -> str:
+    """Get the expected design-phase output filename for a requirement type.
+
+    Used by _validate_outputs and _required_deliverable_paths to avoid
+    hardcoding 'design.md' for all node_type='design' nodes — spike produces
+    'research.md' instead.
+    """
+    try:
+        from app.services.type_workflow_profiles import get_profile
+        profile = get_profile(req_type)
+        for phase in profile.execution_phases:
+            if phase.node_type == "design":
+                from app.services.type_prompts import TYPE_PROMPT_TEMPLATES
+                tmpl = TYPE_PROMPT_TEMPLATES.get(phase.prompt_key, "")
+                import re as _re
+                m = _re.search(r"{doc_dir}/([\w.-]+)", tmpl)
+                if m:
+                    return m.group(1)
+                break
+    except Exception:
+        pass
+    return _DESIGN_OUTPUT_BY_TYPE.get(req_type, "design.md")
+
+
 # ── Agent Discovery ──
 
 
@@ -1576,11 +1687,13 @@ class WorkspaceManager:
             "timeout",
             "timed out",
             "server not responding",
+            "received disconnect",
             "unexpected disconnect",
             "early eof",
             "invalid index-pack output",
             "fetch-pack",
             "remote hung up unexpectedly",
+            "too many concurrent connections",
             "connection reset",
             "connection closed",
             "connection refused",
@@ -1901,6 +2014,42 @@ class WorkspaceManager:
             _shutil.rmtree(wt, ignore_errors=True)
         _shutil.rmtree(main_repo, ignore_errors=True)
 
+    async def _find_existing_worktree_for_branch(
+        self,
+        main_repo: Path,
+        branch_name: str,
+    ) -> Path | None:
+        """Return an existing healthy linked worktree already on branch_name."""
+        try:
+            raw = await self._git("worktree", "list", "--porcelain", cwd=main_repo)
+        except RuntimeError:
+            return None
+
+        target_ref = f"refs/heads/{branch_name}"
+        entries: list[tuple[Path, str | None]] = []
+        current_path: Path | None = None
+        current_branch: str | None = None
+
+        for line in raw.splitlines():
+            if line.startswith("worktree "):
+                if current_path is not None:
+                    entries.append((current_path, current_branch))
+                current_path = Path(line.split(" ", 1)[1].strip())
+                current_branch = None
+            elif line.startswith("branch "):
+                current_branch = line.split(" ", 1)[1].strip()
+
+        if current_path is not None:
+            entries.append((current_path, current_branch))
+
+        for candidate_path, candidate_branch in entries:
+            if candidate_path == main_repo or candidate_branch != target_ref:
+                continue
+            if candidate_path.exists() and await self._is_healthy_worktree(candidate_path, main_repo=main_repo):
+                return candidate_path
+
+        return None
+
     async def _detect_unrelated_histories(self, repo_path: Path, project_key: str) -> bool:
         """Detect whether local clone has diverged from remote due to history rewrite.
 
@@ -2550,12 +2699,34 @@ class WorkspaceManager:
                     cwd=main_repo,
                 )
             except Exception:
+                existing_branch_worktree = await self._find_existing_worktree_for_branch(
+                    main_repo, branch_name,
+                )
+                if existing_branch_worktree is not None:
+                    logger.info(
+                        "Reusing existing worktree %s for branch %s instead of creating %s",
+                        existing_branch_worktree,
+                        branch_name,
+                        ws_path,
+                    )
+                    return existing_branch_worktree
                 try:
                     await self._git(
                         "worktree", "add", str(ws_path), branch_name,
                         cwd=main_repo,
                     )
                 except Exception:
+                    existing_branch_worktree = await self._find_existing_worktree_for_branch(
+                        main_repo, branch_name,
+                    )
+                    if existing_branch_worktree is not None:
+                        logger.info(
+                            "Reusing existing worktree %s for branch %s instead of creating %s",
+                            existing_branch_worktree,
+                            branch_name,
+                            ws_path,
+                        )
+                        return existing_branch_worktree
                     # Fallback: create from default_branch
                     try:
                         await self._git(
@@ -2563,6 +2734,17 @@ class WorkspaceManager:
                             cwd=main_repo,
                         )
                     except Exception:
+                        existing_branch_worktree = await self._find_existing_worktree_for_branch(
+                            main_repo, branch_name,
+                        )
+                        if existing_branch_worktree is not None:
+                            logger.info(
+                                "Reusing existing worktree %s for branch %s instead of cloning %s",
+                                existing_branch_worktree,
+                                branch_name,
+                                ws_path,
+                            )
+                            return existing_branch_worktree
                         ws_path.mkdir(parents=True, exist_ok=True)
                         await self._clone_repo(
                             repo_url,
@@ -2891,6 +3073,7 @@ class ProcessManager:
         "rate limit",
         "rate_limit",
         "quota exceeded",
+        "monthly quota",        # Copilot: "You have exceeded your monthly quota"
         "too many requests",
         "overloaded",
         "insufficient_quota",
@@ -3028,7 +3211,12 @@ class ProcessManager:
                 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")
+                        raw_errors = data.get("errors")
+                        if isinstance(raw_errors, list):
+                            err_text = "; ".join(str(item).strip() for item in raw_errors if str(item).strip())
+                        else:
+                            err_text = ""
+                        err_text = err_text or 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
@@ -3391,7 +3579,8 @@ class ProcessManager:
             req_type = (task.input_data or {}).get("requirement_type", "feature")
             required_files = _get_analysis_outputs_for_type(req_type)
         elif task.node_type == "design":
-            required_files = ["design.md"]
+            req_type = (task.input_data or {}).get("requirement_type", "feature")
+            required_files = [_get_design_output_for_type(req_type)]
         elif task.node_type == "delivery":
             # Required docs come from node input_data (set by delivery_doc_service)
             required_files = (task.input_data or {}).get("required_docs") or ["release-note.md"]
@@ -3411,48 +3600,6 @@ class ProcessManager:
             changed_paths.update(self._normalize_repo_paths(paths))
         return bool(required_paths & changed_paths)
 
-    def _recover_timeout_from_workspace_changes(
-        self,
-        task: TaskInfo,
-        workspace_path: Path,
-        result: TaskResult,
-        pre_commit_git: dict,
-    ) -> bool:
-        """Recover absolute-timeout failures after validating workspace output."""
-        error_lower = (result.error or "").lower()
-        is_absolute_timeout = (
-            "absolute limit" in error_lower or "timed out after" in error_lower
-        )
-        changed_files = list(pre_commit_git.get("files_changed") or [])
-        if not is_absolute_timeout or not changed_files:
-            return False
-        if not self.process_manager.has_meaningful_agent_output(result):
-            return False
-
-        if result.files_changed:
-            result.files_changed = sorted(set(result.files_changed) | set(changed_files))
-        else:
-            result.files_changed = changed_files
-        if not result.lines_added:
-            result.lines_added = int(pre_commit_git.get("lines_added", 0) or 0)
-        if not result.lines_removed:
-            result.lines_removed = int(pre_commit_git.get("lines_removed", 0) or 0)
-
-        if not self.process_manager._has_required_deliverable_updates(
-            task,
-            changed_files,
-            result.files_changed,
-        ):
-            return False
-
-        validation_issues = self._validate_outputs(workspace_path, task, result)
-        if validation_issues:
-            result.metrics["timeout_recovery_validation_issues"] = validation_issues
-            return False
-
-        result.metrics["recovered_from_timeout_uncommitted_changes"] = True
-        return True
-
     def _build_prompt(self, task: TaskInfo) -> str:
         """Build the prompt to send to the agent.
 
@@ -3743,6 +3890,7 @@ class ProcessManager:
             "--output-format", "stream-json",
             "--verbose",
             "--max-turns", str(max_turns),
+            "--no-session-persistence",
             "--dangerously-skip-permissions",
         ]
 
@@ -3750,6 +3898,7 @@ class ProcessManager:
         model_override = os.environ.get("FACTORY_CLAUDE_MODEL")
         if model_override:
             env["ANTHROPIC_MODEL"] = model_override
+        env.update(self._prepare_claude_environment())
 
         try:
             proc = await asyncio.create_subprocess_exec(
@@ -3770,6 +3919,8 @@ class ProcessManager:
 
             # Parse Claude JSON output for metrics
             metrics = self._parse_claude_output(stdout)
+            structured_errors = self._extract_output_signals("\n".join(part for part in (stdout, stderr) if part))["error_messages"]
+            structured_error_text = "; ".join(str(msg).strip() for msg in structured_errors if str(msg).strip())
 
             if returncode == 0:
                 return TaskResult(
@@ -3798,6 +3949,15 @@ class ProcessManager:
                               "exceeded the model's limit. Reduce prompt size or shorten file reads.",
                         metrics=metrics,
                     )
+                if structured_error_text:
+                    return TaskResult(
+                        status="failed",
+                        exit_code=returncode,
+                        stdout=stdout[-settings.AGENT_MAX_OUTPUT_SIZE:],
+                        stderr=stderr[-10000:],
+                        error=f"Claude exited with code {returncode}: {structured_error_text}",
+                        metrics=metrics,
+                    )
                 return TaskResult(
                     status="failed",
                     exit_code=returncode,
@@ -4101,6 +4261,58 @@ class ProcessManager:
         result.error = error_clean or result.error
         return result
 
+    @staticmethod
+    def _prepare_claude_environment() -> dict[str, str]:
+        """Prepare writable Claude config/data/cache dirs under ~/.forgexa.
+
+        The daemon service runs with ProtectSystem=strict and only allows
+        writes under ~/.forgexa plus the workspace root. Claude Code writes
+        config, debug logs, cache, and session state under XDG paths and
+        ~/.claude by default, which can fail with EROFS inside the daemon.
+
+        Point Claude at writable daemon-owned directories and mirror only the
+        small set of user config files it needs for headless execution.
+        """
+        sandbox_root = Path.home() / ".forgexa" / "claude-home"
+        config_root = sandbox_root / "config"
+        data_root = sandbox_root / "data"
+        cache_root = sandbox_root / "cache"
+        state_root = sandbox_root / "state"
+        claude_config_dir = config_root / "claude"
+
+        for path in (config_root, data_root, cache_root, state_root, claude_config_dir):
+            path.mkdir(parents=True, exist_ok=True)
+
+        source_files = [
+            (Path.home() / ".claude.json", claude_config_dir / ".claude.json"),
+            (Path.home() / ".claude" / "settings.json", claude_config_dir / "settings.json"),
+        ]
+        for source, dest in source_files:
+            try:
+                if source.is_file() and not dest.exists():
+                    shutil.copy2(source, dest)
+            except Exception as exc:
+                logger.debug(
+                    "Claude config mirror skipped %s -> %s: %s",
+                    source, dest, exc,
+                )
+
+        env = {
+            "XDG_CONFIG_HOME": str(config_root),
+            "XDG_DATA_HOME": str(data_root),
+            "XDG_CACHE_HOME": str(cache_root),
+            "XDG_STATE_HOME": str(state_root),
+            "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": str(
+                os.environ.get("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC", "1")
+            ),
+        }
+
+        if not os.environ.get("CLAUDE_CODE_DEBUG_LOGS_DIR"):
+            env["CLAUDE_CODE_DEBUG_LOGS_DIR"] = str(cache_root / "claude-debug")
+            Path(env["CLAUDE_CODE_DEBUG_LOGS_DIR"]).mkdir(parents=True, exist_ok=True)
+
+        return env
+
     @staticmethod
     def _prepare_copilot_home() -> str:
         """Prepare a writable Copilot home under ~/.forgexa for sandboxed runs.
@@ -4998,10 +5210,36 @@ class ProcessManager:
 class ProgressReporter:
     """Reports task progress back to the server."""
 
+    _MIN_HEARTBEAT_INTERVAL_SECONDS = 5.0
+    _MIN_PROGRESS_DELTA = 5
+
     def __init__(self, client: httpx.AsyncClient, server_url: str, runtime_id: str):
         self.client = client
         self.server_url = server_url.rstrip("/")
         self.runtime_id = runtime_id
+        self._last_progress_sent: dict[str, dict[str, Any]] = {}
+
+    def _should_skip_progress(
+        self,
+        task_id: str,
+        progress_percent: int,
+        current_step: str,
+        output_lines: list[str],
+        files_changed: list[str],
+        lines_added: int,
+        lines_removed: int,
+    ) -> bool:
+        if output_lines or files_changed or lines_added or lines_removed:
+            return False
+
+        last = self._last_progress_sent.get(task_id)
+        if not last:
+            return False
+        if last["current_step"] != current_step:
+            return False
+        if progress_percent - int(last["progress_percent"]) >= self._MIN_PROGRESS_DELTA:
+            return False
+        return (time.monotonic() - float(last["sent_at"])) < self._MIN_HEARTBEAT_INTERVAL_SECONDS
 
     async def report_progress(
         self,
@@ -5013,24 +5251,43 @@ class ProgressReporter:
         lines_added: int = 0,
         lines_removed: int = 0,
     ):
+        output_lines = output_lines or []
+        files_changed = files_changed or []
+        if self._should_skip_progress(
+            task_id,
+            progress_percent,
+            current_step,
+            output_lines,
+            files_changed,
+            lines_added,
+            lines_removed,
+        ):
+            return
+
         try:
             await self.client.post(
                 f"{self.server_url}/api/v1/runtimes/{self.runtime_id}/tasks/{task_id}/progress",
                 json={
                     "progress_percent": progress_percent,
                     "current_step": current_step,
-                    "output_lines": output_lines or [],
-                    "files_changed": files_changed or [],
+                    "output_lines": output_lines,
+                    "files_changed": files_changed,
                     "lines_added": lines_added,
                     "lines_removed": lines_removed,
                 },
                 timeout=10,
             )
+            self._last_progress_sent[task_id] = {
+                "progress_percent": progress_percent,
+                "current_step": current_step,
+                "sent_at": time.monotonic(),
+            }
         except Exception as e:
             logger.warning("Failed to report progress for task %s: %s", task_id, e)
 
     async def report_complete(self, task_id: str, result: TaskResult):
         """Report task completion with retry."""
+        self._last_progress_sent.pop(task_id, None)
         payload = {
             "status": result.status,
             "exit_code": result.exit_code,
@@ -5224,6 +5481,8 @@ class LogUploader:
 class TaskPoller:
     """Polls the server for assigned tasks."""
 
+    _EMPTY_BACKOFF_STEPS = (0, 0, 1, 2, 3, 5)
+
     def __init__(
         self,
         client: httpx.AsyncClient,
@@ -5237,6 +5496,16 @@ class TaskPoller:
         self.interval = interval
         self._on_success = lambda: None  # Callbacks set by ServerConnection
         self._on_auth_failure = lambda: None
+        self._empty_cycles = 0
+
+    def note_activity(self, *, had_work: bool) -> None:
+        if had_work:
+            self._empty_cycles = 0
+            return
+        self._empty_cycles = min(self._empty_cycles + 1, len(self._EMPTY_BACKOFF_STEPS) - 1)
+
+    def next_delay_seconds(self) -> int:
+        return self.interval + self._EMPTY_BACKOFF_STEPS[self._empty_cycles]
 
     async def poll(self) -> list[TaskInfo]:
         """Poll for tasks assigned to this daemon."""
@@ -5967,15 +6236,28 @@ class RuntimeDaemon:
         # 3. Main loop
         try:
             while not self._shutdown:
-                await self._poll_and_execute()
-                await asyncio.sleep(self.poll_interval)
+                had_work = await self._poll_and_execute()
+                next_delay = self.poll_interval
+                if self.connections:
+                    next_delay = min(
+                        conn.poller.next_delay_seconds()
+                        for conn in self.connections
+                        if conn.poller is not None
+                    )
+                logger.debug(
+                    "Daemon poll cycle complete (had_work=%s, next_delay=%ss)",
+                    had_work,
+                    next_delay,
+                )
+                await asyncio.sleep(next_delay)
         except asyncio.CancelledError:
             pass
         finally:
             await self._shutdown_gracefully()
 
-    async def _poll_and_execute(self):
+    async def _poll_and_execute(self) -> bool:
         """Poll for tasks from all connected servers and execute them."""
+        had_work = False
         # Clean up completed tasks
         for task_id in list(self.active_tasks):
             if self.active_tasks[task_id].done():
@@ -5990,7 +6272,7 @@ class RuntimeDaemon:
 
         # Check capacity
         if total_active >= self.max_concurrent:
-            return
+            return True
 
         # Poll from all connected servers
         for conn in self.connections:
@@ -5998,6 +6280,12 @@ class RuntimeDaemon:
                 break
 
             tasks = await conn.poller.poll()
+            ai_jobs: list[dict] = []
+            if len(self.active_tasks) < self.max_concurrent:
+                ai_jobs = await conn.poller.poll_ai_jobs()
+
+            conn.poller.note_activity(had_work=bool(tasks or ai_jobs))
+            had_work = had_work or bool(tasks or ai_jobs)
 
             for task in tasks:
                 if task.task_id in self.active_tasks:
@@ -6015,21 +6303,63 @@ class RuntimeDaemon:
                 )
 
             # Poll for AIJobs (workspace-mode tasks)
-            if len(self.active_tasks) < self.max_concurrent:
-                ai_jobs = await conn.poller.poll_ai_jobs()
-                for aj in ai_jobs:
-                    job_id = aj.get("job_id", "")
-                    ai_task_key = f"aijob_{job_id}"
-                    if ai_task_key in self.active_tasks:
-                        continue
-                    if len(self.active_tasks) >= self.max_concurrent:
-                        break
-                    logger.info("[%s] Starting AIJob %s (type=%s)",
-                               conn.label, job_id, aj.get("task_type"))
-                    self._task_connections[ai_task_key] = conn
-                    self.active_tasks[ai_task_key] = asyncio.create_task(
-                        self._execute_ai_job(aj, conn)
-                    )
+            for aj in ai_jobs:
+                job_id = aj.get("job_id", "")
+                ai_task_key = f"aijob_{job_id}"
+                if ai_task_key in self.active_tasks:
+                    continue
+                if len(self.active_tasks) >= self.max_concurrent:
+                    break
+                logger.info("[%s] Starting AIJob %s (type=%s)",
+                           conn.label, job_id, aj.get("task_type"))
+                self._task_connections[ai_task_key] = conn
+                self.active_tasks[ai_task_key] = asyncio.create_task(
+                    self._execute_ai_job(aj, conn)
+                )
+
+        return had_work
+
+    def _recover_timeout_from_workspace_changes(
+        self,
+        task: TaskInfo,
+        workspace_path: Path,
+        result: TaskResult,
+        pre_commit_git: dict,
+    ) -> bool:
+        """Recover absolute-timeout failures after validating workspace output."""
+        error_lower = (result.error or "").lower()
+        is_absolute_timeout = (
+            "absolute limit" in error_lower or "timed out after" in error_lower
+        )
+        changed_files = list(pre_commit_git.get("files_changed") or [])
+        if not is_absolute_timeout or not changed_files:
+            return False
+        if not self.process_manager.has_meaningful_agent_output(result):
+            return False
+
+        if result.files_changed:
+            result.files_changed = sorted(set(result.files_changed) | set(changed_files))
+        else:
+            result.files_changed = changed_files
+        if not result.lines_added:
+            result.lines_added = int(pre_commit_git.get("lines_added", 0) or 0)
+        if not result.lines_removed:
+            result.lines_removed = int(pre_commit_git.get("lines_removed", 0) or 0)
+
+        if not self.process_manager._has_required_deliverable_updates(
+            task,
+            changed_files,
+            result.files_changed,
+        ):
+            return False
+
+        validation_issues = self._validate_outputs(workspace_path, task, result)
+        if validation_issues:
+            result.metrics["timeout_recovery_validation_issues"] = validation_issues
+            return False
+
+        result.metrics["recovered_from_timeout_uncommitted_changes"] = True
+        return True
 
     async def _execute_task(self, task: TaskInfo, conn: ServerConnection):
         """Execute a single task, reporting to the originating server connection."""
@@ -6654,12 +6984,23 @@ class RuntimeDaemon:
                     # as failed so the orchestrator can retry (transient network).
                     if commit_result.get("push_error"):
                         push_err = commit_result["push_error"]
-                        logger.error(
-                            "Task %s: push failed, marking as failed so retry can attempt push again: %s",
-                            task.task_id, push_err,
-                        )
                         result.status = "failed"
-                        result.error = f"Git push failed: {push_err}"
+                        if commit_result.get("push_error_code") == "forbidden_branch_merge":
+                            logger.error(
+                                "Task %s: push blocked by requirement-branch merge protection: %s",
+                                task.task_id, push_err,
+                            )
+                            result.failure_code = "forbidden_branch_merge"
+                            result.error = (
+                                commit_result.get("push_error_display")
+                                or f"Push blocked: {push_err}"
+                            )
+                        else:
+                            logger.error(
+                                "Task %s: push failed, marking as failed so retry can attempt push again: %s",
+                                task.task_id, push_err,
+                            )
+                            result.error = f"Git push failed: {push_err}"
                 # Re-collect git info after commit (compare with parent)
                 post_commit_git = await self.process_manager._collect_git_info_vs_parent(workspace_path)
                 # Merge: use the pre-commit file list if post-commit is empty
@@ -6896,12 +7237,14 @@ class RuntimeDaemon:
 
         elif node_type == "design":
             doc_dir = (task.input_data or {}).get("output_dir", "")
+            req_type = (task.input_data or {}).get("requirement_type", "feature")
             if doc_dir:
-                design_path = workspace_path / doc_dir / "design.md"
+                design_filename = _get_design_output_for_type(req_type)
+                design_path = workspace_path / doc_dir / design_filename
                 if not design_path.exists():
-                    issues.append(f"Design document missing: {doc_dir}/design.md")
+                    issues.append(f"Design document missing: {doc_dir}/{design_filename}")
                 elif design_path.stat().st_size == 0:
-                    issues.append(f"Design document is empty: {doc_dir}/design.md")
+                    issues.append(f"Design document is empty: {doc_dir}/{design_filename}")
 
         elif node_type in ("coding", "testing", "fix", "review"):
             # Syntax-check modified Python and JS/TS files
@@ -7053,12 +7396,14 @@ class RuntimeDaemon:
         agent_override = aj.get("agent_override")
         system_prompt = aj.get("system_prompt", "")
         user_prompt = aj.get("user_prompt", "")
+        input_ctx = aj.get("input_context", {})
+        ai_workspace_scope = _resolve_ai_job_workspace_scope(aj)
 
         reporter_url = f"{conn.server_url.rstrip('/')}/api/v1/runtimes/{conn.runtime_id}/ai-jobs/{job_id}"
         # Use workspace-level key (project:requirement or project:job_id) so AI jobs
         # for different requirements run in parallel while same-requirement jobs serialize.
         _aj_proj_key = project_info.get("project_key") or str(project_info.get("id") or "default")
-        project_lock_key = f"{_aj_proj_key}:{requirement_key or job_id}"
+        project_lock_key = f"{_aj_proj_key}:{ai_workspace_scope or job_id}"
         project_lock = await self._get_project_execution_lock(project_lock_key)
         if project_lock.locked():
             logger.info(
@@ -7111,11 +7456,10 @@ class RuntimeDaemon:
             full_prompt = f"{system_prompt}\n\n{user_prompt}" if system_prompt else user_prompt
             fake_task = TaskInfo(
                 task_id=job_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,
+                # Reuse a stable workspace key when the server provides one so
+                # delegated retries do not create a fresh clone per AIJob row.
+                # Fall back to job_id so workspace_key is always non-empty.
+                graph_id=ai_workspace_scope or job_id,
                 node_type="ai_job",
                 agent_type=agent_type,
                 input_prompt=full_prompt,
@@ -7134,6 +7478,17 @@ class RuntimeDaemon:
                 project_info, fake_task,
             )
 
+            if task_type == "qa_scenario_generate_prompt" and not input_ctx.get("project_context"):
+                local_project_context = _summarize_workspace_source(workspace_path)
+                if local_project_context:
+                    fake_task.input_prompt = (
+                        f"{full_prompt}\n\n"
+                        "Use the provided project source context when grounding scenario coverage. "
+                        "Do not rely on additional workspace searching before responding.\n"
+                        "Do not call Grep or search tools against '.' or a bare directory path directly.\n\n"
+                        f"## Project Source Code Context\n{local_project_context}"
+                    )
+
             await conn.client.post(
                 f"{reporter_url}/progress",
                 json={"current_phase": "running", "current_step": "Running agent...", "progress_pct": 15},
@@ -7210,7 +7565,6 @@ class RuntimeDaemon:
             # 4. Auto-commit if successful (always call _auto_commit on success:
             # _auto_commit handles both uncommitted changes AND internally-committed
             # changes that just need to be pushed — same as _execute_task).
-            input_ctx = aj.get("input_context", {})
             git_info = {}
             if result.status == "success":
                 git_info = await self._auto_commit(workspace_path, fake_task)
@@ -7628,11 +7982,11 @@ class RuntimeDaemon:
         Some agents (e.g. claude) commit changes internally, so we must
         also push even when the working directory is clean.
 
-        Before pushing, we rebase onto the latest ``origin/{default_branch}``
-        so that the PR is based on up-to-date code and avoids unnecessary
-        merge conflicts.  If rebase fails (true conflict), we fall back to a
-        merge.  If the merge also fails, we invoke the same AI agent to
-        resolve the remaining conflicts automatically.
+        For non-requirement branches, we may integrate the latest
+        ``origin/{default_branch}`` before push. Requirement branches are
+        explicitly excluded because silently rebasing/merging the default
+        branch into a requirement branch widens the change scope, pollutes gate
+        review diffs, and can import unrelated requirements into the fix.
 
         Returns a dict with commit/push status info (empty on success).
         """
@@ -7747,6 +8101,35 @@ class RuntimeDaemon:
                 )
                 return {"push_error": f"Would push to default branch {current_branch}"}
 
+            if task.requirement_key and current_branch:
+                forbidden_merges = await self._list_unpushed_merge_commits(
+                    workspace_path, current_branch, default_branch,
+                )
+                if forbidden_merges:
+                    short_merges = ", ".join(sha[:12] for sha in forbidden_merges[:5])
+                    logger.error(
+                        "Requirement branch %s has %d new merge commit(s) pending push [%s] — "
+                        "aborting push to prevent cross-requirement contamination",
+                        current_branch, len(forbidden_merges), short_merges,
+                    )
+                    display_error = (
+                        f"Push blocked: requirement branch '{current_branch}' contains "
+                        f"merge commit(s) pending push ({short_merges}). "
+                        "This would import default-branch or unrelated requirement changes "
+                        "into the current execution scope. Roll back or recreate this fix "
+                        "on a clean requirement branch. Do not merge, rebase, or pull the "
+                        "default branch into requirement branches."
+                    )
+                    return {
+                        "push_error_code": "forbidden_branch_merge",
+                        "push_error": (
+                            "Requirement branch contains merge commit(s) pending push: "
+                            f"{short_merges}. Merging default/other branches into "
+                            "requirement branches is forbidden."
+                        ),
+                        "push_error_display": display_error,
+                    }
+
             # ── Push ──
             push_error = await self._push_branch(workspace_path, project_key, task=task)
             if push_error:
@@ -8560,6 +8943,11 @@ class RuntimeDaemon:
     ):
         """Integrate the current branch with ``origin/{default_branch}``.
 
+                Requirement branches are intentionally excluded. They already sync to the
+                latest remote requirement branch during workspace preparation, so pulling
+                in ``origin/{default_branch}`` here only risks importing unrelated work
+                into the requirement/fix scope.
+
         Strategy:
           - If the current branch already exists on remote (was previously pushed):
             Skip rebase entirely and use merge only.  Rebase rewrites commit
@@ -8575,6 +8963,15 @@ class RuntimeDaemon:
         target = f"origin/{default_branch}"
         _git_name, _git_email = _resolve_git_author(task.project)
 
+        if task.requirement_key:
+            logger.info(
+                "Skipping automatic integration of %s into requirement branch %s "
+                "to preserve task scope and avoid cross-requirement contamination",
+                target,
+                task.requirement_key,
+            )
+            return
+
         # Fetch latest remote state
         try:
             await git("fetch", "origin", cwd=workspace_path,
@@ -8658,6 +9055,38 @@ class RuntimeDaemon:
         # ── Tier 3: AI-assisted conflict resolution ──
         await self._ai_resolve_conflicts(workspace_path, default_branch, task)
 
+    async def _list_unpushed_merge_commits(
+        self,
+        workspace_path: Path,
+        current_branch: str,
+        default_branch: str,
+    ) -> list[str]:
+        """Return merge commits introduced locally and not yet on the remote branch.
+
+        Requirement branches must stay linear and requirement-scoped. Any new
+        merge commit pending push indicates an explicit merge/rebase workflow that
+        can import unrelated changes (for example, merging origin/develop into a
+        fix branch). Those pushes are rejected by the caller.
+        """
+        git = self.workspace_manager._git
+
+        try:
+            await git("rev-parse", "--verify", f"origin/{current_branch}", cwd=workspace_path)
+            out = await git(
+                "rev-list", "--min-parents=2", f"origin/{current_branch}..HEAD",
+                cwd=workspace_path,
+            )
+        except RuntimeError:
+            try:
+                out = await git(
+                    "rev-list", "--min-parents=2", "HEAD", "--not", f"origin/{default_branch}",
+                    cwd=workspace_path,
+                )
+            except RuntimeError:
+                return []
+
+        return [line.strip() for line in out.splitlines() if line.strip()]
+
     async def _ai_resolve_conflicts(
         self, workspace_path: Path, default_branch: str, task: TaskInfo,
     ):

{forgexa_cli-1.14.2 → forgexa_cli-1.14.4}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.14.2
+Version: 1.14.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.14.2 → forgexa_cli-1.14.4}/pyproject.toml

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