claude-dev-env 8.25.0 → 8.26.0

package/hooks/routing/thread_spawn_pace_hook.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""PreToolUse hook: reshape a thread spawn when usage runs over pace.
+
+Registered on ``mcp__hearthbot__start_thread_session``. It runs ``usage_pace.py``
+beside it, or the script ``COORDINATOR_USAGE_PACE_SCRIPT`` names.
+
+::
+
+    usage under pace (exit 1)          -> no output; the call runs unchanged
+    over pace (exit 0) or unreadable   -> allow with updatedInput:
+        model "claude-sonnet-5-5", effort "medium",
+        instructions + the mandatory Fable advisor line
+    input that cannot be reshaped      -> deny with a one-line reason
+
+``updatedInput`` is the whole tool input the call runs with, so it carries
+every original key.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+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.bash_pre_tool_use_dispatcher_constants import (
+    ALLOW_DECISION,
+    HOOK_EVENT_NAME,
+)
+from hooks_constants.pre_tool_use_allow_output import (
+    HOOK_EVENT_NAME_KEY,
+    HOOK_SPECIFIC_OUTPUT_KEY,
+    PERMISSION_DECISION_KEY,
+    UPDATED_INPUT_KEY,
+)
+from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+from hooks_constants.thread_spawn_pace_hook_constants import (
+    ADDITIONAL_CONTEXT_KEY,
+    EFFORT_INPUT_KEY,
+    FABLE_ADVISOR_LINE,
+    INSTRUCTIONS_ENCODING,
+    INSTRUCTIONS_INPUT_KEY,
+    INSTRUCTIONS_MAXIMUM_BYTES,
+    INSTRUCTIONS_SEPARATOR,
+    LAUNCH_FAILURE_ERROR_TEMPLATE,
+    MODEL_INPUT_KEY,
+    NO_INSTRUCTIONS_REASON,
+    NOT_AN_OBJECT_REASON,
+    OVER_BYTE_CAP_REASON_TEMPLATE,
+    PACE_VERDICT_CONTEXT_MAXIMUM_CHARACTERS,
+    PERMISSION_DECISION_REASON_KEY,
+    PERMISSION_DENY,
+    RESHAPE_CONTEXT_PREFIX,
+    THREAD_EFFORT_WHEN_OVER_PACE,
+    THREAD_MODEL_WHEN_OVER_PACE,
+    TOOL_INPUT_KEY,
+    USAGE_PACE_SCRIPT_ENV_VAR,
+    USAGE_PACE_SCRIPT_FILE_NAME,
+    USAGE_PACE_TIMEOUT_SECONDS,
+)
+from hooks_constants.usage_pace_constants import (
+    EXIT_CODE_UNDER_PACE,
+    EXIT_CODE_UNREADABLE,
+    RESULT_KEY_ERROR,
+    RESULT_KEY_OVER_PACE,
+)
+
+
+class SpawnNotReshapable(Exception):
+    """The spawn input cannot carry the over-pace model, effort, and advisor line."""
+
+
+def _instructions_with_advisor_line(instructions: str) -> str:
+    reshaped_instructions = (
+        instructions
+        if FABLE_ADVISOR_LINE in instructions
+        else f"{instructions}{INSTRUCTIONS_SEPARATOR}{FABLE_ADVISOR_LINE}"
+    )
+    reshaped_byte_count = len(reshaped_instructions.encode(INSTRUCTIONS_ENCODING))
+    if reshaped_byte_count > INSTRUCTIONS_MAXIMUM_BYTES:
+        raise SpawnNotReshapable(
+            OVER_BYTE_CAP_REASON_TEMPLATE.format(
+                reshaped_byte_count=reshaped_byte_count,
+                maximum_bytes=INSTRUCTIONS_MAXIMUM_BYTES,
+                excess_byte_count=reshaped_byte_count - INSTRUCTIONS_MAXIMUM_BYTES,
+            )
+        )
+    return reshaped_instructions
+
+
+def reshape_thread_spawn(tool_input: object) -> dict[str, object]:
+    """Move a thread spawn to Sonnet at medium effort with a Fable advisor line.
+
+    ::
+
+        {"title": "t", "instructions": "Do X."}
+        -> {"title": "t", "instructions": "Do X.\\n\\nMandatory Fable advisor: ...",
+            "model": "claude-sonnet-5-5", "effort": "medium"}
+
+    An instructions text that already carries the advisor line keeps one copy.
+
+    Args:
+        tool_input: The ``tool_input`` object of the start_thread_session call.
+
+    Raises:
+        SpawnNotReshapable: The input is not an object, has no instructions
+            text, or would pass the server's instructions byte cap.
+    """
+    if not isinstance(tool_input, dict):
+        raise SpawnNotReshapable(NOT_AN_OBJECT_REASON)
+    instructions = tool_input.get(INSTRUCTIONS_INPUT_KEY)
+    if not isinstance(instructions, str):
+        raise SpawnNotReshapable(NO_INSTRUCTIONS_REASON)
+    return {
+        **tool_input,
+        MODEL_INPUT_KEY: THREAD_MODEL_WHEN_OVER_PACE,
+        EFFORT_INPUT_KEY: THREAD_EFFORT_WHEN_OVER_PACE,
+        INSTRUCTIONS_INPUT_KEY: _instructions_with_advisor_line(instructions),
+    }
+
+
+def _hook_output(all_decision_fields: dict[str, object]) -> dict[str, object]:
+    return {
+        HOOK_SPECIFIC_OUTPUT_KEY: {
+            HOOK_EVENT_NAME_KEY: HOOK_EVENT_NAME,
+            **all_decision_fields,
+        }
+    }
+
+
+def _deny_output(reason: str) -> dict[str, object]:
+    return _hook_output(
+        {PERMISSION_DECISION_KEY: PERMISSION_DENY, PERMISSION_DECISION_REASON_KEY: reason}
+    )
+
+
+def decide_hook_output(
+    tool_input: object, pace_exit_code: int, pace_verdict_text: str
+) -> dict[str, object] | None:
+    """Choose the hook's output for one spawn and one pace reading.
+
+    Args:
+        tool_input: The ``tool_input`` of the PreToolUse payload, or None when
+            stdin held no JSON object.
+        pace_exit_code: The usage-pace exit code; anything but under pace
+            counts as over pace.
+        pace_verdict_text: The usage-pace stdout, quoted into the context.
+
+    Returns:
+        None to pass the call through unchanged, else the hook JSON output.
+    """
+    if pace_exit_code == EXIT_CODE_UNDER_PACE:
+        return None
+    try:
+        reshaped_input = reshape_thread_spawn(tool_input)
+    except SpawnNotReshapable as not_reshapable:
+        return _deny_output(str(not_reshapable))
+    verdict_excerpt = pace_verdict_text.strip()[:PACE_VERDICT_CONTEXT_MAXIMUM_CHARACTERS]
+    return _hook_output(
+        {
+            PERMISSION_DECISION_KEY: ALLOW_DECISION,
+            UPDATED_INPUT_KEY: reshaped_input,
+            ADDITIONAL_CONTEXT_KEY: RESHAPE_CONTEXT_PREFIX + verdict_excerpt,
+        }
+    )
+
+
+def run_usage_pace() -> tuple[int, str]:
+    """Run the usage-pace script and return its exit code and stdout.
+
+    Returns:
+        The exit code and stdout. A missing script, a launch failure, or a
+        timeout returns the unreadable exit code.
+    """
+    pace_script = os.environ.get(USAGE_PACE_SCRIPT_ENV_VAR) or str(
+        Path(__file__).resolve().parent / USAGE_PACE_SCRIPT_FILE_NAME
+    )
+    try:
+        completed = subprocess.run(
+            [sys.executable, pace_script],
+            capture_output=True,
+            text=True,
+            timeout=USAGE_PACE_TIMEOUT_SECONDS,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired) as launch_error:
+        return EXIT_CODE_UNREADABLE, json.dumps(
+            {
+                RESULT_KEY_OVER_PACE: None,
+                RESULT_KEY_ERROR: LAUNCH_FAILURE_ERROR_TEMPLATE.format(
+                    failure_type=type(launch_error).__name__
+                ),
+            }
+        )
+    return completed.returncode, completed.stdout
+
+
+def main() -> int:
+    """Read the PreToolUse payload, read the pace, and print the decision.
+
+    Returns:
+        0 in every case; a deny travels in the JSON output.
+    """
+    hook_payload = read_hook_input_dictionary_from_stdin()
+    tool_input = hook_payload.get(TOOL_INPUT_KEY) if hook_payload is not None else None
+    pace_exit_code, pace_verdict_text = run_usage_pace()
+    hook_output = decide_hook_output(tool_input, pace_exit_code, pace_verdict_text)
+    if hook_output is not None:
+        sys.stdout.write(json.dumps(hook_output))
+        sys.stdout.flush()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/hooks/routing/usage_pace.py

@@ -0,0 +1,345 @@
+#!/usr/bin/env python3
+"""Report whether the account running the project spends faster than its windows reset.
+
+::
+
+    python usage_pace.py
+    {"over_pace": true, "checked_at": "2026-09-29T13:57:40+00:00",
+     "windows": [{"window": "five_hour", "used_percent": 3.0,
+                  "elapsed_percent": 2.6, "resets_at": "...", "over_pace": false},
+                 {"window": "seven_day", "used_percent": 93.0,
+                  "elapsed_percent": 39.3, "resets_at": "...", "over_pace": true}]}
+
+A window is over pace when at least 10% of it has elapsed and its used percent
+exceeds the percent already elapsed. The floor keeps a window's first minutes,
+where any spend outruns the clock, from reading as over pace. The account is over pace when any window is. The script reads
+the OAuth usage endpoint with the session ingress bearer token, the same probe
+the usage-pause skill's ``resolve_usage_window.py`` uses. It never prints or
+stores the token.
+
+Exit codes: 0 over pace, 1 under pace, 2 unreadable. ``--payload-file`` and
+``--now`` replace the live probe and the clock for a deterministic run.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import ssl
+import sys
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+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.usage_pace_constants import (
+    ALL_RATE_WINDOW_LENGTHS,
+    ANTHROPIC_BETA_HEADER,
+    AUTHORIZATION_HEADER,
+    BEARER_PREFIX,
+    CONTAINER_PROXY_CA_BUNDLE_PATH,
+    CONTENT_TYPE_HEADER_NAME,
+    CONTENT_TYPE_JSON,
+    EXIT_CODE_OVER_PACE,
+    EXIT_CODE_UNDER_PACE,
+    EXIT_CODE_UNREADABLE,
+    INGRESS_BEARER_FILE_ENV_VAR,
+    ISO_UTC_OFFSET,
+    ISO_UTC_SUFFIX,
+    MINIMUM_ELAPSED_PERCENT_FOR_PACE,
+    PERCENT_DECIMAL_PLACES,
+    PERCENT_SCALE,
+    PROBE_TIMEOUT_SECONDS,
+    RESETS_AT_KEY,
+    RESULT_KEY_CHECKED_AT,
+    RESULT_KEY_ERROR,
+    RESULT_KEY_OVER_PACE,
+    RESULT_KEY_WINDOWS,
+    SSL_CERT_FILE_ENV_VAR,
+    USAGE_BETA_VALUE,
+    USAGE_ENDPOINT_URL,
+    UTILIZATION_KEY,
+    WINDOW_KEY_ELAPSED_PERCENT,
+    WINDOW_KEY_NAME,
+    WINDOW_KEY_OVER_PACE,
+    WINDOW_KEY_RESETS_AT,
+    WINDOW_KEY_USED_PERCENT,
+)
+
+
+class UsageUnreadable(Exception):
+    """The usage meters could not be read, so the pace is unknown."""
+
+
+@dataclass(frozen=True)
+class WindowPace:
+    """One rate window's spend against the time it has run.
+
+    Attributes:
+        name: The usage bucket key, such as ``five_hour``.
+        used_percent: Percent of the window's allowance spent.
+        elapsed_percent: Percent of the window's length already passed.
+        resets_at: When the window resets.
+    """
+
+    name: str
+    used_percent: float
+    elapsed_percent: float
+    resets_at: datetime
+
+    @property
+    def over_pace(self) -> bool:
+        """True when spend runs ahead of the clock past the window's opening stretch.
+
+        ::
+
+            elapsed 2.6%,  used 3.0%   -> False  (under the 10% floor)
+            elapsed 39.3%, used 93.0%  -> True
+            elapsed 39.3%, used 20.0%  -> False
+        """
+        return (
+            self.elapsed_percent >= MINIMUM_ELAPSED_PERCENT_FOR_PACE
+            and self.used_percent > self.elapsed_percent
+        )
+
+
+def _parse_resets_at(raw_resets_at: object, window_name: str) -> datetime:
+    if not isinstance(raw_resets_at, str):
+        raise UsageUnreadable(f"{window_name} has no resets_at time")
+    try:
+        parsed = datetime.fromisoformat(raw_resets_at.replace(ISO_UTC_SUFFIX, ISO_UTC_OFFSET))
+    except ValueError as parse_error:
+        raise UsageUnreadable(f"{window_name} resets_at is unreadable") from parse_error
+    if parsed.tzinfo is None:
+        raise UsageUnreadable(f"{window_name} resets_at carries no time zone")
+    return parsed
+
+
+def _read_utilization(all_bucket_fields: dict[object, object], window_name: str) -> float:
+    raw_utilization = all_bucket_fields.get(UTILIZATION_KEY)
+    if isinstance(raw_utilization, bool) or not isinstance(raw_utilization, (int, float)):
+        raise UsageUnreadable(f"{window_name} has no utilization number")
+    return float(raw_utilization)
+
+
+def _elapsed_percent(window_length: timedelta, resets_at: datetime, now: datetime) -> float:
+    elapsed_fraction = (now - (resets_at - window_length)) / window_length
+    clamped_elapsed_fraction = min(max(elapsed_fraction, 0.0), 1.0)
+    return round(clamped_elapsed_fraction * PERCENT_SCALE, PERCENT_DECIMAL_PLACES)
+
+
+def measure_window_pace(
+    window_name: str, window_length: timedelta, bucket: object, now: datetime
+) -> WindowPace:
+    """Measure one usage bucket's spend against its elapsed time.
+
+    ::
+
+        five_hour, 5h, {"utilization": 3.0, "resets_at": 18:50Z}, now 13:58Z
+        -> WindowPace("five_hour", 3.0, 2.7, 18:50Z)   over pace
+
+    Elapsed time counts from one window length before the reset, clamped to 0-100.
+
+    Args:
+        window_name: The usage bucket key.
+        window_length: How long the window runs.
+        bucket: The bucket object from the usage response.
+        now: The time the pace is measured at.
+
+    Raises:
+        UsageUnreadable: The bucket, its utilization, or its reset is unreadable.
+    """
+    if not isinstance(bucket, dict):
+        raise UsageUnreadable(f"usage response has no {window_name} window")
+    resets_at = _parse_resets_at(bucket.get(RESETS_AT_KEY), window_name)
+    return WindowPace(
+        name=window_name,
+        used_percent=_read_utilization(bucket, window_name),
+        elapsed_percent=_elapsed_percent(window_length, resets_at, now),
+        resets_at=resets_at,
+    )
+
+
+def measure_account_pace(
+    all_usage_buckets: dict[str, object], now: datetime
+) -> list[WindowPace]:
+    """Measure every rate window the verdict covers.
+
+    Args:
+        all_usage_buckets: The decoded usage response body.
+        now: The time the pace is measured at.
+
+    Returns:
+        One WindowPace per rate window, five-hour first.
+
+    Raises:
+        UsageUnreadable: Any covered window is missing or unreadable.
+    """
+    return [
+        measure_window_pace(each_name, each_length, all_usage_buckets.get(each_name), now)
+        for each_name, each_length in ALL_RATE_WINDOW_LENGTHS
+    ]
+
+
+def build_verdict(
+    all_window_paces: list[WindowPace], now: datetime
+) -> dict[str, object]:
+    """Assemble the JSON verdict for a set of measured windows.
+
+    Args:
+        all_window_paces: The measured windows.
+        now: The time the pace was measured at.
+
+    Returns:
+        The verdict mapping: the account-level flag, the check time, and
+        each window's percents, reset time, and flag.
+    """
+    return {
+        RESULT_KEY_OVER_PACE: any(
+            each_pace.over_pace for each_pace in all_window_paces
+        ),
+        RESULT_KEY_CHECKED_AT: now.isoformat(),
+        RESULT_KEY_WINDOWS: [
+            {
+                WINDOW_KEY_NAME: each_pace.name,
+                WINDOW_KEY_USED_PERCENT: each_pace.used_percent,
+                WINDOW_KEY_ELAPSED_PERCENT: each_pace.elapsed_percent,
+                WINDOW_KEY_RESETS_AT: each_pace.resets_at.isoformat(),
+                WINDOW_KEY_OVER_PACE: each_pace.over_pace,
+            }
+            for each_pace in all_window_paces
+        ],
+    }
+
+
+def _read_session_ingress_bearer() -> str:
+    configured_path = os.environ.get(INGRESS_BEARER_FILE_ENV_VAR)
+    if not configured_path:
+        raise UsageUnreadable(f"{INGRESS_BEARER_FILE_ENV_VAR} is unset")
+    try:
+        file_text = Path(configured_path).read_text(encoding="utf-8").strip()
+    except (OSError, UnicodeDecodeError) as read_error:
+        raise UsageUnreadable("session ingress token file is unreadable") from read_error
+    if not file_text:
+        raise UsageUnreadable("session ingress token file is empty")
+    return file_text
+
+
+def _certificate_context() -> ssl.SSLContext:
+    named_bundle = os.environ.get(SSL_CERT_FILE_ENV_VAR)
+    if named_bundle:
+        return ssl.create_default_context(cafile=named_bundle)
+    if Path(CONTAINER_PROXY_CA_BUNDLE_PATH).is_file():
+        return ssl.create_default_context(cafile=CONTAINER_PROXY_CA_BUNDLE_PATH)
+    return ssl.create_default_context()
+
+
+def _build_usage_request() -> urllib.request.Request:
+    return urllib.request.Request(
+        USAGE_ENDPOINT_URL,
+        headers={
+            AUTHORIZATION_HEADER: f"{BEARER_PREFIX}{_read_session_ingress_bearer()}",
+            ANTHROPIC_BETA_HEADER: USAGE_BETA_VALUE,
+            CONTENT_TYPE_HEADER_NAME: CONTENT_TYPE_JSON,
+        },
+    )
+
+
+def fetch_usage_payload() -> dict[str, object]:
+    """Read the usage of the account the session ingress token belongs to.
+
+    Returns:
+        The decoded response body.
+
+    Raises:
+        UsageUnreadable: No token, a failed request, or a body that is not a
+            JSON object. The message names the failure type, never the token.
+    """
+    try:
+        with urllib.request.urlopen(
+            _build_usage_request(),
+            timeout=PROBE_TIMEOUT_SECONDS,
+            context=_certificate_context(),
+        ) as usage_reply:
+            decoded = json.loads(usage_reply.read())
+    except urllib.error.HTTPError as http_error:
+        raise UsageUnreadable(f"usage endpoint answered HTTP {http_error.code}") from http_error
+    except (urllib.error.URLError, TimeoutError, OSError, ValueError) as probe_error:
+        raise UsageUnreadable(
+            f"usage probe failed with {type(probe_error).__name__}"
+        ) from probe_error
+    if not isinstance(decoded, dict):
+        raise UsageUnreadable("usage response body is not a JSON object")
+    return decoded
+
+
+def _read_payload_file(payload_path: str) -> dict[str, object]:
+    try:
+        decoded = json.loads(Path(payload_path).read_text(encoding="utf-8"))
+    except (OSError, ValueError) as read_error:
+        raise UsageUnreadable(
+            f"payload file unreadable: {type(read_error).__name__}"
+        ) from read_error
+    if not isinstance(decoded, dict):
+        raise UsageUnreadable("payload file is not a JSON object")
+    return decoded
+
+
+def _parse_arguments() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Report whether the account running the project spends faster than its windows reset.",
+    )
+    parser.add_argument(
+        "--payload-file",
+        default=None,
+        help="A saved usage response to read instead of probing the endpoint.",
+    )
+    parser.add_argument(
+        "--now",
+        default=None,
+        help="ISO-8601 time with a zone to measure at; defaults to the current time.",
+    )
+    return parser.parse_args()
+
+
+def _measure_verdict(arguments: argparse.Namespace) -> dict[str, object]:
+    now = datetime.fromisoformat(arguments.now) if arguments.now else datetime.now(timezone.utc)
+    if now.tzinfo is None:
+        raise UsageUnreadable("--now carries no time zone")
+    all_usage_buckets = (
+        _read_payload_file(arguments.payload_file)
+        if arguments.payload_file
+        else fetch_usage_payload()
+    )
+    return build_verdict(measure_account_pace(all_usage_buckets, now), now)
+
+
+def _write_json_line(all_document_fields: dict[str, object]) -> None:
+    sys.stdout.write(json.dumps(all_document_fields) + "\n")
+    sys.stdout.flush()
+
+
+def main() -> int:
+    """Print the pace verdict JSON and return its exit code.
+
+    Returns:
+        0 when any window is over pace, 1 when every window is under pace,
+        2 when the meters or the arguments are unreadable.
+    """
+    try:
+        verdict = _measure_verdict(_parse_arguments())
+    except (UsageUnreadable, ValueError) as unreadable:
+        _write_json_line({RESULT_KEY_OVER_PACE: None, RESULT_KEY_ERROR: str(unreadable)})
+        return EXIT_CODE_UNREADABLE
+    _write_json_line(verdict)
+    return EXIT_CODE_OVER_PACE if verdict[RESULT_KEY_OVER_PACE] else EXIT_CODE_UNDER_PACE
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.25.0",
+    "version": "8.26.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/rules/shell-invocation.md

@@ -6,7 +6,7 @@ Two constraints govern every shell command an agent issues: which shell runs it,
 
 Every Bash-tool shell command on Windows uses `pwsh`: `pwsh -NoProfile -File '<script>.ps1' <args>` for scripts, `pwsh -NoProfile -Command "..."` (or a literal `@'...'@` here-string) for inline work, or the built-in `PowerShell` tool for pure-PowerShell workflows (it supports `run_in_background`). Never wrap a script path in `-Command "& '...'"` — `-File` keeps `permissions.allow` matching. The `&` call operator is fine for invoking an executable at a path (`& '<venv>\Scripts\python.exe' script.py`).
 
-The mandate covers the shell a command runs through, not every executable a command names. A direct interpreter invocation another rule documents — the paramiko NAS helper in [`nas-ssh-invocation.md`](nas-ssh-invocation.md), a `python` call on a repo script — conforms as written.
+The mandate covers the shell a command runs through. A direct interpreter invocation, such as a `python` call on a repo script, conforms as written.
 
 Keep `powershell`, `powershell.exe`, `cmd /c`, and `bash -c` out of the `settings.json` permission rules. `Audit-ShellPolicy.ps1` reports those forms and `Migrate-ShellPolicy.ps1` rewrites them to `pwsh`. Both ship in the claude-dev-env repo at `packages/claude-dev-env/scripts/` and run on demand, not as a live gate.
 

package/scripts/dev_env_scripts_constants/grok_worker_constants.py

@@ -87,16 +87,12 @@ ROLE_BUGTEAM: str = "bugteam"
 ROLE_CLEAN_CODER: str = "clean-coder"
 """Compatibility role for FIX and standards-fix using poteto-agent."""
 
-ROLE_TRANSLATOR: str = "translator"
-"""Role the shared_utils translation chain dispatches, served by poteto-agent."""
-
 DEFAULT_ROLE: str = ROLE_BUGTEAM
 """Role applied when the caller does not pass ``--role``."""
 
 ALL_AGENT_FILENAMES_BY_ROLE: dict[str, tuple[str, ...]] = {
     ROLE_BUGTEAM: ("poteto-agent.md",),
     ROLE_CLEAN_CODER: ("poteto-agent.md",),
-    ROLE_TRANSLATOR: ("poteto-agent.md",),
 }
 """Agent definition filenames required under ``agents/`` for each known role."""
 

package/scripts/repository_checks/config/constants.py

@@ -147,10 +147,5 @@ ALL_TRACKED_SECRET_EXACT_EXEMPTIONS: frozenset[tuple[str, str, str]] = frozenset
             "home-path",
             "5d956228802fbd4a65af8fa7fb4183f5a9f8793dbe218877aefe887b905f726d",
         ),
-        (
-            "shared_utils/theme_assets/contracts/evidence/theme_editor_asset_resolution_master.oneui9.v1.json",
-            "home-path",
-            "ec69fe88e2f9d3f1ed3504532c7484120591cbec7ae6fda017b0f9ca57a3fc25",
-        ),
     )
 )

package/scripts/test_resolve_worker_spawn.py

@@ -57,7 +57,6 @@ from dev_env_scripts_constants.grok_worker_constants import (  # noqa: E402
     REASON_GROK_AUTH_FAILED,
     REASON_PROMPT_FILE_MISSING,
     REASON_TIMEOUT_OUT_OF_BOUNDS,
-    ROLE_TRANSLATOR,
     RESULT_KEY_ATTEMPTS,
     RESULT_KEY_OK,
     RESULT_KEY_OUTPUT,
@@ -867,33 +866,6 @@ def test_tier_three_argv_includes_agent_for_default_role(
     )
 
 
-def test_translator_role_dispatches_the_poteto_agent_on_tier_three(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    prompt_file, working_directory, run_state_directory = _paths(tmp_path)
-    call_log = _install_seams(
-        monkeypatch,
-        grok_outcome=_grok_failure(CLASSIFICATION_AUTH_FAILURE),
-        claude_outcome=_claude_served(),
-        host_profile=HOST_PROFILE_CLAUDE,
-    )
-
-    spawn_outcome = dispatcher.resolve_worker_spawn(
-        role=ROLE_TRANSLATOR,
-        prompt_file=prompt_file,
-        working_directory=working_directory,
-        timeout_seconds=DEFAULT_WORKER_TIMEOUT_SECONDS,
-        is_claude_tier_enabled=True,
-        run_state_directory=run_state_directory,
-    )
-
-    assert spawn_outcome.tier_used == TIER_CLAUDE_HEADLESS
-    assert call_log.claude_arguments is not None
-    agent_flag_index = call_log.claude_arguments.index(AGENT_FLAG)
-    assert call_log.claude_arguments[agent_flag_index + 1] == "poteto-agent"
-    assert ROLE_TRANSLATOR not in call_log.claude_arguments
-
-
 def test_large_prompt_stays_out_of_claude_argv(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None: