claude-dev-env 8.43.5 → 8.43.6

package/scripts/invoke_code_review.py

@@ -7,14 +7,14 @@ Mode decision::
     host=Claude, session_model=sonnet -> mode chain (headless opus spawn)
     host=ThirdParty, any model        -> mode chain
 
-Chain mode runs ``run_claude`` with argv from ``build_code_review_arguments``
+Chain mode runs the account broker with argv from ``build_code_review_arguments``
 (single-turn prompt, model opus, json output, and the permission mode this
 caller is allowed to ask the review binary for).
 
 cwd is the PR working tree and stdin is redirected from the empty stream so
 the spawn does not wait for interactive input. Result JSON on stdout only::
 
-    {"mode", "served_command", "returncode", "dirty_tree"}
+    {"mode", "served_command", "returncode", "dirty_tree", "status", "wait_reset_at"}
 
 Import ``invoke_code_review`` for the outcome object, or run as a CLI::
 
@@ -29,7 +29,7 @@ import json
 import os
 import subprocess
 import sys
-from collections.abc import Callable, Sequence
+from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -58,16 +58,13 @@ from tier_model_ids import detect_host_profile  # noqa: E402
 from advisor_scripts_constants.model_tier_run_validator_constants import (  # noqa: E402
     HOST_PROFILE_CLAUDE,
 )
