@hunter-harness/workflow-harness 0.2.43 → 0.2.45

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

@@ -29,6 +29,7 @@ if str(SCRIPT_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPT_DIR))
 
 import harness_environment as henv
+import harness_process as hprocess
 
 DEFAULT_MAX_WORKERS = 2
 DEFAULT_TIMEOUT_SECONDS = 300.0
@@ -139,35 +140,30 @@ def build_unittest_plan(
 
 
 def _pid_is_running(pid: int) -> bool:
-    if pid <= 0:
-        return False
-    if pid == os.getpid():
-        return True
-    if os.name == "nt":
-        process_query_limited_information = 0x1000
-        kernel32 = ctypes.windll.kernel32
-        kernel32.OpenProcess.restype = ctypes.c_void_p
-        handle = kernel32.OpenProcess(
-            process_query_limited_information,
-            False,
-            pid,
-        )
-        if not handle:
-            return False
-        try:
-            exit_code = ctypes.c_uint32()
-            if not kernel32.GetExitCodeProcess(handle, ctypes.byref(exit_code)):
-                return False
-            return int(exit_code.value) == 259
-        finally:
-            kernel32.CloseHandle(ctypes.c_void_p(handle))
+    return hprocess.is_pid_alive(pid)
+
+
+def _verify_recorded_owner(owner: Mapping[str, object]) -> bool | None:
+    """Verify a legacy lock owner through the canonical process provider."""
+
     try:
-        os.kill(pid, 0)
-    except ProcessLookupError:
-        return False
-    except PermissionError:
+        pid = int(owner.get("pid") or 0)
+    except (TypeError, ValueError):
+        return None
+    observed = hprocess.observe_process_identity(pid)
+    decision = hprocess.verify_process_identity(
+        {
+            "pid": pid,
+            "createdAt": owner.get("startedAt"),
+            "executable": owner.get("executable"),
+        },
+        observed,
+    )
+    if decision.get("ok") is True:
         return True
-    return True
+    if decision.get("reasonCode") == "IDENTITY_UNVERIFIABLE":
+        return None
+    return False
 
 
 def classify_test_lock(path: Path) -> dict[str, object]:
@@ -237,13 +233,7 @@ def classify_test_lock(path: Path) -> dict[str, object]:
             "token": payload.get("token"),
             "owner": owner,
         }
-    verified = henv.hservice.verify_process_identity(
-        {
-            "pid": owner_pid,
-            "startedAt": owner["startedAt"],
-            "processIdentity": {"executable": owner["executable"]},
-        }
-    )
+    verified = _verify_recorded_owner(owner)
     classification = (
         "OWNER_ACTIVE"
         if verified is True
@@ -348,9 +338,9 @@ class TestRunLock:
                 )
             else:
                 now = time.time()
-                created = henv.hservice.get_process_create_time(os.getpid())
+                created = hprocess.get_process_create_time(os.getpid())
                 executable = (
-                    henv.hservice.get_process_executable(os.getpid())
+                    hprocess.get_process_executable(os.getpid())
                     or str(Path(sys.executable).resolve())
                 )
                 payload = {
@@ -794,35 +784,12 @@ def _terminate_process_tree(
     *,
     windows_job: _WindowsKillOnCloseJob | None,
 ) -> None:
+    """Legacy seam retained for callers; ownership must be provider-backed."""
+
     if windows_job is not None and windows_job.handle is not None:
         windows_job.terminate_and_wait()
-    elif os.name == "nt":
-        subprocess.run(
-            ["taskkill", "/PID", str(process.pid), "/T", "/F"],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-            check=False,
-            timeout=10,
-            creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),
-        )
     else:
