@hunter-harness/workflow-harness 0.2.57 → 0.2.59

package/harness/bundles/java/cursor/scripts/harness_gate.py

@@ -36,6 +36,7 @@ import harness_events_sync as hes  # noqa: E402
 import harness_ledger as hl  # noqa: E402
 import harness_paths as hp  # noqa: E402
 import harness_plan_finalize as hpf  # noqa: E402
+import harness_review as hr  # noqa: E402
 import harness_workflow_policy as hwp  # noqa: E402
 import harness_test_guard as htg  # noqa: E402
 
@@ -1319,11 +1320,62 @@ def classify_risk(
         changed: list[str] = []
         for line in proc.stdout.splitlines():
             raw = line[3:].strip().strip('"').replace("\\", "/")
-            if not raw or raw.startswith(".harness/"):
+            if not raw:
                 continue
+            if " -> " in raw:
+                raw = raw.rsplit(" -> ", 1)[-1].strip().strip('"')
             changed.append(raw)
-        capabilities = sorted(set(capabilities) | set(_diff_capabilities(changed)))
-        lowered = "\n".join(changed).lower()
+        try:
+            contract = hp.load_change_contract(change_dir)
+        except (OSError, ValueError, json.JSONDecodeError):
+            contract = {}
+        ownership = contract.get("ownership") if isinstance(contract, dict) else None
+        modern_scope = isinstance(ownership, dict) and bool(
+            ownership.get("productPaths") or ownership.get("staticEvidencePaths")
+        )
+        product_paths: list[str] = []
+        static_paths: list[str] = []
+        excluded_paths: list[str] = []
+        maintenance_paths: list[str] = []
+        foreign_paths: list[str] = []
+
+        def is_harness_maintenance(path: str) -> bool:
+            normalized = path.replace("\\", "/")
+            return normalized.startswith(
+                (
+                    ".cursor/skills/",
+                    ".claude/skills/",
+                    ".agents/skills/",
+                    ".codebuddy/skills/",
+                )
+            ) or normalized in {
+                ".harness/context-index.json",
+                ".harness/config/build-profile.json",
+            }
+
+        for path in changed:
+            if modern_scope:
+                category = hl._classify_ownership_path(
+                    path, change_dir.name, ownership
+                )
+                if category == "owned":
+                    product_paths.append(path)
+                elif category == "staticEvidence":
+                    static_paths.append(path)
+                elif category == "excludedRuntime":
+                    excluded_paths.append(path)
+                elif is_harness_maintenance(path):
+                    maintenance_paths.append(path)
+                else:
+                    foreign_paths.append(path)
+            elif path.startswith(".harness/") or is_harness_maintenance(path):
+                maintenance_paths.append(path)
+            else:
+                product_paths.append(path)
+        capabilities = sorted(
+            set(capabilities) | set(_diff_capabilities(product_paths))
+        )
+        lowered = "\n".join(product_paths).lower()
         full_markers = {
             "auth": ("auth", "token", "credential", "permission"),
             "security": ("security", "secret", "crypto"),
@@ -1338,14 +1390,14 @@ def classify_risk(
                 signals.append(signal)
         if signals:
             observed = "full"
-        elif changed and all(
+        elif product_paths and all(
             path.lower().endswith((".md", ".txt", ".rst"))
             or path.lower().startswith("docs/")
-            for path in changed
+            for path in product_paths
         ):
             observed = "fast"
             signals.append("docs-only")
-        elif changed:
+        elif product_paths:
             observed = "standard"
             signals.append("production-code")
         else:
@@ -1373,6 +1425,14 @@ def classify_risk(
         "conditionalStages": list(tier_policy["conditionalStages"]),
         "stageDecisions": _stage_decisions_for_tier(workflow, tier, unique_signals),
     }
+    if stage == "post-run":
+        payload["workspaceBreakdown"] = {
+            "productPaths": sorted(set(product_paths)),
+            "staticEvidencePaths": sorted(set(static_paths)),
+            "excludedRuntimePaths": sorted(set(excluded_paths)),
+            "harnessMaintenancePaths": sorted(set(maintenance_paths)),
+            "foreignPaths": sorted(set(foreign_paths)),
+        }
     if stage == "post-run":
         _write_json(change_dir / "meta" / "risk-classification.json", payload)
     result = _apply_required_gate_contract(payload, workflow, capabilities)
@@ -2158,6 +2218,72 @@ def validate_plan_handoff(change_dir: Path) -> dict[str, Any]:
     return hpf.verify_plan(change_dir)
 
 
+def validate_review_outputs_for_close(
+    change_dir: Path,
+    run_id: str,
+) -> dict[str, Any]:
+    """Require complete, run-bound structured Review sidecars before close."""
+
+    findings_path = hr.findings_path(change_dir)
+    dispositions_path = hr.dispositions_path(change_dir)
+    missing = [
+        str(path)
+        for path in (findings_path, dispositions_path)
+        if not path.is_file()
+    ]
+    if missing:
+        return {
+            "ok": False,
+            "code": "REVIEW_OUTPUTS_INCOMPLETE",
+            "message": "评审的结构化发现或处置记录缺失，尚不能结束评审阶段。",
+            "missing": missing,
+            "recoveryAction": "补写 review-findings.json 与 fixback-dispositions.json 后重试关门",
+        }
+    try:
+        findings = json.loads(findings_path.read_text(encoding="utf-8-sig"))
+        dispositions = json.loads(
+            dispositions_path.read_text(encoding="utf-8-sig")
+        )
+    except (OSError, json.JSONDecodeError) as exc:
+        return {
+            "ok": False,
+            "code": "REVIEW_OUTPUTS_INVALID",
+            "message": f"评审结构化记录无法读取：{exc}",
+        }
+    finding_problems = hr.validate_findings(findings, require_ids=True)
+    known_ids = {
+        str(item.get("id"))
+        for item in findings.get("findings", [])
+        if isinstance(item, dict) and item.get("id")
+    }
+    disposition_problems = hr.validate_dispositions(dispositions, known_ids)
+    disposition_ids = {
+        str(item.get("findingId"))
+        for item in dispositions.get("dispositions", [])
+        if isinstance(item, dict) and item.get("findingId")
+    }
+    problems = [*finding_problems, *disposition_problems]
+    if findings.get("runId") != run_id or dispositions.get("runId") != run_id:
+        problems.append("review sidecars must match the active review runId")
+    missing_dispositions = sorted(known_ids - disposition_ids)
+    if missing_dispositions:
+        problems.append(
+            "findings without dispositions: " + ",".join(missing_dispositions)
+        )
+    if problems:
+        return {
+            "ok": False,
+            "code": "REVIEW_OUTPUTS_INVALID",
+            "message": "评审结构化记录不完整或与当前轮次不一致。",
+            "problems": problems,
+        }
+    return {
+        "ok": True,
+        "code": "REVIEW_OUTPUTS_READY",
+        "findingCount": len(known_ids),
+    }
+
+
 def cmd_begin(args: argparse.Namespace) -> int:
     as_json = bool(args.json)
     project = hc.resolve_main_project_root()
@@ -2738,6 +2864,35 @@ def cmd_close(args: argparse.Namespace) -> int:
             extra={k: v for k, v in ledger_result.items() if k not in {"ok", "message", "code"}},
         )
 
+    if args.phase == "review":
+        review_outputs = validate_review_outputs_for_close(change_dir, run_id)
+        if not review_outputs.get("ok"):
+            persist_close_failure(
+                change_dir,
+                args.phase,
+                run_id,
+                capsule,
+                status="REVIEW_OUTPUTS_INVALID",
+                error=review_outputs,
+            )
+            record_gate_blocked(
+                change_dir,
+                phase=args.phase,
+                code=str(review_outputs.get("code") or "REVIEW_OUTPUTS_INVALID"),
+                message=str(review_outputs.get("message") or "评审记录不完整。"),
+                run_id=run_id,
+            )
+            return emit_error(
+                str(review_outputs.get("code") or "REVIEW_OUTPUTS_INVALID"),
+                str(review_outputs.get("message") or "评审记录不完整。"),
+                as_json=as_json,
+                extra={
+                    key: value
+                    for key, value in review_outputs.items()
+                    if key not in {"ok", "code", "message"}
+                },
+            )
+
     # C9: scenario coverage check — all P0 scenarios must have a ledger entry.
     if args.phase in {"run", "test"}:
         coverage = _validate_scenario_coverage(change_dir)

package/harness/bundles/java/cursor/scripts/harness_ledger.py

@@ -808,6 +808,50 @@ def expand_profile_input_files(
     return sorted(seen), None
 
 
+def ensure_profile_input_target(
+    project: Path,
+    profile_input: str,
+) -> tuple[dict[str, Any] | None, str | None]:
+    """Refresh a missing/stale detected profile before recording evidence."""
+
+    project_root = Path(project).resolve()
+    profile = harness_profile.load_profile(project_root)
+    inputs = profile.get("verificationInputs") if isinstance(profile, dict) else None
+    graph = profile.get("verificationGraph") if isinstance(profile, dict) else None
+    targets = graph.get("targets") if isinstance(graph, dict) else None
+    if (
+        isinstance(inputs, dict)
+        and profile_input in inputs
+        and isinstance(targets, dict)
+        and isinstance(targets.get(profile_input), dict)
+    ):
+        return profile, None
+
+    # An unreadable profile needs an explicit repair; silently replacing it can
+    # discard user-owned overrides.
+    common = harness_paths.common_root(project_root)
+    for root in dict.fromkeys((common, project_root)):
+        candidate = root / ".harness" / "config" / "build-profile.json"
+        if not candidate.is_file():
+            continue
+        try:
+            json.loads(candidate.read_text(encoding="utf-8-sig"))
+        except (OSError, json.JSONDecodeError) as exc:
+            return None, f"build-profile.json unreadable: {exc}"
+
+    detected = harness_profile.detect(project_root)
+    if not detected.get("ok"):
+        return None, str(
+            detected.get("message")
+            or detected.get("code")
+            or "build profile detection failed"
+        )
+    refreshed = harness_profile.load_profile(project_root)
+    if not isinstance(refreshed, dict):
+        return None, "build-profile.json missing after detection"
+    return refreshed, None
+
+
 def _state_dir(change_dir: Path) -> Path:
     return Path(harness_paths.resolve_state_dir_for_contract(change_dir))
 
@@ -1728,6 +1772,7 @@ def decide_can_reuse(
             "reuse": False,
             "reason": "insufficient-evidence",
             "code": "LEDGER_MISSING",
+            "executionNeed": "first-run",
             "verification": verification,
             "detail": "ledger missing",
         }
@@ -1787,6 +1832,7 @@ def decide_can_reuse(
             "reuse": False,
             "reason": "insufficient-evidence",
             "code": "VALIDATIONS_MISSING",
+            "executionNeed": "first-run",
             "verification": verification,
             "detail": "validations missing",
             "ledger_path": str(ledger_path) if ledger_path else None,
@@ -1800,6 +1846,7 @@ def decide_can_reuse(
             "reuse": False,
             "reason": "insufficient-evidence",
             "code": "VALIDATION_MISSING",
+            "executionNeed": "first-run",
             "verification": verification,
             "detail": f"validation '{verification}' missing",
             "ledger_path": str(ledger_path) if ledger_path else None,
@@ -1821,6 +1868,7 @@ def decide_can_reuse(
             "reuse": False,
             "reason": "rerun",
             "code": "EVIDENCE_INVALIDATED",
+            "executionNeed": "rerun",
             "verification": verification,
             "detail": "recorded target was invalidated by workflow fixback",
             "invalidation": entry.get("invalidation"),
@@ -1868,6 +1916,7 @@ def decide_can_reuse(
             "reuse": False,
             "reason": "insufficient-evidence",
             "code": "MISSING_V2_FIELDS" if v2_missing else "MISSING_FIELDS",
+            "executionNeed": "evidence-incomplete",
             "verification": verification,
             "detail": "missing or invalid: " + ", ".join(all_missing),
             "ledger_path": str(ledger_path) if ledger_path else None,
@@ -2017,6 +2066,7 @@ def decide_can_reuse(
         "reuse": True,
         "reason": "reuse",
         "code": "REUSED",
+        "executionNeed": "reuse",
         "invalidationCode": None,
         "verification": verification,
         "ledger_path": str(ledger_path) if ledger_path else None,
@@ -2171,7 +2221,6 @@ def cmd_can_reuse(args: argparse.Namespace) -> int:
         )
     except (OSError, ValueError) as exc:
         return emit_error(f"can-reuse failed: {exc}", as_json=as_json)
-    explicit_files = list(files)
     target = resolve_verification_target(verification, project_root)
     if target is None:
         return emit_error(
@@ -2180,6 +2229,7 @@ def cmd_can_reuse(args: argparse.Namespace) -> int:
             "verificationGraph.targets",
             as_json=as_json,
         )
+    explicit_files = list(files)
     profile_input = getattr(args, "profile_input", None)
     project_raw = getattr(args, "project", None)
     if profile_input:
@@ -2297,6 +2347,20 @@ def cmd_record(args: argparse.Namespace) -> int:
     except (OSError, ValueError) as exc:
         return emit_error(f"record failed: {exc}", as_json=as_json)
     explicit_files = list(files)
+    profile_input = getattr(args, "profile_input", None)
+    project_raw = getattr(args, "project", None)
+    if profile_input:
+        if not project_raw:
+            return emit_error("--profile-input requires --project", as_json=as_json)
+        _profile, profile_error = ensure_profile_input_target(
+            project_root, profile_input
+        )
+        if profile_error:
+            return emit_error(
+                f"record failed: {profile_error}",
+                as_json=as_json,
+                error_code="BUILD_PROFILE_REFRESH_FAILED",
+            )
     target = resolve_verification_target(verification, project_root)
     if target is None:
         return emit_error(
@@ -2305,11 +2369,7 @@ def cmd_record(args: argparse.Namespace) -> int:
             "verificationGraph.targets",
             as_json=as_json,
         )
-    profile_input = getattr(args, "profile_input", None)
-    project_raw = getattr(args, "project", None)
     if profile_input:
-        if not project_raw:
-            return emit_error("--profile-input requires --project", as_json=as_json)
         resolved_files, err = expand_profile_input_files(project_root, profile_input)
         if err:
             return emit_error(f"record failed: {err}", as_json=as_json)
@@ -2455,8 +2515,21 @@ def cmd_record(args: argparse.Namespace) -> int:
                 )
             except ValueError as exc:
                 return emit_error(str(exc), as_json=as_json)
-        if args.scope is not None and str(args.scope).strip():
-            entry["scope"] = str(args.scope).strip()
+        effective_scope = (
+            str(args.scope).strip()
+            if args.scope is not None and str(args.scope).strip()
+            else (
+                str(
+                    target.get("coverageLevel")
+                    or target.get("requiredCoverage")
+                    or ""
+                ).strip()
+                if profile_input
+                else ""
+            )
+        )
+        if effective_scope:
+            entry["scope"] = effective_scope
         # No default scope: recording an incremental run as broad "module" scope
         # would let can-reuse wrongly approve untested classes (D13 guardrail).
         # Missing scope → can-reuse treats unitTest as insufficient-evidence.
@@ -2470,7 +2543,7 @@ def cmd_record(args: argparse.Namespace) -> int:
         )
         coverage = getattr(args, "coverage", None)
         if not (_nonempty_str(coverage) and str(coverage).strip() in COVERAGE_RANK):
-            coverage = derive_coverage(verification, args.scope)
+            coverage = derive_coverage(verification, effective_scope or None)
         entry["coverage"] = coverage
         for field, attr in (
             ("toolchainHash", "toolchain_hash"),

package/harness/bundles/java/cursor/scripts/harness_review.py

@@ -37,6 +37,7 @@ if hasattr(sys.stderr, "reconfigure"):
     sys.stderr.reconfigure(encoding="utf-8")
 
 SEVERITIES = {"RED", "YELLOW", "OK"}
+FIXBACK_ACTIONS = {"code", "manual", "workflow"}
 DISPOSITIONS = {
     "OPEN",
     "FIXED",
@@ -48,7 +49,14 @@ DISPOSITIONS = {
 CURRENT_RISK_DISPOSITIONS = {"OPEN", "ACCEPTED_RISK", "DEFERRED", "UNKNOWN"}
 FINDINGS_REL = Path("reports") / "review" / "review-findings.json"
 DISPOSITIONS_REL = Path("reports") / "review" / "fixback-dispositions.json"
-_REQUIRED_FINDING_FIELDS = ("dimension", "severity", "path", "line", "title")
+_REQUIRED_FINDING_FIELDS = (
+    "dimension",
+    "severity",
+    "path",
+    "line",
+    "title",
+    "fixbackAction",
+)
 
 
 def _write_json_atomic(path: Path, data: Any) -> None:
@@ -95,7 +103,7 @@ def stable_finding_id(
     return "f-" + hashlib.sha256(basis.encode("utf-8")).hexdigest()[:16]
 
 
-def validate_findings(doc: Any) -> list[str]:
+def validate_findings(doc: Any, *, require_ids: bool = False) -> list[str]:
     problems: list[str] = []
     if not isinstance(doc, dict):
         return ["findings document must be an object"]
@@ -105,10 +113,19 @@ def validate_findings(doc: Any) -> list[str]:
     if not isinstance(findings, list):
         problems.append("findings must be a list")
         return problems
+    seen_ids: set[str] = set()
     for index, finding in enumerate(findings):
         if not isinstance(finding, dict):
             problems.append(f"findings[{index}] must be an object")
             continue
+        if require_ids:
+            finding_id = finding.get("id")
+            if not isinstance(finding_id, str) or not finding_id.strip():
+                problems.append(f"findings[{index}].id is required")
+            elif finding_id in seen_ids:
+                problems.append(f"findings[{index}].id must be unique")
+            else:
+                seen_ids.add(finding_id)
         for field in _REQUIRED_FINDING_FIELDS:
             if field not in finding:
                 problems.append(f"findings[{index}].{field} is required")
@@ -120,6 +137,12 @@ def validate_findings(doc: Any) -> list[str]:
         line = finding.get("line")
         if line is not None and (not isinstance(line, int) or line < 0):
             problems.append(f"findings[{index}].line must be a non-negative int")
+        action = finding.get("fixbackAction")
+        if action is not None and action not in FIXBACK_ACTIONS:
+            problems.append(
+                f"findings[{index}].fixbackAction must be one of "
+                f"{sorted(FIXBACK_ACTIONS)}"
+            )
     return problems
 
 

package/harness/bundles/java/cursor/scripts/harness_test_runner.py

@@ -14,6 +14,8 @@ import ctypes
 import hashlib
 import json
 import os
+import re
+import shutil
 import signal
 import subprocess
 import sys
@@ -68,6 +70,104 @@ class TestRunAlreadyActive(RuntimeError):
     """Raised when another resource-safe runner owns the project lock."""
 
 
+class ManagedCommandNotFound(FileNotFoundError):
+    """Raised when a structured command cannot be resolved without a shell."""
+
+
+class ManagedCommandUnsafe(ValueError):
+    """Raised when a Windows batch argument could be interpreted by cmd.exe."""
+
+
+_WINDOWS_BATCH_SUFFIXES = {".bat", ".cmd"}
+_WINDOWS_CMD_META = re.compile(r'[\r\n&|<>^%!\"]')
+
+
+def validate_managed_argv(
+    argv: Sequence[str], *, platform_name: str | None = None
+) -> None:
+    """Fail closed when Windows would reinterpret a batch argv boundary."""
+
+    platform = platform_name or os.name
+    if (
+        platform != "nt"
+        or not argv
+        or Path(argv[0]).suffix.casefold() not in _WINDOWS_BATCH_SUFFIXES
+    ):
+        return
+    for index, argument in enumerate(argv):
+        if _WINDOWS_CMD_META.search(str(argument)):
+            raise ManagedCommandUnsafe(
+                "MANAGED_BATCH_ARGUMENT_UNSAFE: "
+                f"Windows 批处理命令的第 {index} 个参数包含命令解释符；"
+                "请改用原生可执行文件或不含命令解释符的参数"
+            )
+
+
+def resolve_managed_argv(
+    argv: Sequence[str],
+    *,
+    environ: Mapping[str, str],
+    platform_name: str | None = None,
+) -> list[str]:
+    """Resolve argv[0] through PATH/PATHEXT while preserving argv boundaries."""
+
+    if not argv or not isinstance(argv[0], str) or not argv[0].strip():
+        raise ManagedCommandNotFound("MANAGED_COMMAND_NOT_FOUND: 命令不能为空")
+    command = argv[0].strip()
+    platform = platform_name or os.name
+    windows_extensions = [
+        item.strip() if item.strip().startswith(".") else f".{item.strip()}"
+        for item in str(
+            environ.get("PATHEXT") or ".COM;.EXE;.BAT;.CMD"
+        ).split(";")
+        if item.strip()
+    ] if platform == "nt" else []
+    windows_extension_set = {item.casefold() for item in windows_extensions}
+    has_path = Path(command).is_absolute() or "/" in command or "\\" in command
+    if has_path:
+        requested = Path(command).expanduser()
+        suffix = requested.suffix.casefold()
+        candidates = (
+            [Path(str(requested) + extension) for extension in windows_extensions]
+            + [requested]
+            if platform == "nt" and suffix not in windows_extension_set
+            else [requested]
+        )
+        for candidate in candidates:
+            if candidate.is_file():
+                return [str(candidate.resolve()), *list(argv[1:])]
+        raise ManagedCommandNotFound(
+            f"MANAGED_COMMAND_NOT_FOUND: 找不到可执行命令 {command}"
+        )
+
+    path_value = str(environ.get("PATH") or "")
+    resolved: str | None = None
+    if platform == "nt":
+        suffix = Path(command).suffix.casefold()
+        names = (
+            [command]
+            if suffix and suffix in windows_extension_set
+            else [*(command + item for item in windows_extensions), command]
+        )
+        for raw_directory in path_value.split(";"):
+            directory = raw_directory.strip().strip('"') or "."
+            for name in names:
+                candidate = Path(directory) / name
+                if candidate.is_file():
+                    resolved = str(candidate.resolve())
+                    break
+            if resolved is not None:
+                break
+    else:
+        resolved = shutil.which(command, path=path_value or None)
+
+    if resolved is None:
+        raise ManagedCommandNotFound(
+            f"MANAGED_COMMAND_NOT_FOUND: 找不到可执行命令 {command}"
+        )
+    return [resolved, *list(argv[1:])]
+
+
 def _truthy(value: object) -> bool:
     return str(value or "").strip().lower() in TRUTHY_VALUES
 
@@ -819,6 +919,8 @@ def run_managed_command(
     if environ:
         child_env.update({str(key): str(value) for key, value in environ.items()})
     child_env.setdefault("PYTHONUNBUFFERED", "1")
+    resolved_argv = resolve_managed_argv(argv, environ=child_env)
+    validate_managed_argv(resolved_argv)
     lower_process_priority()
 
     output_stream = tempfile.TemporaryFile(mode="w+b") if capture_output else None
@@ -828,7 +930,7 @@ def run_managed_command(
     cleanup_complete = False
     try:
         spawned = hprocess.spawn_structured_argv(
-            list(argv),
+            resolved_argv,
             cwd=Path(cwd).resolve(),
             environment=child_env,
             owner_token=f"test-runner:{uuid.uuid4().hex}",
@@ -1133,6 +1235,32 @@ def _run_unittest(args: argparse.Namespace) -> int:
     except TestRunAlreadyActive as exc:
         print(str(exc), file=sys.stderr)
         return 3
+    except ManagedCommandNotFound as exc:
+        print(
+            json.dumps(
+                {
+                    "ok": False,
+                    "code": "MANAGED_COMMAND_NOT_FOUND",
+                    "message": str(exc).split(":", 1)[-1].strip(),
+                },
+                ensure_ascii=False,
+            ),
+            file=sys.stderr,
+        )
+        return 127
+    except OSError as exc:
+        print(
+            json.dumps(
+                {
+                    "ok": False,
+                    "code": "MANAGED_COMMAND_START_FAILED",
+                    "message": f"命令无法启动：{exc}",
+                },
+                ensure_ascii=False,
+            ),
+            file=sys.stderr,
+        )
+        return 126
 
     duration = time.monotonic() - started
     status = "PASS" if not failures else "FAIL"
@@ -1264,6 +1392,32 @@ def _run_exec(args: argparse.Namespace) -> int:
     except TestRunAlreadyActive as exc:
         print(str(exc), file=sys.stderr)
         return 3
+    except ManagedCommandNotFound as exc:
+        print(
+            json.dumps(
+                {
+                    "ok": False,
+                    "code": "MANAGED_COMMAND_NOT_FOUND",
+                    "message": str(exc).split(":", 1)[-1].strip(),
+                },
+                ensure_ascii=False,
+            ),
+            file=sys.stderr,
+        )
+        return 127
+    except OSError as exc:
+        print(
+            json.dumps(
+                {
+                    "ok": False,
+                    "code": "MANAGED_COMMAND_START_FAILED",
+                    "message": f"命令无法启动：{exc}",
+                },
+                ensure_ascii=False,
+            ),
+            file=sys.stderr,
+        )
+        return 126
     if not result.process_tree_isolated:
         print("PROCESS_TREE_ISOLATION_UNAVAILABLE", file=sys.stderr)
         return 4