forgexa-cli 1.79.2__tar.gz → 1.80.0__tar.gz

{forgexa_cli-1.79.2 → forgexa_cli-1.80.0}/PKG-INFO

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

{forgexa_cli-1.79.2 → forgexa_cli-1.80.0}/forgexa_cli/__init__.py

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

{forgexa_cli-1.79.2 → forgexa_cli-1.80.0}/forgexa_cli/agent_core.py

@@ -106,6 +106,25 @@ def is_implementation_testing_task(node_type: str, input_data: dict) -> bool:
     )
 
 
+def validate_task_delivery_baseline(
+    baseline: object, node_id: str, graph_id: str, branch: str | None = None,
+) -> str:
+    if not isinstance(baseline, dict) or (
+        type(baseline.get("version")) is not int or baseline["version"] != 1
+        or set(baseline) - {"version", "node_id", "graph_id", "branch", "before_sha", "anchor_node_id"}
+        or not baseline.get("node_id") or not baseline.get("graph_id")
+        or baseline.get("node_id") != str(node_id)
+        or baseline.get("graph_id") != str(graph_id)
+        or not isinstance(baseline.get("branch"), str)
+        or not baseline["branch"].strip()
+        or len(baseline["branch"]) > 255
+        or branch is not None and baseline["branch"] != branch
+        or not re.fullmatch(r"[0-9a-fA-F]{40}", str(baseline.get("before_sha") or ""))
+    ):
+        raise ValueError("Planned task delivery baseline does not match its task, graph, or branch")
+    return baseline["before_sha"].lower()
+
+
 def missing_planned_task_files(task_input: dict, changed_files: list[str]) -> list[str]:
     """Find planned files without delivery evidence, including grouped sub-tasks."""
     def normalize_path(value: object) -> str | None:
@@ -142,6 +161,15 @@ def missing_planned_task_files(task_input: dict, changed_files: list[str]) -> li
     )
 
 
+def requires_task_delivery_baseline(node_type: str, task_input: dict) -> bool:
+    return (
+        node_type == "coding" or node_type == "fix" and task_input.get("task") == "phase_remediation_fix"
+    ) and (
+        task_input.get("planned_task_git_baseline") is not None
+        or bool(missing_planned_task_files(task_input, []))
+    )
+
+
 def extract_implementation_audit(text: str) -> dict | None:
     """Read the last complete audit envelope from mixed assistant output."""
     decoder = json.JSONDecoder()
@@ -227,7 +255,7 @@ def _assess_implementation_contributions(contract: dict, report: object) -> dict
             key: implementation[key] for key in ("status", "evidence", "description", "files", "plan_revision")
             if key in implementation
         }}
-        if row.get("plan_revision") is not None:
+        if row.get("plan_revision") is not None and implementation.get("status") != "covered":
             check["plan_revision"] = row["plan_revision"]
         checks.append(check)
         if implementation.get("status") == "covered" and row.get("status") == "gap":
@@ -305,6 +333,12 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
             ):
                 issues.append(f"Implementation {kind} check requires an explicit status and concrete evidence")
                 continue
+            if status == "covered" and row.get("plan_revision") is not None:
+                issues.append(
+                    "A covered implementation check cannot request a plan revision; "
+                    "report the affected check as gap, blocked, or unverified"
+                )
+                continue
             if kind == "task":
                 task_id = row.get("task_id")
                 if not isinstance(task_id, str) or task_id not in expected or task_id in checked:

{forgexa_cli-1.79.2 → forgexa_cli-1.80.0}/forgexa_cli/daemon.py

@@ -1234,7 +1234,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.79.2"
+DAEMON_VERSION = "1.80.0"
 
 
 def _detect_client_type() -> str:
@@ -8950,6 +8950,7 @@ class ProgressReporter:
         lines_added: int = 0,
         lines_removed: int = 0,
         execution_attempt_id: str | None = None,
+        task_delivery_baseline: dict | None = None,
     ) -> bool:
         output_lines = [
             *self._pending_output_lines.get(task_id, []),
@@ -8957,7 +8958,7 @@ class ProgressReporter:
         ]
         activity_lines = activity_lines or []
         files_changed = files_changed or []
-        if self._should_skip_progress(
+        if task_delivery_baseline is None and self._should_skip_progress(
             task_id,
             progress_percent,
             current_step,
@@ -8981,12 +8982,15 @@ class ProgressReporter:
                     "lines_added": lines_added,
                     "lines_removed": lines_removed,
                     "execution_attempt_id": execution_attempt_id,
+                    **({"task_delivery_baseline": task_delivery_baseline} if task_delivery_baseline is not None else {}),
                 },
                 timeout=10,
             )
             if 200 <= response.status_code < 300:
                 if response.json().get("status") == "ignored":
                     return False
+                if task_delivery_baseline is not None and response.json().get("task_delivery_baseline") != task_delivery_baseline:
+                    return False
                 self._pending_output_lines.pop(task_id, None)
                 self._last_progress_sent[task_id] = {
                     "progress_percent": progress_percent,
@@ -9946,6 +9950,7 @@ class ServerConnection:
                     "protocol_version": runtime_evidence.DEFERRED_ACCEPTANCE_VERIFICATION_PROTOCOL_VERSION,
                 },
                 "implementation_audit": {"protocol_version": 3},
+                "task_delivery": {"protocol_version": 1},
                 "task_attachment_staging": {"protocol_version": 1, "runtime_proxy": True, "image_agents": ["claude"]},
             },
             "server_url": self.server_url,
@@ -10370,6 +10375,7 @@ class ServerConnection:
                         "protocol_version": runtime_evidence.DEFERRED_ACCEPTANCE_VERIFICATION_PROTOCOL_VERSION,
                     },
                     "implementation_audit": {"protocol_version": 3},
+                    "task_delivery": {"protocol_version": 1},
                     "local_evidence": {"protocol_version": 1, "structured_summary": True},
                     "task_attachment_staging": {"protocol_version": 1, "runtime_proxy": True, "image_agents": ["claude"]},
                 },
@@ -12608,6 +12614,53 @@ class RuntimeDaemon:
                 f"wipe_analysis_dir failed for {output_dir_norm}: {_wipe_err}"
             ) from _wipe_err
 
+    async def _resolve_task_delivery_before_sha(
+        self, task: TaskInfo, workspace_path: Path, attempt_before_sha: str,
+    ) -> str:
+        baseline = (task.input_data or {}).get("planned_task_git_baseline")
+        if baseline is None and not agent_core.requires_task_delivery_baseline(task.node_type, task.input_data or {}):
+            return attempt_before_sha
+        if not re.fullmatch(r"[0-9a-fA-F]{40}", attempt_before_sha):
+            raise ValueError("Planned task attempt has no verified starting commit")
+        try:
+            branch = (await self.workspace_manager._git(
+                "rev-parse", "--abbrev-ref", "HEAD", cwd=workspace_path, timeout=10,
+            )).strip()
+        except Exception as error:
+            raise ValueError("Planned task delivery branch could not be verified") from error
+        if baseline is None:
+            baseline = {
+                "version": 1, "node_id": task.task_id, "graph_id": task.graph_id,
+                "branch": branch, "before_sha": attempt_before_sha,
+            }
+            task.input_data = {**(task.input_data or {}), "planned_task_git_baseline": baseline}
+        before_sha = agent_core.validate_task_delivery_baseline(
+            baseline, task.task_id, task.graph_id, branch,
+        )
+        try:
+            await self.workspace_manager._git(
+                "merge-base", "--is-ancestor", before_sha, "HEAD", cwd=workspace_path, timeout=10,
+            )
+        except Exception as error:
+            raise ValueError("Planned task delivery baseline is not a verified ancestor of HEAD") from error
+        return before_sha
+
+    async def _collect_task_delivery_git(
+        self, task: TaskInfo, workspace_path: Path, result: TaskResult, *, attempt_before_sha: str,
+    ) -> None:
+        if task.node_type != "coding" and not (
+            task.node_type == "fix" and (task.input_data or {}).get("task") == "phase_remediation_fix"
+        ):
+            return
+        before_sha = await self._resolve_task_delivery_before_sha(task, workspace_path, attempt_before_sha)
+        git_info = await self.process_manager._collect_git_info_vs_parent(workspace_path, before_sha=before_sha)
+        if git_info.get("files_changed_verified") is not True:
+            raise ValueError("Planned task cumulative Git delivery could not be verified")
+        result.git = {**(result.git or {}), **git_info, "attempt_before_sha": attempt_before_sha}
+        result.files_changed = list(git_info.get("files_changed") or [])
+        result.lines_added = git_info.get("lines_added", 0)
+        result.lines_removed = git_info.get("lines_removed", 0)
+
     async def _execute_task(self, task: TaskInfo, conn: ServerConnection):
         """Execute a single task, reporting to the originating server connection."""
         reporter = conn.reporter
