claude-dev-env 8.117.0 → 8.117.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -20,6 +20,10 @@ test('EVER_REGISTERED_HOOK_RELATIVE_PATHS includes every script the package regi
20
20
  );
21
21
  });
22
22
 
23
+ test('EVER_REGISTERED_HOOK_RELATIVE_PATHS keeps the question brief gate', () => {
24
+ assert.ok(EVER_REGISTERED_HOOK_RELATIVE_PATHS.has('blocking/question_brief_gate.py'));
25
+ });
26
+
23
27
  test('EVER_REGISTERED_HOOK_RELATIVE_PATHS keeps the retired merge-over-review card gate', () => {
24
28
  assert.equal(
25
29
  EVER_REGISTERED_HOOK_RELATIVE_PATHS.has('blocking/merge_over_review_offer_gate.py'),
@@ -0,0 +1,166 @@
1
+ import json
2
+ import sys
3
+ import tempfile
4
+ from pathlib import Path
5
+
6
+ import pytest
7
+
8
+ from hooks_constants.turn_review_gate_constants import REVIEW_FAILURE_DIAGNOSTIC_TEMPLATE
9
+ from turn_review_child import (
10
+ _child_stdout,
11
+ _ChildRun,
12
+ _judge_command,
13
+ _review_command,
14
+ _review_environment,
15
+ )
16
+
17
+ PARENT_SESSION_VARIABLES = (
18
+ "CLAUDE_CODE_SESSION_ID",
19
+ "CLAUDE_CODE_REMOTE_SESSION_ID",
20
+ "CLAUDE_CODE_MESSAGING_SOCKET",
21
+ "CLAUDE_CODE_MESSAGING_TOKEN",
22
+ "CLAUDE_SESSION_INGRESS_TOKEN_FILE",
23
+ "CLAUDE_CODE_POST_FOR_SESSION_INGRESS_V2",
24
+ "CLAUDE_CODE_TEE_SDK_STDOUT",
25
+ )
26
+ CHILD_REPORT_SOURCE = """import json
27
+ import os
28
+ import sys
29
+
30
+ print(json.dumps({
31
+ "cwd": os.getcwd(),
32
+ "stdin": sys.stdin.read(),
33
+ "marker": os.environ.get("CLAUDE_TURN_REVIEW_CHILD"),
34
+ "parent_session": os.environ.get("CLAUDE_CODE_SESSION_ID"),
35
+ }))
36
+ """
37
+ FAILING_CHILD_SOURCE = """import sys
38
+
39
+ print("partial review")
40
+ sys.exit(3)
41
+ """
42
+ SLOW_CHILD_SOURCE = """import time
43
+
44
+ time.sleep(5)
45
+ print("late review")
46
+ """
47
+
48
+
49
+ @pytest.fixture(autouse=True)
50
+ def isolated_home(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
51
+ home_directory = tmp_path / "home"
52
+ home_directory.mkdir()
53
+ state_directory = tmp_path / "state"
54
+ state_directory.mkdir()
55
+ monkeypatch.setenv("HOME", str(home_directory))
56
+ monkeypatch.setenv("USERPROFILE", str(home_directory))
57
+ monkeypatch.setattr(tempfile, "tempdir", str(state_directory))
58
+ return home_directory
59
+
60
+
61
+ @pytest.fixture
62
+ def checkout(tmp_path: Path) -> Path:
63
+ repository_root = tmp_path / "app"
64
+ repository_root.mkdir()
65
+ return repository_root
66
+
67
+
68
+ def child_run(
69
+ tmp_path: Path, repository_root: Path, child_source: str, prompt_text: str | None
70
+ ) -> _ChildRun:
71
+ child_script = tmp_path / "child.py"
72
+ child_script.write_text(child_source)
73
+ return _ChildRun(
74
+ repository_root,
75
+ [sys.executable, str(child_script)],
76
+ prompt_text,
77
+ REVIEW_FAILURE_DIAGNOSTIC_TEMPLATE,
78
+ )
79
+
80
+
81
+ def log_lines(home_directory: Path) -> list[str]:
82
+ log_path = home_directory / ".claude" / "logs" / "turn-review.log"
83
+ return log_path.read_text().splitlines() if log_path.exists() else []
84
+
85
+
86
+ def test_should_build_the_review_command_for_the_range_with_read_only_options(
87
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
88
+ ) -> None:
89
+ stub_directory = tmp_path / "bin"
90
+ stub_directory.mkdir()
91
+ stub_claude = stub_directory / "claude"
92
+ stub_claude.write_text("")
93
+ stub_claude.chmod(0o755)
94
+ monkeypatch.setenv("PATH", str(stub_directory))
95
+ review_command = _review_command("aaa111", "bbb222")
96
+ assert review_command[:7] == [
97
+ str(stub_claude),
98
+ "-p",
99
+ "/code-review low aaa111..bbb222",
100
+ "--model",
101
+ "sonnet",
102
+ "--effort",
103
+ "high",
104
+ ]
105
+ assert review_command[review_command.index("--tools") + 1] == "Read,Grep,Glob,Bash"
106
+ assert review_command[review_command.index("--permission-mode") + 1] == "dontAsk"
107
+ assert json.loads(review_command[review_command.index("--settings") + 1]) == {
108
+ "disableAllHooks": True
109
+ }
110
+
111
+
112
+ def test_should_build_the_judge_command_with_no_prompt_argument(
113
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
114
+ ) -> None:
115
+ monkeypatch.setenv("PATH", str(tmp_path))
116
+ judge_command = _judge_command()
117
+ assert judge_command[:6] == ["claude", "-p", "--model", "sonnet", "--effort", "high"]
118
+ assert "--no-session-persistence" in judge_command
119
+
120
+
121
+ def test_should_drop_every_parent_session_variable_from_the_child_environment(
122
+ monkeypatch: pytest.MonkeyPatch,
123
+ ) -> None:
124
+ for each_name in PARENT_SESSION_VARIABLES:
125
+ monkeypatch.setenv(each_name, "parent-value")
126
+ monkeypatch.setenv("TURN_REVIEW_KEPT_VARIABLE", "kept")
127
+ child_environment = _review_environment()
128
+ assert [
129
+ each_name for each_name in PARENT_SESSION_VARIABLES if each_name in child_environment
130
+ ] == []
131
+ assert child_environment["CLAUDE_TURN_REVIEW_CHILD"] == "1"
132
+ assert child_environment["TURN_REVIEW_KEPT_VARIABLE"] == "kept"
133
+
134
+
135
+ def test_should_run_the_child_in_the_checkout_with_the_prompt_on_stdin(
136
+ tmp_path: Path, checkout: Path, monkeypatch: pytest.MonkeyPatch
137
+ ) -> None:
138
+ monkeypatch.setenv("CLAUDE_CODE_SESSION_ID", "parent-session")
139
+ child_output = _child_stdout(
140
+ child_run(tmp_path, checkout, CHILD_REPORT_SOURCE, "judge data"), 30
141
+ )
142
+ assert child_output is not None
143
+ assert json.loads(child_output) == {
144
+ "cwd": str(checkout.resolve()),
145
+ "stdin": "judge data",
146
+ "marker": "1",
147
+ "parent_session": None,
148
+ }
149
+
150
+
151
+ def test_should_give_no_output_and_log_a_child_that_exits_with_an_error(
152
+ tmp_path: Path, checkout: Path, isolated_home: Path
153
+ ) -> None:
154
+ assert _child_stdout(child_run(tmp_path, checkout, FAILING_CHILD_SOURCE, None), 30) is None
155
+ assert [each_line.split(" ", 1)[1] for each_line in log_lines(isolated_home)] == [
156
+ "[turn_review_gate] review of app did not finish: exit 3"
157
+ ]
158
+
159
+
160
+ def test_should_give_no_output_and_log_a_child_that_runs_out_of_time(
161
+ tmp_path: Path, checkout: Path, isolated_home: Path
162
+ ) -> None:
163
+ assert _child_stdout(child_run(tmp_path, checkout, SLOW_CHILD_SOURCE, None), 0.5) is None
164
+ assert [each_line.split(" ", 1)[1] for each_line in log_lines(isolated_home)] == [
165
+ "[turn_review_gate] review of app did not finish: timed out"
166
+ ]
@@ -0,0 +1,194 @@
1
+ import subprocess
2
+ import tempfile
3
+ from pathlib import Path
4
+
5
+ import pytest
6
+
7
+ from hooks_constants.turn_review_gate_constants import BLOCK_REASON_TEMPLATE
8
+ from turn_review_claim import (
9
+ _claim_locked_stop,
10
+ _is_wake_prompt,
11
+ _JudgeRequest,
12
+ _judge_requests,
13
+ _locked_stop_wake,
14
+ _prompt_baselines,
15
+ )
16
+ from turn_review_findings import JudgeVerdict
17
+ from turn_review_snapshot import working_tree_snapshot
18
+ from turn_review_state import _Finding, _load_state, _ReviewState, _save_state
19
+
20
+ SESSION_ID = "claim-session"
21
+ BASE_COMMIT = "a" * 40
22
+ TURN_COMMIT = "b" * 40
23
+ FINDING_TEXT = "src/service.py:3 - The diff drops the retry."
24
+
25
+
26
+ @pytest.fixture(autouse=True)
27
+ def isolated_home(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
28
+ home_directory = tmp_path / "home"
29
+ home_directory.mkdir()
30
+ state_directory = tmp_path / "state"
31
+ state_directory.mkdir()
32
+ monkeypatch.setenv("HOME", str(home_directory))
33
+ monkeypatch.setenv("USERPROFILE", str(home_directory))
34
+ monkeypatch.setattr(tempfile, "tempdir", str(state_directory))
35
+ return home_directory
36
+
37
+
38
+ def git(repository: Path, *all_arguments: str) -> str:
39
+ return subprocess.run(
40
+ ["git", *all_arguments], cwd=repository, check=True, capture_output=True, text=True
41
+ ).stdout.strip()
42
+
43
+
44
+ @pytest.fixture
45
+ def repository(tmp_path: Path) -> Path:
46
+ repository_root = tmp_path / "app"
47
+ repository_root.mkdir()
48
+ git(repository_root, "init", "-q", "-b", "main")
49
+ git(repository_root, "config", "user.email", "test@example.com")
50
+ git(repository_root, "config", "user.name", "Test")
51
+ (repository_root / "service.py").write_text("call()\n")
52
+ git(repository_root, "add", "-A")
53
+ git(repository_root, "commit", "-q", "-m", "start")
54
+ return repository_root
55
+
56
+
57
+ def log_text(home_directory: Path) -> str:
58
+ log_path = home_directory / ".claude" / "logs" / "turn-review.log"
59
+ return log_path.read_text() if log_path.exists() else ""
60
+
61
+
62
+ def test_should_count_a_prompt_inside_the_wake_window_or_a_task_notification_as_the_wake() -> None:
63
+ woken_state = _ReviewState(last_wake_at=1000.0)
64
+ assert _is_wake_prompt(woken_state, "next task", 1009.9) is True
65
+ assert _is_wake_prompt(woken_state, "next task", 1010.0) is False
66
+ assert (
67
+ _is_wake_prompt(_ReviewState(), " <task-notification>done</task-notification>", 0.0)
68
+ is True
69
+ )
70
+ assert _is_wake_prompt(_ReviewState(), "next task", 0.0) is False
71
+
72
+
73
+ def test_should_keep_the_saved_baseline_only_while_the_turn_is_open(repository: Path) -> None:
74
+ saved_baselines = {str(repository): BASE_COMMIT}
75
+ open_state = _ReviewState(all_baselines=saved_baselines, is_turn_open=True)
76
+ assert _prompt_baselines(open_state, [repository]) == saved_baselines
77
+ closed_state = _ReviewState(all_baselines=saved_baselines, is_turn_open=False)
78
+ fresh_commit = _prompt_baselines(closed_state, [repository])[str(repository)]
79
+ assert fresh_commit != BASE_COMMIT
80
+ assert git(repository, "rev-parse", f"{fresh_commit}^") == git(repository, "rev-parse", "HEAD")
81
+
82
+
83
+ def test_should_judge_only_an_open_finding_in_a_reviewed_checkout(
84
+ repository: Path, isolated_home: Path
85
+ ) -> None:
86
+ open_finding = _Finding(FINDING_TEXT, str(repository), BASE_COMMIT, TURN_COMMIT)
87
+ review_state = _ReviewState(
88
+ all_findings={
89
+ "TR-1": open_finding,
90
+ "TR-2": _Finding(FINDING_TEXT, str(repository), BASE_COMMIT, TURN_COMMIT, "dismissed"),
91
+ "TR-3": _Finding(FINDING_TEXT, "/elsewhere/lib", BASE_COMMIT, TURN_COMMIT),
92
+ }
93
+ )
94
+ all_reasons = {
95
+ "TR-1": "The caller retries.",
96
+ "TR-2": "Asked again.",
97
+ "TR-3": "Other checkout.",
98
+ "TR-9": "Unknown.",
99
+ }
100
+ assert _judge_requests(review_state, all_reasons, [repository], False) == [
101
+ _JudgeRequest("TR-1", open_finding, "The caller retries.")
102
+ ]
103
+ assert _judge_requests(review_state, {"TR-1": "The caller retries."}, [repository], True) == []
104
+ logged_text = log_text(isolated_home)
105
+ assert "Dismiss TR-2 ignored: the finding is dismissed" in logged_text
106
+ assert (
107
+ "Dismiss TR-3 ignored: the finding is in a checkout this stop does not review"
108
+ in logged_text
109
+ )
110
+ assert "Dismiss TR-9 ignored: the finding is not a finding of this session" in logged_text
111
+ assert "Dismiss TR-1 waits: the hold cap is reached, so no judge ran" in logged_text
112
+
113
+
114
+ def test_should_claim_the_turn_range_once_and_move_the_baseline(repository: Path) -> None:
115
+ base_commit = working_tree_snapshot(repository, None)
116
+ assert base_commit is not None
117
+ _save_state(
118
+ SESSION_ID,
119
+ _ReviewState(
120
+ all_baselines={str(repository): base_commit}, blocks_in_a_row=2, is_turn_open=True
121
+ ),
122
+ )
123
+ (repository / "service.py").write_text("call(1)\n")
124
+ first_claim = _claim_locked_stop(SESSION_ID, [repository], {})
125
+ claimed_state = _load_state(SESSION_ID)
126
+ turn_commit = claimed_state.all_baselines[str(repository)]
127
+ assert turn_commit != base_commit
128
+ assert first_claim.all_turn_ranges == [(repository, base_commit, turn_commit)]
129
+ assert claimed_state.is_turn_open is False
130
+ assert claimed_state.blocks_in_a_row == 2
131
+ second_claim = _claim_locked_stop(SESSION_ID, [repository], {})
132
+ assert second_claim.all_turn_ranges == []
133
+ assert _load_state(SESSION_ID).blocks_in_a_row == 0
134
+
135
+
136
+ def test_should_wake_with_the_rejections_in_id_order_and_the_new_findings(tmp_path: Path) -> None:
137
+ repository_root = tmp_path / "app"
138
+ _save_state(
139
+ SESSION_ID,
140
+ _ReviewState(
141
+ blocks_in_a_row=1,
142
+ all_findings={
143
+ "TR-2": _Finding(FINDING_TEXT, str(repository_root), BASE_COMMIT, TURN_COMMIT),
144
+ "TR-10": _Finding(FINDING_TEXT, str(repository_root), BASE_COMMIT, TURN_COMMIT),
145
+ },
146
+ ),
147
+ )
148
+ all_verdicts = {
149
+ "TR-10": JudgeVerdict(is_approved=False, reason="Nothing retries.\n"),
150
+ "TR-2": JudgeVerdict(is_approved=False, reason="The diff still drops it. "),
151
+ }
152
+ wake_text = _locked_stop_wake(
153
+ SESSION_ID,
154
+ [(repository_root, BASE_COMMIT, TURN_COMMIT, ["src/service.py:9 - The update is lost."])],
155
+ all_verdicts,
156
+ )
157
+ assert wake_text == (
158
+ "Dismissal of TR-2 rejected: The diff still drops it. Fix it.\n"
159
+ "Dismissal of TR-10 rejected: Nothing retries. Fix it.\n\n"
160
+ + BLOCK_REASON_TEMPLATE.format(
161
+ all_findings="app:\n[TR-11] src/service.py:9 - The update is lost."
162
+ )
163
+ )
164
+ saved_state = _load_state(SESSION_ID)
165
+ assert {each_id: each.status for each_id, each in saved_state.all_findings.items()} == {
166
+ "TR-2": "upheld",
167
+ "TR-10": "upheld",
168
+ "TR-11": "open",
169
+ }
170
+ assert saved_state.blocks_in_a_row == 2
171
+ assert saved_state.last_wake_at is not None
172
+
173
+
174
+ def test_should_dismiss_quietly_on_an_approval_and_keep_a_capped_hold_count(
175
+ tmp_path: Path, isolated_home: Path
176
+ ) -> None:
177
+ approval = {"TR-1": JudgeVerdict(is_approved=True, reason="The caller retries.")}
178
+ for each_blocks, each_expected_blocks in ((2, 0), (3, 3)):
179
+ _save_state(
180
+ SESSION_ID,
181
+ _ReviewState(
182
+ blocks_in_a_row=each_blocks,
183
+ all_findings={
184
+ "TR-1": _Finding(FINDING_TEXT, str(tmp_path), BASE_COMMIT, TURN_COMMIT)
185
+ },
186
+ ),
187
+ )
188
+ assert _locked_stop_wake(SESSION_ID, [], approval) is None
189
+ saved_state = _load_state(SESSION_ID)
190
+ assert saved_state.all_findings["TR-1"].status == "dismissed"
191
+ assert saved_state.all_findings["TR-1"].judge_reason == "The caller retries."
192
+ assert saved_state.blocks_in_a_row == each_expected_blocks
193
+ assert saved_state.last_wake_at is None
194
+ assert "[turn_review_gate] TR-1 dismissed: The caller retries." in log_text(isolated_home)
@@ -0,0 +1,65 @@
1
+ import subprocess
2
+ import tempfile
3
+ from pathlib import Path
4
+
5
+ import pytest
6
+
7
+ from turn_review_repositories import _opted_in_repository_roots, _opted_in_repository_slugs
8
+
9
+
10
+ @pytest.fixture(autouse=True)
11
+ def isolated_home(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
12
+ home_directory = tmp_path / "home"
13
+ home_directory.mkdir()
14
+ state_directory = tmp_path / "state"
15
+ state_directory.mkdir()
16
+ monkeypatch.setenv("HOME", str(home_directory))
17
+ monkeypatch.setenv("USERPROFILE", str(home_directory))
18
+ monkeypatch.setattr(tempfile, "tempdir", str(state_directory))
19
+ return home_directory
20
+
21
+
22
+ def checkout(folder: Path, origin_slug: str) -> Path:
23
+ folder.mkdir(parents=True, exist_ok=True)
24
+ subprocess.run(["git", "init", "-q", "-b", "main"], cwd=folder, check=True, capture_output=True)
25
+ subprocess.run(
26
+ ["git", "remote", "add", "origin", f"https://github.com/{origin_slug}.git"],
27
+ cwd=folder,
28
+ check=True,
29
+ capture_output=True,
30
+ )
31
+ return folder
32
+
33
+
34
+ def test_should_read_the_listed_slugs_without_letter_case_or_blanks(
35
+ monkeypatch: pytest.MonkeyPatch,
36
+ ) -> None:
37
+ monkeypatch.setenv("CLAUDE_TURN_REVIEW_REPOSITORIES", " Owner/App , ,owner/LIB, ")
38
+ assert _opted_in_repository_slugs() == frozenset({"owner/app", "owner/lib"})
39
+
40
+
41
+ def test_should_take_only_a_checkout_whose_origin_is_listed(
42
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
43
+ ) -> None:
44
+ project_directory = tmp_path / "workspace"
45
+ listed_checkout = checkout(project_directory / "app", "owner/app")
46
+ checkout(project_directory / "docs", "owner/docs")
47
+ (project_directory / "notes").mkdir()
48
+ (project_directory / "readme.txt").write_text("notes\n")
49
+ monkeypatch.setenv("CLAUDE_PROJECT_DIR", str(project_directory))
50
+ assert _opted_in_repository_roots(frozenset({"owner/app"})) == [listed_checkout.resolve()]
51
+
52
+
53
+ def test_should_list_the_project_folder_first_then_its_children_by_name(
54
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
55
+ ) -> None:
56
+ project_directory = checkout(tmp_path / "workspace", "owner/workspace")
57
+ zeta_checkout = checkout(project_directory / "zeta", "owner/zeta")
58
+ alpha_checkout = checkout(project_directory / "alpha", "owner/alpha")
59
+ monkeypatch.setenv("CLAUDE_PROJECT_DIR", str(project_directory))
60
+ all_slugs = frozenset({"owner/workspace", "owner/zeta", "owner/alpha"})
61
+ assert _opted_in_repository_roots(all_slugs) == [
62
+ project_directory.resolve(),
63
+ alpha_checkout.resolve(),
64
+ zeta_checkout.resolve(),
65
+ ]
@@ -0,0 +1,132 @@
1
+ import json
2
+ import os
3
+ import tempfile
4
+ from pathlib import Path
5
+
6
+ import pytest
7
+
8
+ from turn_review_state import (
9
+ _Finding,
10
+ _is_lock_taken,
11
+ _load_state,
12
+ _log,
13
+ _next_finding_id,
14
+ _release_and_close,
15
+ _ReviewState,
16
+ _save_state,
17
+ _state_path,
18
+ )
19
+
20
+ SESSION_ID = "state-session"
21
+ BASE_COMMIT = "a" * 40
22
+ TURN_COMMIT = "b" * 40
23
+
24
+
25
+ @pytest.fixture(autouse=True)
26
+ def isolated_home(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
27
+ home_directory = tmp_path / "home"
28
+ home_directory.mkdir()
29
+ state_directory = tmp_path / "state"
30
+ state_directory.mkdir()
31
+ monkeypatch.setenv("HOME", str(home_directory))
32
+ monkeypatch.setenv("USERPROFILE", str(home_directory))
33
+ monkeypatch.setattr(tempfile, "tempdir", str(state_directory))
34
+ return home_directory
35
+
36
+
37
+ def log_lines(home_directory: Path) -> list[str]:
38
+ log_path = home_directory / ".claude" / "logs" / "turn-review.log"
39
+ return log_path.read_text().splitlines() if log_path.exists() else []
40
+
41
+
42
+ def test_should_load_every_field_a_save_wrote() -> None:
43
+ saved_state = _ReviewState(
44
+ all_baselines={"/work/app": BASE_COMMIT},
45
+ blocks_in_a_row=2,
46
+ is_turn_open=True,
47
+ last_wake_at=100.5,
48
+ open_turn_prompt_at=90.0,
49
+ all_findings={
50
+ "TR-3": _Finding(
51
+ "src/service.py:3 - drops the retry",
52
+ "/work/app",
53
+ BASE_COMMIT,
54
+ TURN_COMMIT,
55
+ "upheld",
56
+ "Nothing retries.",
57
+ )
58
+ },
59
+ )
60
+ _save_state(SESSION_ID, saved_state)
61
+ assert _state_path(SESSION_ID).name == "turn-review-state-session.json"
62
+ assert _load_state(SESSION_ID) == saved_state
63
+
64
+
65
+ def test_should_leave_out_saved_entries_in_another_form() -> None:
66
+ finding_record = {
67
+ "text": "src/service.py:3 - drops the retry",
68
+ "repository": "/work/app",
69
+ "base": BASE_COMMIT,
70
+ "turn": TURN_COMMIT,
71
+ "status": "open",
72
+ "judge_reason": None,
73
+ }
74
+ _state_path(SESSION_ID).write_text(
75
+ json.dumps(
76
+ {
77
+ "baselines": {"/work/app": BASE_COMMIT, "/work/lib": "HEAD~1"},
78
+ "blocks_in_a_row": 1,
79
+ "turn_open": 1,
80
+ "last_wake_at": True,
81
+ "findings": {
82
+ "TR-1": finding_record,
83
+ "TR-01": finding_record,
84
+ "TR-2": {**finding_record, "status": "closed"},
85
+ "TR-4": {**finding_record, "turn": "main"},
86
+ },
87
+ }
88
+ )
89
+ )
90
+ loaded_state = _load_state(SESSION_ID)
91
+ assert loaded_state.all_baselines == {"/work/app": BASE_COMMIT}
92
+ assert loaded_state.blocks_in_a_row == 1
93
+ assert loaded_state.is_turn_open is False
94
+ assert loaded_state.last_wake_at is None
95
+ assert list(loaded_state.all_findings) == ["TR-1"]
96
+
97
+
98
+ def test_should_give_an_empty_state_for_a_file_that_is_not_json() -> None:
99
+ _state_path(SESSION_ID).write_text("{not json")
100
+ assert _load_state(SESSION_ID) == _ReviewState()
101
+
102
+
103
+ def test_should_number_the_next_finding_after_the_highest_id() -> None:
104
+ finding = _Finding("text", "/work/app", BASE_COMMIT, TURN_COMMIT)
105
+ review_state = _ReviewState(all_findings={"TR-2": finding, "TR-10": finding})
106
+ assert _next_finding_id(review_state) == "TR-11"
107
+ assert _next_finding_id(_ReviewState()) == "TR-1"
108
+
109
+
110
+ def test_should_log_one_dated_line_each_call_and_log_a_failed_save(isolated_home: Path) -> None:
111
+ _log("[turn_review_gate] first\n")
112
+ _log("[turn_review_gate] second\n")
113
+ _state_path(SESSION_ID).mkdir()
114
+ _save_state(SESSION_ID, _ReviewState(blocks_in_a_row=1))
115
+ all_lines = log_lines(isolated_home)
116
+ assert len(all_lines) == 3
117
+ assert all_lines[0].endswith(" [turn_review_gate] first")
118
+ assert all_lines[0][:4].isdigit()
119
+ assert all_lines[1].endswith(" [turn_review_gate] second")
120
+ assert "[turn_review_gate] the review state was not saved: " in all_lines[2]
121
+
122
+
123
+ def test_should_refuse_a_second_lock_until_the_first_is_released(tmp_path: Path) -> None:
124
+ lock_path = tmp_path / "state.lock"
125
+ lock_path.write_text("x")
126
+ first_descriptor = os.open(lock_path, os.O_RDWR)
127
+ second_descriptor = os.open(lock_path, os.O_RDWR)
128
+ assert _is_lock_taken(first_descriptor) is True
129
+ assert _is_lock_taken(second_descriptor) is False
130
+ _release_and_close(first_descriptor, True)
131
+ assert _is_lock_taken(second_descriptor) is True
132
+ _release_and_close(second_descriptor, True)