forgexa-cli 1.84.4__tar.gz → 1.85.1__tar.gz

{forgexa_cli-1.84.4 → forgexa_cli-1.85.1}/PKG-INFO

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

{forgexa_cli-1.84.4 → forgexa_cli-1.85.1}/forgexa_cli/__init__.py

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

{forgexa_cli-1.84.4 → forgexa_cli-1.85.1}/forgexa_cli/agent_core.py

@@ -211,6 +211,17 @@ def extract_implementation_audit(text: str) -> dict | None:
     return report
 
 
+def _implementation_acceptance_index(row: dict) -> int | None:
+    index = row.get("index", row.get("acceptance_index"))
+    if type(index) is not int:
+        return None
+    if "index" in row and "acceptance_index" in row and (
+        type(row["acceptance_index"]) is not int or row["acceptance_index"] != index
+    ):
+        return None
+    return index
+
+
 def redact_implementation_audit(contract: dict, report: object) -> dict | None:
     """Keep contract-owned status and hashed evidence without local free text."""
     from hashlib import sha256
@@ -244,7 +255,7 @@ def redact_implementation_audit(contract: dict, report: object) -> dict | None:
                 if contract.get("version") == 2 and row["task_id"] in coding_ids and isinstance(row.get("implementation_check"), dict):
                     check["implementation_check"] = redact_check(row["implementation_check"])
             else:
-                check.update(index=row["index"], task_ids=row["task_ids"])
+                check.update(index=_implementation_acceptance_index(row), task_ids=row["task_ids"])
             summary[key].append(check)
     return summary
 
@@ -305,22 +316,42 @@ def _assess_implementation_contributions(contract: dict, report: object) -> dict
             and len(criteria) == len(reserved_ids)
             and reserved_ids == [criterion.get("id") for criterion in criteria if isinstance(criterion, dict)]
         ):
+            index_map = deferred_contract.get("acceptance_criteria_indices")
+            expected_indices = {identifier: index for index, identifier in enumerate(reserved_ids, 1)}
+            valid_index_map = (
+                isinstance(index_map, dict) and set(index_map) == set(expected_indices)
+                and all(type(value) is int and value == expected_indices[identifier] for identifier, value in index_map.items())
+            )
             for criterion_id in reserved_ids:
                 match = re.fullmatch(r"AC-([0-9]+)", criterion_id)
-                if match is None or not 1 <= int(match.group(1)) <= len(contract.get("acceptance_criteria") or []):
+                index = index_map[criterion_id] if valid_index_map else int(match.group(1)) if index_map is None and match else 0
+                if not 1 <= index <= len(contract.get("acceptance_criteria") or []):
                     reserved_indexes.clear()
                     break
-                reserved_indexes.add(int(match.group(1)))
+                reserved_indexes.add(index)
             if len(reserved_indexes) != len(reserved_ids):
                 reserved_indexes.clear()
     acceptance_checks = []
     deferred_acceptance = []
+    subject = contract.get("subject_task_id")
+    prepared_verifier = (
+        not contract.get("final_verification") and task_types.get(subject) in ("testing", "verify")
+        and implementation_statuses.get(subject) == "covered"
+    )
     for row in report["acceptance_checks"]:
+        index = _implementation_acceptance_index(row)
         if (
-            row["index"] in reserved_indexes and row["status"] == "unverified" and row.get("plan_revision") is None
-            and all(implementation_statuses.get(task_id) == "covered" for task_id in row["task_ids"])
+            index in reserved_indexes and row["status"] == "unverified" and row.get("plan_revision") is None
+            and (
+                all(implementation_statuses.get(task_id) == "covered" for task_id in row["task_ids"])
+                or prepared_verifier and subject in row["task_ids"] and all(
+                    implementation_statuses.get(task_id) == "covered"
+                    or task_id not in implementation_statuses and task_types.get(task_id) in ("coding", "fix")
+                    for task_id in row["task_ids"]
+                )
+            )
         ):
