ai-push-hooks 0.3.1 → 0.3.2

package/src/ai_push_hooks/executors/ask.py

@@ -31,7 +31,9 @@ def extract_json_object(text: str) -> dict[str, Any]:
     try:
         payload = json.loads(text[start : end + 1])
     except json.JSONDecodeError as exc:
-        raise HookError(f"Failed to parse JSON object from model output: {exc}") from exc
+        raise HookError(
+            f"Failed to parse JSON object from model output: {exc}"
+        ) from exc
     if not isinstance(payload, dict):
         raise HookError("Model output JSON is not an object")
     return payload
@@ -41,7 +43,9 @@ def validate_schema(schema: str | None, payload: Any) -> Any:
     if schema is None:
         return payload
     if schema == "string_array":
-        if not isinstance(payload, list) or not all(isinstance(item, str) for item in payload):
+        if not isinstance(payload, list) or not all(
+            isinstance(item, str) for item in payload
+        ):
             raise HookError("Expected schema string_array")
         return payload
     if schema == "docs_issue_array":
@@ -50,7 +54,10 @@ def validate_schema(schema: str | None, payload: Any) -> Any:
         for item in payload:
             if not isinstance(item, dict):
                 raise HookError("docs_issue_array items must be objects")
-            if not str(item.get("file", "")).strip() or not str(item.get("description", "")).strip():
+            if (
+                not str(item.get("file", "")).strip()
+                or not str(item.get("description", "")).strip()
+            ):
                 raise HookError("docs_issue_array items require file and description")
         return payload
     if schema == "beads_alignment_result":
@@ -58,13 +65,21 @@ def validate_schema(schema: str | None, payload: Any) -> Any:
             raise HookError("Expected schema beads_alignment_result")
         commands = payload.get("commands", [])
         if commands is not None and (
-            not isinstance(commands, list) or not all(isinstance(item, str) for item in commands)
+            not isinstance(commands, list)
+            or not all(isinstance(item, str) for item in commands)
         ):
-            raise HookError("beads_alignment_result.commands must be an array of strings")
+            raise HookError(
+                "beads_alignment_result.commands must be an array of strings"
+            )
         return payload
     if schema == "pr_create_payload":
         if not isinstance(payload, dict):
             raise HookError("Expected schema pr_create_payload")
+        for field in ("title", "body"):
+            if field in payload and not isinstance(payload[field], str):
+                raise HookError(f"pr_create_payload.{field} must be a string")
+        if "draft" in payload and not isinstance(payload["draft"], bool):
+            raise HookError("pr_create_payload.draft must be a boolean")
         return payload
     raise HookError(f"Unsupported schema: {schema}")
 
@@ -149,7 +164,9 @@ def run_ask_step(
                         f"{_safe_invalid_output(invocation, last_output)}"
                     ) from exc
 
-                snippet = last_output[: context.config.llm.invalid_json_feedback_max_chars]
+                snippet = last_output[
+                    : context.config.llm.invalid_json_feedback_max_chars
+                ]
                 suffix = (
                     "Return ONLY valid JSON array."
                     if expects_json_array
@@ -167,7 +184,11 @@ def run_ask_step(
 
                 session = result.session
                 can_resume = bool(
-                    getattr(getattr(invocation.runner, "capabilities", None), "supports_resume", False)
+                    getattr(
+                        getattr(invocation.runner, "capabilities", None),
+                        "supports_resume",
+                        False,
+                    )
                     and session is not None
                     and session.session_id
                     and session.resumable
@@ -181,13 +202,9 @@ def run_ask_step(
                         retry_reason = "runner does not support resume"
                     retry_message = "Retrying with a fresh runner invocation."
                     if retry_reason == "runner does not support resume":
-                        retry_message = (
-                            "Retrying with a fresh runner invocation; unsupported session reuse."
-                        )
+                        retry_message = "Retrying with a fresh runner invocation; unsupported session reuse."
                     elif retry_reason == "session absent":
-                        retry_message = (
-                            "Retrying with a fresh runner invocation; no reusable session was captured."
-                        )
+                        retry_message = "Retrying with a fresh runner invocation; no reusable session was captured."
                     context.logger.status(
                         "llm.retry_fresh_session",
                         retry_message,

package/src/ai_push_hooks/executors/exec.py

@@ -20,6 +20,7 @@ from ..paths import (
     resolve_contained_path,
 )
 from ..types import HookError, ModuleRuntimeState, RuntimeContext, StepConfig
+from .ask import validate_schema
 
 BEADS_ALIGNMENT_TIMEOUT_SECONDS = 30
 BEADS_ALIGNMENT_TOTAL_TIMEOUT_SECONDS = 120
@@ -72,10 +73,14 @@ BEADS_MIGRATION_OVERRIDE_ENV_NAMES = frozenset(
 )
 
 
-def _report_file_path(context: RuntimeContext, state: ModuleRuntimeState) -> pathlib.Path:
+def _report_file_path(
+    context: RuntimeContext, state: ModuleRuntimeState
+) -> pathlib.Path:
     branch_context = state.artifacts.get("collect/branch-context.txt")
     if branch_context and branch_context.exists():
-        payload = git_utils.parse_key_value_text(branch_context.read_text(encoding="utf-8"))
+        payload = git_utils.parse_key_value_text(
+            branch_context.read_text(encoding="utf-8")
+        )
         report_file = payload.get("report_file", "BEADS_STATUS_ACTION_REQUIRED.md")
     else:
         report_file = "BEADS_STATUS_ACTION_REQUIRED.md"
@@ -101,13 +106,19 @@ def _validate_beads_issue_ids(values: list[str]) -> None:
         raise HookError("Beads alignment commands require between 1 and 20 issue ids")
     for issue_id in values:
         if not BEADS_ISSUE_ID_PATTERN.fullmatch(issue_id):
-            raise HookError(f"Invalid Beads issue id in alignment command: {issue_id!r}")
+            raise HookError(
+                f"Invalid Beads issue id in alignment command: {issue_id!r}"
+            )
 
 
 def validate_beads_alignment_command(command: str) -> list[str]:
     if not isinstance(command, str) or not command.strip():
         raise HookError("Beads alignment commands must be non-empty strings")
-    if len(command) > 4096 or "\x00" in command or any(ord(char) < 32 for char in command):
+    if (
+        len(command) > 4096
+        or "\x00" in command
+        or any(ord(char) < 32 for char in command)
+    ):
         raise HookError("Beads alignment command contains invalid or excessive input")
     try:
         argv = shlex.split(command, posix=True)
@@ -119,7 +130,11 @@ def validate_beads_alignment_command(command: str) -> list[str]:
 
     subcommand = argv[1]
     if subcommand == "update":
-        if len(argv) < 5 or argv[-2] != "--status" or argv[-1] not in BEADS_UPDATE_STATUSES:
+        if (
+            len(argv) < 5
+            or argv[-2] != "--status"
+            or argv[-1] not in BEADS_UPDATE_STATUSES
+        ):
             raise HookError(
                 "Allowed Beads update form is: bd update <issue-id> [<issue-id> ...] "
                 "--status <open|in_progress|blocked>"
@@ -154,14 +169,18 @@ def resolve_beads_executable(repo_root: pathlib.Path) -> str:
     lexical_candidate = pathlib.Path(os.path.abspath(candidate))
     resolved_repo_root = repo_root.resolve(strict=True)
     if is_path_within(lexical_candidate, resolved_repo_root):
-        raise HookError(f"Refusing repository-contained `bd` executable: {lexical_candidate}")
+        raise HookError(
+            f"Refusing repository-contained `bd` executable: {lexical_candidate}"
+        )
     try:
         executable = lexical_candidate.resolve(strict=True)
     except (OSError, RuntimeError) as exc:
         raise HookError("Unable to safely resolve the `bd` executable") from exc
     if is_path_within(executable, resolved_repo_root):
         raise HookError(f"Refusing repository-contained `bd` executable: {executable}")
-    if path_is_link_or_reparse(executable) or not stat.S_ISREG(executable.stat().st_mode):
+    if path_is_link_or_reparse(executable) or not stat.S_ISREG(
+        executable.stat().st_mode
+    ):
         raise HookError(f"Resolved `bd` executable is not a regular file: {executable}")
     if not os.access(executable, os.X_OK):
         raise HookError(f"Resolved `bd` executable is not executable: {executable}")
@@ -184,7 +203,12 @@ def beads_alignment_executor(
     inputs: list[pathlib.Path],
 ) -> dict[str, Any]:
     if state.metadata.get("skip_module"):
-        return {"skipped": True, "commands_run": [], "report_written": False, "unresolved": False}
+        return {
+            "skipped": True,
+            "commands_run": [],
+            "report_written": False,
+            "unresolved": False,
+        }
     payload = json.loads(inputs[0].read_text(encoding="utf-8"))
     if not isinstance(payload, dict):
         raise HookError("beads_alignment payload must be an object")
@@ -195,14 +219,18 @@ def beads_alignment_executor(
         raise HookError(
             f"beads_alignment accepts at most {BEADS_ALIGNMENT_MAX_COMMANDS} commands"
         )
-    validated_commands = [validate_beads_alignment_command(command) for command in commands]
+    validated_commands = [
+        validate_beads_alignment_command(command) for command in commands
+    ]
     beads_executable = resolve_beads_executable(context.repo_root) if commands else ""
     command_env = beads_alignment_env()
     report_path = _report_file_path(context, state)
     commands_run: list[str] = []
     started_at = time.monotonic()
     for command, argv in zip(commands, validated_commands):
-        remaining = BEADS_ALIGNMENT_TOTAL_TIMEOUT_SECONDS - (time.monotonic() - started_at)
+        remaining = BEADS_ALIGNMENT_TOTAL_TIMEOUT_SECONDS - (
+            time.monotonic() - started_at
+        )
         if remaining <= 0:
             raise HookError(
                 f"Beads alignment exceeded its {BEADS_ALIGNMENT_TOTAL_TIMEOUT_SECONDS}-second total budget"
@@ -223,7 +251,9 @@ def beads_alignment_executor(
     if report_markdown:
         if not report_markdown.endswith("\n"):
             report_markdown += "\n"
-        if not git_utils.write_text_file(report_path, report_markdown, root=context.repo_root):
+        if not git_utils.write_text_file(
+            report_path, report_markdown, root=context.repo_root
+        ):
             raise HookError(f"Failed to write Beads alignment report: {report_path}")
         report_written = True
     elif report_path.exists() and not unresolved:
@@ -253,7 +283,9 @@ def gh_pr_create_executor(
     branch_name = str(context.cache.get("branch_name", "")).strip()
     if not branch_name:
         reason = str(
-            context.cache.get("branch_selection_reason", "no single pushed branch is available")
+            context.cache.get(
+                "branch_selection_reason", "no single pushed branch is available"
+            )
         )
         raise HookError(f"PR creation requires one pushed branch: {reason}")
     default_base_branch = context.config.general.base_branch.strip() or "main"
@@ -266,14 +298,14 @@ def gh_pr_create_executor(
             "deferred_until_remote": True,
             "reason": reason,
         }
+    payload = validate_schema(
+        "pr_create_payload", json.loads(inputs[0].read_text(encoding="utf-8"))
+    )
     if shutil.which("gh") is None:
         raise HookError("`gh` is required for PR creation but is not installed")
     repository = git_utils.resolve_github_repository(
         context.repo_root, context.remote_name, context.remote_url
     )
-    payload = json.loads(inputs[0].read_text(encoding="utf-8"))
-    if not isinstance(payload, dict):
-        raise HookError("PR creation payload must be an object")
     existing_pr = git_utils.lookup_open_pr_url(
         context.repo_root, branch_name, default_base_branch, repository
     )
@@ -282,8 +314,8 @@ def gh_pr_create_executor(
 
     base_branch = default_base_branch
     head_branch = branch_name
-    title = git_utils.sanitize_pr_title(str(payload.get("title", "")).strip(), branch_name)
-    body = str(payload.get("body", "")).strip()
+    title = git_utils.sanitize_pr_title(payload.get("title", "").strip(), branch_name)
+    body = payload.get("body", "").strip()
     if not body:
         commits = git_utils.collect_commit_messages_for_ranges(
             context.repo_root,
@@ -312,17 +344,24 @@ def gh_pr_create_executor(
         "--body",
         body,
     ]
-    if bool(payload.get("draft", False)):
+    if payload.get("draft", False):
         args.append("--draft")
     created = git_utils.run_command(args, cwd=context.repo_root, check=False)
-    combined_output = "\n".join([(created.stdout or "").strip(), (created.stderr or "").strip()])
-    pr_url = git_utils.extract_pr_url(combined_output)
-    if created.returncode != 0 and not pr_url:
+    combined_output = "\n".join(
+        [(created.stdout or "").strip(), (created.stderr or "").strip()]
+    )
+    if created.returncode != 0:
+        # A URL in failed-command output is not proof that the create operation
+        # succeeded. Reconcile against GitHub before accepting the result.
         pr_url = git_utils.lookup_open_pr_url(
             context.repo_root, branch_name, default_base_branch, repository
         )
+    else:
+        pr_url = git_utils.extract_pr_url(combined_output)
     if not pr_url:
-        details = git_utils._command_diagnostics(args, created.stdout or "", created.stderr or "")
+        details = git_utils._command_diagnostics(
+            args, created.stdout or "", created.stderr or ""
+        )
         raise HookError(
             details or f"gh pr create failed with exit code {created.returncode}"
         )

package/src/ai_push_hooks/executors/runner_workflow.py

@@ -76,29 +76,36 @@ def _safe_input_artifacts(
         # parents immediately before opening each file; this is a same-user
         # race defense, not an OS sandbox.  O_NOFOLLOW and descriptor checks
         # below protect the final open even if the leaf changes concurrently.
-        if (
-            not is_path_within(lexical_path, run_root)
-            or path_has_symlink(run_root, lexical_path)
+        if not is_path_within(lexical_path, run_root) or path_has_symlink(
+            run_root, lexical_path
         ):
             raise HookError(f"Runner artifact must not traverse a symlink: {name}")
         try:
             resolved_path = lexical_path.resolve(strict=True)
         except (OSError, RuntimeError) as exc:
-            raise HookError(f"Unable to safely resolve runner artifact: {name}") from exc
+            raise HookError(
+                f"Unable to safely resolve runner artifact: {name}"
+            ) from exc
         if (
             resolved_path != lexical_path
             or not is_path_within(resolved_path, run_root)
             or not resolved_path.is_file()
         ):
-            raise HookError(f"Runner artifact must be a regular hook-owned file: {name}")
+            raise HookError(
+                f"Runner artifact must be a regular hook-owned file: {name}"
+            )
 
         descriptor: int | None = None
         try:
-            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)
+            )
             descriptor = os.open(lexical_path, flags)
             metadata = os.fstat(descriptor)
             if not os.path.isfile(lexical_path) or not stat.S_ISREG(metadata.st_mode):
-                raise HookError(f"Runner artifact must be a regular hook-owned file: {name}")
+                raise HookError(
+                    f"Runner artifact must be a regular hook-owned file: {name}"
+                )
             remaining = RUNNER_INPUT_MAX_BYTES - total_bytes
             if metadata.st_size > remaining:
                 raise HookError(
@@ -121,7 +128,9 @@ def _safe_input_artifacts(
             total_bytes += len(content_bytes)
             content = bytes(content_bytes).decode("utf-8")
         except (OSError, UnicodeError) as exc:
-            raise HookError(f"Unable to read hook-owned runner artifact: {name}") from exc
+            raise HookError(
+                f"Unable to read hook-owned runner artifact: {name}"
+            ) from exc
         finally:
             if descriptor is not None:
                 os.close(descriptor)
@@ -143,7 +152,9 @@ def _build_request(
     profile = resolve_runner_profile(context.config, step)
     cwd = pathlib.Path(working_directory).resolve(strict=True)
     if not cwd.is_dir():
-        raise HookError(f"Runner working directory is not a directory: {working_directory}")
+        raise HookError(
+            f"Runner working directory is not a directory: {working_directory}"
+        )
     request = RunnerRequest(
         profile_id=profile.name,
         runner_type=profile.type,
@@ -206,7 +217,9 @@ def _failure_result(
     if not isinstance(session_id, str) or not session_id.strip():
         session_id = fallback_session_id
     session = _session_metadata(runner, session_id.strip()) if session_id else None
-    return RunnerResult(final_text="", returncode=1, stdout="", stderr="", session=session)
+    return RunnerResult(
+        final_text="", returncode=1, stdout="", stderr="", session=session
+    )
 
 
 def _preserve_failure_session(
@@ -214,7 +227,9 @@ def _preserve_failure_session(
     result: RunnerResult,
     fallback_session_id: str | None,
 ) -> RunnerResult:
-    if (result.session is not None and result.session.session_id) or not fallback_session_id:
+    if (
+        result.session is not None and result.session.session_id
+    ) or not fallback_session_id:
         return result
     return RunnerResult(
         final_text=result.final_text,
@@ -250,7 +265,9 @@ def _completion(
     )
 
 
-def _print_normalized_output(context: RuntimeContext, invocation: _RunnerInvocation) -> None:
+def _print_normalized_output(
+    context: RuntimeContext, invocation: _RunnerInvocation
+) -> None:
     if not context.config.logging.print_llm_output or not invocation.result.final_text:
         return
     # This is an explicit opt-in.  Only normalized final text is printed and
@@ -270,7 +287,14 @@ def _request_sensitive_values(request: RunnerRequest) -> tuple[str, ...]:
         if value
         and any(
             marker in name.upper()
-            for marker in ("API_KEY", "TOKEN", "SECRET", "PASSWORD", "AUTH", "CREDENTIAL")
+            for marker in (
+                "API_KEY",
+                "TOKEN",
+                "SECRET",
+                "PASSWORD",
+                "AUTH",
+                "CREDENTIAL",
+            )
         )
     )
     return (
@@ -316,9 +340,7 @@ def _named_error(
             "\n".join(part for part in (reason, streams) if part),
             max_chars=1_200,
         )
-    message = (
-        f"Runner profile `{profile_name}` ({runner_type}) failed at stage `{stage_name}`"
-    )
+    message = f"Runner profile `{profile_name}` ({runner_type}) failed at stage `{stage_name}`"
     if details:
         message += f": {details}"
     return HookError(message)

package/src/ai_push_hooks/executors/runners/claude.py

@@ -65,7 +65,9 @@ def resolve_claude_executable() -> str:
     )
 
 
-def _capability_error(reason: str, *, details: str = "") -> RunnerAdapterUnavailableError:
+def _capability_error(
+    reason: str, *, details: str = ""
+) -> RunnerAdapterUnavailableError:
     return RunnerAdapterUnavailableError(
         "Claude Code CLI does not satisfy the required non-interactive contract",
         details=f"{reason}{(': ' + details) if details else ''}",
@@ -102,9 +104,13 @@ def check_claude_capabilities(
         raise _capability_error("help output was truncated")
 
     help_text = f"{help_result.stdout}\n{help_result.stderr}"
-    missing = tuple(marker for marker in REQUIRED_HELP_MARKERS if marker not in help_text)
+    missing = tuple(
+        marker for marker in REQUIRED_HELP_MARKERS if marker not in help_text
+    )
     if missing:
-        raise _capability_error("missing required flags or modes", details=", ".join(missing))
+        raise _capability_error(
+            "missing required flags or modes", details=", ".join(missing)
+        )
 
 
 def _protocol_failure(
@@ -158,13 +164,19 @@ def parse_claude_result(
     try:
         payload: Any = json.loads(raw)
     except json.JSONDecodeError as exc:
-        raise _protocol_failure(request, process_result, "stdout was not valid JSON") from exc
+        raise _protocol_failure(
+            request, process_result, "stdout was not valid JSON"
+        ) from exc
     if not isinstance(payload, dict):
-        raise _protocol_failure(request, process_result, "top-level JSON value was not an object")
+        raise _protocol_failure(
+            request, process_result, "top-level JSON value was not an object"
+        )
 
     message_type = payload.get("type")
     if message_type != "result":
-        raise _protocol_failure(request, process_result, "top-level JSON type was not result")
+        raise _protocol_failure(
+            request, process_result, "top-level JSON type was not result"
+        )
 
     is_error = payload.get("is_error")
     if not isinstance(is_error, bool):

package/src/ai_push_hooks/executors/runners/codex.py

@@ -111,14 +111,18 @@ def _parse_codex_jsonl(request: RunnerRequest, process: ProcessResult) -> _Codex
             thread_id = value
         elif event_type == "turn.started":
             if turn_open:
-                raise _protocol_error(request, process, "Codex JSONL turn order was invalid")
+                raise _protocol_error(
+                    request, process, "Codex JSONL turn order was invalid"
+                )
             turn_open = True
             if not terminal_failure:
                 terminal_success = False
         elif event_type == "item.completed":
             item = event.get("item")
             if not isinstance(item, dict):
-                raise _protocol_error(request, process, "Codex item.completed event had no item")
+                raise _protocol_error(
+                    request, process, "Codex item.completed event had no item"
+                )
             if item.get("type") == "agent_message":
                 text = item.get("text")
                 if not isinstance(text, str):
@@ -213,7 +217,9 @@ class CodexRunner:
         if process.stdout_truncated or process.stderr_truncated:
             raise _protocol_error(request, process, "Codex output stream was truncated")
         if not process.stdout.strip():
-            raise _protocol_error(request, process, "Codex emitted an empty JSONL stream")
+            raise _protocol_error(
+                request, process, "Codex emitted an empty JSONL stream"
+            )
 
         parsed = _parse_codex_jsonl(request, process)
         if not parsed.terminal_success:

package/src/ai_push_hooks/executors/runners/command.py

@@ -25,8 +25,10 @@ _PLACEHOLDER_PATTERN = re.compile(r"\{[^{}]*\}")
 
 
 def _is_plain_text(value: object, *, allow_empty: bool = False) -> bool:
-    return isinstance(value, str) and (allow_empty or bool(value.strip())) and not any(
-        ord(character) < 32 for character in value
+    return (
+        isinstance(value, str)
+        and (allow_empty or bool(value.strip()))
+        and not any(ord(character) < 32 for character in value)
     )
 
 
@@ -69,10 +71,14 @@ def _validate_request(request: object) -> RunnerRequest:
         or not math.isfinite(request.timeout_seconds)
         or request.timeout_seconds <= 0
     ):
-        raise RunnerContractError("timeout_seconds must be finite and greater than zero")
+        raise RunnerContractError(
+            "timeout_seconds must be finite and greater than zero"
+        )
 
     if request.model is not None and not _is_plain_text(request.model):
-        raise RunnerContractError("model must be a non-empty NUL-free string when provided")
+        raise RunnerContractError(
+            "model must be a non-empty NUL-free string when provided"
+        )
     if request.variant is not None:
         raise RunnerContractError("variant is not valid for runner type command")
     if request.prompt_transport not in {"stdin", "argv"}:
@@ -85,11 +91,17 @@ def _validate_request(request: object) -> RunnerRequest:
     prompt_count = 0
     for index, argument in enumerate(command, start=1):
         if not isinstance(argument, str) or not argument.strip() or "\x00" in argument:
-            raise RunnerContractError(f"command[{index}] must be a non-empty NUL-free string")
+            raise RunnerContractError(
+                f"command[{index}] must be a non-empty NUL-free string"
+            )
         for placeholder in _PLACEHOLDER_PATTERN.findall(argument):
             if placeholder not in _ALLOWED_PLACEHOLDERS:
-                raise RunnerContractError(f"unknown placeholder {placeholder!r} in command[{index}]")
-        if ("{" in argument or "}" in argument) and argument not in _ALLOWED_PLACEHOLDERS:
+                raise RunnerContractError(
+                    f"unknown placeholder {placeholder!r} in command[{index}]"
+                )
+        if (
+            "{" in argument or "}" in argument
+        ) and argument not in _ALLOWED_PLACEHOLDERS:
             raise RunnerContractError(
                 f"placeholders in command[{index}] must be whole argv elements"
             )
@@ -97,7 +109,9 @@ def _validate_request(request: object) -> RunnerRequest:
             prompt_count += 1
 
     if request.prompt_transport == "stdin" and prompt_count:
-        raise RunnerContractError("command must not contain {prompt} with stdin transport")
+        raise RunnerContractError(
+            "command must not contain {prompt} with stdin transport"
+        )
     if request.prompt_transport == "argv" and prompt_count != 1:
         raise RunnerContractError(
             "command must contain exactly one {prompt} with argv transport"
@@ -142,7 +156,9 @@ class CommandRunner:
         except RunnerExecutableNotFoundError as exc:
             # The rendered argv can contain prompt/model values.  Do not
             # repeat the lower-level adapter's executable detail here.
-            raise RunnerExecutableNotFoundError("runner executable was not found") from exc
+            raise RunnerExecutableNotFoundError(
+                "runner executable was not found"
+            ) from exc
         result = RunnerResult(
             final_text=process_result.stdout,
             returncode=process_result.returncode,