claude-dev-env 8.15.0 → 8.16.0

package/scripts/test_claude_account_choice.py

@@ -30,7 +30,7 @@ def meters(
 
 
 class TestChooseAccount:
-    def should_pick_main_in_jons_example(self) -> None:
+    def test_should_pick_main_when_week_resets_soon(self) -> None:
         main_meters = meters(
             session_used=10.0, weekly_used=80.0, weekly_resets_in=timedelta(hours=5)
         )
@@ -42,7 +42,7 @@ class TestChooseAccount:
         )
         assert decision.account == choice.CHOICE_MAIN
 
-    def should_pick_second_when_main_week_resets_later_than_a_day(self) -> None:
+    def test_should_pick_second_when_main_week_resets_later_than_a_day(self) -> None:
         main_meters = meters(
             session_used=0.0, weekly_used=5.0, weekly_resets_in=timedelta(hours=30)
         )
@@ -54,7 +54,7 @@ class TestChooseAccount:
         )
         assert decision.account == choice.CHOICE_SECOND
 
-    def should_keep_main_once_it_nears_its_weekly_ceiling(self) -> None:
+    def test_should_keep_main_once_it_nears_its_weekly_ceiling(self) -> None:
         main_meters = meters(
             session_used=0.0, weekly_used=90.0, weekly_resets_in=timedelta(hours=3)
         )
@@ -66,7 +66,7 @@ class TestChooseAccount:
         )
         assert decision.account == choice.CHOICE_SECOND
 
-    def should_keep_main_when_its_five_hour_window_is_half_spent(self) -> None:
+    def test_should_keep_main_when_its_five_hour_window_is_half_spent(self) -> None:
         main_meters = meters(
             session_used=50.0, weekly_used=20.0, weekly_resets_in=timedelta(hours=3)
         )
@@ -78,7 +78,7 @@ class TestChooseAccount:
         )
         assert decision.account == choice.CHOICE_SECOND
 
-    def should_never_pick_main_when_its_meter_is_unread(self) -> None:
+    def test_should_never_pick_main_when_its_meter_is_unread(self) -> None:
         second_meters = meters(
             session_used=95.0, weekly_used=99.0, weekly_resets_in=timedelta(days=4)
         )
@@ -87,7 +87,7 @@ class TestChooseAccount:
         )
         assert decision.account == choice.CHOICE_WAIT
 
-    def should_never_pick_main_when_its_reset_time_is_missing(self) -> None:
+    def test_should_never_pick_main_when_its_reset_time_is_missing(self) -> None:
         main_meters = meters(session_used=0.0, weekly_used=0.0, weekly_resets_in=None)
         second_meters = meters(
             session_used=95.0, weekly_used=99.0, weekly_resets_in=timedelta(days=4)
@@ -97,12 +97,12 @@ class TestChooseAccount:
         )
         assert decision.account == choice.CHOICE_WAIT
 
-    def should_pick_second_when_its_meter_is_unread(self) -> None:
+    def test_should_pick_second_when_its_meter_is_unread(self) -> None:
         decision = choice.choose_account(main_meters=None, second_meters=None, now=NOW)
         assert decision.account == choice.CHOICE_SECOND
         assert decision.reason == choice.REASON_SECOND_UNREAD
 
