claude-dev-env 8.7.0 → 8.9.0

package/hooks/session/test_skill_loaded_reminder.py

@@ -0,0 +1,206 @@
+"""Tests for skill_loaded_reminder. Checks every fresh context gets poteto-mode, and loaded ones hear nothing."""
+
+import json
+import sys
+from io import BytesIO, StringIO, TextIOWrapper
+from pathlib import Path
+from unittest.mock import patch
+
+_SESSION_DIR = Path(__file__).resolve().parent
+_HOOKS_ROOT = _SESSION_DIR.parent
+for each_sys_path_entry in (str(_SESSION_DIR), str(_HOOKS_ROOT)):
+    if each_sys_path_entry not in sys.path:
+        sys.path.insert(0, each_sys_path_entry)
+
+import skill_loaded_reminder as reminder
+from hooks_constants.skill_loaded_reminder_constants import (
+    COMPACTION_REMINDER,
+    NOT_LOADED_REMINDER,
+)
+
+SKILL_CALL_LINE = json.dumps(
+    {
+        "type": "assistant",
+        "message": {
+            "role": "assistant",
+            "content": [
+                {
+                    "type": "tool_use",
+                    "name": "Skill",
+                    "input": {"skill": "pstack:poteto-mode"},
+                }
+            ],
+        },
+    }
+)
+TYPED_COMMAND_LINE = json.dumps(
+    {
+        "type": "user",
+        "message": {
+            "role": "user",
+            "content": "<command-name>/pstack:poteto-mode</command-name>",
+        },
+    }
+)
+COMPACT_BOUNDARY_LINE = json.dumps({"type": "system", "subtype": "compact_boundary"})
+READ_CALL_LINE = json.dumps(
+    {
+        "type": "assistant",
+        "message": {
+            "content": [{"type": "tool_use", "name": "Read", "input": {"file_path": "a.py"}}]
+        },
+    }
+)
+TOOL_RESULT_QUOTING_THE_SKILL_LINE = json.dumps(
+    {
+        "type": "user",
+        "message": {
+            "content": [
+                {
+                    "type": "tool_result",
+                    "content": 'SKILL = "pstack:poteto-mode" and <command-name>/pstack:poteto-mode</command-name>',
+                }
+            ]
+        },
+    }
+)
+
+
+def _run_main(hook_payload: object) -> str:
+    """Return the text main() prints for the given hook payload."""
+    stdin_text = hook_payload if isinstance(hook_payload, str) else json.dumps(hook_payload)
+    captured_stdout = StringIO()
+    fake_stdin = TextIOWrapper(BytesIO(stdin_text.encode("utf-8")), encoding="utf-8")
+    with patch("sys.stdin", fake_stdin), patch("sys.stdout", captured_stdout):
+        reminder.main()
+    return captured_stdout.getvalue()
+
+
+def _agent_call(tool_input: dict[str, object], tool_name: str = "Agent") -> dict[str, object]:
+    return {"hook_event_name": "PreToolUse", "tool_name": tool_name, "tool_input": tool_input}
+
+
+def _user_turn(transcript_path: Path) -> dict[str, object]:
+    return {"hook_event_name": "UserPromptSubmit", "transcript_path": str(transcript_path)}
+
+
+def _write_transcript(tmp_path: Path, all_lines: list[str]) -> Path:
+    transcript_path = tmp_path / "session.jsonl"
+    transcript_path.write_text("\n".join(all_lines) + "\n", encoding="utf-8")
+    return transcript_path
+
+
+class TestSubagentSpawn:
+    def test_a_plain_subagent_prompt_opens_with_the_poteto_mode_invocation(self) -> None:
+        emitted = json.loads(
+            _run_main(
+                _agent_call(
+                    {
+                        "description": "Find callers",
+                        "subagent_type": "Explore",
+                        "prompt": "List every caller of main.",
+                    }
+                )
+            )
+        )
+        hook_output = emitted["hookSpecificOutput"]
+        rewritten_input = hook_output["updatedInput"]
+        assert hook_output["permissionDecision"] == "allow"
+        assert rewritten_input["prompt"].startswith(
+            "Before any other work, invoke the pstack:poteto-mode skill with the Skill tool."
+        )
+        assert rewritten_input["prompt"].endswith("\n\nList every caller of main.")
+        assert rewritten_input["subagent_type"] == "Explore"
+        assert rewritten_input["description"] == "Find callers"
+
+    def test_the_legacy_task_tool_name_is_rewritten_too(self) -> None:
+        emitted = json.loads(_run_main(_agent_call({"prompt": "Go."}, tool_name="Task")))
+        assert "pstack:poteto-mode" in emitted["hookSpecificOutput"]["updatedInput"]["prompt"]
+
+    def test_a_prompt_that_already_names_the_skill_is_left_alone(self) -> None:
+        assert _run_main(_agent_call({"prompt": "Invoke pstack:poteto-mode first. Then go."})) == ""
+
+    def test_a_poteto_agent_is_left_alone_because_it_loads_the_skill_itself(self) -> None:
+        assert (
+            _run_main(_agent_call({"subagent_type": "pstack:poteto-agent", "prompt": "Go."})) == ""
+        )
+
+    def test_another_tool_is_left_alone(self) -> None:
+        assert _run_main(_agent_call({"prompt": "Go."}, tool_name="Bash")) == ""
+
+
+class TestSubagentInputWithPotetoMode:
+    def test_every_other_input_field_is_kept(self) -> None:
+        rewritten_input = reminder.subagent_input_with_poteto_mode(
+            {"prompt": "Go.", "model": "sonnet", "run_in_background": True}
+        )
+        assert rewritten_input is not None
+        assert rewritten_input["model"] == "sonnet"
+        assert rewritten_input["run_in_background"] is True
+
+    def test_an_input_with_no_prompt_is_left_alone(self) -> None:
+        assert reminder.subagent_input_with_poteto_mode({"description": "Go"}) is None
+
+
+class TestIsPotetoModeLoaded:
+    def test_a_skill_call_loads_it(self) -> None:
+        assert reminder.is_poteto_mode_loaded([READ_CALL_LINE, SKILL_CALL_LINE, READ_CALL_LINE])
+
+    def test_a_typed_slash_command_loads_it(self) -> None:
+        assert reminder.is_poteto_mode_loaded([TYPED_COMMAND_LINE, READ_CALL_LINE])
+
+    def test_a_compaction_after_the_skill_call_drops_it(self) -> None:
+        assert not reminder.is_poteto_mode_loaded(
+            [SKILL_CALL_LINE, COMPACT_BOUNDARY_LINE, READ_CALL_LINE]
+        )
+
+    def test_a_skill_call_after_the_compaction_loads_it_again(self) -> None:
+        assert reminder.is_poteto_mode_loaded(
+            [SKILL_CALL_LINE, COMPACT_BOUNDARY_LINE, SKILL_CALL_LINE]
+        )
+
+    def test_a_plain_user_prompt_does_not_load_it(self) -> None:
+        plain_prompt_line = json.dumps(
+            {"type": "user", "message": {"content": "Read pstack:poteto-mode docs."}}
+        )
+        assert not reminder.is_poteto_mode_loaded([plain_prompt_line])
+
+    def test_a_tool_result_that_quotes_the_skill_name_does_not_load_it(self) -> None:
+        assert not reminder.is_poteto_mode_loaded([TOOL_RESULT_QUOTING_THE_SKILL_LINE])
+
+
+class TestReminderFor:
+    def test_a_user_turn_in_a_session_that_never_loaded_the_skill_gets_the_reminder(
+        self, tmp_path: Path
+    ) -> None:
+        transcript_path = _write_transcript(tmp_path, [READ_CALL_LINE])
+        emitted = json.loads(_run_main(_user_turn(transcript_path)))
+        hook_output = emitted["hookSpecificOutput"]
+        assert hook_output["hookEventName"] == "UserPromptSubmit"
+        assert hook_output["additionalContext"] == NOT_LOADED_REMINDER
+        assert "pstack:poteto-mode" in NOT_LOADED_REMINDER
+
+    def test_a_user_turn_in_a_session_that_loaded_the_skill_prints_nothing(
+        self, tmp_path: Path
+    ) -> None:
+        transcript_path = _write_transcript(tmp_path, [SKILL_CALL_LINE, READ_CALL_LINE])
+        assert _run_main(_user_turn(transcript_path)) == ""
+
+    def test_a_user_turn_with_no_transcript_yet_gets_the_reminder(self, tmp_path: Path) -> None:
+        assert (
+            reminder.reminder_for(_user_turn(tmp_path / "not-written-yet.jsonl"))
+            == NOT_LOADED_REMINDER
+        )
+
+    def test_session_start_after_compaction_tells_the_session_to_invoke_it_again(self) -> None:
+        emitted = json.loads(_run_main({"hook_event_name": "SessionStart", "source": "compact"}))
+        hook_output = emitted["hookSpecificOutput"]
+        assert hook_output["hookEventName"] == "SessionStart"
+        assert hook_output["additionalContext"] == COMPACTION_REMINDER
+        assert "pstack:poteto-mode" in COMPACTION_REMINDER
+
+    def test_a_resumed_session_keeps_its_context_and_prints_nothing(self) -> None:
+        assert _run_main({"hook_event_name": "SessionStart", "source": "resume"}) == ""
+
+    def test_a_payload_that_is_not_json_prints_nothing(self) -> None:
+        assert _run_main("not json") == ""