-        try:
-            os.killpg(process.pid, signal.SIGTERM)
-        except ProcessLookupError:
-            pass
-        try:
-            process.wait(timeout=2)
-        except subprocess.TimeoutExpired:
-            try:
-                os.killpg(process.pid, signal.SIGKILL)
-            except ProcessLookupError:
-                pass
-    if process.poll() is None:
-        process.kill()
-    try:
-        process.wait(timeout=5)
-    except subprocess.TimeoutExpired:
-        pass
+        raise RuntimeError("PROCESS_OWNERSHIP_REQUIRED")
 
 
 def _cleanup_descendants_after_success(
@@ -832,12 +799,7 @@ def _cleanup_descendants_after_success(
 ) -> bool:
     if windows_job is not None and windows_job.handle is not None:
         return windows_job.terminate_and_wait()
-    if os.name != "nt":
-        try:
-            os.killpg(process.pid, signal.SIGTERM)
-        except ProcessLookupError:
-            pass
-    return os.name != "nt"
+    return False
 
 
 def run_managed_command(
@@ -859,74 +821,84 @@ def run_managed_command(
     child_env.setdefault("PYTHONUNBUFFERED", "1")
     lower_process_priority()
 
-    popen_kwargs: dict[str, object] = {
-        "cwd": str(Path(cwd).resolve()),
-        "env": child_env,
-        "shell": False,
-    }
     output_stream = tempfile.TemporaryFile(mode="w+b") if capture_output else None
-    if output_stream is not None:
-        popen_kwargs["stdout"] = output_stream
-        popen_kwargs["stderr"] = subprocess.STDOUT
-    if os.name == "nt":
-        popen_kwargs["creationflags"] = getattr(
-            subprocess,
-            "CREATE_NEW_PROCESS_GROUP",
-            0,
-        )
-    else:
-        popen_kwargs["start_new_session"] = True
-
     started = time.monotonic()
+    spawned = None
+    process: subprocess.Popen[object] | None = None
+    cleanup_complete = False
     try:
-        process = subprocess.Popen(list(argv), **popen_kwargs)
-        windows_job = (
-            _WindowsKillOnCloseJob(allow_breakaway=allow_detached_processes)
-            if os.name == "nt"
-            else None
+        spawned = hprocess.spawn_structured_argv(
+            list(argv),
+            cwd=Path(cwd).resolve(),
+            environment=child_env,
+            owner_token=f"test-runner:{uuid.uuid4().hex}",
+            stdout=output_stream,
+            stderr=(subprocess.STDOUT if output_stream is not None else None),
         )
-        isolated = bool(windows_job and windows_job.assign(process))
-        known_windows_descendants: set[int] = set()
-        windows_snapshot_ok = True
-        if os.name != "nt":
-            isolated = True
+        process = spawned.process
+        isolated = bool(
+            isinstance(spawned.ownershipProof, dict)
+            and spawned.ownershipProof.get("membersComplete") is True
+        )
+
+        def provider_cleanup() -> bool:
+            hprocess.capture_owned_members(spawned)
+            result = hprocess.terminate_owned_tree(
+                spawned.attestation,
+                spawned.ownershipProof,
+                {"graceSeconds": 3.0},
+            )
+            return bool(result.get("cleanupComplete"))
+
+        def wait_owned_members_gone() -> bool:
+            proof = spawned.ownershipProof
+            if not isinstance(proof, dict):
+                return False
+            members = proof.get("members")
+            if not isinstance(members, list):
+                return False
+            pids = {
+                int(item["pid"])
+                for item in members
+                if isinstance(item, dict) and isinstance(item.get("pid"), int)
+            }
+            deadline = time.monotonic() + 5.0
+            while pids and time.monotonic() < deadline:
+                pids = {pid for pid in pids if hprocess.is_pid_alive(pid)}
+                if pids:
+                    time.sleep(0.05)
+            return not pids
+
         timed_out = False
         try:
             deadline = time.monotonic() + max(0.01, float(timeout_seconds))
             while True:
-                if os.name == "nt":
-                    windows_snapshot_ok = (
-                        _update_windows_descendants(
-                            process.pid,
-                            known_windows_descendants,
-                        )
-                        and windows_snapshot_ok
-                    )
                 polled = process.poll()
                 if polled is not None:
                     returncode = polled
                     break
                 if time.monotonic() >= deadline:
                     timed_out = True
-                    _terminate_process_tree(process, windows_job=windows_job)
+                    cleanup_complete = provider_cleanup()
                     returncode = 124
                     break
                 time.sleep(0.05)
         except KeyboardInterrupt:
-            _terminate_process_tree(process, windows_job=windows_job)
-            if os.name == "nt":
-                _terminate_tracked_windows_descendants(known_windows_descendants)
+            cleanup_complete = provider_cleanup()
             raise
-        descendants_drained = True
         if not timed_out:
-            descendants_drained = _cleanup_descendants_after_success(
-                process,
-                windows_job=windows_job,
-            )
-        if os.name == "nt":
-            _update_windows_descendants(process.pid, known_windows_descendants)
-            _terminate_tracked_windows_descendants(known_windows_descendants)
-            isolated = isolated and windows_snapshot_ok and descendants_drained
+            cleanup_complete = provider_cleanup()
+            # A named Windows Job remains an owned capability after the leader
+            # exits. Closing that provider handle drains any attested children;
+            # PID-only or POSIX group fallbacks stay fail-closed.
+            if not cleanup_complete and os.name == "nt":
+                spawned.close()
+                cleanup_complete = wait_owned_members_gone()
+        if process.poll() is None:
+            try:
+                process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                cleanup_complete = False
         duration = time.monotonic() - started
         output_tail = ""
         if output_stream is not None:
@@ -939,10 +911,28 @@ def run_managed_command(
             returncode=returncode,
             timed_out=timed_out,
             duration_seconds=duration,
-            process_tree_isolated=isolated,
+            process_tree_isolated=isolated and cleanup_complete,
             output_tail=output_tail,
         )
     finally:
+        if (
+            not cleanup_complete
+            and process is not None
+            and process.poll() is None
+            and spawned is not None
+        ):
+            try:
+                hprocess.capture_owned_members(spawned)
+                cleanup = hprocess.terminate_owned_tree(
+                    spawned.attestation,
+                    spawned.ownershipProof,
+                    {"graceSeconds": 3.0},
+                )
+                cleanup_complete = bool(cleanup.get("cleanupComplete"))
+            except Exception:
+                cleanup_complete = False
+        if spawned is not None:
+            spawned.close()
         if output_stream is not None:
             output_stream.close()
 

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

@@ -7,12 +7,63 @@ import argparse
 import fnmatch
 import json
 import time
+from collections import Counter
 from pathlib import Path
 from typing import Any
 
 
 _COVERAGE_RANK = {"incremental": 0, "module": 1, "module-am": 2, "full": 3}
 
+_REASON_EXPLANATIONS = {
+    "PRODUCT_IDENTITY_REQUIRED": "A product identity is required before a verification can run.",
+    "CAPABILITY_MISSING": "A required execution capability is not available.",
+    "REQUIRED_COVERAGE_INVALID": "The required coverage declaration is invalid.",
+    "COVERAGE_DECLARATION_REQUIRED": "The target does not declare the coverage level needed for this gate.",
+    "COVERAGE_INSUFFICIENT": "The target coverage is below the required gate level.",
+    "NOT_APPLICABLE": "The target is explicitly not applicable to this change.",
+    "FROZEN_IDENTITY_REQUIRED": "The target requires a frozen product identity.",
+    "FROZEN_IDENTITY_DRIFT": "The current product identity differs from the frozen identity.",
+    "REUSE_POLICY_NEVER": "The target policy explicitly requires a fresh execution.",
+    "REUSE_EVIDENCE_INVALID": "Ledger evidence does not match the target and product identity exactly.",
+    "REUSE_ELIGIBLE": "Identity-matched ledger evidence permits reuse.",
+    "SELECTED_FOR_EXECUTION": "The target was selected for execution and passed its gate checks.",
+    "COMMAND_NOT_DECLARED": "The target command key is absent from the authoritative command declaration map.",
+    "COMMAND_DECLARATION_INVALID": "The authoritative command declaration is empty or malformed.",
+    "DEPENDENCY_UNKNOWN": "The target depends on a node that is not in the verification graph.",
+    "DEPENDENCY_BLOCKED": "A dependency was skipped or blocked, so this target cannot run.",
+    "DEPENDENCY_CYCLE": "The verification graph contains a dependency cycle.",
+    "VERIFICATION_REUSED": "The target reused an identity-matched verification receipt.",
+    "VERIFICATION_ARGV_NOT_CONCRETE": "The target command arguments are not concrete and executable.",
+}
+
+
+def _reason_explanation(reason_codes: list[str], decision: str) -> str:
+    explanations: list[str] = []
+    for raw in reason_codes:
+        code = str(raw).split(":", 1)[0]
+        explanation = _REASON_EXPLANATIONS.get(code)
+        if explanation is None:
+            if raw.startswith("depends-on:"):
+                explanation = f"The target waits for dependency {raw.split(':', 1)[1]} to complete."
+            elif raw.startswith("consumer-of:"):
+                explanation = f"The target is included because it consumes {raw.split(':', 1)[1]}."
+            elif raw.startswith("input-match:"):
+                explanation = f"A changed input matched {raw.split(':', 1)[1]}."
+            elif raw.startswith("CAPABILITY_MISSING:"):
+                explanation = f"Capability {raw.split(':', 1)[1]} is unavailable."
+            else:
+                explanation = f"Verification decision reason: {raw}."
+        if explanation not in explanations:
+            explanations.append(explanation)
+    if explanations:
+        return " ".join(explanations)
+    return {
+        "EXECUTE": "The target passed all declared gate checks and is ready to execute.",
+        "REUSE": "The target has valid identity-matched reusable evidence.",
+        "SKIP": "The target is not applicable to this change.",
+        "BLOCKED": "The target cannot execute until its blocking conditions are resolved.",
+    }.get(decision, "The target has no executable decision.")
+
 
 def _normalize_targets(raw_targets: Any) -> list[dict[str, Any]]:
     if isinstance(raw_targets, dict):
@@ -133,10 +184,26 @@ def _target_decision(
     frozen_identity: str,
     available_capabilities: set[str],
     verification_ledger: list[dict[str, Any]],
+    command_declarations: dict[str, Any] | None = None,
 ) -> tuple[str, list[str]]:
     blockers: list[str] = []
     if not product_identity:
         return "BLOCKED", ["PRODUCT_IDENTITY_REQUIRED"]
+    if command_declarations is not None:
+        command_key = str(target.get("commandKey") or "").strip()
+        declaration = command_declarations.get(command_key) if command_key else None
+        if declaration is None:
+            blockers.append("COMMAND_NOT_DECLARED")
+        elif isinstance(declaration, dict):
+            argv = declaration.get("argv") or declaration.get("argvTemplate")
+            if not isinstance(argv, list) or not argv or not all(
+                isinstance(item, str) and item for item in argv
+            ):
+                blockers.append("COMMAND_DECLARATION_INVALID")
+        elif not isinstance(declaration, list) or not declaration or not all(
+            isinstance(item, str) and item for item in declaration
+        ):
+            blockers.append("COMMAND_DECLARATION_INVALID")
     required_capabilities = {
         str(item).strip()
         for item in target.get("requiredCapabilities", [])
@@ -238,6 +305,12 @@ def schedule_verifications(payload: dict[str, Any]) -> dict[str, Any]:
         for item in payload.get("verificationLedger", [])
         if isinstance(item, dict)
     ]
+    raw_commands = payload.get("commands")
+    command_declarations = (
+        {str(key): value for key, value in raw_commands.items()}
+        if isinstance(raw_commands, dict)
+        else None
+    )
     decisions: dict[str, tuple[str, list[str]]] = {
         target_id: _target_decision(
             target,
@@ -245,6 +318,7 @@ def schedule_verifications(payload: dict[str, Any]) -> dict[str, Any]:
             frozen_identity=frozen_identity,
             available_capabilities=available_capabilities,
             verification_ledger=verification_ledger,
+            command_declarations=command_declarations,
         )
         for target_id, target in by_id.items()
     }
@@ -345,10 +419,14 @@ def schedule_verifications(payload: dict[str, Any]) -> dict[str, Any]:
                 "id": target_id,
                 "decision": decision,
                 "reasonCodes": reason_codes,
+                "explanation": _reason_explanation(reason_codes, decision),
                 "resourceLocks": _resource_locks(target),
                 "wave": placed[target_id],
             }
         )
+    decision_counts = dict(
+        sorted(Counter(item["decision"] for item in plan).items())
+    )
     return {
         "ok": all(item["decision"] != "BLOCKED" for item in plan),
         "code": (
@@ -359,6 +437,7 @@ def schedule_verifications(payload: dict[str, Any]) -> dict[str, Any]:
         "productIdentity": product_identity,
         "frozenIdentity": frozen_identity,
         "plan": plan,
+        "decisionCounts": decision_counts,
         "waves": [
             {"wave": index, "targets": target_ids}
             for index, target_ids in enumerate(waves)