claude-dev-env 8.15.1 → 8.16.1

package/scripts/claude_account_worker.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import argparse
 import importlib
+import json
 import os
 import shutil
 import subprocess
@@ -14,7 +15,13 @@ from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
 
-from claude_account_choice import choose_account, decision_payload, read_account_meters
+from claude_account_choice import (
+    choose_account_from_extras,
+    config_directory_for_decision,
+    decision_payload,
+    read_account_meters,
+    read_extra_accounts,
+)
 from claude_account_profile import default_profile_home
 from claude_account_worker_process import WorkerProcess, invoke_worker
 from claude_account_worker_report import (
@@ -26,7 +33,6 @@ from claude_account_worker_report import (
 )
 from dev_env_scripts_constants.claude_account_worker_constants import (
     CHOICE_MAIN,
-    CHOICE_SECOND,
     CHOICE_WAIT,
     CLAUDE_BINARY_NAME,
     CLAUDE_CONFIG_DIR_ENV_VAR,
@@ -35,6 +41,7 @@ from dev_env_scripts_constants.claude_account_worker_constants import (
     CWD_FLAG,
     DEFAULT_PERMISSION_MODE,
     DEFAULT_TIMEOUT_MINUTES,
+    EXTRA_PROFILES_FILE_NAME,
     INVALID_TIMEOUT_MESSAGE,
     JSON_ACCOUNT_KEY,
     JSON_CONFIG_DIRECTORY_KEY,
@@ -104,6 +111,33 @@ def _selection_from_payload(all_selection_payload: Mapping[str, str | None]) ->
     )
 
 
+def extra_config_directories(main_config_dir: Path) -> tuple[Path, ...]:
+    """Read the ordered local profile list or use the legacy default.
+
+    Args:
+        main_config_dir: The main Claude home that may hold the list file.
+
+    Returns:
+        The extra profile homes in the order they are tried.
+
+    Raises:
+        ValueError: When the list is empty, holds a non-name, or repeats a name.
+    """
+    profiles_file = main_config_dir / EXTRA_PROFILES_FILE_NAME
+    if not profiles_file.exists():
+        return (default_profile_home(),)
+    profile_names = json.loads(profiles_file.read_text(encoding=UTF8_ENCODING))
+    if (
+        not isinstance(profile_names, list)
+        or not profile_names
+        or any(not isinstance(name, str) for name in profile_names)
+    ):
+        raise ValueError("extra profile list must be a nonempty JSON list of names")
+    if len({name.casefold() for name in profile_names}) != len(profile_names):
+        raise ValueError("extra profile names must be distinct")
+    return tuple(default_profile_home(name) for name in profile_names)
+
+
 def select_account() -> AccountSelection:
     """Pick the account this worker runs on and its Claude home directory.
 
@@ -111,20 +145,19 @@ def select_account() -> AccountSelection:
         The chosen account, its Claude config directory, and the reason.
 
     Raises:
-        ValueError: When the account picker returns an incomplete decision.
+        ValueError: When the profile list or account decision is invalid.
     """
     main_config_dir = Path.home() / MAIN_CLAUDE_HOME_DIRECTORY_NAME
-    second_config_dir = default_profile_home()
-    config_directory_by_account = {
-        CHOICE_MAIN: main_config_dir,
-        CHOICE_SECOND: second_config_dir,
-    }
+    extra_accounts = read_extra_accounts(extra_config_directories(main_config_dir))
     main_meters = read_account_meters(main_config_dir / CREDENTIALS_FILE_NAME)
-    second_meters = read_account_meters(second_config_dir / CREDENTIALS_FILE_NAME)
-    decision = choose_account(
-        main_meters=main_meters, second_meters=second_meters, now=datetime.now().astimezone()
+    decision = choose_account_from_extras(
+        main_meters=main_meters,
+        all_extra_accounts=extra_accounts,
+        now=datetime.now().astimezone(),
+    )
+    selected_config_dir = config_directory_for_decision(
+        decision, main_config_dir=main_config_dir, all_extra_accounts=extra_accounts
     )
-    selected_config_dir = config_directory_by_account.get(decision.account)
     payload = decision_payload(decision, config_directory=selected_config_dir)
     return _selection_from_payload(payload)
 
@@ -163,14 +196,14 @@ def _child_environment(
     selection: AccountSelection,
     all_environment_variables: Mapping[str, str],
 ) -> dict[str, str]:
-    if selection.account not in (CHOICE_MAIN, CHOICE_SECOND):
-        raise ValueError(f"unsupported account selection: {selection.account}")
     all_child_environment_variables = dict(all_environment_variables)
     if selection.account == CHOICE_MAIN:
         all_child_environment_variables.pop(CLAUDE_CONFIG_DIR_ENV_VAR, None)
         return all_child_environment_variables
+    if selection.account == CHOICE_WAIT:
+        raise ValueError("wait selection cannot launch a worker")
     if selection.config_dir is None:
-        raise ValueError("second account selection needs a config directory")
+        raise ValueError("extra account selection needs a config directory")
     all_child_environment_variables[CLAUDE_CONFIG_DIR_ENV_VAR] = str(selection.config_dir)
     return all_child_environment_variables
 

package/scripts/dev_env_scripts_constants/claude_account_constants.py

@@ -22,10 +22,28 @@ PROFILES_ROOT_ENVIRONMENT_VARIABLE: str = "LLM_SETTINGS_PROFILES_ROOT"
 SECOND_ACCOUNT_PROFILE_NAME: str = "ev"
 """Profile directory name the second account signs in under."""
 
+EXTRA_PROFILES_FILE_NAME: str = "extra-profiles.json"
+"""Local main-home file listing extra profile names in selection order."""
+
+PROFILE_NAME_PATTERN: str = r"[A-Za-z0-9][A-Za-z0-9_-]*"
+"""Allowed profile names for directories and command launchers."""
+
+ALL_WINDOWS_RESERVED_PROFILE_NAMES: frozenset[str] = frozenset(
+    {"con", "prn", "aux", "nul"}
+    | {f"com{number}" for number in range(1, 10)}
+    | {f"lpt{number}" for number in range(1, 10)}
+)
+"""Windows device names that cannot be used as profile directories."""
+
 ALL_LAUNCHER_DIRECTORY_RELATIVE_PARTS: tuple[str, ...] = (".local", "bin")
 """Path parts under the user home of the directory on PATH that holds the launcher."""
 
-LAUNCHER_FILE_NAME: str = "claude-ev.cmd"
+LAUNCHER_FILE_NAME_TEMPLATE: str = "claude-{profile_name}.cmd"
+"""File name pattern for a named profile launcher."""
+
+LAUNCHER_FILE_NAME: str = LAUNCHER_FILE_NAME_TEMPLATE.format(
+    profile_name=SECOND_ACCOUNT_PROFILE_NAME
+)
 """File name of the launcher that runs Claude under the second account."""
 
 LAUNCHER_TEXT_TEMPLATE: str = (
@@ -67,6 +85,7 @@ ALL_ACCOUNT_LOCAL_NAMES: frozenset[str] = frozenset(
         "cache",
         "paste-cache",
         "stats-cache.json",
+        EXTRA_PROFILES_FILE_NAME,
     }
 )
 """Top-level Claude home entries that belong to one account and are never linked."""
@@ -135,6 +154,22 @@ REASON_SECOND_UNREAD: str = (
 )
 """Reason when the second account's meter cannot be read and it takes the job anyway."""
 
+REASON_EXTRA_HAS_ROOM_TEMPLATE: str = (
+    "{account} has {weekly_remaining_percent:.0f}% of its week"
+    " and {session_remaining_percent:.0f}% of its 5-hour window left"
+)
+"""Reason when a later extra profile takes the job."""
+
+REASON_EXTRA_UNREAD_TEMPLATE: str = (
+    "{account} meter unreadable; its own run refreshes the sign-in"
+)
+"""Reason when a later extra profile's meter cannot be read."""
+
+REASON_ALL_EXTRAS_WAIT_TEMPLATE: str = (
+    "all extra accounts are full; next known reset {next_reset}"
+)
+"""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}"

package/scripts/dev_env_scripts_constants/claude_account_worker_constants.py

@@ -7,6 +7,7 @@ from dev_env_scripts_constants.claude_account_constants import (
     CHOICE_SECOND,
     CHOICE_WAIT,
     CREDENTIALS_FILE_NAME,
+    EXTRA_PROFILES_FILE_NAME,
     JSON_ACCOUNT_KEY,
     JSON_CONFIG_DIRECTORY_KEY,
     JSON_REASON_KEY,
@@ -103,6 +104,7 @@ __all__ = [
     "DRAIN_ATTEMPT_LIMIT",
     "DRAIN_GRACE_TIMEOUT_SECONDS",
     "DURATION_DECIMAL_PLACES",
+    "EXTRA_PROFILES_FILE_NAME",
     "INVALID_TIMEOUT_MESSAGE",
     "JSON_ACCOUNT_KEY",
     "JSON_CONFIG_DIRECTORY_KEY",

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)