forgexa-cli 1.59.2__tar.gz → 1.60.1__tar.gz

{forgexa_cli-1.59.2 → forgexa_cli-1.60.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.59.2
+Version: 1.60.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
@@ -35,7 +35,7 @@ Requires-Dist: socksio>=1.0.0; extra == "daemon"
 Command-line client and agent runtime for the [Forgexa](https://forgexa.net) platform.
 
 Communicates with the Forgexa server via REST API.
-Includes a built-in **daemon** that discovers twelve local AI agent integrations (Claude Code, Codex, GitHub Copilot, Gemini CLI, OpenCode, Kimi Code, MiMo Code, Qwen Code, CodeBuddy, Qoder CLI, TraeCode CLI, and ZCode) and executes tasks on behalf of the server. MiMo Code (`mimo`, v0.1.14+), Qwen Code (`qwen`, v0.24.1+), CodeBuddy (`codebuddy`, v2.156.0+), Qoder CLI (`qoder`, v1.1.59+), TraeCode CLI (`trae`), and ZCode (`zcode`) are selected explicitly; automatic routing and generated default fallback chains exclude all six. CodeBuddy and Qoder completed their local AgentHost start/resume acceptance gates. Authentication, endpoint, and model selection remain in each local CLI profile; Forgexa never stores or overrides them.
+Includes a built-in **daemon** with thirteen integrations: Claude Code, Codex, GitHub Copilot, Gemini CLI, OpenCode, Kimi Code, MiMo Code, Qwen Code, CodeBuddy, Qoder CLI, TraeCode CLI, ZCode, and DeepSeek Harness. Six standard candidates are automatically routed; seven require explicit selection. Harness (`deepseek`) is a developer preview for personal Runtimes/Desktop, pinned to 0.2.0-rc.2 and Node 22.19+ within 22.x or 24+. It owns a managed runtime profile with read-only external credentials, without copying personal settings. Shared pools/native Windows are blocked. After exact-build live acceptance, `forgexa agent approve-live deepseek` records an attestation; `forgexa check --agent deepseek --quick` avoids model calls, while normal `check` runs a potentially billable minimal task. See [global/local installation and limits](../documentation/guide/agent-installation.md#deepseek-harness-developer-preview).
 
 ## Installation
 

{forgexa_cli-1.59.2 → forgexa_cli-1.60.1}/README.md

@@ -3,7 +3,7 @@
 Command-line client and agent runtime for the [Forgexa](https://forgexa.net) platform.
 
 Communicates with the Forgexa server via REST API.
-Includes a built-in **daemon** that discovers twelve local AI agent integrations (Claude Code, Codex, GitHub Copilot, Gemini CLI, OpenCode, Kimi Code, MiMo Code, Qwen Code, CodeBuddy, Qoder CLI, TraeCode CLI, and ZCode) and executes tasks on behalf of the server. MiMo Code (`mimo`, v0.1.14+), Qwen Code (`qwen`, v0.24.1+), CodeBuddy (`codebuddy`, v2.156.0+), Qoder CLI (`qoder`, v1.1.59+), TraeCode CLI (`trae`), and ZCode (`zcode`) are selected explicitly; automatic routing and generated default fallback chains exclude all six. CodeBuddy and Qoder completed their local AgentHost start/resume acceptance gates. Authentication, endpoint, and model selection remain in each local CLI profile; Forgexa never stores or overrides them.
+Includes a built-in **daemon** with thirteen integrations: Claude Code, Codex, GitHub Copilot, Gemini CLI, OpenCode, Kimi Code, MiMo Code, Qwen Code, CodeBuddy, Qoder CLI, TraeCode CLI, ZCode, and DeepSeek Harness. Six standard candidates are automatically routed; seven require explicit selection. Harness (`deepseek`) is a developer preview for personal Runtimes/Desktop, pinned to 0.2.0-rc.2 and Node 22.19+ within 22.x or 24+. It owns a managed runtime profile with read-only external credentials, without copying personal settings. Shared pools/native Windows are blocked. After exact-build live acceptance, `forgexa agent approve-live deepseek` records an attestation; `forgexa check --agent deepseek --quick` avoids model calls, while normal `check` runs a potentially billable minimal task. See [global/local installation and limits](../documentation/guide/agent-installation.md#deepseek-harness-developer-preview).
 
 ## Installation
 

{forgexa_cli-1.59.2 → forgexa_cli-1.60.1}/forgexa_cli/__init__.py

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

{forgexa_cli-1.59.2 → forgexa_cli-1.60.1}/forgexa_cli/agent_core.py

@@ -46,12 +46,14 @@ import hashlib
 import json
 import logging
 import os
+import platform
 import re
 import shutil
 import subprocess
 import tempfile
 import time
-from dataclasses import dataclass
+from contextlib import contextmanager
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
@@ -529,6 +531,34 @@ def _agent_discovery_verification_issue(agent_id: str, binary: str) -> str | Non
     return agent_execution_verification_issue(agent_id, binary)
 
 
+def canonical_agent_id(agent_id: str | None) -> str | None:
+    return "deepseek" if agent_id == "deepseek-harness" else agent_id
+
+
+def canonical_agent_inventory(agents: list | None) -> list | None:
+    if not isinstance(agents, list) or not agents:
+        return agents
+    return [
+        {**entry, "agent_id": "deepseek", "reported_agent_id": "deepseek-harness"}
+        if isinstance(entry, dict) and entry.get("agent_id") == "deepseek-harness" else entry
+        for entry in agents
+    ]
+
+
+def runtime_agent_wire_id(agent_id: str | None, available_agents: list | None) -> str | None:
+    canonical = canonical_agent_id(agent_id)
+    if canonical != "deepseek":
+        return canonical
+    reported = [
+        entry.get("reported_agent_id") or entry.get("agent_id")
+        for entry in available_agents or []
+        if isinstance(entry, dict) and canonical_agent_id(entry.get("agent_id")) == canonical
+    ]
+    if "deepseek" not in reported and "deepseek-harness" in reported:
+        return "deepseek-harness"
+    return canonical
+
+
 # ── Agent Discovery ──
 
 
@@ -582,6 +612,17 @@ class AgentDiscovery:
             ),
             "upgrade_hint": "mimo upgrade",
         },
+        "deepseek": {
+            "commands": ["dsh"],
+            "detect": "dsh --version",
+            "invoke_modes": ["cli"],
+            "env_path_override": "FACTORY_DEEPSEEK_HARNESS_PATH",
+            "env_model_override": "FACTORY_DEEPSEEK_HARNESS_MODEL",
+            "compatibility_level": "L2",
+            "min_version": (0, 2, 0),
+            "strict_min_version": True,
+            "upgrade_hint": "npm i -g @deepseek-ai/dsh@0.2.0-rc.2",
+        },
         "qwen": {
             "commands": ["qwen"],
             "detect": "qwen --version",
@@ -872,7 +913,7 @@ class AgentDiscovery:
                     )
                     continue
                 min_version_ok, version_warning = _check_agent_min_version(agent_id, version, spec)
-                verification_issue = _agent_discovery_verification_issue(agent_id, resolved)
+                verification_issue = await asyncio.to_thread(_agent_discovery_verification_issue, agent_id, resolved)
                 if verification_issue:
                     min_version_ok = False
                     version_warning = verification_issue
@@ -916,6 +957,8 @@ class AgentDiscovery:
                     parts[0] = resolved
             parts = _prepare_agent_command(parts, preserve_argv=False)
             env = None
+            if detect_cmd == "dsh --version":
+                env = deepseek_harness_probe_env()
             if detect_cmd in ("opencode --version", "mimo --version"):
                 probe_dir = tempfile.TemporaryDirectory(prefix=f"forgexa-{detect_cmd.split()[0]}-probe-")
                 env = os.environ.copy()
@@ -2111,6 +2154,591 @@ def build_mimo_command(
     return cmd
 
 
+DEEPSEEK_HARNESS_VERSION = "0.2.0-rc.2"
+DEEPSEEK_HARNESS_MAX_OUTPUT_BYTES = 4 * 1024 * 1024
+DEEPSEEK_HARNESS_APPROVAL_FILE = Path.home() / ".forgexa" / "deepseek-harness-approved.json"
+
+
+def _reject_nonfinite_json(value: str) -> None:
+    raise ValueError("Non-finite JSON number")
+
+
+@dataclass
+class DeepSeekHarnessRunState:
+    """Validate one headless invocation independently of retained log tails."""
+
+    expected_cwd: str | None = None
+    session_id: str | None = None
+    text: str = ""
+    reason: dict | None = None
+    error: str | None = None
+    failure_code: str | None = None
+    started: bool = False
+    saw_final: bool = False
+    usage_incomplete: bool = False
+    usage_steps: dict = field(default_factory=dict)
+
+    def fail(self, message: str, code: str = "deepseek_harness_protocol_error") -> None:
+        if self.error is None:
+            self.error = message[:2000]
+            self.failure_code = code
+
+    def feed_line(self, line: str) -> dict | None:
+        if len(line.encode("utf-8")) > DEEPSEEK_HARNESS_MAX_OUTPUT_BYTES:
+            self.fail("Harness output exceeds the allowed size", "deepseek_harness_output_limit")
+            return None
+        try:
+            event = json.loads(line, parse_constant=_reject_nonfinite_json)
+        except (ValueError, RecursionError):
+            self.fail("Harness stdout must contain valid JSONL events")
+            return None
+        if not isinstance(event, dict):
+            self.fail("Harness event must be an object")
+            return None
+        self.feed(event)
+        return event
+
+    def feed(self, event: dict) -> None:
+        event_type = event.get("type")
+        if self.saw_final:
+            self.fail("Harness emitted data after its final event")
+            return
+        if event_type == "error":
+            message = event.get("message")
+            if not isinstance(message, str):
+                self.fail("Harness error event is missing its message")
+                return
+            missing = not self.started and re.search(
+                r'^session ".+" does not exist; omit --session-id', message,
+            )
+            self.fail(message, "native_session_not_found" if missing else "deepseek_harness_error")
+            return
+        if event_type == "session":
+            session_id, cwd = event.get("sessionId"), event.get("cwd")
+            if (
+                self.session_id is not None or event.get("truncated")
+                or not isinstance(session_id, str) or not session_id.strip()
+                or len(session_id) > 256 or "\0" in session_id
+                or not isinstance(cwd, str) or not cwd or "\0" in cwd
+            ):
+                self.fail("Harness session identity is missing, duplicated or truncated")
+                return
+            if self.expected_cwd and Path(cwd).resolve() != Path(self.expected_cwd).resolve():
+                self.fail("Harness session belongs to another workspace", "deepseek_harness_session_incompatible")
+                return
+            self.session_id = session_id
+            return
+        if self.session_id is None:
+            self.fail("Harness output did not begin with a session event")
+            return
+        if event_type == "status":
+            phase = event.get("phase")
+            if phase not in {"turn_start", "step_start", "step_end", "turn_end"}:
+                self.fail("Harness emitted an unsupported status phase")
+            elif phase == "turn_start":
+                if self.started:
+                    self.fail("Harness emitted more than one turn")
+                self.started = True
+            elif not self.started or self.reason is not None:
+                self.fail("Harness emitted an out-of-order turn status")
+            elif phase == "turn_end":
+                reason = event.get("reason")
+                if (
+                    not isinstance(reason, dict) or not isinstance(reason.get("kind"), str)
+                    or ("error" in reason and not isinstance(reason["error"], dict))
+                    or event.get("truncated")
+                ):
+                    self.fail("Harness terminal reason is missing or truncated")
+                else:
+                    self.reason = reason
+            elif phase == "step_end" and "usage" in event:
+                usage = event["usage"]
+                if (
+                    not isinstance(usage, dict)
+                    or any(not isinstance(usage.get(key), int) or isinstance(usage.get(key), bool) or usage[key] < 0 for key in ("inputTokens", "outputTokens"))
+                    or any(not isinstance(value, int) or isinstance(value, bool) or value < 0 for value in usage.values())
+                ):
+                    self.fail("Harness usage sample is invalid")
+                else:
+                    self.usage_steps[(str(event.get("turn")), str(event.get("step")))] = usage
+            elif phase == "step_end":
+                self.usage_incomplete = True
+            return
+        if event_type == "final":
+            final_text = event.get("text")
+            if not isinstance(final_text, str) or self.reason is None or event.get("truncated"):
+                self.fail("Harness final answer is missing or arrived before its terminal reason")
+            elif len(final_text.encode("utf-8")) > DEEPSEEK_HARNESS_MAX_OUTPUT_BYTES:
+                self.fail("Harness final answer exceeds the allowed size", "deepseek_harness_output_limit")
+            else:
+                self.text = final_text
+                self.saw_final = True
+            return
+        if event_type in {"text", "thinking"}:
+            if not isinstance(event.get("text"), str) and not event.get("truncated"):
+                self.fail("Harness text event is missing its text")
+        elif event_type in {"tool_call", "tool_result"}:
+            call_id = event.get("callId")
+            if not isinstance(call_id, str) or not call_id.strip() or len(call_id) > 256 or "\0" in call_id:
+                self.fail("Harness tool event is missing a valid native callId")
+            elif event_type == "tool_call" and not isinstance(event.get("tool"), str):
+                self.fail("Harness tool call is missing its tool name")
+            elif event_type == "tool_result" and event.get("status") not in {"completed", "error"}:
+                self.fail("Harness tool result has an unsupported status")
+        else:
+            self.fail("Harness emitted an unsupported event type")
+
+    def finish(self, exit_code: int, *, cancelled: bool = False) -> dict:
+        if not cancelled and self.error is None:
+            if not self.started or self.reason is None or not self.saw_final:
+                self.fail("Harness exited without a complete turn and final answer")
+            elif self.reason.get("kind") != "completed":
+                detail = self.reason.get("error") or {}
+                self.fail(
+                    str(detail.get("message") or f"Harness turn ended: {self.reason['kind']}"),
+                    str(detail.get("code") or "deepseek_harness_turn_failed"),
+                )
+            elif exit_code != 0:
+                self.fail(f"Harness exited with code {exit_code}", "agent_exit_code")
+        metrics = {}
+        for native, normalized in (
+            ("inputTokens", "input_tokens"), ("outputTokens", "output_tokens"),
+            ("cacheReadTokens", "cache_read_tokens"), ("cacheWriteTokens", "cache_write_tokens"),
+            ("reasoningTokens", "reasoning_tokens"),
+        ):
+            if not self.usage_incomplete and self.usage_steps and all(native in sample for sample in self.usage_steps.values()):
+                metrics[normalized] = sum(sample[native] for sample in self.usage_steps.values())
+        return {
+            "status": "cancelled" if cancelled else "failed" if self.error else "success",
+            "text": self.text, "summary": self.text[-2000:],
+            "session_id": self.session_id,
+            "error": None if cancelled else self.error,
+            "failure_code": None if cancelled else self.failure_code,
+            "is_error": not cancelled and self.error is not None,
+            "metrics": metrics,
+        }
+
+
+def build_deepseek_harness_command(
+    binary: str,
+    *,
+    overlay_path: str | Path,
+    session_id: str | None = None,
+) -> list[str]:
+    """Build a headless JSONL invocation whose prompt arrives through stdin."""
+    command = [
+        binary, "--profile", "headless", "--patch", str(overlay_path), "--json",
+    ]
+    if session_id is not None:
+        if not session_id.strip():
+            raise ValueError("DeepSeek Harness session ID must not be blank")
+        command += ["--session-id", session_id]
+    return command
+
+
+def _deepseek_harness_package_roots(binary: str) -> list[Path]:
+    resolved = Path(binary).resolve()
+    roots = []
+    for name in ("dsh", "dsh-headless", "dsh-base"):
+        candidates = []
+        for parent in (resolved.parent, *list(resolved.parents)[:6]):
+            candidates.extend((parent, parent / "node_modules" / "@deepseek-ai" / name, parent / "@deepseek-ai" / name))
+        for candidate in candidates:
+            manifest = candidate / "package.json"
+            try:
+                metadata = json.loads(manifest.read_text(encoding="utf-8"))
+            except (OSError, ValueError):
+                continue
+            if isinstance(metadata, dict) and metadata.get("name") == f"@deepseek-ai/{name}":
+                if metadata.get("version") != DEEPSEEK_HARNESS_VERSION:
+                    raise RuntimeError(f"DeepSeek Harness requires the verified {DEEPSEEK_HARNESS_VERSION} package set")
+                roots.append(candidate.resolve())
+                break
+        else:
+            raise RuntimeError(f"Could not locate the installed @deepseek-ai/{name} package")
+    return roots
+
+
+def deepseek_harness_probe_env() -> dict[str, str]:
+    allowed = {"PATH", "HOME", "USERPROFILE", "SYSTEMROOT", "WINDIR", "COMSPEC", "PATHEXT", "TEMP", "TMP", "LANG", "LC_ALL"}
+    return {key: value for key, value in os.environ.items() if key.upper() in allowed}
+
+
+def deepseek_harness_build_info(binary: str) -> dict:
+    roots = _deepseek_harness_package_roots(binary)
+    node = shutil.which("node")
+    if not node:
+        raise RuntimeError("DeepSeek Harness requires Node.js")
+    result = subprocess.run([node, "-p", "process.versions.node"], capture_output=True, text=True, timeout=10, env=deepseek_harness_probe_env())
+    node_version = result.stdout.strip()
+    parsed = _parse_semver(node_version)
+    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-2".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"))
+        if (root / "cordis.patch.yml").is_file():
+            files.append(root / "cordis.patch.yml")
+        for filename in files:
+            digest.update(str(filename.relative_to(root)).encode())
+            digest.update(filename.read_bytes())
+    return {"version": DEEPSEEK_HARNESS_VERSION, "fingerprint": digest.hexdigest(), "node_version": node_version, "package_root": str(roots[0])}
+
+
+def deepseek_harness_verification_issue(binary: str) -> str | None:
+    try:
+        information = deepseek_harness_build_info(binary)
+        if sys.platform not in {"darwin", "linux"}:
+            return "DeepSeek Harness outer isolation is not verified on this platform"
+        required = "sandbox-exec" if sys.platform == "darwin" else "bwrap"
+        if not shutil.which(required):
+            return f"DeepSeek Harness requires the {required} outer sandbox"
+        approved = json.loads(DEEPSEEK_HARNESS_APPROVAL_FILE.read_text(encoding="utf-8"))
+        if (
+            isinstance(approved, dict) and approved.get("version") == 1
+            and isinstance(approved.get("builds"), list)
+            and information["fingerprint"] in approved["builds"]
+        ):
+            return None
+    except (OSError, ValueError, RuntimeError, subprocess.SubprocessError):
+        pass
+    return (
+        "DeepSeek Harness requires live start/resume/cancel/isolation acceptance "
+        "for this installed build; then run `forgexa agent approve-live deepseek`"
+    )
+
+
+def approve_deepseek_harness_build(binary: str) -> dict:
+    information = deepseek_harness_build_info(binary)
+    DEEPSEEK_HARNESS_APPROVAL_FILE.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    document = {"version": 1, "builds": [information["fingerprint"]], "runtime_version": information["version"]}
+    with tempfile.NamedTemporaryFile("w", encoding="utf-8", dir=DEEPSEEK_HARNESS_APPROVAL_FILE.parent, delete=False) as temporary:
+        json.dump(document, temporary)
+        temporary_path = Path(temporary.name)
+    try:
+        if sys.platform != "win32":
+            temporary_path.chmod(0o600)
+        os.replace(temporary_path, DEEPSEEK_HARNESS_APPROVAL_FILE)
+    finally:
+        temporary_path.unlink(missing_ok=True)
+    return information
+
+
+def deepseek_harness_base_env(env: dict[str, str], *, home: str | Path, temporary_root: str | Path) -> dict[str, str]:
+    allowed = {
+        "PATH", "HOME", "USER", "LOGNAME", "USERPROFILE", "HOMEDRIVE", "HOMEPATH",
+        "SYSTEMROOT", "WINDIR", "COMSPEC", "APPDATA", "LOCALAPPDATA", "LANG", "LC_ALL",
+        "LC_CTYPE", "TERM", "HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "NO_PROXY",
+        "NODE_EXTRA_CA_CERTS", "SSL_CERT_FILE", "SSL_CERT_DIR", "DEEPSEEK_API_KEY",
+    }
+    controlled = {name: value for name, value in env.items() if name.upper() in allowed}
+    controlled.update({
+        "DSH_HOME": str(home), "DSH_PERMISSION_MODE": "workspace-write",
+        "DSH_TELEMETRY_DISABLED": "1", "DSH_TOOLS_MODE": "native",
+        "TMPDIR": str(temporary_root), "TMP": str(temporary_root), "TEMP": str(temporary_root),
+        "DEEPSEEK_BASE_URL": "https://api.deepseek.com/anthropic",
+        "GIT_CONFIG_GLOBAL": os.devnull, "GIT_CONFIG_NOSYSTEM": "1",
+        "GIT_TERMINAL_PROMPT": "0", "GIT_OPTIONAL_LOCKS": "0",
+    })
+    return controlled
+
+
+def deepseek_harness_configuration(binary: str, credentials_path: Path, env: dict[str, str]) -> dict:
+    package_root = _deepseek_harness_package_roots(binary)[0]
+    script = """
+const fs = require('node:fs');
+const path = require('node:path');
+const {createRequire} = require('node:module');
+try {
+  const localRequire = createRequire(path.join(process.argv[1], 'package.json'));
+  const yaml = localRequire('js-yaml');
+  const document = fs.existsSync(process.argv[2]) ? yaml.load(fs.readFileSync(process.argv[2], 'utf8')) : {};
+  const apiKey = Boolean(process.env.DEEPSEEK_API_KEY || document?.refs?.DEEPSEEK_API_KEY);
+  const account = Object.entries(document?.records || {}).some(([name, entry]) => name.includes('deepseek') && entry?.kind === 'grant');
+  console.log(JSON.stringify({provider: apiKey ? 'deepseek-official' : account ? 'deepseek-account' : null}));
+} catch {
+  console.log(JSON.stringify({error: 'Harness credentials could not be validated'}));
+}
+"""
+    result = subprocess.run(
+        [shutil.which("node") or "node", "-e", script, str(package_root), str(credentials_path)],
+        capture_output=True, text=True, timeout=10, env=env,
+    )
+    if result.returncode or len(result.stdout) > 4096:
+        raise RuntimeError("Harness credential inspection failed")
+    metadata = json.loads(result.stdout)
+    if metadata.get("error") or metadata.get("provider") not in {"deepseek-official", "deepseek-account"}:
+        raise RuntimeError("DeepSeek Harness requires an API key or an existing DeepSeek account login")
+    return metadata
+
+
+def deepseek_harness_home(workspace_path: str | Path) -> Path:
+    root = str(Path(workspace_path).expanduser().resolve())
+    key = hashlib.sha256(root.encode("utf-8")).hexdigest()
+    return Path.home() / ".forgexa" / "agents" / "deepseek-harness" / key
+
+
+def deepseek_harness_profile_lock_path(workspace_path: str | Path) -> Path:
+    return deepseek_harness_home(workspace_path) / "profile.lock"
+
+
+def deepseek_harness_overlay(*, cwd: Path, credentials_path: Path, provider: str, model: str) -> list[dict]:
+    if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._:/-]{0,199}", model):
+        raise ValueError("Invalid DeepSeek Harness model ID")
+    rows = [
+        {"id": "agent-default-model", "config": {"provider": provider, "model": model, "reasoningEffort": "high"}},
+        {"id": "credentials", "config": {"path": str(credentials_path), "watch": False}},
+        {"id": "approval", "config": {"policy": "never"}},
+        {"id": "permission", "config": {
+            "presets": {"forgexa-workspace": {"sandbox": "workspace-write", "approval": "never"}},
+            "defaultPreset": "forgexa-workspace",
+        }},
+        {"id": "sandbox-policy", "config": {"mode": "workspace-write", "workspaceRoot": str(cwd)}},
+        {"id": "fs-sandbox", "config": {"cwd": str(cwd)}},
+        {"id": "tools", "config": {"mode": "native"}},
+        {"id": "session-log-deepseek", "config": {"enabled": False}},
+        {"id": "plugin-package-inventory-deepseek", "config": {"enabled": False}},
+    ]
+    disabled = (
+        "session-telemetry-otel", "hmr", "plugin-manager", "tool-plugin-manager",
+        "llm-pi-ai", "skill-filesystem", "tool-skill", "tool-subagent", "tool-subagent-fork",
+        "tool-subagent-control", "tool-subagent-list-agents", "tool-workflow",
+        "goal-round-driver", "command-goal", "tool-goal", "command-feedback", "tool-web",
+    )
+    rows.extend({"id": name, "disabled": True} for name in disabled)
+    rows.extend([
+        {"id": "deepseek-account", "disabled": provider != "deepseek-account"},
+        {"id": "llm-deepseek-account", "disabled": provider != "deepseek-account"},
+        {"id": "llm-deepseek", "disabled": provider != "deepseek-official", "config": {
+            "apiKeyEnv": "DEEPSEEK_API_KEY", "baseURL": "https://api.deepseek.com/anthropic",
+            "reasoningEffort": "high", "maxTokens": 32768,
+        }},
+    ])
+    return rows
+
+
+def _deepseek_harness_git_roots(cwd: Path) -> list[Path]:
+    roots = [cwd / ".git"]
+    if roots[0].is_file():
+        content = roots[0].read_text(encoding="utf-8")[:4096]
+        if content.startswith("gitdir:"):
+            git_dir = (cwd / content[7:].strip()).resolve()
+            roots.append(git_dir)
+            common = git_dir / "commondir"
+            if common.is_file():
+                roots.append((git_dir / common.read_text(encoding="utf-8").strip()).resolve())
+    return roots
+
+
+def deepseek_harness_sandbox_command(command: list[str], *, cwd: Path, home: Path, temporary_root: Path, credentials_path: Path | None = None) -> list[str]:
+    git_roots = [*_deepseek_harness_git_roots(cwd), home / "forgexa-session-bindings"]
+    if credentials_path is not None:
+        git_roots.append(credentials_path)
+    if sys.platform == "darwin":
+        sandbox = shutil.which("sandbox-exec")
+        if not sandbox:
+            raise RuntimeError("DeepSeek Harness outer sandbox is unavailable")
+        writable = " ".join(f"(subpath {json.dumps(str(root.resolve()))})" for root in (cwd, home, temporary_root))
+        protected = " ".join(f"(subpath {json.dumps(str(root.resolve()))})" for root in git_roots)
+        profile = f'(version 1) (allow default) (deny file-write*) (allow file-write* {writable} (literal "/dev/null")) (deny file-write* {protected})'
+        return [sandbox, "-p", profile, *command]
+    if sys.platform == "linux":
+        sandbox = shutil.which("bwrap")
+        if not sandbox:
+            raise RuntimeError("DeepSeek Harness requires a working bubblewrap outer sandbox")
+        wrapped = [sandbox, "--die-with-parent", "--unshare-pid", "--ro-bind", "/", "/", "--proc", "/proc", "--dev", "/dev"]
+        for root in (cwd, home, temporary_root):
+            wrapped += ["--bind", str(root), str(root)]
+        for root in git_roots:
+            if root.exists():
+                wrapped += ["--ro-bind", str(root.resolve()), str(root.resolve())]
+        return [*wrapped, "--chdir", str(cwd), "--", *command]
+    raise RuntimeError("DeepSeek Harness outer isolation has not been verified on this platform")
+
+
+@contextmanager
+def deepseek_harness_runtime(binary: str, workspace_path: str | Path, *, model: str | None = None, session_id: str | None = None):
+    binary = os.path.abspath(shutil.which(binary) or os.path.expanduser(binary))
+    cwd = Path(workspace_path).expanduser().resolve()
+    home = deepseek_harness_home(cwd)
+    home.mkdir(parents=True, exist_ok=True, mode=0o700)
+    if sys.platform != "win32":
+        home.chmod(0o700)
+    lock = acquire_file_lock(deepseek_harness_profile_lock_path(cwd))
+    if lock is None:
+        raise RuntimeError("DeepSeek Harness profile is busy with another local turn")
+    try:
+        bindings = home / "forgexa-session-bindings"
+        bindings.mkdir(exist_ok=True, mode=0o700)
+        profile = home / "profiles" / "headless"
+        for untrusted in (home / "cordis.patch.yml", profile / "node_modules", home / "profiles" / "node_modules"):
+            if untrusted.exists() or untrusted.is_symlink():
+                raise RuntimeError("The managed Harness home must not contain user patches or plugin overrides")
+        patch = profile / "cordis.patch.yml"
+        if patch.is_file():
+            effective_lines = [
+                line.strip() for line in patch.read_text(encoding="utf-8").splitlines()
+                if line.strip() and not line.lstrip().startswith("#")
+            ]
+            if effective_lines not in ([], ["[]"]):
+                raise RuntimeError("The managed Harness profile must not contain user patches")
+        manifest = profile / "package.json"
+        if manifest.is_file():
+            bundles = json.loads(manifest.read_text(encoding="utf-8")).get("dsh", {}).get("profile", {}).get("bundles")
+            if bundles != ["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-headless"]:
+                raise RuntimeError("The managed Harness profile contains an unsupported bundle")
+        with tempfile.TemporaryDirectory(prefix="run-", dir=home) as run_dir:
+            temporary_root = Path(run_dir).resolve()
+            env = deepseek_harness_base_env(os.environ.copy(), home=home, temporary_root=temporary_root)
+            source_home = Path(os.environ.get("DSH_HOME", str(Path.home() / ".dsh"))).expanduser().resolve()
+            credentials = Path(os.environ.get("FACTORY_DEEPSEEK_HARNESS_CREDENTIALS", str(source_home / ".credentials.yaml"))).expanduser().resolve()
+            configuration = deepseek_harness_configuration(binary, credentials, env)
+            selected_model = model or os.environ.get("FACTORY_DEEPSEEK_HARNESS_MODEL", "").strip() or "deepseek-flash"
+            overlay = temporary_root / "run.patch.json"
+            composition = deepseek_harness_overlay(cwd=cwd, credentials_path=credentials, provider=configuration["provider"], model=selected_model)
+            identity = hashlib.sha256(json.dumps({"build": deepseek_harness_build_info(binary)["fingerprint"], "overlay": composition}, sort_keys=True).encode()).hexdigest()
+            env["FORGEXA_DEEPSEEK_HARNESS_COMPOSITION"] = identity
+            if session_id:
+                binding = bindings / (hashlib.sha256(session_id.encode()).hexdigest() + ".json")
+                if not binding.is_file() or json.loads(binding.read_text(encoding="utf-8")).get("composition") != identity:
+                    raise RuntimeError("Native Harness session configuration changed or is not owned by Forgexa; start a new session")
+            overlay.write_text(json.dumps(composition), encoding="utf-8")
+            command = build_deepseek_harness_command(binary, overlay_path=overlay, session_id=session_id)
+            yield deepseek_harness_sandbox_command(command, cwd=cwd, home=home, temporary_root=temporary_root, credentials_path=credentials), env
+    finally:
+        release_file_lock(lock)
+
+
+async def run_deepseek_harness(
+    binary: str,
+    prompt: str,
+    workspace_path: str | Path,
+    *,
+    timeout: float | None = 300,
+    model: str | None = None,
+    session_id: str | None = None,
+    on_event: Any = None,
+    on_started: Any = None,
+    on_chunk: Any = None,
+    cancel_requested: Any = None,
+) -> dict:
+    """Execute and validate a supervised one-shot process with bounded output."""
+    process = None
+    state = DeepSeekHarnessRunState(expected_cwd=str(workspace_path))
+    raw_lines = []
+    raw_bytes = 0
+    stderr_text = ""
+    runtime = deepseek_harness_runtime(binary, workspace_path, model=model, session_id=session_id)
+    entered = False
+    try:
+        command, env = await asyncio.to_thread(runtime.__enter__)
+        entered = True
+        process = await asyncio.create_subprocess_exec(
+            *_prepare_agent_command(command), cwd=str(workspace_path), env=env,
+            stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE, limit=DEEPSEEK_HARNESS_MAX_OUTPUT_BYTES,
+            **_agent_process_group_kwargs(),
+        )
+        if on_started is not None:
+            on_started(process)
+        if cancel_requested is not None and cancel_requested():
+            _kill_proc(process)
+
+        async def read_stderr() -> str:
+            tail = ""
+            while True:
+                chunk = await process.stderr.read(4096)
+                if not chunk:
+                    return tail
+                tail = (tail + chunk.decode("utf-8", errors="replace"))[-10000:]
+
+        async def collect() -> str:
+            nonlocal raw_bytes
+            stderr_task = asyncio.create_task(read_stderr())
+            try:
+                process.stdin.write(prompt.encode("utf-8"))
+                await process.stdin.drain()
+                process.stdin.close()
+                while True:
+                    try:
+                        encoded = await process.stdout.readline()
+                    except (ValueError, asyncio.LimitOverrunError):
+                        state.fail("Harness output exceeds the allowed size", "deepseek_harness_output_limit")
+                        _kill_proc(process)
+                        break
+                    if not encoded:
+                        break
+                    raw_bytes += len(encoded)
+                    if raw_bytes > DEEPSEEK_HARNESS_MAX_OUTPUT_BYTES:
+                        state.fail("Harness output exceeds the allowed size", "deepseek_harness_output_limit")
+                        _kill_proc(process)
+                        break
+                    try:
+                        line = encoded.decode("utf-8").strip()
+                    except UnicodeDecodeError:
+                        state.fail("Harness output contains invalid UTF-8")
+                        _kill_proc(process)
+                        break
+                    if not line:
+                        continue
+                    raw_lines.append(line[-10000:])
+                    raw_lines[:] = raw_lines[-20:]
+                    event = state.feed_line(line)
+                    if state.error:
+                        _kill_proc(process)
+                        break
+                    if event is not None and event.get("type") == "session" and env.get("FORGEXA_DEEPSEEK_HARNESS_COMPOSITION"):
+                        binding = deepseek_harness_home(workspace_path) / "forgexa-session-bindings" / (hashlib.sha256(state.session_id.encode()).hexdigest() + ".json")
+                        with tempfile.NamedTemporaryFile("w", encoding="utf-8", dir=binding.parent, delete=False) as temporary:
+                            json.dump({"composition": env["FORGEXA_DEEPSEEK_HARNESS_COMPOSITION"]}, temporary)
+                            temporary_path = Path(temporary.name)
+                        try:
+                            os.replace(temporary_path, binding)
+                        finally:
+                            temporary_path.unlink(missing_ok=True)
+                    if on_chunk is not None:
+                        await on_chunk(line)
+                    if event is not None and on_event is not None:
+                        await on_event(event)
+                await process.wait()
+                return await stderr_task
+            finally:
+                if not stderr_task.done():
+                    stderr_task.cancel()
+                await asyncio.gather(stderr_task, return_exceptions=True)
+
+        try:
+            stderr_text = await asyncio.wait_for(collect(), timeout=timeout)
+        except asyncio.TimeoutError:
+            state.fail(f"Harness timed out after {timeout:g}s", "agent_timeout")
+        except (BrokenPipeError, ConnectionResetError):
+            state.fail("Harness closed the input pipe before accepting its task")
+        if process.returncode is None:
+            _kill_proc(process)
+            await process.wait()
+    except asyncio.CancelledError:
+        if process is not None and process.returncode is None:
+            _kill_proc(process)
+            await process.wait()
+        raise
+    except Exception as error:
+        message = str(error)
+        code = "deepseek_harness_profile_busy" if "profile is busy" in message else "deepseek_harness_startup_failed"
+        state.fail(message, code)
+    finally:
+        if process is not None and process.returncode is None:
+            _kill_proc(process)
+            await process.wait()
+        if entered:
+            await asyncio.to_thread(runtime.__exit__, None, None, None)
+    cancelled = bool(cancel_requested is not None and cancel_requested())
+    result = state.finish(process.returncode if process is not None else -1, cancelled=cancelled)
+    return {**result, "exit_code": process.returncode if process is not None else -1,
+            "stderr": stderr_text, "raw_tail": "\n".join(raw_lines)}
+
+
 def mimo_base_env(env: dict[str, str]) -> dict[str, str]:
     """Return the constrained MiMo Code environment used by AgentHost turns."""
     env = dict(env)
@@ -2506,6 +3134,9 @@ def agent_live_gate_approved(agent_id: str, env: dict[str, str] | None = None) -
 
 def agent_execution_verification_issue(agent_id: str, binary: str) -> str | None:
     """Return a fail-closed build/live-acceptance gate for local agents."""
+    agent_id = canonical_agent_id(agent_id)
+    if agent_id == "deepseek":
+        return deepseek_harness_verification_issue(binary)
     if agent_id == "zcode":
         build_issue = zcode_build_verification_issue(binary)
         if build_issue:

{forgexa_cli-1.59.2 → forgexa_cli-1.60.1}/forgexa_cli/daemon.py

@@ -1196,7 +1196,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.59.2"
+DAEMON_VERSION = "1.60.1"
 
 
 def _detect_client_type() -> str:
@@ -5912,6 +5912,7 @@ class ProcessManager:
     def __init__(self):
         self.active_processes: dict[str, asyncio.subprocess.Process] = {}
         self.active_zcode_sessions: dict[str, ZCodeProtocolSession] = {}
+        self._harness_cancel_requests: dict[str, bool] = {}
 
     @staticmethod
     def _has_failure_pattern(text: str) -> str | None:
@@ -6212,7 +6213,7 @@ class ProcessManager:
                 preflight={"scope": "runtime", "checks": [check]},
             )
 