-import claude_chain_runner as chain_runner  # noqa: E402
-from claude_chain_runner import (  # noqa: E402
-    ChainConfigurationError,
-    ChainInvocationOutcome,
-    run_claude,
-)
-from dev_env_scripts_constants.claude_chain_constants import (  # noqa: E402
-    CHAIN_CONFIG_ERROR_EXIT_CODE,
-    collect_forwarded_text_codec,
+from account_broker import run_job
+from dev_env_scripts_constants.account_broker_constants import (
+    BrokerConfigurationError,
+    JobOutcome,
+    Product,
 )
+from dev_env_scripts_constants.claude_chain_constants import CHAIN_CONFIG_ERROR_EXIT_CODE
 from dev_env_scripts_constants.code_review_constants import (  # noqa: E402
     ALL_EFFORT_TOKENS_IN_ASCENDING_ORDER,
     CLI_EFFORT_HELP,
@@ -116,7 +113,7 @@ class CodeReviewOutcome:
 
     ``mode`` is ``in_session`` when the skill should run the slash command
     itself, or ``chain`` when a headless spawn already ran. ``served_command``
-    names the chain binary that served a chain run, or ``None`` otherwise.
+    names the broker account that served a chain run, or ``None`` otherwise.
     ``is_dirty_tree`` is True when ``git status --porcelain`` is non-empty
     after a chain run (fixes applied).
     """
@@ -125,9 +122,11 @@ class CodeReviewOutcome:
     served_command: str | None
     returncode: int
     is_dirty_tree: bool
+    status: str | None = None
+    wait_reset_at: str | None = None
 
 
-review_claude_runner = run_claude
+review_claude_runner = run_job
 review_host_profile_detector = detect_host_profile
 review_git_status_runner = subprocess.run
 
@@ -198,7 +197,7 @@ def build_code_review_prompt(effort: str) -> str:
 def build_code_review_arguments(
     effort: str = DEFAULT_CODE_REVIEW_EFFORT,
 ) -> list[str]:
-    """Return the argv tokens passed to ``run_claude`` for a chain review.
+    """Return the argv tokens passed to the account broker for a review.
 
     ::
 
@@ -308,41 +307,16 @@ def _run_claude_with_empty_stdin(
     *,
     timeout_seconds: int,
     working_directory: Path,
-) -> ChainInvocationOutcome:
-    working_directory_path = str(working_directory)
-
-    def _runner_with_empty_stdin(
-        all_invocation_tokens: Sequence[str],
-        *all_positionals: object,
-        **all_keywords: object,
-    ) -> subprocess.CompletedProcess[str]:
-        del all_positionals
-        maybe_timeout = all_keywords.get("timeout")
-        timeout_for_run: float | None
-        if isinstance(maybe_timeout, (int, float)):
-            timeout_for_run = float(maybe_timeout)
-        else:
-            timeout_for_run = None
-        forwarded_text_codec = collect_forwarded_text_codec(all_keywords)
-        completed_process: subprocess.CompletedProcess[str] = previous_runner(
-            all_invocation_tokens,
-            capture_output=True,
-            text=True,
-            timeout=timeout_for_run,
-            check=False,
-            stdin=subprocess.DEVNULL,
-            cwd=working_directory_path,
-            **forwarded_text_codec,
-        )
-        return completed_process
-
-    empty_stdin_runner: TextCapturingSubprocessRunner = _runner_with_empty_stdin
-    with chain_runner.override_chain_subprocess_runner(
-        empty_stdin_runner
-    ) as previous_runner:
-        return review_claude_runner(
-            all_claude_arguments, timeout_seconds=timeout_seconds
-        )
+) -> JobOutcome:
+    return review_claude_runner(
+        Product.CLAUDE,
+        ["claude", *all_claude_arguments],
+        timeout_seconds=timeout_seconds,
+        stdin_text="",
+        cwd=working_directory,
+        encoding="utf-8",
+        errors="replace",
+    )
 
 
 def _in_session_outcome() -> CodeReviewOutcome:
@@ -355,15 +329,17 @@ def _in_session_outcome() -> CodeReviewOutcome:
 
 
 def _chain_outcome(
-    chain_outcome: ChainInvocationOutcome,
+    chain_outcome: JobOutcome,
     *,
     working_directory: Path,
 ) -> CodeReviewOutcome:
     return CodeReviewOutcome(
         mode=MODE_CHAIN,
-        served_command=chain_outcome.served_command,
+        served_command=chain_outcome.account_name,
         returncode=chain_outcome.returncode,
-        is_dirty_tree=is_working_tree_dirty(working_directory),
+        is_dirty_tree=is_working_tree_dirty(working_directory) if chain_outcome.account_name else False,
+        status=chain_outcome.status,
+        wait_reset_at=chain_outcome.wait_reset_at.isoformat() if chain_outcome.wait_reset_at else None,
     )
 
 
@@ -410,7 +386,7 @@ def invoke_code_review(
     Args:
         working_directory: PR working tree used as cwd for the chain spawn.
         session_model: Caller-stated session model short alias.
-        timeout_seconds: Timeout applied to each chain binary invocation.
+        timeout_seconds: Timeout applied to the broker job.
         effort: Effort token embedded in the ``/code-review`` prompt.
 
     Returns:
@@ -447,6 +423,8 @@ def encode_code_review_outcome(
         RESULT_KEY_SERVED_COMMAND: review_outcome.served_command,
         RESULT_KEY_RETURNCODE: review_outcome.returncode,
         RESULT_KEY_DIRTY_TREE: review_outcome.is_dirty_tree,
+        "status": review_outcome.status,
+        "wait_reset_at": review_outcome.wait_reset_at,
     }
 
 
@@ -469,7 +447,7 @@ def _add_review_arguments(parser: argparse.ArgumentParser) -> None:
         dest="timeout_seconds",
         type=int,
         default=DEFAULT_CODE_REVIEW_TIMEOUT_SECONDS,
-        help="Timeout in seconds applied to each chain binary invocation.",
+        help="Timeout in seconds applied to the broker job.",
     )
 
 
@@ -509,7 +487,7 @@ def _run_plain_review_cli(*, parsed_arguments: argparse.Namespace, effort: str)
             timeout_seconds=parsed_arguments.timeout_seconds,
             effort=effort,
         )
-    except ChainConfigurationError:
+    except BrokerConfigurationError:
         review_outcome = _failure_code_review_outcome(CHAIN_CONFIG_ERROR_EXIT_CODE)
     except ValueError:
         review_outcome = _failure_code_review_outcome(HOST_PROFILE_ERROR_RETURNCODE)

package/scripts/resolve_worker_spawn.py

@@ -9,7 +9,7 @@ Walk order:
    On a Claude host with the claude tier disabled, stop with
    ``claude_agent_required`` so the calling skill runs the Agent tool.
    On a third-party host, or when the claude tier is enabled, tier 3 runs
-   ``claude_chain_runner.run_claude`` with ``-p --output-format json --agent
+   the account broker with ``-p --output-format json --agent
    <stem>``, prompt body on stdin from the prompt file, and subprocess
    ``cwd`` set to the caller's working directory.
 
@@ -27,10 +27,9 @@ import json
 import os
 import subprocess
 import sys
-from collections.abc import Callable, Sequence
+from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
-from typing import IO
 
 _scripts_directory_path = Path(__file__).resolve().parent
 _scripts_directory = str(_scripts_directory_path)
@@ -57,14 +56,12 @@ from tier_model_ids import detect_host_profile  # noqa: E402
 from advisor_scripts_constants.model_tier_run_validator_constants import (  # noqa: E402
     HOST_PROFILE_CLAUDE,
 )
-import claude_chain_runner as chain_runner  # noqa: E402
-from claude_chain_runner import (  # noqa: E402
-    ChainConfigurationError,
-    ChainInvocationOutcome,
-    run_claude,
-)
-from dev_env_scripts_constants.claude_chain_constants import (  # noqa: E402
-    collect_forwarded_text_codec,
+from account_broker import run_job
+from dev_env_scripts_constants.account_broker_constants import (
+    BrokerConfigurationError,
+    JobOutcome,
+    Product,
+    WAIT_EXIT_CODE,
 )
 from dev_env_scripts_constants.grok_worker_constants import (  # noqa: E402
     AGENT_FLAG,
@@ -136,20 +133,16 @@ class SpawnOutcome:
     captured_stdout: str
     returncode: int
     is_config_error: bool = False
+    status: str | None = None
+    wait_reset_at: str | None = None
 
 
 spawn_preflight_runner = run_preflight
 spawn_grok_runner = run_headless_worker
-spawn_claude_runner = run_claude
+spawn_claude_runner = run_job
 spawn_host_profile_detector = detect_host_profile
 
 
-TextCapturingSubprocessRunner = Callable[
-    ...,
-    subprocess.CompletedProcess[str],
-]
-
-
 def _attempt(tier: int, *, is_ok: bool, reason: str | None) -> SpawnAttempt:
     return SpawnAttempt(tier=tier, is_ok=is_ok, reason=reason)
 
@@ -173,51 +166,22 @@ def _build_claude_arguments(*, agent_name: str) -> list[str]:
     ]
 
 
-def _timeout_seconds_from_keywords(
-    all_keywords: dict[str, object],
-) -> float | None:
-    maybe_timeout = all_keywords.get("timeout")
-    if isinstance(maybe_timeout, (int, float)):
-        return float(maybe_timeout)
-    return None
-
-
 def _run_claude_with_headless_overrides(
     all_claude_arguments: list[str],
     *,
     timeout_seconds: int,
     working_directory: Path,
-    prompt_stdin: IO[str],
-) -> ChainInvocationOutcome:
-    working_directory_path = str(working_directory)
-
-    def _runner_with_headless_overrides(
-        all_invocation_tokens: Sequence[str],
-        *all_positionals: object,
-        **all_keywords: object,
-    ) -> subprocess.CompletedProcess[str]:
-        del all_positionals
-        prompt_stdin.seek(0)
-        forwarded_text_codec = collect_forwarded_text_codec(all_keywords)
-        completed_process: subprocess.CompletedProcess[str] = previous_runner(
-            all_invocation_tokens,
-            capture_output=True,
-            text=True,
-            timeout=_timeout_seconds_from_keywords(all_keywords),
-            check=False,
-            stdin=prompt_stdin,
-            cwd=working_directory_path,
-            **forwarded_text_codec,
-        )
-        return completed_process
-
-    headless_runner: TextCapturingSubprocessRunner = _runner_with_headless_overrides
-    with chain_runner.override_chain_subprocess_runner(
-        headless_runner
-    ) as previous_runner:
-        return spawn_claude_runner(
-            all_claude_arguments, timeout_seconds=timeout_seconds
-        )
+    prompt_text: str,
+) -> JobOutcome:
+    return spawn_claude_runner(
+        Product.CLAUDE,
+        ["claude", *all_claude_arguments],
+        timeout_seconds=timeout_seconds,
+        stdin_text=prompt_text,
+        cwd=working_directory,
+        encoding="utf-8",
+        errors="replace",
+    )
 
 
 def _prompt_file_unreadable_outcome(
@@ -261,9 +225,9 @@ def _claude_agent_required_outcome(
 
 def _served_claude_outcome(
     all_attempts: list[SpawnAttempt],
-    chain_outcome: ChainInvocationOutcome,
+    chain_outcome: JobOutcome,
 ) -> SpawnOutcome:
-    is_served = chain_outcome.served_command is not None
+    is_served = chain_outcome.account_name is not None
     is_ok = is_served and chain_outcome.returncode == SPAWN_SERVED_EXIT_CODE
     all_attempts.append(_attempt(TIER_CLAUDE_HEADLESS, is_ok=is_ok, reason=None))
     if not is_served:
@@ -273,6 +237,8 @@ def _served_claude_outcome(
             all_attempts=tuple(all_attempts),
             captured_stdout=chain_outcome.stdout,
             returncode=chain_outcome.returncode,
+            status=chain_outcome.status,
+            wait_reset_at=chain_outcome.wait_reset_at.isoformat() if chain_outcome.wait_reset_at else None,
         )
     return SpawnOutcome(
         tier_used=TIER_CLAUDE_HEADLESS,
@@ -280,6 +246,7 @@ def _served_claude_outcome(
         all_attempts=tuple(all_attempts),
         captured_stdout=chain_outcome.stdout,
         returncode=chain_outcome.returncode,
+        status=chain_outcome.status,
     )
 
 
@@ -293,18 +260,15 @@ def _run_tier_claude_headless(
 ) -> SpawnOutcome:
     all_claude_arguments = _build_claude_arguments(agent_name=agent_name)
     try:
-        prompt_stdin = prompt_file.open(encoding=UTF8_ENCODING)
+        prompt_text = prompt_file.read_text(encoding=UTF8_ENCODING)
     except OSError:
         return _prompt_file_unreadable_outcome(all_attempts)
-    try:
-        chain_outcome = _run_claude_with_headless_overrides(
-            all_claude_arguments,
-            timeout_seconds=timeout_seconds,
-            working_directory=working_directory,
-            prompt_stdin=prompt_stdin,
-        )
-    finally:
-        prompt_stdin.close()
+    chain_outcome = _run_claude_with_headless_overrides(
+        all_claude_arguments,
+        timeout_seconds=timeout_seconds,
+        working_directory=working_directory,
+        prompt_text=prompt_text,
+    )
     return _served_claude_outcome(all_attempts, chain_outcome)
 
 
@@ -505,6 +469,8 @@ def encode_spawn_outcome(spawn_outcome: SpawnOutcome) -> dict[str, object]:
         RESULT_KEY_ATTEMPTS: all_encoded_attempts,
         RESULT_KEY_OUTPUT: spawn_outcome.captured_stdout,
         RESULT_KEY_RETURNCODE: spawn_outcome.returncode,
+        "status": spawn_outcome.status,
+        "wait_reset_at": spawn_outcome.wait_reset_at,
     }
 
 
@@ -568,6 +534,8 @@ def _exit_code_for_outcome(
 ) -> int:
     if is_config_error or spawn_outcome.is_config_error:
         return SPAWN_CONFIG_ERROR_EXIT_CODE
+    if spawn_outcome.status in {"wait", "exhausted"}:
+        return WAIT_EXIT_CODE
     if spawn_outcome.tier_used is None:
         return SPAWN_EXHAUSTED_EXIT_CODE
     return SPAWN_SERVED_EXIT_CODE
@@ -639,7 +607,7 @@ def main(all_command_arguments: list[str]) -> int:
 
     A timeout outside the accepted bounds is a config fault: the run prints a
     structured outcome whose attempt reason is ``timeout_out_of_bounds`` and
-    exits ``3``, rather than raising out of the CLI. A chain misconfiguration,
+    exits ``3``, rather than raising out of the CLI. A broker configuration error,
     or an unknown host profile refused by ``detect_host_profile``, prints the
     same exit code with the refusal text as its output.
 
@@ -672,7 +640,7 @@ def main(all_command_arguments: list[str]) -> int:
     except WorkerTimeoutOutOfBoundsError as bounds_error:
         is_config_error = True
         spawn_outcome = _timeout_out_of_bounds_outcome(bounds_error)
-    except (ChainConfigurationError, ValueError) as configuration_error:
+    except (BrokerConfigurationError, ValueError) as configuration_error:
         is_config_error = True
         spawn_outcome = _config_error_outcome(configuration_error)
     return _write_spawn_outcome_and_exit_code(

package/scripts/test_account_broker_guard.py

@@ -7,10 +7,6 @@ from pathlib import Path
 SCRIPTS = Path(__file__).resolve().parent
 ALLOWED_LEGACY_MODULES = frozenset(
     {
-        "claude_account_choice.py",
-        "claude_account_worker.py",
-        "claude_chain_runner.py",
-        "claude_chain_usage.py",
         "codex_account_choice.py",
         "codex_account_meters.py",
     }