@@ -12617,7 +12670,22 @@ class RuntimeDaemon:
         # skipped for a node bound to the user's own real directory. See
         # docs/designs/forgexa-ide-design.md §6.2.
         is_local_bind = task.workspace_resolution == "local_bind"
+        workspace_path: Path | None = None
+        node_before_sha = ""
+        delivery_before_sha = ""
         async def report_task_complete(result: TaskResult) -> None:
+            if workspace_path is not None and node_before_sha:
+                try:
+                    await self._collect_task_delivery_git(
+                        task, workspace_path, result, attempt_before_sha=node_before_sha,
+                    )
+                except ValueError as error:
+                    if result.status == "success":
+                        result.status = "failed"
+                        result.failure_code = "planned_task_baseline_invalid"
+                        result.error = str(error)
+                    else:
+                        result.metrics["task_delivery_issue"] = str(error)
             if is_local_bind:
                 if result.error:
                     _append_local_bind_output_log(task.task_id, [f"[daemon] {result.error}"])
@@ -12640,7 +12708,6 @@ class RuntimeDaemon:
                 return
 
         default_branch = str((task.project or {}).get("default_branch") or "").strip()
-        node_before_sha = ""
         # Use workspace-level granularity (requirement_workflow_id or graph_id) so that
         # tasks for DIFFERENT requirements can run in parallel on the same daemon, while
         # tasks for the SAME requirement (e.g. analysis + retry) are still serialized to
@@ -12839,6 +12906,29 @@ class RuntimeDaemon:
                     _before_sha_err,
                 )
 
+            try:
+                delivery_before_sha = await self._resolve_task_delivery_before_sha(task, workspace_path, node_before_sha)
+            except ValueError as error:
+                await report_task_complete(TaskResult(
+                    status="failed", exit_code=-1, stdout="", stderr="", error=str(error),
+                    failure_code="planned_task_baseline_invalid", execution_attempt_id=task.execution_attempt_id,
+                ))
+                return
+
+            if agent_core.requires_task_delivery_baseline(task.node_type, task.input_data or {}):
+                confirmed = await reporter.report_progress(
+                    task.task_id, 9, "freezing_task_delivery_baseline",
+                    execution_attempt_id=task.execution_attempt_id,
+                    task_delivery_baseline=task.input_data["planned_task_git_baseline"],
+                )
+                if not confirmed:
+                    await report_task_complete(TaskResult(
+                        status="failed", exit_code=-1, stdout="", stderr="",
+                        error="Server did not confirm the durable task delivery baseline; update the backend and verify connectivity before retrying",
+                        failure_code="planned_task_baseline_invalid", execution_attempt_id=task.execution_attempt_id,
+                    ))
+                    return
+
             # 3. Run agent with real-time output streaming + periodic progress heartbeat
             await reporter.report_progress(task.task_id, 10, "running_agent", execution_attempt_id=task.execution_attempt_id)
 