-        execution_gate_issue = agent_core.agent_execution_verification_issue(
+        execution_gate_issue = await asyncio.to_thread(agent_core.agent_execution_verification_issue,
             agent.agent_id,
             agent.command,
         )
@@ -6265,6 +6266,10 @@ class ProcessManager:
             result = await self._run_mimo(
                 agent, prompt, workspace_path, timeout, task.task_id, on_chunk,
             )
+        elif agent_core.canonical_agent_id(agent.agent_id) == "deepseek":
+            result = await self._run_deepseek_harness(
+                agent, prompt, workspace_path, timeout, task.task_id, on_chunk,
+            )
         elif agent.agent_id == "qwen":
             result = await self._run_qwen(
                 agent, prompt, workspace_path, timeout, task, on_chunk,
@@ -6311,7 +6316,7 @@ class ProcessManager:
         result.metrics["duration_seconds"] = round(elapsed, 2)
 
         # Detect agent-level failures despite exit code 0
-        output_failure = self._detect_agent_output_failure(result, agent.agent_id)
+        output_failure = None if agent_core.canonical_agent_id(agent.agent_id) == "deepseek" else self._detect_agent_output_failure(result, agent.agent_id)
         if output_failure:
             logger.warning(
                 "Agent '%s' exited 0 but output indicates failure: %s",
@@ -7079,6 +7084,32 @@ class ProcessManager:
         result.metrics.update(parsed_metrics)
         return result
 
+    async def _run_deepseek_harness(
+        self, agent: DiscoveredAgent, prompt: str, cwd: Path, timeout: int,
+        task_id: str, on_chunk: Any = None,
+    ) -> TaskResult:
+        self._harness_cancel_requests[task_id] = False
+
+        def on_started(proc: asyncio.subprocess.Process) -> None:
+            self.active_processes[task_id] = proc
+
+        try:
+            result = await agent_core.run_deepseek_harness(
+                agent.command, prompt, cwd, timeout=timeout,
+                on_started=on_started, on_chunk=on_chunk,
+                cancel_requested=lambda: self._harness_cancel_requests.get(task_id, False),
+            )
+            return TaskResult(
+                status=result["status"], exit_code=result.get("exit_code", -1),
+                stdout=result.get("text", ""), stderr=result.get("stderr", ""),
+                error=result.get("error") or "", failure_code=result.get("failure_code") or "",
+                metrics=result.get("metrics", {}),
+                has_verified_completion=result["status"] == "success",
+            )
+        finally:
+            self.active_processes.pop(task_id, None)
+            self._harness_cancel_requests.pop(task_id, None)
+
     async def _run_qwen(
         self,
         agent: DiscoveredAgent,
@@ -8446,6 +8477,8 @@ class ProcessManager:
         return info
 
     async def cancel(self, task_id: str):
+        if task_id in self._harness_cancel_requests:
+            self._harness_cancel_requests[task_id] = True
         zcode_session = self.active_zcode_sessions.pop(task_id, None)
         if zcode_session is not None:
             try:
@@ -12071,6 +12104,7 @@ class RuntimeDaemon:
                     "codex": "npm install -g @openai/codex",
                     "opencode": "curl -sSL https://opencode.ai/install | sh",
                     "mimo": "curl -fsSL https://mimo.xiaomi.com/install | bash",
+                    "deepseek": "npm i -g @deepseek-ai/dsh@0.2.0-rc.2",
                     "qwen": "npm install -g @qwen-code/qwen-code",
                     "codebuddy": "npm install -g @tencent-ai/codebuddy-code",
                     "qoder": "curl -fsSL https://qoder.com/install | bash",
@@ -13133,13 +13167,15 @@ class RuntimeDaemon:
         self, current_agent_id: str, fallback_chain: list[str] | None, tried: set[str]
     ) -> DiscoveredAgent | None:
         """Find the next untried agent from fallback chain or available agents."""
+        tried = {agent_core.canonical_agent_id(agent_id) for agent_id in tried}
         # 1. Try fallback chain
         if fallback_chain:
             for fallback_id in fallback_chain:
+                fallback_id = agent_core.canonical_agent_id(fallback_id)
                 if fallback_id in tried:
                     continue
                 for agent in self.agents:
-                    if agent.agent_id == fallback_id:
+                    if agent_core.canonical_agent_id(agent.agent_id) == fallback_id:
                         return agent
 
         # 2. Try any available agent not yet tried (prefer opencode > copilot > gemini > claude)
@@ -13155,8 +13191,8 @@ class RuntimeDaemon:
         # become implicit catch-alls because their execution profiles are
         # tightly managed.
         for agent in self.agents:
-            if agent.agent_id not in tried and agent.agent_id not in {
-                "mimo", "qwen", "codebuddy", "qoder", "trae", "zcode",
+            if agent_core.canonical_agent_id(agent.agent_id) not in tried and agent_core.canonical_agent_id(agent.agent_id) not in {
+                "mimo", "qwen", "codebuddy", "qoder", "trae", "zcode", "deepseek",
             }:
                 return agent
 
@@ -13174,18 +13210,20 @@ class RuntimeDaemon:
         custom identifier).  This prevents silent substitution when the user explicitly
         selected an agent that is just not installed locally.
         """
+        agent_type = agent_core.canonical_agent_id(agent_type)
         # 1. Exact match
         for agent in self.agents:
-            if agent.agent_id == agent_type:
+            if agent_core.canonical_agent_id(agent.agent_id) == agent_type:
                 return agent
 
         # 2. Try fallback chain from policy
         if fallback_chain:
             for fallback_id in fallback_chain:
+                fallback_id = agent_core.canonical_agent_id(fallback_id)
                 if fallback_id == agent_type:
                     continue
                 for agent in self.agents:
-                    if agent.agent_id == fallback_id:
+                    if agent_core.canonical_agent_id(agent.agent_id) == fallback_id:
                         logger.info("Using fallback agent '%s' (requested '%s')", fallback_id, agent_type)
                         return agent
 
@@ -13205,8 +13243,8 @@ class RuntimeDaemon:
         return next(
             (
                 agent for agent in self.agents
-                if agent.agent_id not in {
-                    "mimo", "qwen", "codebuddy", "qoder", "trae", "zcode",
+                if agent_core.canonical_agent_id(agent.agent_id) not in {
+                    "mimo", "qwen", "codebuddy", "qoder", "trae", "zcode", "deepseek",
                 }
             ),
             None,
@@ -14590,7 +14628,7 @@ class RuntimeDaemon:
             # string so _select_agent falls through to its "any available L3
             # agent" logic instead of hard-failing on the 'claude' default.
             _AGENT_ALIASES = {"claude": "claude", "kimi": "kimi"}
-            agent_type = _AGENT_ALIASES.get(agent_override or "", agent_override or "")
+            agent_type = agent_core.canonical_agent_id(_AGENT_ALIASES.get(agent_override or "", agent_override or ""))
             agent = self._select_agent(agent_type, [])
             if not agent:
                 _INSTALL_HINTS = {
@@ -14598,6 +14636,7 @@ class RuntimeDaemon:
                     "codex": "npm install -g @openai/codex",
                     "opencode": "curl -sSL https://opencode.ai/install | sh",
                     "mimo": "curl -fsSL https://mimo.xiaomi.com/install | bash",
+                    "deepseek": "npm i -g @deepseek-ai/dsh@0.2.0-rc.2",
                     "qwen": "npm install -g @qwen-code/qwen-code",
                     "codebuddy": "npm install -g @tencent-ai/codebuddy-code",
                     "qoder": "curl -fsSL https://qoder.com/install | bash",

{forgexa_cli-1.59.2 → forgexa_cli-1.60.1}/forgexa_cli/main.py

@@ -3018,8 +3018,9 @@ def cmd_check(args: argparse.Namespace) -> None:
 
     os.environ.setdefault("DAEMON_NO_CONSOLE_LOG", "1")
     from forgexa_cli.daemon import AgentDiscovery
+    from forgexa_cli.agent_core import canonical_agent_id
 
-    only_agent = getattr(args, "agent", None)
+    only_agent = canonical_agent_id(getattr(args, "agent", None))
     quick = bool(getattr(args, "quick", False))
     environment_requested = bool(getattr(args, "environment", False))
     timeout = getattr(args, "timeout", None) or 90
@@ -3686,7 +3687,21 @@ def cmd_agent_approve_live(args: argparse.Namespace) -> None:
 
     from . import agent_core
 
-    agent_id = args.agent_id.strip().lower()
+    agent_id = agent_core.canonical_agent_id(args.agent_id.strip().lower())
+    if agent_id == "deepseek":
+        binary = getattr(args, "binary", None) or os.environ.get("FACTORY_DEEPSEEK_HARNESS_PATH") or shutil.which("dsh")
+        if not binary:
+            print("error: dsh not found; install @deepseek-ai/dsh@0.2.0-rc.2 globally", file=sys.stderr)
+            return
+        try:
+            information = agent_core.approve_deepseek_harness_build(binary)
+        except (OSError, ValueError, RuntimeError, subprocess.SubprocessError) as exc:
+            print(f"error: {exc}", file=sys.stderr)
+            return
+        print(f"DeepSeek Harness build approved: {information['fingerprint']}")
+        print(f"runtime version: {information['version']}; Node: {information['node_version']}")
+        print("This records your attestation, not an automatic live test. Only approve after start/resume/cancel/isolation acceptance.")
+        return
     gated = set(agent_core._UNVERIFIED_AGENT_LIVE_GATE_REASONS)
     if agent_id not in gated:
         print(
@@ -3962,8 +3977,9 @@ def main() -> None:
     )
     agent_approve_live_p.add_argument(
         "agent_id", metavar="AGENT_ID",
-        help="Gated agent id (e.g. trae, zcode)",
+        help="Gated agent id (e.g. trae, zcode, deepseek; legacy deepseek-harness accepted)",
     )
+    agent_approve_live_p.add_argument("--binary", default=None, metavar="PATH", help="Installed Harness binary for build-scoped acceptance")
 
     # runtimes
     rt_p = sub.add_parser("runtimes", help="Runtime management")

{forgexa_cli-1.59.2 → forgexa_cli-1.60.1}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.59.2
+Version: 1.60.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
@@ -35,7 +35,7 @@ Requires-Dist: socksio>=1.0.0; extra == "daemon"
 Command-line client and agent runtime for the [Forgexa](https://forgexa.net) platform.
 
 Communicates with the Forgexa server via REST API.
-Includes a built-in **daemon** that discovers twelve local AI agent integrations (Claude Code, Codex, GitHub Copilot, Gemini CLI, OpenCode, Kimi Code, MiMo Code, Qwen Code, CodeBuddy, Qoder CLI, TraeCode CLI, and ZCode) and executes tasks on behalf of the server. MiMo Code (`mimo`, v0.1.14+), Qwen Code (`qwen`, v0.24.1+), CodeBuddy (`codebuddy`, v2.156.0+), Qoder CLI (`qoder`, v1.1.59+), TraeCode CLI (`trae`), and ZCode (`zcode`) are selected explicitly; automatic routing and generated default fallback chains exclude all six. CodeBuddy and Qoder completed their local AgentHost start/resume acceptance gates. Authentication, endpoint, and model selection remain in each local CLI profile; Forgexa never stores or overrides them.
+Includes a built-in **daemon** with thirteen integrations: Claude Code, Codex, GitHub Copilot, Gemini CLI, OpenCode, Kimi Code, MiMo Code, Qwen Code, CodeBuddy, Qoder CLI, TraeCode CLI, ZCode, and DeepSeek Harness. Six standard candidates are automatically routed; seven require explicit selection. Harness (`deepseek`) is a developer preview for personal Runtimes/Desktop, pinned to 0.2.0-rc.2 and Node 22.19+ within 22.x or 24+. It owns a managed runtime profile with read-only external credentials, without copying personal settings. Shared pools/native Windows are blocked. After exact-build live acceptance, `forgexa agent approve-live deepseek` records an attestation; `forgexa check --agent deepseek --quick` avoids model calls, while normal `check` runs a potentially billable minimal task. See [global/local installation and limits](../documentation/guide/agent-installation.md#deepseek-harness-developer-preview).
 
 ## Installation
 

{forgexa_cli-1.59.2 → forgexa_cli-1.60.1}/pyproject.toml

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

{forgexa_cli-1.59.2 → forgexa_cli-1.60.1}/tests/test_check_command.py

@@ -30,6 +30,35 @@ def _agent(agent_id: str, version: str = "1.0.0") -> daemon.DiscoveredAgent:
     )
 
 
+@pytest.mark.parametrize("agent_id", ["deepseek", "deepseek-harness"])
+def test_deepseek_harness_live_approval_is_build_scoped(tmp_path, monkeypatch, capsys, agent_id):
+    from forgexa_cli import agent_core
+
+    approval = tmp_path / "build-approved.json"
+    old_approval = tmp_path / "agent-approved"
+    monkeypatch.setattr(agent_core, "DEEPSEEK_HARNESS_APPROVAL_FILE", approval)
+    monkeypatch.setattr(agent_core, "AGENT_LIVE_VERIFIED_FILE", old_approval)
+    monkeypatch.setattr(agent_core, "deepseek_harness_build_info", lambda binary: {"fingerprint": "test-build", "version": "0.2.0-rc.2", "node_version": "25.2.1"})
+    main.cmd_agent_approve_live(SimpleNamespace(agent_id=agent_id, binary="/fake/dsh"))
+    assert json.loads(approval.read_text())["builds"] == ["test-build"]
+    assert not old_approval.exists()
+    assert "attestation" in capsys.readouterr().out
+
+
+@pytest.mark.parametrize("agent_id", ["deepseek", "deepseek-harness"])
+def test_deepseek_harness_quick_check_accepts_legacy_id(monkeypatch, capsys, agent_id):
+    monkeypatch.setattr(daemon.AgentDiscovery, "AGENT_REGISTRY", {"deepseek": {"commands": ["dsh"], "detect": "dsh --version"}})
+    monkeypatch.setattr(daemon.AgentDiscovery, "discover", AsyncMock(return_value=[_agent("deepseek", "0.2.0-rc.2")]))
+    execute = AsyncMock()
+    monkeypatch.setattr(daemon.ProcessManager, "run_agent", execute)
+    main.cmd_check(SimpleNamespace(agent=agent_id, quick=True, timeout=90))
+    output = capsys.readouterr().out
+    assert "deepseek" in output and "v0.2.0-rc.2" in output
+    assert "1/1 agent(s) available" in output
+    assert "deepseek-harness" not in output
+    execute.assert_not_called()
+
+
 def test_check_quick_reports_installed_and_missing_agents(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],
 ) -> None: