claude-dev-env 8.78.3 → 8.80.0

package/hooks/hooks_constants/test_shell_command_wrappers.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import base64
+
 import pytest
 
 from hooks_constants import shell_command_wrappers
@@ -31,6 +33,29 @@ def test_should_return_only_the_command_when_no_wrapper_runs() -> None:
     assert shell_command_wrappers.all_wrapped_command_texts("git push") == ["git push"]
 
 
+@pytest.mark.parametrize(
+    "command",
+    [
+        "git push",
+        'bash -c "git add -A && git push"; echo done',
+        "bash -c \"pwsh -Command 'git push; git status'\"",
+        "sudo bash -c 'gh pr list' | head",
+        'echo "$(git push)"',
+        "x=`git push`",
+    ],
+)
+def test_should_return_the_segments_of_every_wrapped_command_text(command: str) -> None:
+    all_segments_from_texts = [
+        each_segment
+        for each_text in shell_command_wrappers.all_wrapped_command_texts(command)
+        for each_segment, _following_operator in (
+            shell_command_wrappers.pipeline_segments_for_command(each_text)
+        )
+    ]
+    all_segments = shell_command_wrappers.all_wrapped_command_segments(command)
+    assert sorted(all_segments) == sorted(all_segments_from_texts)
+
+
 @pytest.mark.parametrize(
     ("all_segment_tokens", "expected_program_and_arguments"),
     [
@@ -50,6 +75,13 @@ def test_should_return_only_the_command_when_no_wrapper_runs() -> None:
         (["time", "sudo", "git", "push"], ("git", ["push"])),
         (["'/usr/bin/git'", "push"], ("git", ["push"])),
         (["VAR=x"], ("", [])),
+        (["if", "git", "push"], ("git", ["push"])),
+        (["then", "git", "push"], ("git", ["push"])),
+        (["if", "!", "git", "push"], ("git", ["push"])),
+        (["while", "git", "push"], ("git", ["push"])),
+        (["command", "git", "push"], ("git", ["push"])),
+        (["command", "-p", "git", "push"], ("git", ["push"])),
+        (["exec", "-a", "name", "git", "push"], ("git", ["push"])),
     ],
 )
 def test_should_return_the_program_past_its_wrappers(
@@ -59,3 +91,96 @@ def test_should_return_the_program_past_its_wrappers(
         shell_command_wrappers.segment_program_and_arguments(all_segment_tokens)
         == expected_program_and_arguments
     )
+
+
+@pytest.mark.parametrize(
+    ("command", "all_expected_texts"),
+    [
+        ('echo "$(gh pr list)"', ["gh pr list"]),
+        ("x=`git push`", ["git push"]),
+        ("echo $(echo $(git push))", ["echo $(git push)"]),
+        ("echo $(cat <(ls))", ["cat <(ls)"]),
+        ("echo \"$(printf ')'; git push)\"", ["printf ')'; git push"]),
+        ('echo $(echo "$(git push)")', ['echo "$(git push)"']),
+        ("x=`echo \\`git push\\``", ["echo `git push`"]),
+        ("echo '$(gh pr list)'", []),
+        ("echo \\$(gh pr list)", []),
+        ("git push", []),
+    ],
+)
+def test_should_return_each_command_substitution_body_outside_single_quotes(
+    command: str, all_expected_texts: list[str]
+) -> None:
+    assert shell_command_wrappers.all_command_substitution_texts(command) == all_expected_texts
+
+
+def test_should_unwrap_a_command_substitution_in_turn() -> None:
+    all_command_texts = shell_command_wrappers.all_wrapped_command_texts(
+        "echo \"$(bash -c 'git push')\""
+    )
+    assert "bash -c 'git push'" in all_command_texts
+    assert "git push" in all_command_texts
+
+
+_ENCODED_GIT_PUSH = base64.b64encode("git push".encode("utf-16-le")).decode()
+
+
+@pytest.mark.parametrize(
+    ("all_segment_tokens", "expected_inner_command"),
+    [
+        (["eval", "git push"], "git push"),
+        (["eval", "git", "push"], "git push"),
+        (["Invoke-Expression", "'git push'"], "git push"),
+        (["iex", '"git push"'], "git push"),
+        (["find", ".", "-exec", "git", "push", ";"], "git push"),
+        (["find", ".", "-execdir", "git", "push", "{}", "+"], "git push {}"),
+        (["pwsh", "-EncodedCommand", _ENCODED_GIT_PUSH], "git push"),
+        (["powershell.exe", "-enc", _ENCODED_GIT_PUSH], "git push"),
+        (["pwsh", "-e", _ENCODED_GIT_PUSH], "git push"),
+        (["pwsh", "-ec", _ENCODED_GIT_PUSH], "git push"),
+        (["pwsh", "-e", "not-base64!"], None),
+        (["find", ".", "-exec", "true", ";", "-exec", "git", "push", ";"], "true ; git push"),
+        (["-exec", "git", "push", "\\"], "git push \\"),
+        (["pwsh", "-e", f"'{_ENCODED_GIT_PUSH[:8]} {_ENCODED_GIT_PUSH[8:]}'"], "git push"),
+        (["Start-Process", "git", "-ArgumentList", "'push'"], "git push"),
+        (
+            ["Start-Process", "-FilePath", "git", "-ArgumentList", "push,origin", "-Wait"],
+            "git push origin",
+        ),
+        (["saps", "git", "-WorkingDirectory", "C:/repo", "-ArgumentList", "push"], "git push"),
+        (["Start-Process", "-FilePath:git", "-ArgumentList:'push'"], "git push"),
+        (["Start-Process", "git", "-WorkingDirectory:C:/repo", "-ArgumentList:push"], "git push"),
+        (["find", ".", "-name", "x"], None),
+        (["git", "push"], None),
+    ],
+)
+def test_should_return_the_command_an_evaluating_program_runs(
+    all_segment_tokens: list[str], expected_inner_command: str | None
+) -> None:
+    assert (
+        shell_command_wrappers.evaluated_inner_command(all_segment_tokens) == expected_inner_command
+    )
+
+
+def test_should_unwrap_an_evaluated_command_in_turn() -> None:
+    assert "git push" in shell_command_wrappers.all_wrapped_command_texts('eval "git push"')
+
+
+def test_should_read_a_quoted_value_that_spans_lines() -> None:
+    command = f'pwsh -EncodedCommand "{_ENCODED_GIT_PUSH[:8]}\n{_ENCODED_GIT_PUSH[8:]}"'
+    assert "git push" in shell_command_wrappers.all_wrapped_command_texts(command)
+
+
+def test_should_stop_unwrapping_past_the_depth_limit_without_error() -> None:
+    nesting_depth = 1000
+    command = "echo " + "$(" * nesting_depth + "git push" + ")" * nesting_depth
+    all_command_texts = shell_command_wrappers.all_wrapped_command_texts(command)
+    assert all_command_texts[0] == command
+    assert len(all_command_texts) <= nesting_depth
+
+
+def test_should_parse_a_repeated_inner_command_once() -> None:
+    all_command_texts = shell_command_wrappers.all_wrapped_command_texts(
+        'bash -c "git push"; bash -c "git push"'
+    )
+    assert all_command_texts.count("git push") == 1

package/hooks/test_conftest.py

@@ -9,7 +9,7 @@ import sys
 from hooks_constants.harness_scratchpad_constants import (
     CLAUDE_SESSION_ID_ENVIRONMENT_VARIABLE_NAME,
 )
-from hooks_constants.headless_claude_broker_gate_constants import CLOUD_SESSION_ENV_VAR
+from hooks_constants.cloud_session_constants import CLOUD_SESSION_ENV_VAR
 
 
 def test_live_session_id_is_absent_inside_each_test() -> None:

package/package.json

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

package/scripts/account_broker.py

@@ -47,6 +47,7 @@ from dev_env_scripts_constants.account_broker_constants import (
     _wait_decision,
     ALL_PARENT_CLAUDE_SESSION_VARIABLES,
     COMMAND_MISSING_EXIT_CODE,
+    PLACEHOLDER_NAME_SLOT,
     REPORT_INDENT_SPACES,
     TIMEOUT_EXIT_CODE,
     WAIT_EXIT_CODE,
@@ -102,6 +103,7 @@ def decision_payload(decision: Decision) -> dict[str, object]:
     return {
         "action": decision.action,
         "account": decision.account.name if decision.account else None,
+        "profile": decision.account.profile if decision.account else None,
         "home": str(decision.account.home) if decision.account else None,
         "reason": decision.reason,
         "tier": decision.tier,
@@ -121,6 +123,7 @@ def readings_payload(all_readings: Sequence[Reading]) -> list[dict[str, object]]
     return [
         {
             "name": each_reading.account.name,
+            "profile": each_reading.account.profile,
             "home": str(each_reading.account.home),
             "is_main": each_reading.account.is_main,
             "priority": each_reading.account.priority,
@@ -150,11 +153,16 @@ def _spent_for_readings(all_readings: Sequence[Reading], all_state: dict[str, ob
     return frozenset(spent), spent
 
 
-def _mark_spent(all_state: dict[str, object], reading: Reading, now: datetime, reset: datetime | None = None) -> datetime:
+def _record_spent(all_state: dict[str, object], reading: Reading, now: datetime, reset: datetime | None = None) -> datetime:
     until = reset or _account_reset(reading, is_spent=True) or now + timedelta(hours=1)
     if until <= now:
         until = now + timedelta(hours=1)
     all_state["spent"][_state_key(reading.account)] = until.timestamp()
+    return until
+
+
+def _mark_spent(all_state: dict[str, object], reading: Reading, now: datetime) -> datetime:
+    until = _record_spent(all_state, reading, now)
     _save_state(broker_state_path(), all_state)
     return until
 
@@ -162,8 +170,7 @@ def _mark_spent(all_state: dict[str, object], reading: Reading, now: datetime, r
 def _outside_roster_resets(product: Product, all_readings: Sequence[Reading], all_state: Mapping[str, object], now: datetime) -> dict[str, datetime]:
     marks = all_state.get("spent") if isinstance(all_state.get("spent"), dict) else {}
     all_roster_names = {each_reading.account.name for each_reading in all_readings}
-    prefix = f"{product.value}:"
-    placeholder_suffix = f":{Path()}"
+    prefix, _, placeholder_suffix = _state_key(Account(product, PLACEHOLDER_NAME_SLOT, Path(), False)).partition(PLACEHOLDER_NAME_SLOT)
     all_resets_by_name = {}
     for each_key, each_raw in marks.items():
         if not (isinstance(each_key, str) and each_key.startswith(prefix) and each_key.endswith(placeholder_suffix)):
@@ -376,25 +383,30 @@ def _parse_spent_mark(all_accounts_by_name: Mapping[str, Reading], mark: str, pr
     try:
         reset = datetime.fromtimestamp(float(reset_text), timezone.utc) if separator else None
     except (ValueError, OSError, OverflowError) as error:
-        raise BrokerConfigurationError(f"invalid reset for account {name}") from error
+        raise BrokerConfigurationError(f"invalid reset in spent mark {mark!r}") from error
     reading = all_accounts_by_name.get(name)
     if reading is None:
-        if all_accounts_by_name or name != NO_ROSTER_ACCOUNT_NAME:
-            print(f"warning: spent mark names {name}, an account outside the roster; choose waits until its reset", file=sys.stderr)
         return Reading(Account(product, name, Path(), False), None), reset
     return reading, reset
 
 
 def _save_spent_arguments(all_marks: Sequence[str], all_readings: Sequence[Reading], all_state: dict[str, object], now: datetime, product: Product) -> None:
-    all_accounts_by_name = {each_reading.account.name: each_reading for each_reading in all_readings}
-    for each_mark in all_marks:
-        reading, reset = _parse_spent_mark(all_accounts_by_name, each_mark, product)
-        _mark_spent(all_state, reading, now, reset)
+    all_accounts_by_profile = {each_reading.account.profile: each_reading for each_reading in all_readings if each_reading.account.profile}
+    all_accounts_by_name = all_accounts_by_profile | {each_reading.account.name: each_reading for each_reading in all_readings}
+    all_parsed_marks = [_parse_spent_mark(all_accounts_by_name, each_mark, product) for each_mark in all_marks]
+    for each_reading, each_reset in all_parsed_marks:
+        _record_spent(all_state, each_reading, now, each_reset)
+    if all_parsed_marks:
+        _save_state(broker_state_path(), all_state)
+    for each_reading, _ in all_parsed_marks:
+        name = each_reading.account.name
+        if name not in all_accounts_by_name and (all_accounts_by_name or name != NO_ROSTER_ACCOUNT_NAME):
+            print(f"warning: spent mark names {name}, an account outside the roster; choose waits until its reset", file=sys.stderr)
 
 
 def _accounts_cli(product: Product) -> int:
     roster = all_product_adapters[product].load_accounts()
-    print(json.dumps({"accounts": [{"name": each_account.name, "home": str(each_account.home), "is_main": each_account.is_main} for each_account in roster]}))
+    print(json.dumps({"accounts": [{"name": each_account.name, "profile": each_account.profile, "home": str(each_account.home), "is_main": each_account.is_main} for each_account in roster]}))
     return 0
 
 

package/scripts/account_broker_support.py

@@ -43,9 +43,6 @@ from dev_env_scripts_constants.account_broker_constants import (
     JobOutcome,
     LOGIN_REFRESH_TIMEOUT_SECONDS,
     METER_READ_ATTEMPTS,
-    METER_READ_DELAY_FACTOR,
-    METER_READ_FIRST_DELAY_SECONDS,
-    METER_READ_MAX_DELAY_SECONDS,
     Meters,
     Product,
     ProductAdapter,
@@ -54,6 +51,7 @@ from dev_env_scripts_constants.account_broker_constants import (
     REPORT_INDENT_SPACES,
     SubprocessRunner,
     codex_usage_limit_signatures,
+    meter_read_delay_seconds,
     parse_utc_time,
     utc_time_text,
 )
@@ -70,7 +68,6 @@ from dev_env_scripts_constants.codex_account_constants import (
     CODEX_ACCOUNT_LAUNCHERS_FILE_NAME,
     CODEX_ACCOUNT_PROFILES_ENVIRONMENT_VARIABLE,
     CODEX_HOME_ENVIRONMENT_VARIABLE,
-    WEEKLY_WINDOW_MINUTES,
 )
 from dev_env_scripts_constants.shared_tree_constants import CLAUDE_CONFIG_DIR_ENV_VAR
 from shared_tree_paths import resolve_shared_process_tree_scripts_directory
@@ -105,7 +102,7 @@ def _chain_entry(raw_entry: object, main_home: Path, chain_path: Path) -> Accoun
     if not isinstance(extra_args, list) or any(not isinstance(each_arg, str) for each_arg in extra_args):
         raise BrokerConfigurationError(f"invalid account list {chain_path}")
     home = Path(credential).expanduser().parent.resolve() if credential else main_home
-    return Account(Product.CLAUDE, command, home, command=command)
+    return Account(Product.CLAUDE, command, home, command=command, profile=_home_profile(home))
 
 
 def _chain_entries(chain_path: Path, main_home: Path) -> tuple[Account, ...]:
@@ -169,11 +166,20 @@ def _with_priorities(all_accounts: Sequence[Account], all_ordered_names: Sequenc
     return tuple(dataclasses.replace(each_account, priority=priority_of(each_account)) for each_account in all_accounts)
 
 
+def _home_profile(home: Path) -> str | None:
+    try:
+        profile_home = default_profile_home(home.name).resolve()
+    except ValueError:
+        return None
+    return home.name if profile_home == home else None
+
+
 def load_claude_accounts() -> tuple[Account, ...]:
     """Read the Claude account roster.
 
     Returns:
-        Main and additional accounts in configured order, each with its place in the account order file.
+        Main and additional accounts in configured order, each with its place in the account order file
+        and, for a home under the profiles root, its profile name.
 
     Raises:
         BrokerConfigurationError: An account list is unreadable.
@@ -185,7 +191,8 @@ def load_claude_accounts() -> tuple[Account, ...]:
         _append_claude_account(all_accounts, all_seen, each_entry, main_home)
     for each_home in _extra_homes(main_home):
         home = each_home.resolve()
-        _append_claude_account(all_accounts, all_seen, Account(Product.CLAUDE, home.name, home, command=home.name), main_home)
+        extra_account = Account(Product.CLAUDE, home.name, home, command=home.name, profile=_home_profile(home))
+        _append_claude_account(all_accounts, all_seen, extra_account, main_home)
     return _with_priorities(all_accounts, _account_order(main_home))
 
 
@@ -293,14 +300,13 @@ def read_codex_account_meters(account: Account) -> Meters:
 
     Raises:
         CodexMeterUnreadError: The meter read failed.
-        OSError: No Codex executable was found.
+        CodexExecutableNotFoundError: No Codex executable was found, so
+            read_meters_with_backoff stops without a retry.
     """
     codex_path = codex_account_meters.resolve_codex_path(None)
     usage = codex_account_meters.read_codex_meters(codex_path, account.home)
-    weekly = [window for window in usage.all_windows if window.duration_minutes is None or window.duration_minutes >= WEEKLY_WINDOW_MINUTES]
-    short = [window for window in usage.all_windows if window.duration_minutes is not None and window.duration_minutes < WEEKLY_WINDOW_MINUTES]
-    weekly_window = max(weekly, key=lambda window: window.used_percent) if weekly else None
-    short_window = max(short, key=lambda window: window.used_percent) if short else None
+    short_window = usage.short_window
+    weekly_window = usage.weekly_window
     return Meters(
         usage.short_window_percent_left,
         short_window.resets_at if short_window else None,
@@ -318,14 +324,17 @@ def read_meters_with_backoff(read_meters: Callable[[Account], Meters | None], ac
 
     Returns:
         The meters from the first read that succeeds, or None with the last
-        failure text once every attempt failed.
+        failure text once every attempt failed. A missing Codex executable
+        fails at once, without a retry.
     """
     unread_reason = None
     for each_attempt in range(METER_READ_ATTEMPTS):
         if each_attempt:
-            time.sleep(min(METER_READ_FIRST_DELAY_SECONDS * METER_READ_DELAY_FACTOR ** (each_attempt - 1), METER_READ_MAX_DELAY_SECONDS))
+            time.sleep(meter_read_delay_seconds(each_attempt))
         try:
             return read_meters(account), None
+        except codex_account_meters.CodexExecutableNotFoundError as error:
+            return None, str(error)
         except (
             codex_account_meters.CodexMeterUnreadError,
             WeeklyUtilizationProbeError,

package/scripts/codex_account_meters.py

@@ -3,14 +3,17 @@
 
 Codex reports usage through ``codex app-server`` and the JSON-RPC method
 ``account/rateLimits/read``. The reply names up to two windows, a short one
-(5 hours) and a weekly one. The account's room is the smaller of the two::
+(5 hours) and a weekly one. The account broker counts the account's room as
+the smaller of the two::
 
     5-hour window 30% used, week 85% used  -> 15% left
     week window only, 40% used             -> 60% left
     no window, error reply, no reply       -> CodexMeterUnreadError
 
-Every failure raises ``CodexMeterUnreadError``. The caller decides what an
-unread account means; this module never guesses a number.
+Every read failure raises ``CodexMeterUnreadError``. A missing Codex
+executable raises ``CodexExecutableNotFoundError`` from ``resolve_codex_path``.
+The caller decides what an unread account means; this module never guesses a
+number.
 """
 
 from __future__ import annotations
@@ -69,6 +72,10 @@ class CodexMeterUnreadError(Exception):
     """Raised when one account's rate-limit windows cannot be read."""
 
 
+class CodexExecutableNotFoundError(FileNotFoundError):
+    """Raised when no Codex executable is on PATH or at its install path."""
+
+
 @dataclass(frozen=True)
 class UsageWindow:
     """One rate-limit window: its length, the percent used, and when it resets."""
@@ -77,56 +84,36 @@ class UsageWindow:
     used_percent: float
     resets_at: datetime | None
 
+    @property
+    def is_short(self) -> bool:
+        """Whether the window reports a length shorter than a week. A window with no length counts as weekly."""
+        return self.duration_minutes is not None and self.duration_minutes < WEEKLY_WINDOW_MINUTES
+
 
 @dataclass(frozen=True)
 class CodexAccountMeters:
-    """One account's windows, with percent_left, short_window_percent_left and resets_before_room."""
+    """One account's windows, with its tightest short window and its tightest weekly window."""
 
     all_windows: tuple[UsageWindow, ...]
 
     @property
-    def percent_left(self) -> float:
-        """Room left in the tightest window, from 0 to 100."""
-        most_used = max(each_window.used_percent for each_window in self.all_windows)
-        return max(0.0, FULL_PERCENT - most_used)
+    def short_window(self) -> UsageWindow | None:
+        """The most used window shorter than a week, or None when the account has none."""
+        all_short_windows = [each_window for each_window in self.all_windows if each_window.is_short]
+        return max(all_short_windows, key=lambda each_window: each_window.used_percent, default=None)
+
+    @property
+    def weekly_window(self) -> UsageWindow | None:
+        """The most used window of a week or of no reported length, or None when the account has none."""
+        all_weekly_windows = [each_window for each_window in self.all_windows if not each_window.is_short]
+        return max(all_weekly_windows, key=lambda each_window: each_window.used_percent, default=None)
 
     @property
     def short_window_percent_left(self) -> float | None:
         """Room left in the windows shorter than a week, or None when the account has none."""
-        all_short_used = [
-            each_window.used_percent
-            for each_window in self.all_windows
-            if each_window.duration_minutes is not None
-            and each_window.duration_minutes < WEEKLY_WINDOW_MINUTES
-        ]
-        if not all_short_used:
-            return None
-        return max(0.0, FULL_PERCENT - max(all_short_used))
-
-    def resets_before_room(self, minimum_percent_left: float) -> datetime | None:
-        """When every window that holds the account at or under a bar has reset.
-
-        Args:
-            minimum_percent_left: The percent left the account must pass.
-
-        Returns:
-            The latest reset among the blocking windows, or None when one
-            carries no reset time or none blocks.
-        """
-        all_blocking = [
-            each_window
-            for each_window in self.all_windows
-            if FULL_PERCENT - each_window.used_percent <= minimum_percent_left
-        ]
-        if not all_blocking or any(
-            each_window.resets_at is None for each_window in all_blocking
-        ):
+        if self.short_window is None:
             return None
-        return max(
-            each_window.resets_at
-            for each_window in all_blocking
-            if each_window.resets_at is not None
-        )
+        return FULL_PERCENT - self.short_window.used_percent
 
 
 def _finite_number(raw_number: object) -> float | None:
@@ -396,7 +383,7 @@ def resolve_codex_path(explicit_path: Path | None) -> Path:
         The named path, else ``codex`` on PATH, else a known install path.
 
     Raises:
-        FileNotFoundError: No Codex executable was found.
+        CodexExecutableNotFoundError: No Codex executable was found.
     """
     if explicit_path is not None:
         return explicit_path
@@ -407,4 +394,4 @@ def resolve_codex_path(explicit_path: Path | None) -> Path:
         candidate = Path.home().joinpath(*each_parts)
         if candidate.is_file():
             return candidate
-    raise FileNotFoundError("no codex executable on PATH or at its install path")
+    raise CodexExecutableNotFoundError("no codex executable on PATH or at its install path")

package/scripts/conftest.py

@@ -18,7 +18,9 @@ is in place by the time any test module runs its top-level imports.
 from __future__ import annotations
 
 import importlib
+import subprocess
 import sys
+from collections.abc import Callable
 from pathlib import Path
 
 import pytest
@@ -52,3 +54,26 @@ def isolated_broker_state_path(monkeypatch: pytest.MonkeyPatch, tmp_path: Path)
         if getattr(each_module, "broker_state_path", None) is _live_broker_state_resolver:
             monkeypatch.setattr(each_module, "broker_state_path", lambda: isolated_path)
     return isolated_path
+
+
+def _link_directory(*, from_link: Path, to_target: Path) -> None:
+    try:
+        importlib.import_module("claude_account_profile")._link_directory(to_target, from_link)
+    except subprocess.CalledProcessError as error:
+        link_output = (error.stderr or error.stdout or b"").decode(errors="replace").strip()
+        pytest.fail(f"directory link {from_link} -> {to_target} failed: {link_output}")
+    except OSError as error:
+        pytest.fail(f"directory link {from_link} -> {to_target} failed: {error}")
+
+
+@pytest.fixture
+def create_directory_link() -> Callable[..., None]:
+    """Return a helper that points a new directory link at a target folder.
+
+    Windows gets a junction, which needs no extra rights. Other systems get a
+    symlink. A link that cannot be made fails the test on either system.
+
+    Returns:
+        The helper, called as ``create_directory_link(from_link=..., to_target=...)``.
+    """
+    return _link_directory

package/scripts/dev_env_scripts_constants/account_broker_constants.py

@@ -56,6 +56,7 @@ WAIT_EXIT_CODE = 3
 COMMAND_MISSING_EXIT_CODE = 127
 TIMEOUT_EXIT_CODE = 124
 REPORT_INDENT_SPACES = 2
+PLACEHOLDER_NAME_SLOT = "{name}"
 BROKER_STATE_DIRECTORY_NAME = "account-broker"
 BROKER_STATE_FILE_NAME = "state.json"
 BROKER_STATE_TEMP_SUFFIX = ".json"
@@ -111,6 +112,11 @@ def codex_usage_limit_signatures() -> tuple[str, ...]:
     return module.ALL_USAGE_LIMIT_MARKERS
 
 
+def meter_read_delay_seconds(attempt_index: int) -> float:
+    """Seconds to wait before a meter read retry, where the first retry has index 1."""
+    return min(METER_READ_FIRST_DELAY_SECONDS * METER_READ_DELAY_FACTOR ** (attempt_index - 1), METER_READ_MAX_DELAY_SECONDS)
+
+
 def utc_time_text(moment: datetime | None) -> str | None:
     return moment.astimezone(timezone.utc).isoformat() if moment is not None else None
 
@@ -150,6 +156,7 @@ class Account:
     is_main: bool = False
     command: str | None = None
     priority: int | None = None
+    profile: str | None = field(default=None, compare=False)
 
 
 @dataclass(frozen=True)
@@ -215,16 +222,26 @@ class ProductAdapter:
     usage_limit_signatures: tuple[str, ...]
 
 
+def _is_at_or_under(room: float | None, floor: float) -> bool:
+    return room is not None and room <= floor
+
+
+def _claude_blocking_flags(meters: Meters, is_main: bool) -> tuple[bool, bool]:
+    session_key, weekly_key = (
+        ("main_session_used_ceiling", "main_weekly_used_ceiling")
+        if is_main
+        else ("extra_session_used_ceiling", "extra_weekly_used_ceiling")
+    )
+    return (
+        _is_at_or_under(meters.session_percent_left, FULL_PERCENT - ALL_CLAUDE_FLOORS[session_key]),
+        _is_at_or_under(meters.weekly_percent_left, FULL_PERCENT - ALL_CLAUDE_FLOORS[weekly_key]),
+    )
+
+
 def _claude_extra_tier(meters: Meters | None) -> str | None:
     if meters is None or meters.tightest_percent_left is None:
         return None
-    if (
-        meters.weekly_percent_left is not None
-        and meters.weekly_percent_left <= FULL_PERCENT - ALL_CLAUDE_FLOORS["extra_weekly_used_ceiling"]
-    ) or (
-        meters.session_percent_left is not None
-        and meters.session_percent_left <= FULL_PERCENT - ALL_CLAUDE_FLOORS["extra_session_used_ceiling"]
-    ):
+    if any(_claude_blocking_flags(meters, is_main=False)):
         return None
     return "normal"
 
@@ -251,24 +268,19 @@ def _account_reset(reading: Reading, is_spent: bool = False) -> datetime | None:
         return None
     if is_spent:
         return min((reset for reset in (meters.session_resets_at, meters.weekly_resets_at) if reset is not None), default=None)
-    is_claude_main = reading.account.product is Product.CLAUDE and reading.account.is_main
-    if is_claude_main:
-        blocking = (
-            (meters.session_percent_left, FULL_PERCENT - ALL_CLAUDE_FLOORS["main_session_used_ceiling"], meters.session_resets_at),
-            (meters.weekly_percent_left, FULL_PERCENT - ALL_CLAUDE_FLOORS["main_weekly_used_ceiling"], meters.weekly_resets_at),
-        )
-    elif reading.account.product is Product.CLAUDE:
-        blocking = (
-            (meters.session_percent_left, FULL_PERCENT - ALL_CLAUDE_FLOORS["extra_session_used_ceiling"], meters.session_resets_at),
-            (meters.weekly_percent_left, FULL_PERCENT - ALL_CLAUDE_FLOORS["extra_weekly_used_ceiling"], meters.weekly_resets_at),
-        )
+    if reading.account.product is Product.CLAUDE:
+        all_blocking_flags = _claude_blocking_flags(meters, reading.account.is_main)
     else:
-        blocking = (
-            (meters.session_percent_left, ALL_CODEX_FLOORS["luna_short_minimum_left"], meters.session_resets_at),
-            (meters.weekly_percent_left, ALL_CODEX_FLOORS["luna_stop_left"], meters.weekly_resets_at),
+        all_blocking_flags = (
+            meters.session_percent_left is not None and meters.session_percent_left < ALL_CODEX_FLOORS["luna_short_minimum_left"],
+            _is_at_or_under(meters.weekly_percent_left, ALL_CODEX_FLOORS["luna_stop_left"]),
         )
-    all_blocking_resets = [reset for room, floor, reset in blocking if room is not None and room <= floor and reset is not None]
-    return max(all_blocking_resets, default=None)
+    all_resets = (meters.session_resets_at, meters.weekly_resets_at)
+    all_blocking_resets = [reset for is_blocking, reset in zip(all_blocking_flags, all_resets) if is_blocking]
+    all_known_resets = [reset for reset in all_blocking_resets if reset is not None]
+    if len(all_known_resets) < len(all_blocking_resets):
+        return None
+    return max(all_known_resets, default=None)
 
 
 def _rank_key(reading: Reading) -> tuple[bool, int, float]:
@@ -282,8 +294,7 @@ def _main_has_room(meters: Meters | None) -> bool:
         meters is not None
         and meters.session_percent_left is not None
         and meters.weekly_percent_left is not None
-        and meters.session_percent_left > FULL_PERCENT - ALL_CLAUDE_FLOORS["main_session_used_ceiling"]
-        and meters.weekly_percent_left > FULL_PERCENT - ALL_CLAUDE_FLOORS["main_weekly_used_ceiling"]
+        and not any(_claude_blocking_flags(meters, is_main=True))
     )
 
 

package/scripts/dev_env_scripts_constants/claude_account_constants.py

@@ -181,15 +181,6 @@ REASON_ALL_EXTRAS_WAIT_TEMPLATE: str = (
 )
 """Reason when every configured extra profile is blocked."""
 
-REASON_WAIT_TEMPLATE: str = (
-    "second account is at {weekly_used_percent:.0f}% of its week"
-    " and {session_used_percent:.0f}% of its 5-hour window; next reset {next_reset}"
-)
-"""Reason when neither account has room."""
-
-UNKNOWN_RESET_TEXT: str = "unknown"
-"""Reset text when the blocking meter carries no reset time."""
-
 JSON_ACCOUNT_KEY: str = "account"
 """Picker JSON key naming the chosen account."""