forgexa-cli 1.18.12__tar.gz → 1.20.0__tar.gz

{forgexa_cli-1.18.12 → forgexa_cli-1.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.18.12
+Version: 1.20.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.18.12 → forgexa_cli-1.20.0}/forgexa_cli/__init__.py

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

{forgexa_cli-1.18.12 → forgexa_cli-1.20.0}/forgexa_cli/daemon.py

@@ -555,7 +555,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.18.12"
+DAEMON_VERSION = "1.20.0"
 
 
 def _detect_client_type() -> str:
@@ -3520,16 +3520,20 @@ def _kill_proc(proc: asyncio.subprocess.Process) -> None:
 
 
 class _IdleTimeoutError(asyncio.TimeoutError):
-    """Raised when an agent process produces no stdout for longer than AGENT_IDLE_TIMEOUT.
+    """Raised when an agent produces no observable activity for AGENT_IDLE_TIMEOUT.
 
     Subclasses asyncio.TimeoutError so existing ``except asyncio.TimeoutError``
     handlers catch it, but callers can distinguish it from an absolute wall-clock
     timeout via ``isinstance(exc, _IdleTimeoutError)`` or ``exc.idle_seconds``.
+    Partial output is attached before propagation so the failure report retains
+    the evidence needed to diagnose the blocked operation.
     """
 
     def __init__(self, idle_seconds: float) -> None:
         super().__init__(f"idle:{idle_seconds:.0f}s")
         self.idle_seconds = idle_seconds
+        self.stdout = ""
+        self.stderr = ""
 
 
 def _workspace_has_recent_activity(
@@ -4202,13 +4206,15 @@ class ProcessManager:
           not killed while actively producing output.
         - on_chunk(lines) is called with each decoded line so the caller can
           forward to the progress reporter without waiting for completion.
-        - Idle timeout: if the agent produces no stdout for AGENT_IDLE_TIMEOUT
-          seconds the code checks for filesystem activity in workspace_path
+        - Idle timeout: if the agent produces no stdout or stderr bytes for
+          AGENT_IDLE_TIMEOUT seconds the code checks for filesystem activity in
+          workspace_path
           before deciding to kill.  If files were recently modified the agent
           is doing silent work (npm install, compilation, test runs, etc.) and
-          the idle timer is reset.  Only when BOTH stdout AND the filesystem
-          are idle does the process get killed.  This eliminates false-positive
-          kills at the idle boundary.
+          the idle timer is reset.  Only when output and the filesystem are
+          idle does the process get killed. Reading byte chunks rather than
+          lines is important: JSON and progress streams are not guaranteed to
+          flush a newline while the agent is working.
         - Absolute timeout (``timeout`` param): hard ceiling for zombie-process
           prevention.  Always kills at this boundary (no extension), but logs
           filesystem activity status for post-mortem observability.
@@ -4227,38 +4233,42 @@ class ProcessManager:
                 pass
             proc.stdin.close()
 
-        stdout_lines: list[str] = []
+        stdout_chunks: list[bytes] = []
         stderr_chunks: list[bytes] = []
 
         async def _read_stderr():
             if not proc.stderr:
                 return
-            if stream_stderr:
-                # Agent (e.g. Kimi Code 0.18.0+) writes real-time progress to
-                # stderr.  Read line-by-line and forward to on_chunk so the
-                # user sees output immediately.  Also reset the idle timer so
-                # the agent is not killed while actively working on stderr.
-                while True:
-                    line_bytes = await proc.stderr.readline()
-                    if not line_bytes:
-                        break
-                    stderr_chunks.append(line_bytes)
-                    line = line_bytes.decode(errors="replace").rstrip("\n")
-                    if line:
-                        _last_activity_at[0] = time.monotonic()
-                        stdout_lines.append(line)
-                        if on_chunk:
+            pending_line = ""
+            while True:
+                data = await proc.stderr.read(4096)
+                if not data:
+                    break
+                # Stderr often contains startup, authentication, and transport
+                # progress. It is an activity signal even when it is not shown
+                # in the live execution panel.
+                _last_activity_at[0] = time.monotonic()
+                stderr_chunks.append(data)
+                if stream_stderr:
+                    pending_line += data.decode(errors="replace")
+                    complete, separator, pending_line = pending_line.rpartition("\n")
+                    if separator and complete:
+                        lines = [line for line in complete.split("\n") if line]
+                        if lines and on_chunk:
                             try:
-                                await on_chunk([line])
+                                await on_chunk(lines)
                             except Exception:
                                 pass
-            else:
-                data = await proc.stderr.read()
-                stderr_chunks.append(data)
+            if stream_stderr and pending_line and on_chunk:
+                try:
+                    await on_chunk([pending_line])
+                except Exception:
+                    pass
 
         async def _read_stdout():
             if not proc.stdout:
                 return
+            pending_line = ""
             while True:
                 # ── Timeout checks ────────────────────────────────────────────
                 now = time.monotonic()
@@ -4304,7 +4314,7 @@ class ProcessManager:
                     else:
                         # No stdout AND no filesystem activity → truly hung.
                         logger.warning(
-                            "Task %s agent idle %.0fs — no stdout, no "
+                            "Task %s agent idle %.0fs — no output, no "
                             "filesystem activity; killing hung process",
                             task_id, idle_elapsed,
                         )
@@ -4319,17 +4329,17 @@ class ProcessManager:
                     30.0,
                 )
 
-                # ── Read one line with a bounded wait ─────────────────────────
+                # ── Read available bytes with a bounded wait ───────────────────
                 try:
-                    line_bytes = await asyncio.wait_for(
-                        proc.stdout.readline(), timeout=check_interval
+                    data = await asyncio.wait_for(
+                        proc.stdout.read(4096), timeout=check_interval
                     )
                 except asyncio.TimeoutError:
-                    # readline timed out within check_interval — no new output
-                    # yet.  Loop back to re-evaluate idle/absolute conditions.
+                    # No new output yet. Loop back to re-evaluate idle/absolute
+                    # conditions.
                     continue
                 except (ValueError, asyncio.LimitOverrunError, Exception) as exc:
-                    # Line exceeded stream buffer limit — drain remaining bulk.
+                    # Stream read error — drain remaining bulk.
                     logger.warning(
                         "Stream read error for task %s (%s: %s), draining remaining output",
                         task_id, type(exc).__name__, exc,
@@ -4339,28 +4349,27 @@ class ProcessManager:
                     except Exception:
                         remaining = b""
                     if remaining:
-                        for chunk_line in remaining.decode(errors="replace").split("\n"):
-                            if chunk_line:
-                                stdout_lines.append(chunk_line)
-                                if on_chunk:
-                                    try:
-                                        await on_chunk([chunk_line])
-                                    except Exception:
-                                        pass
+                        stdout_chunks.append(remaining)
                     break
 
-                if not line_bytes:
+                if not data:
                     break  # EOF — process exited normally
 
                 # ── New output received — reset idle timer ────────────────────
                 _last_activity_at[0] = time.monotonic()
-                line = line_bytes.decode(errors="replace").rstrip("\n")
-                stdout_lines.append(line)
-                if on_chunk:
+                stdout_chunks.append(data)
+                pending_line += data.decode(errors="replace")
+                complete, separator, pending_line = pending_line.rpartition("\n")
+                if separator and complete and on_chunk:
                     try:
-                        await on_chunk([line])
+                        await on_chunk([line for line in complete.split("\n") if line])
                     except Exception:
                         pass  # never let on_chunk crash the agent run
+            if pending_line and on_chunk:
+                try:
+                    await on_chunk([pending_line])
+                except Exception:
+                    pass
 
         try:
             # Outer wait_for uses timeout+idle_timeout as generous safety net.
@@ -4376,18 +4385,23 @@ class ProcessManager:
             _kill_proc(proc)
             # Drain any remaining output after kill
             try:
-                remaining, _ = await asyncio.wait_for(proc.communicate(), timeout=5)
+                remaining, remaining_stderr = await asyncio.wait_for(proc.communicate(), timeout=5)
                 if remaining:
-                    for line in remaining.decode(errors="replace").split("\n"):
-                        if line:
-                            stdout_lines.append(line)
+                    stdout_chunks.append(remaining)
+                if remaining_stderr:
+                    stderr_chunks.append(remaining_stderr)
             except Exception:
                 pass
+            if isinstance(_exc, _IdleTimeoutError):
+                _exc.stdout = b"".join(stdout_chunks).decode(errors="replace")
+                _exc.stderr = b"".join(stderr_chunks).decode(errors="replace")
             raise  # re-raise (_IdleTimeoutError preserves subclass type)
 
         await proc.wait()
-        stdout = "\n".join(stdout_lines)
-        stderr = (stderr_chunks[0] if stderr_chunks else b"").decode(errors="replace")
+        stdout = b"".join(stdout_chunks).decode(errors="replace")
+        stderr = b"".join(stderr_chunks).decode(errors="replace")
+        if stream_stderr and stderr:
+            stdout = "\n".join(part for part in (stdout, stderr) if part)
         return stdout, stderr, proc.returncode or 0
 
     async def _run_claude(
@@ -4515,10 +4529,17 @@ class ProcessManager:
         except asyncio.TimeoutError as exc:
             _kill_proc(self.active_processes.pop(task_id, None) or proc)
             _err = (
-                f"Agent idle for {exc.idle_seconds:.0f}s without output — process terminated. "
-                "Task may require more context decomposition or a different agent."
+                f"Agent produced no stdout, stderr, or workspace changes for "
+                f"{exc.idle_seconds:.0f}s — process terminated. Inspect retained "
+                "output and the daemon log for the blocked operation."
             ) if isinstance(exc, _IdleTimeoutError) else f"Timed out after {timeout}s (absolute limit)"
-            return TaskResult(status="failed", exit_code=-1, stdout="", stderr="", error=_err)
+            return TaskResult(
+                status="failed",
+                exit_code=-1,
+                stdout=getattr(exc, "stdout", "")[-settings.AGENT_MAX_OUTPUT_SIZE:],
+                stderr=getattr(exc, "stderr", "")[-10000:],
+                error=_err,
+            )
         except Exception as exc:
             logger.exception("Claude stream error for task %s", task_id)
             if task_id in self.active_processes:
@@ -5314,10 +5335,17 @@ class ProcessManager:
         except asyncio.TimeoutError as exc:
             _kill_proc(self.active_processes.pop(task_id, None) or proc)
             _err = (
-                f"Agent idle for {exc.idle_seconds:.0f}s without output — process terminated. "
-                "Task may require more context decomposition or a different agent."
+                f"Agent produced no stdout, stderr, or workspace changes for "
+                f"{exc.idle_seconds:.0f}s — process terminated. Inspect retained "
+                "output and the daemon log for the blocked operation."
             ) if isinstance(exc, _IdleTimeoutError) else f"Timed out after {timeout}s (absolute limit)"
-            return TaskResult(status="failed", exit_code=-1, stdout="", stderr="", error=_err)
+            return TaskResult(
+                status="failed",
+                exit_code=-1,
+                stdout=getattr(exc, "stdout", "")[-settings.AGENT_MAX_OUTPUT_SIZE:],
+                stderr=getattr(exc, "stderr", "")[-10000:],
+                error=_err,
+            )
         except Exception as exc:
             logger.exception("Copilot stream error for task %s", task_id)
             if task_id in self.active_processes:
@@ -5383,10 +5411,17 @@ class ProcessManager:
         except asyncio.TimeoutError as exc:
             _kill_proc(self.active_processes.pop(task_id, None) or proc)
             _err = (
-                f"Agent idle for {exc.idle_seconds:.0f}s without output — process terminated. "
-                "Task may require more context decomposition or a different agent."
+                f"Agent produced no stdout, stderr, or workspace changes for "
+                f"{exc.idle_seconds:.0f}s — process terminated. Inspect retained "
+                "output and the daemon log for the blocked operation."
             ) if isinstance(exc, _IdleTimeoutError) else f"Timed out after {timeout}s (absolute limit)"
-            return TaskResult(status="failed", exit_code=-1, stdout="", stderr="", error=_err)
+            return TaskResult(
+                status="failed",
+                exit_code=-1,
+                stdout=getattr(exc, "stdout", "")[-settings.AGENT_MAX_OUTPUT_SIZE:],
+                stderr=getattr(exc, "stderr", "")[-10000:],
+                error=_err,
+            )
         except Exception as exc:
             logger.exception("CLI stream error for task %s", task_id)
             if task_id in self.active_processes:
@@ -5460,6 +5495,13 @@ class ProcessManager:
                     pass
             if data.get("duration_ms") and "duration_seconds" not in metrics:
                 metrics["duration_seconds"] = data["duration_ms"] / 1000.0
+            # Turn usage (Claude CLI result event) — baseline telemetry for
+            # node-type turn budgeting (see test-script quality audit M0).
+            if data.get("num_turns") and "num_turns" not in metrics:
+                try:
+                    metrics["num_turns"] = int(data["num_turns"])
+                except (TypeError, ValueError):
+                    pass
 
         # ── 3. Prefer "result" type line — most authoritative ──
         for data in reversed(parsed):
@@ -6662,6 +6704,146 @@ class ServerConnection:
 # ── Main Daemon ──
 
 
+def _categorize_validation_issue(issue: str) -> str:
+    """Map a free-text validation issue to a stable category for telemetry.
+
+    Baseline data for the test-script quality initiative (M0): lets us rank
+    validation failure modes without parsing free text. Order matters —
+    specific patterns are checked before generic ones.
+    """
+    text = issue.lower()
+    if "script_content" in text:
+        return "empty_script_content"
+    if "script_path" in text and "does not exist" in text:
+        return "missing_script_file"
+    if "not valid json" in text:
+        return "invalid_json"
+    if "e2e" in text and "test case" in text:
+        return "missing_e2e_case"
+    if "coverage" in text:
+        return "coverage_gap"
+    if "scope" in text and "violation" in text:
+        return "scope_violation"
+    if "missing" in text or "not found" in text:
+        return "missing_file"
+    if "is empty" in text:
+        return "empty_file"
+    return "other"
+
+
+def _extract_testing_artifacts(workspace_path: Path, output_dir: str) -> dict | None:
+    """Summarize test-cases.json artifact counts for telemetry (best effort).
+
+    Returns None when the file is missing/unparseable; never raises.
+    """
+    try:
+        tc_path = workspace_path / output_dir / "test-cases.json"
+        if not output_dir or not tc_path.exists():
+            return None
+        data = json.loads(tc_path.read_text(encoding="utf-8"))
+        cases = data.get("test_cases") or []
+        by_type: dict[str, int] = {}
+        scripted = 0
+        e2e_scripted = 0
+        for case in cases:
+            if not isinstance(case, dict):
+                continue
+            case_type = (case.get("test_type") or "unknown").lower()
+            by_type[case_type] = by_type.get(case_type, 0) + 1
+            if (case.get("script_content") or "").strip():
+                scripted += 1
+                if case_type == "e2e":
+                    e2e_scripted += 1
+        return {
+            "total_cases": len(cases),
+            "by_type": by_type,
+            "scripted_cases": scripted,
+            "e2e_scripted": e2e_scripted,
+        }
+    except Exception:
+        logger.debug("testing artifact telemetry extraction failed", exc_info=True)
+        return None
+
+
+def _validate_test_evidence(
+    base: Path, workspace_path: Path, e2e_case_ids: list[str], max_anchor_checks: int = 50
+) -> list[str]:
+    """Validate the M1 evidence bundle (test-evidence.json) for e2e test cases.
+
+    Deterministic, zero-environment checks: file exists and parses, locators/
+    routes are present, every e2e case has a case_evidence entry, and each
+    evidence anchor is a literal string that actually appears in its declared
+    source_file (rejects invented selectors/routes). Items explicitly marked
+    runtime_evidence_required are exempt from anchor checks by design.
+    """
+    issues: list[str] = []
+    ev_path = base / "test-evidence.json"
+    if not ev_path.exists():
+        return [
+            "test-evidence.json not found. It is MANDATORY when test-intent.json "
+            "has e2e intents: record every route/selector used by E2E scripts with "
+            "source_file + anchor (a literal string copied from that file), plus "
+            "case_evidence mapping each e2e test case to its route/locator refs."
+        ]
+    try:
+        ev = json.loads(ev_path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, UnicodeDecodeError) as e:
+        return [f"test-evidence.json is not valid JSON: {e}"]
+
+    locators = ev.get("locators") or []
+    routes = ev.get("routes") or []
+    if not locators and not routes:
+        issues.append(
+            "test-evidence.json has no 'locators' or 'routes' entries — E2E scripts "
+            "must ground their selectors/routes in source-file evidence."
+        )
+
+    case_evidence = ev.get("case_evidence") or []
+    covered_ids = {
+        str(entry.get("test_case_id"))
+        for entry in case_evidence
+        if isinstance(entry, dict) and entry.get("test_case_id")
+    }
+    missing_cases = [cid for cid in e2e_case_ids if cid not in covered_ids]
+    if missing_cases:
+        issues.append(
+            f"test-evidence.json missing case_evidence for e2e test cases: "
+            f"{missing_cases[:10]}. Each e2e test case needs a case_evidence entry "
+            f"with route_refs/locator_refs."
+        )
+
+    checked = 0
+    for item in list(locators) + list(routes):
+        if checked >= max_anchor_checks:
+            break
+        if not isinstance(item, dict) or item.get("runtime_evidence_required"):
+            continue
+        checked += 1
+        label = item.get("selector") or item.get("path") or item.get("id") or "?"
+        src = (item.get("source_file") or "").strip()
+        anchor = (item.get("anchor") or "").strip()
+        if not src or not anchor:
+            issues.append(
+                f"evidence item '{label}' missing 'source_file' or 'anchor' — "
+                f"anchor must be a literal string copied from source_file."
+            )
+            continue
+        fpath = workspace_path / src
+        if not fpath.exists():
+            issues.append(f"evidence source_file not found: '{src}' (for '{label}')")
+            continue
+        try:
+            content = fpath.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+        if anchor not in content:
+            issues.append(
+                f"evidence anchor not found in '{src}': '{anchor[:80]}' (for '{label}'). "
+                f"Copy the exact literal from the source file — do not paraphrase."
+            )
+    return issues
+
+
 class RuntimeDaemon:
     """Main Daemon orchestrator — runs on the host machine.
 