@@ -13198,7 +13288,7 @@ class RuntimeDaemon:
                     result, agent = await self._validate_with_agent_fallback(
                         agent, task, workspace_path, result,
                         reporter, on_output_chunk, tried_agents=tried_agents,
-                        default_branch=default_branch, before_sha=node_before_sha,
+                        default_branch=default_branch, before_sha=delivery_before_sha,
                     )
                     # Re-collect git info if validation triggered retries
                     if result.metrics.get("validation_issues") is not None or True:
@@ -13280,7 +13370,7 @@ class RuntimeDaemon:
                                 result, agent = await self._validate_with_agent_fallback(
                                     agent, task, workspace_path, result,
                                     reporter, on_output_chunk, tried_agents=tried_agents,
-                                    default_branch=default_branch, before_sha=node_before_sha,
+                                    default_branch=default_branch, before_sha=delivery_before_sha,
                                 )
                                 pre_commit_git = await self.process_manager._collect_git_info(workspace_path)
                             except Exception:
@@ -13416,7 +13506,7 @@ class RuntimeDaemon:
                 try:
                     result = await self._validate_and_retry(
                         agent, task, workspace_path, result, reporter, on_output_chunk,
-                        max_retries=0, default_branch=default_branch, before_sha=node_before_sha,
+                        max_retries=0, default_branch=default_branch, before_sha=delivery_before_sha,
                     )
                 except Exception:
                     _mark_qa_source_validation_unavailable(result)
@@ -13526,7 +13616,7 @@ class RuntimeDaemon:
                 post_commit_git = await self.process_manager._collect_git_info_vs_parent(
                     workspace_path,
                     default_branch=default_branch,
-                    before_sha=node_before_sha,
+                    before_sha=delivery_before_sha,
                 )
                 result.git = post_commit_git
                 result.files_changed = result.git.get("files_changed", [])
@@ -13574,13 +13664,16 @@ class RuntimeDaemon:
                     )
 
             if result.status == "success" and task.critic_review_required:
+                await self._collect_task_delivery_git(
+                    task, workspace_path, result, attempt_before_sha=node_before_sha,
+                )
                 await reporter.report_progress(task.task_id, 95, "running_critic_review", execution_attempt_id=task.execution_attempt_id)
                 result.critic_review = await self._run_runtime_critic_review(
                     task,
                     agent,
                     workspace_path,
                     result,
-                    before_sha=node_before_sha,
+                    before_sha=delivery_before_sha,
                 )
 
             # 6. Report completion (include actual agent used if different from requested)
@@ -16146,8 +16239,12 @@ class RuntimeDaemon:
             qa_policy_violations = [
                 issue for issue in remaining if issue.startswith("qa_policy.")
             ]
+            planned_delivery_issues = [
+                issue for issue in remaining
+                if issue.startswith("Planned task file has no implementation evidence:")
+            ]
             blocking_issues = list(dict.fromkeys(
-                critical_issues + scope_violations + qa_policy_violations
+                critical_issues + scope_violations + qa_policy_violations + planned_delivery_issues
             ))
             if blocking_issues:
                 # Agent didn't produce required output — mark as failed
@@ -16161,6 +16258,9 @@ class RuntimeDaemon:
                 if scope_violations:
                     result.failure_code = "verification_work_item_scope_violation"
                     result.error = "; ".join(scope_violations[:3])
+                elif planned_delivery_issues:
+                    result.failure_code = "planned_task_incomplete"
+                    result.error = "; ".join(planned_delivery_issues[:3])
                 else:
                     result.failure_code = "validation_retry_exhausted"
                     result.error = (

{forgexa_cli-1.79.2 → forgexa_cli-1.80.0}/forgexa_cli.egg-info/PKG-INFO

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

{forgexa_cli-1.79.2 → forgexa_cli-1.80.0}/pyproject.toml

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