-            deferred_acceptance.append(row["index"])
+            deferred_acceptance.append(index)
             continue
         if (
             pending_verification_ids and row["status"] in ("blocked", "unverified")
@@ -399,7 +430,7 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
     checked_criteria: set[int] = set()
     criterion_count = len(contract.get("acceptance_criteria") or [])
     for kind, rows in (("task", task_checks), ("acceptance", acceptance_checks)):
-        for row in rows:
+        for position, row in enumerate(rows, 1):
             if not isinstance(row, dict):
                 issues.append(f"Invalid implementation {kind} check")
                 continue
@@ -426,8 +457,19 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
                 checked[task_id] = status
                 related = [task_id]
             else:
-                index = row.get("index")
+                index = _implementation_acceptance_index(row)
                 related = row.get("task_ids")
+                if index is None:
+                    detail = (
+                        "index and acceptance_index must be identical integers"
+                        if "index" in row and "acceptance_index" in row else
+                        "index must be a one-based integer; acceptance_index is an exact alias, but id is not an index"
+                    )
+                    issues.append(
+                        f"Implementation audit has invalid acceptance criterion or task references; "
+                        f"acceptance row {position}: {detail}"
+                    )
+                    continue
                 if type(index) is int and not 1 <= index <= criterion_count:
                     if criterion_count == 0:
                         issues.append(
@@ -443,11 +485,18 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
                         )
                     continue
                 if (
-                    type(index) is not int or not 1 <= index <= criterion_count or index in checked_criteria
+                    index in checked_criteria
                     or not isinstance(related, list) or not related
                     or any(not isinstance(task_id, str) or task_id not in expected for task_id in related)
                 ):
-                    issues.append("Implementation audit has invalid acceptance criterion or task references")
+                    detail = (
+                        "duplicate index" if index in checked_criteria else
+                        "task_ids must be a non-empty list of approved top-level task IDs"
+                    )
+                    issues.append(
+                        f"Implementation audit has invalid acceptance criterion or task references; "
+                        f"acceptance index {index}: {detail}"
+                    )
                     continue
                 checked_criteria.add(index)
                 if len(related) > 1:
@@ -458,7 +507,16 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
                 description = row.get("description")
                 paths = row.get("files") or []
                 if not isinstance(description, str) or not description.strip() or not isinstance(paths, list):
-                    issues.append("Implementation gaps require an actionable description and file list")
+                    reference = f"task '{row['task_id']}'" if kind == "task" else f"acceptance index {index}"
+                    invalid_fields = []
+                    if not isinstance(description, str) or not description.strip():
+                        invalid_fields.append("description must be non-empty text")
+                    if not isinstance(paths, list):
+                        invalid_fields.append("files must be a list; use files=[] when no source file is implicated")
+                    issues.append(
+                        "Implementation gaps require an actionable description and file list; "
+                        + reference + ": " + "; ".join(invalid_fields)
+                    )
                     continue
                 if any(
                     not isinstance(path, str) or not path.strip()

{forgexa_cli-1.84.4 → forgexa_cli-1.85.1}/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.84.4"
+DAEMON_VERSION = "1.85.1"
 
 
 def _detect_client_type() -> str:
@@ -3040,7 +3040,7 @@ def _runtime_critic_reference_candidates(
             if isinstance(related, dict):
                 texts.append(str(related.get("description") or ""))
                 texts.extend(str(item.get("description") or "") for item in related.get("items") or [] if isinstance(item, dict))
-    if planned.get("type") == "design":
+    if planned.get("type") in ("design", "testing", "review"):
         texts.append(json.dumps({"analysis": baseline.get("approved_analysis"),
                                  "documents": baseline.get("analysis_documents")}, ensure_ascii=True)[:200_000])
     text = re.sub(r"https?://\S+", " ", "\n".join(texts))
@@ -3063,7 +3063,7 @@ def _runtime_critic_reference_candidates(
     php_context = any(Path(path).suffix.lower() == ".php" for path in source_paths)
     directories = {Path(path).parent.as_posix() for path in source_paths if safe_path(path)} - {"."}
     explicit = set()
-    for token in re.findall(r"(?<![\w./\\:-])[A-Za-z0-9_.-]+(?:/[A-Za-z0-9_.-]+)+", text):
+    for token in re.findall(r"(?<![A-Za-z0-9_./\\:-])[A-Za-z0-9_.-]+(?:/[A-Za-z0-9_.-]+)+", text):
         candidate = safe_path(token)
         if candidate is None:
             continue
@@ -4843,15 +4843,43 @@ class WorkspaceManager:
             if branch_name == default_branch:
                 raise RuntimeError("Fresh analysis cannot reset the project default branch")
             await self._git("check-ref-format", branch_ref, cwd=repository)
-            for name in (default_branch, branch_name):
+            await self._git(
+                "fetch", "origin", f"+{default_branch}:refs/remotes/origin/{default_branch}", cwd=repository,
+                timeout=settings.GIT_FETCH_TIMEOUT, project_key=project_key,
+            )
+            tracking_ref = f"refs/remotes/origin/{branch_name}"
+            advertised = (await self._git(
+                "ls-remote", "--heads", "origin", branch_ref, cwd=repository,
+                timeout=settings.GIT_FETCH_TIMEOUT, project_key=project_key,
+            )).strip()
+            if not advertised:
+                await self._git("update-ref", "-d", tracking_ref, cwd=repository)
+                logger.info("Fresh analysis branch %s is absent on origin; removed its stale tracking reference", branch_name)
+                return
+            remote_fields = advertised.split()
+            if len(remote_fields) != 2 or remote_fields[1] != branch_ref or not re.fullmatch(r"[0-9a-fA-F]{40}", remote_fields[0]):
+                raise RuntimeError("Fresh analysis requires an exact remote branch advertisement")
+            try:
                 await self._git(
-                    "fetch", "origin", f"+{name}:refs/remotes/origin/{name}", cwd=repository,
+                    "fetch", "origin", f"+{branch_name}:{tracking_ref}", cwd=repository,
                     timeout=settings.GIT_FETCH_TIMEOUT, project_key=project_key,
                 )
+            except RuntimeError:
+                remaining = (await self._git(
+                    "ls-remote", "--heads", "origin", branch_ref, cwd=repository,
+                    timeout=settings.GIT_FETCH_TIMEOUT, project_key=project_key,
+                )).strip()
+                if remaining:
+                    raise
+                await self._git("update-ref", "-d", tracking_ref, cwd=repository)
+                logger.info("Fresh analysis branch %s disappeared during fetch; removed its stale tracking reference", branch_name)
+                return
             old_sha = (await self._git("rev-parse", "--verify", f"refs/remotes/origin/{branch_name}", cwd=repository)).strip()
             default_sha = (await self._git("rev-parse", "--verify", f"refs/remotes/origin/{default_branch}", cwd=repository)).strip()
             if not all(re.fullmatch(r"[0-9a-fA-F]{40}", value) for value in (old_sha, default_sha)):
                 raise RuntimeError("Fresh analysis requires verified remote branch commits")
+            if old_sha != remote_fields[0]:
+                raise RuntimeError("Remote requirement branch changed during fresh analysis preparation")
             if old_sha == default_sha:
                 return
             backup_ref = f"refs/tags/forgexa/fresh-analysis-backup/{branch_name}/{old_sha}"
@@ -13970,6 +13998,7 @@ class RuntimeDaemon:
 
         after_sha = str((result.git or {}).get("commit_sha") or before_sha or "").strip()
         committed_sources: dict[str, str] = {}
+        unavailable_sources: list[dict[str, str]] = []
         source_bytes = 0
         coverage = {
             "candidate_files": 0, "full_source_files": 0, "unreadable_files": 0,
@@ -13998,6 +14027,27 @@ class RuntimeDaemon:
                         "test-cases.json", "coverage-matrix.json", "test-evidence.json", "test-report.md",
                     }
                 ))
+                if output_dir.startswith(f"docs/requirements/{task.requirement_key}/") and ".." not in Path(output_dir).parts:
+                    verification_dir = output_dir + "/verification"
+                    try:
+                        verification_paths = await self.workspace_manager._git(
+                            "ls-tree", "-r", "--name-only", "-z", after_sha, "--", *asset_paths, verification_dir,
+                            cwd=workspace_path, timeout=10,
+                        )
+                        if len(verification_paths.encode("utf-8")) > _RUNTIME_CRITIC_SOURCE_MAX_BYTES:
+                            raise ValueError("Committed verification inventory exceeds its bounded evidence budget")
+                        existing_artifacts = set(verification_paths.split("\0"))
+                        asset_paths = [path for path in asset_paths if path in existing_artifacts]
+                        paths.extend(path for path in verification_paths.split("\0") if (
+                            path.startswith(verification_dir + "/") and ".." not in Path(path).parts
+                            and re.fullmatch(r"[A-Za-z0-9_./-]+", path)
+                            and Path(path).suffix.lower() in {".php", ".py", ".ts", ".js", ".json", ".md", ".txt"}
+                            and not _is_sensitive_local_path(path)
+                            and Path(path).name.lower() not in {"env.php", "auth.json", "credentials.json", "secrets.json", "service-account.json"}
+                            and not any(part in {".git", ".forgexa", ".aws", ".ssh", ".env"} or part.startswith(".env.") for part in Path(path).parts)
+                        ))
+                    except Exception:
+                        coverage["verification_inventory_unavailable"] = True
                 paths.extend(asset_paths)
                 support_dirs = sorted({(Path(path).parent / "support").as_posix() for path in asset_paths if path.startswith("tests/")})
                 for directory in support_dirs[:5]:
@@ -14089,8 +14139,19 @@ class RuntimeDaemon:
                     source = await self.workspace_manager._git(
                         "show", f"{after_sha}:{path}", cwd=workspace_path, timeout=10,
                     )
-                except Exception:
+                except Exception as error:
                     coverage["unreadable_files"] += 1
+                    detail = str(error).lower()
+                    reason = "source_git_read_failed"
+                    if isinstance(error, UnicodeDecodeError):
+                        reason = "source_encoding_unavailable"
+                    elif isinstance(error, TimeoutError) or "timed out after" in detail:
+                        reason = "source_read_timeout"
+                    elif "cannot be mapped" in detail or "cannot allocate memory" in detail:
+                        reason = "source_memory_unavailable"
+                    elif "does not exist in" in detail or "exists on disk, but not in" in detail:
+                        reason = "source_path_unavailable"
+                    unavailable_sources.append({"path": path, "reason": reason})
                     continue
                 encoded_size = len(source.encode("utf-8"))
                 if source_bytes + encoded_size <= _RUNTIME_CRITIC_SOURCE_MAX_BYTES:
@@ -14108,7 +14169,10 @@ class RuntimeDaemon:
                 diff = (diff or "No new changes; review committed delivery instead.") + "".join(source_context)
         coverage["full_source_files"] = len(committed_sources)
         coverage["omitted_files"] = coverage["candidate_files"] - coverage["full_source_files"]
-        coverage["capsule_incomplete"] = coverage["omitted_files"] > 0 or coverage.get("reference_inventory_unavailable", False)
+        coverage["capsule_incomplete"] = (
+            coverage["omitted_files"] > 0 or coverage.get("reference_inventory_unavailable", False)
+            or coverage.get("verification_inventory_unavailable", False)
+        )
         result.metrics["runtime_critic_coverage"] = coverage
         if not diff:
             return {
@@ -14136,6 +14200,8 @@ class RuntimeDaemon:
             work_item={},
         )
         review_task.input_prompt += "\n## Review Evidence Coverage\n" + json.dumps(coverage, sort_keys=True)
+        if unavailable_sources:
+            review_task.input_prompt += "\n## Unavailable Committed Sources\n" + json.dumps(unavailable_sources, sort_keys=True)
         if coverage["capsule_incomplete"]:
             review_task.input_prompt += (
                 "\nSome candidate files were not available as complete source. Assess the evidence you can inspect; "
@@ -14155,6 +14221,7 @@ class RuntimeDaemon:
                 "reviewed_commit_sha": after_sha,
                 "baseline_fingerprint": baseline.get("fingerprint") if isinstance(baseline, dict) else None,
                 "input_sha256": hashlib.sha256(review_task.input_prompt.encode("utf-8")).hexdigest(),
+                "unavailable_sources": unavailable_sources,
                 "snapshots": [
                     {"path": path, "sha256": hashlib.sha256(source.encode("utf-8")).hexdigest(),
                      "bytes": len(source.encode("utf-8"))}

{forgexa_cli-1.84.4 → forgexa_cli-1.85.1}/forgexa_cli.egg-info/PKG-INFO

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

{forgexa_cli-1.84.4 → forgexa_cli-1.85.1}/pyproject.toml

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