@@ -8422,6 +8604,7 @@ class RuntimeDaemon:
                     # Not gated by _requires_structured_artifacts so that bugfix with e2e
                     # intents gets the same E2E chain validation as feature/improvement.
                     _e2e_intent_ids: set[str] = set()
+                    _e2e_case_ids: list[str] = []
                     _analysis_dir = (
                         _input.get("analysis_output_dir")
                         or (_input.get("context") or {}).get("analysis_output_dir")
@@ -8458,6 +8641,13 @@ class RuntimeDaemon:
                         try:
                             tc_data = _json.loads(tc_path.read_text(encoding="utf-8"))
                             cases = tc_data.get("test_cases", [])
+                            _e2e_case_ids = [
+                                str(_tc.get("id"))
+                                for _tc in cases
+                                if isinstance(_tc, dict)
+                                and (_tc.get("test_type") or "").lower() == "e2e"
+                                and _tc.get("id")
+                            ]
                             if not cases:
                                 issues.append("test-cases.json exists but contains no test cases")
                             else:
@@ -8545,6 +8735,15 @@ class RuntimeDaemon:
                     elif _requires_structured_artifacts or _requires_e2e_artifacts:
                         issues.append(f"coverage-matrix.json not found in {doc_dir or 'workspace root'}")
 
+                    # --- test-evidence.json validation (M1 evidence bundle) ---
+                    # Required whenever e2e intents exist: every route/selector
+                    # used by E2E scripts must be grounded in source-file evidence
+                    # (anchor literals are verified against the declared files).
+                    if _requires_e2e_artifacts:
+                        issues.extend(
+                            _validate_test_evidence(base, workspace_path, _e2e_case_ids)
+                        )
+
                     # --- test-report.md validation ---
                     report_path = base / "test-report.md"
                     if not report_path.exists():
@@ -8862,6 +9061,9 @@ class RuntimeDaemon:
                 )
             issues = self._validate_outputs(workspace_path, task, result)
             if not issues:
+                self._record_testing_telemetry(
+                    workspace_path, task, result, retries_used=attempt
+                )
                 return result  # All validations passed
 
             issues_text = "\n".join(f"- {iss}" for iss in issues)
@@ -8996,8 +9198,38 @@ class RuntimeDaemon:
                     len(remaining), max_retries, task.task_id,
                 )
             result.metrics["validation_issues"] = remaining
+        self._record_testing_telemetry(workspace_path, task, result, retries_used=max_retries)
         return result
 
+    def _record_testing_telemetry(
+        self, workspace_path: Path, task: TaskInfo, result: TaskResult, retries_used: int
+    ) -> None:
+        """Attach validation/testing telemetry to result.metrics (best effort).
+
+        M0 baseline for the test-script quality initiative: validation retry
+        usage, stable failure categories, and testing artifact counts. These
+        travel with the completion payload (metrics are kept in full by the
+        backend) so baselines can be built without parsing free text.
+        Never raises.
+        """
+        try:
+            result.metrics["validation_retries_used"] = retries_used
+            issues = result.metrics.get("validation_issues") or []
+            if issues:
+                result.metrics["validation_issue_categories"] = sorted(
+                    {_categorize_validation_issue(str(issue)) for issue in issues}
+                )
+            if task.node_type != "testing":
+                return
+            input_data = task.input_data or {}
+            context = input_data.get("context") or {}
+            output_dir = input_data.get("output_dir") or context.get("output_dir") or ""
+            artifacts = _extract_testing_artifacts(workspace_path, output_dir)
+            if artifacts:
+                result.metrics["testing_artifacts"] = artifacts
+        except Exception:
+            logger.debug("testing telemetry recording failed", exc_info=True)
+
     async def _collect_analysis_artifacts(
         self, workspace_path: Path, task: TaskInfo, result: TaskResult
     ) -> None:
@@ -9213,7 +9445,19 @@ class RuntimeDaemon:
         workspace_path: Path,
         *diff_args: str,
     ) -> str | None:
-        """Reject Git changes that alter only file modes, not file contents."""
+        """Detect Git changes that alter only a file's mode, not its content.
+
+        Every Forgexa-managed workspace is configured with
+        ``core.filemode=false`` (see ``_prepare_workspace``), which makes Git
+        ignore on-disk executable-bit drift entirely for ``git status``/
+        ``git diff``/``git add`` — incidental permission noise from
+        checkouts, worktree creation, or file-rewrite tools can never reach
+        the diff/index we inspect here. The ONLY way a mode-only change can
+        appear is a deliberate ``git update-index --chmod=...`` (e.g. an
+        agent restoring a shell script's executable bit that a prior commit
+        lost). That is legitimate, intentional work — not noise — so it
+        must be allowed to commit; we only log it for audit visibility.
+        """
         proc = await asyncio.create_subprocess_exec(
             "git", "diff", "--raw", "--no-abbrev", "--no-renames", "-z", *diff_args,
             cwd=str(workspace_path),
@@ -9240,17 +9484,18 @@ class RuntimeDaemon:
             if old_object == new_object and old_mode != new_mode:
                 mode_only_paths.append(path)
 
-        if not mode_only_paths:
-            return None
+        if mode_only_paths:
+            sample = ", ".join(mode_only_paths[:5])
+            remainder = "" if len(mode_only_paths) <= 5 else ", ..."
+            logger.info(
+                "Auto-commit includes %d permission-only file change(s) with "
+                "unchanged content (%s%s) — allowing (core.filemode=false means "
+                "this can only come from a deliberate executable-bit fix, not "
+                "incidental noise).",
+                len(mode_only_paths), sample, remainder,
+            )
 
-        sample = ", ".join(mode_only_paths[:5])
-        remainder = "" if len(mode_only_paths) <= 5 else ", ..."
-        return (
-            "Auto-commit blocked: detected "
-            f"{len(mode_only_paths)} permission-only file change(s) with unchanged content "
-            f"({sample}{remainder}). Restore the original modes before retrying; "
-            "Forgexa does not auto-commit permission-only changes."
-        )
+        return None
 
     async def _auto_commit(
         self,

{forgexa_cli-1.18.12 → forgexa_cli-1.20.0}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.18.12
+Version: 1.20.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.18.12 → forgexa_cli-1.20.0}/pyproject.toml

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