forgexa-cli 1.62.5__tar.gz → 1.63.1__tar.gz

{forgexa_cli-1.62.5 → forgexa_cli-1.63.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.62.5
+Version: 1.63.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.62.5 → forgexa_cli-1.63.1}/forgexa_cli/__init__.py

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

{forgexa_cli-1.62.5 → forgexa_cli-1.63.1}/forgexa_cli/agent_core.py

@@ -1309,12 +1309,14 @@ def _kill_proc(proc: asyncio.subprocess.Process) -> None:
     (npm, yarn, ssh, git, etc.) spawned by the agent stay alive, keep pipes
     open, and exhaust system resources.  ``os.killpg`` sends SIGKILL to the
     whole process group, reliably cleaning up all descendants.
+    Owned agents start a new session, so their PID remains the process-group
+    ID even after the leader exits.
     """
     try:
         if sys.platform != "win32":
             import signal as _signal
             try:
-                os.killpg(os.getpgid(proc.pid), _signal.SIGKILL)
+                os.killpg(proc.pid, _signal.SIGKILL)
             except (ProcessLookupError, PermissionError, OSError):
                 pass
         else:
@@ -1322,6 +1324,7 @@ def _kill_proc(proc: asyncio.subprocess.Process) -> None:
             _subprocess.run(
                 ["taskkill", "/F", "/T", "/PID", str(proc.pid)],
                 capture_output=True,
+                timeout=5,
                 **_agent_process_group_kwargs(),
             )
     except Exception:
@@ -2462,7 +2465,7 @@ def deepseek_harness_build_info(binary: str) -> dict:
     if result.returncode or not re.fullmatch(r"\d+\.\d+\.\d+", node_version) or parsed is None or not ((parsed[0] == 22 and parsed >= (22, 19, 0)) or parsed[0] >= 24):
         raise RuntimeError("DeepSeek Harness requires Node 22.19+ or Node 24+")
     digest = hashlib.sha256()
-    digest.update(f"{sys.platform}:{platform.machine()}:{platform.release()}:{node_version}:harness-policy-3".encode())
+    digest.update(f"{sys.platform}:{platform.machine()}:{platform.release()}:{node_version}:harness-policy-4".encode())
     extensions = [manifest.parent for manifest in (roots[0] / "node_modules" / "@deepseek-ai").glob("dsh*/package.json")]
     for root in sorted(set([*roots, *extensions])):
         files = [root / "package.json"] + sorted((root / "lib").rglob("*.js"))
@@ -2592,10 +2595,15 @@ def deepseek_harness_overlay(*, cwd: Path, credentials_path: Path, provider: str
             "watch": False,
         }},
         {"id": "tool-skill", "disabled": False},
+        {"id": "tool-subagent", "disabled": False, "config": {
+            "provider": "spawn", "enableRunInBackground": False,
+            "backgroundMode": "one-shot", "maxDepth": 1,
+            "modelSelectionSettings": False,
+        }},
     ]
     disabled = (
         "session-telemetry-otel", "hmr", "plugin-manager", "tool-plugin-manager",
-        "llm-pi-ai", "tool-subagent", "tool-subagent-fork",
+        "llm-pi-ai", "tool-subagent-fork",
         "tool-subagent-control", "tool-subagent-list-agents", "tool-workflow",
         "goal-round-driver", "command-goal", "tool-goal", "command-feedback", "tool-web",
     )
@@ -2862,7 +2870,7 @@ def mimo_base_env(env: dict[str, str]) -> dict[str, str]:
                 "git * reset --hard*": "deny",
             },
             "external_directory": "deny",
-            "task": "deny",
+            "task": "allow",
             "skill": {"*": "allow", "compose:*": "deny"},
             "webfetch": "deny",
             "websearch": "deny",
@@ -3168,9 +3176,9 @@ def zcode_build_verification_issue(binary: str | Path, env: dict[str, str] | Non
     return None
 
 
-ZCODE_ALLOWED_TOOLS = ("Read", "Glob", "Grep", "Edit", "Write", "Skill")
+ZCODE_ALLOWED_TOOLS = ("Read", "Glob", "Grep", "Edit", "Write", "Skill", "Agent", "Task")
 ZCODE_DENIED_TOOLS = (
-    "Bash", "MCP", "Plugin", "Task", "WebFetch", "WebSearch",
+    "Bash", "MCP", "Plugin", "WebFetch", "WebSearch",
 )
 
 
@@ -3247,10 +3255,8 @@ def agent_execution_verification_issue(agent_id: str, binary: str) -> str | None
     return None
 
 
-_FORGEXA_CODING_AGENT_TOOLS = ("Read", "Glob", "Grep", "Edit", "Write", "Bash", "Skill")
+_FORGEXA_CODING_AGENT_TOOLS = ("Read", "Glob", "Grep", "Edit", "Write", "Bash", "Skill", "Agent", "Task")
 _FORGEXA_CODING_AGENT_DENIED_TOOLS = (
-    "Agent",
-    "Task",
     "SlashCommand",
     "WebFetch",
     "WebSearch",
@@ -3655,9 +3661,10 @@ def build_copilot_command(
 
     ``prompt_via_stdin`` omits ``-p`` so the caller pipes the prompt into
     stdin instead - verified live on CLI 1.0.86, where piped stdin is a full
-    non-interactive prompt source.  The host uses it when the argv form would
-    exceed the platform command-line limit (inlined attachments can push the
-    prompt past Windows' 32k-char CreateProcess ceiling).
+    non-interactive prompt source.  The daemon uses it for native launchers
+    to avoid single-argument and total command-line limits; Windows batch
+    wrappers retain task-file redirection.  The host uses it when the argv
+    form would exceed the platform command-line limit.
     """
     cmd = [
         binary,

{forgexa_cli-1.62.5 → forgexa_cli-1.63.1}/forgexa_cli/daemon.py

@@ -114,7 +114,6 @@ _redirect_prompt_through_task_file = agent_core._redirect_prompt_through_task_fi
 _agent_process_group_kwargs = agent_core._agent_process_group_kwargs
 _parse_semver = agent_core._parse_semver
 _check_agent_min_version = agent_core._check_agent_min_version
-_kill_proc = agent_core._kill_proc
 _extract_output_signals = agent_core._extract_output_signals
 _should_scan_short_success_stdout = agent_core._should_scan_short_success_stdout
 _copilot_completed_without_result = agent_core._copilot_completed_without_result
@@ -126,6 +125,23 @@ _parse_kimi_wire_metrics = agent_core._parse_kimi_wire_metrics
 _parse_copilot_output = agent_core._parse_copilot_output
 _extract_copilot_exit_code = agent_core._extract_copilot_exit_code
 
+# Only the fixed, admitted entry can select managed mode, never an env flag.
+_wsl_policy_module = sys.modules.get("app.wsl_runtime_policy") or sys.modules.get("wsl_runtime_policy")
+_MANAGED_WSL_POLICY = getattr(_wsl_policy_module, "ACTIVE_POLICY", None)
+
+
+async def _create_subprocess_exec(*command, **kwargs):
+    if _MANAGED_WSL_POLICY is not None:
+        return await _MANAGED_WSL_POLICY.spawn(*command, **kwargs)
+    return await asyncio.create_subprocess_exec(*command, **kwargs)
+
+
+def _kill_proc(proc) -> None:
+    if _MANAGED_WSL_POLICY is not None:
+        _MANAGED_WSL_POLICY.cancel_process(proc)
+    else:
+        agent_core._kill_proc(proc)
+
 # ── httpx dependency — robust auto-install for standalone environments ──
 # When running inside the backend package, httpx is a declared dependency and
 # always available.  In standalone contexts (desktop AppImage/DMG/MSI, CLI
@@ -136,10 +152,13 @@ _extract_copilot_exit_code = agent_core._extract_copilot_exit_code
 #   3. Auto-install via pip --target to the cached deps dir
 #      (bypasses PEP 668 / externally-managed-environment on modern distros)
 #   4. Friendly error with OS-specific instructions if all else fails
-_HTTPX_DEPS_DIR = os.path.join(str(Path.home()), ".forgexa", "daemon", "deps")
+_HTTPX_DEPS_DIR = (str(_MANAGED_WSL_POLICY.state / "deps") if _MANAGED_WSL_POLICY is not None
+                   else os.path.join(str(Path.home()), ".forgexa", "daemon", "deps"))
 
 
 def _cli_config_path() -> Path:
+    if _MANAGED_WSL_POLICY is not None:
+        return _MANAGED_WSL_POLICY.state / "config.json"
     return Path.home() / ".forgexa" / "config"
 
 
@@ -230,10 +249,14 @@ def _local_runtime_registration_path() -> Path:
     nor workspace paths, so desktop clients can safely use it to avoid
     binding a local folder to a runtime on another machine.
     """
+    if _MANAGED_WSL_POLICY is not None:
+        return _MANAGED_WSL_POLICY.state / "runtime-registrations.json"
     return Path.home() / ".forgexa" / "daemon" / "runtime-registrations.json"
 
 
 def _desktop_daemon_restart_request_path(instance_id: str) -> Path:
+    if _MANAGED_WSL_POLICY is not None:
+        return _MANAGED_WSL_POLICY.state / "restart-requests" / f"{instance_id}.json"
     return (
         Path.home()
         / ".forgexa"
@@ -324,6 +347,8 @@ def _clear_local_runtime_registration_snapshot(instance_id: str) -> None:
 
 
 def _cli_credentials_path() -> Path:
+    if _MANAGED_WSL_POLICY is not None:
+        return _MANAGED_WSL_POLICY.state / "credentials.json"
     return Path.home() / ".forgexa" / "credentials.json"
 
 
@@ -374,6 +399,11 @@ def _migrate_legacy_cli_credentials(*, write_lock_held: bool = False) -> dict:
 
 def _load_cli_credentials(*, write_lock_held: bool = False) -> dict:
     """Load issuer-scoped credentials, migrating legacy config on first use."""
+    if _MANAGED_WSL_POLICY is not None:
+        return {_normalize_issuer_url(_MANAGED_WSL_POLICY.config.serverUrl): {
+            "runtime_credential": _MANAGED_WSL_POLICY.credential,
+            "runtime_id": _MANAGED_WSL_POLICY.runtime_id,
+        }}
     path = _cli_credentials_path()
     if path.exists():
         try:
@@ -920,6 +950,9 @@ def _validate_httpx_imports() -> tuple[bool, str]:
 # Actual import sequence
 _httpx_ok, _httpx_missing = _validate_httpx_imports()
 
+if not _httpx_ok and _MANAGED_WSL_POLICY is not None:
+    raise RuntimeError("Managed WSL runtime dependency closure is incomplete")
+
 if not _httpx_ok:
     # Check cached deps directory (previous auto-install)
     if _HTTPX_DEPS_DIR not in sys.path:
@@ -997,6 +1030,8 @@ def _make_httpx_ssl_context():
 
 # ── Settings: graceful fallback when running standalone (outside backend package) ──
 try:
+    if _MANAGED_WSL_POLICY is not None:
+        raise ModuleNotFoundError("Managed WSL uses admitted standalone settings")
     from app.config import settings
 except (ImportError, ModuleNotFoundError):
     # Running standalone (e.g., from desktop app bundle or forgexa-cli).
@@ -1196,7 +1231,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.62.5"
+DAEMON_VERSION = "1.63.1"
 
 
 def _detect_client_type() -> str:
@@ -1234,7 +1269,8 @@ _CLIENT_TYPE = _detect_client_type()
 # so logs are visible on the terminal without duplication.
 # Set DAEMON_NO_CONSOLE_LOG=1 to suppress the stream handler even on a TTY
 # (used by `forgexa daemon start` foreground mode for clean UX).
-_log_dir = Path.home() / ".forgexa" / "daemon"
+_log_dir = (_MANAGED_WSL_POLICY.state / "logs" if _MANAGED_WSL_POLICY is not None
+            else Path.home() / ".forgexa" / "daemon")
 _log_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
 # Ensure directory has restricted permissions even if it already existed
 _log_dir.chmod(0o700)
@@ -1512,6 +1548,8 @@ def _agent_dicts_for_wire(agents: "list[DiscoveredAgent]") -> list[dict]:
 
 def _resolve_git_command() -> str | None:
     """Return Git's executable, including common Windows installer locations."""
+    if _MANAGED_WSL_POLICY is not None:
+        return _MANAGED_WSL_POLICY.executable("git")
     resolved = shutil.which("git")
     if resolved or sys.platform != "win32":
         return resolved
@@ -2478,6 +2516,8 @@ def _local_workspaces_mapping_path() -> Path:
 
 
 def _load_local_workspaces_mapping() -> dict:
+    if _MANAGED_WSL_POLICY is not None:
+        return _MANAGED_WSL_POLICY.mapping()
     path = _local_workspaces_mapping_path()
     if not path.exists():
         return {}
@@ -2519,6 +2559,8 @@ _LOCAL_BIND_SHARED_OUTPUT_MAX_LINES = 5_000
 
 
 def _local_bind_output_log_path(task_id: str) -> Path:
+    if _MANAGED_WSL_POLICY is not None:
+        return _MANAGED_WSL_POLICY.output_path(task_id)
     return Path.home() / ".forgexa" / "local-bind-output" / f"{task_id}.log"
 
 
@@ -2530,6 +2572,9 @@ def _append_local_bind_output_log(task_id: str, lines: list[str]) -> None:
     """
     if not lines:
         return
+    if _MANAGED_WSL_POLICY is not None:
+        _MANAGED_WSL_POLICY.append_output(task_id, lines)
+        return
     try:
         path = _local_bind_output_log_path(task_id)
         path.parent.mkdir(parents=True, exist_ok=True)
@@ -2544,6 +2589,8 @@ def _append_local_bind_output_log(task_id: str, lines: list[str]) -> None:
 
 def _local_bind_output_sharing_enabled(binding_id: str | None) -> bool:
     """Return the private binding's automatic transcript-sharing preference."""
+    if _MANAGED_WSL_POLICY is not None:
+        return False
     if not binding_id:
         return False
     entry = _load_local_workspaces_mapping().get(binding_id)
@@ -2588,6 +2635,8 @@ def _read_local_bind_shared_output_snapshot(task_id: str) -> dict | None:
 
 def _prepare_local_bind_completion(task: "TaskInfo", result: "TaskResult") -> None:
     """Attach the automatic private snapshot before stripping normal local output."""
+    if _MANAGED_WSL_POLICY is not None:
+        result.shared_local_output = None
     if _local_bind_output_sharing_enabled(task.local_workspace_binding_id):
         result.shared_local_output = _read_local_bind_shared_output_snapshot(task.task_id)
     _filter_local_bind_task_result(result)
@@ -2719,6 +2768,11 @@ def _normalize_repo_identity(repo_url: str) -> str | None:
 
 
 async def _validate_local_workspace_binding(binding: dict[str, Any], runtime_id: str) -> str | None:
+    if _MANAGED_WSL_POLICY is not None:
+        _MANAGED_WSL_POLICY.check_mapping()
+        expected = _MANAGED_WSL_POLICY.config.binding
+        if runtime_id != _MANAGED_WSL_POLICY.runtime_id or not expected or any(binding.get(key) != value for key, value in expected.items()):
+            return "mapping_mismatch"
     binding_id = str(binding.get("id") or "")
     entry = _load_local_workspaces_mapping().get(binding_id)
     if not binding_id or not isinstance(entry, dict):
@@ -2746,8 +2800,8 @@ async def _validate_local_workspace_binding(binding: dict[str, Any], runtime_id:
 
     proc = None
     try:
-        proc = await asyncio.create_subprocess_exec(
-            "git", "remote", "get-url", "origin",
+        proc = await _create_subprocess_exec(
+            _resolve_git_command() if _MANAGED_WSL_POLICY is not None else "git", "remote", "get-url", "origin",
             cwd=str(local_path),
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.DEVNULL,
@@ -2826,6 +2880,8 @@ def _try_acquire_local_workspace_file_lock(binding_id: str, workspace_path: Path
 
 
 def _release_local_workspace_file_lock(lock_file) -> None:
+    if _MANAGED_WSL_POLICY is not None and lock_file is _MANAGED_WSL_POLICY.task_lock:
+        return  # Only verified empty-tree cleanup releases the inherited locks.
     agent_core.release_file_lock(lock_file)
 
 
@@ -3573,6 +3629,9 @@ class WorkspaceManager:
         fails closed with a "local_binding_unavailable:" prefixed error. See
         docs/designs/forgexa-ide-design.md §6.2.
         """
+        if _MANAGED_WSL_POLICY is not None:
+            _MANAGED_WSL_POLICY.validate_task(task, runtime_id)
+            _MANAGED_WSL_POLICY.check_mapping()
         binding_id = task.local_workspace_binding_id
         if not binding_id:
             raise RuntimeError("local_binding_unavailable: task has no local_workspace_binding_id")
@@ -4069,7 +4128,7 @@ class WorkspaceManager:
             # Warn if the clone has uncommitted changes so the operator knows
             # what will be lost when it is removed (L3 fix).
             try:
-                st_proc = await asyncio.create_subprocess_exec(
+                st_proc = await _create_subprocess_exec(
                     "git", "status", "--porcelain",
                     cwd=str(ws_path),
                     stdout=asyncio.subprocess.PIPE,
@@ -4242,7 +4301,7 @@ class WorkspaceManager:
         """
         try:
             # Get the local HEAD SHA
-            local_proc = await asyncio.create_subprocess_exec(
+            local_proc = await _create_subprocess_exec(
                 "git", "rev-parse", "HEAD",
                 cwd=str(repo_path),
                 stdout=asyncio.subprocess.PIPE,
@@ -4271,7 +4330,7 @@ class WorkspaceManager:
             # If HEAD is ahead of the merge-base, we count local-only commits — any
             # count > 0 means we should NOT call the branch-r check.
             try:
-                ahead_proc = await asyncio.create_subprocess_exec(
+                ahead_proc = await _create_subprocess_exec(
                     "git", "rev-list", "--count", "--right-only", "origin...HEAD",
                     cwd=str(repo_path),
                     stdout=asyncio.subprocess.PIPE,
@@ -4293,7 +4352,7 @@ class WorkspaceManager:
             except Exception:
                 pass  # If the ahead count fails, proceed with the branch-r check
 
-            check_proc = await asyncio.create_subprocess_exec(
+            check_proc = await _create_subprocess_exec(
                 "git", "branch", "-r", "--contains", local_head,
                 cwd=str(repo_path),
                 stdout=asyncio.subprocess.PIPE,
@@ -5184,7 +5243,7 @@ class WorkspaceManager:
         last_branch_fetch_error: str | None = None
         for _check_attempt in range(3 if not fresh_start else 1):
             try:
-                check_proc = await asyncio.create_subprocess_exec(
+                check_proc = await _create_subprocess_exec(
                     "git", "rev-parse", "--verify", f"refs/remotes/origin/{branch_name}",
                     cwd=str(main_repo),
                     stdout=asyncio.subprocess.PIPE,
@@ -5684,7 +5743,7 @@ class WorkspaceManager:
         # orphaned processes from keeping pipes alive.
         # Windows note: start_new_session creates a new console process group;
         # we use taskkill /T there instead of killpg.
-        proc = await asyncio.create_subprocess_exec(
+        proc = await _create_subprocess_exec(
             git_command, *longpath_args, *git_prefix_args, *args,
             stdin=asyncio.subprocess.DEVNULL,
             stdout=asyncio.subprocess.PIPE,
@@ -5709,7 +5768,9 @@ class WorkspaceManager:
             # ssh grandchild becomes orphaned, keeps the stderr pipe open,
             # and proc.communicate() can never return EOF.
             try:
-                if sys.platform != "win32":
+                if _MANAGED_WSL_POLICY is not None:
+                    _kill_proc(proc)
+                elif sys.platform != "win32":
                     import signal as _signal
                     try:
                         os.killpg(os.getpgid(proc.pid), _signal.SIGKILL)
@@ -6525,10 +6586,11 @@ class ProcessManager:
         _last_activity_at: list[float] = [time.monotonic()]
 
         # Write prompt and close stdin so the agent knows input is done.
-        if stdin_input and proc.stdin:
+        if proc.stdin:
             try:
-                proc.stdin.write(stdin_input)
-                await proc.stdin.drain()
+                if stdin_input:
+                    proc.stdin.write(stdin_input)
+                    await proc.stdin.drain()
             except Exception:
                 pass
             proc.stdin.close()
@@ -6751,7 +6813,7 @@ class ProcessManager:
         env.update(self._prepare_claude_environment(sandbox_root=Path(_claude_home)))
 
         try:
-            proc = await asyncio.create_subprocess_exec(
+            proc = await _create_subprocess_exec(
                 *cmd,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
@@ -7668,7 +7730,8 @@ class ProcessManager:
         explicitly configured supported token environment variable.
 
         Flags:
-          -p / --prompt          Non-interactive prompt (exits after completion).
+          stdin                 Full non-interactive prompt, avoiding argv limits.
+          -p / --prompt          Short task-file instruction for Windows wrappers.
           --output-format json   JSONL stream of session events.
           --allow-all            Grant all tool + path + URL permissions required
                                  for autonomous file-editing tasks.
@@ -7768,11 +7831,13 @@ class ProcessManager:
             _effective_prompt, _task_file = _redirect_prompt_through_task_file(
                 cwd, prompt, task_id, "Copilot",
             )
+        _stdin_input = None if _task_file is not None else prompt.encode("utf-8")
 
         cmd = agent_core.build_copilot_command(
             agent.command,
             cwd=cwd,
             prompt=_effective_prompt,
+            prompt_via_stdin=_stdin_input is not None,
             model=model_override,
             reasoning=reasoning if not _retry_without_effort else None,
             disable_builtin_mcps=disable_builtin_mcps,
@@ -7786,9 +7851,20 @@ class ProcessManager:
         # reproduce failures manually and diagnose CLI version incompatibilities.
         _cmd_display = " ".join(
             f'"{a}"' if " " in a else a
-            for a in cmd[:-1]  # omit the -p value (potentially huge/sensitive)
-        ) + ' -p "<prompt>"'
-        logger.debug("Copilot invocation for task %s: %s", task_id, _cmd_display)
+            for a in (cmd if _stdin_input is not None else cmd[:-1])
+        )
+        if _stdin_input is None:
+            _cmd_display += ' "<prompt>"'
+        logger.debug(
+            "Copilot invocation for task %s: %s (prompt via %s)",
+            task_id, _cmd_display, "stdin" if _stdin_input is not None else "task file",
+        )
+        logger.info(
+            "Copilot task %s prompt transport: %s (%d UTF-8 bytes)",
+            task_id,
+            "stdin" if _stdin_input is not None else "task file",
+            len(_stdin_input) if _stdin_input is not None else len(prompt.encode("utf-8")),
+        )
 
         # On Windows, CREATE_NO_WINDOW ensures GetConsoleWindow() returns NULL for
         # the child process, even when the parent (daemon or Tauri app) has a console
@@ -7796,9 +7872,9 @@ class ProcessManager:
         # check via GetConsoleWindow(): if a console window is visible, it uses only
         # the first line of -p as a brief context note and reports "No task was
         # provided" for the rest of the prompt — silently discarding the full task.
-        # stdin=DEVNULL (below) covers the primary check (GetConsoleMode on stdin);
+        # A pipe or DEVNULL covers the primary check (GetConsoleMode on stdin);
         # CREATE_NO_WINDOW covers this secondary check so Copilot always sees a fully
-        # headless environment and processes -p as the complete task specification.
+        # headless environment and processes the complete task specification.
         proc: asyncio.subprocess.Process | None = None
 
         async def _terminate_copilot_process(
@@ -7813,22 +7889,15 @@ class ProcessManager:
                 pass
 
         try:
-            proc = await asyncio.create_subprocess_exec(
+            proc = await _create_subprocess_exec(
                 *cmd,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
-                # stdin=DEVNULL is critical on Windows.
-                # Without it, the child process inherits the parent daemon's stdin.
-                # On Windows, the daemon often has a real console handle on stdin
-                # (e.g. from a CMD/PowerShell window or the Desktop app's console).
-                # Copilot CLI detects this via GetConsoleMode(GetStdHandle(STD_INPUT))
-                # and enters interactive/session-check mode, ignoring -p as a task:
-                # it checks the session todo table (empty), reports "no tracked work
-                # items", and waits for user input instead of executing the task.
-                # On Linux/macOS (daemon as service), stdin is typically /dev/null so
-                # the bug doesn't manifest.  Explicit DEVNULL ensures non-interactive
-                # mode on all platforms, matching the intended headless operation.
-                stdin=asyncio.subprocess.DEVNULL,
+                stdin=(
+                    asyncio.subprocess.PIPE
+                    if _stdin_input is not None
+                    else asyncio.subprocess.DEVNULL
+                ),
                 cwd=str(cwd),
                 env=env,
                 limit=100 * 1024 * 1024,
@@ -7836,7 +7905,7 @@ class ProcessManager:
             )
             self.active_processes[task_id] = proc
             stdout, stderr, returncode = await self._stream_process(
-                proc, None, timeout, task_id, on_chunk,
+                proc, _stdin_input, timeout, task_id, on_chunk,
                 workspace_path=cwd,
                 stream_stderr=stream_stderr,
             )
@@ -8213,7 +8282,7 @@ class ProcessManager:
         proc = None
         try:
             cmd = _prepare_agent_command(cmd)
-            proc = await asyncio.create_subprocess_exec(
+            proc = await _create_subprocess_exec(
                 *cmd,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
@@ -8305,7 +8374,7 @@ class ProcessManager:
         """Collect git diff stats from workspace."""
         info: dict[str, Any] = {}
         try:
-            proc = await asyncio.create_subprocess_exec(
+            proc = await _create_subprocess_exec(
                 "git", "diff", "--stat", "--cached",
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
@@ -8316,7 +8385,7 @@ class ProcessManager:
             stat_output = stdout.decode()
 
             # Also check unstaged
-            proc2 = await asyncio.create_subprocess_exec(
+            proc2 = await _create_subprocess_exec(
                 "git", "diff", "--stat",
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
@@ -8327,7 +8396,7 @@ class ProcessManager:
             stat_output += stdout2.decode()
 
             # Parse changed files
-            proc3 = await asyncio.create_subprocess_exec(
+            proc3 = await _create_subprocess_exec(
                 "git", "diff", "--name-only", "HEAD",
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
@@ -8339,7 +8408,7 @@ class ProcessManager:
             info["files_changed"] = files
 
             # Parse insertions/deletions
-            proc4 = await asyncio.create_subprocess_exec(
+            proc4 = await _create_subprocess_exec(
                 "git", "diff", "--shortstat", "HEAD",
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
@@ -8354,7 +8423,7 @@ class ProcessManager:
             info["lines_removed"] = int(removed.group(1)) if removed else 0
 
             # Get current branch
-            proc5 = await asyncio.create_subprocess_exec(
+            proc5 = await _create_subprocess_exec(
                 "git", "rev-parse", "--abbrev-ref", "HEAD",
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
@@ -8365,7 +8434,7 @@ class ProcessManager:
             info["branch"] = stdout5.decode().strip()
 
             # Get latest commit
-            proc6 = await asyncio.create_subprocess_exec(
+            proc6 = await _create_subprocess_exec(
                 "git", "rev-parse", "HEAD",
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
@@ -8411,7 +8480,7 @@ class ProcessManager:
                         candidate_refs.append(ref)
 
                 for candidate in candidate_refs:
-                    proc_mb = await asyncio.create_subprocess_exec(
+                    proc_mb = await _create_subprocess_exec(
                         "git", "merge-base", candidate, "HEAD",
                         stdout=asyncio.subprocess.PIPE,
                         stderr=asyncio.subprocess.PIPE,
@@ -8424,7 +8493,7 @@ class ProcessManager:
                         break
 
             # Changed files since branch point
-            proc = await asyncio.create_subprocess_exec(
+            proc = await _create_subprocess_exec(
                 "git", "diff", "--name-only", base_ref, "HEAD",
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
@@ -8436,7 +8505,7 @@ class ProcessManager:
             info["files_changed"] = files
 
             # Lines added/removed since branch point
-            proc2 = await asyncio.create_subprocess_exec(
+            proc2 = await _create_subprocess_exec(
                 "git", "diff", "--shortstat", base_ref, "HEAD",
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
@@ -8451,7 +8520,7 @@ class ProcessManager:
             info["lines_removed"] = int(removed.group(1)) if removed else 0
 
             # Branch name
-            proc3 = await asyncio.create_subprocess_exec(
+            proc3 = await _create_subprocess_exec(
                 "git", "rev-parse", "--abbrev-ref", "HEAD",
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
@@ -8462,7 +8531,7 @@ class ProcessManager:
             info["branch"] = stdout3.decode().strip()
 
             # Commit SHA
-            proc4 = await asyncio.create_subprocess_exec(
+            proc4 = await _create_subprocess_exec(
                 "git", "rev-parse", "HEAD",
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
@@ -8779,7 +8848,7 @@ class RuntimePreflightMonitor:
         process group SIGKILL on POSIX) and waits for reaping before returning.
         """
         try:
-            proc = await asyncio.create_subprocess_exec(
+            proc = await _create_subprocess_exec(
                 *cmd,
                 stdin=asyncio.subprocess.DEVNULL,
                 stdout=asyncio.subprocess.PIPE,
@@ -8804,6 +8873,9 @@ class RuntimePreflightMonitor:
     @staticmethod
     def _kill_process_tree(proc):
         """Best-effort kill of the entire process subtree."""
+        if _MANAGED_WSL_POLICY is not None:
+            _kill_proc(proc)
+            return
         try:
             if sys.platform == "win32":
                 # Must be a BLOCKING call here: this is a plain (non-async)
@@ -9006,6 +9078,8 @@ class HeartbeatService:
         self._agents = [dict(agent) for agent in agents]
 
     async def _sync_local_workspace_bindings(self) -> None:
+        if _MANAGED_WSL_POLICY is not None and _MANAGED_WSL_POLICY.task is not None:
+            return  # The task already retains mapping admission and the physical lock.
         try:
             response = await self.client.get(
                 f"{self.server_url}/api/v1/runtimes/{self.runtime_id}/local-workspace-bindings/verification",
@@ -9025,6 +9099,9 @@ class HeartbeatService:
             for binding in bindings:
                 if not isinstance(binding, dict) or not binding.get("id"):
                     continue
+                if _MANAGED_WSL_POLICY is not None:
+                    await _MANAGED_WSL_POLICY.sync_binding(self, binding)
+                    continue
                 failure_code = await _validate_local_workspace_binding(binding, self.runtime_id)
                 if failure_code is None and binding.get("status") == "active":
                     continue
@@ -9151,6 +9228,8 @@ class LogUploader:
 
     async def _upload(self):
         """Read daemon log tail and upload to server."""
+        if _MANAGED_WSL_POLICY is not None:
+            return  # Private WSL logs are never uploaded, even when no task is active.
         try:
             if not DAEMON_LOG_PATH.exists():
                 return
@@ -9344,6 +9423,11 @@ class ServerConnection:
             # honored here, which otherwise turns loopback calls into 502s.
             trust_env=False,
         )
+        if _MANAGED_WSL_POLICY is not None:
+            if (server_url != _MANAGED_WSL_POLICY.config.serverUrl or api_token != _MANAGED_WSL_POLICY.credential
+                    or daemon_id != _MANAGED_WSL_POLICY.daemon_id or hardware_id != _MANAGED_WSL_POLICY.hardware_id):
+                raise ValueError("wsl_runtime_connection_invalid")
+            self.client = _wsl_policy_module.PrivateClient(self.client, _MANAGED_WSL_POLICY)
         self.heartbeat: HeartbeatService | None = None
         self.poller: TaskPoller | None = None
         self.reporter: ProgressReporter | None = None
@@ -9901,6 +9985,8 @@ class ServerConnection:
                     raise DaemonCredentialUpgradeRequiredError(code)
             resp.raise_for_status()
             data = resp.json()
+            if _MANAGED_WSL_POLICY is not None and data.get("runtime_id") != _MANAGED_WSL_POLICY.runtime_id:
+                raise DaemonCredentialUpgradeRequiredError("runtime_credential_runtime_mismatch")
             self.runtime_id = data["runtime_id"]
             logger.info("[%s] Registered with server. runtime_id=%s", self.label, self.runtime_id)
             self._publish_local_runtime_registration()
@@ -10599,23 +10685,26 @@ class RuntimeDaemon:
     _TASK_ATTACHMENT_MAX_COUNT = 20
     _TASK_ATTACHMENT_MAX_TOTAL_BYTES = 100 * 1024 * 1024
 
-    def __init__(self):
+    def __init__(self, *, managed_policy=None):
+        if managed_policy is not _MANAGED_WSL_POLICY:
+            raise ValueError("wsl_runtime_entry_not_admitted")
+        self.managed_policy = managed_policy
         # Compute stable hardware fingerprint from machine-id / MAC address.
         # This allows the server to identify the same physical machine even when
         # its IP address changes (e.g., DHCP reassignment, home vs. office).
-        self.hardware_id = get_hardware_id()
+        self.hardware_id = managed_policy.hardware_id if managed_policy is not None else get_hardware_id()
 
         # daemon_id: prefer explicit config, fall back to hardware_id (stable),
         # then hostname. Using hardware_id as default instead of platform.node()
         # prevents duplicate registrations when the hostname changes.
-        self.daemon_id = settings.DAEMON_ID or self.hardware_id or platform.node()
-        self.server_urls = settings.get_daemon_server_urls()
-        self.api_token = _configured_daemon_api_token()
+        self.daemon_id = managed_policy.daemon_id if managed_policy is not None else settings.DAEMON_ID or self.hardware_id or platform.node()
+        self.server_urls = [managed_policy.config.serverUrl] if managed_policy is not None else settings.get_daemon_server_urls()
+        self.api_token = managed_policy.credential if managed_policy is not None else _configured_daemon_api_token()
         self._has_explicit_api_token = bool(self.api_token)
-        self.max_concurrent = settings.DAEMON_MAX_CONCURRENT
+        self.max_concurrent = 1 if managed_policy is not None else settings.DAEMON_MAX_CONCURRENT
         self.poll_interval = settings.DAEMON_POLL_INTERVAL
         self.heartbeat_interval = settings.DAEMON_HEARTBEAT_INTERVAL
-        self.workspaces_root = settings.get_daemon_workspaces_root()
+        self.workspaces_root = str(managed_policy.state / "workspaces") if managed_policy is not None else settings.get_daemon_workspaces_root()
 
         self.agents: list[DiscoveredAgent] = []
         self.active_tasks: dict[str, asyncio.Task] = {}
@@ -10668,12 +10757,16 @@ class RuntimeDaemon:
 
     async def _refresh_agents(self) -> None:
         """Re-discover local CLIs so upgrades reach the runtime heartbeat."""
+        if self.managed_policy is not None and self.active_tasks:
+            return
         try:
             refreshed_agents = await self.agent_discovery.discover()
         except Exception as exc:
             logger.warning("Agent inventory refresh failed: %s", exc)
             return
 
+        if self.managed_policy is not None:
+            refreshed_agents = [agent for agent in refreshed_agents if agent.agent_id in self.managed_policy.drivers]
         if refreshed_agents == self.agents:
             return
 
@@ -10717,6 +10810,8 @@ class RuntimeDaemon:
         )
 
     def _begin_desktop_restart_drain_if_requested(self) -> bool:
+        if self.managed_policy is not None:
+            return False
         target_version = _desktop_daemon_restart_target_version(
             self._local_runtime_instance_id
         )
@@ -11484,13 +11579,14 @@ class RuntimeDaemon:
     async def start(self):
         """Main entry point."""
         # Prevent multiple daemon instances on the same machine
-        self._acquire_lock()
+        if self.managed_policy is None:
+            self._acquire_lock()
         _write_local_runtime_registration_snapshot(
             self._local_runtime_instance_id,
             "starting",
             {},
         )
-        cleaned_processes = self._cleanup_stale_agent_processes()
+        cleaned_processes = self._cleanup_stale_agent_processes() if self.managed_policy is None else 0
         if cleaned_processes:
             logger.warning(
                 "Cleaned up %d orphaned Forgexa agent process group(s)",
@@ -11507,6 +11603,8 @@ class RuntimeDaemon:
 
         # 1. Discover agents
         self.agents = await self.agent_discovery.discover()
+        if self.managed_policy is not None:
+            self.agents = [agent for agent in self.agents if agent.agent_id in self.managed_policy.drivers]
         if not self.agents:
             logger.warning("No agent CLIs found. Daemon will run but cannot execute tasks.")
         else:
@@ -11601,7 +11699,8 @@ class RuntimeDaemon:
 
         # Clean up stale Copilot/Claude temp directories left by prior OOM-killed
         # daemon processes.  This runs once at startup so /tmp doesn't fill up.
-        await self._cleanup_stale_tmp_dirs()
+        if self.managed_policy is None:
+            await self._cleanup_stale_tmp_dirs()
 
         # 3. Main loop
         try:
@@ -11649,9 +11748,10 @@ class RuntimeDaemon:
 
         # Opportunistic GC: remove old deploy-merge worktrees (throttled internally).
         try:
-            await self._cleanup_old_merge_worktrees(
-                self.connections[0] if self.connections else None
-            )
+            if self.managed_policy is None:
+                await self._cleanup_old_merge_worktrees(
+                    self.connections[0] if self.connections else None
+                )
         except Exception:
             pass  # GC failure must never block the poll loop
 
@@ -11707,7 +11807,7 @@ class RuntimeDaemon:
             )
             # Always poll AI jobs so server-requested cancellations can stop a
             # process that is itself consuming the last available slot.
-            ai_jobs = await conn.poller.poll_ai_jobs() if accept_new_tasks else []
+            ai_jobs = await conn.poller.poll_ai_jobs() if accept_new_tasks and self.managed_policy is None else []
             _cancel_server_requested_execution_tasks(conn)
             _cancel_server_requested_ai_jobs(conn)
             total_active = len(self.active_tasks)
@@ -12051,8 +12151,23 @@ class RuntimeDaemon:
         async def report_task_complete(result: TaskResult) -> None:
             if is_local_bind:
                 _prepare_local_bind_completion(task, result)
+            if self.managed_policy is not None and not await self.managed_policy.finish_task():
+                result.status = "failed"
+                result.failure_code = "wsl_runtime_recovery_required"
+                result.error = "Managed local writer cleanup is unconfirmed"
             await reporter.report_complete(task.task_id, result)
 
+        if self.managed_policy is not None:
+            try:
+                await self.managed_policy.authorize_task(task, conn)
+            except ValueError as exc:
+                await report_task_complete(TaskResult(
+                    status="failed", exit_code=-1, stdout="", stderr="",
+                    error="Managed local dispatch was refused", failure_code=getattr(exc, "code", "wsl_runtime_dispatch_refused"),
+                    execution_attempt_id=task.execution_attempt_id,
+                ))
+                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
@@ -12082,9 +12197,8 @@ class RuntimeDaemon:
             # but this is a separate, complementary guard against two
             # DAEMON PROCESSES (e.g. a zombie/restarted instance) operating
             # on the same real directory at the same time.
-            local_bind_file_lock = _try_acquire_local_workspace_file_lock(
-                task.local_workspace_binding_id
-            )
+            local_bind_file_lock = (self.managed_policy.task_lock if self.managed_policy is not None
+                                    else _try_acquire_local_workspace_file_lock(task.local_workspace_binding_id))
             if local_bind_file_lock is None:
                 project_lock.release()
                 await report_task_complete(TaskResult(
@@ -12970,13 +13084,19 @@ class RuntimeDaemon:
             logger.info("Task %s completed: %s (agent=%s)", task.task_id, result.status, agent.agent_id)
 
         except Exception as e:
-            logger.exception("Task %s failed with exception", task.task_id)
+            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"))
+            else:
+                logger.exception("Task %s failed with exception", task.task_id)
             await report_task_complete(TaskResult(
                 status="failed", exit_code=-1, stdout="", stderr="",
                 error=str(e),
                 execution_attempt_id=task.execution_attempt_id,
             ))
         finally:
+            if self.managed_policy is not None:
+                await self.managed_policy.finish_task()
             if attachment_staging_dir is not None:
                 shutil.rmtree(attachment_staging_dir, ignore_errors=True)
             if workspace_execution_lock is not None:
@@ -15633,7 +15753,7 @@ class RuntimeDaemon:
             # Unstage if it was already staged
             if is_staged_new:
                 try:
-                    proc = await asyncio.create_subprocess_exec(
+                    proc = await _create_subprocess_exec(
                         "git", "restore", "--staged", file_path,
                         cwd=str(workspace_path),
                         stdout=asyncio.subprocess.PIPE,
@@ -15688,7 +15808,7 @@ class RuntimeDaemon:
         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(
+        proc = await _create_subprocess_exec(
             "git", "diff", "--raw", "--no-abbrev", "--no-renames", "-z", *diff_args,
             cwd=str(workspace_path),
             stdout=asyncio.subprocess.PIPE,
@@ -15946,7 +16066,7 @@ class RuntimeDaemon:
                     except RuntimeError:
                         return {"commit_error": "Refusing to commit: the task baseline changed while preparing the commit"}
                 _git_name, _git_email = _resolve_git_author(task.project)
-                proc = await asyncio.create_subprocess_exec(
+                proc = await _create_subprocess_exec(
                     "git", "commit", "-m", commit_msg,
                     cwd=str(workspace_path),
                     stdout=asyncio.subprocess.PIPE,
@@ -16110,7 +16230,7 @@ class RuntimeDaemon:
                     return {"commit_error": mode_change_error}
 
             # Check for uncommitted changes
-            proc = await asyncio.create_subprocess_exec(
+            proc = await _create_subprocess_exec(
                 "git", "status", "--porcelain",
                 cwd=str(workspace_path),
                 stdout=asyncio.subprocess.PIPE,
@@ -16129,7 +16249,7 @@ class RuntimeDaemon:
                 await self._remove_root_scratch_files(workspace_path, task, stdout.decode())
 
                 # Stage all changes
-                proc = await asyncio.create_subprocess_exec(
+                proc = await _create_subprocess_exec(
                     "git", "add", "-A",
                     cwd=str(workspace_path),
                     stdout=asyncio.subprocess.PIPE,
@@ -16178,7 +16298,7 @@ class RuntimeDaemon:
                     logger.warning("Failed to build rich commit message: %s — using fallback", msg_err)
                     commit_msg = f"{task.node_type}({task.requirement_key or task.task_id}): {display_title}"
                 _git_name, _git_email = _resolve_git_author(task.project)
-                proc = await asyncio.create_subprocess_exec(
+                proc = await _create_subprocess_exec(
                     "git", "commit", "-m", commit_msg,
                     cwd=str(workspace_path),
                     stdout=asyncio.subprocess.PIPE,
@@ -16905,7 +17025,7 @@ class RuntimeDaemon:
         """Collect staged diff stats for building a rich commit message."""
         status_map: dict[str, str] = {}
 
-        proc = await asyncio.create_subprocess_exec(
+        proc = await _create_subprocess_exec(
             "git", "diff", "--cached", "--name-status",
             cwd=str(cwd),
             stdout=asyncio.subprocess.PIPE,
@@ -16919,7 +17039,7 @@ class RuntimeDaemon:
                 status_map[parts[1].strip()] = parts[0].strip()
 
         files: list[dict] = []
-        proc = await asyncio.create_subprocess_exec(
+        proc = await _create_subprocess_exec(
             "git", "diff", "--cached", "--numstat",
             cwd=str(cwd),
             stdout=asyncio.subprocess.PIPE,
@@ -16948,7 +17068,7 @@ class RuntimeDaemon:
         for file_info in files[:20]:
             file_info["symbols"] = await self._extract_staged_file_symbols(cwd, file_info["path"])
 
-        proc = await asyncio.create_subprocess_exec(
+        proc = await _create_subprocess_exec(
             "git", "diff", "--cached", "--stat",
             cwd=str(cwd),
             stdout=asyncio.subprocess.PIPE,
@@ -16977,7 +17097,7 @@ class RuntimeDaemon:
         )
 
         try:
-            proc = await asyncio.create_subprocess_exec(
+            proc = await _create_subprocess_exec(
                 "git", "diff", "--cached", "--unified=0", "--", filepath,
                 cwd=str(cwd),
                 stdout=asyncio.subprocess.PIPE,
@@ -18022,7 +18142,7 @@ class RuntimeDaemon:
                 resolve_result = await self.process_manager.run_agent(agent, _cr_task, workspace_path)
 
             # 6. Check if conflicts are resolved
-            proc = await asyncio.create_subprocess_exec(
+            proc = await _create_subprocess_exec(
                 "git", "diff", "--name-only", "--diff-filter=U",
                 cwd=str(workspace_path),
                 stdout=asyncio.subprocess.PIPE,

{forgexa_cli-1.62.5 → forgexa_cli-1.63.1}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.62.5
+Version: 1.63.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.62.5 → forgexa_cli-1.63.1}/pyproject.toml

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