claude-dev-env 8.69.0 → 8.70.0

package/.agents/skills/second-account-workers/SKILL.md

@@ -3,7 +3,8 @@ name: second-account-workers
 description: >-
   Run local headless Claude workers through the account picker.
   Triggers: spawn a worker on the second account or another extra account, offload a worker,
-  use a named Claude profile, save main account usage.
+  use a named Claude profile, save main account usage, run a local orchestrator that spawns
+  and watches Claude workers.
 ---
 
 # Extra account workers
@@ -22,8 +23,9 @@ JSON list of profile names, with the first choice first. Names use letters,
 digits, hyphens, and underscores. The worker uses the existing second profile
 when the file is absent. When the file exists, its list sets the full order.
 Keep `main` and `wait` out of the list because they name picker decisions.
-The picker ranks main and every extra profile by room left and picks the one
-with the most.
+The picker keeps each account that has room and gives the job to the first one
+listed in `claude-account-order.json` in the main Claude home. Unlisted accounts
+follow, by most room left.
 For direct picker calls, `--second-config-dir` sets the first extra profile and
 each `--extra-config-dir` adds another in the order given.
 Picker JSON prints `config_dir` for the choice and meters under `main`, `second`,
@@ -47,6 +49,13 @@ worker_exit=$?
 cat "<report>"
 ```
 
+Add `--live-log "<events.jsonl>"` to watch the worker while it runs. The worker
+then writes one JSON event per line into that file as it happens. Every event
+carries the `session_id`, from the first startup hook line on. Each `assistant` line names the tool
+calls and text, and the last line is the `result` event. Read new lines with
+`tail -n 20 "<events.jsonl>"` and skip screenshots unless a check needs to see
+the screen.
+
 Read the JSON report and worker log after the process ends. The JSON fields are
 `account`, `reason`, `exit_code`, `duration_seconds`, `result`, and `is_error`.
 The runner writes one summary line with the selected account, exit code, and
@@ -83,3 +92,12 @@ Blocked: <open issue, or none>
 
 Keep the owned file list closed. Name the worktree path with `--cwd` and use a
 separate brief and report path for each worker.
+
+## Run a local orchestrator
+
+To save usage in a long session, start one local orchestrator worker and let it
+spawn the other workers. Give it its own brief that names each worker brief,
+worktree, report path and live log. It launches each worker with the command
+above in the background, reads the live logs to follow progress, and reads each
+report at the end. Each spawn goes through the picker, so every worker lands on
+the account with the most weekly room at its start.

package/docs/rule-guides/features-start-with-an-eval.md

@@ -0,0 +1,40 @@
+Back to the [rule entry](../../rules/features-start-with-an-eval.md).
+
+# Features start with an eval
+
+**When this applies:** A user asks for a new feature or a change in behavior, in any project.
+
+## What counts
+
+A feature is behavior a user or a caller can see that did not exist before, or that now works differently: a command, a flag, a page, an endpoint, a hook, a rule, a skill, a report, or an integration. A bug fix that restores intended behavior, a rename, a refactor, a docs edit, a question, a test run, and speed work that leaves the output the same are not features.
+
+An eval is three things for one feature: a set of input cases with their expected results, a runner that drives the feature through the entry point its users call, and a grader that scores each output. A test suite counts when it does all three for that feature.
+
+## Rule
+
+1. Make the Skill tool call with skill `claude-api` and args `build-eval` your first action on the ask. A user who types `/claude-api build-eval` has made the same call.
+2. Run the existing-work search from [`explore-thoroughly.md`](../../rules/explore-thoroughly.md) next. The guide's own first step also looks for cases, graders, and runners that exist.
+3. Follow the guide the skill loads. It asks the user to approve the inputs and the grading method, and to approve the cost before the first paid run. Ask through the session's question tool. Where the host says to keep working while a question waits, continue on the option you recommended and change course if the answer differs.
+4. Run the eval before the change to get a baseline, build the feature, and run it again.
+5. Give the pull request an "Eval" section. Name the cases and the grader, give the command that runs the eval in backticks, and quote the baseline and the result.
+
+## An existing feature with no eval
+
+When your work touches an existing feature, look for its eval. When it has none, start a separate session that builds it, and keep doing your own work while that session runs. Your own feature still starts with its own eval.
+
+- In a Claude project thread, call `send_message` with the coordinator's session id from `get_channel_session_id`, and ask it to start a thread for the eval. A thread session has no `start_thread_session`, so the coordinator starts that thread.
+- In a project's coordinator session, call `start_thread_session` with the brief.
+- In a command-line session, start a headless session through the account broker: `python ~/.claude/scripts/account_broker.py run --product claude --report <report.json> -- claude -p "<brief>" --model <model> --effort <level>`.
+
+The brief names the feature, its entry point, and the first step, the `claude-api` skill with args `build-eval`. An Agent-tool subagent is not a separate session. It shares your context window and ends with your turn.
+
+You own that session's result. Check its pull request, and link it from your own pull request's "Eval" section.
+
+## Enforcement
+
+`hooks/blocking/pull_request_proof.py` reads each new pull request before it opens, through `pr_lifecycle_skill_gate.py`. A new pull request is a `gh pr create` command, a GitHub MCP create call, or a GitHub MCP `run_workflow` dispatch whose inputs name a `head` branch and a `title`, because that workflow opens the pull request. A pull request whose title starts with `feat` (`feat:`, `feat(scope):`, `feat!:`) is denied when:
+
+- its body has no "Eval" heading, or the text under that heading names no command in backticks;
+- the session's transcript is readable and shows no `claude-api` Skill call with args `build-eval`, and no `/claude-api build-eval` command.
+
+The gate checks that the section and the call are there. Whether the eval measures the feature stays a judgment for the author and the reviewer. The order of the first action and the separate session for an existing feature are not checked by a hook, so the agent applies them.

package/hooks/blocking/followup_pr_dedupe.py

@@ -19,16 +19,20 @@ from hooks_constants.followup_pr_dedupe_constants import (
     ALL_BODY_FILE_OPTIONS,
     ALL_BODY_OPTIONS,
     ALL_REPOSITORY_OPTIONS,
+    ALL_TITLE_OPTIONS,
     CREATE_PULL_REQUEST_TOOL_SUFFIX,
     DUPLICATE_FOLLOWUP_REASON_TEMPLATE,
     FOLLOWUP_PARENT_PATTERN,
     ALL_GH_CREATE_WORDS,
     ALL_GIT_REMOTE_COMMAND_WORDS,
+    ALL_PULL_REQUEST_DISPATCH_INPUT_KEYS,
     GITHUB_API_ROOT,
     GITHUB_REMOTE_PATTERN,
     OPEN_PULL_REQUESTS_PATH_TEMPLATE,
     READ_TIMEOUT_SECONDS,
+    RUN_WORKFLOW_METHOD,
     STANDARD_INPUT_PATH,
+    WORKFLOW_DISPATCH_TOOL_SUFFIX,
 )
 from hooks_constants.pr_lifecycle_skill_gate_constants import SHELL_TOOL_NAMES
 from hooks_constants.pytest_invocation import unquoted_token
@@ -99,6 +103,18 @@ def body_from_arguments(all_arguments: list[str], working_directory: str) -> str
         return None
 
 
+def title_from_arguments(all_arguments: list[str]) -> str | None:
+    """Return the title a gh-style argument list passes, or None when it passes none.
+
+    ::
+
+        ["--title", "feat: x"] -> "feat: x"
+        ["-t=fix: y"]          -> "fix: y"
+        ["--fill"]             -> None
+    """
+    return _option_value(all_arguments, ALL_TITLE_OPTIONS)
+
+
 def _origin_repository(working_directory: str) -> tuple[str, str] | None:
     try:
         completed = subprocess.run(
@@ -146,19 +162,53 @@ def _shell_draft(command: str, working_directory: str) -> PullRequestDraft | Non
     return next((each_draft for each_draft in all_drafts if each_draft is not None), None)
 
 
-def pull_request_draft(all_payload_fields: Mapping[str, object]) -> PullRequestDraft | None:
-    """Return the pull request a PreToolUse payload is about to open, or None."""
+def _dispatch_fields(all_tool_input_fields: Mapping[str, object]) -> dict[str, object] | None:
+    all_inputs = all_tool_input_fields.get("inputs")
+    if all_tool_input_fields.get("method") != RUN_WORKFLOW_METHOD or not isinstance(all_inputs, dict):
+        return None
+    if not all(isinstance(all_inputs.get(each_key), str) for each_key in ALL_PULL_REQUEST_DISPATCH_INPUT_KEYS):
+        return None
+    return {**all_inputs, "owner": all_tool_input_fields.get("owner"), "repo": all_tool_input_fields.get("repo")}
+
+
+def create_tool_fields(all_payload_fields: Mapping[str, object]) -> Mapping[str, object] | None:
+    """Return the fields a GitHub MCP call that opens a pull request carries, or None.
+
+    ::
+
+        create_pull_request {owner, repo, title, body}       -> those fields
+        actions_run_trigger run_workflow, head and title in   -> the inputs, owner and repo
+        actions_run_trigger whose inputs name no head         -> None
+
+    A dispatch whose inputs name a head branch and a title runs a workflow
+    that opens the pull request, so it counts as a create call.
+
+    Args:
+        all_payload_fields: The parsed PreToolUse input.
+
+    Returns:
+        The owner, repo, title, body and head keys the call names, or None.
+    """
     tool_name = all_payload_fields.get("tool_name")
     tool_input = all_payload_fields.get("tool_input")
     if not isinstance(tool_name, str) or not isinstance(tool_input, dict):
         return None
     if tool_name.endswith(CREATE_PULL_REQUEST_TOOL_SUFFIX):
-        owner, repo, body = (tool_input.get(each_key) for each_key in ("owner", "repo", "body"))
+        return tool_input
+    return _dispatch_fields(tool_input) if tool_name.endswith(WORKFLOW_DISPATCH_TOOL_SUFFIX) else None
+
+
+def pull_request_draft(all_payload_fields: Mapping[str, object]) -> PullRequestDraft | None:
+    """Return the pull request a PreToolUse payload is about to open, or None."""
+    create_fields = create_tool_fields(all_payload_fields)
+    if create_fields is not None:
+        owner, repo, body = (create_fields.get(each_key) for each_key in ("owner", "repo", "body"))
         if isinstance(owner, str) and isinstance(repo, str) and isinstance(body, str):
             return PullRequestDraft(owner, repo, body)
         return None
-    command = tool_input.get("command")
-    if tool_name not in SHELL_TOOL_NAMES or not isinstance(command, str):
+    tool_input = all_payload_fields.get("tool_input")
+    command = tool_input.get("command") if isinstance(tool_input, dict) else None
+    if all_payload_fields.get("tool_name") not in SHELL_TOOL_NAMES or not isinstance(command, str):
         return None
     working_directory = all_payload_fields.get("cwd")
     return _shell_draft(command, working_directory if isinstance(working_directory, str) else "")

package/hooks/blocking/image_read_size_gate.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""PreToolUse hook: refuse a Read of an image larger than the agent cap.
+
+A Read of an image puts the whole picture in the context. A phone screenshot
+at 1440x2560 costs about 4,784 tokens, the most one image can cost. The hook
+reads the width and height from the file header and refuses the Read when the
+long edge passes the cap, naming the command that writes a capped copy::
+
+    Read shot.png (1440x2560)        -> refused, names agent_image_copy.py
+    Read shot.agent.png (288x512)    -> allowed
+    Read notes.md                    -> allowed
+    Read broken.png (no header)      -> allowed
+
+A missing file, a WebP or other unknown format and an unreadable header all pass, so the
+hook never fails closed.
+"""
+
+from __future__ import annotations
+
+import json
+import struct
+import sys
+from pathlib import Path
+
+hooks_root_directory = str(Path(__file__).resolve().parent.parent)
+if hooks_root_directory not in sys.path:
+    sys.path.insert(0, hooks_root_directory)
+
+from hooks_constants.hook_specific_output_keys import (
+    HOOK_EVENT_NAME_KEY,
+    HOOK_SPECIFIC_OUTPUT_KEY,
+    PERMISSION_DECISION_KEY,
+)
+from hooks_constants.image_read_size_gate_constants import (
+    AGENT_COPY_SCRIPT_PATH,
+    ALL_JPEG_FRAME_MARKERS,
+    ALL_JPEG_STANDALONE_MARKERS,
+    DENY_DECISION,
+    FILE_PATH_INPUT_KEY,
+    ALL_GIF_SIGNATURES,
+    GIF_SIZE_END,
+    GIF_SIZE_START,
+    HEADER_BYTE_COUNT,
+    JPEG_FRAME_SIZE_END,
+    JPEG_FRAME_SIZE_START,
+    JPEG_MARKER_LENGTH,
+    JPEG_MARKER_PREFIX,
+    JPEG_SIGNATURE,
+    MAXIMUM_LONG_EDGE_PIXELS,
+    OVERSIZED_IMAGE_REASON_TEMPLATE,
+    PERMISSION_DECISION_REASON_KEY,
+    PNG_SIGNATURE,
+    PNG_SIZE_END,
+    PNG_SIZE_START,
+    PRE_TOOL_USE_EVENT_NAME,
+    READ_TOOL_NAME,
+    TOOL_INPUT_KEY,
+    TOOL_NAME_KEY,
+)
+from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+
+
+def _jpeg_size(header: bytes) -> tuple[int, int] | None:
+    offset = len(JPEG_SIGNATURE)
+    while offset + JPEG_FRAME_SIZE_END <= len(header):
+        if header[offset] != JPEG_MARKER_PREFIX:
+            return None
+        marker = header[offset + 1]
+        if marker == JPEG_MARKER_PREFIX:
+            offset += 1
+            continue
+        if marker in ALL_JPEG_STANDALONE_MARKERS:
+            offset += JPEG_MARKER_LENGTH
+            continue
+        if marker in ALL_JPEG_FRAME_MARKERS:
+            height, width = struct.unpack(
+                ">HH", header[offset + JPEG_FRAME_SIZE_START : offset + JPEG_FRAME_SIZE_END]
+            )
+            return width, height
+        segment_length_end = offset + JPEG_MARKER_LENGTH + JPEG_MARKER_LENGTH
+        offset += JPEG_MARKER_LENGTH + struct.unpack(">H", header[offset + JPEG_MARKER_LENGTH : segment_length_end])[0]
+    return None
+
+
+def image_size(header: bytes) -> tuple[int, int] | None:
+    """Return (width, height) read from the first bytes of a PNG, JPEG or GIF file.
+
+    ::
+
+        PNG header of a 1440x2560 file -> (1440, 2560)
+        b"plain text"                  -> None
+
+    Args:
+        header: The first bytes of the file.
+    """
+    if header.startswith(PNG_SIGNATURE) and len(header) >= PNG_SIZE_END:
+        width, height = struct.unpack(">II", header[PNG_SIZE_START:PNG_SIZE_END])
+        return width, height
+    if header.startswith(ALL_GIF_SIGNATURES) and len(header) >= GIF_SIZE_END:
+        width, height = struct.unpack("<HH", header[GIF_SIZE_START:GIF_SIZE_END])
+        return width, height
+    if header.startswith(JPEG_SIGNATURE):
+        return _jpeg_size(header)
+    return None
+
+
+def _read_header(file_path: str) -> bytes:
+    try:
+        with open(file_path, "rb") as image_file:
+            return image_file.read(HEADER_BYTE_COUNT)
+    except OSError:
+        return b""
+
+
+def oversized_image_reason(all_hook_fields: dict[str, object]) -> str | None:
+    """Return the refusal for a Read of an image over the cap, or None to allow it.
+
+    Args:
+        all_hook_fields: The parsed PreToolUse payload.
+    """
+    tool_input = all_hook_fields.get(TOOL_INPUT_KEY)
+    if all_hook_fields.get(TOOL_NAME_KEY) != READ_TOOL_NAME or not isinstance(tool_input, dict):
+        return None
+    file_path = tool_input.get(FILE_PATH_INPUT_KEY)
+    if not isinstance(file_path, str):
+        return None
+    dimensions = image_size(_read_header(file_path))
+    if dimensions is None or max(dimensions) <= MAXIMUM_LONG_EDGE_PIXELS:
+        return None
+    width, height = dimensions
+    return OVERSIZED_IMAGE_REASON_TEMPLATE.format(
+        width=width,
+        height=height,
+        maximum_edge=MAXIMUM_LONG_EDGE_PIXELS,
+        script_path=AGENT_COPY_SCRIPT_PATH,
+        image_path=file_path,
+    )
+
+
+def main() -> int:
+    """Read the PreToolUse payload and print a deny decision for an oversized image.
+
+    Returns:
+        0 in every case; the decision travels in the JSON output.
+    """
+    hook_payload = read_hook_input_dictionary_from_stdin()
+    if hook_payload is None:
+        return 0
+    refusal_reason = oversized_image_reason(hook_payload)
+    if refusal_reason is not None:
+        sys.stdout.write(
+            json.dumps(
+                {
+                    HOOK_SPECIFIC_OUTPUT_KEY: {
+                        HOOK_EVENT_NAME_KEY: PRE_TOOL_USE_EVENT_NAME,
+                        PERMISSION_DECISION_KEY: DENY_DECISION,
+                        PERMISSION_DECISION_REASON_KEY: refusal_reason,
+                    }
+                }
+            )
+        )
+        sys.stdout.flush()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/hooks/blocking/pr_lifecycle_skill_gate.py

@@ -6,6 +6,7 @@ import json
 import re
 import shlex
 import sys
+from collections.abc import Callable, Iterable
 from pathlib import Path
 
 hooks_directory = str(Path(__file__).resolve().parent.parent)
@@ -15,6 +16,7 @@ if hooks_directory not in sys.path:
 from hooks_constants.pr_lifecycle_skill_gate_constants import (
     AGENT_ID_FIELD,
     AGENT_ID_PATTERN,
+    ALL_BUILD_EVAL_SKILL_NAMES,
     ALL_API_ACTION_NAMES,
     ALL_COMMAND_PREFIX_WORDS,
     ALL_GITHUB_MCP_TOOL_SUFFIXES,
@@ -23,6 +25,8 @@ from hooks_constants.pr_lifecycle_skill_gate_constants import (
     ALL_SHELL_WRAPPER_EXECUTABLES,
     ALL_SLASH_COMMAND_MARKERS,
     ALL_TRANSCRIPT_PATH_FIELDS,
+    BUILD_EVAL_ARGUMENT_WORD,
+    BUILD_EVAL_COMMAND_MARKER,
     COMMAND_SEPARATORS,
     COMMAND_WHITESPACE,
     DENY_DECISION,
@@ -52,13 +56,19 @@ from hooks_constants.hook_specific_output_keys import (
 )
 from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
 from hooks_constants.setup_project_paths_constants import DECODE_ERRORS_POLICY, UTF8_ENCODING
-from blocking.followup_pr_dedupe import duplicate_followup_reason
+from blocking.followup_pr_dedupe import create_tool_fields, duplicate_followup_reason
 from blocking.pull_request_proof import (
+    is_feature_pull_request,
+    missing_eval_section_reason,
     missing_existing_work_reason,
     missing_look_reason,
     missing_proof_reason,
 )
-from transcript_skill_scan import is_skill_loaded_after_last_compaction
+from hooks_constants.pull_request_proof_constants import MISSING_BUILD_EVAL_REASON
+from transcript_skill_scan import (
+    invokes_skill_with_argument,
+    is_skill_loaded_after_last_compaction,
+)
 
 
 def _command_segments(command: str) -> list[list[str]]:
@@ -169,7 +179,7 @@ def _is_governed_action(all_payload_fields: dict[str, object]) -> bool:
     tool_name = all_payload_fields.get("tool_name")
     if not isinstance(tool_name, str):
         return False
-    if tool_name.endswith(ALL_GITHUB_MCP_TOOL_SUFFIXES):
+    if tool_name.endswith(ALL_GITHUB_MCP_TOOL_SUFFIXES) or create_tool_fields(all_payload_fields) is not None:
         return True
     if tool_name not in SHELL_TOOL_NAMES:
         return False
@@ -177,16 +187,29 @@ def _is_governed_action(all_payload_fields: dict[str, object]) -> bool:
     return isinstance(tool_input, dict) and isinstance(tool_input.get("command"), str) and _matches_shell_command(tool_input["command"])
 
 
-def _transcript_load_status(path: str) -> bool | None:
+def _scanned_transcript(path: str, scan: Callable[[Iterable[str]], bool]) -> bool | None:
     try:
         with open(path, encoding=UTF8_ENCODING, errors=DECODE_ERRORS_POLICY) as transcript:
-            return is_skill_loaded_after_last_compaction(
-                transcript, (SKILL_NAME,), ALL_SLASH_COMMAND_MARKERS
-            )
+            return scan(transcript)
     except OSError:
         return None
 
 
+def _shows_skill_load(all_transcript_lines: Iterable[str]) -> bool:
+    return is_skill_loaded_after_last_compaction(
+        all_transcript_lines, (SKILL_NAME,), ALL_SLASH_COMMAND_MARKERS
+    )
+
+
+def _shows_build_eval(all_transcript_lines: Iterable[str]) -> bool:
+    return invokes_skill_with_argument(
+        all_transcript_lines,
+        ALL_BUILD_EVAL_SKILL_NAMES,
+        BUILD_EVAL_ARGUMENT_WORD,
+        BUILD_EVAL_COMMAND_MARKER,
+    )
+
+
 def _subagent_transcript_path(all_payload_fields: dict[str, object]) -> str | None:
     session_path = all_payload_fields.get(SESSION_TRANSCRIPT_PATH_FIELD)
     agent_id = all_payload_fields.get(AGENT_ID_FIELD)
@@ -203,7 +226,17 @@ def _subagent_transcript_path(all_payload_fields: dict[str, object]) -> str | No
 
 
 def decision_for(all_payload_fields: dict[str, object]) -> dict[str, object] | None:
-    """Return a deny for an unloaded skill, a new pull request with no proof or existing-work section, or a second follow-up.
+    """Return a deny for the first rule a pull request action breaks, else None.
+
+    ::
+
+        pr-lifecycle skill not loaded                     -> DENY_REASON
+        new pull request with no proof section            -> MISSING_PROOF_REASON
+        new pull request with no existing-work section    -> MISSING_EXISTING_WORK_REASON
+        feature pull request with no eval section         -> MISSING_EVAL_SECTION_REASON
+        changed page whose proof shows no picture         -> MISSING_LOOK_REASON
+        feature pull request, no /claude-api build-eval   -> MISSING_BUILD_EVAL_REASON
+        second follow-up pull request for one parent      -> DUPLICATE_FOLLOWUP_REASON_TEMPLATE
 
     Args:
         all_payload_fields: The parsed PreToolUse input.
@@ -218,23 +251,41 @@ def decision_for(all_payload_fields: dict[str, object]) -> dict[str, object] | N
     search_reason = missing_existing_work_reason(all_payload_fields)
     if search_reason is not None:
         return _deny(search_reason)
+    eval_reason = missing_eval_section_reason(all_payload_fields)
+    if eval_reason is not None:
+        return _deny(eval_reason)
     look_reason = missing_look_reason(all_payload_fields)
     if look_reason is not None:
         return _deny(look_reason)
+    if is_feature_pull_request(all_payload_fields) and _is_build_eval_missing(all_payload_fields):
+        return _deny(MISSING_BUILD_EVAL_REASON)
     duplicate_reason = duplicate_followup_reason(all_payload_fields)
     return None if duplicate_reason is None else _deny(duplicate_reason)
 
 
-def _is_skill_unloaded(all_payload_fields: dict[str, object]) -> bool:
+def _transcript_paths(all_payload_fields: dict[str, object]) -> list[str]:
     paths = [all_payload_fields.get(field) for field in ALL_TRANSCRIPT_PATH_FIELDS]
     paths.append(_subagent_transcript_path(all_payload_fields))
-    readable_paths = list(dict.fromkeys(path for path in paths if isinstance(path, str) and path))
+    return list(dict.fromkeys(path for path in paths if isinstance(path, str) and path))
+
+
+def _is_skill_unloaded(all_payload_fields: dict[str, object]) -> bool:
+    readable_paths = _transcript_paths(all_payload_fields)
     if not readable_paths:
         return False
-    statuses = [_transcript_load_status(path) for path in readable_paths]
+    statuses = [_scanned_transcript(path, _shows_skill_load) for path in readable_paths]
     return not any(status is None or status for status in statuses)
 
 
+def _is_build_eval_missing(all_payload_fields: dict[str, object]) -> bool:
+    all_statuses = [
+        _scanned_transcript(each_path, _shows_build_eval)
+        for each_path in _transcript_paths(all_payload_fields)
+    ]
+    all_read_statuses = [each_status for each_status in all_statuses if each_status is not None]
+    return bool(all_read_statuses) and not any(all_read_statuses)
+
+
 def _deny(reason: str) -> dict[str, object]:
     return {
         HOOK_SPECIFIC_OUTPUT_KEY: {