claude-dev-env 8.69.0 → 8.69.1

package/scripts/claude_account_worker.py

@@ -19,15 +19,19 @@ from dev_env_scripts_constants.claude_account_worker_constants import (
     DEFAULT_TIMEOUT_MINUTES,
     INVALID_TIMEOUT_MESSAGE,
     LAUNCH_FAILURE_EXIT_CODE,
+    LIVE_LOG_FLAG,
     MINIMUM_TIMEOUT_MINUTES,
     MODEL_FLAG,
     OUTPUT_FORMAT_FLAG,
     OUTPUT_FORMAT_JSON,
+    OUTPUT_FORMAT_STREAM_JSON,
     PERMISSION_MODE_FLAG,
     PROMPT_FILE_FLAG,
     REPORT_FILE_FLAG,
     SINGLE_PROMPT_FLAG,
     TIMEOUT_MINUTES_FLAG,
+    UNWRITABLE_LIVE_LOG_MESSAGE,
+    VERBOSE_FLAG,
     UTF8_ENCODING,
 )
 
@@ -50,15 +54,16 @@ def build_argument_parser() -> argparse.ArgumentParser:
     parser.add_argument(MODEL_FLAG)
     parser.add_argument(PERMISSION_MODE_FLAG, default=DEFAULT_PERMISSION_MODE)
     parser.add_argument(TIMEOUT_MINUTES_FLAG, type=_positive_timeout_minutes, default=DEFAULT_TIMEOUT_MINUTES)
+    parser.add_argument(LIVE_LOG_FLAG, type=Path)
     return parser
 
 
-def _invocation(*, model: str | None, permission_mode: str) -> list[str]:
+def _invocation(*, model: str | None, permission_mode: str, is_streamed: bool) -> list[str]:
+    format_flags = [OUTPUT_FORMAT_FLAG, OUTPUT_FORMAT_STREAM_JSON, VERBOSE_FLAG] if is_streamed else [OUTPUT_FORMAT_FLAG, OUTPUT_FORMAT_JSON]
     arguments = [
         CLAUDE_BINARY_NAME,
         SINGLE_PROMPT_FLAG,
-        OUTPUT_FORMAT_FLAG,
-        OUTPUT_FORMAT_JSON,
+        *format_flags,
         PERMISSION_MODE_FLAG,
         permission_mode,
     ]
@@ -81,20 +86,33 @@ def run_worker(
     model: str | None,
     permission_mode: str,
     timeout_minutes: int,
+    live_log: Path | None = None,
 ) -> int:
-    """Run one worker and write its structured report."""
+    """Run one worker and write its structured report.
+
+    With ``live_log`` set, the worker streams one JSON event per line into that
+    file while it runs, so a watching session can read progress before the end.
+    A live log that cannot be written ends the run before the broker starts.
+    """
     try:
         prompt_text = prompt_file.read_text(encoding=UTF8_ENCODING)
     except (OSError, UnicodeError):
         report = pre_launch_failure_report("none", "prompt file is unreadable", LAUNCH_FAILURE_EXIT_CODE)
         return finalize_report(report_file, report)
+    if live_log is not None:
+        try:
+            live_log.write_bytes(b"")
+        except OSError:
+            report = pre_launch_failure_report("none", UNWRITABLE_LIVE_LOG_MESSAGE, LAUNCH_FAILURE_EXIT_CODE)
+            return finalize_report(report_file, report)
     try:
         outcome, duration_seconds = invoke_worker(
-            all_arguments=_invocation(model=model, permission_mode=permission_mode),
+            all_arguments=_invocation(model=model, permission_mode=permission_mode, is_streamed=live_log is not None),
             cwd=cwd,
             prompt_text=prompt_text,
             timeout_minutes=timeout_minutes,
             runner=worker_job_runner,
+            live_log=live_log,
         )
     except BrokerConfigurationError as error:
         report = pre_launch_failure_report("none", str(error), CONFIGURATION_FAILURE_EXIT_CODE)
@@ -122,6 +140,7 @@ def main() -> int:
         model=arguments.model,
         permission_mode=arguments.permission_mode,
         timeout_minutes=arguments.timeout_minutes,
+        live_log=arguments.live_log,
     )
 
 

package/scripts/claude_account_worker_process.py

