agent-lifecycle-kit 1.76.0__tar.gz → 1.77.0__tar.gz

{agent_lifecycle_kit-1.76.0/src/agent_lifecycle_kit.egg-info → agent_lifecycle_kit-1.77.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-lifecycle-kit
-Version: 1.76.0
+Version: 1.77.0
 Summary: Provider-neutral lifecycle control layer that helps coding agents plan, execute, validate, and prove software tasks to completion.
 Author: Agent Lifecycle Kit contributors
 License: Apache-2.0
@@ -43,7 +43,7 @@ ALK provides a verifiable finish for external-agent work with proportionate cont
 ## Quick start
 Start with [install ALK and make the first run](docs/guides/install-and-first-run.md).
 
-It includes macOS, Linux and Windows instructions, Python 3.11-3.14, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==1.76.0`, and common `agent-lifecycle version` errors.
+It includes macOS, Linux and Windows instructions, Python 3.11-3.14, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==1.77.0`, and common `agent-lifecycle version` errors.
 
 For a quick start, run:
 
@@ -64,7 +64,6 @@ and pass a task from a file:
 agent-lifecycle start --adapter <adapter-id> --file task.md
 ```
 
-- Start with [quickstart](docs/guides/quickstart.md).
 - Then choose a suitable scenario in [how ALK works for different tasks](docs/guides/how-alk-works.md).
 - The boundaries of [planning-only launch](docs/reference/planning-only-launch.md) and [frozen-task launch through a verified profile](docs/reference/qualified-host-launch.md) are documented in the reference. Shipped planning profiles remain candidates with safe failure until the corresponding profile is verified.
 - The [system architecture](docs/architecture/system-architecture.md) page explains how the project is organized, and [project comparison](docs/reference/project-comparison.md) shows how it differs from similar tools.
@@ -81,6 +80,7 @@ agent-lifecycle start --adapter <adapter-id> --file task.md
   composes risk, model class, packet size, review and resource limits.
 - Usage visibility: tokens, time, resource counters and structured execution records without sensitive data are native; monetary cost is optional and only used when a metered host reports it.
 - Project-specific workflow settings: ALK can discover and validate uncommitted local defaults, or apply a built-in workflow preset for a common route, while the frozen plan remains authoritative.
+- Reproducible Python maintenance: pinned development-only Ruff, mypy and coverage checks, a non-growing quality ratchet, stable redacted CLI errors, installed package resources and an explicit documented Python API.
 - Project principles and plan deltas keep long-running work understandable: principles provide bounded defaults, while a digest-bound delta shows which plan authority changed and whether review and a new lock are required. CI also checks an acyclic module/package graph, layer direction and source-size limits; adapter inspection uses bounded literal profiles and fails closed without executing adapter code.
 - Read-only progress and managed sessions: host UIs can show lifecycle state,
   attested tokens and Git-style change counters; `start` accepts task text,

{agent_lifecycle_kit-1.76.0 → agent_lifecycle_kit-1.77.0}/README.md

@@ -21,7 +21,7 @@ ALK provides a verifiable finish for external-agent work with proportionate cont
 ## Quick start
 Start with [install ALK and make the first run](docs/guides/install-and-first-run.md).
 
-It includes macOS, Linux and Windows instructions, Python 3.11-3.14, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==1.76.0`, and common `agent-lifecycle version` errors.
+It includes macOS, Linux and Windows instructions, Python 3.11-3.14, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==1.77.0`, and common `agent-lifecycle version` errors.
 
 For a quick start, run:
 
@@ -42,7 +42,6 @@ and pass a task from a file:
 agent-lifecycle start --adapter <adapter-id> --file task.md
 ```
 
-- Start with [quickstart](docs/guides/quickstart.md).
 - Then choose a suitable scenario in [how ALK works for different tasks](docs/guides/how-alk-works.md).
 - The boundaries of [planning-only launch](docs/reference/planning-only-launch.md) and [frozen-task launch through a verified profile](docs/reference/qualified-host-launch.md) are documented in the reference. Shipped planning profiles remain candidates with safe failure until the corresponding profile is verified.
 - The [system architecture](docs/architecture/system-architecture.md) page explains how the project is organized, and [project comparison](docs/reference/project-comparison.md) shows how it differs from similar tools.
@@ -59,6 +58,7 @@ agent-lifecycle start --adapter <adapter-id> --file task.md
   composes risk, model class, packet size, review and resource limits.
 - Usage visibility: tokens, time, resource counters and structured execution records without sensitive data are native; monetary cost is optional and only used when a metered host reports it.
 - Project-specific workflow settings: ALK can discover and validate uncommitted local defaults, or apply a built-in workflow preset for a common route, while the frozen plan remains authoritative.
+- Reproducible Python maintenance: pinned development-only Ruff, mypy and coverage checks, a non-growing quality ratchet, stable redacted CLI errors, installed package resources and an explicit documented Python API.
 - Project principles and plan deltas keep long-running work understandable: principles provide bounded defaults, while a digest-bound delta shows which plan authority changed and whether review and a new lock are required. CI also checks an acyclic module/package graph, layer direction and source-size limits; adapter inspection uses bounded literal profiles and fails closed without executing adapter code.
 - Read-only progress and managed sessions: host UIs can show lifecycle state,
   attested tokens and Git-style change counters; `start` accepts task text,

{agent_lifecycle_kit-1.76.0 → agent_lifecycle_kit-1.77.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agent-lifecycle-kit"
-version = "1.76.0"
+version = "1.77.0"
 description = "Provider-neutral lifecycle control layer that helps coding agents plan, execute, validate, and prove software tasks to completion."
 readme = "README.md"
 requires-python = ">=3.11,<3.15"
@@ -39,6 +39,13 @@ classifiers = [
 ]
 dependencies = []
 
+[dependency-groups]
+quality = [
+  "ruff==0.16.3",
+  "mypy==1.17.1",
+  "coverage==7.10.6",
+]
+
 [project.scripts]
 agent-lifecycle = "agent_lifecycle.cli:main"
 agent-lifecycle-neutrality = "agent_lifecycle.neutrality.cli:main"
@@ -47,14 +54,29 @@ agent-lifecycle-neutrality = "agent_lifecycle.neutrality.cli:main"
 where = ["src"]
 
 [tool.setuptools.package-data]
-agent_lifecycle = ["py.typed"]
+agent_lifecycle = ["py.typed", "data/profiles/**/*.json"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 120
+src = ["src"]
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "B", "I", "UP", "RUF", "SIM", "PTH", "ARG", "BLE"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["agent_lifecycle"]
+
+[tool.ruff.format]
+quote-style = "double"
+
+[tool.mypy]
+python_version = "3.11"
+files = ["src/agent_lifecycle"]
+ignore_missing_imports = true
+show_error_codes = true
 
 [tool.setuptools.data-files]
-"profiles/project-workflow-presets" = [
-  "profiles/project-workflow-presets/quick-change.v1.json",
-  "profiles/project-workflow-presets/research-review.v1.json",
-  "profiles/project-workflow-presets/feature-implementation.v1.json",
-]
 "benchmarks/reference-tasks" = [
   "benchmarks/reference-tasks/README.md",
   "benchmarks/reference-tasks/manifest.json",

{agent_lifecycle_kit-1.76.0 → agent_lifecycle_kit-1.77.0}/src/agent_lifecycle/__init__.py

@@ -2,4 +2,4 @@
 
 from ._version import __version__
 
-__all__ = ["__version__"]
+__all__ = ("__version__",)

{agent_lifecycle_kit-1.76.0 → agent_lifecycle_kit-1.77.0}/src/agent_lifecycle/_version.py

@@ -1,3 +1,3 @@
 """Package version."""
 
-__version__ = "1.76.0"
+__version__ = "1.77.0"

{agent_lifecycle_kit-1.76.0 → agent_lifecycle_kit-1.77.0}/src/agent_lifecycle/adapter_sessions/launch_execution.py

@@ -5,37 +5,27 @@ from __future__ import annotations
 import hashlib
 import os
 import subprocess
+from collections.abc import Callable
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any
 
 from agent_lifecycle.adapter_sessions.contracts import (
     build_launch_receipt,
-    build_local_launch_probe_receipt,
     build_local_launch_profile_receipt,
 )
 from agent_lifecycle.adapter_sessions.env import resolve_launch_env
 from agent_lifecycle.adapter_sessions.local_launch_profile import (
     build_executable_identity,
     load_local_launch_profile,
-    local_receipt_argv,
     local_profile_summary,
-    planning_receipt_argv,
-    render_local_launch_argv,
     render_planning_launch_argv,
 )
 from agent_lifecycle.adapter_sessions.planning_launch import run_planning_launch
-from agent_lifecycle.adapter_sessions.process import run_process as _process_runner
 from agent_lifecycle.adapter_sessions.qualification import (
-    build_qualification_receipt,
-    require_planning_qualification_receipt,
-    require_qualification_receipt,
     shipped_profile_digest,
-    write_qualification_receipt,
 )
 from agent_lifecycle.contracts import LifecycleError, canonical_digest, read_json_object
-from agent_lifecycle.freeze import verify_plan_package_integrity
 from agent_lifecycle.host_protocol.validation import validate_managed_launch_profile
-from agent_lifecycle.workflow.risk_execution_gate import validate_task_risk_profile
 
 
 def load_adapter_descriptor(adapter_id: str, descriptor_path: Path | None = None) -> tuple[Path, dict[str, Any]]:
@@ -69,7 +59,8 @@ def launch_from_descriptor(
     raw_profile = descriptor.get("managedLaunch")
     profile = raw_profile if isinstance(raw_profile, dict) else {}
     validation = validate_managed_launch_profile(profile)
-    adapter_id = descriptor.get("adapterId") if isinstance(descriptor.get("adapterId"), str) else "unknown"
+    raw_adapter_id = descriptor.get("adapterId")
+    adapter_id = raw_adapter_id if isinstance(raw_adapter_id, str) else "unknown"
     timeout_seconds = _timeout_seconds(profile)
     blockers: list[dict[str, Any]] = []
     if validation["status"] != "PASS":
@@ -126,8 +117,6 @@ def inspect_local_launch_profile(
     )
 
 
-
-
 def run_planning_qualification_candidate(
     *,
     profile_path: Path,
@@ -198,7 +187,8 @@ def run_planning_qualification_candidate(
     )
     after = identity_runner(root)
     blockers = list(receipt.get("blockers", []))
-    usage = receipt.get("usageEvidence") if isinstance(receipt.get("usageEvidence"), dict) else {}
+    raw_usage = receipt.get("usageEvidence")
+    usage: dict[str, Any] = raw_usage if isinstance(raw_usage, dict) else {}
     input_tokens = usage.get("inputTokens")
     output_tokens = usage.get("outputTokens")
     if usage.get("confidence") != "ATTESTED" or not isinstance(input_tokens, int) or not isinstance(output_tokens, int):
@@ -332,7 +322,7 @@ def capture_git_worktree_identity(project_root: Path) -> dict[str, Any]:
         try:
             before = path.lstat()
             if path.is_symlink():
-                payload = os.fsencode(os.readlink(path))
+                payload = os.fsencode(path.readlink())
                 kind = "symlink"
             else:
                 payload = path.read_bytes()
@@ -379,8 +369,7 @@ def _git_bytes(root: Path, args: list[str]) -> bytes:
             cwd=root,
             shell=False,
             stdin=subprocess.DEVNULL,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
+            capture_output=True,
             timeout=10,
             check=False,
         )
@@ -478,7 +467,8 @@ def _planning_qualification_report(
         and before.get("identityDigest") == after.get("identityDigest")
         and not blockers
     )
-    policy = profile.get("qualification") if isinstance(profile.get("qualification"), dict) else {}
+    raw_policy = profile.get("qualification")
+    policy: dict[str, Any] = raw_policy if isinstance(raw_policy, dict) else {}
     body = {
         "schemaVersion": "agent-planning-launch-qualification-evidence.v1",
         "status": "PASS" if passed else "FAIL",
@@ -490,7 +480,8 @@ def _planning_qualification_report(
             "maxWallSeconds": approved_wall_seconds,
             "modelTokenBudget": approved_model_token_budget,
         },
-        "usageEvidence": usage_evidence or {
+        "usageEvidence": usage_evidence
+        or {
             "confidence": "MISSING",
             "inputTokens": None,
             "outputTokens": None,
@@ -499,9 +490,7 @@ def _planning_qualification_report(
         "planningSupportStatus": "PLANNING_ONLY_QUALIFIED" if passed else "PLANNING_ONLY_UNSUPPORTED",
         "processCalls": 1 if receipt and receipt.get("hostLaunchStarted") else 0,
         "modelCallsStarted": bool(receipt and receipt.get("modelCallsStarted")),
-        "worktreeUnchanged": bool(
-            before and after and before.get("identityDigest") == after.get("identityDigest")
-        ),
+        "worktreeUnchanged": bool(before and after and before.get("identityDigest") == after.get("identityDigest")),
         "planningReceiptDigest": receipt.get("receiptDigest") if receipt else None,
         "blockers": blockers,
         "productionPromotionClaimed": False,

{agent_lifecycle_kit-1.76.0 → agent_lifecycle_kit-1.77.0}/src/agent_lifecycle/adapter_sessions/launch_preflight.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any
 
 from agent_lifecycle.adapter_sessions.contracts import (
     build_launch_receipt,
@@ -12,11 +13,19 @@ from agent_lifecycle.adapter_sessions.contracts import (
     build_local_launch_profile_receipt,
 )
 from agent_lifecycle.adapter_sessions.env import resolve_launch_env
+from agent_lifecycle.adapter_sessions.launch_execution import (
+    _attach_qualification_receipt,
+    _blocked_local_launch,
+    _blocked_planning_launch,
+    _managed_launch_blockers,
+    _state_task,
+    capture_git_worktree_identity,
+)
 from agent_lifecycle.adapter_sessions.local_launch_profile import (
     build_executable_identity,
     load_local_launch_profile,
-    local_receipt_argv,
     local_profile_summary,
+    local_receipt_argv,
     planning_receipt_argv,
     render_local_launch_argv,
     render_planning_launch_argv,
@@ -32,19 +41,8 @@ from agent_lifecycle.adapter_sessions.qualification import (
 )
 from agent_lifecycle.contracts import LifecycleError, canonical_digest, read_json_object
 from agent_lifecycle.freeze import verify_plan_package_integrity
-from agent_lifecycle.host_protocol.validation import validate_managed_launch_profile
 from agent_lifecycle.workflow.risk_execution_gate import validate_task_risk_profile
 
-from agent_lifecycle.adapter_sessions.launch_execution import (
-    _attach_qualification_receipt,
-    _blocked_local_launch,
-    _blocked_planning_launch,
-    _managed_launch_blockers,
-    _planning_qualification_report,
-    _state_task,
-    capture_git_worktree_identity,
-)
-
 
 @dataclass(frozen=True)
 class _LaunchContext:
@@ -56,7 +54,7 @@ class _LaunchContext:
     env: dict[str, str]
     env_receipt: dict[str, Any]
     timeout_seconds: float
-    shipped_digest: str
+    shipped_digest: str | None
     runner: Callable[..., dict[str, Any]]
 
 
@@ -232,7 +230,9 @@ def _planning_task(
     identity = _identity(context, strict=False)
     try:
         if identity["status"] != "PASS":
-            raise LifecycleError("local-launch-executable-identity-unavailable", "planning launch executable identity is unavailable")
+            raise LifecycleError(
+                "local-launch-executable-identity-unavailable", "planning launch executable identity is unavailable"
+            )
         qualification_receipt = require_planning_qualification_receipt(
             project_root=context.root,
             profile=context.profile,
@@ -345,7 +345,9 @@ def _managed_task(
         if manifest.get("status") != "FROZEN":
             raise LifecycleError("local-launch-frozen-plan-required", "local launch requires a frozen plan")
         task = _state_task(state, task_id)
-        validate_task_risk_profile(state, task, risk_profile, operation_id=operation_id, source_revision=source_revision)
+        validate_task_risk_profile(
+            state, task, risk_profile, operation_id=operation_id, source_revision=source_revision
+        )
         qualification_receipt = require_qualification_receipt(
             project_root=context.root,
             profile=context.profile,
@@ -389,7 +391,7 @@ def _run_managed_process(
     operation_id: str,
     source_revision: str,
     risk_profile: dict[str, Any],
-    qualification_receipt: dict[str, Any],
+    qualification_receipt: dict[str, Any] | None,
     host_identity: dict[str, Any],
 ) -> dict[str, Any]:
     bindings = {

{agent_lifecycle_kit-1.76.0 → agent_lifecycle_kit-1.77.0}/src/agent_lifecycle/adapter_sessions/planning_session.py

@@ -15,15 +15,14 @@ from agent_lifecycle.contracts import (
 from agent_lifecycle.contracts.canonical import ensure_private_directory
 from agent_lifecycle.contracts.persistence import (
     create_private_json as write_json_create_private,
+)
+from agent_lifecycle.contracts.persistence import (
     replace_private_json as write_json_replace_private,
-    require_private_json as require_private_file,
 )
 
 PLANNING_SESSION_SCHEMA = "agent-planning-session-state.v1"
 PLANNING_SESSION_ROOT = Path(".alk/planning-sessions")
-PLANNING_SESSION_STATES = frozenset(
-    {"INTAKE_ACCEPTED", "PLANNING_RUNNING", "REVIEW_REQUIRED", "BLOCKED"}
-)
+PLANNING_SESSION_STATES = frozenset({"INTAKE_ACCEPTED", "PLANNING_RUNNING", "REVIEW_REQUIRED", "BLOCKED"})
 MAX_PLANNING_SESSION_BYTES = 65_536
 _SESSION_ID = re.compile(r"^[a-f0-9]{32}$")
 _TRANSITIONS = {
@@ -194,7 +193,9 @@ def _validate_state(
     if state.get("state") not in PLANNING_SESSION_STATES:
         raise LifecycleError("planning-session-state-invalid", "planning session state is invalid")
     if state.get("implementationAuthorized") is not False or state.get("rawTaskTextStored") is not False:
-        raise LifecycleError("planning-session-authority-invalid", "planning session cannot carry implementation authority")
+        raise LifecycleError(
+            "planning-session-authority-invalid", "planning session cannot carry implementation authority"
+        )
     if state.get("productionPromotionClaimed") is not False:
         raise LifecycleError("planning-session-production-claim", "planning session cannot claim production promotion")
     body = {key: value for key, value in state.items() if key != "stateDigest"}

{agent_lifecycle_kit-1.76.0 → agent_lifecycle_kit-1.77.0}/src/agent_lifecycle/adapter_sessions/process_groups.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import os
 import signal
 import subprocess
-import time
+from contextlib import suppress
 from pathlib import Path
 from typing import Any
 
@@ -39,16 +39,12 @@ class ProcessGroupOwner:
         escalation = "none"
         if self.process.poll() is None:
             if os.name == "posix":
-                try:
+                with suppress(ProcessLookupError):
                     os.killpg(self.pid, signal.SIGTERM)
-                except ProcessLookupError:
-                    pass
                 if not _wait_process(self.process, grace_seconds):
                     escalation = "SIGKILL"
-                    try:
+                    with suppress(ProcessLookupError):
                         os.killpg(self.pid, signal.SIGKILL)
-                    except ProcessLookupError:
-                        pass
                     _wait_process(self.process, grace_seconds)
             elif self._job_handle is not None:
                 _terminate_windows_job(self._job_handle)
@@ -132,7 +128,10 @@ def _create_windows_job(process: subprocess.Popen[Any]) -> int | None:
         import ctypes
         from ctypes import wintypes
 
-        kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+        win_dll = getattr(ctypes, "WinDLL", None)
+        if not callable(win_dll):
+            return None
+        kernel32 = win_dll("kernel32", use_last_error=True)
         kernel32.CreateJobObjectW.argtypes = [wintypes.LPVOID, wintypes.LPCWSTR]
         kernel32.CreateJobObjectW.restype = wintypes.HANDLE
         kernel32.SetInformationJobObject.argtypes = [wintypes.HANDLE, wintypes.INT, ctypes.c_void_p, wintypes.DWORD]
@@ -146,20 +145,45 @@ def _create_windows_job(process: subprocess.Popen[Any]) -> int | None:
             return None
 
         class IO_COUNTERS(ctypes.Structure):
-            _fields_ = [("ReadOperationCount", ctypes.c_uint64), ("WriteOperationCount", ctypes.c_uint64), ("OtherOperationCount", ctypes.c_uint64), ("ReadTransferCount", ctypes.c_uint64), ("WriteTransferCount", ctypes.c_uint64), ("OtherTransferCount", ctypes.c_uint64)]
+            _fields_ = [
+                ("ReadOperationCount", ctypes.c_uint64),
+                ("WriteOperationCount", ctypes.c_uint64),
+                ("OtherOperationCount", ctypes.c_uint64),
+                ("ReadTransferCount", ctypes.c_uint64),
+                ("WriteTransferCount", ctypes.c_uint64),
+                ("OtherTransferCount", ctypes.c_uint64),
+            ]
 
         class BASIC_LIMITS(ctypes.Structure):
-            _fields_ = [("PerProcessUserTimeLimit", ctypes.c_int64), ("PerJobUserTimeLimit", ctypes.c_int64), ("LimitFlags", wintypes.DWORD), ("MinimumWorkingSetSize", ctypes.c_size_t), ("MaximumWorkingSetSize", ctypes.c_size_t), ("ActiveProcessLimit", wintypes.DWORD), ("Affinity", ctypes.c_size_t), ("PriorityClass", wintypes.DWORD), ("SchedulingClass", wintypes.DWORD)]
+            _fields_ = [
+                ("PerProcessUserTimeLimit", ctypes.c_int64),
+                ("PerJobUserTimeLimit", ctypes.c_int64),
+                ("LimitFlags", wintypes.DWORD),
+                ("MinimumWorkingSetSize", ctypes.c_size_t),
+                ("MaximumWorkingSetSize", ctypes.c_size_t),
+                ("ActiveProcessLimit", wintypes.DWORD),
+                ("Affinity", ctypes.c_size_t),
+                ("PriorityClass", wintypes.DWORD),
+                ("SchedulingClass", wintypes.DWORD),
+            ]
 
         class EXTENDED_LIMITS(ctypes.Structure):
-            _fields_ = [("BasicLimitInformation", BASIC_LIMITS), ("IoInfo", IO_COUNTERS), ("ProcessMemoryLimit", ctypes.c_size_t), ("JobMemoryLimit", ctypes.c_size_t), ("PeakProcessMemoryUsed", ctypes.c_size_t), ("PeakJobMemoryUsed", ctypes.c_size_t)]
+            _fields_ = [
+                ("BasicLimitInformation", BASIC_LIMITS),
+                ("IoInfo", IO_COUNTERS),
+                ("ProcessMemoryLimit", ctypes.c_size_t),
+                ("JobMemoryLimit", ctypes.c_size_t),
+                ("PeakProcessMemoryUsed", ctypes.c_size_t),
+                ("PeakJobMemoryUsed", ctypes.c_size_t),
+            ]
 
         limits = EXTENDED_LIMITS()
         limits.BasicLimitInformation.LimitFlags = 0x2000  # JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
         if not kernel32.SetInformationJobObject(handle, 9, ctypes.byref(limits), ctypes.sizeof(limits)):
             kernel32.CloseHandle(handle)
             return None
-        process_handle_value = getattr(process._handle, "value", process._handle)
+        process_handle = getattr(process, "_handle", None)
+        process_handle_value = getattr(process_handle, "value", process_handle)
         if not process_handle_value:
             kernel32.CloseHandle(handle)
             return None
@@ -177,7 +201,10 @@ def _terminate_windows_job(handle: int) -> None:
         import ctypes
         from ctypes import wintypes
 
-        kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+        win_dll = getattr(ctypes, "WinDLL", None)
+        if not callable(win_dll):
+            return
+        kernel32 = win_dll("kernel32", use_last_error=True)
         kernel32.TerminateJobObject.argtypes = [wintypes.HANDLE, wintypes.UINT]
         kernel32.TerminateJobObject.restype = wintypes.BOOL
         kernel32.TerminateJobObject(handle, 1)
@@ -193,11 +220,29 @@ def _windows_job_active_processes(handle: int) -> int | None:
         from ctypes import wintypes
 
         class ACCOUNTING(ctypes.Structure):
-            _fields_ = [("TotalUserTime", ctypes.c_int64), ("TotalKernelTime", ctypes.c_int64), ("ThisPeriodTotalUserTime", ctypes.c_int64), ("ThisPeriodTotalKernelTime", ctypes.c_int64), ("TotalPageFaultCount", wintypes.DWORD), ("TotalProcesses", wintypes.DWORD), ("ActiveProcesses", wintypes.DWORD), ("TotalTerminatedProcesses", wintypes.DWORD)]
+            _fields_ = [
+                ("TotalUserTime", ctypes.c_int64),
+                ("TotalKernelTime", ctypes.c_int64),
+                ("ThisPeriodTotalUserTime", ctypes.c_int64),
+                ("ThisPeriodTotalKernelTime", ctypes.c_int64),
+                ("TotalPageFaultCount", wintypes.DWORD),
+                ("TotalProcesses", wintypes.DWORD),
+                ("ActiveProcesses", wintypes.DWORD),
+                ("TotalTerminatedProcesses", wintypes.DWORD),
+            ]
 
         info = ACCOUNTING()
-        kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
-        kernel32.QueryInformationJobObject.argtypes = [wintypes.HANDLE, wintypes.INT, ctypes.c_void_p, wintypes.DWORD, ctypes.POINTER(wintypes.DWORD)]
+        win_dll = getattr(ctypes, "WinDLL", None)
+        if not callable(win_dll):
+            return None
+        kernel32 = win_dll("kernel32", use_last_error=True)
+        kernel32.QueryInformationJobObject.argtypes = [
+            wintypes.HANDLE,
+            wintypes.INT,
+            ctypes.c_void_p,
+            wintypes.DWORD,
+            ctypes.POINTER(wintypes.DWORD),
+        ]
         kernel32.QueryInformationJobObject.restype = wintypes.BOOL
         if not kernel32.QueryInformationJobObject(handle, 1, ctypes.byref(info), ctypes.sizeof(info), None):
             return None
@@ -211,7 +256,10 @@ def _close_windows_handle(handle: int) -> None:
         import ctypes
         from ctypes import wintypes
 
-        kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+        win_dll = getattr(ctypes, "WinDLL", None)
+        if not callable(win_dll):
+            return
+        kernel32 = win_dll("kernel32", use_last_error=True)
         kernel32.CloseHandle.argtypes = [wintypes.HANDLE]
         kernel32.CloseHandle.restype = wintypes.BOOL
         kernel32.CloseHandle(handle)