ai-push-hooks 0.3.1 → 0.3.2

package/src/ai_push_hooks/modules/beads.py

@@ -6,7 +6,9 @@ from ..git_utils import collect_commit_messages_for_ranges, is_feature_branch
 from ..types import CollectorResult, RuntimeContext
 
 
-def collect_beads_status_context(context: RuntimeContext, state: Any) -> CollectorResult:
+def collect_beads_status_context(
+    context: RuntimeContext, state: Any
+) -> CollectorResult:
     branch_name = str(context.cache.get("branch_name", ""))
     branch_selection_reason = str(
         context.cache.get("branch_selection_reason", "no pushed branch updates")
@@ -22,7 +24,9 @@ def collect_beads_status_context(context: RuntimeContext, state: Any) -> Collect
             skip_reason=branch_selection_reason,
         )
     sync_branch = context.cache.get("sync_branch", "beads-sync")
-    if branch_name in {"HEAD", "main", sync_branch} or not is_feature_branch(branch_name):
+    if branch_name in {"HEAD", "main", sync_branch} or not is_feature_branch(
+        branch_name
+    ):
         return CollectorResult(
             artifacts={"branch-context.txt": f"branch={branch_name}\n"},
             skip_module=True,
@@ -33,8 +37,12 @@ def collect_beads_status_context(context: RuntimeContext, state: Any) -> Collect
     changed_files = context.cache.get(
         "branch_changed_files", context.cache.get("changed_files", [])
     )
-    diff_text = context.cache.get("branch_diff_text", context.cache.get("diff_text", ""))
-    commits = collect_commit_messages_for_ranges(context.repo_root, ranges) if ranges else []
+    diff_text = context.cache.get(
+        "branch_diff_text", context.cache.get("diff_text", "")
+    )
+    commits = (
+        collect_commit_messages_for_ranges(context.repo_root, ranges) if ranges else []
+    )
     report_file = "BEADS_STATUS_ACTION_REQUIRED.md"
     commit_lines = []
     for commit in commits:
@@ -54,8 +62,11 @@ def collect_beads_status_context(context: RuntimeContext, state: Any) -> Collect
                 ]
             )
             + "\n",
-            "changed-files.txt": "\n".join(changed_files) + ("\n" if changed_files else ""),
-            "push.diff": diff_text + ("\n" if diff_text and not diff_text.endswith("\n") else ""),
-            "commits.txt": "\n".join(commit_lines).strip() + ("\n" if commit_lines else ""),
+            "changed-files.txt": "\n".join(changed_files)
+            + ("\n" if changed_files else ""),
+            "push.diff": diff_text
+            + ("\n" if diff_text and not diff_text.endswith("\n") else ""),
+            "commits.txt": "\n".join(commit_lines).strip()
+            + ("\n" if commit_lines else ""),
         }
     )

package/src/ai_push_hooks/modules/docs.py

@@ -252,7 +252,9 @@ def _collect_query_matches(
     return buffers, fallback_contents
 
 
-def _search_docs_context(repo_root: pathlib.Path, doc_files: list[pathlib.Path], queries: list[str]) -> str:
+def _search_docs_context(
+    repo_root: pathlib.Path, doc_files: list[pathlib.Path], queries: list[str]
+) -> str:
     repo_root = repo_root.resolve(strict=True)
     if not doc_files:
         return ""
@@ -297,7 +299,9 @@ def collect_docs_context(context: RuntimeContext, _state: Any) -> CollectorResul
         ["log", "--oneline", "-n", "20", "--", "README.md", "docs"],
         check=False,
     )
-    commits = collect_commit_messages_for_ranges(context.repo_root, ranges) if ranges else []
+    commits = (
+        collect_commit_messages_for_ranges(context.repo_root, ranges) if ranges else []
+    )
     commit_lines = []
     for commit in commits:
         commit_lines.append(f"--- {commit['hash']}")
@@ -308,12 +312,18 @@ def collect_docs_context(context: RuntimeContext, _state: Any) -> CollectorResul
         commit_lines.append("")
     return CollectorResult(
         artifacts={
-            "changed-files.txt": "\n".join(changed_files) + ("\n" if changed_files else ""),
-            "push.diff": diff_text + ("\n" if diff_text and not diff_text.endswith("\n") else ""),
-            "docs-inventory.txt": "\n".join(path.relative_to(context.repo_root).as_posix() for path in doc_files)
+            "changed-files.txt": "\n".join(changed_files)
+            + ("\n" if changed_files else ""),
+            "push.diff": diff_text
+            + ("\n" if diff_text and not diff_text.endswith("\n") else ""),
+            "docs-inventory.txt": "\n".join(
+                path.relative_to(context.repo_root).as_posix() for path in doc_files
+            )
             + ("\n" if doc_files else ""),
             "docs-context.txt": docs_context + ("\n" if docs_context else ""),
-            "recent-commits.txt": recent_commits + ("\n" if recent_commits and not recent_commits.endswith("\n") else ""),
-            "commits.txt": "\n".join(commit_lines).strip() + ("\n" if commit_lines else ""),
+            "recent-commits.txt": recent_commits
+            + ("\n" if recent_commits and not recent_commits.endswith("\n") else ""),
+            "commits.txt": "\n".join(commit_lines).strip()
+            + ("\n" if commit_lines else ""),
         }
     )