package/package.json

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

package/rules/durable-post-artifacts.md

@@ -3,7 +3,8 @@
 ## When this applies
 
 Use this rule for a GitHub issue, pull request, comment, or review created
-through `gh` or a GitHub MCP post tool.
+through `gh` or a GitHub MCP post tool. The image section also covers a PNG a
+commit adds and a file a release upload sends.
 
 ## Rule
 
@@ -26,6 +27,24 @@ Handle text and binary content differently:
   under a `YYYYMMDD_HHMMSS_<name>` asset name, and prints a permanent download
   URL. Put that URL in the post.
 
+## Optimize every image before it reaches GitHub
+
+The helper shrinks a PNG with [oxipng](https://github.com/oxipng/oxipng) before
+it uploads, and prints the size before and after. Oxipng is lossless.
+`--strip none` keeps every chunk, and `--nb --nc` keep the bit depth and the
+color type, so a reader that checks the image mode sees the same file shape.
+
+Any other route to GitHub runs the same pass first: a PNG a commit adds, and a
+file sent with `gh release upload`.
+
+```
+oxipng --opt 4 --strip none --nb --nc <file> [<file> ...]
+```
+
+The `Binary optimization` check fails a pull request whose changed PNG files
+still shrink under that pass. A fixture whose exact bytes a test pins takes
+`binary-optimizer=keep` in `.gitattributes`, and the check skips it.
+
 ## Volatile paths that must not appear in a post body
 
 - A job scratch directory: `.claude-profile-a/jobs/`
@@ -46,5 +65,11 @@ server write. Pass the matching action and body file. Use `pr-create`,
 `pr-edit`, `pr-comment`, `pr-review`, `issue-create`, `issue-edit`,
 `issue-comment`, or `github-mcp-post`.
 
+Pass `--repository <owner>/<name>` for the repository the post targets. A
+post may name a private organization only inside a repository that
+organization owns. The linter holds the names as digests, so it reports the
+line that names one without printing the name. Describe the organization in
+general terms and drop the link.
+
 The linter reads the body file and reports a volatile local path without
 printing the body. Fix the body and rerun the linter before posting.

package/rules/long-horizon-autonomy.md

@@ -18,6 +18,17 @@ A pause is a request you deliver, not a state you enter. Put it in the channel t
 
 Before you end any turn, read your last paragraph. If it is a plan, an analysis, a list of next steps, or a statement of intent ("I'll run the tests", "next I'll wire it up"), do that work with tool calls before you stop. End the turn only when the task is done or you are blocked on input only the user can give.
 
+Four turn endings leave owed work unstarted. Each one is a stop to remove:
+
+- A summary of the work so far that closes by naming the next step, with no tool call to start it.
+- An offer to continue unless the user objects.
+- A list of decisions for the user when none of them blocks the remaining work.
+- A pause chosen because the turn ran long or a milestone finished.
+
+A status note or a recommendation on an open decision rides in the same message as the next tool call. The stops that stay are the two where nothing can move: the next step needs the user, or the blocker is a control that is protected from you on purpose. Confirmation before a risky or destructive action still applies.
+
+A harness or routine that drives an unattended run reads a turn that ends in text as a report. When open checklist items remain and the turn names no blocker, it sends one short message naming those items. It stops after two or three such continuations on one task, so a stuck run ends where a reader can review it. [Prompting Claude Opus 5.5](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#unattended-agentic-runs) is the source for this list and this loop.
+
 In an autonomous pipeline the user cannot answer mid-task. For reversible actions that follow from the original request, act without asking; save any follow-up offers for after the task is done.
 
 Authority the task already granted stays granted. A later preference about tone, brevity, or reply format changes how you report, never what you are allowed to do. Re-asking for permission the task already gave hands the work back to the user, who then does it by hand.

package/rules/prefer-existing-tools.md

@@ -0,0 +1,35 @@
+# Prefer Existing Tools
+
+**When this applies:** Before you build a tool, check, scanner, script, or library of your own.
+
+## Rule
+
+Search in this order, and stop at the first fit:
+
+1. **Internal code.** Search the repository and its shared packages for a tool that already does the job. Reuse or extend it.
+2. **An established open-source option.** Search for a plugin, package, or tool that already does the job.
+3. **Your own code.** Build it only when steps 1 and 2 find nothing that fits.
+
+Use an open-source option only when it meets all four conditions:
+
+- It is secure: it has an active security process and no open critical advisory.
+- It is well known in its field.
+- It is widely used: many stars, downloads, or dependents.
+- It is maintained: it had a release or commit in the last year.
+
+Add only what the option lacks. Put custom rules in its own configuration format. Do not wrap it in a new layer of your own code.
+
+## Report the choice
+
+Tell the user which tool you chose before the work is marked ready. Give its name, link, license, and one number that shows how widely it is used. When you build your own code, name what you searched and why each candidate did not fit.
+
+## Why
+
+Code of your own is code you maintain alone. A trusted tool carries fixes and new patterns from its community, and its users find its defects first.
+
+## Sibling rules
+
+| Rule | Role |
+|---|---|
+| [`explore-thoroughly.md`](explore-thoroughly.md) | Read what exists before you propose a change |
+| [`verify-before-asking.md`](verify-before-asking.md) | Answer a question with a tool before you ask it |

package/rules/review-closure-is-a-check.md

@@ -33,7 +33,7 @@ The driving account is the one that opened the pull request. Where the agent com
 
 `.github/workflows/review-closure.yml` runs it here on a push to a pull request, on a submitted or dismissed review, and on a review comment. Each run reports on the pull request's head commit, so a finding posted after the last push still turns the check red.
 
-`Echo-Visuals-Inc/python-automation` runs the same command from its own workflow, against the revision of this package that its workflow pins.
+A private repository that installs this package runs the same command from its own workflow, against the revision of this package that its workflow pins.
 
 ## Sibling rules
 

package/scripts/claude_account_choice.py

@@ -0,0 +1,291 @@
+#!/usr/bin/env python3
+"""Name the Claude account a runner job uses, protecting the main account.
+
+The main account is the one its owner works on, so a job borrows it only to
+spend leftover usage that expires soon. Every other job goes to the second
+account while that account has room, and waits when it has none::
+
+    main week resets in 5 hours, 20% left, 5-hour window 10% used -> main
+    main week resets in 3 days                                    -> second
+    second at 99% of its week, main not spendable                 -> wait
+    main meter unread                                             -> never main
+
+::
+
+    python claude_account_choice.py --main-config-dir C:/Users/me/.claude
+        --second-config-dir C:/Users/me/.claude-profiles/ev
+    {"account": "second", "config_dir": "C:/Users/me/.claude-profiles/ev",
+     "reason": "second account has 60% of its week and 90% of its 5-hour window left"}
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+from claude_account_profile import default_profile_home
+from claude_chain_usage import (
+    AccountUsageMeters,
+    WeeklyUtilizationProbeError,
+    probe_account_meters,
+)
+from dev_env_scripts_constants.claude_account_constants import (
+    CHOICE_MAIN,
+    CHOICE_SECOND,
+    CHOICE_WAIT,
+    CREDENTIALS_FILE_NAME,
+    FULL_PERCENT,
+    JSON_ACCOUNT_KEY,
+    JSON_CONFIG_DIRECTORY_KEY,
+    JSON_METERS_KEY,
+    JSON_REASON_KEY,
+    JSON_SESSION_RESETS_AT_KEY,
+    JSON_SESSION_USED_PERCENT_KEY,
+    JSON_WEEKLY_RESETS_AT_KEY,
+    JSON_WEEKLY_USED_PERCENT_KEY,
+    MAIN_CLAUDE_HOME_DIRECTORY_NAME,
+    MAIN_SESSION_USED_CEILING_PERCENT,
+    MAIN_SPEND_WINDOW,
+    MAIN_WEEKLY_USED_CEILING_PERCENT,
+    REASON_MAIN_EXPIRING_TEMPLATE,
+    REASON_SECOND_HAS_ROOM_TEMPLATE,
+    REASON_SECOND_UNREAD,
+    REASON_WAIT_TEMPLATE,
+    SECOND_SESSION_USED_CEILING_PERCENT,
+    SECOND_WEEKLY_USED_CEILING_PERCENT,
+    SECONDS_PER_HOUR,
+    UNKNOWN_RESET_TEXT,
+)
+
+
+@dataclass(frozen=True)
+class AccountDecision:
+    """The account a job runs on, and the plain-words reason for it."""
+
+    account: str
+    reason: str
+
+
+def _main_spendable_reason(
+    main_meters: AccountUsageMeters | None, now: datetime
+) -> str | None:
+    if main_meters is None:
+        return None
+    session_used = main_meters.session_utilization
+    weekly_used = main_meters.weekly_utilization
+    weekly_resets_at = main_meters.weekly_resets_at
+    if session_used is None or weekly_used is None or weekly_resets_at is None:
+        return None
+    time_until_reset = weekly_resets_at - now
+    is_expiring_soon = time_until_reset <= MAIN_SPEND_WINDOW
+    has_weekly_room = weekly_used < MAIN_WEEKLY_USED_CEILING_PERCENT
+    has_session_room = session_used < MAIN_SESSION_USED_CEILING_PERCENT
+    if not (is_expiring_soon and has_weekly_room and has_session_room):
+        return None
+    return REASON_MAIN_EXPIRING_TEMPLATE.format(
+        hours_until_reset=int(time_until_reset.total_seconds() // SECONDS_PER_HOUR),
+        remaining_percent=FULL_PERCENT - weekly_used,
+    )
+
+
+def _wait_decision(
+    second_meters: AccountUsageMeters, *, is_week_blocked: bool
+) -> AccountDecision:
+    blocking_reset = (
+        second_meters.weekly_resets_at
+        if is_week_blocked
+        else second_meters.session_resets_at
+    )
+    return AccountDecision(
+        account=CHOICE_WAIT,
+        reason=REASON_WAIT_TEMPLATE.format(
+            weekly_used_percent=second_meters.weekly_utilization,
+            session_used_percent=second_meters.session_utilization,
+            next_reset=(
+                blocking_reset.isoformat() if blocking_reset else UNKNOWN_RESET_TEXT
+            ),
+        ),
+    )
+
+
+def _second_account_decision(
+    second_meters: AccountUsageMeters | None,
+) -> AccountDecision:
+    if second_meters is None:
+        return AccountDecision(account=CHOICE_SECOND, reason=REASON_SECOND_UNREAD)
+    session_used = second_meters.session_utilization
+    weekly_used = second_meters.weekly_utilization
+    if session_used is None or weekly_used is None:
+        return AccountDecision(account=CHOICE_SECOND, reason=REASON_SECOND_UNREAD)
+    is_week_blocked = weekly_used >= SECOND_WEEKLY_USED_CEILING_PERCENT
+    is_session_blocked = session_used >= SECOND_SESSION_USED_CEILING_PERCENT
+    if is_week_blocked or is_session_blocked:
+        return _wait_decision(second_meters, is_week_blocked=is_week_blocked)
+    return AccountDecision(
+        account=CHOICE_SECOND,
+        reason=REASON_SECOND_HAS_ROOM_TEMPLATE.format(
+            weekly_remaining_percent=FULL_PERCENT - weekly_used,
+            session_remaining_percent=FULL_PERCENT - session_used,
+        ),
+    )
+
+
+def choose_account(
+    *,
+    main_meters: AccountUsageMeters | None,
+    second_meters: AccountUsageMeters | None,
+    now: datetime,
+) -> AccountDecision:
+    """Pick the account a job runs on from both accounts' meters.
+
+    ::
+
+        main: week resets in 5h, 80% used, 5-hour 10% used   -> main
+        main: week resets in 30h                             -> second, if it has room
+        main unread, second at 99% of its week               -> wait
+        main unread, second unread                           -> second
+
+    Main runs a job only to spend leftover usage that expires soon.
+
+    Args:
+        main_meters: The main account's meters, or None when unread.
+        second_meters: The second account's meters, or None when unread.
+        now: The time the reset windows are measured from.
+
+    Returns:
+        The chosen account and the reason.
+    """
+    main_reason = _main_spendable_reason(main_meters, now)
+    if main_reason is not None:
+        return AccountDecision(account=CHOICE_MAIN, reason=main_reason)
+    return _second_account_decision(second_meters)
+
+
+def read_account_meters(credentials_path: Path) -> AccountUsageMeters | None:
+    """Read one account's meters, or None when its credential or probe fails.
+
+    Args:
+        credentials_path: The account's CLI credential file.
+
+    Returns:
+        The meters, or None when they cannot be read.
+    """
+    try:
+        return probe_account_meters(credentials_path)
+    except WeeklyUtilizationProbeError:
+        return None
+
+
+def _build_argument_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Name the Claude account a runner job uses."
+    )
+    parser.add_argument(
+        "--main-config-dir",
+        type=Path,
+        default=Path.home() / MAIN_CLAUDE_HOME_DIRECTORY_NAME,
+    )
+    parser.add_argument(
+        "--second-config-dir",
+        type=Path,
+        default=default_profile_home(),
+    )
+    return parser
+
+
+def decision_payload(
+    decision: AccountDecision, *, config_directory: Path | None
+) -> dict[str, str | None]:
+    """Shape a decision as the JSON object the runner job reads.
+
+    ::
+
+        AccountDecision("second", "...") with the profile directory
+        -> {"account": "second", "config_dir": "<profile>", "reason": "..."}
+
+    Args:
+        decision: The chosen account and reason.
+        config_directory: The Claude home the account runs under, or None on wait.
+
+    Returns:
+        The account, its Claude home, and the reason.
+    """
+    return {
+        JSON_ACCOUNT_KEY: decision.account,
+        JSON_CONFIG_DIRECTORY_KEY: str(config_directory) if config_directory else None,
+        JSON_REASON_KEY: decision.reason,
+    }
+
+
+def _iso_or_none(moment: datetime | None) -> str | None:
+    return moment.isoformat() if moment else None
+
+
+def meters_payload(
+    account_meters: AccountUsageMeters | None,
+) -> dict[str, float | str | None] | None:
+    """Shape one account's meters as the JSON object a usage report reads.
+
+    ::
+
+        AccountUsageMeters(12.0, <reset>, 34.0, <reset>)
+        -> {"session_used_percent": 12.0, "session_resets_at": "2026-09-22T22:00:00+00:00",
+            "weekly_used_percent": 34.0, "weekly_resets_at": "2026-09-25T21:00:00+00:00"}
+
+    Args:
+        account_meters: The account's meters, or None when unread.
+
+    Returns:
+        Each used percent and reset time, or None for an unread account.
+    """
+    if account_meters is None:
+        return None
+    return {
+        JSON_SESSION_USED_PERCENT_KEY: account_meters.session_utilization,
+        JSON_SESSION_RESETS_AT_KEY: _iso_or_none(account_meters.session_resets_at),
+        JSON_WEEKLY_USED_PERCENT_KEY: account_meters.weekly_utilization,
+        JSON_WEEKLY_RESETS_AT_KEY: _iso_or_none(account_meters.weekly_resets_at),
+    }
+
+
+def main(all_command_arguments: list[str]) -> int:
+    """Print the chosen account and both accounts' meters as JSON.
+
+    Args:
+        all_command_arguments: Command-line arguments after the program name.
+
+    Returns:
+        Zero once the choice is printed.
+    """
+    arguments = _build_argument_parser().parse_args(all_command_arguments)
+    config_directory_by_account = {
+        CHOICE_MAIN: arguments.main_config_dir,
+        CHOICE_SECOND: arguments.second_config_dir,
+    }
+    main_meters = read_account_meters(arguments.main_config_dir / CREDENTIALS_FILE_NAME)
+    second_meters = read_account_meters(
+        arguments.second_config_dir / CREDENTIALS_FILE_NAME
+    )
+    decision = choose_account(
+        main_meters=main_meters,
+        second_meters=second_meters,
+        now=datetime.now().astimezone(),
+    )
+    config_directory = config_directory_by_account.get(decision.account)
+    report = {
+        **decision_payload(decision, config_directory=config_directory),
+        JSON_METERS_KEY: {
+            CHOICE_MAIN: meters_payload(main_meters),
+            CHOICE_SECOND: meters_payload(second_meters),
+        },
+    }
+    print(json.dumps(report))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))