claude-dev-env 8.69.0 → 8.70.0

package/scripts/test_account_broker.py

@@ -909,6 +909,26 @@ def test_should_keep_a_spent_mark_without_a_reset_for_one_hour(
     assert decision["resets_at"] == (NOW + timedelta(hours=1)).isoformat()
 
 
+def test_should_mark_a_windows_launcher_path_account_spent(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    launcher_name = "C:\\Users\\someone\\.local\\bin\\claude-first.cmd"
+    first = _account(launcher_name)
+    second = _account("second")
+    monkeypatch.setitem(
+        account_broker.all_product_adapters,
+        Product.CODEX,
+        _adapter((first, second), {launcher_name: _meters(80, 80), "second": _meters(80, 80)}),
+    )
+    _freeze_clock(monkeypatch, NOW)
+
+    code = account_broker.main(("choose", "--product", "codex", "--spent", f"{launcher_name}:{(NOW + timedelta(hours=2)).timestamp()}"))
+
+    decision = json.loads(capsys.readouterr().out)["decision"]
+    assert code == 0
+    assert decision["account"] == "second"
+
+
 def test_should_reject_an_invalid_spent_reset(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ) -> None:
@@ -1194,3 +1214,21 @@ def test_should_keep_the_parent_environment_for_codex_jobs(
         run_job(Product.CODEX, ("codex", "exec", "task"))
 
     assert all_child_environments[0]["CLAUDE_CODE_SESSION_ID"] == "parent-session"
+
+
+
+def test_should_hand_the_live_log_to_the_subprocess_runner(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    live_log = tmp_path / "events.jsonl"
+    adapter = _adapter((_account("only"),), {"only": _meters(80, 80)})
+    captured_options: dict[str, object] = {}
+
+    def runner(command: object, **options: object) -> subprocess.CompletedProcess[str]:
+        captured_options.update(options)
+        return subprocess.CompletedProcess(command, 0, "served", "")
+
+    monkeypatch.setitem(account_broker.all_product_adapters, Product.CODEX, adapter)
+    with account_broker.override_subprocess_runner(runner):
+        outcome, _ = account_broker._execute(Product.CODEX, ("job",), now=NOW, live_log=live_log)
+
+    assert outcome.returncode == 0
+    assert captured_options["live_log"] == live_log

package/scripts/test_account_broker_support.py

@@ -419,3 +419,27 @@ def test_should_pass_metacharacters_to_an_executable_unchanged(monkeypatch: pyte
     support.subprocess_runner(["claude", "-p", 'say "a & b" | 100%!'])
 
     assert all_launched_argv == [[resolved_command, "-p", 'say "a & b" | 100%!']]
+
+
+def test_should_write_child_output_into_the_live_log_while_it_runs(tmp_path: Path) -> None:
+    live_log = tmp_path / "worker.jsonl"
+    child_script = "import sys, pathlib; print('first', flush=True); sys.stdout.write(pathlib.Path(sys.argv[1]).read_text())"
+
+    completed = support._run_captured_subprocess([sys.executable, "-c", child_script, str(live_log)], live_log=live_log)
+
+    assert completed.stdout == "first\nfirst\n"
+    assert live_log.read_text(encoding="utf-8") == "first\nfirst\n"
+
+
+def test_should_match_order_names_to_an_account_named_by_its_windows_launcher_path() -> None:
+    launcher_account = Account(
+        Product.CLAUDE,
+        "C:\\Users\\someone\\.local\\bin\\claude-editor.cmd",
+        Path("/profiles/editor"),
+        False,
+        "C:\\Users\\someone\\.local\\bin\\claude-editor.cmd",
+    )
+
+    ranked = support._with_priorities((launcher_account,), ("claude-org-jon", "claude-editor"))
+
+    assert ranked[0].priority == 1

package/scripts/test_agent_image_copy.py

@@ -0,0 +1,76 @@
+"""Behavior tests for the agent image copy script."""
+
+import argparse
+import sys
+from pathlib import Path
+
+import pytest
+from PIL import Image
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import agent_image_copy
+
+
+def test_capped_size_should_keep_the_aspect_ratio() -> None:
+    assert agent_image_copy.capped_size(1440, 2560) == (288, 512)
+    assert agent_image_copy.capped_size(2000, 1000) == (512, 256)
+    assert agent_image_copy.capped_size(300, 200) == (300, 200)
+
+
+def test_visual_tokens_should_count_28_pixel_patches() -> None:
+    assert agent_image_copy.visual_tokens(1440, 2560) == 4784
+    assert agent_image_copy.visual_tokens(288, 512) == 209
+
+
+def test_parse_crop_box_should_refuse_three_numbers() -> None:
+    assert agent_image_copy.parse_crop_box("0,0,10,20") == (0, 0, 10, 20)
+    with pytest.raises(argparse.ArgumentTypeError):
+        agent_image_copy.parse_crop_box("0,0,10")
+
+
+def test_write_agent_copy_should_write_a_capped_newer_file(tmp_path: Path) -> None:
+    source_path = tmp_path / "preview.png"
+    Image.new("RGB", (1440, 2560), "white").save(source_path)
+    copy_path = agent_image_copy.write_agent_copy(source_path, None)
+    assert copy_path.name == "preview.agent.png"
+    with Image.open(copy_path) as copy_image:
+        assert copy_image.size == (288, 512)
+    assert copy_path.stat().st_mtime >= source_path.stat().st_mtime
+
+
+def test_write_agent_copy_should_crop_before_scaling(tmp_path: Path) -> None:
+    source_path = tmp_path / "preview.png"
+    Image.new("RGB", (1440, 2560), "white").save(source_path)
+    copy_path = agent_image_copy.write_agent_copy(source_path, (0, 0, 720, 640))
+    with Image.open(copy_path) as copy_image:
+        assert copy_image.size == (512, 455)
+
+
+def test_write_agent_copy_should_write_a_cmyk_jpeg_as_rgb(tmp_path: Path) -> None:
+    source_path = tmp_path / "print.jpg"
+    Image.new("CMYK", (1000, 800)).save(source_path)
+    copy_path = agent_image_copy.write_agent_copy(source_path, None)
+    with Image.open(copy_path) as copy_image:
+        assert copy_image.mode == "RGB"
+        assert copy_image.size == (512, 410)
+
+
+def test_write_agent_copy_should_follow_the_exif_orientation(tmp_path: Path) -> None:
+    source_path = tmp_path / "phone.jpg"
+    source_image = Image.new("RGB", (1000, 600), "white")
+    all_exif_tags = source_image.getexif()
+    all_exif_tags[0x0112] = 6
+    source_image.save(source_path, exif=all_exif_tags)
+    copy_path = agent_image_copy.write_agent_copy(source_path, None)
+    with Image.open(copy_path) as copy_image:
+        assert copy_image.size == (307, 512)
+
+
+def test_main_should_print_the_copy_path(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    source_path = tmp_path / "shot.png"
+    Image.new("RGB", (1600, 900), "white").save(source_path)
+    assert agent_image_copy.main([str(source_path)]) == 0
+    assert "shot.agent.png 512x288 about 209 tokens" in capsys.readouterr().out

package/scripts/test_claude_account_worker.py

@@ -45,6 +45,7 @@ def _run_worker(
     *,
     model: str | None = None,
     permission_mode: str = "auto",
+    live_log: Path | None = None,
 ) -> tuple[int, dict[str, object], dict[str, object]]:
     prompt_file = tmp_path / "brief.md"
     prompt_file.write_text("standalone brief", encoding="utf-8")
@@ -65,6 +66,7 @@ def _run_worker(
         model=model,
         permission_mode=permission_mode,
         timeout_minutes=60,
+        live_log=live_log,
     )
     return exit_code, json.loads(report_file.read_text(encoding="utf-8")), captured
 
@@ -88,6 +90,51 @@ def test_should_send_prompt_and_flags_to_broker(
     assert captured["timeout_seconds"] == 3600
 
 
+def test_should_stream_events_into_the_live_log_when_one_is_named(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    live_log = tmp_path / "worker.jsonl"
+
+    exit_code, report, captured = _run_worker(monkeypatch, tmp_path, _outcome(), live_log=live_log)
+
+    assert exit_code == 0
+    assert report["result"] == "ready"
+    assert captured["argv"][:5] == ["claude", "-p", "--output-format", "stream-json", "--verbose"]
+    assert captured["live_log"] == live_log
+
+
+def test_should_pass_no_live_log_when_none_is_named(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    _, _, captured = _run_worker(monkeypatch, tmp_path, _outcome())
+
+    assert "live_log" not in captured
+
+
+def test_should_report_an_unwritable_live_log_before_the_broker_runs(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    prompt_file = tmp_path / "brief.md"
+    prompt_file.write_text("standalone brief", encoding="utf-8")
+    report_file = tmp_path / "report.json"
+    monkeypatch.setattr(worker, "worker_job_runner", lambda *args, **kwargs: pytest.fail("broker ran"))
+
+    exit_code = worker.run_worker(
+        prompt_file=prompt_file,
+        cwd=tmp_path,
+        report_file=report_file,
+        model=None,
+        permission_mode="auto",
+        timeout_minutes=60,
+        live_log=tmp_path / "missing" / "worker.jsonl",
+    )
+
+    report = json.loads(report_file.read_text(encoding="utf-8"))
+    assert exit_code == report["exit_code"] == 1
+    assert report["account"] == "none"
+    assert report["reason"] == "live log file is unwritable"
+
+
 def test_should_report_the_broker_wait_reason_and_exit_three(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:

package/scripts/test_claude_account_worker_process.py

@@ -45,3 +45,23 @@ def test_should_send_job_to_runner_and_return_outcome_with_elapsed_seconds(
             },
         )
     ]
+
+
+def test_should_pass_the_live_log_to_the_runner_when_one_is_named(tmp_path: Path) -> None:
+    live_log = tmp_path / "events.jsonl"
+    captured_options: dict[str, object] = {}
+
+    def recording_runner(product: Product, argv: list[str], **options: object) -> JobOutcome:
+        captured_options.update(options)
+        return JobOutcome(0, "{}", "", "main", (), "served", None, None)
+
+    invoke_worker(
+        all_arguments=["claude", "-p"],
+        cwd=tmp_path,
+        prompt_text="brief",
+        timeout_minutes=1,
+        runner=recording_runner,
+        live_log=live_log,
+    )
+
+    assert captured_options["live_log"] == live_log

package/scripts/test_claude_account_worker_report.py

@@ -51,6 +51,21 @@ def test_should_build_report_from_json_result_and_round_duration() -> None:
     assert report.wait_reset_at is None
 
 
+def test_should_take_the_result_event_from_streamed_output() -> None:
+    streamed_lines = "\n".join(
+        (
+            '{"type":"system","subtype":"init","session_id":"s1"}',
+            '{"type":"assistant","message":{"content":[]}}',
+            '{"type":"result","result":"ready","is_error":false}',
+        )
+    )
+
+    report = make_report("extra_2", "served", exit_code=0, duration_seconds=1.0, stdout_text=streamed_lines)
+
+    assert report.payload == "ready"
+    assert report.is_error is False
+
+
 def test_should_mark_report_as_error_when_json_flags_error() -> None:
     report = make_report(
         "extra_2",

package/scripts/tests/test_policy_lint_rules_retired_hook_prose.py

@@ -25,7 +25,7 @@ _HOOKS_CONFIGURATION = """
 """
 _DISPATCHER_ROSTER_SOURCE = """
 ALL_HOSTED_HOOK_ENTRIES = (
-    HostedHookEntry("advisory/refactor_guard.py", is_blocking=False),
+    HostedHookEntry("advisory/migration_safety_advisor.py", is_blocking=False),
 )
 """
 
@@ -40,7 +40,7 @@ def _build_package(repository_root: Path) -> None:
     (package_root / "bin").mkdir(parents=True)
     (package_root / "rules").mkdir(parents=True)
     (hooks_root / "blocking" / "windows_rmtree_blocker.py").write_text("", "utf-8")
-    (hooks_root / "advisory" / "refactor_guard.py").write_text("", "utf-8")
+    (hooks_root / "advisory" / "migration_safety_advisor.py").write_text("", "utf-8")
     (hooks_root / "observability" / "session_file_edit_tracker.py").write_text(
         "", "utf-8"
     )
@@ -96,7 +96,7 @@ def test_a_registered_hook_described_in_the_present_tense_passes(
     _build_package(tmp_path)
     all_messages = _diagnostics_for(
         tmp_path,
-        "`session_file_edit_tracker` records each Write path, and `refactor_guard` reports a risk.\n",
+        "`session_file_edit_tracker` records each Write path, and `migration_safety_advisor` reports a risk.\n",
     )
     assert all_messages == ()
 
@@ -156,7 +156,7 @@ def test_a_second_hook_name_bounds_the_first_claim(tmp_path: Path) -> None:
     _build_package(tmp_path)
     all_messages = _diagnostics_for(
         tmp_path,
-        "`destructive_command_blocker` was retired, and `refactor_guard` reports a risk.",
+        "`destructive_command_blocker` was retired, and `migration_safety_advisor` reports a risk.",
     )
     assert all_messages == ()
 

package/scripts/tests/test_rule_load_scopes.py

@@ -13,6 +13,7 @@ ALWAYS_ON_RULE_NAMES = frozenset(
         "correction-lens.md",
         "destructive-commands.md",
         "explore-thoroughly.md",
+        "features-start-with-an-eval.md",
         "filesystem-search.md",
         "memory-stores-durable-facts.md",
         "no-contrast-framing.md",

package/hooks/advisory/conftest.py

@@ -1,10 +0,0 @@
-"""Pytest registration for shared refactor guard test support."""
-
-import sys
-from pathlib import Path
-
-advisory_directory = str(Path(__file__).resolve().parent)
-if advisory_directory not in sys.path:
-    sys.path.insert(0, advisory_directory)
-
-from refactor_guard_test_support import git_repository  # noqa: E402, F401