ai-push-hooks 0.3.0 → 0.3.2

package/src/ai_push_hooks/paths.py

@@ -98,7 +98,9 @@ def resolve_contained_path(base: pathlib.Path, raw: str, label: str) -> pathlib.
     resolved_base = lexical_base.resolve(strict=False)
     resolved_candidate = lexical_candidate.resolve(strict=False)
     if not is_path_within(resolved_candidate, resolved_base):
-        raise HookError(f"{label} escapes its intended directory through a symlink: {raw}")
+        raise HookError(
+            f"{label} escapes its intended directory through a symlink: {raw}"
+        )
     return resolved_candidate
 
 
@@ -178,5 +180,7 @@ def atomic_write_bytes(
             pass
 
 
-def write_text_no_follow(path: pathlib.Path, content: str, *, encoding: str = "utf-8") -> None:
+def write_text_no_follow(
+    path: pathlib.Path, content: str, *, encoding: str = "utf-8"
+) -> None:
     atomic_write_bytes(path, content.encode(encoding))

package/src/ai_push_hooks/plugin_loader.py

@@ -10,7 +10,6 @@ completed.
 
 from __future__ import annotations  # noqa: I001
 
-import copy
 import errno
 import hashlib
 import inspect
@@ -34,6 +33,8 @@ from .types import HookError, ModuleRuntimeState, RuntimeContext, StepConfig
 
 _CALLABLE_PATTERN = re.compile(r"[A-Za-z_][A-Za-z0-9_]*\Z")
 _SOURCE_ENCODING = "utf-8"
+PLUGIN_SOURCE_MAX_BYTES = 1 * 1024 * 1024
+_SOURCE_READ_CHUNK_BYTES = 64 * 1024
 _OS_OPEN = os.open
 _DESCRIPTOR_RELATIVE_SUPPORTED = bool(
     getattr(os, "O_DIRECTORY", 0)
@@ -46,6 +47,31 @@ def _descriptor_relative_supported() -> bool:
     return _DESCRIPTOR_RELATIVE_SUPPORTED
 
 
+def _read_source_limited(descriptor: int) -> bytes:
+    """Read plugin source from a checked descriptor within the source budget."""
+
+    oversize_message = (
+        f"Python plugin source exceeds maximum size of {PLUGIN_SOURCE_MAX_BYTES} bytes"
+    )
+    if os.fstat(descriptor).st_size > PLUGIN_SOURCE_MAX_BYTES:
+        raise HookError(oversize_message)
+    content = bytearray()
+    while True:
+        read_limit = min(
+            _SOURCE_READ_CHUNK_BYTES,
+            PLUGIN_SOURCE_MAX_BYTES - len(content) + 1,
+        )
+        try:
+            chunk = os.read(descriptor, max(1, read_limit))
+        except OSError:
+            raise HookError("Python plugin source could not be read") from None
+        if not chunk:
+            return bytes(content)
+        content.extend(chunk)
+        if len(content) > PLUGIN_SOURCE_MAX_BYTES:
+            raise HookError(oversize_message)
+
+
 def _reference_parts(reference: str) -> tuple[str, str]:
     if not isinstance(reference, str) or reference.count(":") != 1:
         raise HookError(
@@ -83,7 +109,12 @@ def _open_source_descriptor_relative(
         | getattr(os, "O_DIRECTORY", 0)
         | getattr(os, "O_NOFOLLOW", 0)
     )
-    file_flags = os.O_RDONLY | getattr(os, "O_CLOEXEC", 0) | getattr(os, "O_NOFOLLOW", 0)
+    file_flags = (
+        os.O_RDONLY
+        | getattr(os, "O_CLOEXEC", 0)
+        | getattr(os, "O_NOFOLLOW", 0)
+        | getattr(os, "O_NONBLOCK", 0)
+    )
     try:
         directory_fd = _OS_OPEN(root, directory_flags)
         for part in parts[:-1]:
@@ -93,17 +124,21 @@ def _open_source_descriptor_relative(
         file_fd = _OS_OPEN(parts[-1], file_flags, dir_fd=directory_fd)
         metadata = os.fstat(file_fd)
         if not stat.S_ISREG(metadata.st_mode):
-            raise HookError("Python plugin path must reference an ordinary regular file")
-        with os.fdopen(file_fd, "rb") as source:
-            file_fd = -1
-            return root.joinpath(*parts), source.read()
+            raise HookError(
+                "Python plugin path must reference an ordinary regular file"
+            )
+        return root.joinpath(*parts), _read_source_limited(file_fd)
     except HookError:
         raise
     except OSError as exc:
         if exc.errno in {errno.ELOOP, errno.ENOTDIR}:
-            raise HookError("Python plugin path must not traverse a symlink or reparse point") from None
+            raise HookError(
+                "Python plugin path must not traverse a symlink or reparse point"
+            ) from None
         if exc.errno == errno.ENOENT:
-            raise HookError("Python plugin path must reference an existing regular file") from None
+            raise HookError(
+                "Python plugin path must reference an existing regular file"
+            ) from None
         raise HookError("Python plugin path could not be opened safely") from None
     finally:
         if file_fd >= 0:
@@ -112,18 +147,24 @@ def _open_source_descriptor_relative(
             os.close(directory_fd)
 
 
-def _open_source_absolute(root: pathlib.Path, relative_path: str) -> tuple[pathlib.Path, bytes]:
+def _open_source_absolute(
+    root: pathlib.Path, relative_path: str
+) -> tuple[pathlib.Path, bytes]:
     """Fallback for platforms without descriptor-relative open support."""
 
     lexical_path = root.joinpath(*relative_path.split("/"))
     if path_has_symlink(root, lexical_path):
-        raise HookError("Python plugin path must not traverse a symlink or reparse point")
+        raise HookError(
+            "Python plugin path must not traverse a symlink or reparse point"
+        )
     callback_path = resolve_contained_path(root, relative_path, "Python plugin path")
 
     try:
         metadata = callback_path.lstat()
     except (FileNotFoundError, OSError):
-        raise HookError("Python plugin path must reference an existing regular file") from None
+        raise HookError(
+            "Python plugin path must reference an existing regular file"
+        ) from None
     reparse_flag = getattr(stat, "FILE_ATTRIBUTE_REPARSE_POINT", 0x400)
     if stat.S_ISLNK(metadata.st_mode) or bool(
         getattr(metadata, "st_file_attributes", 0) & reparse_flag
@@ -132,7 +173,12 @@ def _open_source_absolute(root: pathlib.Path, relative_path: str) -> tuple[pathl
     if not stat.S_ISREG(metadata.st_mode):
         raise HookError("Python plugin path must reference an ordinary regular file")
 
-    flags = os.O_RDONLY | getattr(os, "O_CLOEXEC", 0) | getattr(os, "O_NOFOLLOW", 0)
+    flags = (
+        os.O_RDONLY
+        | getattr(os, "O_CLOEXEC", 0)
+        | getattr(os, "O_NOFOLLOW", 0)
+        | getattr(os, "O_NONBLOCK", 0)
+    )
     try:
         descriptor = os.open(callback_path, flags)
     except OSError:
@@ -140,10 +186,10 @@ def _open_source_absolute(root: pathlib.Path, relative_path: str) -> tuple[pathl
     try:
         descriptor_metadata = os.fstat(descriptor)
         if not stat.S_ISREG(descriptor_metadata.st_mode):
-            raise HookError("Python plugin path must reference an ordinary regular file")
-        with os.fdopen(descriptor, "rb") as source:
-            descriptor = -1
-            return callback_path, source.read()
+            raise HookError(
+                "Python plugin path must reference an ordinary regular file"
+            )
+        return callback_path, _read_source_limited(descriptor)
     except HookError:
         raise
     except OSError:
@@ -162,10 +208,10 @@ def _open_source(root: pathlib.Path, relative_path: str) -> tuple[pathlib.Path,
     return _open_source_absolute(root, relative_path)
 
 
-def _failure(stage: str, relative_path: str, callable_name: str, detail: str) -> HookError:
-    return HookError(
-        f"Python {stage} plugin {relative_path}:{callable_name} {detail}"
-    )
+def _failure(
+    stage: str, relative_path: str, callable_name: str, detail: str
+) -> HookError:
+    return HookError(f"Python {stage} plugin {relative_path}:{callable_name} {detail}")
 
 
 class PluginLoader:
@@ -174,96 +220,119 @@ class PluginLoader:
     def __init__(self) -> None:
         self._cache: dict[tuple[pathlib.Path, pathlib.Path], ModuleType] = {}
         self._lock = threading.RLock()
+        self._source_locks: dict[tuple[pathlib.Path, pathlib.Path], threading.Lock] = {}
         self._module_number = 0
 
+    def _source_lock(self, key: tuple[pathlib.Path, pathlib.Path]) -> threading.Lock:
+        with self._lock:
+            lock = self._source_locks.get(key)
+            if lock is None:
+                lock = threading.Lock()
+                self._source_locks[key] = lock
+            return lock
+
+    def _load_module(
+        self,
+        root: pathlib.Path,
+        relative_path: str,
+        callable_name: str,
+    ) -> ModuleType:
+        try:
+            callback_path, source = _open_source(root, relative_path)
+        except HookError as exc:
+            raise HookError(
+                f"Python plugin {relative_path}:{callable_name} could not be loaded safely: "
+                f"{str(exc).removeprefix('Python plugin ')}"
+            ) from None
+        # ``callback_path`` is canonical after containment checks and is equal
+        # to the lexical cache key for a safe repository file.
+        try:
+            source_text = source.decode(_SOURCE_ENCODING)
+            code = compile(source_text, str(callback_path), "exec")
+        except UnicodeDecodeError:
+            raise HookError(
+                f"Python plugin {relative_path}:{callable_name} source is not valid UTF-8"
+            ) from None
+        except (SyntaxError, ValueError, TypeError):
+            raise HookError(
+                f"Python plugin {relative_path}:{callable_name} could not be compiled"
+            ) from None
+
+        with self._lock:
+            self._module_number += 1
+            module_number = self._module_number
+        digest = hashlib.sha256(f"{root}\0{callback_path}".encode()).hexdigest()[:16]
+        module_name = f"ai_push_hooks_plugin_{digest}_{module_number}"
+        module = ModuleType(module_name)
+        module.__file__ = str(callback_path)
+        module.__package__ = ""
+        try:
+            exec(code, module.__dict__)  # noqa: S102
+        except KeyboardInterrupt:
+            raise
+        except SystemExit:
+            raise HookError(
+                f"Python plugin {relative_path}:{callable_name} exited during import"
+            ) from None
+        except ModuleNotFoundError as exc:
+            if exc.name:
+                detail = f"is missing dependency {exc.name!r}"
+            else:
+                detail = "could not import a dependency"
+            raise HookError(
+                f"Python plugin {relative_path}:{callable_name} {detail}"
+            ) from None
+        except ImportError:
+            raise HookError(
+                f"Python plugin {relative_path}:{callable_name} could not import a dependency"
+            ) from None
+        except Exception:  # noqa: BLE001
+            raise HookError(
+                f"Python plugin {relative_path}:{callable_name} failed during import"
+            ) from None
+        return module
+
     def load(self, repo_root: pathlib.Path, reference: str) -> Callable[..., Any]:
         """Return the named top-level callable from a safe source snapshot.
 
-        The lock includes descriptor open, source read, compilation, and module
-        execution.  Thus concurrent collectors cannot execute the same source
-        twice.  The cache key includes both canonical repository root and
-        canonical file path, so identical relative names in two repositories
-        remain independent.
+        A per-source lock includes descriptor open, source read, compilation,
+        and module execution.  Thus concurrent collectors cannot execute the
+        same source twice, while different sources can import concurrently.
+        The cache key includes both canonical repository root and canonical
+        file path, so identical relative names in two repositories remain
+        independent.
         """
 
         relative_path, callable_name = _reference_parts(reference)
         root = _canonical_root(repo_root)
+        lexical_callback_path = root.joinpath(*relative_path.split("/"))
+        key = (root, lexical_callback_path)
         with self._lock:
-            lexical_callback_path = root.joinpath(*relative_path.split("/"))
-            key = (root, lexical_callback_path)
             module = self._cache.get(key)
-            if module is None:
-                try:
-                    callback_path, source = _open_source(root, relative_path)
-                except HookError as exc:
-                    raise HookError(
-                        f"Python plugin {relative_path}:{callable_name} could not be loaded safely: "
-                        f"{str(exc).removeprefix('Python plugin ')}"
-                    ) from None
-                # ``callback_path`` is canonical after containment checks and
-                # is equal to the lexical path for a safe repository file.
-                key = (root, callback_path)
-                try:
-                    source_text = source.decode(_SOURCE_ENCODING)
-                    code = compile(source_text, str(callback_path), "exec")
-                except UnicodeDecodeError:
-                    raise HookError(
-                        f"Python plugin {relative_path}:{callable_name} source is not valid UTF-8"
-                    ) from None
-                except (SyntaxError, ValueError, TypeError):
-                    raise HookError(
-                        f"Python plugin {relative_path}:{callable_name} could not be compiled"
-                    ) from None
-
-                self._module_number += 1
-                digest = hashlib.sha256(
-                    f"{root}\0{callback_path}".encode()
-                ).hexdigest()[:16]
-                module_name = f"ai_push_hooks_plugin_{digest}_{self._module_number}"
-                module = ModuleType(module_name)
-                module.__file__ = str(callback_path)
-                module.__package__ = ""
-                try:
-                    exec(code, module.__dict__)  # noqa: S102
-                except KeyboardInterrupt:
-                    raise
-                except SystemExit:
-                    raise HookError(
-                        f"Python plugin {relative_path}:{callable_name} exited during import"
-                    ) from None
-                except ModuleNotFoundError as exc:
-                    if exc.name:
-                        detail = f"is missing dependency {exc.name!r}"
-                    else:
-                        detail = "could not import a dependency"
-                    raise HookError(
-                        f"Python plugin {relative_path}:{callable_name} {detail}"
-                    ) from None
-                except ImportError:
-                    raise HookError(
-                        f"Python plugin {relative_path}:{callable_name} could not import a dependency"
-                    ) from None
-                except Exception:  # noqa: BLE001
-                    raise HookError(
-                        f"Python plugin {relative_path}:{callable_name} failed during import"
-                    ) from None
-                self._cache[key] = module
-
-            try:
-                callback = getattr(module, callable_name)
-            except AttributeError:
-                raise _failure(
-                    "callback", relative_path, callable_name, "was not defined"
-                ) from None
-            if not callable(callback):
-                raise _failure(
-                    "callback", relative_path, callable_name, "is not callable"
-                ) from None
-            if inspect.iscoroutinefunction(callback):
-                raise _failure(
-                    "callback", relative_path, callable_name, "must be synchronous"
-                ) from None
-            return callback
+        if module is None:
+            with self._source_lock(key):
+                with self._lock:
+                    module = self._cache.get(key)
+                if module is None:
+                    module = self._load_module(root, relative_path, callable_name)
+                    with self._lock:
+                        self._cache[key] = module
+
+        try:
+            callback = getattr(module, callable_name)
+        except AttributeError:
+            raise _failure(
+                "callback", relative_path, callable_name, "was not defined"
+            ) from None
+        if not callable(callback):
+            raise _failure(
+                "callback", relative_path, callable_name, "is not callable"
+            ) from None
+        if inspect.iscoroutinefunction(callback):
+            raise _failure(
+                "callback", relative_path, callable_name, "must be synchronous"
+            ) from None
+        return callback
 
     def invoke(
         self,
@@ -297,13 +366,17 @@ class PluginLoader:
         except SystemExit:
             raise _failure(stage, relative_path, callable_name, "exited") from None
         except Exception:  # noqa: BLE001
-            raise _failure(stage, relative_path, callable_name, "raised an exception") from None
+            raise _failure(
+                stage, relative_path, callable_name, "raised an exception"
+            ) from None
 
         if inspect.isawaitable(value):
             close = getattr(value, "close", None)
             if callable(close):
                 close()
-            raise _failure(stage, relative_path, callable_name, "must return synchronously")
+            raise _failure(
+                stage, relative_path, callable_name, "must return synchronously"
+            )
         return value
 
     # Explicit aliases make the intended internal seam easy to integrate while
@@ -320,7 +393,9 @@ def _ordered_inputs(
         extra = [reference for reference in input_paths if reference not in declared]
         if extra:
             raise HookError(f"Undeclared Python plugin input: {extra[0]}")
-        missing = [reference for reference in step.inputs if reference not in input_paths]
+        missing = [
+            reference for reference in step.inputs if reference not in input_paths
+        ]
         if missing:
             raise HookError(f"Missing resolved Python plugin input: {missing[0]}")
         return {reference: input_paths[reference] for reference in step.inputs}
@@ -358,8 +433,8 @@ def build_plugin_context(
         module_id=state.module.id,
         step_id=step.id,
         inputs=_ordered_inputs(step, input_paths),
-        options=copy.deepcopy(step.options),
-        prior_module_metadata=copy.deepcopy(state.metadata),
+        options=step.options,
+        prior_module_metadata=state.metadata,
         push=push,
         logger=runtime.logger,
     )
@@ -379,7 +454,9 @@ class PluginDispatcher:
         input_paths: Mapping[str, pathlib.Path] | Sequence[pathlib.Path],
     ) -> Any:
         if not step.python:
-            raise HookError(f"Python {step.type} step `{step.id}` has no callback reference")
+            raise HookError(
+                f"Python {step.type} step `{step.id}` has no callback reference"
+            )
         context = build_plugin_context(runtime, state, step, input_paths)
         return self.loader.invoke(
             runtime.repo_root,

package/src/ai_push_hooks/plugins.py

@@ -67,7 +67,9 @@ class PluginContext:
     def __post_init__(self) -> None:
         object.__setattr__(self, "inputs", MappingProxyType(dict(self.inputs)))
         object.__setattr__(self, "options", _freeze(self.options))
-        object.__setattr__(self, "prior_module_metadata", _freeze(self.prior_module_metadata))
+        object.__setattr__(
+            self, "prior_module_metadata", _freeze(self.prior_module_metadata)
+        )
 
 
 def _require_json(value: Any, label: str) -> None:

package/src/ai_push_hooks/prompts_builtin.py

@@ -77,7 +77,7 @@ base_branch = "main"
 # Repository callbacks use python = "path/to/file.py:callable" and command
 # steps use a direct argv array; both are trusted local code.
 runner = "opencode"
-model = "openai/gpt-5.6-terra"
+model = "openai/gpt-5.6-luna"
 variant = ""
 timeout_seconds = 800
 max_parallel = 2

package/src/ai_push_hooks/types.py

@@ -14,6 +14,7 @@ from typing import Any, ClassVar
 READ_ONLY_STEP_TYPES = frozenset({"collect", "ask"})
 PROMPTABLE_STEP_TYPES = frozenset({"ask", "apply"})
 SUPPORTED_STEP_TYPES = frozenset({"collect", "ask", "apply", "exec", "assert"})
+DEFAULT_STEP_COMMAND_TIMEOUT_SECONDS = 60
 FEATURE_BRANCH_PREFIXES = ("feat/", "feature/")
 ZERO_OID_LENGTHS = frozenset({40, 64})
 
@@ -80,7 +81,7 @@ class GeneralConfig:
 @dataclass(frozen=True)
 class LlmConfig:
     runner: str = "opencode"
-    model: str = "openai/gpt-5.6-terra"
+    model: str = "openai/gpt-5.6-luna"
     variant: str = ""
     timeout_seconds: int = 800
     max_parallel: int = 2
@@ -177,10 +178,7 @@ class CollectorResult:
 
 @dataclass
 class StepResult:
-    status: str = "completed"
-    artifacts: dict[str, pathlib.Path] = field(default_factory=dict)
     metadata: dict[str, Any] = field(default_factory=dict)
-    message: str = ""
 
 
 @dataclass
@@ -327,7 +325,9 @@ class HookLogger:
             call_number = cls._safe_text(fields.get("call_number", ""))
             stage = cls._stage_for_console(fields.get("stage_name", ""), colors_enabled)
             purpose = cls._style(
-                cls._safe_text(fields.get("purpose", "")).replace("\n", "\\n").replace("\t", " "),
+                cls._safe_text(fields.get("purpose", ""))
+                .replace("\n", "\\n")
+                .replace("\t", " "),
                 "34",
                 colors_enabled,
             )
@@ -350,12 +350,16 @@ class HookLogger:
             call_number = cls._safe_text(fields.get("call_number", ""))
             stage = cls._stage_for_console(fields.get("stage_name", ""), colors_enabled)
             profile = cls._style(
-                cls._safe_text(fields.get("runner_profile", "")).replace("\n", "\\n").replace("\t", " "),
+                cls._safe_text(fields.get("runner_profile", ""))
+                .replace("\n", "\\n")
+                .replace("\t", " "),
                 "34",
                 colors_enabled,
             )
             runner_type = cls._style(
-                cls._safe_text(fields.get("runner_type", "")).replace("\n", "\\n").replace("\t", " "),
+                cls._safe_text(fields.get("runner_type", ""))
+                .replace("\n", "\\n")
+                .replace("\t", " "),
                 "34",
                 colors_enabled,
             )
@@ -376,7 +380,9 @@ class HookLogger:
                 + cls._style(")", "2", colors_enabled)
             )
             if "; " in safe_message:
-                body += cls._style("; " + safe_message.split("; ", 1)[1], "2", colors_enabled)
+                body += cls._style(
+                    "; " + safe_message.split("; ", 1)[1], "2", colors_enabled
+                )
             return body
 
         return safe_message
@@ -447,13 +453,16 @@ class HookLogger:
                 if initial_metadata is not None:
                     reparse_flag = getattr(stat, "FILE_ATTRIBUTE_REPARSE_POINT", 0x400)
                     if stat.S_ISLNK(initial_metadata.st_mode) or bool(
-                        getattr(initial_metadata, "st_file_attributes", 0) & reparse_flag
+                        getattr(initial_metadata, "st_file_attributes", 0)
+                        & reparse_flag
                     ):
                         raise HookError(
                             "JSONL log target must not be a symlink or reparse point: "
                             f"{self.jsonl_path}"
                         )
-                flags = os.O_WRONLY | os.O_APPEND | os.O_CREAT | getattr(os, "O_CLOEXEC", 0)
+                flags = (
+                    os.O_WRONLY | os.O_APPEND | os.O_CREAT | getattr(os, "O_CLOEXEC", 0)
+                )
                 flags |= getattr(os, "O_NOFOLLOW", 0)
                 descriptor = os.open(self.jsonl_path, flags, 0o600)
                 try:
@@ -464,12 +473,15 @@ class HookLogger:
                         not stat.S_ISREG(descriptor_metadata.st_mode)
                         or stat.S_ISLNK(path_metadata.st_mode)
                         or bool(
-                            getattr(path_metadata, "st_file_attributes", 0) & reparse_flag
+                            getattr(path_metadata, "st_file_attributes", 0)
+                            & reparse_flag
                         )
                         or (descriptor_metadata.st_dev, descriptor_metadata.st_ino)
                         != (path_metadata.st_dev, path_metadata.st_ino)
                     ):
-                        raise HookError(f"JSONL log target is not a regular file: {self.jsonl_path}")
+                        raise HookError(
+                            f"JSONL log target is not a regular file: {self.jsonl_path}"
+                        )
                     os.fchmod(descriptor, 0o600)
                     os.write(
                         descriptor,
@@ -521,7 +533,9 @@ class HookLogger:
                 "purpose": safe_purpose,
                 "model": self._safe_text(model),
                 "module": safe_stage.split(".", 1)[0],
-                "step": safe_stage.split(".", 1)[1] if "." in safe_stage else safe_stage,
+                "step": safe_stage.split(".", 1)[1]
+                if "." in safe_stage
+                else safe_stage,
             }
             if attempt is not None:
                 record["attempt"] = attempt
@@ -558,16 +572,20 @@ class HookLogger:
         safe_stage = self._safe_text(stage_name)
         safe_profile = self._safe_text(runner_profile)
         safe_type = self._safe_text(runner_type)
-        safe_state = self._safe_text(session_state) if session_state is not None else None
-        safe_session_id = self._safe_text(session_id) if session_id is not None else None
-        safe_transcript = self._safe_text(transcript) if transcript is not None else None
+        safe_state = (
+            self._safe_text(session_state) if session_state is not None else None
+        )
+        safe_session_id = (
+            self._safe_text(session_id) if session_id is not None else None
+        )
+        safe_transcript = (
+            self._safe_text(transcript) if transcript is not None else None
+        )
         safe_resume_command = (
             self._safe_text(resume_command) if resume_command is not None else None
         )
         effective_resume_command = (
-            safe_resume_command
-            if safe_state == "persisted" and resumable
-            else None
+            safe_resume_command if safe_state == "persisted" and resumable else None
         )
         session_details: list[str] = []
         if safe_state == "persisted":
@@ -621,15 +639,18 @@ class HookLogger:
             fields["transcript"] = safe_transcript
         if effective_resume_command is not None:
             fields["resume_command"] = effective_resume_command
-        if any(
-            value is not None
-            for value in (
-                safe_session_id,
-                safe_state,
-                safe_transcript,
-                effective_resume_command,
+        if (
+            any(
+                value is not None
+                for value in (
+                    safe_session_id,
+                    safe_state,
+                    safe_transcript,
+                    effective_resume_command,
+                )
             )
-        ) or resumable:
+            or resumable
+        ):
             fields["resumable"] = resumable
         self.status("llm.complete", message, **fields)
 

package/vendor/README.md

@@ -0,0 +1,15 @@
+# Bundled Python Dependency
+
+The npm package includes the unmodified pure-Python wheel for [Tomli](https://pypi.org/project/tomli/2.4.0/). Python 3.10 uses it to parse TOML; Python 3.11+ uses the standard-library `tomllib` module.
+
+The wrapper adds the wheel to `PYTHONPATH`, so no pip install, install script, or runtime download is needed. The wheel includes Tomli's MIT license under `tomli-2.4.0.dist-info/licenses/LICENSE`.
+
+To reproduce the bundled download from the repository root:
+
+```bash
+python -m pip download --index-url https://pypi.org/simple --require-hashes \
+  --only-binary=:all: --no-deps --platform any --implementation py --abi none \
+  --python-version 3.10 --dest vendor --requirement vendor/requirements.txt
+```
+
+When updating, verify the pure-Python wheel's SHA-256 against PyPI, update the pin and wrapper path, and run the npm installed-hook tests on Python 3.10.

package/vendor/requirements.txt

@@ -0,0 +1 @@
+tomli==2.4.0 --hash=sha256:1f776e7d669ebceb01dee46484485f43a4048746235e683bcdffacdf1fb4785a