@@ -17,6 +17,7 @@ def invoke_worker(
     prompt_text: str,
     timeout_minutes: int,
     runner: Callable[..., JobOutcome],
+    live_log: Path | None = None,
     monotonic_clock: Callable[[], float] = time.monotonic,
 ) -> tuple[JobOutcome, float]:
     """Run one broker job and measure its elapsed time.
@@ -28,12 +29,15 @@ def invoke_worker(
         timeout_minutes: Job time limit in minutes; the runner receives it in seconds.
         runner: Broker job runner, called with ``Product.CLAUDE``,
             ``encoding="utf-8"``, and ``errors="replace"``.
+        live_log: File the runner writes the job's standard output into as it
+            runs, passed only when set.
         monotonic_clock: Clock read once before and once after the job.
 
     Returns:
         The runner's job outcome and the difference between the two clock reads.
     """
     started_at = monotonic_clock()
+    all_log_options = {} if live_log is None else {"live_log": live_log}
     outcome = runner(
         Product.CLAUDE,
         all_arguments,
@@ -42,5 +46,6 @@ def invoke_worker(
         cwd=cwd,
         encoding="utf-8",
         errors="replace",
+        **all_log_options,
     )
     return outcome, monotonic_clock() - started_at

package/scripts/claude_account_worker_report.py

@@ -9,6 +9,7 @@ from pathlib import Path
 
 from dev_env_scripts_constants.claude_account_worker_constants import (
     DURATION_DECIMAL_PLACES,
+    JSON_EVENT_TYPE_KEY,
     JSON_IS_ERROR_KEY,
     JSON_RESULT_KEY,
     REPORT_ACCOUNT_KEY,
@@ -18,6 +19,7 @@ from dev_env_scripts_constants.claude_account_worker_constants import (
     REPORT_IS_ERROR_KEY,
     REPORT_REASON_KEY,
     REPORT_RESULT_KEY,
+    RESULT_EVENT_TYPE,
     STDOUT_TAIL_CHARACTER_LIMIT,
     SUMMARY_LINE_TEMPLATE,
     UTF8_ENCODING,
@@ -41,11 +43,24 @@ def _bounded_stdout_tail(stdout_text: str) -> str:
     return stdout_text[-STDOUT_TAIL_CHARACTER_LIMIT:]
 
 
+def _closing_event(stdout_text: str) -> dict[str, object] | None:
+    for each_line in reversed(stdout_text.splitlines()):
+        try:
+            parsed_line = json.loads(each_line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(parsed_line, dict) and parsed_line.get(JSON_EVENT_TYPE_KEY) == RESULT_EVENT_TYPE:
+            return parsed_line
+    return None
+
+
 def _extract_payload(stdout_text: str) -> tuple[object, bool]:
     try:
         parsed_stdout = json.loads(stdout_text)
     except json.JSONDecodeError:
-        return _bounded_stdout_tail(stdout_text), True
+        parsed_stdout = _closing_event(stdout_text)
+        if parsed_stdout is None:
+            return _bounded_stdout_tail(stdout_text), True
     if not isinstance(parsed_stdout, dict) or JSON_RESULT_KEY not in parsed_stdout:
         return None, True
     return parsed_stdout[JSON_RESULT_KEY], parsed_stdout.get(JSON_IS_ERROR_KEY) is True

package/scripts/dev_env_scripts_constants/claude_account_worker_constants.py

@@ -43,6 +43,16 @@ OUTPUT_FORMAT_FLAG: str = "--output-format"
 
 OUTPUT_FORMAT_JSON: str = "json"
 
+OUTPUT_FORMAT_STREAM_JSON: str = "stream-json"
+
+VERBOSE_FLAG: str = "--verbose"
+
+LIVE_LOG_FLAG: str = "--live-log"
+
+JSON_EVENT_TYPE_KEY: str = "type"
+
+RESULT_EVENT_TYPE: str = "result"
+
 SINGLE_PROMPT_FLAG: str = "-p"
 
 SECONDS_PER_MINUTE: int = 60
@@ -67,6 +77,8 @@ SUMMARY_LINE_TEMPLATE: str = "account={account} exit_code={exit_code} report={re
 
 INVALID_TIMEOUT_MESSAGE: str = "--timeout-minutes must be at least 1"
 
+UNWRITABLE_LIVE_LOG_MESSAGE: str = "live log file is unwritable"
+
 
 __all__ = [
     "CLAUDE_BINARY_NAME",

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_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