claude-dev-env 8.98.9 → 8.98.11

package/hooks/test_open_task_asks.py

@@ -2,7 +2,7 @@ from pathlib import Path
 
 import pytest
 
-from open_task_asks import is_ask, record_prompt, recorded_prompts
+from open_task_asks import claude_home, is_ask
 
 
 @pytest.fixture(autouse=True)
@@ -41,17 +41,10 @@ def test_should_classify_work_prompts_as_asks(prompt_text: str, is_expected_ask:
     assert is_ask(prompt_text) is is_expected_ask
 
 
-def test_should_number_asks_and_keep_every_prompt_in_order() -> None:
-    assert record_prompt("s-1", "Export the APKs") == "ask-1"
-    assert record_prompt("s-1", "did it fail?") is None
-    assert record_prompt("s-1", "Submit them") == "ask-2"
-    assert [each_prompt.ask_id for each_prompt in recorded_prompts("s-1")] == [
-        "ask-1",
-        None,
-        "ask-2",
-    ]
+def test_should_read_the_claude_home_from_claude_config_dir(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(tmp_path / "profile"))
+    assert claude_home() == tmp_path / "profile"
 
 
-def test_should_skip_a_session_id_that_is_not_a_plain_name() -> None:
-    assert record_prompt("../escape", "Export the APKs") is None
-    assert recorded_prompts("../escape") == []
+def test_should_default_the_claude_home_to_the_user_home(tmp_path: Path) -> None:
+    assert claude_home() == tmp_path / ".claude"

package/package.json

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

package/rules/index.md

@@ -24,7 +24,7 @@ Each line gives a rule in brief. When its trigger matches your task, open the gu
 **Shipping**
 - **Pull request lifecycle**. Before a commit, push, pull request action, or merge. Invoke the `pr-lifecycle` skill; a hook denies those commands until it loads.
 - **Proof before a pull request** ([guide](../docs/rule-guides/proof-before-pull-request.md)). Before you open a pull request. Run the change with and without it, and quote both under "Proof in practice".
-- **Session title** ([guide](../docs/rule-guides/session-title.md)). The session has a tool whose name ends in `__set_session_title`. Set `<emoji> <name>` before each turn ends.
+- **Session title** ([guide](../docs/rule-guides/session-title.md)). The session has a tool whose name ends in `__set_session_title`. Set `<emoji> <name>` when the status changes.
 
 **Memory**
 - **Durable facts only** ([guide](../docs/rule-guides/memory-stores-durable-facts.md)). Writing auto-memory or a `MEMORY.md` entry. Keep only a fact that helps a fresh session weeks later.

package/scripts/codex_account_choice.py

@@ -5,7 +5,9 @@ Each Codex account signs in under its own Codex home in
 ``~/.codex-profiles/<name>``. The account list names them in try order: the
 ``CODEX_ACCOUNT_PROFILES`` environment variable, comma-separated, else the saved
 ``account-launchers.json`` list under the profiles root. With neither,
-``codex-1`` through ``codex-4`` are the roster.
+``codex-1`` through ``codex-4`` are the roster. An environment roster that
+differs from the saved file is saved to it, so a process without the variable
+reads the same roster.
 
 Three commands::
 
@@ -27,6 +29,7 @@ import argparse
 import json
 import os
 import sys
+import time
 from collections.abc import Callable, Sequence
 from datetime import datetime, timezone
 from pathlib import Path
@@ -60,8 +63,12 @@ from dev_env_scripts_constants.codex_account_constants import (
     MAIN_CODEX_HOME_DIRECTORY_NAME,
     ROSTER_JSON_INDENT,
     ROSTER_NOT_A_LIST_TEMPLATE,
+    ROSTER_REPLACE_ATTEMPTS,
+    ROSTER_REPLACE_RETRY_SECONDS,
+    SAVE_ENVIRONMENT_ROSTER_FAILED_TEMPLATE,
     SETUP_NAMES_SEPARATOR,
     SETUP_NO_SAVED_NAMES_TEXT,
+    SETUP_OVERRIDDEN_BY_ENVIRONMENT_TEMPLATE,
     SETUP_PROMPT_TEXT,
     SETUP_SAVED_NAMES_TEMPLATE,
     TEXT_ENCODING,
@@ -156,12 +163,44 @@ def _saved_roster_file_names(profiles_root: Path) -> tuple[str, ...]:
     return _roster(document, str(roster_path))
 
 
+def _saved_roster_or_nothing(profiles_root: Path) -> tuple[str, ...]:
+    try:
+        return _saved_roster_file_names(profiles_root)
+    except (CodexAccountNameError, OSError, UnicodeError):
+        return ()
+
+
+def _save_environment_roster(
+    profiles_root: Path, all_environment_names: tuple[str, ...]
+) -> None:
+    """Copy the environment roster into the saved file when the two differ.
+
+    A process started without ``CODEX_ACCOUNT_PROFILES`` then reads the same
+    roster from the file.
+
+    Args:
+        profiles_root: The directory that holds every account's Codex home.
+        all_environment_names: The validated names the environment gives.
+    """
+    if _saved_roster_or_nothing(profiles_root) == all_environment_names:
+        return
+    try:
+        save_codex_account_names(profiles_root, all_environment_names)
+    except OSError as error:
+        print(
+            SAVE_ENVIRONMENT_ROSTER_FAILED_TEMPLATE.format(
+                path=profiles_root / CODEX_ACCOUNT_LAUNCHERS_FILE_NAME, error=error
+            ),
+            file=sys.stderr,
+        )
+
+
 def saved_codex_account_names(profiles_root: Path) -> tuple[str, ...]:
     """Name the account list, in try order, without duplicates.
 
     ::
 
-        CODEX_ACCOUNT_PROFILES="alpha, beta,alpha" -> ("alpha", "beta")
+        CODEX_ACCOUNT_PROFILES="alpha, beta,alpha" -> ("alpha", "beta"), saved to the file
         unset, account-launchers.json ["gamma"]    -> ("gamma",)
         unset, no file                             -> ()
 
@@ -170,11 +209,16 @@ def saved_codex_account_names(profiles_root: Path) -> tuple[str, ...]:
 
     Returns:
         The environment's names when it names any, else the saved file's names.
+        Environment names that differ from the file are saved to it.
 
     Raises:
         CodexAccountNameError: When the environment or the file names an invalid account.
     """
-    return _environment_roster() or _saved_roster_file_names(profiles_root)
+    all_environment_names = _environment_roster()
+    if all_environment_names:
+        _save_environment_roster(profiles_root, all_environment_names)
+        return all_environment_names
+    return _saved_roster_file_names(profiles_root)
 
 
 def codex_account_names(profiles_root: Path) -> tuple[str, ...]:
@@ -192,15 +236,48 @@ def codex_account_names(profiles_root: Path) -> tuple[str, ...]:
 def save_codex_account_names(profiles_root: Path, all_names: Sequence[str]) -> None:
     """Write the account list as a JSON list under the profiles root.
 
+    The list goes to a staged file first, and ``os.replace`` moves it over the
+    saved file in one step, so a concurrent reader sees the old list or the new one.
+
     Args:
         profiles_root: The directory that holds every account's Codex home.
         all_names: The account names in try order.
     """
     profiles_root.mkdir(parents=True, exist_ok=True)
     roster_text = json.dumps(list(all_names), indent=ROSTER_JSON_INDENT) + "\n"
-    (profiles_root / CODEX_ACCOUNT_LAUNCHERS_FILE_NAME).write_bytes(
-        roster_text.encode(TEXT_ENCODING)
-    )
+    roster_path = profiles_root / CODEX_ACCOUNT_LAUNCHERS_FILE_NAME
+    staged_path = roster_path.with_name(f"{roster_path.name}.{os.getpid()}.tmp")
+    try:
+        staged_path.write_bytes(roster_text.encode(TEXT_ENCODING))
+        _replace_with_retries(staged_path, roster_path)
+    except OSError:
+        staged_path.unlink(missing_ok=True)
+        raise
+
+
+def _replace_with_retries(staged_path: Path, roster_path: Path) -> None:
+    """Replace the saved roster, retrying while a Windows reader holds it open.
+
+    Args:
+        staged_path: The fully written new roster file.
+        roster_path: The saved roster file to replace.
+
+    Raises:
+        PermissionError: When the saved file stays locked through every attempt.
+    """
+    for _ in range(ROSTER_REPLACE_ATTEMPTS - 1):
+        if _replaced(staged_path, roster_path):
+            return
+        time.sleep(ROSTER_REPLACE_RETRY_SECONDS)
+    os.replace(staged_path, roster_path)
+
+
+def _replaced(staged_path: Path, roster_path: Path) -> bool:
+    try:
+        os.replace(staged_path, roster_path)
+    except PermissionError:
+        return False
+    return True
 
 
 def _sync_account(
@@ -403,9 +480,24 @@ def _run_setup(arguments: argparse.Namespace) -> int:
         now=now,
     )
     print(json.dumps({JSON_INSTALLED_KEY: all_installed, JSON_RETIRED_KEY: all_retired}))
+    _warn_when_the_environment_replaces(all_names)
     return 0
 
 
+def _warn_when_the_environment_replaces(all_setup_names: tuple[str, ...]) -> None:
+    try:
+        all_environment_names = _environment_roster()
+    except CodexAccountNameError:
+        return
+    if all_environment_names and all_environment_names != all_setup_names:
+        print(
+            SETUP_OVERRIDDEN_BY_ENVIRONMENT_TEMPLATE.format(
+                names=SETUP_NAMES_SEPARATOR.join(all_environment_names)
+            ),
+            file=sys.stderr,
+        )
+
+
 def _add_main_home_argument(command_parser: argparse.ArgumentParser) -> None:
     command_parser.add_argument(
         "--main-home", type=Path, default=Path.home() / MAIN_CODEX_HOME_DIRECTORY_NAME

package/scripts/dev_env_scripts_constants/codex_account_constants.py

@@ -39,6 +39,23 @@ INVALID_ACCOUNT_ROSTER_TEMPLATE: str = "{source} names {name!r}: {reason}"
 ROSTER_NOT_A_LIST_TEMPLATE: str = "{source} must hold a JSON list of account names"
 """Error when the roster JSON is anything other than a list of names."""
 
+SAVE_ENVIRONMENT_ROSTER_FAILED_TEMPLATE: str = (
+    "warning: cannot save the CODEX_ACCOUNT_PROFILES roster to {path}: {error}"
+)
+"""Warning when the environment roster cannot be copied into the saved file."""
+
+ROSTER_REPLACE_ATTEMPTS: int = 5
+"""Tries at replacing the saved roster while a Windows reader holds it open."""
+
+ROSTER_REPLACE_RETRY_SECONDS: float = 0.05
+"""Pause between tries at replacing the saved roster."""
+
+SETUP_OVERRIDDEN_BY_ENVIRONMENT_TEMPLATE: str = (
+    "warning: CODEX_ACCOUNT_PROFILES names {names}; the next broker, sync or install run"
+    " saves that list over this setup list"
+)
+"""Warning when setup saves a list that the environment roster will replace."""
+
 ROSTER_JSON_INDENT: int = 2
 """Indent of the saved roster JSON, one name per line."""
 

package/scripts/policy_lint/adapter_configuration.py

@@ -175,8 +175,9 @@ def _names_exempt_registration_path(registered_string: str) -> bool:
     asks the model to check a hedged claim, and the call it reads stays in place.
 
     The session title gates keep the session title in its status format. One
-    denies a malformed title, and the other asks for a title before a turn
-    ends. They decide the shape of a title and no code or safety policy.
+    denies a malformed title, and the other asks for a new title when the
+    shown status stops fitting. They decide the shape of a title and no code
+    or safety policy.
 
     The artifact page gate denies a page publish whose text is unreadable in
     dark mode. It decides how a page renders and no code or safety policy.
@@ -193,10 +194,9 @@ def _names_exempt_registration_path(registered_string: str) -> bool:
     names open review findings. It reads only the wording of a chat card and
     decides no code or safety policy; the merge review gate holds the merge.
 
-    The open tasks Stop gate holds the end of a turn while the session's task
-    list has items the closing reply neither completes nor reports as
-    ``Blocked:`` or ``Open:``. It decides when a turn may end and no code or
-    safety policy.
+    The open tasks Stop gate holds the end of a turn once when the turn worked
+    on an ask and made no task list call. It decides when a turn may end and
+    no code or safety policy.
 
     The owned pull request Stop gate holds the end of a turn while a pull
     request the session opened on an owned repository is still open and the

package/scripts/test_account_broker.py

@@ -850,6 +850,18 @@ def test_should_use_default_codex_home_without_roster(
     assert "no roster" in decision.reason
 
 
+def test_should_keep_the_codex_roster_for_a_process_without_the_roster_variable(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    monkeypatch.setattr(account_broker.support.codex_account_choice, "default_profiles_root", lambda: tmp_path / "profiles")
+    monkeypatch.setenv("CODEX_ACCOUNT_PROFILES", "team,personal")
+    assert [each_account.name for each_account in account_broker.load_codex_accounts()] == ["team", "personal"]
+
+    monkeypatch.delenv("CODEX_ACCOUNT_PROFILES")
+
+    assert [each_account.name for each_account in account_broker.load_codex_accounts()] == ["team", "personal"]
+
+
 def test_should_reuse_meter_cache_for_60_seconds() -> None:
     account = _account("cached")
     calls: list[str] = []

package/scripts/test_codex_account_choice.py

@@ -144,6 +144,79 @@ class TestAccountRoster:
         monkeypatch.setenv("CODEX_ACCOUNT_PROFILES", " beta , alpha,, ")
         assert choice.saved_codex_account_names(tmp_path) == ("beta", "alpha")
 
+    def should_save_the_environment_roster_for_a_process_without_it(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv("CODEX_ACCOUNT_PROFILES", "beta,alpha")
+        assert choice.saved_codex_account_names(tmp_path) == ("beta", "alpha")
+        monkeypatch.delenv("CODEX_ACCOUNT_PROFILES")
+        assert choice.saved_codex_account_names(tmp_path) == ("beta", "alpha")
+
+    @pytest.mark.parametrize("saved_bytes", [b'["alpha",', b"\xff\xfe\x00"])
+    def should_replace_an_unreadable_saved_file_with_the_environment_roster(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, saved_bytes: bytes
+    ) -> None:
+        (tmp_path / "account-launchers.json").write_bytes(saved_bytes)
+        monkeypatch.setenv("CODEX_ACCOUNT_PROFILES", "alpha")
+        assert choice.saved_codex_account_names(tmp_path) == ("alpha",)
+        assert json.loads((tmp_path / "account-launchers.json").read_text(encoding="utf-8")) == ["alpha"]
+
+    def should_keep_the_environment_roster_when_the_saved_file_cannot_be_read(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        def refuse_read(_: Path) -> tuple[str, ...]:
+            raise PermissionError("locked")
+
+        monkeypatch.setattr(choice, "_saved_roster_file_names", refuse_read)
+        monkeypatch.setenv("CODEX_ACCOUNT_PROFILES", "alpha")
+        assert choice.saved_codex_account_names(tmp_path) == ("alpha",)
+
+    def should_remove_the_staged_roster_when_the_write_fails(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        original_write_bytes = Path.write_bytes
+
+        def fail_after_partial_write(path: Path, data: bytes) -> int:
+            original_write_bytes(path, data[:3])
+            raise OSError("disk full")
+
+        monkeypatch.setattr(Path, "write_bytes", fail_after_partial_write)
+        with pytest.raises(OSError, match="disk full"):
+            choice.save_codex_account_names(tmp_path, ("alpha",))
+        assert list(tmp_path.iterdir()) == []
+
+    @pytest.mark.parametrize("document", [["gamma"], ["alpha", "bad name"], {"alpha": 1}])
+    def should_replace_a_saved_file_that_differs_from_the_environment(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, document: object
+    ) -> None:
+        save_roster(tmp_path, document)
+        monkeypatch.setenv("CODEX_ACCOUNT_PROFILES", "alpha")
+        choice.saved_codex_account_names(tmp_path)
+        assert json.loads((tmp_path / "account-launchers.json").read_text(encoding="utf-8")) == ["alpha"]
+
+    def should_leave_a_saved_file_that_matches_the_environment_untouched(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        save_roster(tmp_path, ["beta", "alpha"])
+        saved_bytes = (tmp_path / "account-launchers.json").read_bytes()
+        monkeypatch.setenv("CODEX_ACCOUNT_PROFILES", "beta,alpha")
+        choice.saved_codex_account_names(tmp_path)
+        assert (tmp_path / "account-launchers.json").read_bytes() == saved_bytes
+
+    def should_keep_the_environment_roster_when_the_file_cannot_be_written(
+        self,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        def refuse_save(*_: object) -> None:
+            raise PermissionError("read-only")
+
+        monkeypatch.setattr(choice, "save_codex_account_names", refuse_save)
+        monkeypatch.setenv("CODEX_ACCOUNT_PROFILES", "alpha")
+        assert choice.saved_codex_account_names(tmp_path) == ("alpha",)
+        assert "cannot save the CODEX_ACCOUNT_PROFILES roster" in capsys.readouterr().err
+
     def should_read_the_saved_file_when_the_environment_is_unset(
         self, tmp_path: Path
     ) -> None:
@@ -190,6 +263,37 @@ class TestAccountRoster:
             b'[\n  "alpha",\n  "beta"\n]\n'
         )
         assert choice.saved_codex_account_names(profiles_root) == ("alpha", "beta")
+        assert [each.name for each in profiles_root.iterdir()] == ["account-launchers.json"]
+
+    def should_retry_a_replace_while_a_reader_holds_the_roster(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        original_replace = os.replace
+        all_attempts: list[object] = []
+
+        def refuse_first_replace(source: Path, target: Path) -> None:
+            all_attempts.append(source)
+            if len(all_attempts) == 1:
+                raise PermissionError("in use")
+            original_replace(source, target)
+
+        monkeypatch.setattr(choice.os, "replace", refuse_first_replace)
+        monkeypatch.setattr(choice.time, "sleep", lambda _: None)
+        choice.save_codex_account_names(tmp_path, ("alpha",))
+        assert len(all_attempts) == 2
+        assert json.loads((tmp_path / "account-launchers.json").read_text(encoding="utf-8")) == ["alpha"]
+
+    def should_remove_the_staged_roster_when_the_replace_fails(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        def refuse_replace(*_: object) -> None:
+            raise PermissionError("in use")
+
+        monkeypatch.setattr(choice.os, "replace", refuse_replace)
+        monkeypatch.setattr(choice.time, "sleep", lambda _: None)
+        with pytest.raises(PermissionError):
+            choice.save_codex_account_names(tmp_path, ("alpha",))
+        assert list(tmp_path.iterdir()) == []
 
     def should_fall_back_to_the_four_fixed_accounts_without_a_roster(
         self, tmp_path: Path
@@ -308,6 +412,23 @@ class TestSetupRoster:
             "profile name must use letters, digits, hyphens, or underscores",
         ]
 
+    @pytest.mark.parametrize(("environment_roster", "is_warned"), [("alpha,beta", True), ("alpha", False), ("", False), ("bad name", False)])
+    def should_warn_when_the_environment_roster_will_replace_the_setup_list(
+        self,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        capsys: pytest.CaptureFixture[str],
+        environment_roster: str,
+        is_warned: bool,
+    ) -> None:
+        monkeypatch.setattr(choice, "update_codex_account_roster", lambda **_: (("alpha",), {}))
+        monkeypatch.setenv("CODEX_ACCOUNT_PROFILES", environment_roster)
+        all_arguments = ["--profiles-root", str(tmp_path / "profiles"), "setup"]
+        main_home = build_codex_main_home(tmp_path)
+        assert choice.main([*all_arguments, "--main-home", str(main_home), "--launcher-directory", str(tmp_path / "bin")]) == 0
+        assert ("CODEX_ACCOUNT_PROFILES names alpha" in capsys.readouterr().err) is is_warned
+        assert (tmp_path / "bin" / "codex-alpha.cmd").is_file()
+
     def should_finish_at_the_end_of_input(self, tmp_path: Path) -> None:
         all_names, _ = choice.update_codex_account_roster(
             profiles_root=tmp_path,

package/hooks/session/open_task_ask_recorder.py

@@ -1,38 +0,0 @@
-#!/usr/bin/env python3
-"""UserPromptSubmit hook that records each prompt for the open tasks Stop gate.
-
-A prompt that asks for work becomes ``#ask-N`` in
-``~/.claude/open-task-asks/<session id>.json``. The gate then holds the turn
-until a reply closes it with ``Done: #ask-N``, or with
-``Dropped: #ask-N - "<the user's words>"`` quoting a later prompt. The hook
-prints nothing and always exits 0.
-"""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-hooks_root_directory = str(Path(__file__).resolve().parent.parent)
-if hooks_root_directory not in sys.path:
-    sys.path.insert(0, hooks_root_directory)
-
-from hooks_constants.open_tasks_stop_gate_constants import (
-    ALLOW_EXIT_CODE,
-    PROMPT_KEY,
-    SESSION_ID_KEY,
-)
-from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
-from open_task_asks import record_prompt
-
-
-def main() -> int:
-    hook_input = read_hook_input_dictionary_from_stdin()
-    prompt_value = hook_input.get(PROMPT_KEY) if hook_input is not None else None
-    if hook_input is not None and isinstance(prompt_value, str):
-        record_prompt(hook_input.get(SESSION_ID_KEY), prompt_value)
-    return ALLOW_EXIT_CODE
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/hooks/session/test_open_task_ask_recorder.py

@@ -1,57 +0,0 @@
-import json
-import subprocess
-import sys
-from pathlib import Path
-
-RECORDER_PATH = Path(__file__).resolve().parent / "open_task_ask_recorder.py"
-SESSION_ID = "s-123"
-
-
-def submit_prompt(home_directory: Path, prompt_text: str) -> subprocess.CompletedProcess[str]:
-    hook_input = {
-        "hook_event_name": "UserPromptSubmit",
-        "session_id": SESSION_ID,
-        "prompt": prompt_text,
-    }
-    return subprocess.run(
-        [sys.executable, str(RECORDER_PATH)],
-        input=json.dumps(hook_input),
-        capture_output=True,
-        text=True,
-        env={
-            "HOME": str(home_directory),
-            "USERPROFILE": str(home_directory),
-            "PATH": "",
-        },
-        check=False,
-    )
-
-
-def recorded_ask_ids(home_directory: Path) -> list[str]:
-    asks_path = home_directory / ".claude" / "open-task-asks" / f"{SESSION_ID}.json"
-    all_prompts = json.loads(asks_path.read_text(encoding="utf-8"))["prompts"]
-    return [each_prompt["ask_id"] for each_prompt in all_prompts if each_prompt["ask_id"]]
-
-
-def test_should_record_each_ask_outside_the_task_store_and_stay_silent(
-    tmp_path: Path,
-) -> None:
-    first_process = submit_prompt(tmp_path, "Export the OneUI8 and OneUI9 APKs and submit them")
-    submit_prompt(tmp_path, "did the export fail?")
-    submit_prompt(tmp_path, "<task-notification>\n<task-id>b1</task-id>\n</task-notification>")
-    submit_prompt(tmp_path, "can you check the release dates in neon?")
-    assert (first_process.returncode, first_process.stdout) == (0, "")
-    assert recorded_ask_ids(tmp_path) == ["ask-1", "ask-2"]
-    assert not (tmp_path / ".claude" / "tasks").exists()
-
-
-def test_should_allow_malformed_input(tmp_path: Path) -> None:
-    completed_process = subprocess.run(
-        [sys.executable, str(RECORDER_PATH)],
-        input="not json",
-        capture_output=True,
-        text=True,
-        env={"HOME": str(tmp_path), "USERPROFILE": str(tmp_path), "PATH": ""},
-        check=False,
-    )
-    assert (completed_process.returncode, completed_process.stdout) == (0, "")