@hunter-harness/workflow-harness 0.2.43 → 0.2.44

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

@@ -27,7 +27,7 @@ import sys
 import time
 import uuid
 from pathlib import Path
-from typing import Any
+from typing import Any, Callable, Mapping
 
 SCRIPTS_DIR = Path(__file__).resolve().parent
 if str(SCRIPTS_DIR) not in sys.path:
@@ -586,12 +586,14 @@ def _claim_lease_locked(
     run_id: str,
     ttl_seconds: int,
     steal: bool = False,
+    expected_generation: int | None = None,
 ) -> dict[str, Any]:
     path = _lease_path(project_root, change_id)
     path.parent.mkdir(parents=True, exist_ok=True)
     now = dt.datetime.now().astimezone()
     expires = now + dt.timedelta(seconds=max(1, ttl_seconds))
     new_lease = {
+        "leaseId": str(uuid.uuid4()),
         "changeId": change_id,
         "phase": phase,
         "runId": run_id,
@@ -599,6 +601,7 @@ def _claim_lease_locked(
         "acquiredAt": now.isoformat(timespec="milliseconds"),
         "expiresAt": expires.isoformat(timespec="milliseconds"),
         "ttlSeconds": ttl_seconds,
+        "generation": 1,
     }
     if path.is_file():
         try:
@@ -606,6 +609,12 @@ def _claim_lease_locked(
         except (OSError, json.JSONDecodeError):
             existing = None
         if isinstance(existing, dict) and not _lease_expired(existing):
+            if expected_generation is not None and existing.get("generation") != expected_generation:
+                return {
+                    "ok": False,
+                    "code": "LEASE_GENERATION_CONFLICT",
+                    "holder": existing,
+                }
             same_owner = str(existing.get("runId")) == run_id
             if same_owner:
                 existing.update(
@@ -614,6 +623,7 @@ def _claim_lease_locked(
                         "pid": os.getpid(),
                         "expiresAt": expires.isoformat(timespec="milliseconds"),
                         "refreshedAt": now.isoformat(timespec="milliseconds"),
+                        "generation": int(existing.get("generation") or 1) + 1,
                     }
                 )
                 _write_json(path, existing)
@@ -637,6 +647,7 @@ def claim_lease(
     run_id: str,
     ttl_seconds: int,
     steal: bool = False,
+    expected_generation: int | None = None,
 ) -> dict[str, Any]:
     path = _lease_path(project_root, change_id)
     with _exclusive_file_lock(path.with_suffix(".lock")):
@@ -647,6 +658,7 @@ def claim_lease(
             run_id=run_id,
             ttl_seconds=ttl_seconds,
             steal=steal,
+            expected_generation=expected_generation,
         )
 
 
@@ -656,6 +668,8 @@ def _release_lease_locked(
     change_id: str,
     phase: str,
     run_id: str,
+    lease_id: str | None = None,
+    generation: int | None = None,
 ) -> dict[str, Any]:
     path = _lease_path(project_root, change_id)
     if not path.is_file():
@@ -688,6 +702,18 @@ def _release_lease_locked(
             "message": f"lease phase is {existing.get('phase')}, not {phase}",
             "holder": existing,
         }
+    if lease_id is not None and str(existing.get("leaseId")) != lease_id:
+        return {
+            "ok": False,
+            "code": "LEASE_ID_MISMATCH",
+            "holder": existing,
+        }
+    if generation is not None and existing.get("generation") != generation:
+        return {
+            "ok": False,
+            "code": "LEASE_GENERATION_CONFLICT",
+            "holder": existing,
+        }
     path.unlink(missing_ok=True)
     return {"ok": True, "code": "LEASE_RELEASED", "changeId": change_id, "phase": phase}
 
@@ -698,11 +724,18 @@ def release_lease(
     change_id: str,
     phase: str,
     run_id: str,
+    lease_id: str | None = None,
+    generation: int | None = None,
 ) -> dict[str, Any]:
     path = _lease_path(project_root, change_id)
     with _exclusive_file_lock(path.with_suffix(".lock")):
         return _release_lease_locked(
-            project_root, change_id=change_id, phase=phase, run_id=run_id
+            project_root,
+            change_id=change_id,
+            phase=phase,
+            run_id=run_id,
+            lease_id=lease_id,
+            generation=generation,
         )
 
 
@@ -712,6 +745,8 @@ def lease_port(
     change_id: str,
     run_id: str,
     port_range: tuple[int, int],
+    generation: int = 1,
+    listener_identity: Mapping[str, Any] | None = None,
 ) -> dict[str, Any]:
     start, end = port_range
     if start > end:
@@ -749,6 +784,7 @@ def lease_port(
                     "leaseId": lease_id,
                     "changeId": change_id,
                     "runId": run_id,
+                    "generation": generation,
                     "pid": os.getpid(),
                     "port": port,
                     "acquiredAt": now_iso(),
@@ -756,6 +792,9 @@ def lease_port(
                         dt.datetime.now().astimezone() + dt.timedelta(hours=4)
                     ).isoformat(timespec="milliseconds"),
                 }
+                if isinstance(listener_identity, Mapping):
+                    entry["listenerIdentity"] = dict(listener_identity)
+                    entry["listenerProofRequired"] = True
                 leases.append(entry)
                 registry["leases"] = leases
                 _write_json(registry_path, registry)
@@ -774,6 +813,9 @@ def release_port(
     run_id: str,
     port: int | None = None,
     lease_id: str | None = None,
+    generation: int | None = None,
+    listener_identity: Mapping[str, Any] | None = None,
+    listener_observer: Callable[[int], Mapping[str, Any] | None] | None = None,
 ) -> dict[str, Any]:
     """Release port leases by subset (retro §5.16).
 
@@ -802,6 +844,12 @@ def release_port(
             ]
             # Validate that the lease belongs to this change
             for item in to_release:
+                if generation is not None and item.get("generation") != generation:
+                    return {
+                        "ok": False,
+                        "code": "PORT_LEASE_GENERATION_CONFLICT",
+                        "holder": item,
+                    }
                 if str(item.get("changeId")) != change_id:
                     return {
                         "ok": False,
@@ -818,6 +866,12 @@ def release_port(
             ]
             # Validate runId matches
             for item in to_release:
+                if generation is not None and item.get("generation") != generation:
+                    return {
+                        "ok": False,
+                        "code": "PORT_LEASE_GENERATION_CONFLICT",
+                        "holder": item,
+                    }
                 if str(item.get("runId")) != run_id:
                     return {
                         "ok": False,
@@ -840,6 +894,47 @@ def release_port(
                 and str(item.get("changeId")) == change_id
                 and str(item.get("runId")) == run_id
             ]
+            if generation is not None:
+                mismatched = [
+                    item for item in to_release if item.get("generation") != generation
+                ]
+                if mismatched:
+                    return {
+                        "ok": False,
+                        "code": "PORT_LEASE_GENERATION_CONFLICT",
+                        "holder": mismatched[0],
+                    }
+
+        for item in to_release:
+            expected_listener = item.get("listenerIdentity")
+            if not isinstance(expected_listener, Mapping):
+                continue
+            observed_listener = (
+                listener_observer(int(item["port"]))
+                if listener_observer is not None and isinstance(item.get("port"), int)
+                else listener_identity
+            )
+            if not isinstance(observed_listener, Mapping):
+                return {
+                    "ok": False,
+                    "code": "LISTENER_IDENTITY_UNVERIFIABLE",
+                    "message": "listener identity could not be independently observed",
+                    "holder": item,
+                }
+            try:
+                from harness_process import verify_process_identity
+
+                decision = verify_process_identity(expected_listener, observed_listener)
+            except (ImportError, TypeError, ValueError):
+                decision = {"ok": False, "reasonCode": "IDENTITY_UNVERIFIABLE"}
+            if decision.get("ok") is not True:
+                return {
+                    "ok": False,
+                    "code": "LISTENER_IDENTITY_UNVERIFIABLE",
+                    "message": "listener identity did not match the leased service",
+                    "details": decision,
+                    "holder": item,
+                }
 
         if not to_release:
             # Check if there are other leases under this changeId (different runId)
@@ -1011,6 +1106,7 @@ def cmd_claim(args: argparse.Namespace) -> int:
         run_id=args.run_id,
         ttl_seconds=int(args.ttl_seconds),
         steal=bool(args.steal),
+        expected_generation=getattr(args, "expected_generation", None),
     )
     if payload.get("ok"):
         emit(payload, as_json=bool(args.json))
@@ -1030,6 +1126,8 @@ def cmd_release(args: argparse.Namespace) -> int:
         change_id=args.change,
         phase=args.phase,
         run_id=args.run_id,
+        lease_id=getattr(args, "lease_id", None),
+        generation=getattr(args, "generation", None),
     )
     if payload.get("ok"):
         emit(payload, as_json=bool(args.json))
@@ -1051,11 +1149,26 @@ def cmd_lease_port(args: argparse.Namespace) -> int:
             f"expected --range <start-end>, got {args.range!r}",
             as_json=bool(args.json),
         )
+    listener_identity = None
+    if getattr(args, "listener_identity_json", None):
+        try:
+            parsed_listener = json.loads(args.listener_identity_json)
+            if not isinstance(parsed_listener, dict):
+                raise ValueError("listener identity must be an object")
+            listener_identity = parsed_listener
+        except (TypeError, ValueError, json.JSONDecodeError) as exc:
+            return emit_error(
+                "LISTENER_IDENTITY_UNVERIFIABLE",
+                str(exc),
+                as_json=bool(args.json),
+            )
     payload = lease_port(
         project,
         change_id=args.change,
         run_id=args.run_id,
         port_range=parsed,
+        generation=int(getattr(args, "generation", 1)),
+        listener_identity=listener_identity,
     )
     if payload.get("ok"):
         emit(payload, as_json=bool(args.json))
@@ -1070,12 +1183,27 @@ def cmd_lease_port(args: argparse.Namespace) -> int:
 
 def cmd_release_port(args: argparse.Namespace) -> int:
     project = resolve_main_project_root()
+    listener_identity = None
+    if getattr(args, "listener_identity_json", None):
+        try:
+            parsed_listener = json.loads(args.listener_identity_json)
+            if not isinstance(parsed_listener, dict):
+                raise ValueError("listener identity must be an object")
+            listener_identity = parsed_listener
+        except (TypeError, ValueError, json.JSONDecodeError) as exc:
+            return emit_error(
+                "LISTENER_IDENTITY_UNVERIFIABLE",
+                str(exc),
+                as_json=bool(args.json),
+            )
     payload = release_port(
         project,
         change_id=args.change,
         run_id=args.run_id,
         port=getattr(args, "port", None),
         lease_id=getattr(args, "lease_id", None),
+        generation=getattr(args, "generation", None),
+        listener_identity=listener_identity,
     )
     if payload.get("ok"):
         emit(payload, as_json=bool(args.json))
@@ -1329,18 +1457,23 @@ def build_parser() -> argparse.ArgumentParser:
     p_claim.add_argument("--run-id", required=True)
     p_claim.add_argument("--ttl-seconds", type=int, default=3600)
     p_claim.add_argument("--steal", action="store_true")
+    p_claim.add_argument("--expected-generation", type=int, default=None)
     p_claim.set_defaults(func=cmd_claim)
 
     p_release = sub.add_parser("release", parents=[shared])
     p_release.add_argument("--change", required=True)
     p_release.add_argument("--phase", required=True)
     p_release.add_argument("--run-id", required=True)
+    p_release.add_argument("--lease-id", default=None)
+    p_release.add_argument("--generation", type=int, default=None)
     p_release.set_defaults(func=cmd_release)
 
     p_port = sub.add_parser("lease-port", parents=[shared])
     p_port.add_argument("--change", required=True)
     p_port.add_argument("--run-id", required=True)
     p_port.add_argument("--range", required=True)
+    p_port.add_argument("--generation", type=int, default=1)
+    p_port.add_argument("--listener-identity-json", default=None)
     p_port.set_defaults(func=cmd_lease_port)
 
     p_port_release = sub.add_parser("release-port", parents=[shared])
@@ -1348,6 +1481,8 @@ def build_parser() -> argparse.ArgumentParser:
     p_port_release.add_argument("--run-id", required=True)
     p_port_release.add_argument("--port", type=int, default=None)
     p_port_release.add_argument("--lease-id", default=None)
+    p_port_release.add_argument("--generation", type=int, default=None)
+    p_port_release.add_argument("--listener-identity-json", default=None)
     p_port_release.set_defaults(func=cmd_release_port)
 
     p_lock = sub.add_parser("integration-lock", parents=[shared])

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

@@ -30,6 +30,131 @@ def _integer(value: Any) -> int:
         return 0
 
 
+def _timestamp(value: Any) -> dt.datetime | None:
+    if isinstance(value, dt.datetime):
+        parsed = value
+    elif value:
+        try:
+            parsed = dt.datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+        except (TypeError, ValueError):
+            return None
+    else:
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=dt.timezone.utc)
+    return parsed.astimezone(dt.timezone.utc)
+
+
+def _now_timestamp(value: Any = None) -> dt.datetime:
+    return _timestamp(value) or dt.datetime.now(dt.timezone.utc)
+
+
+def _seconds(value: Any) -> float | None:
+    try:
+        parsed = float(value)
+    except (TypeError, ValueError):
+        return None
+    return parsed if parsed > 0 else None
+
+
+def classify_progress(
+    session: dict[str, Any],
+    *,
+    now: Any = None,
+    historical_durations: list[int | float] | None = None,
+) -> dict[str, Any]:
+    """Classify observable run state without changing execution policy.
+
+    The classifier is intentionally conservative: incomplete clock/heartbeat
+    data produces explicit ``INCOMPLETE``/``NO_BUDGET`` facts instead of an
+    invented ETA or a guessed failure cause.
+    """
+    status = str(session.get("status") or "RUNNING").upper()
+    terminal = {
+        "OK": "COMPLETED",
+        "PASS": "COMPLETED",
+        "COMPLETED": "COMPLETED",
+        "FAIL": "FAILED",
+        "FAILED": "FAILED",
+        "CANCELLED": "CANCELLED",
+        "CANCELED": "CANCELLED",
+        "INCOMPLETE": "INCOMPLETE",
+    }
+    started = _timestamp(session.get("startedAt") or session.get("createdAt"))
+    current = _now_timestamp(now)
+    elapsed_seconds: float | None = None
+    if started is not None:
+        elapsed_seconds = max(0.0, (current - started).total_seconds())
+
+    timeout_seconds = _seconds(session.get("timeoutSeconds"))
+    expected_seconds = _seconds(
+        session.get("expectedDurationSeconds")
+        or session.get("estimatedDurationSeconds")
+    )
+    budget_seconds = _seconds(
+        session.get("budgetSeconds")
+        or session.get("maxDurationSeconds")
+        or expected_seconds
+        or timeout_seconds
+    )
+    if elapsed_seconds is None or budget_seconds is None:
+        budget_state = "NO_BUDGET"
+    elif elapsed_seconds >= budget_seconds:
+        budget_state = "OVER_BUDGET"
+    else:
+        budget_state = "WITHIN_BUDGET"
+
+    progress_state = terminal.get(status)
+    diagnostic_required = False
+    heartbeat_grace = _seconds(
+        session.get("heartbeatGraceSeconds")
+        or session.get("heartbeatTimeoutSeconds")
+        or 60
+    ) or 60
+    heartbeat = _timestamp(session.get("lastHeartbeatAt"))
+    output = _timestamp(
+        session.get("lastOutputAt") or session.get("lastLogAt")
+    )
+    heartbeat_gap = (
+        max(0.0, (current - heartbeat).total_seconds())
+        if heartbeat is not None
+        else None
+    )
+    output_gap = (
+        max(0.0, (current - output).total_seconds()) if output is not None else None
+    )
+
+    if progress_state is None:
+        progress_state = "RUNNING"
+        if timeout_seconds is not None and elapsed_seconds is not None and elapsed_seconds >= timeout_seconds:
+            progress_state = "TIMEOUT"
+        elif output_gap is not None and output_gap > heartbeat_grace:
+            progress_state = "NO_OUTPUT_PROCESS_ACTIVE"
+        elif heartbeat_gap is None or heartbeat_gap > heartbeat_grace:
+            progress_state = "HEARTBEAT_LOST"
+        elif _integer(session.get("resourceWaitMs")) > 0 or session.get("resourceWaitActive") is True:
+            progress_state = "RESOURCE_WAIT"
+        elif expected_seconds is not None and elapsed_seconds is not None and elapsed_seconds > expected_seconds:
+            progress_state = "SLOW_PROGRESSING"
+        diagnostic_required = progress_state in {
+            "TIMEOUT",
+            "HEARTBEAT_LOST",
+            "NO_OUTPUT_PROCESS_ACTIVE",
+        } or budget_state == "OVER_BUDGET"
+    elif progress_state not in {"COMPLETED", "FAILED", "CANCELLED"}:
+        diagnostic_required = True
+
+    return {
+        "progressState": progress_state,
+        "budgetState": budget_state,
+        "diagnosticRequired": diagnostic_required,
+        "elapsedSeconds": int(elapsed_seconds) if elapsed_seconds is not None else None,
+        "budgetSeconds": budget_seconds,
+        "heartbeatGapSeconds": int(heartbeat_gap) if heartbeat_gap is not None else None,
+        "outputGapSeconds": int(output_gap) if output_gap is not None else None,
+    }
+
+
 def _failure_class(session: dict[str, Any]) -> str | None:
     status = str(session.get("status") or "").upper()
     reason = str(session.get("reasonCode") or "").upper()
@@ -128,10 +253,27 @@ def build_efficiency_summary(
     invalidations: list[dict[str, Any]],
 ) -> dict[str, Any]:
     failure_counts = {key: 0 for key in FAILURE_CLASSES}
+    progress_states: Counter[str] = Counter()
+    budget_states: Counter[str] = Counter()
+    slow_stages: Counter[str] = Counter()
     for session in run_sessions:
         classification = _failure_class(session)
         if classification is not None:
             failure_counts[classification] += 1
+        progress = str(
+            session.get("progressState")
+            or classify_progress(session).get("progressState")
+            or "INCOMPLETE"
+        ).upper()
+        budget = str(
+            session.get("budgetState")
+            or classify_progress(session).get("budgetState")
+            or "NO_BUDGET"
+        ).upper()
+        progress_states[progress] += 1
+        budget_states[budget] += 1
+        if progress == "SLOW_PROGRESSING":
+            slow_stages[str(session.get("stage") or session.get("verification") or "unknown")] += 1
     environment_actions: Counter[str] = Counter()
     for item in environment_receipts:
         action = str(item.get("action") or "").lower()
@@ -183,6 +325,9 @@ def build_efficiency_summary(
             for item in run_sessions
         ),
         "failureClasses": failure_counts,
+        "progressStates": dict(sorted(progress_states.items())),
+        "budgetStates": dict(sorted(budget_states.items())),
+        "slowStages": dict(sorted(slow_stages.items())),
         "invalidationReasons": _counts(
             str(item.get("reasonCode") or "UNKNOWN")
             for item in invalidations
@@ -226,6 +371,10 @@ def compact_progress_view(
             "typicalSeconds": int(median(durations)),
             "highSeconds": durations[-1],
         }
+    classification = classify_progress(
+        session,
+        historical_durations=historical_durations,
+    )
     return {
         "verification": session.get("verification"),
         "stage": session.get("stage"),
@@ -235,6 +384,10 @@ def compact_progress_view(
         "eta": eta,
         "resourceWait": list(session.get("resourceLocks") or []),
         "status": session.get("status", "RUNNING"),
+        "progressState": classification["progressState"],
+        "budgetState": classification["budgetState"],
+        "diagnosticRequired": classification["diagnosticRequired"],
+        "elapsedSeconds": classification["elapsedSeconds"],
     }
 
 

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

@@ -23,10 +23,31 @@ from contextlib import contextmanager
 from pathlib import Path
 from typing import Any, Iterator
 
-import harness_service as hservice
+import harness_process as hprocess
 from harness_paths import resolve_state_dir_for_contract
 
 
+def _verify_recorded_owner(owner: dict[str, Any]) -> bool | None:
+    try:
+        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
+    if decision.get("reasonCode") == "IDENTITY_UNVERIFIABLE":
+        return None
+    return False
+
+
 if hasattr(sys.stdout, "reconfigure"):
     sys.stdout.reconfigure(encoding="utf-8")
 if hasattr(sys.stderr, "reconfigure"):
@@ -358,7 +379,7 @@ def _lease_registry_guard(lease_root: Path) -> Iterator[None]:
             except (OSError, json.JSONDecodeError):
                 holder = {}
             pid = holder.get("pid") if isinstance(holder, dict) else None
-            if isinstance(pid, int) and pid > 0 and not hservice.is_pid_alive(pid):
+            if isinstance(pid, int) and pid > 0 and not hprocess.is_pid_alive(pid):
                 try:
                     lock_path.unlink()
                     continue
@@ -444,22 +465,40 @@ def execute_provider_operation(
         raise ValueError("ENVIRONMENT_PROVIDER_LEASE_INVALID")
     executable = shutil.which(argv[0]) or str(Path(argv[0]).expanduser().resolve())
     started_at = now_iso()
-    process = subprocess.Popen(
+    spawned = hprocess.spawn_structured_argv(
         argv,
-        cwd=str(project.resolve()),
-        stdin=subprocess.DEVNULL,
+        cwd=project.resolve(),
+        environment={},
+        owner_token=f"environment:{change_id}:{stack_id}:{uuid.uuid4().hex}",
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
-        shell=False,
     )
-    created = hservice.get_process_create_time(process.pid)
+    process = spawned.process
+    created = hprocess.get_process_create_time(process.pid)
+    cleanup_complete = False
     try:
         stdout, stderr = process.communicate(timeout=timeout_seconds)
         timed_out = False
     except subprocess.TimeoutExpired:
         timed_out = True
-        hservice.terminate_process_tree(process.pid)
+        hprocess.capture_owned_members(spawned)
+        cleanup = hprocess.terminate_owned_tree(
+            spawned.attestation,
+            spawned.ownershipProof,
+            {"graceSeconds": 3.0},
+        )
+        cleanup_complete = bool(cleanup.get("cleanupComplete"))
         stdout, stderr = process.communicate()
+    finally:
+        if process.poll() is None:
+            hprocess.capture_owned_members(spawned)
+            cleanup = hprocess.terminate_owned_tree(
+                spawned.attestation,
+                spawned.ownershipProof,
+                {"graceSeconds": 3.0},
+            )
+            cleanup_complete = bool(cleanup.get("cleanupComplete"))
+        spawned.close()
     operation_id = uuid.uuid4().hex
     receipt_path = _provider_operation_root(root) / f"{operation}-{operation_id}.json"
     receipt: dict[str, Any] = {
@@ -490,6 +529,9 @@ def execute_provider_operation(
                     "utf-8"
                 )
             ),
+            "processAttestation": spawned.attestation,
+            "ownershipProof": spawned.ownershipProof,
+            "cleanupComplete": cleanup_complete or process.poll() is not None,
         },
         "exitCode": process.returncode,
         "timedOut": timed_out,
@@ -716,7 +758,7 @@ def classify_leases(lease_root: Path) -> list[dict[str, Any]]:
             item["classification"] = "OWNER_IDENTITY_INCOMPLETE"
             results.append(item)
             continue
-        if not hservice.is_pid_alive(owner_pid):
+        if not hprocess.is_pid_alive(owner_pid):
             item["classification"] = "RECLAIMABLE"
             results.append(item)
             continue
@@ -728,13 +770,7 @@ def classify_leases(lease_root: Path) -> list[dict[str, Any]]:
             )
             results.append(item)
             continue
-        identity = hservice.verify_process_identity(
-            {
-                "pid": owner_pid,
-                "startedAt": owner["startedAt"],
-                "processIdentity": {"executable": owner["executable"]},
-            }
-        )
+        identity = _verify_recorded_owner(owner)
         item["classification"] = (
             "OWNER_ACTIVE"
             if identity is True
@@ -1021,13 +1057,7 @@ def _acquire_lease_locked(
             owner_pid = int(owner.get("pid"))
         except (TypeError, ValueError):
             owner_pid = 0
-        owner_verified = hservice.verify_process_identity(
-            {
-                "pid": owner_pid,
-                "startedAt": owner.get("startedAt"),
-                "processIdentity": {"executable": owner.get("executable")},
-            }
-        ) is True
+        owner_verified = _verify_recorded_owner(owner) is True
     expires_at = _parse_expiry(current.get("expiresAt"))
     unexpired = (
         expires_at is not None
@@ -1106,10 +1136,10 @@ def _acquire_lease_locked(
         "resetCount": reset_count + (1 if is_reset else 0),
         "owner": {
             "pid": os.getpid(),
-            "executable": hservice.get_process_executable(os.getpid())
+            "executable": hprocess.get_process_executable(os.getpid())
             or str(Path(sys.executable).resolve()),
             "startedAt": (
-                hservice.get_process_create_time(os.getpid())
+                hprocess.get_process_create_time(os.getpid())
                 or started
             ).isoformat(timespec="seconds"),
         },