package/src/ai_push_hooks/modules/pr.py

@@ -37,7 +37,9 @@ def collect_pr_context(context: RuntimeContext, state: Any) -> CollectorResult:
             break
     if flag_env and env_bool(flag_env) is not True:
         return CollectorResult(
-            artifacts={"pr-context.txt": f"branch={branch_name}\nflag_env={flag_env}\n"},
+            artifacts={
+                "pr-context.txt": f"branch={branch_name}\nflag_env={flag_env}\n"
+            },
             skip_module=True,
             skip_reason="PR create env flag is not enabled",
         )
@@ -81,7 +83,9 @@ def collect_pr_context(context: RuntimeContext, state: Any) -> CollectorResult:
         existing_pr_url = ""
     if existing_pr_url:
         return CollectorResult(
-            artifacts={"pr-context.txt": f"branch={branch_name}\nexisting_pr_url={existing_pr_url}\n"},
+            artifacts={
+                "pr-context.txt": f"branch={branch_name}\nexisting_pr_url={existing_pr_url}\n"
+            },
             skip_module=True,
             skip_reason="open PR already exists",
             metadata={"existing_pr_url": existing_pr_url},
@@ -91,8 +95,12 @@ def collect_pr_context(context: RuntimeContext, state: Any) -> CollectorResult:
     changed_files = context.cache.get(
         "branch_changed_files", context.cache.get("changed_files", [])
     )
-    diff_text = context.cache.get("branch_diff_text", context.cache.get("diff_text", ""))
-    commits = collect_commit_messages_for_ranges(context.repo_root, ranges) if ranges else []
+    diff_text = context.cache.get(
+        "branch_diff_text", context.cache.get("diff_text", "")
+    )
+    commits = (
+        collect_commit_messages_for_ranges(context.repo_root, ranges) if ranges else []
+    )
     commit_lines = []
     for commit in commits:
         commit_lines.append(f"--- {commit['hash']}")
@@ -113,8 +121,11 @@ def collect_pr_context(context: RuntimeContext, state: Any) -> CollectorResult:
                 ]
             )
             + "\n",
-            "changed-files.txt": "\n".join(changed_files) + ("\n" if changed_files else ""),
-            "push.diff": diff_text + ("\n" if diff_text and not diff_text.endswith("\n") else ""),
-            "commits.txt": "\n".join(commit_lines).strip() + ("\n" if commit_lines else ""),
+            "changed-files.txt": "\n".join(changed_files)
+            + ("\n" if changed_files else ""),
+            "push.diff": diff_text
+            + ("\n" if diff_text and not diff_text.endswith("\n") else ""),
+            "commits.txt": "\n".join(commit_lines).strip()
+            + ("\n" if commit_lines else ""),
         }
     )

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

@@ -33,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)
@@ -45,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(
@@ -82,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]:
@@ -92,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:
@@ -111,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
@@ -131,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:
@@ -139,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:
@@ -161,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:
@@ -176,9 +223,7 @@ class PluginLoader:
         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:
+    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:
@@ -321,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
@@ -344,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}
@@ -403,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

@@ -81,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
@@ -178,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
@@ -328,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,
             )
@@ -351,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,
             )
@@ -377,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
@@ -448,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:
@@ -465,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,
@@ -522,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
@@ -559,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":
@@ -622,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/run.sh

@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-
-if [[ "${AI_PUSH_HOOKS_SKIP:-0}" == "1" ]]; then
-  printf '[ai-push-hooks] Skipped (AI_PUSH_HOOKS_SKIP=1).\n' >&2
-  exit 0
-fi
-
-script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-if command -v python3 >/dev/null 2>&1; then
-  py_cmd="python3"
-elif command -v python >/dev/null 2>&1; then
-  py_cmd="python"
-else
-  printf '[ai-push-hooks] python3/python is required but not installed.\n' >&2
-  exit 1
-fi
-
-if [[ -d "${script_dir}/src" ]]; then
-  if [[ -n "${PYTHONPATH:-}" ]]; then
-    export PYTHONPATH="${script_dir}/src:${PYTHONPATH}"
-  else
-    export PYTHONPATH="${script_dir}/src"
-  fi
-fi
-
-exec "${py_cmd}" -m ai_push_hooks "$@"