-    def should_wait_and_name_the_session_reset_when_the_five_hour_window_blocks(
+    def test_should_wait_and_name_the_session_reset_when_the_five_hour_window_blocks(
         self,
     ) -> None:
         second_meters = meters(
@@ -117,7 +117,7 @@ class TestChooseAccount:
         assert decision.account == choice.CHOICE_WAIT
         assert (NOW + timedelta(hours=1)).isoformat() in decision.reason
 
-    def should_wait_and_name_the_weekly_reset_when_the_week_blocks(self) -> None:
+    def test_should_wait_and_name_the_weekly_reset_when_the_week_blocks(self) -> None:
         second_meters = meters(
             session_used=10.0, weekly_used=95.0, weekly_resets_in=timedelta(days=2)
         )
@@ -129,7 +129,7 @@ class TestChooseAccount:
 
 
 class TestReadAccountMeters:
-    def should_return_none_when_the_probe_cannot_read_the_account(
+    def test_should_return_none_when_the_probe_cannot_read_the_account(
         self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
     ) -> None:
         def failing_probe(credentials_path: Path) -> AccountUsageMeters:
@@ -138,7 +138,7 @@ class TestReadAccountMeters:
         monkeypatch.setattr(choice, "probe_account_meters", failing_probe)
         assert choice.read_account_meters(tmp_path / ".credentials.json") is None
 
-    def should_return_the_probed_meters(
+    def test_should_return_the_probed_meters(
         self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
     ) -> None:
         probed = meters(
@@ -149,7 +149,7 @@ class TestReadAccountMeters:
 
 
 class TestDecisionPayload:
-    def should_name_no_config_directory_for_a_wait(self) -> None:
+    def test_should_name_no_config_directory_for_a_wait(self) -> None:
         decision = choice.AccountDecision(account=choice.CHOICE_WAIT, reason="full")
         assert choice.decision_payload(decision, config_directory=None) == {
             "account": "wait",
@@ -159,10 +159,10 @@ class TestDecisionPayload:
 
 
 class TestMetersPayload:
-    def should_name_no_meters_for_an_unread_account(self) -> None:
+    def test_should_name_no_meters_for_an_unread_account(self) -> None:
         assert choice.meters_payload(None) is None
 
-    def should_carry_each_used_percent_and_reset_time(self) -> None:
+    def test_should_carry_each_used_percent_and_reset_time(self) -> None:
         read_meters = meters(
             session_used=12.0,
             weekly_used=34.0,
@@ -176,7 +176,7 @@ class TestMetersPayload:
             "weekly_resets_at": "2026-09-25T21:00:00+00:00",
         }
 
-    def should_name_no_reset_time_the_meter_left_out(self) -> None:
+    def test_should_name_no_reset_time_the_meter_left_out(self) -> None:
         read_meters = meters(session_used=1.0, weekly_used=None, weekly_resets_in=None)
         payload = choice.meters_payload(read_meters)
         assert payload is not None
@@ -185,7 +185,7 @@ class TestMetersPayload:
 
 
 class TestMain:
-    def should_print_the_choice_and_the_config_directory_of_the_chosen_account(
+    def test_should_print_the_choice_and_the_config_directory_of_the_chosen_account(
         self,
         tmp_path: Path,
         monkeypatch: pytest.MonkeyPatch,
@@ -219,7 +219,7 @@ class TestMain:
         assert printed["meters"]["main"] is None
         assert printed["meters"]["second"]["weekly_used_percent"] == 10.0
 
-    def should_print_no_config_directory_when_the_job_waits(
+    def test_should_print_no_config_directory_when_the_job_waits(
         self,
         tmp_path: Path,
         monkeypatch: pytest.MonkeyPatch,
@@ -243,3 +243,113 @@ class TestMain:
         assert exit_code == 0
         assert printed["account"] == choice.CHOICE_WAIT
         assert printed["config_dir"] is None
+
+
+def test_should_pick_second_extra_in_order_and_print_every_meter(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    main_home = tmp_path / "main"
+    first_extra = tmp_path / "first"
+    second_extra = tmp_path / "next"
+    third_extra = tmp_path / "last"
+    readings = {
+        main_home: None,
+        first_extra: meters(
+            session_used=90.0, weekly_used=95.0, weekly_resets_in=timedelta(days=4)
+        ),
+        second_extra: meters(
+            session_used=10.0, weekly_used=20.0, weekly_resets_in=timedelta(days=4)
+        ),
+        third_extra: meters(
+            session_used=30.0, weekly_used=40.0, weekly_resets_in=timedelta(days=4)
+        ),
+    }
+    monkeypatch.setattr(
+        choice, "read_account_meters", lambda path: readings[path.parent]
+    )
+
+    assert choice.main(
+        [
+            "--main-config-dir",
+            str(main_home),
+            "--second-config-dir",
+            str(first_extra),
+            "--extra-config-dir",
+            str(second_extra),
+            "--extra-config-dir",
+            str(third_extra),
+        ]
+    ) == 0
+    printed = json.loads(capsys.readouterr().out)
+
+    assert printed["account"] == "extra_2"
+    assert printed["config_dir"] == str(second_extra)
+    assert list(printed["meters"]) == ["main", "second", "extra_2", "extra_3"]
+    assert printed["meters"]["main"] is None
+    assert printed["meters"]["second"]["weekly_used_percent"] == 95.0
+    assert printed["meters"]["extra_2"]["weekly_used_percent"] == 20.0
+    assert printed["meters"]["extra_3"]["weekly_used_percent"] == 40.0
+
+
+def test_should_wait_for_first_usable_reset_when_all_extras_are_full(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    first_extra = tmp_path / "first"
+    second_extra = tmp_path / "next"
+    third_extra = tmp_path / "last"
+    readings = {
+        first_extra: meters(
+            session_used=90.0,
+            weekly_used=95.0,
+            weekly_resets_in=timedelta(hours=1),
+            session_resets_in=timedelta(hours=3),
+        ),
+        second_extra: meters(
+            session_used=10.0, weekly_used=95.0, weekly_resets_in=timedelta(hours=2)
+        ),
+        third_extra: meters(
+            session_used=90.0, weekly_used=10.0, weekly_resets_in=timedelta(days=4),
+            session_resets_in=timedelta(hours=4),
+        ),
+    }
+    monkeypatch.setattr(
+        choice, "read_account_meters", lambda path: readings.get(path.parent)
+    )
+
+    assert choice.main(
+        [
+            "--main-config-dir",
+            str(tmp_path / "main"),
+            "--second-config-dir",
+            str(first_extra),
+            "--extra-config-dir",
+            str(second_extra),
+            "--extra-config-dir",
+            str(third_extra),
+        ]
+    ) == 0
+    printed = json.loads(capsys.readouterr().out)
+
+    assert printed["account"] == choice.CHOICE_WAIT
+    assert printed["config_dir"] is None
+    assert (NOW + timedelta(hours=2)).isoformat() in printed["reason"]
+    assert (NOW + timedelta(hours=1)).isoformat() not in printed["reason"]
+    assert list(printed["meters"]) == ["main", "second", "extra_2", "extra_3"]
+
+
+def test_should_reject_duplicate_extra_config_directories(tmp_path: Path) -> None:
+    with pytest.raises(SystemExit) as error:
+        choice.main(
+            [
+                "--second-config-dir",
+                str(tmp_path / "first"),
+                "--extra-config-dir",
+                str(tmp_path / "first"),
+            ]
+        )
+
+    assert error.value.code == 2

package/scripts/test_claude_account_profile.py

@@ -32,13 +32,13 @@ def sync(main_home: Path, profile_home: Path) -> profile.ProfileSyncReport:
 
 
 class TestDefaultProfileHome:
-    def should_use_the_profiles_root_the_environment_names(
+    def test_should_use_the_profiles_root_the_environment_names(
         self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
     ) -> None:
         monkeypatch.setenv("LLM_SETTINGS_PROFILES_ROOT", str(tmp_path))
         assert profile.default_profile_home() == tmp_path / "ev"
 
-    def should_fall_back_to_the_profiles_root_in_the_user_home(
+    def test_should_fall_back_to_the_profiles_root_in_the_user_home(
         self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
     ) -> None:
         monkeypatch.delenv("LLM_SETTINGS_PROFILES_ROOT", raising=False)
@@ -47,23 +47,24 @@ class TestDefaultProfileHome:
 
 
 class TestIsAccountLocal:
-    def should_keep_sign_in_state_and_history_local(self) -> None:
+    def test_should_keep_sign_in_state_and_history_local(self) -> None:
         for each_name in (
             ".credentials.json",
             ".credentials.json.bak-session-dashboard",
             ".claude.json",
             ".claude.json.backup",
+            "extra-profiles.json",
             "projects",
         ):
             assert profile.is_account_local(each_name)
 
-    def should_share_skills_rules_and_settings(self) -> None:
+    def test_should_share_skills_rules_and_settings(self) -> None:
         for each_name in ("skills", "rules", "CLAUDE.md", "settings.json", "plugins"):
             assert not profile.is_account_local(each_name)
 
 
 class TestSyncProfile:
-    def should_link_every_shared_entry_to_the_main_home(self, tmp_path: Path) -> None:
+    def test_should_link_every_shared_entry_to_the_main_home(self, tmp_path: Path) -> None:
         main_home = build_main_home(tmp_path)
         profile_home = tmp_path / "ev"
         sync(main_home, profile_home)
@@ -76,7 +77,7 @@ class TestSyncProfile:
             profile_home / "settings.json", main_home / "settings.json"
         )
 
-    def should_link_only_what_the_callers_rule_shares(self, tmp_path: Path) -> None:
+    def test_should_link_only_what_the_callers_rule_shares(self, tmp_path: Path) -> None:
         main_home = build_main_home(tmp_path)
         profile_home = tmp_path / "codex-1"
         report = profile.sync_profile(
@@ -88,7 +89,7 @@ class TestSyncProfile:
         assert report.all_linked == ("rules",)
         assert not (profile_home / "skills").exists()
 
-    def should_keep_the_accounts_own_sign_in_state_and_history_apart(
+    def test_should_keep_the_accounts_own_sign_in_state_and_history_apart(
         self, tmp_path: Path
     ) -> None:
         main_home = build_main_home(tmp_path)
@@ -105,7 +106,7 @@ class TestSyncProfile:
         assert not (profile_home / ".claude.json.backup").exists()
         assert not (profile_home / "projects").exists()
 
-    def should_move_a_stale_copy_aside_and_keep_its_content(
+    def test_should_move_a_stale_copy_aside_and_keep_its_content(
         self, tmp_path: Path
     ) -> None:
         main_home = build_main_home(tmp_path)
@@ -120,7 +121,7 @@ class TestSyncProfile:
         assert profile.links_to(profile_home / "CLAUDE.md", main_home / "CLAUDE.md")
         assert report.all_moved_aside == ("CLAUDE.md",)
 
-    def should_remove_a_same_content_copy_without_moving_it_aside(
+    def test_should_remove_a_same_content_copy_without_moving_it_aside(
         self, tmp_path: Path
     ) -> None:
         main_home = build_main_home(tmp_path)
@@ -132,7 +133,7 @@ class TestSyncProfile:
         assert not (profile_home / ".replaced").exists()
         assert profile.links_to(profile_home / "CLAUDE.md", main_home / "CLAUDE.md")
 
-    def should_move_aside_a_link_that_points_somewhere_else(
+    def test_should_move_aside_a_link_that_points_somewhere_else(
         self, tmp_path: Path
     ) -> None:
         main_home = build_main_home(tmp_path)
@@ -147,7 +148,7 @@ class TestSyncProfile:
         assert profile.links_to(profile_home / "rules", main_home / "rules")
         assert report.all_moved_aside == ("rules",)
 
-    def should_change_nothing_on_a_second_run(self, tmp_path: Path) -> None:
+    def test_should_change_nothing_on_a_second_run(self, tmp_path: Path) -> None:
         main_home = build_main_home(tmp_path)
         profile_home = tmp_path / "ev"
         sync(main_home, profile_home)
@@ -156,7 +157,7 @@ class TestSyncProfile:
         assert second_report.all_moved_aside == ()
         assert second_report.all_unlinked == ()
 
-    def should_unlink_an_entry_the_main_home_no_longer_has(
+    def test_should_unlink_an_entry_the_main_home_no_longer_has(
         self, tmp_path: Path
     ) -> None:
         main_home = build_main_home(tmp_path)
@@ -168,7 +169,7 @@ class TestSyncProfile:
         assert report.all_unlinked == ("rules",)
 
 
-    def should_remove_a_main_link_left_under_an_account_local_name(
+    def test_should_remove_a_main_link_left_under_an_account_local_name(
         self, tmp_path: Path
     ) -> None:
         main_home = build_main_home(tmp_path)
@@ -185,7 +186,7 @@ class TestSyncProfile:
 
 
 class TestWriteLauncher:
-    def should_point_claude_at_the_profile_and_pass_every_argument(
+    def test_should_point_claude_at_the_profile_and_pass_every_argument(
         self, tmp_path: Path
     ) -> None:
         profile_home = tmp_path / "ev"
@@ -196,7 +197,7 @@ class TestWriteLauncher:
         assert f'set "CLAUDE_CONFIG_DIR={profile_home}"' in launcher_text
         assert "claude %*" in launcher_text
 
-    def should_move_an_older_launcher_aside(self, tmp_path: Path) -> None:
+    def test_should_move_an_older_launcher_aside(self, tmp_path: Path) -> None:
         launcher_directory = tmp_path / "bin"
         launcher_directory.mkdir()
         (launcher_directory / "claude-ev.cmd").write_text(
@@ -212,7 +213,7 @@ class TestWriteLauncher:
 
 
 class TestMain:
-    def should_print_what_the_sync_changed(
+    def test_should_print_what_the_sync_changed(
         self, tmp_path: Path, capsys: pytest.CaptureFixture[str]
     ) -> None:
         main_home = build_main_home(tmp_path)
@@ -230,3 +231,49 @@ class TestMain:
         assert exit_code == 0
         assert "CLAUDE.md" in printed["linked"]
         assert printed["launcher"] == str(tmp_path / "bin" / "claude-ev.cmd")
+
+
+def test_should_create_named_profile_and_launcher_without_changes_on_repeat(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    main_home = build_main_home(tmp_path)
+    (main_home / "extra-profiles.json").write_text("[]", encoding="utf-8")
+    profiles_root = tmp_path / "profiles"
+    launcher_directory = tmp_path / "bin"
+    monkeypatch.setenv("LLM_SETTINGS_PROFILES_ROOT", str(profiles_root))
+    arguments = [
+        "--main-home",
+        str(main_home),
+        "--profile-name",
+        "profile-3",
+        "--launcher-directory",
+        str(launcher_directory),
+    ]
+
+    assert profile.main(arguments) == 0
+    first_report = json.loads(capsys.readouterr().out)
+    profile_home = profiles_root / "profile-3"
+    launcher_path = launcher_directory / "claude-profile-3.cmd"
+    assert profile.links_to(profile_home / "CLAUDE.md", main_home / "CLAUDE.md")
+    assert not (profile_home / "extra-profiles.json").exists()
+    assert first_report["launcher"] == str(launcher_path)
+    assert f'set "CLAUDE_CONFIG_DIR={profile_home}"' in launcher_path.read_text(
+        encoding="utf-8"
+    )
+
+    assert profile.main(arguments) == 0
+    second_report = json.loads(capsys.readouterr().out)
+    assert second_report["linked"] == []
+    assert second_report["moved_aside"] == []
+    assert second_report["unlinked"] == []
+    assert list(launcher_directory.glob("*.replaced-*")) == []
+
+
+@pytest.mark.parametrize(
+    "profile_name", ["../outside", "bad name", "CON", "main", "wait"]
+)
+def test_should_reject_unsafe_profile_names(profile_name: str) -> None:
+    with pytest.raises(ValueError):
+        profile.default_profile_home(profile_name)

package/scripts/test_claude_account_worker.py

@@ -3,12 +3,15 @@ from __future__ import annotations
 import json
 import subprocess
 from collections.abc import Callable
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any
 
 import pytest
 
+import claude_account_choice
 import claude_account_worker
+from claude_chain_usage import AccountUsageMeters
 from claude_account_worker import (
     AccountSelection,
     WorkerDependencies,
@@ -26,6 +29,8 @@ from dev_env_scripts_constants.claude_account_worker_constants import (
     WAIT_EXIT_CODE,
 )
 
+NOW = datetime(2026, 9, 22, 21, 0, tzinfo=timezone.utc)
+
 
 class FakeProcess:
     def __init__(
@@ -319,6 +324,119 @@ def test_should_pick_second_account_when_neither_meter_is_readable(
     assert selection.config_dir == second_home
 
 
+def test_should_read_profile_list_and_pick_later_extra(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    main_home = tmp_path / ".claude"
+    main_home.mkdir()
+    (main_home / "extra-profiles.json").write_text(
+        json.dumps(["profile_a", "profile_b"]), encoding="utf-8"
+    )
+    profiles_root = tmp_path / "profiles"
+    monkeypatch.setattr(Path, "home", lambda: tmp_path)
+    monkeypatch.setenv("LLM_SETTINGS_PROFILES_ROOT", str(profiles_root))
+    readings = {
+        profiles_root / "profile_a": AccountUsageMeters(
+            session_utilization=90.0,
+            session_resets_at=NOW + timedelta(hours=2),
+            weekly_utilization=95.0,
+            weekly_resets_at=NOW + timedelta(days=2),
+        ),
+        profiles_root / "profile_b": AccountUsageMeters(
+            session_utilization=10.0,
+            session_resets_at=NOW + timedelta(hours=2),
+            weekly_utilization=20.0,
+            weekly_resets_at=NOW + timedelta(days=2),
+        ),
+    }
+
+    def read_meters(path: Path) -> AccountUsageMeters | None:
+        return readings.get(path.parent)
+
+    monkeypatch.setattr(claude_account_choice, "read_account_meters", read_meters)
+    monkeypatch.setattr(claude_account_worker, "read_account_meters", read_meters)
+
+    selection = select_account()
+
+    assert selection.account == "extra_2"
+    assert selection.config_dir == profiles_root / "profile_b"
+
+
+def test_should_exit_three_when_every_listed_profile_is_full(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    main_home = tmp_path / ".claude"
+    main_home.mkdir()
+    (main_home / "extra-profiles.json").write_text(
+        json.dumps(["profile_a", "profile_b"]), encoding="utf-8"
+    )
+    monkeypatch.setattr(Path, "home", lambda: tmp_path)
+    monkeypatch.setenv("LLM_SETTINGS_PROFILES_ROOT", str(tmp_path / "profiles"))
+    blocked = AccountUsageMeters(
+        session_utilization=90.0,
+        session_resets_at=NOW + timedelta(hours=2),
+        weekly_utilization=95.0,
+        weekly_resets_at=NOW + timedelta(days=2),
+    )
+
+    def read_meters(path: Path) -> AccountUsageMeters | None:
+        return None if path.parent == main_home else blocked
+
+    monkeypatch.setattr(claude_account_choice, "read_account_meters", read_meters)
+    monkeypatch.setattr(claude_account_worker, "read_account_meters", read_meters)
+    report_file = tmp_path / "report.json"
+
+    exit_code = run_worker(
+        prompt_file=tmp_path / "unused.md",
+        cwd=tmp_path,
+        report_file=report_file,
+        model=None,
+        permission_mode="auto",
+        timeout_minutes=60,
+        decision_selector=select_account,
+        dependencies=WorkerDependencies(
+            process_factory=lambda *args, **kwargs: (_ for _ in ()).throw(
+                AssertionError("wait must not start a process")
+            ),
+            all_parent_environment_variables={},
+            binary_resolver=lambda _: None,
+            process_terminator=lambda _: None,
+            monotonic_clock=lambda: 1.0,
+        ),
+    )
+    report = json.loads(report_file.read_text(encoding="utf-8"))
+
+    assert exit_code == WAIT_EXIT_CODE
+    assert report["account"] == CHOICE_WAIT
+    assert (NOW + timedelta(days=2)).isoformat() in report["reason"]
+
+
+def test_should_set_later_extra_profile_environment(tmp_path: Path) -> None:
+    profile_dir = tmp_path / "profile_b"
+    exit_code, report, captured = _run_worker(
+        tmp_path,
+        selection=_selection("extra_2", config_dir=profile_dir),
+        process=FakeProcess(),
+    )
+
+    assert exit_code == 0
+    assert report["account"] == "extra_2"
+    assert captured["env"][CLAUDE_CONFIG_DIR_ENV_VAR] == str(profile_dir)
+
+
+@pytest.mark.parametrize(
+    "contents",
+    ['{', '{}', '[]', '["profile_a", "PROFILE_A"]', '["../outside"]', '["main"]'],
+)
+def test_should_reject_invalid_profile_lists(tmp_path: Path, contents: str) -> None:
+    main_home = tmp_path / ".claude"
+    main_home.mkdir()
+    (main_home / "extra-profiles.json").write_text(contents, encoding="utf-8")
+
+    with pytest.raises(ValueError):
+        claude_account_worker.extra_config_directories(main_home)
+
+
 def test_should_require_prompt_file_and_report_file_flags() -> None:
     parser = build_argument_parser()
 

package/scripts/test_spawn_grok_batch.py

@@ -1514,6 +1514,7 @@ def test_bind_unique_worker_advisor_rejects_placeholder(
         batch.bind_unique_worker_advisor(
             advisor_spec=batch.AdvisorSpec(launcher=batch.DEFAULT_ADVISOR_LAUNCHER_PLACEHOLDER),
             role_name="lens",
+            assignment_text="assignment",
             all_used_session_ids=set(),
         )
 
@@ -1528,12 +1529,33 @@ def test_bind_unique_worker_advisor_returns_session(
     session_id, signal = batch.bind_unique_worker_advisor(
         advisor_spec=batch.AdvisorSpec(launcher="fixture-advisor-launcher"),
         role_name="lens",
+        assignment_text="assignment",
         all_used_session_ids=set(),
     )
     assert session_id == "sess-unique-1"
     assert signal == "ENDORSE"
 
 
+def test_bind_unique_worker_advisor_prompt_carries_assignment_text(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_captured_prompts: list[object] = []
+
+    def fake(**kwargs: object) -> tuple[str | None, str, int]:
+        all_captured_prompts.append(kwargs["prompt_text"])
+        return "sess-assignment-1", "ENDORSE\nok", 0
+
+    monkeypatch.setattr(batch, "batch_invoke_advisor", fake)
+    batch.bind_unique_worker_advisor(
+        advisor_spec=batch.AdvisorSpec(launcher="fixture-advisor-launcher"),
+        role_name="lens",
+        assignment_text="Audit module alpha for unused imports.",
+        all_used_session_ids=set(),
+    )
+    assert len(all_captured_prompts) == 1
+    assert "Audit module alpha for unused imports." in str(all_captured_prompts[0])
+
+
 def test_obtain_advisor_completion_verdict_endorses(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:

package/scripts/tests/test_banned_prose_words.py

@@ -86,7 +86,7 @@ def test_governed_paths_lists_the_shipped_surfaces(tmp_path: Path) -> None:
 def test_governed_paths_cover_instruction_surfaces_and_skip_archives() -> None:
     assert governs_path("rules/git-workflow.md")
     assert governs_path(".agents/skills/eli5/SKILL.md")
-    assert governs_path("audit-rubrics/prompts/category-e-dead-code.md")
+    assert governs_path("audit-rubrics/prompts/category-o-docstring-vs-impl-drift.md")
     assert governs_path("system-prompts/software-engineer.xml")
     assert not governs_path("rules-archived/manifest.md")
     assert not governs_path("scripts/banned_prose_words.py")

package/scripts/tests/test_policy_lint_rules_archive.py

@@ -134,3 +134,19 @@ def test_archived_hook_moves_leave_the_automatic_checks(tmp_path: Path) -> None:
     assert runtime_set.documents == ()
     assert runtime_set.deleted_paths == (live_hook_path,)
     assert runtime_set.renamed_paths == ()
+
+
+def test_archived_audit_rubric_moves_leave_the_automatic_checks(tmp_path: Path) -> None:
+    live_rubric_path = PurePosixPath("packages/tool/audit-rubrics/prompts/category-k.md")
+    archived_rubric_path = PurePosixPath("packages/tool/audit-rubrics-archived/prompts/category-k.md")
+    document_set = DocumentSet(
+        (Document.from_text(archived_rubric_path, "archived"),),
+        SelectionKind.BASE,
+        tmp_path,
+        (),
+        ((live_rubric_path, archived_rubric_path),),
+    )
+    runtime_set = _runtime_document_set(document_set)
+    assert runtime_set.documents == ()
+    assert runtime_set.deleted_paths == (live_rubric_path,)
+    assert runtime_set.renamed_paths == ()

package/scripts/tests/test_policy_lint_rules_engine.py

@@ -209,7 +209,7 @@ def test_changed_line_filter_drops_other_located_line(tmp_path: Path) -> None:
     assert lint_report.diagnostics == ()
 
 
-def test_lint_keeps_located_findings_when_changed_lines_are_empty(
+def test_lint_drops_located_findings_when_a_change_only_deletes_lines(
     tmp_path: Path,
 ) -> None:
     repository_root = tmp_path.resolve()
@@ -233,7 +233,7 @@ def test_lint_keeps_located_findings_when_changed_lines_are_empty(
         (document,),
         (_changed_document_rule("probe", collect_diagnostics),),
     )
-    assert len(lint_report.diagnostics) == 1
+    assert lint_report.diagnostics == ()
 
 
 def test_code_rule_diagnostics_includes_comment_policy_without_prior_text(