forgexa-cli 1.63.0__tar.gz → 1.64.0__tar.gz

{forgexa_cli-1.63.0 → forgexa_cli-1.64.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.63.0
+Version: 1.64.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.63.0 → forgexa_cli-1.64.0}/forgexa_cli/__init__.py

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

{forgexa_cli-1.63.0 → forgexa_cli-1.64.0}/forgexa_cli/agent_core.py

@@ -2871,6 +2871,7 @@ def mimo_base_env(env: dict[str, str]) -> dict[str, str]:
             },
             "external_directory": "deny",
             "task": "allow",
+            "actor": "allow",
             "skill": {"*": "allow", "compose:*": "deny"},
             "webfetch": "deny",
             "websearch": "deny",
@@ -3663,8 +3664,9 @@ def build_copilot_command(
     stdin instead - verified live on CLI 1.0.86, where piped stdin is a full
     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.
+    wrappers retain task-file redirection.  The host uses it for every prompt
+    so task text never passes through Windows batch argument parsing or
+    command-line limits, including when attachments are inlined.
     """
     cmd = [
         binary,

forgexa_cli-1.64.0/forgexa_cli/aws_evidence.py

@@ -0,0 +1,279 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from datetime import datetime
+from typing import Any
+from urllib.parse import urlsplit
+from uuid import UUID
+
+PAYLOAD_MAX_BYTES = 10 * 1024 * 1024
+SUMMARY_MAX_BYTES = 32 * 1024
+REFERENCE_FIELDS = frozenset(
+    {
+        "issuer",
+        "workspace_id",
+        "project_id",
+        "user_id",
+        "snapshot_id",
+        "payload_sha256",
+        "summary_sha256",
+    }
+)
+SECRET_FIELDS = frozenset(
+    {
+        "access_key_id",
+        "secret_access_key",
+        "session_token",
+        "private_key",
+        "encrypted_material",
+        "aws_access_key_id",
+        "aws_secret_access_key",
+        "aws_session_token",
+        "authorization",
+    }
+)
+
+
+class EvidenceError(ValueError):
+    pass
+
+
+def canonical_json(value: Any) -> str:
+    return json.dumps(
+        value, sort_keys=True, separators=(",", ":"), ensure_ascii=True, allow_nan=False
+    )
+
+
+def digest(value: Any) -> str:
+    return hashlib.sha256(canonical_json(value).encode("utf-8")).hexdigest()
+
+
+def model_destination(driver_id: str, environment: dict) -> dict:
+    if any(
+        environment.get(key) not in (None, "", "0", "false")
+        for key in (
+            "CLAUDE_CODE_USE_BEDROCK",
+            "CLAUDE_CODE_USE_VERTEX",
+            "CLAUDE_CODE_USE_FOUNDRY",
+        )
+    ):
+        raise EvidenceError("aws_evidence_unknown_provider")
+    defaults = {
+        "claude": ("anthropic", "https://api.anthropic.com"),
+        "copilot": ("github", "https://api.githubcopilot.com"),
+        "gemini": ("google", "https://generativelanguage.googleapis.com"),
+    }
+    explicit_keys = {
+        "claude": ("ANTHROPIC_BASE_URL",),
+        "mimo": ("ANTHROPIC_BASE_URL",),
+        "deepseek": ("DEEPSEEK_BASE_URL", "ANTHROPIC_BASE_URL"),
+        "copilot": ("COPILOT_API_URL", "GITHUB_COPILOT_BASE_URL", "GH_HOST"),
+        "gemini": ("GOOGLE_GEMINI_BASE_URL", "GEMINI_API_BASE_URL"),
+        "kimi": ("KIMI_BASE_URL", "OPENAI_BASE_URL"),
+    }
+    if driver_id not in explicit_keys:
+        raise EvidenceError("aws_evidence_unknown_provider")
+    endpoints = [environment[key] for key in explicit_keys[driver_id] if environment.get(key)]
+    if len(set(endpoints)) > 1 or (not endpoints and driver_id not in defaults):
+        raise EvidenceError("aws_evidence_unknown_provider")
+    endpoint = endpoints[0] if endpoints else defaults[driver_id][1]
+    parsed = urlsplit(endpoint)
+    known_hosts = {
+        "api.anthropic.com": "anthropic",
+        "api.githubcopilot.com": "github",
+        "api.individual.githubcopilot.com": "github",
+        "api.business.githubcopilot.com": "github",
+        "api.enterprise.githubcopilot.com": "github",
+        "generativelanguage.googleapis.com": "google",
+        "api.kimi.com": "moonshot",
+        "api.moonshot.cn": "moonshot",
+        "api.moonshot.ai": "moonshot",
+        "api.xiaomimimo.com": "xiaomi",
+        "api.deepseek.com": "deepseek",
+    }
+    provider = known_hosts.get(parsed.hostname or "")
+    if (
+        parsed.scheme != "https"
+        or parsed.username
+        or parsed.password
+        or not provider
+        or parsed.port not in (None, 443)
+    ):
+        raise EvidenceError("aws_evidence_unknown_provider")
+    return {"model_provider": provider, "endpoint": endpoint.rstrip("/")}
+
+
+def validate_reference(reference: Any) -> dict:
+    if not isinstance(reference, dict) or set(reference) != REFERENCE_FIELDS:
+        raise EvidenceError("aws_evidence_invalid_reference")
+    for field in ("workspace_id", "project_id", "user_id", "snapshot_id"):
+        value = reference[field]
+        if not isinstance(value, str):
+            raise EvidenceError("aws_evidence_invalid_reference")
+        try:
+            if str(UUID(value)) != value:
+                raise ValueError("Noncanonical identifier")
+        except ValueError:
+            raise EvidenceError("aws_evidence_invalid_reference") from None
+    for field in ("payload_sha256", "summary_sha256"):
+        if not isinstance(reference[field], str) or not re.fullmatch(
+            r"[0-9a-f]{64}", reference[field]
+        ):
+            raise EvidenceError("aws_evidence_invalid_reference")
+    issuer = reference["issuer"]
+    if (
+        not isinstance(issuer, str)
+        or len(issuer) > 2048
+        or not issuer.startswith(("https://", "http://"))
+    ):
+        raise EvidenceError("aws_evidence_invalid_reference")
+    return dict(reference)
+
+
+def _unique_object(pairs: list) -> dict:
+    result = {}
+    for key, value in pairs:
+        if key in result or key.lower() in SECRET_FIELDS:
+            raise EvidenceError("aws_evidence_invalid_payload")
+        result[key] = value
+    return result
+
+
+def _reject_constant(value: str) -> None:
+    raise EvidenceError("aws_evidence_invalid_payload")
+
+
+def validate_payload(reference: Any, metadata: Any, payload: Any, model_provider: str) -> dict:
+    reference = validate_reference(reference)
+    if not isinstance(payload, str) or len(payload.encode("utf-8")) > PAYLOAD_MAX_BYTES:
+        raise EvidenceError("aws_evidence_size_limit")
+    if hashlib.sha256(payload.encode("utf-8")).hexdigest() != reference["payload_sha256"]:
+        raise EvidenceError("aws_evidence_integrity_failed")
+    if not isinstance(metadata, dict) or metadata.get("status") not in ("ready", "partial"):
+        raise EvidenceError("aws_evidence_unavailable")
+    for field in REFERENCE_FIELDS - {"issuer"}:
+        if metadata.get(field) != reference[field]:
+            raise EvidenceError("aws_evidence_identity_mismatch")
+    policy = metadata.get("data_policy")
+    if (
+        not isinstance(policy, dict)
+        or policy.get("allow_agent_transfer") is not True
+        or not isinstance(policy.get("allowed_model_providers"), list)
+        or not model_provider
+        or model_provider not in policy.get("allowed_model_providers", [])
+        or type(policy.get("policy_version")) is not int
+        or policy["policy_version"] < 1
+    ):
+        raise EvidenceError("aws_evidence_policy_denied")
+    try:
+        expires = datetime.fromisoformat(str(metadata["expires_at"]).replace("Z", "+00:00"))
+        if expires.tzinfo is None or expires <= datetime.now(expires.tzinfo):
+            raise ValueError("Expired")
+        evidence = json.loads(
+            payload, object_pairs_hook=_unique_object, parse_constant=_reject_constant
+        )
+    except (ValueError, TypeError, KeyError, RecursionError):
+        raise EvidenceError("aws_evidence_invalid_payload") from None
+    if (
+        not isinstance(evidence, dict)
+        or evidence.get("schema_version") != 1
+        or evidence.get("provider") != "aws_metrics"
+    ):
+        raise EvidenceError("aws_evidence_invalid_payload")
+    if evidence.get("snapshot_id") != reference["snapshot_id"]:
+        raise EvidenceError("aws_evidence_identity_mismatch")
+    origin = evidence.get("origin")
+    if not isinstance(origin, dict) or any(
+        origin.get(key) != reference[field]
+        for key, field in (
+            ("issuer", "issuer"),
+            ("workspace_id", "workspace_id"),
+            ("project_id", "project_id"),
+            ("created_by_user_id", "user_id"),
+        )
+    ):
+        raise EvidenceError("aws_evidence_identity_mismatch")
+    sources, resources, metrics = (
+        evidence.get("sources"),
+        evidence.get("resources"),
+        evidence.get("metrics"),
+    )
+    if not isinstance(sources, list) or not 1 <= len(sources) <= 8:
+        raise EvidenceError("aws_evidence_invalid_sources")
+    source_ids = set()
+    for source in sources:
+        if (
+            not isinstance(source, dict)
+            or not isinstance(source.get("source_id"), str)
+            or source["source_id"] in source_ids
+            or not re.fullmatch(r"\d{12}", str(source.get("account_id", "")))
+            or source.get("partition") not in ("aws", "aws-cn", "aws-us-gov")
+            or not isinstance(source.get("region"), str)
+            or not isinstance(source.get("aws_profile_id"), str)
+            or type(source.get("credential_version")) is not int
+            or source["credential_version"] < 1
+        ):
+            raise EvidenceError("aws_evidence_invalid_sources")
+        source_ids.add(source["source_id"])
+    if (
+        not isinstance(resources, list)
+        or len(resources) > 20
+        or not isinstance(metrics, list)
+        or len(metrics) > 100
+    ):
+        raise EvidenceError("aws_evidence_size_limit")
+    resource_sources = {}
+    for resource in resources:
+        if (
+            not isinstance(resource, dict)
+            or not isinstance(resource.get("resource_ref"), str)
+            or not isinstance(resource.get("source_id"), str)
+            or resource["resource_ref"] in resource_sources
+            or resource.get("source_id") not in source_ids
+        ):
+            raise EvidenceError("aws_evidence_invalid_resources")
+        resource_sources[resource["resource_ref"]] = resource["source_id"]
+    metric_ids = set()
+    for metric in metrics:
+        if (
+            not isinstance(metric, dict)
+            or not isinstance(metric.get("evidence_ref"), str)
+            or not isinstance(metric.get("source_id"), str)
+            or not isinstance(metric.get("resource_ref"), str)
+            or metric["evidence_ref"] in metric_ids
+            or metric.get("source_id") not in source_ids
+            or resource_sources.get(metric.get("resource_ref")) != metric["source_id"]
+            or not isinstance(metric.get("data_status"), str)
+        ):
+            raise EvidenceError("aws_evidence_invalid_metrics")
+        metric_ids.add(metric["evidence_ref"])
+    selection = evidence.get("selection")
+    if not isinstance(selection, dict) or selection.get("scope_mode") not in ("common", "market"):
+        raise EvidenceError("aws_evidence_invalid_selection")
+    if selection["scope_mode"] == "common" and "country_codes" in selection:
+        raise EvidenceError("aws_evidence_invalid_selection")
+    summary = {
+        **evidence,
+        "metrics": [
+            {key: value for key, value in metric.items() if key != "datapoints"}
+            for metric in metrics
+        ],
+    }
+    try:
+        summary_json = canonical_json(summary)
+    except (ValueError, TypeError):
+        raise EvidenceError("aws_evidence_invalid_payload") from None
+    if len(summary_json.encode("utf-8")) > SUMMARY_MAX_BYTES:
+        raise EvidenceError("aws_evidence_size_limit")
+    if digest(summary) != reference["summary_sha256"]:
+        raise EvidenceError("aws_evidence_integrity_failed")
+    return {
+        "reference": reference,
+        "summary": summary,
+        "summary_json": summary_json,
+        "data_policy": dict(policy),
+        "expires_at": metadata["expires_at"],
+        "model_provider": model_provider,
+    }

{forgexa_cli-1.63.0 → forgexa_cli-1.64.0}/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.63.0"
+DAEMON_VERSION = "1.64.0"
 
 
 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)
@@ -6752,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,
@@ -7828,7 +7889,7 @@ class ProcessManager:
                 pass
 
         try:
-            proc = await asyncio.create_subprocess_exec(
+            proc = await _create_subprocess_exec(
                 *cmd,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
@@ -8221,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,
@@ -8313,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,
@@ -8324,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,
@@ -8335,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,
@@ -8347,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,
@@ -8362,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,
@@ -8373,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,
@@ -8419,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,
@@ -8432,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,
@@ -8444,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,
@@ -8459,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,
@@ -8470,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,
@@ -8787,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,
@@ -8812,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)
@@ -9014,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",
@@ -9033,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
@@ -9159,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
@@ -9352,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
@@ -9909,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()
@@ -10607,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] = {}
@@ -10676,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
 
@@ -10725,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
         )
@@ -11492,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)",
@@ -11515,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:
@@ -11609,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:
@@ -11657,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
 
@@ -11715,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)
@@ -12059,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
@@ -12090,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(
@@ -12978,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:
@@ -15641,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,
@@ -15696,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,
@@ -15954,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,
@@ -16118,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,
@@ -16137,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,
@@ -16186,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,
@@ -16913,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,
@@ -16927,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,
@@ -16956,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,
@@ -16985,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,
@@ -18030,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.63.0 → forgexa_cli-1.64.0}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.63.0
+Version: 1.64.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.63.0 → forgexa_cli-1.64.0}/forgexa_cli.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ forgexa_cli/_build_config.py
 forgexa_cli/_local_bind.py
 forgexa_cli/agent_core.py
 forgexa_cli/autoupgrade.py
+forgexa_cli/aws_evidence.py
 forgexa_cli/daemon.py
 forgexa_cli/main.py
 forgexa_cli/py.typed

{forgexa_cli-1.63.0 → forgexa_cli-1.64.0}/pyproject.toml

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