claude-dev-env 8.46.0 → 8.46.2

package/docs/account-broker.md

@@ -27,6 +27,7 @@ The broker stores cached meters, spent marks, and Claude session bindings in one
 | `0` | `choose` or `check` found an account, or the job exited successfully. |
 | `3` | No account clears its floor. The decision includes `resets_at`. |
 | `4` | A Claude job stopped with `advisor_blocked`. |
+| `127` | A Codex job timed out, or its command could not start while no Codex roster is configured. |
 | Other command code | `run` returns the command's exit code after a served response. |
 
 `run` writes a JSON report with `product`, `command`, `events`, and `final_decision`. A wait report has `final_decision.action` equal to `wait` and a UTC `final_decision.resets_at`.

package/package.json

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

package/scripts/account_broker.py

@@ -263,7 +263,8 @@ def _attempt_once(context: _RunContext, decision: Decision) -> JobOutcome | None
         _record_spent_attempt(context, account, status, COMMAND_MISSING_EXIT_CODE)
         if isinstance(error, subprocess.TimeoutExpired) or not context.all_readings:
             context.report.final_decision = decision
-            return JobOutcome(COMMAND_MISSING_EXIT_CODE, "", str(error), account.name, tuple(context.all_attempts), "advisor_blocked", None, None)
+            final_status = "advisor_blocked" if context.product is Product.CLAUDE else status
+            return JobOutcome(COMMAND_MISSING_EXIT_CODE, "", str(error), account.name, tuple(context.all_attempts), final_status, None, None)
         return None
     combined = f"{completion.stdout}{completion.stderr}".casefold()
     is_limited = completion.returncode != 0 and any(

package/scripts/test_account_broker.py

@@ -435,13 +435,44 @@ def test_should_stop_after_timeout_without_running_job_again(
 
     assert invoked_homes == ["first"]
     assert outcome.attempts == (("first", "timeout"),)
-    assert outcome.status == "advisor_blocked"
+    assert outcome.status == "timeout"
     assert outcome.account_name == "first"
     assert report.final_decision.account.name == "first"
     assert account_broker.main(("choose", "--product", "codex")) == 0
     assert json.loads(capsys.readouterr().out)["decision"]["account"] == "first"
 
 
+@pytest.mark.parametrize(
+    ("product", "roster_names", "start_error", "expected_code"),
+    (
+        (Product.CLAUDE, ("first",), subprocess.TimeoutExpired("job", 1), 4),
+        (Product.CODEX, ("first",), subprocess.TimeoutExpired("job", 1), 127),
+        (Product.CODEX, (), OSError("missing command"), 127),
+    ),
+)
+def test_should_exit_four_only_for_a_blocked_claude_job(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    product: Product,
+    roster_names: tuple[str, ...],
+    start_error: Exception,
+    expected_code: int,
+) -> None:
+    accounts = tuple(_account(each_name, product) for each_name in roster_names)
+    monkeypatch.setitem(account_broker.all_product_adapters, product, _adapter(accounts, {
+        each_name: _meters(80, 80) for each_name in roster_names
+    }))
+    monkeypatch.setattr(account_broker.sys, "stdin", io.TextIOWrapper(io.BytesIO(b""), encoding="utf-8"))
+
+    def runner(argv: object, **options: object) -> subprocess.CompletedProcess[str]:
+        raise start_error
+
+    with account_broker.override_subprocess_runner(runner):
+        code = account_broker.main(("run", "--product", product.value, "--report", str(tmp_path / "report.json"), "--", "job"))
+
+    assert code == expected_code
+
+
 def test_should_keep_usage_limited_account_spent_for_later_choices(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ) -> None:

package/scripts/tests/test_code_rules_index.py

@@ -3,11 +3,12 @@
 from __future__ import annotations
 
 import ast
-import os
 import re
 from collections import Counter
 from pathlib import Path
 
+import pytest
+
 
 _PACKAGE_ROOT = Path(__file__).resolve().parents[2]
 _REPOSITORY_ROOT = _PACKAGE_ROOT.parent.parent
@@ -118,28 +119,31 @@ def _collect_citation_texts() -> list[tuple[Path, str]]:
 
 def test_should_resolve_code_rules_anchors_and_sections() -> None:
     index_text = _INDEX_PATH.read_text(encoding="utf-8")
-    all_citations = _collect_citation_texts()
-    injected_anchor = os.environ.get("CODE_RULES_INDEX_TEST_ANCHOR")
-    if injected_anchor:
-        all_citations.append((_INDEX_PATH, "CODE_RULES.md" + "#" + injected_anchor))
-    _assert_citations_resolve(index_text, all_citations)
+    _assert_citations_resolve(index_text, _collect_citation_texts())
+
+
+def test_should_report_dead_code_rules_anchor() -> None:
+    index_text = _INDEX_PATH.read_text(encoding="utf-8")
+    dead_citation = (_INDEX_PATH, "CODE_RULES.md" + "#no-such-heading")
+    with pytest.raises(AssertionError, match="dead CODE_RULES anchor #no-such-heading"):
+        _assert_citations_resolve(index_text, [dead_citation])
 
 
-def _assert_destination_resolves(family_path: Path, destination: str) -> None:
+def _assert_destination_resolves(markdown_path: Path, destination: str) -> None:
     if "://" in destination or destination.startswith("#"):
         return
     path_text, _, anchor_text = destination.partition("#")
-    destination_path = family_path.parent / path_text
-    assert destination_path.is_file(), f"{family_path}: {destination}"
+    destination_path = markdown_path.parent / path_text
+    assert destination_path.is_file(), f"{markdown_path}: {destination}"
     if anchor_text:
         destination_text = destination_path.read_text(encoding="utf-8")
         assert anchor_text in _heading_slugs(destination_text), (
-            f"{family_path}: {destination}"
+            f"{markdown_path}: {destination}"
         )
 
 
-def test_should_resolve_every_family_relative_link() -> None:
-    for each_family_path in _FAMILY_DIRECTORY.glob("*.md"):
-        family_text = each_family_path.read_text(encoding="utf-8")
-        for each_destination in _MARKDOWN_LINK.findall(family_text):
-            _assert_destination_resolves(each_family_path, each_destination)
+def test_should_resolve_every_index_and_family_relative_link() -> None:
+    for each_markdown_path in [_INDEX_PATH, *_FAMILY_DIRECTORY.glob("*.md")]:
+        markdown_text = each_markdown_path.read_text(encoding="utf-8")
+        for each_destination in _MARKDOWN_LINK.findall(markdown_text):
+            _assert_destination_resolves(each_markdown_path, each_destination)