forgexa-cli 1.67.1__tar.gz → 1.68.1__tar.gz

{forgexa_cli-1.67.1 → forgexa_cli-1.68.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.67.1
+Version: 1.68.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.67.1 → forgexa_cli-1.68.1}/forgexa_cli/__init__.py

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

{forgexa_cli-1.67.1 → forgexa_cli-1.68.1}/forgexa_cli/agent_core.py

@@ -3753,7 +3753,13 @@ def is_copilot_model_discovery_auth_error(*messages: str | None) -> bool:
 def is_runtime_resource_exhaustion_error(*messages: str | None) -> bool:
     """Return whether the OS refused an agent process, thread, or file watch."""
     detail = " ".join(str(message or "").lower() for message in messages)
-    return any(
+    return (
+        any(pattern in detail for pattern in (
+            "failed to spawn thread",
+            "failed to start task transition watcher",
+        ))
+        and "resource temporarily unavailable" in detail
+    ) or any(
         pattern in detail
         for pattern in (
             "can't spawn worker thread",
@@ -3778,23 +3784,35 @@ def collect_runtime_resource_metrics(
         return metrics
 
     proc_path = Path(proc_root)
-    cgroup_path = Path(cgroup_root)
-    constraints: list[tuple[str, int, int]] = []
+    cgroup_path = Path(cgroup_root).resolve()
+    constraints: list[tuple[str, int, int, Path | None]] = []
 
     try:
         for line in (proc_path / "self" / "cgroup").read_text().splitlines():
             hierarchy, controllers, relative_path = line.split(":", 2)
             relative = relative_path.lstrip("/")
             if hierarchy == "0" and not controllers:
-                pid_dir = cgroup_path / relative
+                controller_root = cgroup_path
             elif "pids" in controllers.split(","):
-                pid_dir = cgroup_path / "pids" / relative
+                controller_root = (cgroup_path / "pids").resolve()
             else:
                 continue
-            current_text = (pid_dir / "pids.current").read_text().strip()
-            maximum_text = (pid_dir / "pids.max").read_text().strip()
-            if maximum_text != "max":
-                constraints.append(("cgroup", int(current_text), int(maximum_text)))
+            pid_dir = (controller_root / relative).resolve()
+            if not pid_dir.is_relative_to(controller_root):
+                continue
+            while True:
+                try:
+                    current_text = (pid_dir / "pids.current").read_text().strip()
+                    maximum_text = (pid_dir / "pids.max").read_text().strip()
+                    if maximum_text != "max":
+                        constraints.append((
+                            "cgroup", int(current_text), int(maximum_text), pid_dir,
+                        ))
+                except (OSError, ValueError):
+                    pass
+                if pid_dir == controller_root:
+                    break
+                pid_dir = pid_dir.parent
             break
     except (OSError, ValueError):
         pass
@@ -3819,12 +3837,12 @@ def collect_runtime_resource_metrics(
                         user_threads += threads
                 except (OSError, ValueError, IndexError):
                     continue
-            constraints.append(("rlimit_nproc", user_threads, int(soft_limit)))
+            constraints.append(("rlimit_nproc", user_threads, int(soft_limit), None))
     except (ImportError, OSError, ValueError):
         pass
 
     if constraints:
-        source, current, limit = min(
+        source, current, limit, limit_path = min(
             constraints,
             key=lambda item: item[2] - item[1],
         )
@@ -3834,6 +3852,20 @@ def collect_runtime_resource_metrics(
             "process_limit": limit,
             "process_remaining": max(0, limit - current),
         })
+        if limit_path is not None:
+            metrics["process_limit_path"] = str(limit_path)
+            try:
+                for line in (limit_path / "pids.events").read_text().splitlines():
+                    name, value = line.split()
+                    if name == "max":
+                        metrics["process_limit_hits"] = int(value)
+                        break
+            except (OSError, ValueError):
+                pass
+            try:
+                metrics["process_peak"] = int((limit_path / "pids.peak").read_text().strip())
+            except (OSError, ValueError):
+                pass
 
     try:
         for line in (proc_path / "meminfo").read_text().splitlines():
@@ -3873,7 +3905,7 @@ def collect_runtime_resource_metrics(
 def runtime_resource_exhaustion_reason(metrics: dict[str, Any]) -> str | None:
     """Return a blocking reason when the OS cannot safely start an agent."""
     process_remaining = metrics.get("process_remaining")
-    if isinstance(process_remaining, int) and process_remaining < 32:
+    if isinstance(process_remaining, int) and process_remaining < 64:
         return (
             f"Only {process_remaining} process/thread slots remain "
             f"({metrics.get('process_current')}/{metrics.get('process_limit')} used via "

{forgexa_cli-1.67.1 → forgexa_cli-1.68.1}/forgexa_cli/aws_logs_evidence.py

@@ -31,7 +31,7 @@ def select_attachment(evidence, event_ids, ranges, attachment_id):
     available = {event["event_ref"]: event for event in evidence["events"]}
     if len(event_ids) != len(set(event_ids)) or set(event_ids) - available.keys() or set(ranges) - set(event_ids):
         raise ValueError("aws_logs_selection_invalid")
-    if not event_ids and evidence["events"]:
+    if not event_ids:
         raise ValueError("aws_logs_selection_required")
     selected = []
     for event_id in event_ids:
@@ -114,6 +114,8 @@ def validate_payload(reference, metadata, payload):
     events = evidence.get("events")
     if not isinstance(sources, list) or not 1 <= len(sources) <= 4 or not isinstance(events, list) or len(events) > 1000:
         raise ValueError("aws_evidence_size_limit")
+    if not events:
+        raise ValueError("aws_logs_selection_required")
     identities = set()
     for source in sources:
         if not isinstance(source, dict) or source.get("source_ref") in identities or not re.fullmatch(r"AWS-L1-S\d+", str(source.get("source_ref", ""))):

{forgexa_cli-1.67.1 → forgexa_cli-1.68.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.67.1"
+DAEMON_VERSION = "1.68.1"
 
 
 def _detect_client_type() -> str:
@@ -1624,6 +1624,7 @@ class TaskInfo:
     runtime_evidence_plan: dict | None = None
     local_evidence_upload: bool = False
     critic_review_required: bool = False
+    local_untracked_paths: set[str] = field(default_factory=set, repr=False)
 
 
 @dataclass
@@ -2612,6 +2613,8 @@ def _read_local_bind_shared_output_snapshot(task_id: str) -> dict | None:
             start = max(total_bytes - _LOCAL_BIND_SHARED_OUTPUT_MAX_BYTES, 0)
             output_file.seek(start)
             raw = output_file.read()
+    except FileNotFoundError:
+        return None
     except OSError as exc:
         logger.warning("Failed to read local-bind output log for task %s: %s", task_id, exc)
         return None
@@ -3650,8 +3653,9 @@ class WorkspaceManager:
         """Resolve the workspace path for a workspace_resolution="local_bind" task.
 
         Validates the daemon-private mapping entry (binding_id -> local_path),
-        the directory's git remote identity, and its branch/cleanliness
-        state. Ordinary local-bind tasks perform NO destructive git operation
+        the directory's git remote identity, branch, and tracked changes.
+        Pre-existing untracked and ignored files remain user-owned and local.
+        Ordinary local-bind tasks perform NO destructive git operation
         (no reset --hard, clean, branch deletion, or implicit branch switch)
         on the user's real directory. The only exception is an explicitly
         authorized fresh-analysis reset, which has its own server marker,
@@ -3739,16 +3743,25 @@ class WorkspaceManager:
                 "will never switch branches in your real working directory automatically."
             )
 
-        status_output = await self._git("status", "--porcelain", cwd=local_path)
-        if status_output.strip():
-            dirty_paths = [line[3:] for line in status_output.splitlines() if line.strip()]
+        status_output = await self._git(
+            "status", "--porcelain=v1", "--untracked-files=no", "-z", cwd=local_path,
+        )
+        dirty_paths = _git_status_paths(status_output)
+        if dirty_paths:
             shown = ", ".join(dirty_paths[:20])
             more = f" (+{len(dirty_paths) - 20} more)" if len(dirty_paths) > 20 else ""
             raise RuntimeError(
-                "local_binding_unavailable: local directory has uncommitted changes, refusing "
-                f"to run: {shown}{more}"
+                "local_binding_unavailable: local directory has uncommitted tracked changes, "
+                f"refusing to overwrite user work: {shown}{more}. Commit or stash these "
+                "changes, then retry; unrelated untracked files do not need to be deleted."
             )
 
+        task.local_untracked_paths = {
+            path for path in (await self._git(
+                "ls-files", "--others", "-z", cwd=local_path,
+            )).split("\0") if path
+        }
+
         try:
             remote_branch = await self._git(
                 "ls-remote", "--heads", "origin", f"refs/heads/{target_branch}",
@@ -3784,8 +3797,12 @@ class WorkspaceManager:
                 await self._git("rev-parse", f"origin/{target_branch}", cwd=local_path)
             ).strip()
             if local_head != remote_head:
+                await self._check_local_untracked_overwrites(local_path, remote_head)
                 try:
-                    await self._git("merge", "--ff-only", f"origin/{target_branch}", cwd=local_path)
+                    await self._git(
+                        "merge", "--ff-only", "--no-overwrite-ignore",
+                        f"origin/{target_branch}", cwd=local_path,
+                    )
                 except RuntimeError as exc:
                     raise RuntimeError(
                         f"local_binding_unavailable: local branch '{target_branch}' cannot "
@@ -3866,6 +3883,33 @@ class WorkspaceManager:
 
         return local_path
 
+    async def _check_local_untracked_overwrites(self, local_path: Path, revision: str) -> None:
+        untracked_paths = {
+            path for path in (await self._git(
+                "ls-files", "--others", "-z", cwd=local_path,
+            )).split("\0") if path
+        }
+        if not untracked_paths:
+            return
+        target_paths = {
+            path for path in (await self._git(
+                "ls-tree", "-r", "--name-only", "-z", revision, cwd=local_path,
+            )).split("\0") if path
+        }
+        conflicts = {
+            path for path in target_paths if _is_preserved_local_path(path, untracked_paths)
+        }
+        conflicts.update(
+            path.rstrip("/") for path in untracked_paths
+            if _is_preserved_local_path(path.rstrip("/"), target_paths)
+        )
+        if conflicts:
+            raise RuntimeError(
+                "local_binding_unavailable: branch update would overwrite untracked or "
+                "ignored local files; no branch was updated. Preserve the conflicting "
+                f"files, then retry: {', '.join(sorted(conflicts)[:20])}"
+            )
+
     async def _reset_authorized_local_fresh_branch(
         self,
         local_path: Path,
@@ -3903,6 +3947,18 @@ class WorkspaceManager:
             )
             return
 
+        await self._check_local_untracked_overwrites(local_path, default_sha)
+        try:
+            await git(
+                "read-tree", "--dry-run", "-m", "-u", "HEAD", default_sha,
+                cwd=local_path,
+            )
+        except RuntimeError as exc:
+            raise RuntimeError(
+                "local_binding_unavailable: local fresh branch reset would overwrite local "
+                f"files; no branch was reset. Preserve the conflicting files, then retry: {exc}"
+            ) from exc
+
         backup_tag = f"forgexa/fresh-analysis-backup/{task_id}"
         await git("check-ref-format", f"refs/tags/{backup_tag}", cwd=local_path)
         remote_tag = await git(
@@ -3948,7 +4004,8 @@ class WorkspaceManager:
             ) from exc
 
         try:
-            await git("reset", "--hard", default_sha, cwd=local_path)
+            await self._check_local_untracked_overwrites(local_path, default_sha)
+            await git("reset", "--keep", default_sha, cwd=local_path)
         except RuntimeError as exc:
             try:
                 await git(
@@ -6563,6 +6620,18 @@ class ProcessManager:
                     "Fix ALL listed issues. Focus on the specific problems above."
                 )
 
+        if task.workspace_resolution == "local_bind":
+            prompt += (
+                "\n\n## Local Workspace Safety\n"
+                "This is the user's real working directory. Pre-existing untracked and "
+                "ignored files are user-owned, not task output. Preserve them: do not delete, "
+                "overwrite, stage, or commit them. Modify only tracked task files or create "
+                "new task files. If the task requires changing a pre-existing untracked "
+                "file, report the conflict instead of overwriting it. Never run git clean, "
+                "git reset --hard, force-push, or blanket staging such as git add -A. "
+                "Leave committing and pushing task changes to Forgexa."
+            )
+
         if workspace_path is not None:
             return agent_core.with_workspace_environment_guidance(
                 prompt, workspace_path,
@@ -7906,12 +7975,15 @@ class ProcessManager:
         # CREATE_NO_WINDOW covers this secondary check so Copilot always sees a fully
         # headless environment and processes the complete task specification.
         proc: asyncio.subprocess.Process | None = None
+        cleaned_process: asyncio.subprocess.Process | None = None
 
         async def _terminate_copilot_process(
             process: asyncio.subprocess.Process | None,
         ) -> None:
-            if process is None:
+            nonlocal cleaned_process
+            if process is None or process is cleaned_process:
                 return
+            cleaned_process = process
             _kill_proc(process)
             try:
                 await asyncio.wait_for(process.wait(), timeout=5)
@@ -7919,6 +7991,7 @@ class ProcessManager:
                 pass
 
         try:
+            resources_before = agent_core.collect_runtime_resource_metrics()
             proc = await _create_subprocess_exec(
                 *cmd,
                 stdout=asyncio.subprocess.PIPE,
@@ -7947,6 +8020,15 @@ class ProcessManager:
             # from the JSONL "result" event for a true success signal.
             copilot_exit = self._extract_copilot_exit_code(stdout)
             signals = self._extract_output_signals(stdout)
+            resource_exhausted = agent_core.is_runtime_resource_exhaustion_error(
+                stderr, *(signals.get("error_messages") or []),
+            )
+            if resource_exhausted:
+                metrics["runtime_resources_before"] = resources_before
+                metrics["runtime_resources_at_failure"] = (
+                    agent_core.collect_runtime_resource_metrics()
+                )
+            await _terminate_copilot_process(proc)
             completed_without_result = bool(
                 signals["has_turn_completed"]
                 and signals["has_assistant_events"]
@@ -8226,10 +8308,7 @@ class ProcessManager:
                     error=failure_error,
                     failure_code=(
                         "runtime_resource_exhausted"
-                        if agent_core.is_runtime_resource_exhaustion_error(
-                            failure_error,
-                            stderr,
-                        )
+                        if resource_exhausted
                         else ""
                     ),
                     metrics=metrics,
@@ -8278,6 +8357,7 @@ class ProcessManager:
                 error=f"Stream processing error: {exc}",
             )
         finally:
+            await _terminate_copilot_process(proc)
             self.active_processes.pop(task_id, None)
             if _is_outer_call and _isolated_copilot_home:
                 if _master_copilot_home and _auth_state["persist"]:
@@ -10401,9 +10481,9 @@ def _testing_intents_have_e2e(workspace_path: Path, input_data: dict[str, Any])
 _QA_TEST_LEVELS = frozenset({"unit", "integration", "e2e"})
 
 
-def _git_status_paths(status_output: str) -> list[str]:
-    """Extract changed paths from porcelain-v1 `-z` output."""
-    paths: list[str] = []
+def _git_status_entries(status_output: str) -> list[tuple[str, str]]:
+    """Extract status/path pairs from porcelain-v1 `-z` output."""
+    entries: list[tuple[str, str]] = []
     records = status_output.split("\0")
     index = 0
     while index < len(records):
@@ -10411,12 +10491,35 @@ def _git_status_paths(status_output: str) -> list[str]:
         index += 1
         if len(record) < 4 or record[2] != " ":
             continue
-        paths.append(record[3:])
+        entries.append((record[:2], record[3:]))
         if "R" in record[:2] or "C" in record[:2]:
             if index < len(records) and records[index]:
-                paths.append(records[index])
+                entries.append((record[:2], records[index]))
             index += 1
-    return paths
+    return entries
+
+
+def _git_status_paths(status_output: str) -> list[str]:
+    """Extract changed paths from porcelain-v1 `-z` output."""
+    return [path for _status, path in _git_status_entries(status_output)]
+
+
+def _is_preserved_local_path(path: str, preserved_paths: set[str]) -> bool:
+    if path in preserved_paths or path + "/" in preserved_paths:
+        return True
+    prefix = ""
+    for component in path.split("/")[:-1]:
+        prefix += component + "/"
+        if prefix in preserved_paths or prefix[:-1] in preserved_paths:
+            return True
+    return False
+
+
+def _local_bind_changed_paths(status_output: str, preserved_paths: set[str]) -> list[str]:
+    return [
+        path for status, path in _git_status_entries(status_output)
+        if status != "??" or not _is_preserved_local_path(path, preserved_paths)
+    ]
 
 
 def _qa_test_level_from_source_path(path: object) -> str | None:
@@ -12247,6 +12350,8 @@ class RuntimeDaemon:
         is_local_bind = task.workspace_resolution == "local_bind"
         async def report_task_complete(result: TaskResult) -> None:
             if is_local_bind:
+                if result.error:
+                    _append_local_bind_output_log(task.task_id, [f"[daemon] {result.error}"])
                 _prepare_local_bind_completion(task, result)
             if self.managed_policy is not None and not await self.managed_policy.finish_task():
                 result.status = "failed"
@@ -13206,6 +13311,9 @@ class RuntimeDaemon:
             logger.info("Task %s completed: %s (agent=%s)", task.task_id, result.status, agent.agent_id)
 
         except Exception as e:
+            failure_code = str(getattr(e, "code", "") or "")
+            if is_local_bind and str(e).startswith("local_binding_unavailable:"):
+                failure_code = "local_binding_unavailable"
             if self.managed_policy is not None:
                 _append_local_bind_output_log(task.task_id, [str(e)])
                 logger.warning("Managed local task failed: %s", getattr(e, "code", "local_task_failed"))
@@ -13214,6 +13322,7 @@ class RuntimeDaemon:
             await report_task_complete(TaskResult(
                 status="failed", exit_code=-1, stdout="", stderr="",
                 error=str(e),
+                failure_code=failure_code,
                 execution_attempt_id=task.execution_attempt_id,
             ))
         finally:
@@ -15405,12 +15514,18 @@ class RuntimeDaemon:
         require_source_inventory = _qa_source_test_validation_required(
             (task.input_data or {}).get("qa_test_level_policy_snapshot")
         )
+        preserved_paths = (
+            getattr(task, "local_untracked_paths", None)
+            if getattr(task, "workspace_resolution", None) == "local_bind"
+            else None
+        )
         for attempt in range(max_retries):
             inventory_issues = await self._refresh_validation_changed_paths(
                 workspace_path,
                 result,
                 default_branch=default_branch,
                 before_sha=before_sha,
+                preserved_paths=preserved_paths,
             )
             issues = self._validate_outputs(workspace_path, task, result)
             if require_source_inventory:
@@ -15534,6 +15649,7 @@ class RuntimeDaemon:
             result,
             default_branch=default_branch,
             before_sha=before_sha,
+            preserved_paths=preserved_paths,
         )
         remaining = self._validate_outputs(workspace_path, task, result)
         if require_source_inventory:
@@ -15628,6 +15744,7 @@ class RuntimeDaemon:
         *,
         default_branch: str,
         before_sha: str,
+        preserved_paths: set[str] | None = None,
     ) -> list[str]:
         """Merge reported, working-tree, and already-committed task paths."""
         reported_paths = ProcessManager._normalize_repo_paths(result.files_changed)
@@ -15643,7 +15760,7 @@ class RuntimeDaemon:
                 cwd=workspace_path,
             )
             paths.update(ProcessManager._normalize_repo_paths(
-                _git_status_paths(status_output)
+                _local_bind_changed_paths(status_output, preserved_paths or set())
             ))
             collected_paths = True
         except Exception:
@@ -15996,6 +16113,8 @@ class RuntimeDaemon:
     async def _discard_transient_untracked_runtime_files(
         self,
         workspace_path: Path,
+        *,
+        preserved_paths: set[str] | None = None,
     ) -> list[str]:
         """Discard known untracked test-run metadata before automatic staging."""
         git = self.workspace_manager._git
@@ -16015,6 +16134,8 @@ class RuntimeDaemon:
             if not line.startswith("?? "):
                 continue
             relative_path = line[3:].replace("\\", "/").lstrip("./")
+            if _is_preserved_local_path(relative_path, preserved_paths or set()):
+                continue
             if relative_path not in _TRANSIENT_UNTRACKED_RUNTIME_PATHS:
                 continue
             candidate = workspace_path / relative_path
@@ -16115,12 +16236,12 @@ class RuntimeDaemon:
           before staging and again before pushing: if the user switched
           branches while the agent ran, the task fails closed instead of
           committing/pushing the changes onto the wrong branch
-        - refuses to commit if any changed path (staged, or already
-          committed by the agent itself since before_sha) looks like a
-          secret (.env, private keys, etc.) — fails the task closed rather
-          than silently excluding just those files, since a partial commit
-          would leave the directory dirty and block future local_bind tasks
-          on this binding (which requires a clean working tree)
+                - preserves the startup inventory of user-owned untracked/ignored
+                    files and excludes it from staging and convergence checks; if the
+                    agent stages or commits those files, refuses to push
+                - refuses to commit/push task paths that look like secrets (.env,
+                    private keys, etc.), including paths committed by the agent itself
+                    since before_sha; untouched pre-existing private files stay local
         - never rebases, merges, resets, or force-pushes; a non-fast-forward
           push failure just fails the task closed, no automatic recovery
         Returns a dict with commit/push status info (empty dict on success),
@@ -16162,9 +16283,26 @@ class RuntimeDaemon:
                         "from HEAD. Review the branch history yourself before retrying."
                     )}
 
-            await self._discard_transient_untracked_runtime_files(workspace_path)
-            status_output = await git("status", "--porcelain", cwd=workspace_path)
-            dirty_paths = [line[3:] for line in status_output.splitlines() if line.strip()]
+            if task.local_untracked_paths and not before_sha:
+                return {"commit_error": "Refusing to commit: the local task baseline is unavailable"}
+
+            await self._discard_transient_untracked_runtime_files(
+                workspace_path, preserved_paths=task.local_untracked_paths,
+            )
+            status_output = await git(
+                "status", "--porcelain=v1", "--untracked-files=all", "-z", cwd=workspace_path,
+            )
+            dirty_paths = _local_bind_changed_paths(status_output, task.local_untracked_paths)
+            preserved_dirty = [
+                path for path in dirty_paths
+                if _is_preserved_local_path(path, task.local_untracked_paths)
+            ]
+            if preserved_dirty:
+                return {"commit_error": (
+                    "Refusing to commit: pre-existing user-owned local files were staged ("
+                    + ", ".join(preserved_dirty[:20])
+                    + "). Not pushed; unstage these files and review the task changes."
+                )}
 
             sensitive_dirty = [p for p in dirty_paths if _is_sensitive_local_path(p)]
             if sensitive_dirty:
@@ -16175,7 +16313,19 @@ class RuntimeDaemon:
                 )}
 
             if dirty_paths:
-                await git("add", "-A", cwd=workspace_path)
+                await git("add", "-u", cwd=workspace_path)
+                new_paths = [
+                    path for status, path in _git_status_entries(status_output)
+                    if status == "??" and not _is_preserved_local_path(
+                        path, task.local_untracked_paths,
+                    )
+                ]
+                for offset in range(0, len(new_paths), 100):
+                    await git(
+                        "add", "--",
+                        *(f":(literal){path}" for path in new_paths[offset:offset + 100]),
+                        cwd=workspace_path,
+                    )
 
                 mode_change_error = await self._pure_file_mode_change_error(
                     workspace_path, "--cached"
@@ -16243,15 +16393,27 @@ class RuntimeDaemon:
             # every path touched since before_sha for sensitive content too,
             # not just what we just staged ourselves.
             if before_sha:
-                try:
+                committed_paths: set[str] = set()
+                commits = await git("rev-list", f"{before_sha}..HEAD", cwd=workspace_path)
+                for commit_sha in commits.splitlines():
                     changed_since_before = await git(
-                        "diff", "--name-only", f"{before_sha}..HEAD", cwd=workspace_path,
+                        "diff-tree", "--no-commit-id", "--name-only", "--no-renames",
+                        "-r", "-m", "-z", commit_sha, cwd=workspace_path,
                     )
-                except RuntimeError:
-                    changed_since_before = ""
+                    committed_paths.update(path for path in changed_since_before.split("\0") if path)
+                preserved_committed = sorted(
+                    path for path in committed_paths
+                    if _is_preserved_local_path(path, task.local_untracked_paths)
+                )
+                if preserved_committed:
+                    return {"commit_error": (
+                        "Refusing to push: commit(s) made during this task include pre-existing "
+                        "user-owned local files ("
+                        + ", ".join(preserved_committed[:20])
+                        + "). Not pushed; inspect and fix the commit(s) yourself."
+                    )}
                 agent_sensitive = [
-                    p for p in changed_since_before.splitlines()
-                    if p.strip() and _is_sensitive_local_path(p)
+                    path for path in sorted(committed_paths) if _is_sensitive_local_path(path)
                 ]
                 if agent_sensitive:
                     return {"commit_error": (
@@ -16261,8 +16423,10 @@ class RuntimeDaemon:
                         + "). Not pushed — inspect and fix the commit(s) yourself."
                     )}
 
-            post_commit_status = await git("status", "--porcelain", cwd=workspace_path)
-            if post_commit_status.strip():
+            post_commit_status = await git(
+                "status", "--porcelain=v1", "--untracked-files=all", "-z", cwd=workspace_path,
+            )
+            if _local_bind_changed_paths(post_commit_status, task.local_untracked_paths):
                 if _post_commit_sync_attempts_remaining > 0:
                     logger.warning(
                         "local_bind: workspace changed after commit in %s; "
@@ -16317,8 +16481,10 @@ class RuntimeDaemon:
                     "yourself (e.g. pull/merge), then retry."
                 )}
 
-            post_push_status = await git("status", "--porcelain", cwd=workspace_path)
-            if not post_push_status.strip():
+            post_push_status = await git(
+                "status", "--porcelain=v1", "--untracked-files=all", "-z", cwd=workspace_path,
+            )
+            if not _local_bind_changed_paths(post_push_status, task.local_untracked_paths):
                 return {}
 
             if _post_commit_sync_attempts_remaining > 0:

{forgexa_cli-1.67.1 → forgexa_cli-1.68.1}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.67.1
+Version: 1.68.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.67.1 → forgexa_cli-1.68.1}/pyproject.toml

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